1~
2Les 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.
3~
4Quatre 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.
5~
6## Vue d'Ensemble
7~
8| Aspect | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Par** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architecture** | Basee sur les graphes | Basee sur les roles | Basee sur les handoff | Boucle autonome |
12| **Philosophie** | Controle maximal | Collaboration d'equipe | Abstraction minimale | Donner un ordinateur a l'agent |
13| **Langages** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Support des modeles** | Tous (OpenAI, Claude, local) | Tous | Tous (malgre le nom) | Claude uniquement |
15| **Etoiles GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Ideal pour** | Workflows stateful complexes | Specialisation multi-agent | Routing et triage | Coding et taches sur fichiers |
17~
18## LangGraph : Le Constructeur de Graphes
19~
20LangGraph 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.
21~
22C'est le framework le plus explicite et controlable  -  vous ciblez chaque etape vous-meme.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Concepts Cles
35~
36- **StateGraph** : la definition du graphe avec un etat type
37- **Nodes** : des fonctions Python qui transforment l'etat
38- **Edges** : des connexions entre les noeuds, pouvant etre conditionnelles
39- **Checkpointing** : persistance integree pour les workflows de longue duree
40~
41### Exemple de Code
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Points Forts
79~
80- Controle fin sur chaque etape et transition
81- Checkpointing integre et human-in-the-loop
82- Parite complete avec TypeScript
83- Fonctionne avec n'importe quel fournisseur LLM
84- Ideal pour les workflows complexes avec des branchements conditionnels et des boucles
85~
86### Points Faibles
87~
88- Courbe d'apprentissage abrupte  -  il faut comprendre les concepts de la theorie des graphes
89- Verbeux pour les cas d'utilisation simples  -  un agent basique necessite plus de boilerplate que les autres frameworks
90- Le debugging des flux du graphe peut etre difficile sans LangSmith
91~
92### Tarification
93~
94Open-source (MIT). LangSmith (plateforme d'observabilite geree) propose des plans payants pour le monitoring en production.
95~
96## CrewAI : L'Assembleur d'Equipe
97~
98CrewAI 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).
99~
100Pensez-y comme recruter une equipe ou chaque membre a un titre et une specialite specifiques.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Concepts Cles
114~
115- **Agent** : un persona avec role, objectif, histoire et tool
116- **Task** : une mission avec description, sortie attendue et agent assigne
117- **Crew** : un groupe d'agents travaillant ensemble
118- **Process** : strategie d'execution (sequentielle, hierarchique, consensuelle)
119- **Flow** : couche d'orchestration event-driven pour connecter plusieurs crews
120~
121### Exemple de Code
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Points Forts
171~
172- Abstraction basee sur les roles intuitive  -  facile a apprehender
173- Plus de 100 integrations de tool integrees
174- Memoire partagee entre les agents (court terme, long terme, par entite)
175- Plus grande communaute (~40k etoiles GitHub)
176- Processus hierarchique avec un agent "manager" qui delegue et valide
177~
178### Points Faibles
179~
180- Moins de controle fin que LangGraph  -  vous definissez les roles, pas les chemins d'execution exacts
181- Le processus hierarchique peut etre imprevisible quand les agents ne sont pas d'accord
182- Le debugging des conversations multi-agent est plus difficile que les flux a agent unique
183~
184### Tarification
185~
186Core open-source (gratuit). CrewAI Platform : $99/mois (Teams) jusqu'a $120k/an (Enterprise). Tarification basee sur les crews actifs et les executions mensuelles.
187~
188## OpenAI Agents SDK : Le Routeur
189~
190L'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.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Concepts Cles
204~
205- **Agent** : modele + instructions + tool + handoff
206- **Handoff** : un transfert vers un autre agent (modelise comme un tool que le LLM peut appeler)
207- **Guardrail** : validation d'entree/sortie qui s'execute en parallele avec l'agent
208- **Runner** : execute la boucle de l'agent
209- **Tracing** : observabilite integree pour tous les appels LLM, invocations de tool et handoff
210~
211### Exemple de Code
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Points Forts
258~
259- Pattern de handoff propre  -  naturel pour les workflows de routing/triage
260- Les guardrail s'executent en parallele avec l'execution (fail-fast, non bloquants)
261- Dashboard de tracing integre pour le debugging
262- Malgre le nom, supporte les modeles non-OpenAI
263- Abstraction minimale  -  facile a comprendre et a etendre
264~
265### Points Faibles
266~
267- Gestion de l'etat moins mature que LangGraph
268- Pas de persistance ni de checkpointing integres
269- L'ecosysteme de tool tiers est plus restreint
270- Le design centre sur les handoff peut ne pas convenir a toutes les architectures
271~
272### Tarification
273~
274Open-source (MIT). Vous payez par token selon le modele utilise.
275~
276## Claude Agent SDK : Le Developpeur
277~
278Le 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.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Concepts Cles
291~
292- **query()** : le point d'entree principal qui lance la boucle de l'agent
293- **Tool integres** : Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Tool personnalises via MCP** : definissez des tool comme des serveurs MCP in-process
295- **Sub-agents** : agents specialises a qui le parent peut deleguer
296- **Sessions** : maintiennent le contexte a travers plusieurs interactions
297~
298### Exemple de Code
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Points Forts
336~
337- Integration MCP de premiere classe  -  connectez-vous a n'importe quel ecosysteme de serveurs MCP
338- Tool integres pour les operations sur fichiers, le terminal et l'acces web
339- Compaction automatique du contexte pour les grandes bases de code
340- Parallelisme des sub-agents pour les taches complexes
341- Meme moteur que Claude Code  -  eprouve sur des workflows de developpement reels
342~
343### Points Faibles
344~
345- Modeles Claude uniquement  -  pas de support multi-fournisseur
346- Framework plus recent avec une communaute plus restreinte
347- Necessite le runtime Node.js meme pour le SDK Python
348- Moins de controle explicite du workflow par rapport a LangGraph
349~
350### Tarification
351~
352Open-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.
353~
354## Quand Choisir Lequel
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Choisissez LangGraph si :
371- Vous avez besoin d'un controle precis sur chaque etape du workflow
372- Votre cas d'utilisation implique une logique conditionnelle complexe et des boucles
373- Vous voulez de la persistance integree et des checkpoints human-in-the-loop
374- Vous devez utiliser plusieurs fournisseurs LLM dans le meme workflow
375~
376### Choisissez CrewAI si :
377- Vous voulez une abstraction intuitive basee sur les roles
378- Votre tache implique plusieurs agents avec des specialites distinctes
379- Vous avez besoin que les agents collaborent et se passent du contexte
380- Vous valorisez la plus grande communaute et le plus grand nombre d'integrations
381~
382### Choisissez OpenAI Agents SDK si :
383- Votre pattern principal est le routing des conversations vers des specialistes
384- Vous avez besoin de guardrail qui valident l'entree/sortie en parallele
385- Vous voulez l'abstraction la plus simple possible avec un boilerplate minimal
386- Le tracing et l'observabilite integres sont importants
387~
388### Choisissez Claude Agent SDK si :
389- Vos agents doivent lire, ecrire et executer du code
390- Vous voulez une integration de premiere classe avec des serveurs MCP
391- Vous avez besoin d'agents autonomes qui iterent et s'auto-corrigent
392- Vous utilisez deja Claude et voulez l'integration la plus profonde
393~
394## Peut-on Combiner les Frameworks ?
395~
396Oui. Un pattern courant consiste a utiliser un framework pour l'orchestration et un autre pour les agents individuels :
397~
398- **LangGraph** pour le graphe du workflow global
399- **CrewAI** pour un noeud specifique qui necessite une collaboration multi-agent
400- **Claude Agent SDK** pour les sous-taches liees au coding via MCP
401- **OpenAI Agents SDK** pour le triage et le routing cote client
402~
403Les frameworks ne sont pas mutuellement exclusifs. Utilisez celui qui convient a chaque partie de votre systeme.
404~
405## Conclusion
406~
407Chaque framework fait un pari clair :
408~
409- **LangGraph** optimise le controle  -  vous decidez chaque transition
410- **CrewAI** optimise la collaboration  -  les agents travaillent en equipe
411- **OpenAI Agents SDK** optimise la simplicite  -  abstraction minimale, handoff propres
412- **Claude Agent SDK** optimise l'autonomie  -  donnez-lui des tool et laissez-le travailler
413~
414Le 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.
415~