# Multi-Agent Systems: Patterns, Benefits and When One Agent Is Enough

> Multiple agents pay off when a task splits into independent parts that can run in parallel, or when a single agent struggles with too many tools and too much context. For tightly coupled work, one agent with well-designed tools is usually more reliable and much cheaper.

Canonical URL: https://www.ruebstudio.de/en/guides/ai-agent-architecture/multi-agent-systems-guide  
Author: Dr.-Ing. Marcus Rüb, CEO  
Published: 2026-10-24

Once an AI agent has to handle more than a few jobs, someone usually suggests splitting it into a team of specialists: one researches, one writes, one reviews. It sounds like good division of labour, but it comes at a cost in tokens, latency and reliability. This guide covers the main patterns, what they cost, and why the counter-argument, that one agent is often enough, deserves to be taken seriously.

## What is a multi-agent system and what is it used for?

A multi-agent system is a set of [AI agents](https://www.ruebstudio.de/en/glossary/ai-agent), each with its own context, instructions and usually its own tools, working together on one task. Teams use it when a job is too broad for a single context window, splits cleanly into independent parts, or when different teams need to own and maintain separate capabilities.

It helps to separate agents from fixed pipelines. In [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents), Anthropic distinguishes *workflows*, where language models and tools are orchestrated through predefined code paths, from *agents*, where the model decides for itself which steps to take and which tools to call. Plenty of products sold as "multi-agent" are really workflows with several model calls. That is not a weakness; it is often the better design.

Common use cases:

- **Broad research:** several sub-questions are investigated in parallel and merged at the end.
- **Separate domains:** an assistant covering calendar, email, CRM and a database can hand each domain to a specialist with a small, focused tool set.
- **Generate and check:** one agent drafts, another reviews against criteria, for example a sales quote against price lists and delivery terms.
- **Distributed ownership:** different teams build and run their own agents behind clear interfaces.

## How does a multi-agent system work?

Every multi-agent system has three building blocks: the agents themselves, each with a role and tools; a coordination layer that decides who works when; and a way to pass context and results between them. Overall quality depends most on the third block, because every handover is a place where information can get lost.

**The agents.** Each agent is a language model with its own system prompt, tool list and context window. In practice, specialisation means fewer tools, shorter and sharper instructions, and less irrelevant context.

**Coordination.** Control can sit with the model or with your code. The [OpenAI Agents SDK documentation](https://openai.github.io/openai-agents-python/multi_agent/) describes exactly these two options: either the model decides which agent runs next, or code fixes the sequence, which makes speed, cost and output more predictable. You can mix both.

**Handover.** Agents either exchange compact results (a sub-agent returns a summary) or pass control together with the conversation history. The less context you pass, the cheaper the system, but the higher the risk that the receiving agent reads the task differently from what was intended.

For agents built by different vendors or on different frameworks there is now an open protocol. [A2A (Agent2Agent)](https://a2a-protocol.org/latest/) was originally developed by Google and donated to the Linux Foundation. It covers communication between agents, while the [Model Context Protocol (MCP)](https://www.ruebstudio.de/en/glossary/model-context-protocol-mcp) covers how an agent reaches tools and data. The A2A documentation explicitly describes the two as complementary rather than competing.

## Which patterns are there?

The common patterns differ in who holds control: a central coordinator, a fixed sequence, or the agents themselves. For business applications, two or three basic forms usually cover the ground, and they can be combined. A dedicated article on supervisor, hierarchical, pipeline and swarm patterns is in preparation.

**Supervisor (orchestrator–worker).** A central agent breaks the task down, calls specialists as if they were tools and merges their results. Anthropic uses this for its research system: a lead agent plans the work and launches sub-agents that run in parallel. The [LangChain documentation](https://docs.langchain.com/oss/python/langchain/multi-agent) calls it "subagents", with all routing going through the main agent. In the OpenAI Agents SDK the equivalent is "agents as tools". Strength: one place owns the final answer. Weakness: every round trip through the coordinator adds model calls.

**Handoff.** A front-door agent identifies the request and passes control to a specialist, who handles the rest, for instance from a general service desk to a returns agent. This fits best when the specialist should carry on the conversation with the user directly.

**Router.** A classification step sends a request to one or more specialist agents and combines their answers. At heart this is a workflow with a fixed branch, which makes it easy to test.

**Pipeline and review loop.** Agents work in a fixed order, such as research, outline, draft, critique, revise. A variant is the generator–reviewer loop that Anthropic calls "evaluator-optimizer": one model produces output, a second scores it and feeds back until the criteria are met.

**Skills instead of agents.** Not every specialisation needs its own agent. LangChain describes an alternative where a single agent stays in control and loads specialist prompts and knowledge only when it needs them.

## What does a multi-agent system cost?

Multiple agents use far more tokens, because each one builds its own context and results have to be summarised and passed on. Cost is therefore the first criterion to check, not the last: a multi-agent design only makes sense when the value of the task covers the extra spend.

The most concrete public figures come from Anthropic. According to its [write-up of the research system](https://www.anthropic.com/engineering/multi-agent-research-system), agents typically use about 4 times the tokens of a chat interaction, and multi-agent systems about 15 times. In the same report, a system with Claude Opus 4 as lead agent and Claude Sonnet 4 sub-agents outperformed a single Claude Opus 4 agent by 90.2% on an internal research evaluation. The explanation matters: Anthropic reports that token usage alone explained 80% of the performance variance on the BrowseComp evaluation. Put simply, several agents help mainly because they apply more compute to a problem in parallel.

The choice of pattern also shifts cost noticeably. In a comparison in the [LangChain documentation](https://docs.langchain.com/oss/python/langchain/multi-agent), a request spanning three domains took 5 model calls and around 9,000 tokens with the subagents pattern, and 7 or more calls and around 14,000 tokens with handoffs. For a repeated simple request, however, handoffs needed fewer calls (2 instead of 4 on the second turn). There is no universally cheapest pattern; it depends on what your typical requests look like.

For planning, measure tokens and model calls per transaction from day one, and compare against a single agent with the same tools. Without that baseline you cannot tell whether splitting the work is worth the money.

## When is one agent enough?

One agent is enough whenever the steps depend closely on each other, every participant needs the same context, or the whole job fits in one context window. That describes a large share of business processes: preparing a quote, working through a support ticket, drafting an inspection report. Here the case against multi-agent designs is strong.

The sharpest version of that argument comes from Walden Yan at Cognition in [Don't Build Multi-Agents](https://cognition.com/blog/dont-build-multi-agents). He sets out two principles: agents should share full context, including complete traces rather than individual messages, and every action carries implicit decisions that can clash when agents work in parallel. His example: a task to clone a simple game is split into background and character. Without shared context, one sub-agent produces a background in a completely different style and the other a character that does not fit, leaving the final agent to reconcile two incompatible results. Yan recommends a single-threaded agent instead and, once the context grows too long, a deliberate compression of the history so far.

Anthropic and Cognition disagree less than their headlines suggest. Anthropic's own research write-up says that tasks requiring all agents to share the same context are a poor fit, and that most coding tasks contain fewer truly parallelisable parts than research does. Both end up at the same rule of thumb: parallel agents for independent sub-questions, one continuous agent for connected work.

Practical signs that one agent will do:

- The steps build on each other and cannot sensibly run at the same time.
- The agent has fewer than roughly one or two dozen tools, each with a clearly distinct description.
- The relevant context fits comfortably into the model's context window.
- Response time matters because a person is waiting for the result.
- Errors must be traceable, for example because the output is written into an ERP system.

The "one or two dozen tools" mark is a working heuristic, not a hard limit. What counts is whether the model still picks the right tool reliably on your own test cases. For how specialised agents are scoped around individual business processes, see the overview of [AI agents for mid-sized companies](https://www.ruebstudio.de/en/ai-agents). A separate article with decision criteria for single versus multiple agents is in preparation.

## What do you need before building one?

Before building several agents you need the same foundations as for one, only more rigorously: clean tool interfaces, a test set of real cases, full logging of every model call and a clear owner for the overall result. If any of these is missing, adding agents multiplies the problems instead of solving them.

**Data and tools.** Every agent needs stable tools in the sense of [tool use](https://www.ruebstudio.de/en/glossary/tool-use-function-calling) with unambiguous descriptions, such as a "look up item master data" function rather than open database access. Integrations with systems such as SAP, SharePoint or a ticketing tool should already work reliably with a single agent, for example through [MCP servers](https://www.ruebstudio.de/en/guides/ai-agent-integrations/mcp-servers-connect-ai-agents).

**Evaluation.** Without a set of real test cases and expected outcomes you cannot show that the split design beats one agent. The OpenAI Agents SDK documentation explicitly lists investing in evals as part of making model-driven orchestration work.

**Tracing.** For every transaction you need to see which agent received which input, which tools it called and what it returned. Without that trail, interaction bugs are very hard to find.

**Ownership.** Decide who is accountable for the final output and who maintains each agent. When different teams run their own agents, they also need agreements on interfaces and versioning.

**Hosting.** If data must stay on your premises, that applies to every agent in the system. A multi-agent setup on local models needs correspondingly more compute, because several agents run at once. Background on running models on your own infrastructure is available under [sovereign AI](https://www.ruebstudio.de/en/sovereign-ai).

## How do you build one step by step?

The approach that holds up in practice starts with the simplest system that could solve the task and adds agents only when measurements show a specific bottleneck. In Building effective agents, Anthropic recommends finding the simplest solution possible and increasing complexity only when needed.

1. **Build one agent.** One model, the tools it needs, a clear system prompt. For quotations, that might mean: read the enquiry, find the items, fetch prices, write the draft.
2. **Collect test cases and measure.** Take 30 to 50 real, anonymised transactions with known good outcomes. Track accuracy, tokens and run time.
3. **Name the bottleneck.** Is the agent choosing the wrong tools? Is the context overflowing? Is it slow because independent steps run one after another?
4. **Split deliberately.** Move out only the part causing the bottleneck. Too many tools: give domains to sub-agents. Too much context: hand research to sub-agents that return condensed findings. Independent sub-questions: run them in parallel.
5. **Write precise briefs.** Anthropic reports that vague instructions to sub-agents led to duplicated work and misread tasks. Each brief needs a goal, an output format, boundaries and the tools available.
6. **Cap the effort.** Set a maximum number of sub-agents and tool calls per request. Anthropic says its early versions sometimes spawned 50 sub-agents for simple queries.
7. **Compare against the baseline.** The multi-agent version must beat the single agent from step 1 on the same test cases; if it does not, keep the simpler design.

In our own operations, sub-agents have worked best in read-only roles: they research, check or summarise, while a single agent makes the actual decisions and writes the output. That matches Yan's observation that sub-agents work well when they only answer a clearly defined question.

## What are the limits and risks?

The biggest risks sit in the interaction between agents rather than in any single one: conflicting decisions, context lost at handovers, missing verification of the final result and costs that are hard to predict. These failures are systematic and cannot be fixed with better prompts alone.

A systematic study of this is [Why Do Multi-Agent LLM Systems Fail?](https://arxiv.org/abs/2503.13657) by Cemri and co-authors (arXiv, 2025). It analyses more than 1,600 annotated traces from seven multi-agent frameworks and sorts the failures into a taxonomy called MAST, with 14 failure modes in three groups: system design issues, misalignment between agents, and weak task verification. The authors conclude that these failures are systematic and that better system design offers more room for progress than isolated fixes.

Further limits seen in practice:

- **Latency.** A coordinator waiting on several sub-agents is slower than a single call. Anthropic notes that its lead agent runs sub-agents synchronously, so the whole system can stall waiting on one of them.
- **Error propagation.** A wrong intermediate result is treated as fact by downstream agents and rarely questioned.
- **Debugging.** [Agent frameworks](https://www.ruebstudio.de/en/guides/agent-frameworks/ai-agent-frameworks-comparison) speed up the build, but according to Anthropic they add layers of abstraction that can hide the underlying prompts and responses.
- **Security.** Every agent with tools is an attack surface, for example for instructions smuggled into documents. More agents with write access mean more places where that can go wrong.
- **Maintenance.** Each agent has its own prompts and tests. Switching models means re-testing all of them.

## How do I get started?

Start with one agent for a well-defined process, measure it against real cases, and split it up only when a specific bottleneck justifies it. That way you know, for every extra agent, which problem it solves and what it costs.

A good first candidate is a process with clear inputs and a verifiable result, such as [quotation preparation](https://www.ruebstudio.de/en/ai-agents/quotation) or drafting responses in [technical service](https://www.ruebstudio.de/en/ai-agents/technical-service). If it turns out that searching manuals and past tickets overflows the context, a research sub-agent is the obvious second step. For questions spanning many document sources, a parallel search across several sub-agents can make sense, a need that comes up often in [knowledge management](https://www.ruebstudio.de/en/ai-agents/knowledge-management).

Three questions help before you write any code:

- Can the task be split into parts that can be solved without knowing about the other parts?
- Does the value of the result cover the extra token spend?
- Can you measure whether the split system actually beats a single agent?

If any answer is "no", stay with one agent for now. More articles on agent architecture and operations are collected in the [guides section](https://www.ruebstudio.de/en/guides), and key terms are explained in the [glossary](https://www.ruebstudio.de/en/glossary).

As of October 2026. All figures come from the linked sources and refer to the systems and models described there.

## Frequently asked questions

### Does a multi-agent system always beat a single agent?

No. It does well on broad, parallelisable work such as research. On tightly coupled tasks, where each decision depends on the previous one, splitting the work tends to create more coordination errors than it removes.

### How much more expensive is a multi-agent setup?

Anthropic reports roughly 15 times the tokens of a normal chat for its research system, compared with about 4 times for a single agent. Exact figures depend on the pattern and the task, but the direction is clear.

### Do I need a framework to run several agents?

Not necessarily. Supervisor and pipeline patterns can be built with a few direct model API calls. Frameworks such as LangGraph or the OpenAI Agents SDK help with state, handoffs and tracing, but they can also hide prompts and make debugging harder.

### How do MCP and A2A relate to each other?

MCP connects an agent to tools and data sources; A2A connects agents to each other, including across vendors and frameworks. The two protocols are designed to complement each other.

## Sources

- [Anthropic: How we built our multi-agent research system (June 2025)](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Anthropic: Building effective agents (December 2024)](https://www.anthropic.com/engineering/building-effective-agents)
- [Cognition: Don't Build Multi-Agents (June 2025)](https://cognition.com/blog/dont-build-multi-agents)
- [Cemri et al.: Why Do Multi-Agent LLM Systems Fail? (arXiv 2503.13657)](https://arxiv.org/abs/2503.13657)
- [LangChain documentation: Multi-agent](https://docs.langchain.com/oss/python/langchain/multi-agent)
- [OpenAI Agents SDK: Agent orchestration](https://openai.github.io/openai-agents-python/multi_agent/)
- [A2A Protocol: official documentation](https://a2a-protocol.org/latest/)
