Multi Agent Systems: When More Agents Hurt
Learn when multi agent systems beat one agent, which topology to use, and how handoffs fail in software delivery.
In this article
- When More Agents Help and When They Hurt
- Software delivery is mostly ordered work
- What Makes a System Multi Agent
- Four Ways Agents Can Be Wired
- Pick a default and instrument it
- How to Hand Off Work Without Losing the Thread
- Test reliability by disrupting the run
- Failure Modes That Show Up in Code Delivery
- Review agents are a first pass, not the gate
- A Feature Built by Several Agents
- Watch the artifacts, not the model names
- Choose the Simplest System That Still Ships
The most repeated advice about multi agent systems is to add more of them. Split the work, run agents in parallel, let specialists talk to each other. It sounds like a free upgrade. For most software work, it isn't.
Adoption isn't the open question. In 2025, 79% of surveyed companies said AI agents were already being adopted and 88% planned to increase AI-related budgets within the following year, according to PwC's survey of 308 U.S. business executives. The question is which architecture you point them at.
On some tasks, extra agents produce large gains. On others, they produce worse results than a single agent, and no amount of orchestration polish rescues a task that didn't want to be split. Telling those two cases apart before you ship is the whole skill.
When More Agents Help and When They Hurt
Start with the result that should reshape your roadmap. On a parallelizable financial-reasoning benchmark, centralized multi-agent coordination lifted mean performance from 34.9% for a single agent to 63.1%, an absolute gain of 28.2 points and a relative improvement of about 80.8%. Google Research's evaluation of 180 agent configurations also found a predictive model picked the best architecture for 87% of tasks it had not seen before.
The cause is easy to see. Separate agents analyzed distinct dimensions, such as revenue trends, costs, and market comparisons, and a combiner merged their answers. A wrong cost estimate doesn't corrupt the revenue analysis, because neither agent waits on the other.
Now the same research, pointed at ordered work. On the PlanCraft benchmark, every tested multi-agent configuration underperformed the single-agent baseline, with declines of 39% to 70%. Step-by-step reasoning punishes handoffs, because overhead, inconsistent intermediate state, and coordination errors all land on the critical path.
Practical rule: add an agent only when that agent's work can finish without waiting on another agent's answer.
Mistakes multiply too. Independent agents can amplify errors by up to 17.2 times, against about 4.4 times in a centralized architecture with an orchestrator and a validation bottleneck, per Google Research's analysis of scaling agent systems. Peers copy each other's bad assumptions. A validation step stops the copying.
Software delivery is mostly ordered work
Product intent, technical design, implementation, and review each depend on the step before them. Run those four in parallel and one agent builds a button against a schema another agent already changed. The patch compiles. The spec is stale. The reviewer spends the afternoon deciding which document is current.
Label your next ticket before you hand it to anyone.
| Task shape | Use this | What the evidence shows | Main risk if you add agents |
|---|---|---|---|
| Parallel and independent, such as separate analyses | Centralized multi-agent with one combiner | Mean performance rose from 34.9% to 63.1% on a financial-reasoning benchmark | A combiner that merges conflicting answers |
| Strict step-by-step reasoning | One agent | Every multi-agent setup on PlanCraft fell 39% to 70% | Overhead, stale intermediate state, coordination errors |
| Ordered software pipeline: design, then code, then review | Staged chain with locked handoffs | Sequential steps lose when run in parallel, the PlanCraft pattern | Design drift and patches that do not match the spec |
| Parallel checks on one approved artifact | Star with an orchestrator | Error amplification about 4.4x with a central orchestrator, up to 17.2x without one | Orchestrator bottleneck and a skipped validation step |
| Changing state, disruptions, shared resources | Central supervisor plus escalation | Coordination, not planning skill, becomes the bottleneck under disruption | Stale assumptions and partial failures |
What Makes a System Multi Agent
A multi agent system is a group of software actors. Each holds a local goal, sees only part of a shared situation, and acts without one controller doing every step.
Picture a busy kitchen line. The grill cook, the pastry cook, and the expediter all read from one ticket rail. None of them sees the whole meal. The rail does, and plates land together because the rail is clear, not because someone shouts every order twice.

Four properties separate that from a single agent with a longer prompt:
- Local goal. Each agent pursues its own objective, such as passing tests or matching an approved design.
- Partial view. Each agent reads only part of the shared situation, which keeps its context small and its output focused.
- No central controller. Agents act without one process driving every individual step.
- Shared situation. All of them work from common context, such as a design document or a pull request.
The idea is older than language models. Craig Reynolds's 1986 "boids" simulation showed that simple local rules, followed by individual agents, produced coordinated global behavior with no leader, as IBM's history of agent research traces. That result made emergence a central idea in agent-based systems, and it's why you can't debug a swarm by reading one agent's prompt.
By the 1990s the field had vocabulary. Wooldridge and Jennings's 1995 classification sorted agents along dimensions such as reactive versus deliberative behavior. A reactive agent answers the next input or tool result. A deliberative agent plans against a stated goal or spec. Most coding agents you use today are hybrids: they plan a step, then react to what the test run returns.
Three parts appear in every multi agent system worth building: a role, a limited view, and a shared artifact. Get those right and coordination improves. Get them wrong and you've paid for five models to share one messy chat log.
Four Ways Agents Can Be Wired
Who talks to whom matters more than how many agents you run. The MultiAgentBench study of coordination topologies scores star, chain, tree, and graph layouts on milestone completion, planning, and communication, so overhead becomes a number instead of a pass or fail at the end.
Star. Specialists report to one orchestrator. Point security review, test coverage, and documentation at an approved spec, let each report back, and you get three independent reads with one place to look when something breaks. The center also becomes the bottleneck, and it's the single component that can skip a check.
Chain. Each agent reads only the previous artifact and emits the next one. This is the natural shape for product design, then technical design, then implementation, then review, because every stage has one input and one output. A broken handoff stops the line, which is a feature until it happens on a Friday.
Tree. Leads own subteams, which suits a large epic split by service. It also loosens the context: an assumption agreed at the top arrives three levels down as a stale instruction nobody re-checked.
Graph. Peers message freely. This is the right shape for negotiation when context must be shared across everyone, and the expensive one to operate. Every new peer adds paths where a message can be lost, retried twice, or blamed on the wrong agent.
Pick a default and instrument it
For software work, default to a chain or a star, because each step can be paused, checked, and retried.
Then measure the shape, not just the outcome. Record agent topology, message count, latency, token cost, handoff retries, and milestone completion. That turns a debate about architecture into an experiment: run a sequential product-design to technical-design to implementation pipeline against a group of specialists plus one synthesis step, and compare the two on the same feature.
| Shape | Who talks to whom | Fits this software job | Failure that grows |
|---|---|---|---|
| Star | Specialists report to one orchestrator | Parallel checks on one approved spec | The center becomes a bottleneck or skips a check |
| Chain | Each agent reads only the previous artifact | Design, then build, then review | One broken handoff stops the line |
| Tree | Leads report up and own subteams | A large epic split by service | Assumptions go stale as they move down |
| Graph | Peers message freely | Negotiation when context must be shared | More paths, harder retries, harder blame |
How to Hand Off Work Without Losing the Thread
A handoff is a small transaction, not a chat summary. The rules below run in order, and each one exists because a specific failure gets past you without it.

- Classify the task first. Decide parallel, sequential, or mixed before you assign roles. Roles chosen first tend to invent work for themselves.
- Write a handoff contract. State the source revision, the allowed inputs, and the acceptance checks. Without it, the next agent fills gaps with invention.
- Persist the approved context. A missing paragraph should fail loudly, not get rewritten from memory.
- Lock the design revision before implementation. Two agents editing against different revisions produce a patch nobody can review.
- Make retries idempotent. A second run must not open a second conflicting change to the same file.
- Require the reviewer to cite a concrete deviation, such as a requirement the patch skipped or a column it renamed. Prose objections can't be actioned.
- Stop automatic advance when evidence is missing, a tool is down, or the retry budget is spent. Move the card to an escalation state instead of guessing.
That last rule carries more weight than it looks. Under changing state, coordination itself becomes the bottleneck. REALM-Bench reports roughly 85% to 95% success for single-agent static logistics problems, against about 45% to 70% for multi-agent scenarios involving disruptions and large-scale coordination. The agents keep planning on beliefs that expired two steps ago.
Test reliability by disrupting the run
One clean demo proves nothing. Repeat the same run, then disrupt it with a late tool response, a changed requirement, or a dead worker. Score completion rate, recovery time, fix rounds, and cost per finished card.
That's a different kind of measurement from a green checkmark. Keeping the approved context and the source revision attached to each card is the same discipline good context management asks for: the agent should work from the record, not from whatever it remembers of the conversation.
Why lock the revision: the most expensive bug in an agent pipeline isn't a syntax error. It's a correct patch written against a design that changed an hour ago.
Failure Modes That Show Up in Code Delivery
More agents can deliver more code and still make the next incident harder to explain.
Error amplification arrives first. Peer agents that trust each other's assumptions spread one bad guess across the whole change. A validating center cuts the spread, because a claim has to survive a check before it becomes a patch.
Stale state looks like code written against last week's design. One agent revises the schema, another still uses the old column names, and the tests pass because they were written against the older shape again. Locking the approved revision removes the question of which document is current.
Silent propagation costs you a weekend. A hallucinated file path or a failed tool call travels through three agents before anyone notices. A study of production agent failures documents 77 distinct technical challenges across seven areas, including runtime integration, dependency management, orchestration complexity, and evaluation reliability. It points at the fix too: treat each run as an auditable production event, keeping structured inputs and outputs, provenance, tool permissions, approval points, and what changed after the approval. A human checkpoint helps only if you can show what that human reviewed.
Review agents are a first pass, not the gate
Automated review is improving and still isn't a replacement. In a benchmark of code-review agents, current systems identified only about 40% of the issues in the set.
The merge data makes the gap concrete. Pull requests reviewed only by coding-review agents merged at 45.20%, against 68.37% for human-only review. The automated-only group also abandoned 34.88% of them against 21.60%, a difference that was statistically significant at p < 0.001, per the pull-request review study.
Rework is the other half. An analysis of agent-authored pull requests found 83.8% were eventually accepted and merged, and 54.9% of those merged with no further modification. That's a reason to keep the loop and the person, not to skip either.
| Failure | What you see | Control |
|---|---|---|
| Weak automated review | About 40% of benchmark issues found | Second agent as a first pass, human for the final gate |
| Agent-only approval | 45.20% merge and 34.88% abandoned, against 68.37% and 21.60% for humans | Targeted human checkpoint before merge |
| One-shot generation | Resolve rate stays low until someone reworks the patch | Explicit review and rework stages before merge |
| Accepted but unchecked agent code | 83.8% of agent pull requests eventually merged, 54.9% with no edits | Keep the maintainer approval even when most land clean |
| Undiagnosable incident | No record of the prompt, the tool call, or the handoff | Store inputs, outputs, provenance, permissions, and the approval |
Replay is the practical test of everything in that table. If you can't reconstruct which prompt, tool call, or handoff produced a bad line, the controls are theory. The habits behind agent observability turn an incident review into a ten-minute lookup instead of a meeting.
None of these failures argues against agents. They argue for keeping a record and a gate. The teams that get value from multi agent systems are the ones who can answer "which agent introduced this, and what did it read?" without a meeting.
A Feature Built by Several Agents
Take one small feature: export a table to CSV. Watch it fail, then watch it work.
The parallel run. Three agents start at the same moment from a chat summary. One builds the button, one writes the API endpoint, one writes tests. The tests pass, because the test agent invented the response shape it expected. The API returns a different one. The reviewer argues in prose and nobody can say which spec was current. Fix rounds climb because each agent repairs a different bug.
The staged run. Same feature, same models, different order. One agent drafts a short product note and a clickable sketch of the button and the file it downloads. A person approves that note. A second agent writes the technical design from the approved note, covering columns, empty states, and the error text. A person locks that revision. Only then does an implementer open a pull request. A reviewer lists deviations against the locked design, with file and line, and the implementer revises.

The difference isn't talent. The second run refused to write code until the previous artifact was approved.
That refusal pays. A review-and-revise loop on 1,384 candidate pull requests covering 500 SWE-bench Verified issues raised resolve rate from 27.5% to 56.9% for one model and from 50.9% to 68.8% for another, per a benchmark of iterative code revision. A separate experiment in the same line of work improved resolve rate from 22.9% to 38.4% after four revision rounds.
Watch the artifacts, not the model names
In the good run, five artifacts tell the story: a product note, a locked design, a pull request, a defect list, and a merge. Anyone can audit that chain a week later, including a person who wasn't in the room. In the bad run, the only artifact is a chat log, and the chat log argues with itself.
The valuable part isn't that an agent can write an endpoint. You already knew that. The valuable part is that the second setup made the agent's work reviewable by someone with less context than the agent.
Choose the Simplest System That Still Ships
Decide before the next ticket, not after a messy pull request.
- Write the reliability target first. Name the completion rate you'll accept across repeated identical runs. A number you can fail is a target. A good feeling isn't.
- Cap the handoff count. Three handoffs is a chain. Nine is a rumor mill. When the budget is spent, escalate instead of adding another peer.
- Keep a person where the cost of being wrong is high. Correctness, security, and product intent each deserve a sign-off, plus a record of what that person saw.
Then let the task shape pick the architecture. Independent pieces get one orchestrator and a validation step. Dependent steps get one agent or a short chain. A world that can change mid-run gets an escalation state and a locked revision.
The human gate is only as strong as the evidence behind it, which is the case for human in the loop checkpoints that preserve what was reviewed rather than just noting that someone clicked approve.
Loupe holds that chain as a board with six stages, from product design through to done, and it runs no AI models itself, so you bring the agents. An agent review checks every design and every pull request against the approved design and sends it back for fixes before you see it. Put one feature on that path, compare it against your current single-agent chat, and keep the shape only if fix rounds and hours to merge both improve.
Loupe gives coding agents a board where work moves through defined stages and a person holds the decision points that matter. If you're deciding whether to split a feature across agents, the board makes the answer measurable: one card, one approved design, one pull request, and a fix-round count you can compare against what you do today. Visit Loupe to see how the staged workflow runs.