10 cadres d’agents IA à connaître en 2026 : LangGraph, CrewAI et d’autres.
Dix cadres d’agents pour 2026, dont LangGraph, CrewAI et AutoGen, classés selon la manière dont ils coordonnent les agents, avec leurs avantages et inconvénients ainsi qu’un guide pour en choisir un.
Sources: 10 AI Agent Frameworks You Should Know in 2026: LangGraph, CrewAI, AutoGen & More 🤖
Les frameworks d’agents se sont multipliés rapidement. OpenAI a publié un Agents SDK, Google a mis en place ADK, Hugging Face a sorti Smolagents et l’équipe de Pydantic a développé une couche d’agents typée, tous parallèlement aux noms plus anciens. Choisir parmi eux devient plus simple une fois qu’on comprend que chacun repose sur une seule idée : la manière dont les agents coordonnent leurs actions.
Le tableau : huit modèles de coordination
- Basé sur les graphes : les agents sont des nœuds, les transitions sont des arêtes. LangGraph utilise cette approche.
- Basé sur les rôles : les agents agissent comme des titres de poste au sein d’une équipe. CrewAI.
- Basé sur la conversation : les agents participent à une discussion en groupe et se relaient. AutoGen et AG2.
- Hiérarchique : un agent parent assigne des tâches aux agents enfants, à l’image d’un organigramme. Google ADK.
- Basé sur l’exécution de code : l’action de l’agent consiste à écrire et exécuter du Python. Smolagents.
- Basé sur le transfert de contrôle : un agent transfère délibérément le contrôle à un autre. OpenAI Agents SDK.
Semantic Kernel et le Claude Agent SDK ne s’intègrent pas parfaitement dans cette liste et bénéficient de sections distinctes ci-dessous. Compte tenu de cette liste, le choix du framework se résume à une question : quel modèle de coordination correspond à votre problème ?
1. LangGraph, le choix par défaut en production
Début 2026, LangGraph a dépassé CrewAI en nombre d’étoiles sur GitHub grâce à une adoption accrue par les entreprises. Sa structure graphique répond aux besoins en production tels que les traces d’audit et les points de restauration.
Vous définez explicitement un graphe orienté. Les agents, les outils et les points de contrôle constituent les nœuds, tandis que les arêtes conditionnelles déterminent ce qui s’exécute ensuite. Le framework conserve l’état entre les étapes et utilise une logique de réducteur pour fusionner les mises à jour arrivant simultanément. Cela en fait un outil idéal lorsque vous avez besoin d’un contrôle précis sur l’ordre d’exécution, la prise de décisions conditionnelles et la récupération en cas d’erreurs. Il a atteint la version 1.0 à la fin de 2025, est devenu l’environnement d’exécution par défaut pour les agents de LangChain et prend en charge à la fois Python et JavaScript.
La persistance est intégrée via des points de contrôle permettant un « voyage dans le temps » : n’importe quel état antérieur peut être rejoué, ce qui est utile pour le débogage et le respect des normes. En l’associant à LangSmith, vous obtenez l’un des meilleurs systèmes de suivi de ce groupe.
Le prix à payer est la quantité de code générique nécessaire. Un agent ReAct de base peut compter environ 40 lignes dans Smolagents et près de 120 lignes dans LangGraph. Vous échangez de la longueur du code contre un meilleur contrôle.
Ce cadre convient aux systèmes de production qui nécessitent un état explicite et une traçabilité, aux workflows comportant des boucles, des branches et un routage conditionnel, aux agents ayant besoin d’points de contrôle pour une approbation humaine, ainsi qu’aux équipes déjà investies dans LangChain.
Un exemple minimal définit un état typé, une fonction déterminant s’il faut continuer après dix itérations, un nœud agent et un nœud outils, ainsi que des liens qui créent des boucles entre eux jusqu’à atteindre la limite fixée.
from langgraph.graph import StateGraph, END
from typing import TypedDict
class AgentState(TypedDict):
messages: list
iteration_count: int
def should_continue(state: AgentState) -> str:
if state["iteration_count"] >= 10:
return "end"
return "continue"
graph = StateGraph(AgentState)
graph.add_node("agent", run_agent)
graph.add_node("tools", run_tools)
graph.add_conditional_edges("agent", should_continue, {"continue": "tools", "end": END})
graph.add_edge("tools", "agent")
2. CrewAI, une mise en route rapide
Grâce à son concept de conception basé sur les rôles, CrewAI permet à une petite équipe de mettre en place un système multi-agents fonctionnel en environ une demi-heure.
Vous décrivez chaque agent en fonction de son rôle, de son histoire et de ses objectifs, puis vous les regroupez en une équipe avec des tâches à accomplir, laissant le framework gérer la coordination. Le code ressemble presque à de l’anglais simple : vous déclarez un chercheur, un rédacteur et un correcteur, vous leur assignez des tâches, et CrewAI décide qui fait quoi et quand. Aucune théorie des graphes n’est nécessaire.
Les coûts se manifestent en deux domaines. Les comparaisons publiées pour 2026 indiquent des frais supplémentaires modérés en tokens, d’environ 18 % par rapport à une version LangGraph équivalente pour une équipe de trois agents chargée du tri des tickets, bien que ces chiffres dépendent du volume de travail. De plus, lorsque le flux de travail impliquant cinq agents échoue, l’abstraction peut devenir opaque et difficile à déboguer. L’état est simplement la sortie d’une tâche transmise d’un agent à l’autre.
Ce outil convient aux prototypes rapides et aux MVP, à l’automatisation des processus métier correspondant aux rôles des équipes humaines, aux équipes ne disposant pas d’ingénieurs en IA dédiés, ainsi qu’aux petites organisations qui font leurs premiers pas dans l’automatisation par des agents. Une histoire courante : les équipes créent des prototypes avec CrewAI, puis passent à LangGraph lorsqu’elles ont besoin d’un traitement adéquat des états et d’un routage conditionnel.
from crewai import Agent, Task, Crew
researcher = Agent(role="Research Analyst", goal="Find key facts", backstory="Expert researcher")
writer = Agent(role="Content Writer", goal="Write clear summaries", backstory="Skilled communicator")
research_task = Task(description="Research AI agent frameworks", agent=researcher)
writing_task = Task(description="Write a summary of findings", agent=writer)
crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])
result = crew.kickoff()
3. AutoGen et AG2, des agents en conversation
Au sein d’AutoGen, les flux de travail prennent la forme de conversations. Les agents rejoignent un chat en groupe, échangent par plusieurs tours, et un sélecteur choisit le prochain orateur. Alors que LangGraph crée un graphe de nœuds et d’arêtes, AutoGen organise une discussion.
La première version, 0.2, a popularisé les agents qui débattent et affinent leurs réponses grâce au dialogue. La réécriture 0.4, poursuivie sous le nom d’AG2, a adopté un noyau basé sur des événements, avec une exécution asynchrone en priorité et des stratégies d’orchestration interchangeables.
Le problème réside dans le coût. Chaque tour implique une appel complet au LLM qui transmet toute la conversation jusqu’alors ; donc quatre agents débattant pendant cinq tours signifient au moins vingt appels. Cela représente une charge importante pour des tâches en temps réel à forte volume, comme le service client. Cela s’avère utile pour des travaux hors ligne où la qualité prime sur la vitesse. L’état est conservé dans l’historique de la conversation, par défaut en mémoire.
Les utilisations pertinentes incluent la recherche et l’analyse où des agents débattent et affinent leurs idées, la génération de code où un agent critique un autre, tout ce qui bénéficie d’une réflexion approfondie, ainsi que les équipes ayant également besoin de support .NET, puisque AutoGen dispose d’interfaces interlangages. AutoGen Studio ajoute une interface sans code pour tester des configurations multi-agents, utile pour ceux qui ne sont pas ingénieurs.
4. Google ADK, l’arbre de délégation
Lancé en avril 2025, ADK organise les agents en un arbre. Un agent racine reçoit une tâche et la transmet sous-tâches à ses enfants, qui peuvent eux-mêmes avoir des enfants. Pensez à un organigramme, et non à une discussion en groupe.
Il est étroitement lié à Vertex AI, Gemini et Google Cloud, bien que d’autres modèles fonctionnent également. Sa caractéristique principale est son support natif pour A2A, le protocole Agent-to-Agent, permettant ainsi à un agent ADK de trouver et d’appeler un agent écrit en LangGraph ou CrewAI via l’interface de tâches standard d’A2A. L’état de la session est géré grâce à des backends interchangeables.
C’est le choix naturel pour les équipes profondément intégrées à Google Cloud, pour les systèmes qui doivent coordonner des agents entre différents frameworks, pour les entreprises qui comptent sur les certifications de conformité de Google, ainsi que pour les workflows disposant d’une chaîne de délégation claire.
5. OpenAI Agents SDK, petit et rapide
Lors de son arrivée en mars 2025, l’Agents SDK a remplacé le projet expérimental Swarm par une solution prête pour la production. Son idée centrale repose sur le transfert de responsabilités : un agent termine sa tâche et transmet explicitement le contrôle, ainsi que le contexte de la conversation, à un autre agent. Chaque agent est défini par des instructions, un modèle, des outils et la liste des agents auxquels il peut transférer les tâches. Le résultat est prévisible et facile à comprendre.
Les limites existent bel et bien. Il est lié aux modèles d’OpenAI, sans possibilité d’utiliser ses propres modèles. Il n’y a pas de mécanisme intégré pour enregistrer l’état des tâches longues, le contrôle de la communication entre agents est limité et la gestion des erreurs est sommaire. L’état est constitué de variables contextuelles qui sont, par défaut, éphémères. La courbe d’apprentissage est douce, grâce à une API simple et bien définie.
Choisissez-le si vous utilisez déjà des modèles OpenAI, que votre flux est une simple série de transferts sans besoins importants en état, ou si vous souhaitez créer un prototype avant de vous engager dans quelque chose de plus complexe.
from agents import Agent, handoff
support_agent = Agent(name="Support", instructions="Handle general questions")
billing_agent = Agent(name="Billing", instructions="Handle payment issues")
support_agent.tools = [handoff(billing_agent, "Transfer billing questions")]
6. Smolagents : le code comme action
La bibliothèque de Hugging Face adopte une approche simplifiée. Plutôt que des prompts complexes et une orchestration poussée, elle exécute une boucle minimale dans laquelle l’agent écrit et met en œuvre du code pour atteindre son objectif.
La plupart des agents choisissent un outil et ses arguments sous forme JSON. Le CodeAgent de Smolagents écrit directement en Python, ce qui permet à toute bibliothèque d’être utilisée comme outil dès que l’import est autorisé. Cela facilite également le support des modèles locaux, développés par Hugging Face pour son propre écosystème. Pour des raisons de sécurité, l’exécution peut être isolée au sein d’un environnement sandbox grâce à Blaxel, E2B, Modal, Docker ou un sandbox Pyodide-plus-Deno WebAssembly.
La faiblesse réside dans sa dépendance à la qualité des modèles. Les modèles de type GPT-4o ou Claude Sonnet génèrent du code fiable, tandis que les modèles comptant environ 7 milliards de paramètres introduisent systématiquement des erreurs. Cette dépendance est plus forte que dans d’autres frameworks.
Cela convient aux agents de recherche et d’exécution de code, aux pipelines d’analyse de données qui bénéficient du code généré, aux utilisateurs déjà présents sur Hugging Face Hub ainsi qu’aux prototypes utilisant des modèles open source locaux.
from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool
model = InferenceClientModel()
agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=model)
result = agent.run("Find the top 5 AI frameworks by GitHub stars and plot a bar chart")
# The agent writes and executes Python to search, process data, and generate the chart
7. PydanticAI, contrats typés
Pydantic AI intègre la sécurité des types et l’expérience de développement de Pydantic dans le fonctionnement des agents, avec une sensation proche de FastAPI. Vous déclarez les entrées, les signatures des outils et les sorties en tant que types Python, et le framework les valide tout en ajoutant des outils d’instrumentation OpenTelemetry.
Son mécanisme de boucle utilise l’injection de dépendances à chaque étape : vous indiquez ce qui entre et ce qui sort, et Pydantic assure le respect du contrat. Si votre pipeline a besoin de formats de sortie fiables et validés, cela offre des garanties au niveau de Pydantic quant à ce que le modèle renvoie. Toute personne ayant utilisé Pydantic ou FastAPI le trouvera familier.
Ce système convient aux applications ayant des sorties validées selon un schéma, comme dans les domaines financiers, de la santé et du droit, aux équipes soucieuses de sécurité des types et de facilité de test, aux développeurs Python qui souhaitent des contrats explicites pour chaque interaction, et, plus particulièrement, à l’utilisation en tant que couche de sortie structurée au sein d’un orchestrateur plus large tel que LangGraph.
8. Microsoft Semantic Kernel, la solution d’entreprise
Semantic Kernel est basé sur des plugins, avec des agents qui agissent comme planificateurs orchestrés ; il a été conçu pour ressembler à un logiciel d’entreprise ordinaire plutôt qu’à un prototype de recherche. Il est plus léger que certains concurrents, mais s’intègre fortement à .NET.
C’est le choix idéal pour les équipes utilisant Azure, qui développent en C# ou Java et déploient au sein de l’écosystème conforme à la réglementation de Microsoft. Il est principalement conçu pour Azure OpenAI, mais prend également en charge d’autres fournisseurs. Il convient aux équipes enterprise travaillant avec .NET, C# et Java, aux déploiements axés sur Azure, aux organisations déjà utilisant Copilot Studio, ainsi qu’aux workflows nécessitant une connexion à Microsoft 365 et Office.
9. Claude Agent SDK, la fiabilité en premier
Le SDK d’Anthropic fonctionne comme une chaîne d’utilisation d’outils avec des sous-agents. Claude décide quels outils utiliser, les relie entre eux et peut lancer des sous-agents isolés pour un travail en parallèle grâce à l’infrastructure d’agent de Claude Code.
Il met l’accent sur une gestion fiable des erreurs et un comportement sécurisé plutôt que sur la vitesse brute, s’intègre nativement à MCP pour les connexions aux outils et peut utiliser la capacité de raisonnement avancé de Claude pour des tâches complexes. Il ne fonctionne que sur les modèles Claude. L’état externe passe par des serveurs MCP, tandis que l’état de la session reste dans le contexte de Claude.
Envisagez-le si vous êtes déjà sur la plateforme d’Anthropic, si les garanties de sécurité et le respect des politiques de contenu sont importants, pour des travaux nécessitant un contexte long bénéficiant d’une fenêtre de 200 000 tokens, ainsi que pour des projets intégrés à l’écosystème d’outils MCP plus large.
10. OpenAgents, un réseau basé sur des protocoles
OpenAgents crée des réseaux d’agents persistants où les membres communiquent via des normes ouvertes, MCP pour les outils et A2A entre agents. Un agent LangGraph, un agent CrewAI ainsi qu’un agent Python développé manuellement peuvent rejoindre le même réseau. L’objectif est l’interopérabilité entre différents frameworks et organisations, plutôt que d’imposer un flux de travail unique.
Cette technologie est plus récente, dispose d’une communauté plus petite que AutoGen ou LangGraph, et offre moins d’intégrations prêtes à l’emploi que l’écosystème LangChain. Elle convient aux écosystèmes d’agents à long terme en évolution, à la collaboration entre organisations via A2A, aux équipes ayant besoin d’agents provenant de frameworks différents pour interagir, ainsi qu’aux projets d’infrastructure où le support de protocoles ouverts est indispensable.
Choisir l’un d’eux
Commencez par déterminer qui développe l’outil.
- Un développeur solo travaillant sur son premier projet d’agent : CrewAI ou le SDK d’OpenAI.
Puis ce qui est en cours de développement.
- Un système de production nécessitant une gestion d’état et une traçabilité : LangGraph.
- Un flux de travail professionnel avec une séparation claire des rôles : CrewAI.
- Un processus de débat ou d’examen de code entre des agents : AutoGen ou AG2.
- Un déploiement sur Google Cloud avec Gemini : ADK.
- Quelque chose qui doit fonctionner indépendamment des frameworks des différents fournisseurs : OpenAgents.
- Une application à usage critique en termes de sécurité : le Claude Agent SDK.
Puis ce qui ne peut absolument pas être compromis.
- Des solutions agnostiques aux modèles, fonctionnant avec OpenAI, Anthropic et des modèles locaux : LangGraph, CrewAI, AutoGen ou Smolagents.
- Uniquement OpenAI, configuration la plus rapide : le SDK OpenAI Agents.
- Optimisé pour Gemini : ADK.
- Uniquement Claude, avec la posture de sécurité la plus stricte : le SDK d’Anthropic.
- Résultats validés et sûrs du point de vue des types : PydanticAI.
- Interopérabilité entre différents frameworks : OpenAgents.
En guise d’aperçu du marché, il semble que LangGraph domine les niveaux de production et d’entreprise, que Smolagents prenne le dessus dans la communauté Hugging Face et les milieux de recherche, tandis que CrewAI et AutoGen se disputent la place dans le segment accessible intermédiaire.
Le véritable critère
Choisissez le framework qui convient à votre problème, à votre équipe et à l’ensemble des outils que vous utilisez déjà. Pas celui qui a le plus d’étoiles ni le plus récent. Choisissez celui qui permet d’exprimer simplement votre problème de coordination spécifique et de le déboguer facilement. C’est toujours été l’objectif principal.