Frameworks pour agents IA : LangGraph, CrewAI, OpenAI ou Claude ?

Mise à jour (9 novembre 2026) : Claude Fable 5.2 et Mythos 5.2 sont sortis - prix, accès et benchmarks dans mon guide Claude Fable 5.2.

👁 116 lectures

J’ai developpe le meme agent IA cinq fois : sans framework, avec OpenAI Agents SDK, LangGraph, CrewAI et Claude Agent SDK. Chaque variante a recu exactement les trois memes outils et la meme mission, ce qui m’a permis de mesurer le nombre de lignes de code, le temps d’execution, le volume de requetes au modele et le cout. En resume : pour apprendre ou concevoir des agents simples, votre propre boucle ou OpenAI Agents SDK restent ideaux ; LangGraph s’impose sur les flux complexes ; CrewAI excelle sur les equipes d’agents avec des roles ; et Claude Agent SDK prend tout son sens lorsque l’agent doit manipuler des fichiers a la maniere de Claude Code. Cet article s’inscrit dans le cadre de la serie Agents IA de zero.

Le cas de test

L’agent doit calculer le montant total de factures situees dans un repertoire dane/ (deux factures libellees en monnaie locale et une de 120 EUR), en convertissant les euros au taux de change officiel du jour de la banque centrale polonaise (NBP). Le resultat exact attendu est de 3919,74 dans la devise locale. Les outils sont strictement identiques pour toutes les versions et isoles dans un module dedie :

• szukaj_plikow : recherche et lit le contenu des fichiers .txt du dossier ;
• kalkulator : evalue de maniere securisee des calculs arithmetiques ;
• czytaj_strone : recupere le contenu d’une page Web ou d’une reponse d’API.

Note : Le test original a ete realise avec des invites et des donnees en polonais. Le code ci-dessous presente une traduction fidele des consignes et commentaires employes lors de cette evaluation.

"""Outils partages pour toutes les versions de l'agent (fonctions Python standard, sans framework)."""
import ast, operator, pathlib
import requests
from bs4 import BeautifulSoup

KATALOG = (pathlib.Path(__file__).parent.parent / "dane").resolve()
# Traduction de l'invite testee initialement en polonais :
ZADANIE = ("Calcule combien j'ai depense au total sur les factures du dossier dane. "
           "Convertis la facture en euros selon le cours du jour de la NBP.")
INSTRUKCJA = ("Resous le probleme a l'aide des outils. Taux de change : https://api.nbp.pl/api/exchangerates/rates/a/{kod}/?format=json. "
              "Effectue toujours les calculs avec la calculatrice. Reponds de maniere breve.")

def szukaj_plikow(fraza: str = "") -> str:
    """Affiche les fichiers .txt du dossier dane/ et leur contenu. Chaine vide = tous les fichiers."""
    out = [f"== {p.relative_to(KATALOG)} ==\n{p.read_text(encoding='utf-8')[:1500]}"
           for p in sorted(KATALOG.rglob("*.txt")) if fraza.lower() in p.read_text(encoding="utf-8").lower()]
    return "\n".join(out) or "aucun fichier"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def kalkulator(wyrazenie: str) -> str:
    """Calcule une expression arithmetique, par exemple 2214+1180.8."""
    def licz(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](licz(n.left), licz(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](licz(n.operand))
        raise ValueError("uniquement des nombres et + - * /")
    return str(round(licz(ast.parse(wyrazenie, mode="eval").body), 4))

def czytaj_strone(url: str) -> str:
    """Telecharge le texte d'une page Web ou la reponse d'une API a l'URL fournie."""
    r = requests.get(url, timeout=20, headers={"User-Agent": "agent-starter/1.0"})
    return BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)[:4000]

Cette approche permet d’isoler precisement la charge ajoutee par chaque framework, sans distorsion liee aux outils. Pour observer le fonctionnement interne d’une boucle d’agent, consultez notre guide Comment construire un agent IA en Python.

Resultats des mesures

Couts calcules a titre indicatif sur la base du taux de reference de la BCE du 12/10/2026 (1 EUR = 1,1181 USD).

Methode de calcul retenue :

• Lignes de code : lignes non vides et non commentees, a l’exclusion du fichier d’outils partage ;
• Temps : intervalle entre le demarrage du processus Python et le resultat final, incluant l’import des modules (moyenne sur 3 executions) ;
• Paquets : volume de dependances installees par pip avec le framework (resolution sous Python 3.13) ;
• Cout : somme du champ cost transmis par OpenRouter lors de chaque requete.

Enseignements cles :

• Sur un agent basique, le framework n’impacte quasiment pas le cout. Avec GPT-5.6 Luna, les valeurs restent comprises entre ~0,0005 EUR et ~0,0008 EUR (0,0006 a 0,0009 USD). OpenAI Agents SDK et CrewAI ont parfois necessite une 4e requete (appels de calculatrice separes au lieu d’un appel groupe), d’ou une moyenne legerement superieure.
• Claude Agent SDK s’avere nettement plus cher et lent, d’abord a cause du modele utilise. Le test temoin permet d’analyser la difference : le meme modele Haiku execute dans une boucle native a coute ~0,0063 EUR (0,0071 USD), contre ~0,0133 EUR (0,0149 USD) avec Claude Agent SDK. Environ la moitie de ce surcout provient du moteur Claude Code lui-meme (consignes systeme etendues, etapes de raisonnement prealables a chaque action).
• CrewAI implique le volume de dependances le plus lourd (137 paquets, soit environ 790 Mo d’environnement) et le temps d’import le plus eleve. Son installation dans un environnement virtuel separe est recommandee pour eviter les conflits.

1. Sans framework : 16 lignes

import json, os
from openai import OpenAI
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
FUNKCJE = {f.__name__: f for f in (szukaj_plikow, kalkulator, czytaj_strone)}
TOOLS = [{"type": "function", "function": {"name": n, "description": f.__doc__, "parameters": {"type": "object",
          "properties": {p: {"type": "string"} for p in f.__annotations__ if p != "return"}}}} for n, f in FUNKCJE.items()]

messages = [{"role": "system", "content": INSTRUKCJA}, {"role": "user", "content": ZADANIE}]
for krok in range(8):
    msg = client.chat.completions.create(model=os.environ["MODEL"], messages=messages, tools=TOOLS).choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        print(msg.content); break
    for c in msg.tool_calls:
        wynik = FUNKCJE[c.function.name](**json.loads(c.function.arguments or "{}"))
        messages.append({"role": "tool", "tool_call_id": c.id, "content": wynik})

L’ensemble de la logique est parfaitement explicite : liste des messages, boucle d’iteration, execution des fonctions. La specification des outils est deduite des docstrings. Il manque ici la gestion du logging, les nouvelles tentatives en cas d’erreur reseau et la validation des arguments. En production, vous ajouteriez ces fonctionnalites en 30 a 50 lignes supplementaires, comme presente dans notre guide complet de l’agent.

2. OpenAI Agents SDK : 10 lignes

import os
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

set_tracing_disabled(True)
model = OpenAIChatCompletionsModel(model=os.environ["MODEL"], openai_client=AsyncOpenAI(
    base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))
agent = Agent(name="Factures", instructions=INSTRUKCJA, model=model,
              tools=[function_tool(f) for f in (szukaj_plikow, kalkulator, czytaj_strone)])
print(Runner.run_sync(agent, ZADANIE, max_turns=8).final_output)

Il s’agit de la syntaxe la plus compacte. function_tool genere automatiquement le schema a partir de la signature de la fonction, et Runner.run_sync pilote la boucle d’execution avec un plafond max_turns. Vous disposez d’emblee des transferts d’agents (handoffs), de garde-fous (guardrails), de sessions et d’un suivi des traces. Sur OpenRouter, pensez a desactiver le tracing et a encapsuler le client dans OpenAIChatCompletionsModel, car le SDK cible par defaut l’API Responses d’OpenAI.

3. LangGraph : 19 lignes

import os
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

outils = [szukaj_plikow, kalkulator, czytaj_strone]
llm = ChatOpenAI(model=os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
                 api_key=os.environ["OPENROUTER_API_KEY"]).bind_tools(outils)

def modele(etat: MessagesState):
    return {"messages": [llm.invoke(etat["messages"])]}

graf = StateGraph(MessagesState)
graf.add_node("modele", modele)
graf.add_node("tools", ToolNode(outils))
graf.add_edge(START, "modele")
graf.add_conditional_edges("modele", tools_condition)  # presence d'appels d'outils ? -> "tools", sinon fin
graf.add_edge("tools", "modele")
agent = graf.compile()

resultat = agent.invoke({"messages": [("system", INSTRUKCJA), ("user", ZADANIE)]}, {"recursion_limit": 16})
print(resultat["messages"][-1].content)

Cette implementation est plus verbeuse, car le graphe a ete construit manuellement pour illustrer l’architecture interne plutot que d’utiliser une fonction preconfiguree. On y retrouve les fondements de LangGraph : l’etat (liste des messages), les noeuds (modele, outils) et les transitions (condition d’appel d’un outil). Pour un agent unique, cette structure peut sembler disproportionnee. En revanche, pour un flux multi-etapes comprenant des embranchements, une validation humaine, une persistance d’etat et une reprise sur panne, cette modularite fait gagner un temps precieux. Le plafond de tours se configure via recursion_limit.

4. CrewAI : 10 lignes

import os
from crewai import Agent, Task, Crew, LLM
from crewai.tools import tool
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

llm = LLM(model="openrouter/" + os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
          api_key=os.environ["OPENROUTER_API_KEY"])
comptable = Agent(role="Comptable", goal="Calculer les depenses des factures", backstory=INSTRUKCJA, llm=llm,
                  tools=[tool(f) for f in (szukaj_plikow, kalkulator, czytaj_strone)], max_iter=8, verbose=False)
mission = Task(description=ZADANIE, expected_output="Total dans la devise avec detail court du calcul", agent=comptable)
print(Crew(agents=[comptable], tasks=[mission]).kickoff().raw)

CrewAI adopte une approche anthropomorphique : chaque agent dispose d’un role, d’un objectif et d’un contexte metier (backstory), tandis que la tache definit une description et un format de sortie attendu. Pour un agent isole, ce formalisme est un peu lourd. En revanche, dans le cadre d’un collectif (par exemple un chercheur, un redacteur et un relecteur), cette organisation est particulierement intuitive a apprehender, y compris pour des profils non techniques. Le modele est declare avec le prefixe du fournisseur (ici openrouter/). CrewAI prend en charge Python de 3.10 a 3.13.

5. Claude Agent SDK : 24 lignes

import asyncio, os
from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, create_sdk_mcp_server, query, tool
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

def emballer(f, param):  # fonction Python -> outil SDK (retourne des blocs de contenu)
    @tool(f.__name__, f.__doc__, {param: str})
    async def t(args):
        return {"content": [{"type": "text", "text": f(args.get(param, ""))}]}
    return t

serveur = create_sdk_mcp_server("factures", tools=[emballer(szukaj_plikow, "fraza"), emballer(kalkulator, "wyrazenie"),
                                                   emballer(czytaj_strone, "url")])
options = ClaudeAgentOptions(system_prompt=INSTRUKCJA, model=os.environ.get("CLAUDE_MODEL", "anthropic/claude-haiku-4.5"),
                             mcp_servers={"factures": serveur}, strict_mcp_config=True,
                             tools=[],  # exclusion des outils integres de Claude Code (Bash, Edition, etc.)
                             allowed_tools=["mcp__factures__szukaj_plikow", "mcp__factures__kalkulator",
                                            "mcp__factures__czytaj_strone"], max_turns=8,
                             cli_path=os.getenv("CLAUDE_CLI"),  # sous Windows : chemin vers claude.exe (pas claude.cmd)
                             setting_sources=[],  # evite de charger ~/.claude/settings.json (qui peut imposer un autre ANTHROPIC_BASE_URL)
                             env={"ANTHROPIC_BASE_URL": "https://openrouter.ai/api",  # appel Claude via OpenRouter
                                  "ANTHROPIC_AUTH_TOKEN": os.environ["OPENROUTER_API_KEY"], "ANTHROPIC_API_KEY": ""})

async def main():
    async for m in query(prompt=ZADANIE, options=options):
        if isinstance(m, ResultMessage):
            print(m.result)
asyncio.run(main())

Cette approche necessite le plus de parametrage, car Claude Agent SDK embarque l’integralite du moteur Claude Code sous forme de bibliotheque. Les fonctions personnalisees sont exposees via un serveur MCP cree en memoire (create_sdk_mcp_server), tandis que les outils systeme par defaut (Bash, modifications de fichiers) ont ete neutralises via tools=[]. Trois difficultes pratiques rencontrees durant les tests :

• Sous Windows, le SDK refuse d’executer le script claude.cmd issu de npm. Il convient d’indiquer le chemin absolu vers claude.exe dans le parametre cli_path ;
• Sans setting_sources=[], le SDK charge les options locales depuis ~/.claude/settings.json, routant les requetes vers une URL non souhaitee (declenchant une erreur 403) ;
• Via OpenRouter, Claude Code dialogue avec un endpoint conforme a l’API Anthropic (ANTHROPIC_BASE_URL=https://openrouter.ai/api), et la cle doit etre transmise dans ANTHROPIC_AUTH_TOKEN.

Comparatif : quel framework choisir selon votre usage ?

D’autres bibliotheques existent sur le marche : Google propose ADK (Agent Development Kit, version 2.11.0 sur PyPI), Hugging Face developpe smolagents (1.26.0), et Microsoft soutient Agent Framework. Elles n’ont pas ete incluses dans ce banc d’essai. Si vous recherchez des solutions sans programmation, l’equivalent fonctionnel de ces outils se trouve dans n8n (avec le noeud AI Agent) ou sur Gumloop.

Mes conseils pratiques

1. Commencez par concevoir un agent sans aucun framework. Quelques heures consacrees a coder votre propre boucle vous epargneront des semaines d’incomprehension sur ce que font les bibliotheques en coulisses.
2. Pour lancer un premier vrai projet, OpenAI Agents SDK offre le meilleur compromis. Il fonctionne parfaitement avec OpenRouter ou des modeles locaux tout en reduisant le code boilerplate.
3. Adoptez LangGraph des lors que votre flux de traitement commence a ressembler a un ordinogramme sur papier avec des boucles, des conditions et des embranchements.
4. Reservez CrewAI et Claude Agent SDK a leurs specialites respectives : la coordination de profils specialises pour le premier, la manipulation directe de bases documentaires ou de code source pour le second.

Foire aux questions

LangChain ou LangGraph ?

LangChain fournit les briques elementaires (modeles, connecteurs d’outils, parseurs), tandis que LangGraph organise la cinematique d’execution de l’agent sous forme de graphe. Dans leurs versions actuelles, LangChain delegue l’orchestration des agents a LangGraph. Pour concevoir un agent, demarrez directement avec LangGraph, en utilisant uniquement les connecteurs cibles de LangChain, par exemple langchain-openai.

Ces frameworks sont-ils gratuits ?

Les cinq options comparees ici sont open source et gratuites a l’installation. Seule la consommation de jetons (tokens) aupres des fournisseurs de modeles genere des couts. Certains modules complementaires demeurent payants, a l’image de LangSmith (outils de tracing pour LangGraph) ou des services heberges de CrewAI.

Quelles solutions supportent des modeles heberges localement ?

Une boucle de code native, OpenAI Agents SDK, LangGraph et CrewAI s’interfacent directement avec Ollama via les points d’entree compatibles avec l’API OpenAI. Claude Agent SDK exige pour sa part l’utilisation de modeles Claude.

Un framework ameliore-t-il la precision des resultats ?

Non, pas lors de ce test. Toutes les versions ont produit des reponses strictement exactes. La precision depend avant tout de la qualite du modele de langage, de la description des outils et des donnees fournies. Le framework intervient sur la structure, l’observabilite et la robustesse de l’environnement d’execution.

Quel a ete le montant total depense pour ces benchmarks ?

L’ensemble des 16 executions (15 mesures comparatives et 1 controle) a represente environ 0,054 EUR (0,060 USD au taux BCE du 12/10/2026 : 1 EUR = 1,1181 USD), dont environ 0,046 EUR (0,052 USD) imputables aux tests conduits sur Claude Haiku.

Quelles ressources consulter pour progresser ?

Plusieurs tutoriels gratuits sont accessibles : LangChain Academy (formation Intro to LangGraph), DeepLearning.AI (AI Agents in LangGraph, Multi AI Agent Systems with crewAI), ainsi que les documentations techniques d’OpenAI Agents SDK et de Claude Agent SDK. Une liste complete est rassemblee dans notre dossier de synthese.

Sources et details de l’environnement de test

• Documentation officielle consultee le 4/10/2026 : OpenAI Agents SDK, LangChain Academy: Intro to LangGraph, CrewAI docs, Claude Agent SDK.
• Versions logicielles relevees sur PyPI au 4/10/2026.
• Mesures effectuees sur une machine personnelle (Windows 11, Python 3.13), le 4 octobre 2026, entre 13h53 et 13h57. Le code de chaque variante est disponible dans le pack de ressources agent-starter, au sein du repertoire frameworki/.

// lire la suitePasser de Claude Code à Codex : AGENTS.md, skills et MCPGuidesAgents API OpenAI : computer use, Decisions API et tarifsOutils d'IADes chercheurs ont utilisé Claude d’Anthropic pour s’introduire dans les systèmes d’OpenAIActualités

Kinetyra