Attenuation

A project stalls. The deadline presses, requirements contradict each other, nobody has the full picture. Someone decides what's missing is coordination and calls a meeting with twelve people. Each brings their partial perspective. The meeting lasts ninety minutes. It produces six action items, three misunderstandings, and two subgroups that will need their own meetings the following week. The project is still stuck, but now more people are involved, more threads are open, more surface area where things can go wrong.

What was missing wasn't more people thinking. What was missing was one person with enough context and enough time to think the whole problem through.

A recent paper by Dat Tran and Douwe Kiela says the same thing happens with artificial intelligence agents. In Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets, the researchers controlled for something nobody had controlled before: computational budget. They gave a single LLM agent exactly the same reasoning tokens as a coordinated multi-agent system and measured who solved complex multi-hop reasoning problems better. The result: the single agent matched or outperformed the multi-agent system in nearly every condition. The advantages reported in prior studies were artifacts of giving the multi-agent system more resources, not a better architecture.

The surprise shouldn't be that great. We've been discovering the same thing in other fields for half a century.

The Mythical Man

In 1975, Frederick Brooks published The Mythical Man-Month, a book about the disasters of IBM's OS/360 project that became the founding text of software engineering. His most famous law is simple: adding people to a late project makes it later. The reason is arithmetic. If you have n people working on a problem, the communication channels between them grow as n(n−1)/2. Two people need one channel. Five need ten. Twelve need sixty-six. Each channel consumes time, generates misunderstandings, requires alignment.

But Brooks's deeper argument was not quantitative — it was qualitative. What truly mattered was conceptual integrity: the ability of a system to reflect a coherent vision, as if it had been designed by a single mind. When many people contribute without that coherence, each one solves their part in a locally reasonable but globally contradictory way. The result is a system that works in pieces but doesn't work as a whole.

Men and months are interchangeable commodities only when a task can be partitioned among many workers with no communication among them. This is true of reaping wheat or picking cotton; it is not even approximately true of systems programming.

— Frederick Brooks, The Mythical Man-Month (1975)

The Tran and Kiela paper finds exactly this. The sequential multi-agent system — where a planner decomposes the problem and multiple workers solve it in parts — "explores more entities but drifts." It covers more ground but loses the thread. The single agent, by contrast, maintains what the researchers call tighter constraint anchoring: a firmer grip on the constraints of the original problem. More territory covered, less coherence. It's Brooks's law, replicated fifty years later in an artificial intelligence lab.

The Data Processing Inequality

The researchers ground their analysis in an information theory theorem called the Data Processing Inequality. The idea, which traces back to Claude Shannon's foundational 1948 work on the mathematical theory of communication, is intuitive once you grasp it: if information passes through a chain of processing steps, each step can only preserve or lose information. Never create it. This is not an empirical tendency. It is a theorem. Every intermediate node is a potential bottleneck where signal degrades.

In a multi-agent system, every agent that summarises, reformulates, or translates the problem for the next one is a node in that chain. Every summary loses nuance. Every reformulation introduces its own interpretation. Every translation between agents is a transmission through a noisy channel. The information from the original problem degrades with each handoff.

A parallel study by Yubin Kim and colleagues from Google and MIT puts numbers to this degradation. In Towards a Science of Scaling Agent Systems, they evaluated 260 distinct agent configurations and found that independent agent swarms can amplify baseline errors up to 17 times. In tasks requiring sixteen tools, the single agent's coordination efficiency was 0.466 while multi-agent systems dropped to between 0.074 and 0.234 — a penalty of two to six times. Every additional agent is not free: it consumes token budget that could have been spent reasoning.

But the theorem's metaphor extends beyond LLMs. Every handoff in an organisation — every meeting that summarises what was discussed in another meeting, every management layer that translates strategic decisions into operational tasks, every intermediary that filters what goes up and what goes down — is a processing node where the same inequality holds. Conway described it as a law: organisations design systems that mirror their communication structure. More intermediaries, more structural constraints, more places where signal is lost.

A firm will tend to expand until the costs of organizing an extra transaction within the firm become equal to the costs of carrying out the same transaction by means of an exchange on the open market.

— Ronald Coase, The Nature of the Firm (1937)

Ronald Coase arrived at the same frontier from economics. In The Nature of the Firm (1937), he asked something nobody was asking: if the market is so efficient, why do firms exist? His answer was that coordinating activities on the open market has transaction costs — finding suppliers, negotiating contracts, verifying quality. The firm exists because internalising those activities is cheaper than contracting them out. And the firm grows until the cost of coordinating internally exceeds the cost of going to the market.

Replace "firm" with "single agent" and "market" with "multi-agent system." The single agent grows until the cost of holding all context in one window exceeds the benefit of coherence. That frontier is exactly what the Stanford paper measures with token budget. And as Coase predicted, the frontier isn't fixed — it moves with technology. As LLM context windows grow, the frontier shifts in favour of the single agent.

Do One Thing and Do It Well

There is a design tradition that has lived with this problem for half a century. In 1978, Doug McIlroy wrote the foreword to the Unix manual with three rules that became a philosophy: write programs that do one thing and do it well; write programs that work together; make them handle text streams, because that's the universal interface.

The Unix pipe is, strictly speaking, a multi-agent architecture. Four independent programs chained together, each ignorant of what the others do, coordinated by a text stream flowing from one to the next. But it is an architecture designed with brutal economy. Each tool hides its implementation. None needs to understand the others' context. The interface between them — plain text, line by line — is as narrow as possible.

Unix works not because it avoids decomposition but because it minimises information loss at each handoff. Plain text is the universal interface precisely because it accepts the loss: it sacrifices the richness of internal structures in exchange for the universality of the format. Each tool receives the minimum needed to do its job and produces the minimum needed for the next.

Herbert Simon formalised this principle in The Architecture of Complexity (1962). Complex systems that survive, Simon argued, are nearly decomposable: they are composed of subsystems with strong internal interactions and weak external ones. The interfaces between modules are narrow. When they are, decomposition helps. When every component needs the full system context, decomposition destroys more than it builds.

Every module is characterized by its knowledge of a design decision which it hides from all others. Its interface or definition was chosen to reveal as little as possible about its inner workings.

— David Parnas, On the Criteria To Be Used in Decomposing Systems into Modules (1972)

David Parnas brought the same insight to software design in 1972. In On the Criteria To Be Used in Decomposing Systems into Modules, he demonstrated with a concrete example that the obvious way to decompose a system — following its processing steps — produces brittle designs. That is exactly what a sequential multi-agent system does: a planner decomposes the task into steps and assigns an agent to each. Parnas showed that the right decomposition follows not the processing flow but the design decisions likely to change, with interfaces that hide internal details. The Unix pipe works because each tool hides how it does what it does. The sequential multi-agent system fails because each agent needs to interpret what the previous ones did — a wide, ambiguous, expensive interface.

The Invisible Waste

Taiichi Ohno classified seven types of waste in the Toyota Production System. The most insidious was what he called overprocessing: doing more work than necessary to produce value. It is not a failure of omission — it is a failure of excess. Work that is done, that consumes resources, that looks productive, but adds nothing the customer needs.

In a multi-agent system, every agent that summarises the problem for the next, every reformulation, every intermediate synthesis, is work that may be destroying signal rather than creating it. The Stanford paper found that multi-agent systems produce "longer reasoning traces" and "explore more entities" — but that extra exploration doesn't translate into better answers. It is overprocessing: more tokens spent, more ground covered, less value produced. Ohno would have recognised it immediately.

But Ohno was no centralist. Toyota didn't work because one person controlled everything. It worked because every worker had the authority to pull the andon cord — to stop the entire production line when they spotted a problem. The system was distributed, not concentrated. The key was not having a single mind make all decisions but having every person empowered to act on what they could see from their position.

What magical trick makes us intelligent? The trick is that there is no trick. The power of intelligence stems from our vast diversity, not from any single, perfect principle.

— Marvin Minsky, The Society of Mind (1986)

The Stanford paper finds something similar. There is a regime where the multi-agent system becomes competitive: when context is degraded. When input information is noisy, contradictory, or too large for a single agent to process with coherence, decomposition helps — because each agent can filter a different kind of noise. It's the equivalent of the worker on the Toyota line who sees something the plant manager, from his office, cannot.

The Google and MIT study quantifies the threshold: the multi-agent system only adds value when the single agent's accuracy falls below 45%. Above that — when the single agent is reasonably competent — adding agents doesn't help. It amplifies errors and consumes budget.

Marvin Minsky made the most ambitious version of the counter-argument in The Society of Mind (1986): the human mind is, itself, a society of agents. There is no central homunculus doing the thinking. There are hundreds of simple processes, none intelligent on its own, collectively producing what we call thought. Intelligence emerges from interaction, not from an omniscient agent.

But Minsky's agents were extremely simple, with extremely narrow interfaces. Like Unix tools, not like LLMs trying to comprehend all the context they receive. The lesson is subtle: multi-agent works when agents are cheap and interfaces are clear. It fails when agents are expensive — in tokens, in latency, in complexity — and interfaces are ambiguous. A natural language summary between two LLMs is an expensive, noisy interface. A plain text stream between two Unix tools is a cheap, precise one.

---

Back to the meeting. It didn't fail because the twelve people were incompetent. It failed because the problem, at that moment, was not decomposable — it needed one person with the full context and the space to think. The Stanford paper's conclusion is modest: it proposes "moving beyond broad MAS superiority claims toward understanding when coordination overhead is justified."

It is a conclusion Brooks, Parnas, Coase, Ohno, and Simon would have signed without reading the paper. The novelty lies not in the answer but in the material where the question is posed: we are no longer talking about programmers, or workers on an assembly line, or departments in a company. We are talking about artificial intelligence agents. But the question is the same one that has animated organisational theory, software architecture, and the economics of the firm for seventy years.

When does a problem need a team, and when does it need a mind?

Information theory says every handoff loses something. Experience says some handoffs create something too — they filter noise, contribute perspectives a single viewpoint cannot reach, catch errors the lone eye misses. The hard part is knowing which is which. And that frontier isn't fixed. It moves with the agent's capability — human or artificial —, with the quality of the interfaces, with the structure of the problem. The Google and MIT study found that the saturation threshold disappears when the single agent exceeds a certain level of competence. In other words: what needs a team today may need only a more capable mind tomorrow.

Just as in organisations. The threshold shifts when the person grows.