Coût d'un système multi-agents : pourquoi les orchestrateurs coûtent 3 à 6 fois plus

Un agent gestionnaire déléguant à quatre travailleurs lit 362,600 jetons d'entrée et écrit 17,100 jetons de sortie pour accomplir une tâche qu'un seul agent en 12 étapes termine avec 172,800 entrées et 4,800 sorties. C'est 2.1 fois l'entrée, 3.6 fois la sortie. Le tout sur Claude Sonnet 5 ($2 / $10 par million) le système coûte $0.90 contre $0.39 pour l'agent seul. Le tout sur Claude Opus 5 ($5 / $25) il coûte $2.24, 5.7 fois le run Sonnet seul.

Les frameworks ne sont pas le coût ; LangGraph, CrewAI, l'OpenAI Agents SDK et le Claude Agent SDK sont open source. Le coût est le contexte : chaque agent le reconstruit, chaque transfert le copie, chaque tour du gestionnaire le renvoie.

Voici le calcul derrière ces chiffres. Un seul agent a un préfixe de 4,000 jetons (prompt système plus outils), une tâche de 500 jetons, et douze étapes qui ajoutent chacune un appel d'outil de 300 jetons et un résultat de 1,500 jetons. Son entrée cumulée sur douze étapes est de 172,800 jetons ; la sortie est de 4,800.

Divisons maintenant la même tâche. Quatre travailleurs reçoivent chacun un préfixe de 3,000 jetons, un briefing de 500 jetons, et exécutent huit étapes. Par travailleur : 8 × 3,500 + 1,800 × 28 = 78,400 entrées, 8 × 300 + un rapport de 1,000 jetons = 3,400 sorties. Quatre travailleurs : 313,600 entrées, 13,600 sorties.

Le gestionnaire a un contexte de départ de 4,500 jetons. Il planifie (800 jetons en sortie), puis pour chaque travailleur il envoie une dépêche de 300 jetons et reçoit un rapport enveloppé de 1,500 jetons, puis écrit une synthèse de 1,500 jetons. Ses six tours envoient 4,500 + 5,300 + 7,100 + 8,900 + 10,700 + 12,500 = 49,000 jetons d'entrée et 3,500 de sortie.

Quatre choses entraînent le multiplicateur : quatre préfixes séparés au lieu d'un, des travailleurs en huit étapes qui renvoient chacun leur contexte croissant, un gestionnaire qui renvoie le sien, et 3.6 fois les jetons de sortie parce que chaque travailleur écrit un rapport et que le gestionnaire les réécrit. La sortie coûte cinq fois le prix de l'entrée sur chaque modèle du tableau, donc ce dernier facteur fait le plus mal.

Un rapport de 1 000 tokens d'un travailleur est payé une fois comme production du travailleur (10 $ par million sur Sonnet 5), puis à nouveau comme entrée du gestionnaire à chaque tour suivant. Dans le schéma séquentiel ci-dessus, le premier rapport est renvoyé quatre fois de plus, le second trois, et ainsi de suite. Cela représente 15 renvois de rapports encapsulés de 1 500 tokens, soit 22 500 des 49 000 tokens d'entrée du gestionnaire, consacrés à la relecture de ce qu'il a déjà lu.

Les transferts comportent également un cadrage : le brief répète la tâche, le rapport répète le contexte. Selon notre expérience, cela ajoute 20 à 40 % au résultat brut, donc limitez la production du travailleur par instruction (« au maximum 300 mots, pas de préambule »).

La distribution séquentielle permet au travailleur 2 de voir ce que le travailleur 1 a trouvé, mais augmente le contexte du gestionnaire à chaque tour. La distribution parallèle envoie les quatre briefs en un seul tour et lit les quatre rapports en un seul tour : 4 500 + 5 300 + 11 900 = 21 700 tokens d'entrée du gestionnaire au lieu de 49 000, et environ un quart du temps réel.

Avec un gestionnaire Opus 5, la différence est de 27 300 × 5 $ = 0,14 $ par exécution ; avec Sonnet 5, elle est de 0,05 $. Mais si les sous-tâches se chevauchent, les travailleurs parallèles répètent les appels d'outils des autres, et quatre recherches répétées de 1 500 tokens coûtent plus que ce que le gestionnaire a économisé. Utilisez le parallélisme pour les sous-tâches indépendantes, et le séquentiel lorsque les travailleurs ultérieurs dépendent des résultats précédents.

Le planificateur lit le moins de tokens et prend les décisions qui coûtent le plus cher lorsqu’elles sont erronées, c’est donc le seul nœud où un modèle phare justifie son prix. Les travailleurs exécutent des sous-tâches bien spécifiées avec des outils, ce que les modèles bon marché font de manière fiable.

Associations suggérées avec les tarifs par million :

• Planificateur : Claude Opus 5 (5 $ / 25 $) ou GPT-5.5 (5 $ / 30 $)
• Travailleurs : Claude Haiku 5.5 (0,10 $ / 0,50 $ pour les prompts jusqu’à 100 000 tokens), GPT-5.4 mini (0,75 $ / 4,50 $), Gemini 3.8 Flash (0,75 $ / 3,75 $) ou DeepSeek V4.1 Flash (0,30 $ / 1,20 $ en heures de pointe, moitié en heures creuses)
• Compromis lorsque les travailleurs nécessitent du jugement : Claude Sonnet 5 (2 $ / 10 $) ou GPT-5.4 (2,50 $ / 15 $)

Le travailleur le moins cher sur le plan tarifaire est désormais Claude Haiku 5.5, sorti en octobre ; il a remplacé l’ancien Haiku 4.5 (1 $ / 5 $) et coûte dix fois moins cher. Nous ne l’avons pas encore testé en tant que travailleur. Le travailleur le moins cher que nous ayons vu tenir le coup, pour des appels d’outils structurés sur des briefs clairs, est DeepSeek V4.1 Flash, nom d’API deepseek-flash, qui a remplacé le V4 Flash retiré ; voir [DeepSeek V4 pour les agents IA](/guides/deepseek-v4-for-ai-agents-cost) pour savoir où il échoue. Payez pour des travailleurs Sonnet 5 ou GPT-5.4 lorsque les sous-tâches sont ambiguës ou dépassent dix étapes, car un travailleur bon marché qui s’égare renvoie son contexte à chaque étape inutile et le manager paie ensuite pour lire un mauvais rapport. Le classement plus large se trouve dans [LLM le moins cher pour les agents IA](/guides/cheapest-llm-for-ai-agents).

Tâche : « Comparez les pages de tarification de trois fournisseurs et rédigez une recommandation. » Un planificateur, trois travailleurs exécutant chacun huit étapes (78 400 tokens d’entrée, 3 400 tokens de sortie par travailleur ; 235 200 et 10 200 combinés), dispatch séquentiel, tours du manager de 4 500 + 5 300 + 7 100 + 8 900 + 10 700 = 36 500 tokens d’entrée et 3 200 tokens de sortie.

À titre de comparaison, un seul agent Sonnet 5 effectuant l’ensemble en 12 étapes coûte 0,39 $. Le multi-agent n’est gagnant sur le coût que lorsque les travailleurs sont bon marché. La mise en cache des prompts (environ 10 % pour les lectures de cache chez Anthropic et OpenAI) s’applique à chaque ligne et principalement aux travailleurs, dont le préfixe est renvoyé huit fois chacun ; la [comparaison de la mise en cache des prompts](/compare/ai-prompt-caching-costs) contient les tarifs. Modélisez votre propre répartition dans le [calculateur](/calculator). Les lignes DeepSeek utilisent les tarifs de pointe ; tarifs DeepSeek vérifiés le 2026-10-27 sur api-docs.deepseek.com. Les lignes Haiku 5.5 utilisent son tarif pour les prompts jusqu’à 100 000 tokens (vérifié le 2026-11-03) ; aucun appel de travailleur ici ne s’en approche.

LangGraph, CrewAI, le SDK OpenAI Agents et le SDK Claude Agent sont gratuits à installer et à exécuter ; leurs fournisseurs vendent un hébergement et une observabilité optionnels, facturés sur leurs propres pages. Ce que chaque framework vous coûte, c'est l'échafaudage : des modèles de rôles et d'objectifs, des instructions d'utilisation d'outils, des descriptions de transfert et des règles de format de sortie qui sont ajoutés à chaque appel de modèle. D'après notre expérience, cela va de quelques centaines de tokens par étape sur les SDK les plus légers à quelques milliers sur les plus directifs, et cela est renvoyé à chaque étape de chaque agent.

Mesurez-le une fois avec le compteur de tokens du fournisseur, avec et sans le prompt par défaut du framework, et remplacez le modèle s'il dépasse le vôtre. La même mesure s'applique aux listes d'outils MCP, couvertes dans [Coût en tokens du serveur MCP](/guides/mcp-server-token-cost).

Avec le SDK OpenAI Agents, chaque Agent porte son propre model, donc le planificateur et les travailleurs sont facturés indépendamment et le travailleur est exposé au planificateur en tant qu'outil :

from agents import Agent, Runner, function_tool

@function_tool
def fetch_pricing_page(url: str) -> str:
    return http_get(url)[:6000]          # limiter le résultat : ~1 500 tokens

worker = Agent(
    name="researcher", model="gpt-5.4-mini",            # 0,75 $ / 4,50 $ par million
    instructions="Répondre à une sous-question avec l'outil. Max 300 mots, pas de préambule.",
    tools=[fetch_pricing_page],
)
planner = Agent(
    name="planner", model="gpt-5.5",                    # 5 $ / 30 $ par million
    instructions="Diviser la tâche en 3 sous-questions maximum, déléguer, puis rédiger la recommandation.",
    tools=[worker.as_tool(tool_name="research", tool_description="Rechercher une sous-question")],
)
result = Runner.run_sync(planner, task, max_turns=8)
planner_in = sum(r.usage.input_tokens for r in result.raw_responses)
planner_out = sum(r.usage.output_tokens for r in result.raw_responses)
# coût planificateur = planner_in * 5 / 1e6 + planner_out * 30 / 1e6 ; les travailleurs enregistrent leur propre coût

Dans LangGraph, donnez à chaque nœud son propre client de modèle ; dans CrewAI, définissez llm par agent. Voir [Coût de l'API OpenAI Agents](/guides/openai-agents-api-cost) pour savoir comment le SDK rapporte l'utilisation.

Les systèmes multi-agents échouent de manière coûteuse car un travailleur confus peut boucler pendant que le gestionnaire attend. Appliquez les garde-fous par agent, pas seulement par exécution :

• max_tokens sur chaque appel, et une limite de mots en sortie dans les instructions de chaque travailleur
• max_turns (ou l'équivalent du framework) sur chaque travailleur, généralement de 8 à 12, et sur le gestionnaire, généralement de 6 à 10
• Une condition d'arrêt que chaque travailleur peut déclencher : un outil report qui met fin à sa boucle
• Un budget en dollars par exécution totalisé à partir des champs d'utilisation de chaque agent, le gestionnaire annulant lorsqu'il est dépassé

L'article [Garde-fous de budget de tokens](/guides/ai-agent-token-budget-guardrails) propose un exécuteur que vous pouvez envelopper autour de chaque nœud. Pour les déploiements nocturnes où la latence n'a pas d'importance, l'API Batch à environ 50 % de réduction s'applique aux travailleurs aussi facilement qu'aux appels uniques ; voir [Comparaison des prix de l'API Batch](/compare/llm-batch-api-pricing).