Premium
Services
Premium

Top 13 frameworks IA agentiques open source

Nous avons testé 13 frameworks IA agentiques open source sur 5 tâches, en répétant chaque tâche 100 fois : 6 500 exécutions au total.

Cem Dilmegani
Cem Dilmegani
mis à jour le 5 nov. 2026
Chargement du graphique

smolagents n'apparaît pas dans le graphique. À 20.55 s et $4,52 par 1 000 exécutions en moyenne, il a enregistré de loin le temps et le coût les plus élevés, et son inclusion rendait illisibles les différences entre les autres frameworks. Nous expliquons pourquoi ci-dessous.

  • Les trois frameworks les moins chers sont Agno ($1,41), CAMEL ($1,45) et Google ADK ($1,48). Tous les trois exécutent les outils l'un après l'autre et ne rencontrent jamais les erreurs qui surviennent lorsque les outils ne s'attendent pas les uns les autres. LangChain ($1,49) et LangGraph ($1,50) exécutent les outils en même temps, mais coûtent à peu près la même chose, car ils écrivent certaines des définitions d'outils les plus courtes.
  • Microsoft Agent Framework est rapide (7.57 s) mais c'est le framework le plus cher du graphique ($1,88). Il exécute les outils en même temps, de sorte que 64 % de ses exécutions rencontrent une erreur et répètent des étapes, et il écrit de longues définitions d'outils.
  • L'écart de coût entre les 12 frameworks du graphique est faible : au maximum $0,47 par 1 000 exécutions.
  • 98 % à 99 % du temps est consacré à l'attente du model. Le code du framework lui-même n'a presque aucun effet sur le temps.

Nous avons d'abord exécuté ce benchmark en février 2026 avec quatre frameworks sur GPT-5.2 : LangChain, LangGraph, AutoGen et CrewAI. CrewAI prenait alors environ deux fois plus de temps que les trois autres (52.7 s en moyenne contre 27.5-29.6 s), et le framework le plus lourd utilisait 64 % de tokens de plus que le plus léger. Avec les versions actuelles, les quatre frameworks affichent en moyenne 8.20-8.39 s et l'écart de tokens est de 26 %.

Consultez notre méthodologie de benchmark pour plus de détails sur la façon dont nous avons exécuté les tests et analysé les résultats.

Parallel et exécution séquentielle des outils

Le model demande parfois plusieurs outils à la fois. Agno, CAMEL et Google ADK exécutent ces outils l'un après l'autre : le suivant démarre lorsque le précédent se termine. Les dix autres frameworks les démarrent tous en même temps par défaut. Lorsque les outils dépendent les uns des autres, les démarrer ensemble pose des problèmes, car le deuxième outil n'attend pas la fin du premier. Dans une application réelle, cela revient à un outil qui écrit un enregistrement de base de données pendant qu'un autre outil tente de lire le même enregistrement.

Le comportement séquentiel s'applique aux appels synchrones que nous avons utilisés. Les arun() d'Agno, les astep() de CAMEL et les outils asynchrones dans Google ADK exécutent les appels en même temps.

Nous avons constaté cela sur trois tâches :

  • Tâche 1 (charger les données, puis calculer) :
    • Le model a demandé les deux étapes ensemble. Dans les frameworks qui exécutent les outils en même temps, le calcul a démarré avant le chargement des données et a échoué, et le model l'a redemandé.
    • Cela représente un appel LLM supplémentaire. La tâche a pris 2.5-3 s et $0,48-0.64 par 1 000 exécutions dans Agno, Google ADK et CAMEL, contre 3.5-5.2 s et $0,74-1.05 dans les dix frameworks qui exécutent les outils en même temps.
  • Tâche 3 (appliquer deux filtres l'un après l'autre, puis calculer) :
    • Le model a demandé les trois étapes ensemble. Le calcul s'est exécuté avant la fin du deuxième filtre ; il a donc utilisé 1 483 clients au lieu de 592.
    • 10 des 13 exécutions échouées du benchmark proviennent de cela : 3 mauvaises réponses chacune dans LangChain et LangGraph, 1 dans Microsoft Agent Framework, et 3 exécutions CrewAI arrêtées par une erreur d'outil. Dans 6 des mauvaises réponses, le model a indiqué que le résultat n'était pas fiable au lieu de donner un nombre.
    • Le model a souvent remarqué l'incohérence et a répété des étapes. Microsoft Agent Framework a répété des étapes dans 59 % des exécutions et a été le framework le plus cher sur cette tâche après smolagents ($1,96 par 1 000 exécutions). Google ADK n'a jamais répété une étape et a été le plus rapide (8.05 s).
  • Tâche 5 (reconnaître les colonnes JSON et texte et traiter chacune avec le bon outil) :
    • Ici, les frameworks n'ont pas montré de différence. Dans l'ensemble des 1 300 exécutions, le model a inspecté les deux colonnes avant de les traiter et a choisi le bon outil.
    • La différence provenait à nouveau de l'exécution parallèle. Dans 85 % des exécutions de CrewAI et 69 % des exécutions de Microsoft Agent Framework, un outil s'est exécuté avant que ses données ne soient prêtes et des étapes ont été répétées.
    • Les réponses étaient correctes, mais CrewAI a été le framework le plus cher sur cette tâche après smolagents ($2,08 par 1 000 exécutions).

Nous avons utilisé le réglage par défaut de chaque framework. L'exécution simultanée des outils ne fait gagner du temps que lorsque les outils sont lents, par exemple des appels API qui prennent plusieurs secondes chacun. Nos outils se terminent en millisecondes ; ici, cela a entraîné les erreurs ci-dessus sans gain de vitesse. Si vos outils sont lents et indépendants, conservez la valeur par défaut. S'ils partagent des données, deux options s'offrent à vous :

  • Configurez le framework pour exécuter les outils un à la fois. SequentialToolExecutor dans Strands Agents et max_tool_threads=1 dans smolagents le font. Dans LlamaIndex, allow_parallel_tool_calls=False fait que le model demande un outil par réponse.
  • Écrivez des outils qui ne dépendent pas les uns des autres, par exemple en combinant « filter » et « calculate » en un seul outil.

Comment les instructions et l'historique parviennent au model

La plupart des frameworks envoient nos instructions telles quelles et envoient les étapes précédentes sous forme de messages d'outils standard. smolagents place nos instructions dans son propre gabarit de 6 780 caractères et renvoie les étapes précédentes sous forme de texte brut. Cette différence s'est manifestée à trois endroits :

  • La première requête est plus volumineuse : 4 428 tokens en moyenne dans smolagents, contre 1 917-2 822 dans les autres frameworks.
  • Le model a réfléchi davantage : le même model a produit 1 050 tokens de raisonnement par exécution en moyenne dans smolagents, contre 122-228 dans les autres frameworks. Les tokens de raisonnement sont facturés comme sortie et prennent du temps à générer. Dans notre benchmark d'orchestration agentique, le model a également réfléchi dans chaque exécution de smolagents.
  • Il y a davantage d'appels LLM : 6.52 par exécution en moyenne dans smolagents, contre 3.73-4.78 chez les autres. Cela provient principalement de son comportement différent sur la tâche 4 (ci-dessous).

L'écart se creuse sur les tâches comportant davantage d'étapes. La tâche 2 demandait à l'agent de calculer et de comparer deux groupes : le revenu perdu des clients avec et sans support technique. L'agent filtre et calcule chaque groupe séparément, de sorte que la tâche prend plusieurs étapes, et le gabarit et l'historique sont renvoyés à chaque étape.

  • smolagents a envoyé 31 200 tokens par exécution en moyenne sur cette tâche ; les autres frameworks ont envoyé entre 9 244 et 14 161.
  • smolagents a terminé la tâche en 24.34 s et pour $4,38 par 1 000 exécutions, soit 2 à 3 fois les autres frameworks. Deux exécutions de smolagents ont atteint la limite d'appels LLM sans réponse.
  • La plupart des autres frameworks ont terminé en 10-12 s. Google ADK a été le plus rapide à 7.58 s avec 3.39 appels LLM, et CAMEL a été le moins cher à $1.34.

Nous avons utilisé le gabarit par défaut de smolagents. Vous pouvez en passer un plus court avec le paramètre prompt_templates.

Comportement lorsqu'un outil échoue

La tâche 4 a testé ce que fait l'agent lorsqu'un outil est cassé. L'outil qui calcule le taux d'attrition par mode de paiement échoue lors des trois premiers appels (erreur de connexion, délai d'attente, limite de débit) et fonctionne au quatrième. Chaque message d'erreur dit « retry ». L'agent a deux options : réessayer l'outil, ou filtrer et calculer chaque mode de paiement séparément.

  • Dans douze frameworks, le model a réessayé l'outil après chaque erreur dans 97 % à 100 % des exécutions et a obtenu le résultat au quatrième essai. La tâche a pris 5.7-7.1 appels LLM et 7.9-10.4 s en moyenne.
  • Dans smolagents, le même model a abandonné l'outil après la deuxième ou la troisième erreur dans 96 % des exécutions et a calculé les quatre modes de paiement un par un. La tâche a pris 13.76 appels LLM et 41.07 s en moyenne, et a coûté $9,96 par 1 000 exécutions, contre $1,90-2.75 dans les autres frameworks.
  • Le message d'erreur était le même dans tous les frameworks. Ce qui diffère dans smolagents, c'est qu'il affiche l'erreur et les étapes précédentes sous forme de texte brut dans son propre gabarit. Nous pensons que la différence de comportement vient de là, mais nous ne l'avons pas testée séparément.

Le model influence également ce comportement : lors d'une vérification avec GPT-5.2 et une exécution par framework, 6 des 13 frameworks ont abandonné l'outil et ont choisi l'autre voie.

Nous avons montré les erreurs au model telles qu'elles étaient. Si les erreurs temporaires telles que les erreurs de connexion, les délais d'attente et les limites de débit sont réessayées à l'intérieur de l'outil, le model ne les voit jamais, et le comportement ne dépend plus du framework.

Comment les définitions d'outils sont écrites pour le model

Nous avons donné à chaque framework les mêmes fonctions Python avec les mêmes descriptions. Chaque framework les transforme, à sa manière, en définitions d'outils que le model lit. Cela a modifié la taille de la première requête : 1 917 tokens en moyenne dans Agno, 2 754 dans AutoGen. La majeure partie de la différence provient des définitions d'outils :

  • Agno, LangChain et LangGraph n'utilisent que la première phrase de la description de la fonction comme description de l'outil et placent les descriptions des paramètres sur les paramètres. Leurs définitions sont les plus courtes.
  • AutoGen, Microsoft Agent Framework, CrewAI et Google ADK envoient la description complète de la fonction, y compris les descriptions des paramètres et du retour.
  • LlamaIndex ajoute également la signature de la fonction au début.
  • Pydantic IA écrit la description dans des balises XML et ajoute la description du retour.

Deux frameworks ajoutent du texte aux instructions. CrewAI place les instructions dans un gabarit de rôle, d'historique et d'objectif, et Google ADK ajoute à la fin une ligne qui commence par « Vous êtes un agent ». Ces ajouts sont plus petits que les différences dans les définitions d'outils.

Les définitions d'outils sont renvoyées à chaque requête, de sorte que la différence ajoute un coût à chaque étape. Agno et AutoGen ont effectué presque le même nombre d'appels LLM par exécution (4.40 et 4.45), mais AutoGen a envoyé 37 % de tokens en plus au model en moyenne (14 932 contre 10 899).

Nous avons donné à chaque framework les mêmes fonctions et descriptions. Garder des descriptions de fonctions courtes, ou donner au framework une description d'outil distincte, réduit cette différence. Dans CrewAI, le texte ajouté aux instructions peut être modifié avec system_template et prompt_template.

Surcharge du code du framework

Le code du framework lui-même ajoute 0.04-0.14 s à une exécution en moyenne, soit moins de 2 % du temps total.

Le démarrage prend environ 1 s dans Google ADK, 0.6 s dans CAMEL et moins de 0.35 s dans les autres. Le temps de démarrage n'est pas inclus dans les résultats du benchmark.

Dans les systèmes qui redémarrent à chaque requête, comme les fonctions serverless, le temps de démarrage s'ajoute à chaque requête. Charger le framework une seule fois au démarrage de l'application et maintenir le processus en cours d'exécution élimine ce temps.

Frameworks agentiques vs agents de codage IA

Pour voir ce qu'un framework change par rapport à un agent de codage IA, nous avons également exécuté les cinq tâches 100 fois chacune dans OpenCode, un agent de codage IA open source. Nous l'avons utilisé comme agent général : même model, mêmes instructions et mêmes outils, avec ses propres outils de codage désactivés.

La différence était faible. OpenCode a répondu correctement aux 500 exécutions, son temps moyen (6.42 s) était conforme aux frameworks les plus rapides, et son coût ($1,78 par 1 000 exécutions) se situait dans la moitié supérieure des frameworks ($1,41 à $1,88). Les écarts provenaient des mêmes choix qui distinguent les frameworks :

  • Exécution des outils en même temps : OpenCode le fait également ; ainsi, lors de la tâche 1, le calcul s'est souvent exécuté avant le chargement des données et a nécessité un appel LLM supplémentaire.
  • Taille de la requête : Sa première requête a fait en moyenne 2 980 tokens, contre 1 917 à 2 822 pour les frameworks, car les outils lui parvenaient via MCP avec leurs descriptions complètes. Cela en a fait le plus cher sur les tâches 1 et 4.
Laissez notre équipe automatiser l'un de vos processus métier avec des agents IA, gratuitement.
Automatiser un processus

Support multi-agents

Ce benchmark utilisait un seul agent, mais les 13 frameworks prennent en charge l'exécution de plusieurs agents ensemble. Nous avons vérifié les informations de cette section et des trois suivantes dans le code source des versions testées. Les approches se répartissent en trois groupes :

  • Définis comme un flux : LangGraph (nœuds et arêtes), Microsoft Agent Framework (WorkflowBuilder), Google ADK (SequentialAgent, ParallelAgent, LoopAgent), Strands Agents (Graph et Swarm) et LlamaIndex (AgentWorkflow avec transferts entre agents).
  • Définis comme une équipe : CrewAI (une Crew séquentielle ou une avec un agent gestionnaire), AutoGen (RoundRobinGroupChat, SelectorGroupChat, Swarm), Agno (Team) et CAMEL (Workforce, RolePlaying).
  • Délégation du travail à un autre agent : OpenAI Agents SDK (transferts), smolagents (managed_agents), Pydantic IA et LangChain (donner un agent à un autre comme outil).

Nous avons mesuré comment ces frameworks gèrent un flux de cinq agents dans notre benchmark d'orchestration agentique.

Support de MCP

MCP (Model Context Protocol) offre aux agents un moyen standard de se connecter à des outils et sources de données externes. Les 13 frameworks peuvent tous utiliser des outils provenant de serveurs MCP.

Client MCP inclus dans le package propre du framework :

  • Agno
  • CAMEL
  • CrewAI
  • Google ADK
  • LangChain (dépendance supplémentaire : langchain[mcp])
  • Microsoft Agent Framework
  • OpenAI Agents SDK
  • Pydantic IA
  • smolagents (dépendance supplémentaire : smolagents[mcp])
  • Strands Agents

Package séparé nécessaire :

  • AutoGen : autogen-ext
  • LangGraph : aucun client MCP propre ; utilise le support MCP de LangChain ou langchain-mcp-adapters
  • LlamaIndex : llama-index-tools-mcp
Ne manquez pas nos benchmarks et analyses basées sur les données. Le bouton ouvre Google ; sélectionner AIMultiple confirme que vous souhaitez voir AIMultiple plus souvent dans les résultats de recherche Google.
GoogleAjouter comme source préférée

Approbation humaine (human-in-the-loop)

Certaines actions ne devraient pas se produire sans l'approbation d'une personne, comme l'envoi d'un e-mail ou la suppression d'un enregistrement. Les frameworks prennent en charge cela de trois manières.

Demande d'approbation avant l'exécution d'un outil :

  • Agno : requires_confirmation
  • Google ADK : require_confirmation
  • LangChain : HumanInTheLoopMiddleware
  • Microsoft Agent Framework : approval_mode
  • OpenAI Agents SDK : needs_approval
  • Pydantic IA : requires_approval

Mise en pause du flux et attente de la réponse d'une personne :

  • LangGraph : interrupt
  • LlamaIndex : événements qui attendent une saisie humaine
  • Strands Agents : interruptions

Connexion d'une personne en tant qu'agent ou outil :

  • AutoGen : UserProxyAgent
  • CAMEL : HumanToolkit
  • CrewAI : retour d'information via human_input à la fin d'une tâche
  • smolagents : UserInputTool

Mémoire

Chaque framework conserve l'historique au sein d'une tâche. La différence réside dans la mémoire persistante entre les tâches et les conversations.

Mémoire persistante intégrée :

  • Agno : MemoryManager
  • AutoGen : Memory
  • CAMEL : LongtermAgentMemory
  • CrewAI : le paramètre de mémoire sur une Crew
  • Google ADK : services de mémoire
  • LangChain : points de contrôle et magasins
  • LangGraph : points de contrôle et magasins
  • LlamaIndex : Memory
  • Microsoft Agent Framework : fournisseurs de contexte et d'historique
  • OpenAI Agents SDK : sessions
  • Strands Agents : gestionnaires de session

Pas de mémoire persistante intégrée (l'application stocke l'historique et le transmet à l'agent lors de l'exécution suivante) :

  • Pydantic IA
  • smolagents

Meilleurs frameworks agentiques

LangGraph

Il définit un agent comme un graphe de nœuds et d'arêtes, et le développeur gère explicitement l'état transmis entre les étapes. Il existe en versions Python et JavaScript, et les exécutions peuvent être tracées dans la plateforme LangSmith de LangChain.

La plus longue exécution de LangGraph sur la tâche 3 a effectué 25 appels d'outils avant d'atteindre la bonne réponse, et 16 d'entre eux étaient des répétitions. Hormis smolagents, la plus longue exécution de tout autre framework s'est arrêtée à 21 appels d'outils.

LangChain

Le framework généraliste de l'équipe LangChain pour les applications LLM. Depuis la version 1.0, les agents sont construits avec create_agent et s'exécutent sur le runtime LangGraph. Le middleware peut modifier la boucle de l'agent, et des middlewares prêts à l'emploi couvrent la synthèse des longs historiques, le masquage des données personnelles, les nouvelles tentatives après des erreurs et le repli vers un autre model.

Comme create_agent s'exécute sur LangGraph, il a envoyé au model les mêmes instructions et définitions d'outils que LangGraph, et les deux frameworks ont obtenu presque le même temps et le même coût.

CrewAI

Il définit les agents par rôle, objectif et historique, et les exécute avec des tâches en équipe (une crew). Au-dessus des crews, Flows connecte les étapes via des événements, et l'entreprise propose également une plateforme d'entreprise payante.

Il a été le framework le plus rapide sur la tâche 4 (7.85 s) et y a effectué le moins d'appels LLM (5.68 en moyenne).

AutoGen

Le framework de Microsoft Research dans lequel les agents travaillent en s'envoyant des messages. Il a une conception en couches (Core, AgentChat et Extensions), et AutoGen Studio, une interface sans code, est fourni comme package séparé. Microsoft recommande Microsoft Agent Framework pour les nouveaux projets.

Par défaut, AssistantAgent s'arrête après une série d'appels d'outils et renvoie le résultat de l'outil comme réponse (max_tool_iterations=1). Les tâches à plusieurs étapes nécessitent une valeur plus élevée, et nous l'avons augmentée.

Microsoft Agent Framework

Le framework de Microsoft qui réunit AutoGen et Semantic Kernel. Il prend en charge Python et .NET, et une version Go est en aperçu public depuis juillet 2026. Il offre le traçage OpenTelemetry et un middleware pour les appels d'agents, et une interface de développement appelée DevUI est fournie comme package séparé.

Il a été le framework le plus rapide sur la tâche 5 (6.50 s), même s'il répétait souvent des étapes.

OpenAI Agents SDK

Le framework d'OpenAI et le successeur de Swarm, construit autour des agents, des outils, des transferts et des garde-fous. Il possède des versions Python et TypeScript. Par défaut, il envoie une trace de chaque exécution au tableau de bord de traçage d'OpenAI (nous l'avons désactivé pour le benchmark). Il comprend des modules distincts pour les agents vocaux et en temps réel. Il utilise par défaut l'API Responses d'OpenAI ; les models d'autres fournisseurs nécessitent donc la classe de models Chat Completions.

Google ADK

Il fonctionne directement avec Gemini et avec d'autres models via LiteLLM, ce que nous avons utilisé. Il est livré avec une interface de développement locale (adk web) et un outil d'évaluation (adk eval), et les agents peuvent être déployés depuis la ligne de commande vers Vertex AI Agent Engine, Cloud Run ou GKE.

Il a été le framework le plus rapide en moyenne (6.79 s) et s'est classé parmi les trois plus rapides sur les cinq tâches. Il a également effectué le moins d'appels LLM par exécution (3.73 en moyenne).

Agno

Il est livré avec un vaste catalogue de boîtes à outils prêtes à l'emploi et propose AgentOS, un runtime pour servir et gérer des agents sous forme d'API sur votre propre infrastructure.

Dans Agno, le model n'a presque jamais écrit de commentaire à côté de ses appels d'outils : il l'a fait dans 0,2 % des tours d'appel d'outils, contre 3 % à 26 % dans les autres frameworks. Ces commentaires sont facturés comme tokens de sortie.

Pydantic IA

Il valide les arguments des outils et la sortie de l'agent avec des models Pydantic et demande au model de corriger un argument invalide. Un mécanisme typé deps transmet des dépendances telles que les connexions de base de données aux outils. Les exécutions peuvent être tracées avec Pydantic Logfire et rendues durables face aux interruptions avec Temporal, DBOS ou Prefect.

smolagents

Son approche la plus connue est CodeAgent, qui appelle des outils en écrivant du code Python au lieu de JSON et exécute ce code localement ou dans des environnements isolés tels qu'E2B, Docker ou Modal. Les outils et les agents peuvent être partagés sur le Hub Hugging Face. Nous avons testé ToolCallingAgent, qui effectue des appels d'outils JSON ; CodeAgent ne fait donc pas partie de ces résultats.

Comme il renvoie la réponse via un outil final_answer distinct, 99,6 % de ses sorties étaient du JSON brut. Dans les autres frameworks, 17 % à 41 % des réponses arrivaient enveloppées dans un bloc de code Markdown.

LlamaIndex

Il comprend des composants pour charger, découper, indexer et interroger des documents, et un moteur de requêtes peut être fourni à un agent comme outil avec QueryEngineTool. Pour les agents, il propose FunctionAgent et AgentWorkflow, qui connecte plusieurs agents.

Il a été le framework le plus cher du graphique lors des tâches 2 et 4, les tâches comportant le plus d'étapes ($1,91 et $2,75 par 1 000 exécutions). Ses longues définitions d'outils sont renvoyées à chaque étape, de sorte que l'écart augmente avec le nombre d'étapes.

Strands Agents

Il laisse la planification et le choix des outils au model et garde la boucle de l'agent simple. Si aucun model n'est défini, il utilise un model Claude sur Amazon Bedrock, et il possède des fournisseurs intégrés pour Anthropic, OpenAI, Gemini, Mistral, Ollama et LiteLLM. Il trace les exécutions avec OpenTelemetry.

Dans l'ensemble des 100 exécutions de la tâche 1, le model a d'abord appelé l'outil de calcul sans charger les données, a reçu une erreur, puis a chargé les données dans une étape distincte. En raison de cette étape supplémentaire, Strands a été le framework le plus lent du graphique lors de la tâche 1 (5.18 s).

CAMEL

Un framework agentique issu de la communauté CAMEL-IA, né de la recherche multi-agents ; OWL est construit dessus. Outre des boîtes à outils prêtes à l'emploi, il comprend des modules de génération de données synthétiques et des benchmarks ; il vise donc également un usage de recherche.

Il a été le framework le plus lent du graphique lors de la tâche 3 (14.43 s). Sur cette tâche, le model a effectué 4.73 appels LLM et produit 598 tokens de raisonnement par exécution en moyenne dans CAMEL, contre 3.22 et 207 dans Google ADK.

Méthodologie du benchmark

Toutes les tâches utilisent les mêmes données : 5 000 clients échantillonnés à partir du dataset de churn des clients Telco d'IBM. Nous avons ajouté une colonne JSON (données d'appareil) et une colonne de texte (notes de support) au dataset. L'agent charge d'abord les données, puis filtre et calcule avec les outils, et renvoie la réponse dans un format JSON fixe.

  • Tâche 1, calcul de base : Taux d'attrition par type de contrat. Mesure la surcharge que le framework ajoute au travail le plus simple.
  • Tâche 2, comparaison de deux groupes : Revenu mensuel perdu des clients avec et sans support technique. Mesure si deux résultats distincts restent corrects à travers les étapes.
  • Tâche 3, seuils : Taux d'attrition des clients ayant moins de 1 an d'ancienneté qui paient plus de $70 par mois. Mesure la transformation des expressions en bons nombres et l'application de deux filtres l'un après l'autre.
  • Tâche 4, outil cassé : Taux d'attrition par mode de paiement. L'outil requis échoue trois fois et fonctionne au quatrième essai. Mesure ce que fait l'agent lorsqu'un outil échoue.
  • Tâche 5, données mixtes : Nombre d'appareils (à partir de la colonne JSON) et mots-clés de réclamation (à partir de la colonne de texte) pour les clients désabonnés qui paient plus de $100 par mois. Mesure si l'agent reconnaît les types de colonnes et choisit le bon outil.

Configuration

  • Model : Claude Haiku 5.5 via OpenRouter avec le fournisseur Anthropic, effort de raisonnement moyen.
  • 100 exécutions par framework et par tâche, 6 500 exécutions au total. Date : 27 octobre 2026.
  • Limites par exécution : 15 appels LLM sur les tâches 1 à 3, 25 sur les tâches 4 et 5, et 420 s.
  • Chaque framework a reçu les mêmes instructions, le même texte de tâche et les mêmes outils. Nous avons configuré chaque framework de manière standard et n'avons pas modifié son comportement par défaut. Nous avons seulement augmenté les limites d'étapes suffisamment pour que les tâches se terminent, et modifié un réglage dans CrewAI, smolagents et AutoGen afin qu'ils puissent fonctionner avec Claude.
  • Toutes les requêtes sont passées par le même proxy de journalisation. Le proxy a appliqué le même model et le même réglage de raisonnement à chaque requête et a supprimé les réglages d'échantillonnage que certains frameworks ajoutent, comme la température de 0.1 envoyée par LlamaIndex.
  • Chaque exécution s'est déroulée dans son propre processus après un passage d'échauffement non mesuré. Les exécutions se sont déroulées trois à la fois dans un ordre aléatoire.
  • Nous avons comparé chaque réponse avec la bonne réponse calculée par les mêmes outils.
  • Les résultats de notre échantillon de 5 000 clients diffèrent des résultats publics bien connus du dataset, de sorte que le model ne peut pas répondre de mémoire.
  • Versions testées : LangGraph 1.2.17, LangChain 1.4.7, CrewAI 1.15.30, AutoGen AgentChat 0.7.5, Microsoft Agent Framework 1.23.0, OpenAI Agents SDK 0.24.0, Google ADK 2.13.0, Agno 3.1.10, Pydantic IA 2.61.0, smolagents 1.26.0, LlamaIndex 0.14.25, Strands Agents 1.62.0, CAMEL 0.2.90.

Citez ce benchmark

Choisissez le format qui correspond à votre lieu de publication. Coller la version avec lien dans votre CMS préserve le lien retour.

Cem Dilmegani and Nazlı Şipi (2026) - "Top 13 frameworks IA agentiques open source". Publié en ligne sur AIMultiple.com. Consulté le 5 novembre 2026, à : https://aimultiple.com/agentic-frameworks [Ressource en ligne]

Dilmegani, C., & Şipi, N. (2026, 5 novembre). Top 13 frameworks IA agentiques open source. AIMultiple. https://aimultiple.com/agentic-frameworks

@misc{dilmegani2026,
  author = {Dilmegani, Cem and Şipi, Nazlı},
  title  = {{Top 13 frameworks IA agentiques open source}},
  year   = {2026},
  month  = nov,
  howpublished    = {\url{https://aimultiple.com/agentic-frameworks}},
  note   = {AIMultiple. Consulté le 5 novembre 2026}
}
Télécharger toutes les données

Résultats et horodatages de 7.1 mille points de données. Téléchargez les données de synthèse présentées dans les graphiques et les tableaux de cet article sous forme de fichier ZIP contenant 2 fichiers CSV et un README.

Dernière mise à jour : 10 novembre 2026
Télécharger

Vous voulez les données détaillées derrière ? Rejoindre Premium

Journal des modifications

10 mises à jour
  1. Remplacement des résultats et de l'analyse du benchmark dans la section "Agentic AI frameworks benchmark".

  2. Suppression d'un changement de méthodologie décrivant l'intégration des tâches dans les architectures basées sur les agents.

Cem Dilmegani
Cem Dilmegani
Analyste principal
Cem est analyste principal chez AIMultiple depuis 2017.

Le travail de Cem chez AIMultiple a été cité par des publications mondiales de premier plan, notamment Business Insider, Forbes, Morning Brew et Washington Post, par des entreprises mondiales comme Deloitte et HPE, par des ONG comme World Economic Forum et par des organisations supranationales comme European Commission. [1], [2], [3], [4], [5]

Tout au long de sa carrière, Cem a été consultant en technologies, acheteur de technologies et entrepreneur technologique. Il a conseillé des entreprises sur leurs décisions technologiques chez McKinsey & Company et Altman Solon pendant plus de dix ans. Il a également publié un rapport McKinsey sur la digitalisation.

Il a dirigé la stratégie technologique et les achats d'un opérateur télécom, sous la responsabilité du PDG. Il a également dirigé la croissance commerciale de l'entreprise de technologie profonde Hypatos, qui a atteint un revenu récurrent annuel à 7 chiffres et une valorisation à 9 chiffres, passant de 0 à ce résultat en deux ans. Le travail de Cem chez Hypatos a été couvert par des publications technologiques de premier plan comme TechCrunch et Business Insider.

Cem intervient régulièrement lors de conférences technologiques internationales. Il est diplômé de Bogazici University en tant qu'ingénieur informatique et titulaire d'un MBA de la Columbia Business School.
Voir le profil complet
Recherche effectuée par
Nazlı Şipi
Nazlı Şipi
Chercheuse en IA
Nazlı est analyste de données chez AIMultiple. Elle a une expérience préalable en analyse de données dans divers secteurs, où elle a travaillé à transformer des datasets complexes en informations exploitables.
Voir le profil complet

Commentaires 1

Partagez vos idées

Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires. Les commentaires sont laissés dans leur langue d'origine.

0/450
Chaitanya
Chaitanya
Dec 19, 2025 at 01:47

Thank you for this informative and detailed article! It helped me get a reading on these frameworks.