Multi-Agent Design Patterns — Division, Debate, Verification

Stack as many agents as you like — if they all fail the same way, you have one agent and a larger bill. The condition under which voting actually helps, written down, then the three patterns that follow from it: division of labour, debate, and adversarial verification — plus when one agent is enough.

Improving Factuality and Reasoning in Language Models through Multiagent Debate

Does adding people to the meeting make it smarter?

"Two heads are better than one" carries a hidden assumption: that the two heads think differently. Two people trained on the same material, in the same way, get stuck at the same place. Take a vote among them and all you have done is certify the mistake with more confidence.

Running several LLM agents is the engineering version of that proverb. Take one agent — the think, reach for a tool, look at the result loop covered in LLM Agents from Scratch — run several, split the roles, compare the answers. Done well, you reach a quality a single agent cannot. Done badly, the only thing that scales is the invoice.

So this article settles when adding agents pays before it looks at any pattern. In the other order you end up copying a fashionable topology and shipping a system that is slower, pricier, and exactly as accurate.

The condition, written down

Start with the simplest arrangement. Give the same problem to $n$ agents and take a majority vote. Suppose each is correct with probability $p$, and that they fail independently.

Read in words, this is the same shape as tossing $n$ slightly biased coins and asking how often heads takes the majority. $p$ is how strongly one coin leans towards heads — the accuracy of a single agent — and $n$ is how many coins you toss, the agent count.

Equation (1) says nothing more than "the probability that more than half of the $n$ agents are right." $\binom{n}{k}$ is the number of ways to pick $k$ agents out of $n$; $p^k(1-p)^{n-k}$ is the probability that those $k$ get it right and the rest do not. What matters is the direction. If $p > 0.5$, raising $n$ pushes the result towards 1. If $p < 0.5$, it pushes it towards 0. On a task where a single agent is right less than half the time, adding agents makes you reliably wrong.

And the whole equation rests on that one-line independence assumption. Let $\rho$ be the correlation between the agents' errors. Then the spread of their average behaves like this:

Put in words, adding agents only dilutes the part of the error each one makes on its own; the part they all make together survives however many you line up. The arrow on the right reads "where this ends up as the agent count grows without bound."

Here $e_i$ is each agent's error, $\sigma^2$ is how large those errors are, and $\rho$ is how strongly two agents tend to be wrong in the same direction. Equation (2) makes exactly one point: no number of agents pushes the spread below $\sigma^2\rho$. At $\rho = 1$ — everyone wrong in precisely the same way — the $1/n$ term vanishes and a hundred agents behave like one.

This is the sore spot of multi-agent design. Outputs from the same model, on the same prompt, at the same temperature, have $\rho$ close to 1, and neither voting nor debate does much for them. To make either work you have to force them apart: raise the temperature, change the angle of the prompt (look for counterexamples first, or state the conclusion first), hand them different source material, or use a different model. Diversity in sampling has been a working resource ever since self-consistency, which draws multiple reasoning paths and votes over the answers (Wang et al., 2022).

Pattern 1: Division — cutting the context into pieces

Splitting roles is a pattern about context and attention more than about accuracy. Cram "read the spec," "implement," "write tests," and "review" into one prompt and the later instructions get honoured least, while the history balloons. Give each job to a separate agent and hand each one only the material its own job needs.

There are two shapes. A pipeline is serial — survey, design, implement, verify — where each output feeds the next. It is easy to trace when something breaks, but an upstream error flows downstream untouched. A fan-out hands independent small jobs (migrate ten files, review from five angles) to agents at once, so the wall-clock time is set by the slowest single agent.