LangGraph, CrewAI ou Google ADK ? Une tâche à deux agents, trois frameworks.

Les comparaisons de frameworks se basent généralement sur un modèle unique : un tableau des fonctionnalités, un paragraphe par colonne, ainsi qu’une conclusion qui évite de recommander quoi que ce soit. Cela ne sert pas ceux qui doivent choisir et passer à l’action. La comparaison présentée ici repose sur l’écriture du même petit système avec LangGraph, CrewAI et Google ADK, de sorte que les différences proviennent du code et des compromis, et non d’une fiche technique.

Trois modèles mentaux

Un cadre rapide avant même d’écrire du code :

• LangGraph est une boîte de briques Lego. Chaque nœud, chaque arête et chaque branche conditionnelle est défini explicitement. Il offre le plus de contrôle mais présente aussi la courbe d’apprentissage la plus raide.
• CrewAI est une équipe prédéfinie qui demande ce qu’elle doit faire. Les rôles et les objectifs y sont déclarés, et le framework s’occupe de la coordination. C’est le moyen le plus rapide d’obtenir un prototype fonctionnel, avec moins de contrôle sur la manière dont les agents s’organisent pour accomplir leur travail.
• Google ADK fonctionne comme un ingénieur backend expérimenté. Il est basé sur des événements et gère un état, avec des fonctionnalités de surveillance, de testabilité et de gestion des pannes intégrées, ainsi que des liens étroits avec Google Cloud et Gemini.

Aucune de ces approches n’est une critique. Ce ne sont que des choix différents concernant ce dont la plupart des développeurs ont le plus besoin en général.

La tâche de test

Chaque framework remplit la même fonction : un chercheur collecte des informations, puis un rédacteur les transforme en réponse finale, de sorte que le rédacteur ne peut commencer que lorsque le chercheur a terminé. Un routeur de type superviseur gérerait précisément cela, ce qui en fait un critère fiable pour évaluer dans quelle mesure chaque outil exprime différemment le même flux.

LangGraph

Importation en premier :

from langgraph.graph import StateGraph, END
from typing import TypedDict

Ensuite, un état tapé, des nœuds et des arêtes explicites :

class State(TypedDict):
    query: str
    research: str
    final_answer: str
def research_node(state: State) -> State:
    # Call your research agent/tool here
    state["research"] = f"Research findings for: {state['query']}"
    return state
def writer_node(state: State) -> State:
    # Call your writer agent, using state["research"]
    state["final_answer"] = f"Final answer using: {state['research']}"
    return state
graph = StateGraph(State)
graph.add_node("research", research_node)
graph.add_node("writer", writer_node)
graph.set_entry_point("research")
graph.add_edge("research", "writer")
graph.add_edge("writer", END)
app = graph.compile()
result = app.invoke({"query": "What is agentic AI?"})

Tous les arcs sont dessinés à la main ici. À chaque étape, il est clair ce qui se passe ensuite, et c’est là le prix à payer ainsi que l’avantage de LangGraph : du code supplémentaire au départ en échange d’un flux de contrôle que le framework ne improvise jamais.

CrewAI

from crewai import Agent, Task, Crew

Viennent ensuite les agents et les tâches :

researcher = Agent(
    role="Research Specialist",
    goal="Find accurate information on the given topic",
    backstory="An expert at gathering and synthesizing information."
)
writer = Agent(
    role="Content Writer",
    goal="Write a clear final answer using research findings",
    backstory="An expert at turning research into clear prose."
)
research_task = Task(
    description="Research: {query}",
    agent=researcher,
    expected_output="A summary of relevant findings"
)
writing_task = Task(
    description="Write a final answer using the research",
    agent=writer,
    expected_output="A clear, well-written final answer",
    context=[research_task]
)
crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])
result = crew.kickoff(inputs={"query": "What is agentic AI?"})

Remarquez ce qui est absent à côté de LangGraph : personne ne dessine de graphe ni ne relie de arêtes. Le code indique qui est responsable de quoi, et la logique de traitement de CrewAI transfère automatiquement le résultat de la tâche de recherche vers la tâche d’écriture. Il faut bien moins de temps pour obtenir une version fonctionnelle, environ vingt minutes une fois que le schéma est maîtrisé.

Google ADK

from google.adk.agents import Agent
from google.adk.runners import Runner

research_agent = Agent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="Research the given topic thoroughly and return findings.",
)
writer_agent = Agent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="Write a clear final answer using the research findings provided.",
    sub_agents=[research_agent]  # hierarchical relationship
)
runner = Runner(agent=writer_agent, app_name="research_writer_app")
result = runner.run(user_id="user1", session_id="session1",
                     new_message="What is agentic AI?")

Regardez le champ sub_agents. ADK s’appuie sur une hiérarchie parent-enfant fonctionnant via des événements, et son environnement de exécution pilote la boucle qui alterne entre les demandes entrantes, les appels de modèles et les exécutions d’outils. Il se situe entre le câblage manuel de LangGraph et la coordination implicite de CrewAI : on obtient bien une hiérarchie, mais beaucoup plus de aspects techniques sont gérés automatiquement par rapport à LangGraph.

Où ils diffèrent réellement

Les exemples simplifiés semblent trompeusement similaires. Les différences apparaissent une fois passé le stade du prototype.

Contrôle et observabilité. LangGraph est largement considéré comme le choix le plus adapté aux environnements de production pour des workflows complexes et ramifiés. La fonction de sauvegarde à des points clés ainsi qu’une exécution fiable y sont intégrées de base, et on rapporte que Klarna l’utilise pour 85 millions d’utilisateurs. Un tel usage en production constitue un argument suffisant, indépendamment de toute liste de fonctionnalités. Le seul inconvénient est la courbe d’apprentissage, qui est la plus raide des trois précisément parce que le contrôle y est le plus explicite.

Vitesse pour obtenir le premier prototype. CrewAI l’emporte systématiquement. Pour un premier système multi-agents ou afin de tester rapidement une idée, son abstraction basée sur les rôles permet de mettre quelque chose en marche plus rapidement. Cependant, cette même abstraction de haut niveau devient un frein lorsque la logique de coordination devient complexe, car le contrôle détaillé sur le moment et la manière dont les agents transfèrent des tâches est limité.

Besoins des entreprises et en matière de langages. ADK est devenu généralement disponible en 2026 et a changé de direction au cours de ce processus, remplaçant son exécuteur hiérarchique par un moteur basé sur des graphes, qui correspondait déjà au concept de conception de LangGraph depuis le début. Son véritable avantage réside ailleurs : il prend en charge plus de langages que ses concurrents (Python, TypeScript, Go, Java, Kotlin), s’intègre directement à Gemini et Google Cloud pour les équipes déjà présentes dans ces plateformes, et inclut des outils d’évaluation que LangGraph et CrewAI ne proposent pas.

Communication entre frameworks différents. Peu de comparaisons abordent ce point. ADK prend en charge nativement le protocole Agent2Agent (A2A), ce qui permet à un agent écrit dans un tout autre framework d’échanger des messages avec lui, les cartes d’agent signées assurant une vérification cryptographique. Lorsqu’un système doit appeler un agent appartenant à un fournisseur ou à un partenaire, A2A permet aux agents de communiquer de la même manière que MCP le fait pour les outils : il standardise la conversation entre deux agents plutôt qu’entre un agent et un outil.

Efficacité en termes de tokens. Il existe également une différence mesurable. Des tests de performance effectués sur les mêmes tâches avec LangGraph et CrewAI ont montré que LangGraph utilise clairement moins de tokens. La raison probable est que LangGraph suit des chemins explicites, tandis que CrewAI s’appuie sur le LLM pour acheminer les tâches, chaque choix de routage implicite entraînant une petite requête vers le modèle. Quoi qu’il en soit, quelqu’un doit payer pour cette décision.

Choix en ordre

Évitez les tableaux des fonctionnalités et posez ces questions dans l’ordre suivant :

1. Prototype rapidement, ou s’agit-il du premier système multi-agents ? Choisissez CrewAI. C’est le chemin le plus rapide pour obtenir un système fonctionnel, et ce choix pourra être réexaminé une fois que la logique de coordination s’avérera complexe.
2. Ont vous besoin d’un contrôle maximal sur la gestion des branches, un routage explicite des erreurs ou des points de contrôle avec intervention humaine ? Choisissez LangGraph. Lorsque le routage est délicat, vous souhaitez contrôler chaque élément plutôt que de laisser la logique du framework décider à votre place.
3. Vous utilisez déjà Google Cloud, ou avez-vous besoin de langages autres que Python ? Choisissez Google ADK. L’intégration native avec Gemini et Cloud élimine les obstacles pour les équipes travaillant dans cet écosystème, et sa gamme de langages est inégalée.

Est-il obligatoire que les agents provenant de frameworks ou de fournisseurs différents communiquent entre eux ? Choisissez Google ADK pour un soutien A2A, car c’est la seule solution qui répond aux exigences de production, tandis que les autres ne le traitent pas comme une fonctionnalité prioritaire.

Aucune des options ci-dessus ne convient clairement ? Utilisez celle que votre équipe maîtrise le mieux. Les trois solutions sont aptes à être mises en production en 2026, et ce qui importe davantage, c’est la manière dont les couches de routage et d’outils sont conçues à leur niveau.

Aucun gagnant universel

Aucun framework n’est le meilleur pour tout le monde, et toute comparaison affirmant le contraire a un but commercial. Choisissez LangGraph pour un contrôle accru et une meilleure résilience dans les workflows complexes, CrewAI pour obtenir le plus rapidement possible un prototype fonctionnel, et Google ADK pour les équipes axées sur Google Cloud et nécessitant une véritable communication inter-frameworks.

Décidez en fonction de la contrainte réelle, qu’il s’agisse de ce que l’équipe connaît déjà, du cloud sur lequel le système fonctionne ou de la complexité réelle de la logique de coordination, et non en fonction du framework ayant fait l’objet de la annonce la plus spectaculaire récemment. Le framework n’est qu’un squelette. Une bonne conception d’agent s’applique à chacun des trois aspects : la boucle de traitement, la récupération d’informations, le routage, les normes des outils, l’observabilité ainsi que l’habitude d’évaluer les résultats.