# Multi-agent systems: when one agent is not enough

> How orchestrator-worker, pipeline, handoff and fan-out designs work, what they cost in tokens, latency and debugging, and when several agents beat one.

- Published: 2026-04-06; last updated 2026-11-13
- Author: the WeStack AI team
- Subject: AI agents
- Address: https://westack.ai/blog/multi-agent-systems-when-to-use

> Use several agents when the work splits into parts that can run independently, when it will not fit in one context window, or when the parts need different permissions or belong to different organisations. For most other tasks, one agent with well-designed tools costs less and is far easier to debug. Most teams we meet reach for several agents before they have made one work.

## What counts as a multi-agent system?

An agent, for this article, is a model running in a loop with tools, deciding its own next step. A multi-agent system has more than one of these, each with its own instructions, its own tools and, most importantly, its own context window.

That last point is the one to hold on to. Splitting a task across agents means splitting what each one knows. Every benefit of the approach comes from that separation: workers can run at once, each sees only what it needs, and a noisy search does not clutter the lead agent's context. Every problem comes from it too, because an agent that cannot see what another one decided will happily contradict it.

A lot of diagrams labelled 'multi-agent' are neither. Five boxes called Researcher, Writer, Editor, Fact-checker and Publisher, run in a fixed order, are a pipeline of prompts. That can be a perfectly good design. It is just not what makes this subject hard.

## The four patterns

### Orchestrator and workers

A lead agent reads the request, makes a plan, and gives sub-tasks to worker agents. Each worker runs with a fresh context, does its piece, and returns a condensed result. The lead combines them. Anthropic describes its Research feature this way in a write-up on [how it built its multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system): a lead agent coordinates and delegates to specialised subagents that work in parallel.

A close relative is 'agents as tools', where the lead never gives up control and calls a specialist as it would call a function.

### Pipeline

Fixed stages, each consuming the previous stage's output: extract, analyse, draft, review. Code decides the order, not a model. Pipelines are predictable and easy to test stage by stage. Their weakness is that a mistake made at stage one travels down the line, and no later stage knows to question it.

### Handoff

One agent passes the whole conversation to another, which takes over. Support desks use this: a front-line agent identifies a billing problem and hands the customer to a billing specialist. The OpenAI Agents SDK documents [handoffs and agents-as-tools](https://openai.github.io/openai-agents-python/multi_agent/) as its two model-driven orchestration patterns, next to code-driven ones. The risks are context dropped at the handoff and customers bounced back and forth.

### Parallel fan-out

The same job is run across many items at once (summarise each of forty contracts), or the same question is given to several agents and the answers compared. The agents do not talk to each other. Code, or one more agent, merges the results.

## What do several agents really cost?

### Tokens

Every agent carries its own system prompt and tool definitions and does its own exploring, and the lead then reads what comes back. Anthropic's numbers are the clearest published ones: in its data, single agents used about 4 times the tokens of a chat interaction, and its multi-agent system about 15 times. Its conclusion is one we repeat to clients: the approach suits tasks where the value is 'high enough to pay for the increased performance'.

### Latency

Sequential designs add a model round trip at every handoff. Parallel designs reduce the clock time for wide tasks, but the lead still waits for the slowest worker, then spends another long call reading and combining. For a customer on a chat screen, a three-agent relay feels slow.

### Errors that compound

If each of five dependent steps is right 95% of the time, the whole chain is right about 77% of the time. That is arithmetic, not a measurement, but real measurements point the same way. A [Google Research study](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/) published in January 2026 tested 180 agent configurations. On a financial reasoning task that splits into parallel parts, centralised coordination improved on a single agent by 80.9%. On a sequential planning task, every multi-agent variant did worse than the single agent, by 39 to 70%. Agents working independently with nothing checking them amplified errors 17.2 times, against 4.4 times with an orchestrator.

The pattern in those results is the useful part. Coordination helps where the work divides cleanly and hurts where each step depends on the last.

### Lost context

Cognition, the company behind the Devin coding agent, argued this forcefully in a post titled [Don't Build Multi-Agents](https://cognition.com/blog/dont-build-multi-agents). Its two principles are 'Share context, and share full agent traces, not just individual messages' and 'Actions carry implicit decisions, and conflicting decisions carry bad results'. In plain terms: two workers given halves of a task will each make small assumptions, about date formats, currency, tone, which customer segment is meant, and the halves will not fit together.

### Debugging

When one agent fails you read one trace. When four agents fail, the fault is usually in what passed between them: a brief that was too vague, a result that was over-compressed, a handoff that dropped the one fact that mattered. Runs also differ from each other even with identical prompts. You need traces that follow a request across every agent, and evals for each agent as well as for the whole. Budget for that before you start, not after the first incident.

## When do they earn their place?

We would use several agents in five situations.

**Wide, independent research.** Comparing twelve suppliers across public filings, certifications and news is twelve separate investigations. Workers run at once and return a page each. This is the case the published evidence supports most clearly.

**More material than one context can hold.** If doing the job means reading two hundred documents, workers that read a lot and report a little are a form of compression. The lead works from summaries and its context stays clean.

**Different permissions.** An agent that reads untrusted web pages should not also hold the tool that sends money. Splitting them puts a controlled boundary between reading and acting. This is a security decision as much as an architectural one.

**Different owners.** When the other capability is run by another team or another company, it is a separate agent whether you like it or not.

**An independent check.** A reviewer with different instructions, and ideally a different model, catching errors in a draft. The gains are modest and it adds a round trip, so we add it only where a wrong output is expensive.

Now a case where they do not earn it. A software company wants an [AI support assistant](https://westack.ai/services/conversational-ai) and sketches a router, a billing agent, a technical agent and an account agent. Then a real ticket arrives: 'I was charged twice after the upgrade failed and now I cannot log in.' That is billing, technical and account at once. The router picks one. The specialist lacks the tools for the other two parts, hands off, and the next agent starts without the diagnosis the first one made.

We would build that as one agent with tools grouped by area and instructions loaded for the kind of ticket in front of it. It keeps the whole conversation in view, and there is one prompt to maintain and one trace to read. If the tool list later grows past what one agent can choose between reliably, or refunds need a tighter permission boundary, split then, with evidence.

## One agent with good tools, or several?

| Question | One agent with good tools | Several agents |
| --- | --- | --- |
| Do the parts need to see each other's progress? | Yes, steps depend on each other | No, parts are independent |
| Does the relevant material fit in one context window? | Yes, once tool results are trimmed | No, even after trimming |
| Is the work mostly one line of reasoning or one document being edited? | Yes | No, it is many separate lookups |
| Do parts need different permissions or data access? | Same trust level throughout | Different trust levels |
| Who owns the other capability? | Your team | Another team or company |
| Is each task worth several times the token cost? | Not clearly | Yes |
| Can you already trace and evaluate a single agent? | Not yet, so fix that first | Yes |

Two or more answers in the right-hand column make a case worth testing. One answer is usually a reason to improve the tools. Quite often 'we need more agents' turns out to mean 'our one agent has twenty-five badly described tools', and the fix for that is better tools, as we describe in [AI agents in production](https://westack.ai/blog/ai-agents-in-production).

## Where do A2A and MCP fit?

Two protocols come up in every conversation about this, and they solve different problems.

[MCP](https://westack.ai/blog/model-context-protocol-explained) connects an agent to its tools and data. A2A, the Agent2Agent protocol, connects agents to each other. It was started by Google, is now hosted by the Linux Foundation, and reached version 1.0 in early 2026. Under the [A2A specification](https://a2a-protocol.org/latest/specification/), an agent publishes an Agent Card describing its skills, its endpoint and how to authenticate. Other agents send it tasks, which have a lifecycle (submitted, working, completed, failed) and return results as artefacts. Neither side sees the other's memory or tools. The project's own explanation of [how A2A relates to MCP](https://a2a-protocol.org/latest/topics/a2a-and-mcp/) puts it in one line: 'A2A connects the agents to each other; MCP connects each agent to its own tools.'

Our advice on A2A is narrow. It is the right choice when you cross an organisational boundary: your procurement agent asking a supplier's agent for stock and lead times, or a platform exposing an agent for customers' agents to call. It is unnecessary inside one codebase, where an orchestrator calling a worker is a function call and adding a network protocol only adds things to break. Do not adopt A2A in order to have a multi-agent system. Adopt it when someone else's agent exists and you need to talk to it.

## How to start: build the single agent first

Begin with one agent, a small set of well-designed tools and an eval set of real cases to measure it against. Run it and read the failures.

Then ask what kind of failure you are seeing. If the agent runs out of context halfway through, or takes ten minutes doing lookups one after another that do not depend on each other, or needs a permission you are not willing to give the whole agent, you have found a specific reason for a second agent. Add exactly one worker for that reason.

Finally, compare the two versions on the same eval set, looking at quality, cost per task and time to finish together. Keep the split only if the numbers support it. Our guide to [evaluating AI agents](https://westack.ai/blog/how-to-evaluate-ai-agents) covers how to set that comparison up. Plenty of planned multi-agent designs do not survive it, and the systems are better for that. It is the same test we apply to the [agent systems](https://westack.ai/services/ai-agents) we build at WeStack AI.

## Frequently asked questions

### What is a multi-agent system in AI?

It is a system in which several model-driven agents, each with its own instructions, tools and context window, work on parts of one task. A lead agent may delegate to workers, agents may pass a conversation between them, or several may run in parallel. The defining feature is separate contexts, which is both the benefit and the main source of trouble.

### Are multi-agent systems better than a single agent?

Only for some kinds of work. Research published by Google in January 2026 found large gains from coordinated agents on tasks that split into parallel parts and clear losses on tasks that must be reasoned through in sequence. For most business processes, one agent with well-designed tools is cheaper and easier to debug.

### What is the difference between MCP and A2A?

MCP connects one agent to its tools and data. A2A, the Agent2Agent protocol, lets independent agents built by different teams or companies find each other and exchange tasks without sharing their internal memory or tools. You need MCP far more often. A2A matters when the other agent belongs to someone else.

### How much more does a multi-agent system cost to run?

It depends on the design, but expect a multiple, not a margin. Anthropic reported that its multi-agent research system used about 15 times the tokens of a chat interaction, against about 4 times for a single agent. Each worker pays for its own prompt, tool definitions and exploration, and the lead agent pays again to read the results.
