Anthropic measured it: multi-agent systems burn roughly 15x more tokens than a normal chat interaction, against about 4x for a single agent (Anthropic engineering). That one number should sit at the top of every "agentic AI roadmap" deck, and it almost never does. Every agent you add multiplies inference cost, adds a failure surface, and inserts a handoff where context can leak. Sometimes that trade is worth it. Usually it is not.
We build AI systems for clients, and the most common correction we make to inbound briefs in 2026 is subtraction: the five-agent "org chart" becomes one well-tooled agent plus two plain functions. This post explains what multi-agent orchestration actually is, what it costs in dollars and latency, which patterns survive production versus conference demos, and a decision checklist for when to split. It is not an argument that multi-agent is fake; we ship multi-agent systems where the workload earns them, and we will show you exactly which workloads those are.
What multi-agent orchestration actually is
An agent is a model in a loop: it reads a goal, calls tools, observes results, and repeats until done. A multi-agent system is several of those loops with a coordination scheme. Strip away the vendor vocabulary and there are three working patterns:
- Planner and workers (orchestrator-worker). A lead agent decomposes the task and delegates sub-tasks to worker agents, often running in parallel, then synthesizes their reports. This is the architecture behind Anthropic's research system, where a lead model coordinating parallel subagents beat a single-agent setup by 90.2% on their internal research eval (Anthropic).
- Guardian and QA agents. A second agent with fresh context reviews the first agent's output against a spec: checking a generated contract clause, verifying extracted figures against source documents, grading a draft against a rubric. Independence is the point; a model grading its own work inherits its own blind spots.
- Handoffs. One agent transfers the conversation and its state to a specialist: billing agent to refunds agent, triage agent to human. Handoffs are the pattern most likely to fail quietly, because whatever context does not survive the transfer is simply gone, and the second agent does not know what it does not know.
What multi-agent is not: a pipeline. If your "agents" always run in the same order with predictable inputs and outputs, you have a workflow, and workflows should be plain code with an LLM call at the steps that need judgment. Code is cheaper, faster, and testable. We cover that boundary in more depth in our guide to AI agents for business that actually work.
The numbers the demos leave out
Three data points frame every multi-agent decision we make with clients:
- Token multiplication. Anthropic's production telemetry: agents use ~4x the tokens of chat; multi-agent systems ~15x. Their own conclusion is that the architecture only makes economic sense for tasks "valuable enough to pay for the increased performance" (Anthropic).
- The reliability counter-argument. Cognition, the team behind the Devin coding agent, published "Don't Build Multi-Agents" and it aged well: parallel subagents that cannot see each other's decisions make conflicting assumptions, and the coordinator cannot reconcile them. Their principles, share full context and never let parallel agents make conflicting implicit decisions, explain most multi-agent failures we get called in to fix (Cognition).
- The market reality. Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027, citing escalating costs, unclear business value, and inadequate risk controls (Gartner). Most of the canceled projects will have been architected for the demo, not the economics.
The cost math in dollars
Current frontier pricing makes the multiplier concrete. A Sonnet-class model runs $3 per million input tokens and $15 per million output; an Opus-class model $5 and $25 (Anthropic pricing). A single-agent customer query consuming 20k input and 2k output tokens costs about $0.09 on the Sonnet tier. The same query through a five-agent pipeline at the 15x multiplier costs roughly $1.35, and arrives later, because handoffs serialize what a single context window handles in one pass. At 10,000 queries a month that is the difference between $900 and $13,500 in inference alone, before you count the extra engineering to build and monitor five loops instead of one.
Latency compounds the same way. Parallelism can offset it, Anthropic reports up to 90% faster research when subagents fan out concurrently, but only when the sub-tasks are genuinely independent. Sequential handoffs just stack round trips.
Production patterns vs conference-demo patterns
| Pattern | Demo version | Production version | Verdict |
|---|---|---|---|
| Role-play org chart | "CEO agent" briefs "engineer agent" who reports to "QA agent" | Does not exist; roles collapse into one agent with tools | Skip |
| Planner + parallel workers | Agents debate each other for minutes | Lead agent fans out read-only research, synthesizes results | Ship, for research-shaped work |
| Guardian / QA agent | "Reflection" loops where a model critiques itself | Independent checker with fresh context and a written rubric | Ship, where errors are expensive |
| Handoff chains | Five specialists passing a ticket along | One agent, plus escalation to a human | Usually skip |
| Agent-as-router | An LLM deciding which agent handles each request | A 20-line classifier or rules function | Replace with code |
The pattern behind the pattern: multi-agent earns its cost when sub-tasks are parallel, independent, and bigger than one context window. It fails when agents need to share fine-grained state, which is why coding, the most demoed use case, is where Cognition argues single-threaded agents win.
The decision checklist: start with one, split when forced
Our default on client work is one agent with good tools, and we split only when the workload proves it needs splitting. Before adding a second agent, give the first one better tools: a search API, a database connection, a code interpreter. A well-tooled single agent covers the large majority of business automation.
Split into multiple agents when at least one of these is true:
- The task exceeds one context window. Reviewing 400 supplier contracts or researching 30 competitors will not fit in one loop, no matter how large the window. Fan out workers, return summaries.
- Sub-tasks are genuinely parallel and independent. If worker B needs worker A's decisions to do its job, do not parallelize; you will merge conflicting assumptions at the end.
- Verification must be independent. Compliance checks, financial figures, anything where "the model reviewed itself" fails an audit. A separate QA agent with fresh context and a rubric is cheap insurance.
- Permissions or compliance boundaries require separation. An agent that reads HR data and an agent that emails externally should not be the same process with the same credentials.
- The task's value survives 10x to 15x the inference cost. If a run is worth $50 to the business, $1.50 of tokens is fine. If a run is worth $0.30, it is not.
If none of the five apply, the multi-agent version of your project is over-engineering, and you should spend the difference on evals and better tools instead. That single decision is worth more than any framework choice; the orchestration layer itself is a solved problem in every major stack, as we outline in our AI-powered SaaS architecture guide.
Three business use cases with realistic costs
1. Customer support: one agent, not a swarm
Support is the most mature agent market and the pricing proves the single-agent point. Intercom's Fin charges $0.99 per resolved conversation; Decagon's enterprise deployments land around $0.50–$1.50 per resolution (Fin pricing comparison; Superkind). These products are, architecturally, one agent with retrieval and a handful of actions. Nobody selling per-resolution can afford a 15x token multiplier.
Realistic numbers: buy at $0.50–$1.50 per resolution, or commission a custom single agent at $15k–$50k when you need deep integration with proprietary systems, with token costs typically $0.03–$0.10 per conversation. A multi-agent build here roughly triples the budget for accuracy gains measured in single percentage points.
2. Research and due diligence: multi-agent, and worth it
Vendor risk assessments, market scans, competitor monitoring, deal screening: the work is parallel (many sources), independent (source A does not change how you read source B), and larger than any context window. This is the one workload where the orchestrator-worker pattern reliably beats a single agent, and where a 90% wall-clock reduction from parallel fan-out matters to the people waiting on the report.
Realistic numbers: $40k–$120k to build a production system with sources, citations, and review workflow; token cost per deep-research run typically $0.50–$5.00 at the 15x multiplier. The economics work because the run replaces analyst hours billed at $50 to $150 each, not because the tokens are cheap.
3. Document-heavy back office: neither, use a workflow
Invoice intake, claims triage, KYC document checks. Briefs for these arrive labeled "multi-agent" more than any other, and they are almost never agent-shaped: the steps are fixed, the inputs are predictable, and nothing needs to decide anything mid-flight. The right build is a pipeline in plain code with one or two LLM calls (extraction, judgment on the ambiguous 10%) and a single QA check where errors cost money.
Realistic numbers: $10k–$40k to build, and per-document costs of a cent or less, often 50x cheaper than the agentic version of the same system, with the bonus that deterministic pipelines can be tested like normal software. A full cost model for all three shapes, including the run costs that dominate after launch, is in our AI agent development cost breakdown.
Frequently asked questions
What is a multi-agent AI system?
A system where several LLM agents, each a model running in its own loop with its own tools and context, coordinate on one task. The common production patterns are a planner delegating to parallel workers, an independent QA agent verifying another agent's output, and handoffs between specialists. If the steps always run in a fixed order, it is a workflow, not a multi-agent system, and should mostly be plain code.
How much more does a multi-agent system cost than a single agent?
Anthropic's production data puts multi-agent systems at roughly 15x the tokens of a chat interaction versus 4x for a single agent, so expect 3x to 4x the inference cost of a single-agent build, plus meaningfully higher engineering and monitoring cost. On current pricing that turns a $0.09 query into roughly $1.35. The multiplier is justified when a run replaces hours of skilled work, and unjustifiable for high-volume, low-value requests.
When should a business use multiple AI agents instead of one?
When the task exceeds one context window, when sub-tasks are genuinely parallel and independent, when verification must be independent of the producer, when permission boundaries require separate processes, or when the value per run comfortably absorbs 10x to 15x token costs. Research and due diligence workloads usually qualify. Support, coding assistants, and back-office pipelines usually do not.
Are multi-agent frameworks like CrewAI or LangGraph necessary?
No. The orchestration itself is a few hundred lines in any stack, and the hard problems, context sharing, evals, cost control, live outside the framework. Frameworks speed up prototypes; in production the teams we see succeed keep orchestration thin and spend the effort on tools, specs, and evaluation instead. Pick the framework your team can debug at 2 a.m., or skip one entirely.
Why do so many agentic AI projects fail?
Gartner expects over 40% of agentic AI projects to be canceled by end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. In our experience the root cause is architectural: teams build the multi-agent demo first and discover the economics later. Projects that start with one agent, a measurable success metric, and an eval suite rarely end up in that 40%.
Key takeaways
- Multi-agent systems consume ~15x the tokens of chat; a single agent ~4x. Price your use case against that multiplier before designing anything.
- Start with one agent and better tools. Split only for context-window limits, true parallelism, independent verification, or permission boundaries.
- Fixed-order steps are a workflow, not agents. Plain code with two LLM calls beats five loops for most back-office automation.
- Research-shaped work is where multi-agent genuinely wins: parallel, independent, bigger than one context, high value per run.
- Handoffs and role-play org charts are demo patterns. Shared context and independent QA are production patterns.
- Budget anchors: single support agent $15k–$50k, multi-agent research system $40k–$120k, document pipeline $10k–$40k, run costs from $0.03 to $5.00 per task.
Get a swarm-free second opinion
If you are weighing an agent build, or a vendor has quoted you a five-agent architecture and you want it sanity checked, describe the workload to us and we will map it to one of the three shapes above with a cost range attached. If one agent does it, we will say so, and quote you the smaller number; that is the whole point of our AI development practice. We would rather build you the system that survives 2027 than the one that demos well in 2026.