Kosten van multi-agentsystemen: Waarom orchestrators 3 tot 6x duurder zijn

Een manager agent die taken delegeert aan vier workers leest 362.600 invoertokens en schrijft 17.100 uitvoertokens om een taak te voltooien die een enkele 12-stappen agent afrondt met 172.800 invoer en 4.800 uitvoer. Dat is 2,1 keer de invoer, 3,6 keer de uitvoer. Alles op Claude Sonnet 5 ($2 / $10 per miljoen) kost het systeem $0,90 tegenover $0,39 voor de enkele agent. Alles op Claude Opus 5 ($5 / $25) kost het $2,24, 5,7 keer de enkele Sonnet-run.

Frameworks zijn niet de kosten; LangGraph, CrewAI, de OpenAI Agents SDK en de Claude Agent SDK zijn open source. De kosten zijn context: elke agent bouwt het opnieuw op, elke overdracht kopieert het, elke managerbeurt stuurt het opnieuw.

Hier is de boekhouding achter die cijfers. Een enkele agent heeft een prefix van 4.000 tokens (systeemprompt plus tools), een taak van 500 tokens, en twaalf stappen die elk een toolcall van 300 tokens en een resultaat van 1.500 tokens toevoegen. De invoer opgeteld over twaalf stappen is 172.800 tokens; uitvoer is 4.800.

Splits nu dezelfde taak. Vier workers krijgen elk een prefix van 3.000 tokens, een briefing van 500 tokens, en voeren acht stappen uit. Per worker: 8 × 3.500 + 1.800 × 28 = 78.400 invoer, 8 × 300 + een rapport van 1.000 tokens = 3.400 uitvoer. Vier workers: 313.600 invoer, 13.600 uitvoer.

De manager heeft een startcontext van 4.500 tokens. Het plant (800 tokens uit), stuurt vervolgens voor elke worker een dispatch van 300 tokens en ontvangt een ingepakt rapport van 1.500 tokens, en schrijft dan een synthese van 1.500 tokens. De zes beurten sturen 4.500 + 5.300 + 7.100 + 8.900 + 10.700 + 12.500 = 49.000 invoertokens en 3.500 uitvoer.

Vier drijven de vermenigvuldiger: vier aparte prefixes in plaats van één, achtstappenworkers die elk hun groeiende context opnieuw verzenden, een manager die zijn eigen context opnieuw verzendt, en 3,6 keer de uitvoertokens omdat elke worker een rapport schrijft en de manager ze herschrijft. Uitvoer is vijf keer de prijs van invoer op elk model in de tabel, dus die laatste factor doet het meeste pijn.

Een rapport van 1.000 tokens van een worker wordt eenmaal betaald als worker-uitvoer ($10 per miljoen op Sonnet 5) en vervolgens opnieuw als manager-invoer bij elke volgende managerbeurt. In het sequentiële patroon hierboven wordt het eerste rapport nog vier keer opnieuw verzonden, het tweede drie, enzovoort. Dat zijn 15 herverzendingen van ingepakte rapporten van 1.500 tokens, of 22.500 van de 49.000 invoertokens van de manager, besteed aan het herlezen van dingen die het al heeft gelezen.

Overdrachten brengen ook framing met zich mee: de briefing herhaalt de taak, het rapport herhaalt de context. Naar onze ervaring voegt dat 20 tot 40% toe aan de ruwe bevinding, dus beperk de worker-uitvoer door instructie ("maximaal 300 woorden, geen inleiding").

Sequentiële dispatch laat worker 2 zien wat worker 1 heeft gevonden, maar laat de context van de manager elke beurt groeien. Parallelle dispatch stuurt alle vier de briefings in één beurt en leest alle vier de rapporten in één beurt: 4.500 + 5.300 + 11.900 = 21.700 manager invoertokens in plaats van 49.000, en ongeveer een kwart van de verstreken tijd.

Op een Opus 5 manager is het verschil 27.300 × $5 = $0,14 per run; op Sonnet 5 is het $0,05. Maar als de sub-taken overlappen, herhalen parallelle workers elkaars toolcalls, en vier herhaalde zoekopdrachten van 1.500 tokens kosten meer dan de manager heeft bespaard. Gebruik parallel voor onafhankelijke sub-taken, sequentieel wanneer latere workers afhankelijk zijn van eerdere bevindingen.

De planner leest de minste tokens en maakt de beslissingen die het duurst zijn wanneer ze fout zijn, dus dit is het ene knooppunt waar een vlaggenschipmodel zijn prijs waard is. Werknemers voeren welgespecificeerde subtaken uit met tools, wat goedkope modellen juist betrouwbaar doen.

Voorgestelde combinaties met tarieven per miljoen:

• Planner: Claude Opus 5 ($5 / $25) of GPT-5.5 ($5 / $30)
• Werknemers: Claude Haiku 5.5 ($0.10 / $0.50 op prompts tot 100K tokens), GPT-5.4 mini ($0.75 / $4.50), Gemini 3.8 Flash ($0.75 / $3.75) of DeepSeek V4.1 Flash ($0.30 / $1.20 tijdens piekuren, de helft buiten piek)
• Middenweg wanneer werknemers oordeelvermogen nodig hebben: Claude Sonnet 5 ($2 / $10) of GPT-5.4 ($2.50 / $15)

De goedkoopste werknemer qua prijs is nu Claude Haiku 5.5, uitgebracht in oktober; deze verving de legacy Haiku 4.5 ($1 / $5) en kost slechts een tiende daarvan. We hebben het nog niet getest als werknemer. De goedkoopste werknemer die wij hebben zien standhouden, voor gestructureerde toolcalls op heldere briefings, is DeepSeek V4.1 Flash, API-naam deepseek-flash, welke de gepensioneerde V4 Flash verving; zie [DeepSeek V4 for AI agents](/guides/deepseek-v4-for-ai-agents-cost) voor waar het tekortschiet. Betaal voor Sonnet 5- of GPT-5.4-werknemers wanneer subtaken ambigu zijn of meer dan tien stappen omvatten, omdat een goedkope werknemer die afdwaalt zijn context bij elke versleten stap opnieuw verzendt en de manager vervolgens betaalt voor het lezen van een slecht rapport. De bredere ranglijst vind je in [cheapest LLM for AI agents](/guides/cheapest-llm-for-ai-agents).

Taak: "Vergelijk de prijspagina's van drie leveranciers en schrijf een aanbeveling." Eén planner, drie werknemers die elk acht stappen uitvoeren (78.400 input, 3.400 output per werknemer; 235.200 en 10.200 gecombineerd), sequentiële dispatch, manager-beurten van 4.500 + 5.300 + 7.100 + 8.900 + 10.700 = 36.500 input en 3.200 output.

Ter vergelijking: een enkele Sonnet 5-agent die het hele proces in 12 stappen doet kost $0.39. Multi-agent wint alleen op kosten wanneer de werknemers goedkoop zijn. Prompt caching (ongeveer 10% voor cache-leesbewerkingen bij Anthropic en OpenAI) geldt voor elke rij en vooral voor de werknemers, waarvan de prefix elk acht keer opnieuw wordt verzonden; de [prompt caching comparison](/compare/ai-prompt-caching-costs) bevat de tarieven. Simuleer je eigen verdeling in de [calculator](/calculator). DeepSeek-rijen gebruiken piektarieven; DeepSeek-prijzen gecontroleerd op 2026-10-27 via api-docs.deepseek.com. Haiku 5.5-rijen gebruiken het tarief voor prompts tot 100.000 tokens (gecontroleerd op 2026-11-03); geen enkele werknemeroproep komt hier ook maar in de buurt.

LangGraph, CrewAI, de OpenAI Agents SDK en de Claude Agent SDK zijn gratis te installeren en uit te voeren; hun leveranciers verkopen optionele hosting en observability, geprijsd op hun eigen pagina's. Wat elk framework je wel kost is scaffolding: rol- en doelsjablonen, instructies voor toolgebruik, overdrachtsbeschrijvingen en regels voor uitvoerformaat die aan elke modelaanroep worden voorgevoegd. In onze ervaring varieert dit van een paar honderd tokens per stap bij de dunnere SDK's tot een paar duizend bij de meer uitgesprokene, en het wordt opnieuw verzonden bij elke stap van elke agent.

Meet het eenmalig met de token teller van de leverancier, met en zonder het standaardprompt van het framework, en overschrijf het sjabloon als het zwaarder weegt dan het jouwe. Dezelfde meting is van toepassing op MCP-tool lijsten, behandeld in [MCP server token cost](/guides/mcp-server-token-cost).

Met de OpenAI Agents SDK heeft elke Agent zijn eigen model, zodat de planner en workers onafhankelijk worden geprijsd en de worker wordt blootgesteld aan de planner als een tool:

from agents import Agent, Runner, function_tool

@function_tool
def fetch_pricing_page(url: str) -> str:
    return http_get(url)[:6000]          # cap the result: ~1,500 tokens

worker = Agent(
    name=\"researcher\", model=\"gpt-5.4-mini\",            # $0.75 / $4.50 per 1M
    instructions=\"Answer one sub-question with the tool. Max 300 words, no preamble.\",
    tools=[fetch_pricing_page],
)
planner = Agent(
    name=\"planner\", model=\"gpt-5.5\",                    # $5 / $30 per 1M
    instructions=\"Split the task into at most 3 sub-questions, delegate, then write the recommendation.\",
    tools=[worker.as_tool(tool_name=\"research\", tool_description=\"Research one sub-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)
# planner cost = planner_in * 5 / 1e6 + planner_out * 30 / 1e6; workers log their own

In LangGraph geef je elk node zijn eigen modelclient; in CrewAI stel je llm per agent in. Zie [OpenAI Agents API cost](/guides/openai-agents-api-cost) voor hoe de SDK het gebruik rapporteert.

Multi-agentsystemen falen duur omdat een verwarde worker kan blijven herhalen terwijl de manager wacht. Pas de guardrails per agent toe, niet alleen per run:

• max_tokens bij elke aanroep, en een uitvoerwoordlimiet in de instructies van elke worker
• max_turns (of het framework-equivalent) op elke worker, typisch 8 tot 12, en op de manager, typisch 6 tot 10
• Een stopconditie die elke worker kan activeren: een report-tool die zijn lus beëindigt
• Een dollar budget per run, opgeteld uit de gebruikersvelden van elke agent, waarbij de manager afbreekt wanneer het wordt overschreden

Het artikel [token budget guardrails](/guides/ai-agent-token-budget-guardrails) heeft een runner die je om elk node kunt wikkelen. Voor nachtelijke fan-out waar latentie er niet toe doet, is de Batch API met ongeveer 50% korting van toepassing op workers net zo gemakkelijk als op enkele aanroepen; zie [batch API pricing compared](/compare/llm-batch-api-pricing).