The Coordination Problem: Why More AI Agents Doesn't Mean More Capability

A vendor demo runs eight agents and produces a polished report in ninety seconds. Your team adds eight agents to the internal copilot and p99 latency doubles while task success flatlines. The gap is not model quality — it is coordination. Every agent you add is another process that must agree on goal, state, permissions, and stopping conditions with the others. Without explicit coordination design, marginal capability gains shrink while overhead compounds. More agents is not a scaling lever; it is a tax schedule.

The coordination tax#

Think in terms of edges, not nodes. One agent with twelve tools has twelve tool interfaces to secure and test. Four agents with three tools each have four prompts, four context packers, six inter-agent handoffs (in a fully connected mesh), and merge logic on top. The tool count is similar. The coordination surface is not.

Each handoff costs:

• Serialization loss — nuance dropped when worker A's prose becomes worker B's input
• Latency — another model call, often sequential
• Ambiguity — two agents interpret "done" differently
• Side-effect risk — duplicate writes without single-writer discipline

Brooks's law applies uncomfortably well: adding agents to a late project makes it later. In AI systems, "late" means over budget, under eval, and fragile in prod.

Diminishing returns in practice#

Capability is sublinear in agent count when tasks are mostly sequential or share one context. A researcher agent followed by a writer agent followed by an editor agent sounds like specialization. Often it is three passes over the same facts with three chances to hallucinate inconsistently.

Measure capability per dollar and capability per second, not agent count. Run your golden task set at N=1, N=2, N=4 agents with matched total token budgets. You will often see a curve like this:

Numbers vary by domain. The shape repeats: a modest lift, then a plateau, then quality drops as merge noise and conflicting sub-goals dominate. Teams celebrate the 4.3 row and ship the 4.2 row because the diagram looked impressive in the pitch deck.

Why "more agents = more power" persists#

Three narratives keep the myth alive:

Specialization fantasy. Human teams have roles, so agent teams should too. Humans share institutional context, career incentives, and synchronous whiteboards. Agents share a token budget and whatever you remembered to paste. Role labels in prompts do not create true skill isolation unless backed by different tools, corpora, and evals.

Demo selection bias. Parallel fan-out over independent subtasks looks brilliant on stage — summarize ten PDFs at once. Your production ticket flow is not ten independent PDFs. It is one customer thread with entangled policy constraints.

Failure to attribute. When the eight-agent system underperforms, teams swap models instead of removing agents. Model upgrades mask coordination debt briefly, then the curve returns.

Coordination primitives that actually help#

You do not eliminate coordination overhead. You budget it and structure it.

Single writer per resource. Only one agent (or one orchestrated phase) may mutate a given ticket, row, or file. Others read replicas or structured summaries.

Typed handoffs, not prose relay. Worker output is JSON with required fields. The orchestrator rejects incomplete artifacts instead of forwarding vague paragraphs.

Global step and token ceilings. Include inter-agent turns in the budget. A system that allows each of five agents ten steps behaves like fifty steps of chaos.

Idempotency on external effects. Coordination failures retry. Retries duplicate without keys.

Explicit merge function. Average-of-drafts is not a merge. Pick a schema: latest wins, highest-confidence wins, human queue, or rule-based tie-break.

from dataclasses import dataclass

@dataclass
class CoordinationBudget:
    max_agent_steps: int
    max_handoffs: int
    max_tokens: int

    steps_used: int = 0
    handoffs_used: int = 0
    tokens_used: int = 0

    def charge(self, *, steps: int = 0, handoffs: int = 0, tokens: int = 0) -> None:
        self.steps_used += steps
        self.handoffs_used += handoffs
        self.tokens_used += tokens
        if (
            self.steps_used > self.max_agent_steps
            or self.handoffs_used > self.max_handoffs
            or self.tokens_used > self.max_tokens
        ):
            raise RuntimeError("coordination budget exhausted")

def run_with_budget(orchestrator, goal: str, budget: CoordinationBudget):
    # orchestrator must call budget.charge on every agent invocation and handoff
    return orchestrator.run(goal, budget=budget)

If your framework does not expose coordination spend separately from model spend, you cannot optimize it.

When additional agents still pay off#

Adding agents is rational when the coordination graph is sparse and constraints are real:

• Hard permission boundaries — billing vs support vs legal; splitting reduces blast radius more than it adds handoffs
• Embarrassingly parallel subtasks — disjoint documents, independent locales, separate customer accounts
• Different model tiers — small fast classifier routes to large reasoner only on hard cases; two agents, one hop, clear contract
• Isolation for untrusted input — a sandbox agent processes raw web content; a privileged agent never sees the HTML, only extracted claims

In each case, you can draw a small graph — usually star topology, not full mesh — and name the merge rule.

Anti-patterns that burn capability#

Committee without a chair. Peers with equal tool access and no orchestrator duplicate searches, contradict each other, and double-post.

Specialists that share one prompt. Four agents with identical system instructions and tools are four copies of the same failure mode.

Unbounded critique loops. Writer and critic agents ping-pong until the user leaves. Cap rounds; require structured diffs, not rhetorical feedback.

Implicit shared memory. A growing scratchpad every agent appends to becomes stale, toxic, and expensive. Summarize into the job document or drop.

Merge by concatenation. Stacking agent outputs increases tokens and contradictions without increasing truth.

Evaluating coordination, not just output quality#

Extend your eval harness:

• Handoff completeness — did downstream agents receive all required fields?
• Redundant work index — count duplicate tool calls across agents on the same task
• Convergence rate — for collaborative sub-phases, what fraction finish within round budget?
• Blame traceability — one ID, one ordered event list, no orphan writes

Regression-test coordination schema changes the way you test API versions. A breaking handoff is a breaking contract.

A sane scaling rule#

Before agent N+1 ships, document:

1. What constraint agent N cannot satisfy alone (permission, corpus, parallelism — not vibes)
2. The handoff schema between N and N+1
3. The merge rule when their outputs conflict
4. Expected marginal lift on golden tasks and acceptable cost/latency delta

If you cannot fill those four lines, you are not scaling capability. You are scaling headcount in the prompt.

interface AgentSplitJustification {
  constraint: "permissions" | "corpus" | "parallelism" | "model_tier";
  handoffSchemaId: string;
  mergeRule: "orchestrator_pick" | "schema_validate" | "human_queue";
  expectedQualityDelta: number; // from eval, not forecast
  maxExtraLatencyMs: number;
}

function approveNewAgent(j: AgentSplitJustification): boolean {
  return (
    j.expectedQualityDelta > 0 &&
    j.handoffSchemaId.length > 0 &&
    j.mergeRule !== undefined
  );
}

Make the justification a code-reviewed artifact, not a Slack thread.

Summary#

Agent count drives coordination overhead superlinearly while capability gains taper quickly without structure. The fix is not fewer agents at all costs — it is explicit budgets, typed handoffs, single-writer rules, and evals that measure coordination failure. Scale agents when the graph stays sparse and constraints are real; refuse the demo topology when your workload is one intertwined thread and merge noise will eat the lift.