Top 13 frameworks d'IA agentique open source

smolagents ne figure pas dans le graphique. À 20.55 s et $4,52 par 1 000 exécutions en moyenne, il avait de loin le temps et le coût les plus élevés, et l'inclure rendait les différences entre les autres frameworks illisibles. 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 provenant d'outils qui n'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, si bien 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.
• De 98 % à 99 % du temps est consacré à l'attente du modèle. Le code propre du framework n'a presque aucun effet sur le temps.

Nous avons initialement 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 font 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 manière dont nous avons exécuté les tests et analysé les résultats.

Exécution parallèle et séquentielle des outils

Le modèle 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 à ce qu'un outil écrive 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 de Google ADK exécutent les appels en même temps.

Nous avons observé cela sur trois tâches :

• Tâche 1 (charger les données, puis calculer) :
  • Le modèle a demandé les deux étapes ensemble. Dans les frameworks qui exécutent les outils en même temps, le calcul a commencé avant le chargement des données et a échoué, et le modèle 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 modèle a demandé les trois étapes ensemble. Le calcul a été exécuté avant la fin du deuxième filtre, si bien qu'il a utilisé 1 483 clients au lieu de 592.
  • 10 des 13 exécutions échouées du benchmark proviennent de cela : 3 réponses fausses 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 modèle a indiqué que le résultat n'était pas fiable au lieu de donner un nombre.
  • Le modèle 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 différé. Dans toutes les 1 300 exécutions, le modèle 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 % de celles de Microsoft Agent Framework, un outil s'est exécuté avant que ses données 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 paramètre par défaut de chaque framework. Exécuter les outils en même temps ne fait gagner du temps que lorsque les outils sont lents, comme les appels API qui prennent plusieurs secondes chacun. Nos outils se terminent en millisecondes, donc cela a provoqué les erreurs ci-dessus sans gain de vitesse. Si vos outils sont lents et indépendants, conservez le paramètre par défaut. S'ils partagent des données, il existe deux options :

• 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 en sorte que le modèle demande un outil par réponse.
• Écrivez des outils qui ne dépendent pas les uns des autres, par exemple en combinant « filtrer » et « calculer » en un seul outil.

Comment les instructions et l'historique parviennent au modèle

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 modèle 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 modèle a réfléchi davantage : le même modèle 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 modèle a également réfléchi à 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 dans les autres. Cela provient en grande partie 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 chez les clients avec et sans support technique. L'agent filtre et calcule chaque groupe séparément, si bien que la tâche prend plusieurs étapes, et le modèle 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 en ont envoyé entre 9 244 et 14 161.
• smolagents a terminé la tâche en 24.34 s et à $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 avec 7.58 s et 3.39 appels LLM, et CAMEL a été le moins cher à $1.34.

Nous avons utilisé le modèle 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 défaillant. L'outil qui calcule le taux d'attrition par moyen 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 indique « réessayer ». L'agent a deux options : réessayer l'outil, ou filtrer et calculer chaque moyen de paiement séparément.

• Dans douze frameworks, le modèle 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 nécessité 5.7-7.1 appels LLM et 7.9-10.4 s en moyenne.
• Dans smolagents, le même modèle a abandonné l'outil après la deuxième ou la troisième erreur dans 96 % des exécutions et a calculé les quatre moyens de paiement un par un. La tâche a nécessité 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 modèle. Nous pensons que la différence de comportement vient de cela, mais nous ne l'avons pas testé séparément.

Le modèle affecte également ce comportement : lors d'un contrôle avec GPT-5.2 et une exécution par framework, 6 des 13 frameworks ont abandonné l'outil et ont emprunté l'autre voie.

Nous avons montré les erreurs au modèle 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 modèle ne les voit jamais et le comportement ne dépend plus du framework.

Comment les définitions d'outils sont écrites pour le modèle

Nous avons donné à chaque framework les mêmes fonctions Python avec les mêmes descriptions. Chaque framework les transforme en définitions d'outils que le modèle lit, à sa manière. 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 de la valeur de 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 de la valeur de retour.

Deux frameworks ajoutent du texte aux instructions. CrewAI place les instructions dans un modèle 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, si bien 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 de plus au modèle en moyenne (14 932 contre 10 899).

Nous avons donné à chaque framework les mêmes fonctions et descriptions. Garder les 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 propre du framework 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 le supprime.

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 modèle, 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 simultanée des outils : OpenCode le fait aussi, si bien que dans 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 comptait 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 l'a rendu le plus cher sur les tâches 1 et 4.

Prise en charge 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 par rapport au code source des versions que nous avons 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).
• Transmettre le travail à un autre agent : OpenAI Agents SDK (handoffs), smolagents (managed_agents), Pydantic IA et LangChain (donner un agent à un autre comme outil).

Nous avons mesuré la manière dont ces frameworks gèrent un flux à cinq agents dans notre benchmark d'orchestration agentique.

Prise en charge 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 utiliser des outils provenant de serveurs MCP.

Client MCP inclus dans le propre package 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 : pas de client MCP propre ; utilise la prise en charge de LangChain pour MCP 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.

Ajouter comme source préférée

Approbation humaine (humain dans la boucle)

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.

Demander l'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

Mettre le flux en pause et attendre la réponse d'une personne :

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

Connecter 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 stockages
• LangGraph : points de contrôle et stockages
• LlamaIndex : Memory
• Microsoft Agent Framework : fournisseurs de contexte et d'historique
• OpenAI Agents SDK : sessions
• Strands Agents : gestionnaires de session

Aucune 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 des versions Python et JavaScript, et les exécutions peuvent être tracées dans la plateforme LangSmith de LangChain.

L'exécution LangGraph la plus longue 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, l'exécution la plus longue dans 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 l'environnement d'exécution LangGraph. Les middlewares peuvent 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 erreur et le recours à un autre modèle.

Comme create_agent s'exécute sur LangGraph, il a envoyé au modèle les mêmes instructions et définitions d'outils que LangGraph, et les deux frameworks ont abouti à un temps et un coût presque identiques.

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, les Flows relient les étapes par le biais d'é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 présente une conception en couches (Core, AgentChat et Extensions), et AutoGen Studio, une interface sans code, est fourni en tant que 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. Il offre le traçage OpenTelemetry et des middlewares pour les appels d'agents, et une interface de développement appelée DevUI est fournie en tant que package séparé.

Il a été le framework le plus rapide sur la tâche 5 (6.50 s), même s'il a souvent répété 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 existe 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 l'API Responses d'OpenAI par défaut, si bien que les modèles d'autres fournisseurs nécessitent la classe de modèle Chat Completions.

Google ADK

Il fonctionne directement avec Gemini et avec d'autres modèles 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 environnement d'exécution pour exposer et gérer des agents en tant qu'API sur votre propre infrastructure.

Dans Agno, le modèle n'a presque jamais écrit de commentaire à côté de ses appels d'outils : il l'a fait dans 0,2 % des tours d'appels 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 des agents avec des modèles Pydantic et demande au modèle de corriger un argument invalide. Un mécanisme deps typé 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 contre les interruptions avec Temporal, DBOS ou Prefect.

smolagents

Son approche la plus connue est CodeAgent, qui appelle les outils en écrivant du code Python au lieu de JSON et exécute ce code localement ou dans des environnements isolés comme E2B, Docker ou Modal. Les outils et les agents peuvent être partagés sur le Hugging Face Hub. 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ête peut être fourni à un agent comme outil avec QueryEngineTool. Pour les agents, il propose FunctionAgent et AgentWorkflow, qui connecte plusieurs agents. Il existe des versions Python et TypeScript.

Il a été le framework le plus cher du graphique sur les tâches 2 et 4, les tâches avec 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, si bien que l'écart augmente avec le nombre d'étapes.

Strands Agents

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

Dans les 100 exécutions de la tâche 1, le modèle 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 sur 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 pour la génération de données synthétiques et des benchmarks, si bien qu'il vise également un usage en recherche.

Il a été le framework le plus lent du graphique sur la tâche 3 (14.43 s). Sur cette tâche, le modèle 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 jeu de données de churn client IBM Telco. Nous avons ajouté une colonne JSON (données d'appareil) et une colonne de texte (notes de support) au jeu de données. L'agent charge d'abord les données, puis filtre et calcule avec des 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 chez les clients avec et sans support technique. Mesure si deux résultats distincts restent corrects d'une étape à l'autre.
• Tâche 3, seuils : taux d'attrition des clients ayant moins d'un an d'ancienneté qui paient plus de $70 par mois. Mesure la transformation des phrases en bons nombres et l'application de deux filtres l'un après l'autre.
• Tâche 4, outil défaillant : taux d'attrition par moyen 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 : nombres d'appareils (à partir de la colonne JSON) et mots-clés de réclamation (à partir de la colonne de texte) pour les clients résiliés qui paient plus de $100 par mois. Mesure si l'agent reconnaît les types de colonnes et choisit le bon outil.

Configuration

• Modèle : 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 pour les tâches 1 à 3, 25 pour 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 paramètre chacun 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 modèle et le même réglage de raisonnement à chaque requête et a supprimé les paramètres d'échantillonnage que certains frameworks ajoutent, comme la température de 0.1 qu'envoie LlamaIndex.
• Chaque exécution s'est déroulée dans son propre processus après une passe d'échauffement non mesurée. Les exécutions se déroulaient trois à la fois dans un ordre mélangé.
• Nous avons comparé chaque réponse à la réponse correcte 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 jeu de données, de sorte que le modèle 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.

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

Journal des modifications

10 mises à jour

Toutes10Général9Méthodologie1

20262025

1. 2 mar

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

2. 22 jan

   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

Analyste principal

Suivre

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

Chercheuse en IA

Suivre

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.

Nom

Adresse email

Commentaire

0/450

Publier un commentaire

Chaitanya

Dec 19, 2025 at 01:47

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

Répondre