Multi-agent systems spend more and call it architecture

In June, researchers ran GPT-5 against two of the more cited automated multi-agent frameworks, ADAS and AFlow, on GPQA-Diamond, a hard graduate-level science benchmark. Plain chain-of-thought with self-consistency — one agent, sampling itself and voting on the answer — scored 87.35% for $46.39. ADAS, which assembles a custom multi-agent pipeline per problem, scored 85.23% for $832.10: nearly eighteen times the cost for two points less accuracy. AFlow scored 84.13% for $274.60, about six times the cost for a worse answer.

It isn’t an isolated result. Two months earlier, other researchers made the same case with a cleaner method. They held the reasoning-token budget constant across three model families — Qwen3, DeepSeek-R1-Distill-Llama, and Gemini 2.5 — and compared a single agent against five different multi-agent architectures on multi-hop reasoning benchmarks. Once the token spend is matched, the single agent matches or beats every multi-agent configuration. Their argument for why is information-theoretic. Under a fixed token budget, splitting reasoning across agents and re-summarizing it for handoff can only lose information relative to one process that keeps it all in one context. Two groups, working independently, landed on the same conclusion within a season. A lot of the multi-agent advantage reported in earlier work was just uncounted compute wearing an architecture diagram.

Cognition made a version of this argument a year earlier, from production experience. Splitting an agent’s work across parallel subagents breaks shared context, and a long task needs that context to stay coherent. Summarize a subagent’s work for a coordinator and you’ve thrown away the detail a single continuous run would have kept. The AFlow result gives that argument a number: left to design its own pipeline, AFlow kept converging on a structure that repeats one custom prompt three times and aggregates the votes. That’s chain-of-thought self-consistency with extra steps bolted on. An automated system built to invent multi-agent architectures rediscovered plain self-consistency and charged six times as much for it.

The pattern underneath is old enough to have a name: Amdahl’s law. It says the speedup available from parallel work is bounded by however much of the task is genuinely independent, not by how many workers you throw at it. Multi-hop reasoning is mostly serial — step four needs step three’s conclusion. Splitting it across agents doesn’t parallelize the work; it just adds a coordination tax on top of a chain that still has to run in order. That’s the same lesson service teams learned breaking monoliths apart: a decomposition only pays for itself when the pieces are actually independent. Split along the wrong seam and you get a distributed monolith, same coupling as before plus network hops and a harder debugger.

The honest counterpoint is Anthropic’s own multi-agent research system. It used about fifteen times the tokens of a single chat and beat single-agent Claude Opus 4 by 90.2% on their internal eval. Read only that far, it looks like the exception disproving everything above. Read Anthropic’s own accounting and the exception dissolves. They reported that token usage alone explained about 80% of the variance in that eval’s results. They scoped the win to breadth-first queries — pulling every board member of every S&P 500 information-technology company, say. That’s work that genuinely splits into independent searches a single agent would otherwise run one at a time. Call it map-reduce with a chat interface: fan a parallel task out across workers, then combine, no reasoning collaboration required. Anthropic flagged the boundary themselves. They noted coding has far fewer parallelizable pieces than research, and that agents struggle more at real-time coordination there — the same Amdahl case, in a different domain.

A July paper on small local models sharpens the coordination-tax point from a different angle. A five-agent pipeline over a 7B model scored 45% on GSM8K when its inter-agent messages were JSON — worse than a single direct call at 75%. A chunk of the handoffs failed to parse. Switching the same pipeline to plain-text messages recovered it to 82%. A two-call self-refinement loop beat both at 86.2%, using 7.4 times fewer tokens than the five-agent version. Their own follow-up on code generation cuts the other way, as a caution against overcorrecting. The first two-call design they tried dropped HumanEval accuracy from a 96.3% direct baseline to 66.5%, and only a task-aware redesign clawed it back to 95.1%. Adding a hop doesn’t just fail to help by default — it’s one more place for a brittle interface to break the whole run.

The real dividing line runs between two different jobs the extra agents can be doing. Multi-agent against single-agent was never the interesting axis. Agents running genuinely independent pieces of work in parallel buy a real latency win. Agents running the same reasoning chain through more mouths in series, hoping deliberation beats one well-funded pass, buy a compute bill with a diagram attached. A useful test before reaching for a second agent: if the two agents need to talk to each other to finish, the task wasn’t parallel to begin with. The win already got spent on the conversation.