Comparatif des Frameworks d IA Agentique : LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Les agents IA sont passes des demos de recherche aux systemes en production. On estime que plus de 60 % des applications IA en entreprise incluront des composants agentiques d'ici 2026. Mais construire des agents depuis zero - gerer les boucles de tool, l'etat, la memoire, la gestion des erreurs et la coordination multi-agent - est complexe. C'est la que les frameworks interviennent.

Quatre frameworks dominent en 2026 : LangGraph, CrewAI, OpenAI Agents SDK et Claude Agent SDK. Chacun adopte une approche fondamentalement differente du meme probleme : donner aux LLM la capacite de raisonner, planifier, utiliser des tool et collaborer.

Vue d'Ensemble

LangGraph : Le Constructeur de Graphes

LangGraph modelise les workflows d'agents sous forme de graphes cycliques diriges. Vous definissez des noeuds (des fonctions qui effectuent le travail) et des aretes (des transitions entre eux, optionnellement conditionnelles). L'etat circule a travers le graphe et persiste via le checkpointing.

C'est le framework le plus explicite et controlable - vous ciblez chaque etape vous-meme.

Concepts Cles

• StateGraph : la definition du graphe avec un etat type
• Nodes : des fonctions Python qui transforment l'etat
• Edges : des connexions entre les noeuds, pouvant etre conditionnelles
• Checkpointing : persistance integree pour les workflows de longue duree

Exemple de Code

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Points Forts

• Controle fin sur chaque etape et transition
• Checkpointing integre et human-in-the-loop
• Parite complete avec TypeScript
• Fonctionne avec n'importe quel fournisseur LLM
• Ideal pour les workflows complexes avec des branchements conditionnels et des boucles

Points Faibles

• Courbe d'apprentissage abrupte - il faut comprendre les concepts de la theorie des graphes
• Verbeux pour les cas d'utilisation simples - un agent basique necessite plus de boilerplate que les autres frameworks
• Le debugging des flux du graphe peut etre difficile sans LangSmith

Tarification

Open-source (MIT). LangSmith (plateforme d'observabilite geree) propose des plans payants pour le monitoring en production.

CrewAI : L'Assembleur d'Equipe

CrewAI utilise une metaphore humaine : vous assemblez un crew d'agents specialises, chacun avec un role, un objectif et une histoire. Les agents collaborent sur des taches en utilisant des tool, coordonnes par un processus (sequentiel, hierarchique ou consensuel).

Pensez-y comme recruter une equipe ou chaque membre a un titre et une specialite specifiques.

Concepts Cles

• Agent : un persona avec role, objectif, histoire et tool
• Task : une mission avec description, sortie attendue et agent assigne
• Crew : un groupe d'agents travaillant ensemble
• Process : strategie d'execution (sequentielle, hierarchique, consensuelle)
• Flow : couche d'orchestration event-driven pour connecter plusieurs crews

Exemple de Code

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Points Forts

• Abstraction basee sur les roles intuitive - facile a apprehender
• Plus de 100 integrations de tool integrees
• Memoire partagee entre les agents (court terme, long terme, par entite)
• Plus grande communaute (~40k etoiles GitHub)
• Processus hierarchique avec un agent "manager" qui delegue et valide

Points Faibles

• Moins de controle fin que LangGraph - vous definissez les roles, pas les chemins d'execution exacts
• Le processus hierarchique peut etre imprevisible quand les agents ne sont pas d'accord
• Le debugging des conversations multi-agent est plus difficile que les flux a agent unique

Tarification

Core open-source (gratuit). CrewAI Platform : $99/mois (Teams) jusqu'a $120k/an (Enterprise). Tarification basee sur les crews actifs et les executions mensuelles.

OpenAI Agents SDK : Le Routeur

L'OpenAI Agents SDK (successeur spirituel de Swarm) se concentre sur les handoff - des agents qui transferent les conversations a d'autres agents specialises. C'est le framework le plus minimal : agents, tool, handoff et guardrail. C'est tout.

Concepts Cles

• Agent : modele + instructions + tool + handoff
• Handoff : un transfert vers un autre agent (modelise comme un tool que le LLM peut appeler)
• Guardrail : validation d'entree/sortie qui s'execute en parallele avec l'agent
• Runner : execute la boucle de l'agent
• Tracing : observabilite integree pour tous les appels LLM, invocations de tool et handoff

Exemple de Code

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Points Forts

• Pattern de handoff propre - naturel pour les workflows de routing/triage
• Les guardrail s'executent en parallele avec l'execution (fail-fast, non bloquants)
• Dashboard de tracing integre pour le debugging
• Malgre le nom, supporte les modeles non-OpenAI
• Abstraction minimale - facile a comprendre et a etendre

Points Faibles

• Gestion de l'etat moins mature que LangGraph
• Pas de persistance ni de checkpointing integres
• L'ecosysteme de tool tiers est plus restreint
• Le design centre sur les handoff peut ne pas convenir a toutes les architectures

Tarification

Open-source (MIT). Vous payez par token selon le modele utilise.

Claude Agent SDK : Le Developpeur

Le Claude Agent SDK adopte une approche differente : au lieu de definir des workflows ou des roles, vous donnez a l'agent un ensemble de tool et le laissez trouver comment accomplir la tache. Il utilise la meme boucle autonome qui alimente Claude Code - lire, agir, verifier, iterer.

Concepts Cles

• query() : le point d'entree principal qui lance la boucle de l'agent
• Tool integres : Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Tool personnalises via MCP : definissez des tool comme des serveurs MCP in-process
• Sub-agents : agents specialises a qui le parent peut deleguer
• Sessions : maintiennent le contexte a travers plusieurs interactions

Exemple de Code

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Points Forts

• Integration MCP de premiere classe - connectez-vous a n'importe quel ecosysteme de serveurs MCP
• Tool integres pour les operations sur fichiers, le terminal et l'acces web
• Compaction automatique du contexte pour les grandes bases de code
• Parallelisme des sub-agents pour les taches complexes
• Meme moteur que Claude Code - eprouve sur des workflows de developpement reels

Points Faibles

• Modeles Claude uniquement - pas de support multi-fournisseur
• Framework plus recent avec une communaute plus restreinte
• Necessite le runtime Node.js meme pour le SDK Python
• Moins de controle explicite du workflow par rapport a LangGraph

Tarification

Open-source. Tarifs standard par token de l'API Claude. Managed Agents (version hebergee) : $0.08 par heure de session en plus des couts par token.

Quand Choisir Lequel

Choisissez LangGraph si :

• Vous avez besoin d'un controle precis sur chaque etape du workflow
• Votre cas d'utilisation implique une logique conditionnelle complexe et des boucles
• Vous voulez de la persistance integree et des checkpoints human-in-the-loop
• Vous devez utiliser plusieurs fournisseurs LLM dans le meme workflow

Choisissez CrewAI si :

• Vous voulez une abstraction intuitive basee sur les roles
• Votre tache implique plusieurs agents avec des specialites distinctes
• Vous avez besoin que les agents collaborent et se passent du contexte
• Vous valorisez la plus grande communaute et le plus grand nombre d'integrations

Choisissez OpenAI Agents SDK si :

• Votre pattern principal est le routing des conversations vers des specialistes
• Vous avez besoin de guardrail qui valident l'entree/sortie en parallele
• Vous voulez l'abstraction la plus simple possible avec un boilerplate minimal
• Le tracing et l'observabilite integres sont importants

Choisissez Claude Agent SDK si :

• Vos agents doivent lire, ecrire et executer du code
• Vous voulez une integration de premiere classe avec des serveurs MCP
• Vous avez besoin d'agents autonomes qui iterent et s'auto-corrigent
• Vous utilisez deja Claude et voulez l'integration la plus profonde

Peut-on Combiner les Frameworks ?

Oui. Un pattern courant consiste a utiliser un framework pour l'orchestration et un autre pour les agents individuels :

• LangGraph pour le graphe du workflow global
• CrewAI pour un noeud specifique qui necessite une collaboration multi-agent
• Claude Agent SDK pour les sous-taches liees au coding via MCP
• OpenAI Agents SDK pour le triage et le routing cote client

Les frameworks ne sont pas mutuellement exclusifs. Utilisez celui qui convient a chaque partie de votre systeme.

Conclusion

Chaque framework fait un pari clair :

• LangGraph optimise le controle - vous decidez chaque transition
• CrewAI optimise la collaboration - les agents travaillent en equipe
• OpenAI Agents SDK optimise la simplicite - abstraction minimale, handoff propres
• Claude Agent SDK optimise l'autonomie - donnez-lui des tool et laissez-le travailler

Le bon choix depend de votre workflow, de votre equipe et de votre stack existant. Choisissez celui qui correspond a votre cas d'utilisation principal, apprenez-le bien et integrez les autres quand vous atteignez leur point fort.