A single agent with a context bloat problem is expensive in a way that's at least traceable as it represents just one pipeline, one set of tokens, and one place to look.
Multi-agent systems break that traceability. Once an agent starts delegating to others, planning to a sub-agent, handing off to a specialist agent, calling a critic agent to check its own work, the cost accounting problem stops being about one workflow's token spend and becomes about coordination overhead nobody assigned to a line item.
We call this the multi-agent tax, which is the cost of agents talking to other agents, on top of the cost of any of them doing actual work. It's one of the fastest-growing and least-visible categories of agentic AI spend, and almost nobody is tracking it as its own number.
What Is the Multi-Agent Tax in Agentic AI Systems?
The multi-agent tax is the token and compute cost consumed by coordination between agents rather than by the underlying task itself: a planning agent breaking down a request, a specialist agent executing a subtask, a critic or reviewer agent checking the output, and the handoffs between all three. None of that coordination is wasted in the sense of being pointless, multi-agent architectures exist because splitting work this way often produces better results. But coordination isn't free, and unlike a single agent's token spend, it doesn't show up as a clean line item anywhere, because it's distributed across every hop in the chain.
Why Does Orchestration Overhead Get Bigger as You Add Agents?
Every additional agent in a workflow adds at least one more context handoff, and each handoff typically means re-sending relevant context to the next agent, since agents generally don't share memory automatically. A three-agent pipeline, planner, executor, reviewer, means the task's context gets reconstructed or re-passed at least twice beyond the initial request. Add a fourth agent for a specialized subtask and that number grows again. This scales roughly with the number of handoffs, not the number of agents, which means the tax grows faster than the architecture diagram would suggest, especially once a workflow starts branching into parallel sub-agents that each need their own context.
How Does Context Get Duplicated Across a Multi-Agent System?
This connects directly to the context bloat problem from a single-agent pipeline, except multiplied across agents that don't share state. If a planning agent retrieves relevant documents to build a plan, and then passes that plan plus the original context to an executor agent, and the executor calls a tool and passes its result plus everything before it to a reviewer agent, the same underlying information can end up duplicated in the context window of every agent in the chain. Each agent pays token cost for context it may only partially need, and because no single agent's cost looks abnormal in isolation, the duplication is invisible unless someone adds up token spend across the entire chain rather than per agent.
What's the Coordination Cost of Agents Calling Agents?
Beyond duplicated context, there's a second cost: the coordination messages themselves, an agent describing what it did and why to the next agent in the chain, formatted in a way the next agent can parse and act on. This overhead exists even when the underlying task is simple, because the coordination protocol between agents has its own token cost independent of task complexity. A workflow that could be handled by one agent in 2,000 tokens might cost 8,000 or more tokens once split across three coordinating agents, not because the task got harder, but because coordination itself has a price that scales with the number of participants.
How Do You Measure and Reduce the Multi-Agent Tax?
Measuring this requires tracking cost at the level of the whole task across every agent involved, not per agent, since a per-agent view will make every individual agent look reasonably efficient while the aggregate cost tells a different story. Once that visibility exists, the reduction levers echo the context bloat fixes from a single-agent system, but applied across the handoff points: pass only the context each downstream agent actually needs rather than the full history, standardize a compact coordination format instead of verbose natural-language handoffs, and question whether every additional agent in the chain is earning its coordination cost or whether a simpler, single-agent version of the workflow would resolve the task just as well for meaningfully less.
Not every multi-agent architecture is over-engineered. Some tasks genuinely benefit from specialization and review. But the decision to add another agent to a chain should be made with the coordination cost in view, not just the marginal capability the new agent adds, because that coordination cost compounds with every hop.
The Takeaway
The multi-agent tax is invisible by construction: it's distributed across every handoff in a chain, and no single agent's cost looks unusual on its own. The only way to see it is to measure cost at the level of the full task across every agent involved, not agent by agent. Once that number is visible, the same discipline that fixes context bloat in a single pipeline, only passing what's needed, cutting duplicated context, applies across every handoff in a multi-agent system, just with more places it needs to be applied.
