How it works
Coordination cost is the tax on every boundary you draw between agents. A single agent working in one context carries its own state: what it read, what it decided, what it already tried. The moment you split that work across two agents, none of that state crosses for free. Each handoff forces the system to do extra work:
- Serialize. The sending agent compresses its live context into a message—a summary, a plan, a partial result. Nuance is dropped here.
- Transmit and interpret. The receiving agent reads that message cold, with no memory of how it was produced, and reconstructs intent.
- Re-ground. The receiver often re-fetches files, re-runs searches, or re-derives facts the sender already had, because the summary omitted them.
- Reconcile. When agents work in parallel, their outputs must be merged, and divergent assumptions surface as conflicts that something—usually an orchestrator—has to resolve.
Each step is lossy and each is repeated per boundary. Cost scales with the number of handoffs and the number of agents that must agree, not with the size of the task. Two agents that must stay in sync can cost more than one agent doing both jobs sequentially, because the sequential agent never pays the serialize/re-ground/reconcile tax at all.
Why it matters in an agent harness
Coordination cost is the hidden term in every multi-agent design, and it shows up as concrete failure, not abstract overhead. Latency rises because handoffs serialize; an orchestrator waiting on three workers moves at the speed of the slowest plus the merge. Token spend rises because re-grounding means the same file is read three times by three contexts. Correctness degrades in a quieter way: a fact that was clear in the sender's context arrives as a lossy summary, the receiver fills the gap with a plausible guess, and that guess propagates downstream where no one can trace it back. This is how coordination cost turns into silent divergence.
It also erodes the properties a harness exists to protect. Observability gets harder because the real reasoning lived in a context that was thrown away at the boundary; your logs show the summary, not the decision. Reversibility gets harder because two agents may have committed conflicting side effects before the conflict was detected, so a clean rollback no longer exists. And containment gets harder: an error introduced at one boundary is now laundered through a summary and treated as ground truth by the next agent. The practical rule is that every boundary you add is a place where control, legibility, and recoverability leak. You add boundaries anyway when the work genuinely parallelizes or when isolation is worth more than the tax—but you should know you are paying.
Coordination cost vs context cost
The real tradeoff is not "multi-agent good, single-agent bad." It is which overhead you would rather pay.
| Single agent, one context | Multi-agent, many contexts | |
|---|---|---|
| Dominant overhead | Context window fills; needs compaction | Handoffs lose state; needs reconciliation |
| Failure mode | Forgets earlier detail as it truncates | Misreads a peer's summary, diverges |
| Parallelism | None—work is serial | Real, if subtasks are independent |
| Traceability | High—one continuous trajectory | Low—reasoning discarded at each boundary |
A single agent pays a context cost that grows with task length and is fought with [[context-compaction]]. A multi-agent system pays a coordination cost that grows with the number of boundaries. Choose the architecture whose overhead is cheaper for your task, then engineer against that specific tax.
The Rifty take
We treat every agent boundary as a liability that has to earn its place. We optimize for the fewest agents that can do the work, and we reach for parallelism only when subtasks are genuinely independent and the isolation buys us containment we actually need. The tradeoff we accept is less theoretical parallelism in exchange for a legible, reversible trajectory—a single thread we can read and undo beats three threads we have to reconcile after the fact.
Common failure modes
- Boundary sprawl. Splitting one coherent task across agents that all need the same context—you pay the tax with no parallelism to show for it.
- Lossy summaries as ground truth. A receiver treats a peer's compressed handoff as fact and never re-verifies, so early errors propagate unchecked.
- Silent divergence. Parallel agents build on conflicting assumptions and the conflict only surfaces at merge, when it is expensive to unwind.
- Re-grounding thrash. Multiple agents independently re-read the same files and re-run the same searches, inflating latency and token spend.
- Untraceable decisions. The reasoning that mattered lived in a context discarded at the boundary; your logs hold the summary, not the why.
- Unrecoverable side effects. Agents commit real actions before reconciliation, so no clean rollback point exists.
Frequently asked questions
When is the coordination cost of a multi-agent system worth paying?
Pay it when subtasks are genuinely independent, so parallelism is real, or when isolation buys containment you need—keeping a risky operation in its own sandbox. If agents must constantly re-sync shared state, the tax usually exceeds the benefit and a single agent is cheaper and more legible.
How is coordination cost different from context window limits?
Context limits are a single agent's overhead: as a task grows, its context fills and detail truncates. Coordination cost is a multi-agent overhead: state is lost crossing agent boundaries. One scales with task length and is fought with compaction; the other scales with the number of handoffs.
Why do 'teams of agents' often perform worse than one agent?
Because coordination cost compounds. Each boundary forces serialize, re-ground, and reconcile work that a single continuous context never pays. Lossy summaries become ground truth, agents diverge on hidden assumptions, and the same files get read repeatedly—so added agents can add latency, token spend, and error without adding real throughput.
How do I reduce coordination cost without giving up parallelism?
Draw boundaries only where subtasks are truly independent, so agents don't need to re-sync. Pass explicit, verifiable state instead of prose summaries, and have receivers re-check facts rather than trusting them. Minimize the number of agents that must agree, since reconciliation cost rises with the size of the consensus set.
How does coordination cost affect reversibility and observability?
It degrades both. The reasoning that mattered often lived in a context discarded at the boundary, so logs show summaries, not decisions. And parallel agents may commit conflicting side effects before conflicts surface, so a clean rollback point no longer exists. Fewer boundaries keep trajectories legible and recoverable.