A first-principles model of multi-agent systems as a complex system — why decomposition has a sweet spot, why a critical handoff fidelity decides whether coordination holds or melts, and why the lever is the interface, not the headcount

Brian James Curry · Vector1 Research Fifth in a series. The first four modeled the layer around a single model; this one models the layer between models.

“Adding manpower to a late software project makes it later.” — Brooks’s Law (1975), rediscovered every year since, now by machines.

Abstract

In June 2025 the field had its loudest architecture fight to date. Anthropic reported that an orchestrator-with-subagents design beat a single agent by roughly 90% on breadth-first research; one day earlier, Cognition published a piece titled Don’t Build Multi-Agents, arguing that parallel sub-agents are inherently fragile because isolated context produces conflicting decisions and compounding errors. Both are right — which means the interesting question is not whether to decompose a task across agents but when, and how far. This installment answers that with a model.

I treat a multi-agent pipeline as a complex system with two opposing forces: decomposition raises reliability because a single agent’s accuracy decays super-linearly with the number of steps it must chain, so shorter sub-chains are disproportionately more reliable; but every handoff between agents is a failure point, and handoff penalties compound. The product peaks at an interior optimum I call the coordination threshold, N* = L·[α(γ−1)/ln(1/h)]^(1/γ). The model produces a three-regime phase diagram — solo, pipeline, cascade — and a genuine phase transition: below a critical handoff fidelity h_c(L), no decomposition reaches deployable reliability, and coordination melts. The contrarian result, in the series' usual grammar: the lever is handoff fidelity — the quality of the interface between agents — not their number or their raw capability. Independent agreement is striking: the largest empirical study of multi-agent failures finds that coordination and specification problems, not model weakness, account for the majority of breakdowns. The closed form matches a direct Monte Carlo simulation of the pipeline to within Monte Carlo error.

1. The argument everyone is having

The multi-agent debate is unusually well-documented because two credible labs staked out opposite ground in the same week. Anthropic’s research system uses a lead agent that plans and spawns parallel subagents, each with its own context window, and on breadth-first research tasks it outperformed a strong single agent by about 90% — at a cost of roughly fifteen times the tokens of an ordinary chat. Cognition’s counter-argument was that the moment you let sub-agents act in parallel without shared context, they make locally reasonable but globally incompatible decisions, and the errors compound into unusable output; their prescription was a single, linear agent.

The reconciliation that the community settled on is the right starting point: it depends on the task. Multi-agent decomposition wins when sub-tasks are genuinely independent and can be explored in parallel; it loses when the work is tightly coupled, where shared context and many dependencies make every handoff a chance to diverge. But “it depends” is not a model. It does not tell you how many agents, or where the line between pipeline and cascade actually falls.

And the stakes of getting it wrong are now measured. The largest empirical study of the question — a 2025 taxonomy built from more than 1,600 annotated execution traces across seven multi-agent frameworks — found multi-agent systems failing at rates between roughly 40% and 87%, and sorted the 14 distinct failure modes into three buckets: specification problems, inter-agent misalignment, and verification gaps. Specification and coordination failures together accounted for the clear majority of breakdowns. The authors’ sharpest conclusion is the one this whole series has been circling: improving the base model will not fix most of these failures, because they live in the coordination, not the cognition. That is the empirical shadow of the model I’m about to build.

2. Two forces, one tension

Engineers have modeled exactly this shape twice before, in other domains, and both precedents are worth holding in mind. Amdahl’s Law (1967) showed that the speedup from parallelizing a computation is capped by its irreducibly serial fraction — throw cores at a problem and coordination overhead eventually dominates. Brooks’s Mythical Man-Month (1975) made the human version famous: communication channels grow combinatorially with team size, so adding people to a late project can make it later. A multi-agent system is the same physics with LLMs in the nodes. The question is where its optimum sits.

Two forces pull against each other.

The benefit of decomposition is real and quantifiable. A single agent’s reliability does not merely fall linearly as a task lengthens; it falls super-linearly. Long contexts corrupt state, errors accumulate across more steps, and recent work measuring agents across tens of thousands of episodes confirms reliability degrades faster than the task grows — a finding echoed by the result that long context alone degrades performance even with perfect retrieval. Splitting a task into shorter sub-chains is therefore disproportionately rewarding: each agent does less, and does its less far more reliably.

The cost of decomposition is equally real. Every boundary between two agents is an interface across which intent, state, and partial results must pass — and each such handoff can drop or distort information. The MAST taxonomy’s “inter-agent misalignment” category is exactly this failure, observed in the wild. More agents means more handoffs, and the survival probability of the whole chain falls geometrically in their number.

Decomposition buys reliability and spends it at the same time. The optimum is where the next agent’s benefit equals its handoff cost.

3. A model of the coordination threshold

Make it precise. A task is a chain of L atomic steps. Split it across N agents in series, so each handles L/N steps. Model a single agent's probability of completing an m-step sub-chain as decaying super-linearly in m:

Per-agent success. The exponent γ > 1 is the super-linearity of failure: doubling an agent’s workload more than doubles its log-failure. This is the empirical regularity that makes decomposition worth doing at all.

End-to-end success requires every agent to succeed and every one of the N−1 handoffs to survive, each with fidelity h. Because the agents are in series, probabilities multiply:

End-to-end reliability. The first factor rises toward 1 as N grows (shorter sub-chains tame the super-linear decay); the second falls geometrically (more handoffs, more exposure). The whole game is the product.

Notice what the work factor does: [exp(−α(L/N)^γ)]^N = exp(−αL^γN^(1−γ)), and since γ > 1, the exponent shrinks toward zero as N grows. Decomposition cannot make the work harder; it can only ever help. So if handoffs were free (h = 1), you would decompose without limit. Handoffs are not free, and that single fact creates everything interesting.

4. The sweet spot

Take logs and the tension separates into two clean terms:

The decomposition benefit (rising, but with diminishing returns) versus the handoff penalty (strictly linear in the number of agents). Their sum has a maximum.

A 64-step task with super-linear decay (γ = 1.4), agents that solo the whole thing 40% of the time, and 97%-reliable handoffs. The benefit curve climbs and saturates; the handoff curve decays; their product peaks at six agents, lifting end-to-end reliability from 40% to 55%. Push past the optimum and you fall off the cliff: at one agent per step the chain cascades to about 12%. More agents is not more reliable. It is, eventually, catastrophically less.

This is the same shape as the over-testing wall from the evaluation installment and the heavy-tailed supervision frontier from the autonomy one. A productive interior optimum, flanked by a region where the industry’s instinct — here, “add more agents” — actively destroys value. The cascade is not a tail risk; it is the default destination of naive decomposition.

5. The threshold, in closed form

Set the marginal benefit of the (N+1)-th agent equal to its marginal handoff cost:

Decompose until the reliability one more split buys equals the handoff penalty it adds.

This solves in closed form — and unlike the evaluation bound, it needs no special functions, only a root:

The coordination threshold: the optimal number of agents. It scales linearly with task length L (longer tasks justify more decomposition) and is governed, through the denominator, by handoff fidelity.

The structure is the message. Near the regime that matters — good but imperfect handoffs — ln(1/h) ≈ 1−h, so the optimum behaves as:

The usable team size scales as the inverse handoff-failure rate raised to 1/γ. Halve your handoff failure rate and the chain you can profitably run grows by a factor of 2^(1/γ) — and, more importantly, the reliability ceiling rises with it.

Capability — better, cheaper agents — enters only through α and γ, the per-step difficulty. It shifts the curve. But the shape of the trade, and the wall on the far side of the optimum, are set by h. You cannot make a low-fidelity architecture safe by swapping in a smarter model; you can only change where it cascades.

6. Three regimes

Because N* and the achievable reliability depend on just two numbers — handoff fidelity h and task horizon L — the entire design space fits on one diagram.

The whole landscape of “should I use multiple agents?” Three regimes, separated by where the optimum falls and whether it clears a deployability threshold θ.

Solo (one agent, start to finish). When the task is short or handoffs are unreliable, the optimum is a single agent. Decomposition’s benefit is too small to pay the handoff tax. This is Cognition’s regime, and for tightly coupled work like most coding — where every step depends on shared, evolving context, i.e. where effective h is low — it is the correct one.

Pipeline (decompose into N* agents). The productive middle, where a finite, computable team size beats both the solo agent and the over-decomposed swarm. The closed form tells you exactly how many agents to use. Notice the region widens as h improves: high-fidelity interfaces let you decompose longer tasks profitably.

Cascade (sub-critical). The high-horizon, low-fidelity corner where no number of agents reaches deployable reliability. Here the lesson is not “add agents” — every choice fails — but that the system is mis-architected for its fidelity. The fix is to raise h: cleaner contracts between agents, schema-checked handoffs, explicit shared state, verification at the seams. The red boundary is the critical curve h_c(L), and it climbs steeply: a 64-step task needs about 95% handoff fidelity to be coordinatable at all; a 128-step task needs better than 99%.

7. The lever: fidelity, not headcount

Here is the result that should reorganize how teams build. The number of agents has an optimum and a cliff; the handoff fidelity has neither — it monotonically raises the entire reliability curve and the height of its peak.

The same task at five handoff fidelities. At 99.5% fidelity the optimum sits near twenty agents and clears the deployability line comfortably. At 92% the peak never reaches it: no team size is good enough. The ceiling is set by the interface, and capability cannot buy its way past it.

This is why the MAST finding lands so hard. When the largest study of multi-agent failures attributes the majority of breakdowns to specification and coordination — and states plainly that better base models will not close the gap — it is reporting, empirically, that real systems are h-limited, not capability-limited. The field's reflex is to add agents (more parallelism, bigger swarms) or to wait for a stronger model. The model says the highest-leverage investment is almost always the unglamorous one: make the handoff better. Typed, validated interfaces between agents. Explicit contracts about what each agent receives and returns. Shared state where the work is coupled, rather than hoping isolated contexts reconcile. Verification at the boundaries, not just the ends. Every point of handoff fidelity you recover raises the ceiling for every team size at once.

The phase diagram and the lever together also explain the June 2025 debate without contradiction. Anthropic’s research tasks are breadth-first and decomposable — near-independent subqueries, so effective h is high and shared state is thin; that lives deep in the pipeline regime, where decomposition wins by 90%. Cognition's coding tasks are tightly coupled — high implicit dependency, low effective h; that sits in the solo regime, where a single linear agent is correctly optimal. Same model, two regimes, no disagreement.

8. A phase transition in coordination

Why call this a complex system and not just an optimization? Because the achievable reliability behaves like an order parameter undergoing a transition as you tune a control parameter.

Maximum achievable reliability (optimized over team size) as handoff fidelity rises. For a long task it stays pinned below the deployability threshold across a wide range of fidelity, then climbs sharply through a critical value h_c, above which coordination suddenly “holds.” Below h_c the system is sub-critical — no architecture rescues it. Above it, a pipeline becomes viable. The transition sharpens as tasks lengthen.

The critical fidelity is defined implicitly by the point where the best achievable reliability just touches the deployability bar:

The phase boundary. Solve for the handoff fidelity at which the optimized reliability equals the threshold θ, and you have the critical curve h_c(L) — the red boundary in the phase diagram.

This is the same mathematics that describes percolation and critical phenomena in physics: an order parameter that is effectively dead below a critical coupling and comes alive above it. The control parameter here is the fidelity of the coupling between agents. It tells you something the “it depends” consensus cannot: that there are tasks which are uncoordinatable at a given interface quality — not hard, not expensive, but impossible at any team size — and that the only way to move them into feasibility is to cross the critical fidelity. Coordination is not a dial you can always turn up by adding workers. It is a phase, and phases have boundaries.

9. Does the math hold?

I simulated the pipeline directly — drawing each agent’s success and each handoff’s survival as independent events with the model’s probabilities, over 400,000 trials per configuration — and compared realized end-to-end reliability against the closed form.

The closed-form optimum (N* = 5.91) matches the numerical maximizer to four decimals, the best integer team size is six, and the simulated reliabilities track the analytic curve to within a few ten-thousandths everywhere — including across the peak and down the cascade. The model is a calculator, not a metaphor.

10. What this means for how we build

Four working rules survive the algebra.

Count your handoffs before your agents. The first question about any multi-agent design is not “how many agents?” but “how reliable is each handoff, and how coupled is the work?” Those two numbers — h and the implicit dependency that lowers it — place you in solo, pipeline, or cascade, and that placement decides everything else.

There is a sweet spot, and past it lies a cliff. Decomposition has an optimum, N*, computable in closed form. Beyond it, every additional agent lowers end-to-end reliability, and naive "one agent per step" decomposition cascades toward zero. Bigger is not safer.

Spend on the interface, not the headcount or the model. Because fidelity raises the whole reliability curve while headcount has a cliff and capability only shifts the curve, the highest-return investment is typed, validated, contract-checked handoffs and shared state where work is coupled. This is the same lesson the series keeps finding: the leverage is in the coupling, not the component.

Respect the phase boundary. Some tasks are uncoordinatable at your current interface quality — not at any team size. When you are below h_c, stop adding agents and go raise fidelity, or keep the task whole. Pretending a sub-critical system is merely under-resourced is the most expensive mistake in the diagram.

Across five installments the thesis has not wavered. The causal layer makes agentic optimization trustworthy; the memory layer makes long horizons affordable; the autonomy layer decides when to let an agent act; the verification layer decides when to believe it; and now the coordination layer decides when many agents beat one. The model keeps getting better, and the leverage keeps moving to the layer around it — and, now, to the layer between the models. The bottleneck was never only the mind. It was always, also, the seams.

A note on what this model does not capture

The clean result rests on a series chain with a constant, independent handoff fidelity, and three real complications strain that. First, real multi-agent systems are rarely pure series; they are directed graphs with parallel branches and a merge — and parallel decomposition flips the reliability algebra (independent branches raise robustness rather than compounding failure), which means the next installment’s natural subject is the topology of coordination, not just its length. Second, h is not a constant: it falls as the work becomes more coupled and as agents share more implicit context, so the truly hard systems are those where decomposition itself lowers h — a feedback the static model only points at. Third, failures across agents are often correlated (a shared misreading of an ambiguous spec), which fattens the tail beyond the independent-Bernoulli assumption and, as in the evaluation piece, is where the convenient normal-world approximations break. Each is a direction the model recommends rather than resolves. A simple model earns its keep not by being complete but by telling you precisely which complication to model next — and here it points squarely at topology.

References

• Amdahl, G. (1967). Validity of the Single-Processor Approach to Achieving Large-Scale Computing Capabilities. AFIPS Conference Proceedings.
• Brooks, F. P. (1975). The Mythical Man-Month. Addison-Wesley.
• Stanley, H. E. (1971). Introduction to Phase Transitions and Critical Phenomena. Oxford.
• Barlow, R. E., & Proschan, F. (1975). Statistical Theory of Reliability and Life Testing. Holt, Rinehart and Winston.
• Cemri, M., Pan, M. Z., Yang, S., et al. (2025). Why Do Multi-Agent LLM Systems Fail? arXiv:2503.13657 (NeurIPS 2025); MAST taxonomy and MAST-Data.
• Anthropic (2025). How We Built Our Multi-Agent Research System. Anthropic Engineering, June 2025.
• Cognition / Yan, W. (2025). Don’t Build Multi-Agents. Cognition Blog, June 2025.
• Yao, S., et al. (2024). τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains. arXiv:2406.12045.
• Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents. (2026). arXiv:2603.29231.
• Context Length Alone Hurts LLM Performance Despite Perfect Retrieval. (2025). arXiv:2510.05381.
• Single-Agent LLMs Outperform Multi-Agent Systems Under Equal Thinking-Token Budgets. (2026). arXiv:2604.02460.

Code: sim5.py reproduces the closed-form coordination threshold, the numerical optimum, the critical-fidelity curve, and the Monte Carlo validation table. Drop it into a Gist where marked.

Brian James Curry is the founder of Vector1 Research, an independent lab working at the intersection of marketing economics, causal inference, cognitive AI systems, and the economics of intelligent automation. This is the fifth piece in a series modeling the layers around — and between — AI models. Reach him at brian@vector1.ai or vector1.ai.

Tags: #MultiAgent #AIAgents #ComplexSystems #AgentReliability #MLOps #Orchestration #DecisionTheory #Vector1 #AIArchitecture #AppliedResearch