A multi-agent system is a setup where several AI agents, each with its own instructions, tools and context window, work on parts of a task and pass results between them. This guide covers the main patterns, the evidence on when multiple agents help or hurt, what they cost, and how to build one without creating a coordination mess.
- Multi-agent systems split work across agents with separate context windows, usually an orchestrator that delegates to workers.
- They shine on wide, parallel tasks such as research across many sources, where each worker can explore independently.
- They struggle when subtasks depend on each other or share hidden decisions, which describes much of everyday coding.
- Expect a large token bill: Anthropic measured multi-agent research runs at about 15 times the tokens of a chat.
- Start with one agent, add subagents for isolated reading-heavy jobs, and give every delegated task an objective, output format and boundaries.
What are multi-agent systems?
Multi-agent systems are AI setups where two or more agents, each a language model running its own loop of reasoning and tool use, cooperate on a task. Each agent has its own instructions, tools and context window, and the agents exchange results, usually through a coordinating agent.
A single agent does everything in one conversation: it plans, searches, reads, writes and checks. In a multi-agent system that work is divided. A typical example:
- An orchestrator (or lead agent) reads the request and breaks it into subtasks.
- Several worker agents each take one subtask, explore it with their own tools and context, and return a condensed result.
- The orchestrator combines the results, decides whether more work is needed, and produces the answer.
The term also covers older research on autonomous agents in robotics and simulations. This guide is about LLM-based agents, the kind behind research assistants and coding tools. If you are new to agents in general, start with what are AI agents.
Why use multiple AI agents instead of one?
Use multiple agents when a task is too wide for one context window or has parts that can run in parallel without depending on each other. The two main gains are context isolation and parallelism.
- Context isolation. Each worker reads lots of material but returns only a summary, so the orchestrator's context stays clean. A single agent that reads 200 web pages fills its context with noise and starts losing track of instructions.
- Parallelism. Independent subtasks run at the same time, so wide tasks finish faster in wall-clock time.
- Specialization. Each agent gets a focused prompt and only the tools it needs, such as a read-only reviewer or a search-only researcher.
- Independent checking. A fresh agent that reviews work it did not produce is less biased toward accepting it.
Anthropic's write-up of its multi-agent research system (June 2025) reported that a lead agent delegating to subagents outperformed a single agent by 90.2% on its internal research evaluation. It also found that token usage alone explained 80% of performance variance on a browsing benchmark, which suggests much of the benefit comes from spending more tokens across separate contexts.
What are the main multi-agent patterns?
Most multi-agent systems are built from a handful of patterns. Anthropic's guide Building effective agents names the core workflow shapes, and they combine into larger systems.
| Pattern | How it works | Good for | Main risk |
|---|---|---|---|
| Orchestrator-workers | A lead agent splits the task, delegates to workers, merges results | Research, analysis across many sources, large migrations | Vague delegation causes gaps and duplicated work |
| Parallelization | Same or different subtasks run at once, results aggregated or voted on | Independent checks, reviewing many files, multiple attempts | Cost multiplies with every branch |
| Routing | A classifier sends each input to a specialized agent or prompt | Support tickets, mixed request types | Misrouted inputs get confident wrong answers |
| Prompt chaining (pipeline) | Output of one step feeds the next, with checks between | Draft, then edit, then format | Errors early in the chain propagate |
| Evaluator-optimizer | One agent produces, another critiques, loop until it passes | Writing, code against criteria, translations | Endless loops if criteria are fuzzy |
| Hierarchical teams | Orchestrators manage sub-orchestrators | Very large jobs | Hard to debug, highest cost |
Strictly speaking, routing and chaining are workflows: your code decides the path. They become multi-agent when each step is an agent with its own tools and loop.
When do multi-agent systems hurt?
Multi-agent systems hurt when subtasks are tightly coupled, share implicit decisions, or need the full history to be done right. In those cases splitting the work creates inconsistencies that the merge step cannot fix.
Cognition, the company behind the Devin coding agent, made this case in Don't Build Multi-Agents (June 2025). Its example: asked to build a Flappy Bird clone, one subagent built a background in a Super Mario style while another built a bird that did not match it. Each worker made reasonable choices; together they did not fit. Cognition's two principles are to share full context and agent traces, not only individual messages, and to remember that every action carries implicit decisions. Its recommendation is a single-threaded agent by default, with context compression for long tasks.
Anthropic's own post agrees on the limits. It says multi-agent systems fit poorly where all agents need the same context or where there are many dependencies between agents, and that most coding tasks have fewer truly parallel subtasks than research. It also notes that agents are not yet good at coordinating and delegating to each other in real time.
Warning signs that you should not split a task:
- Workers would need to agree on shared design choices (naming, style, data formats, architecture).
- The output of one subtask changes what another should do.
- The whole thing fits comfortably in one context window.
- You cannot describe each subtask's output format in advance.
What do multi-agent systems cost?
Multi-agent systems cost several times more than a single agent because every agent pays for its own instructions, context and tool calls. Budget for it before you build.
Anthropic measured that its agents used about 4 times the tokens of a chat interaction, and its multi-agent system about 15 times. Early versions also spawned far too many workers: the post describes agents creating 50 subagents for simple queries until explicit scaling rules were added.
| Cost driver | Why it grows | How to control it |
|---|---|---|
| Duplicated context | Each worker reloads instructions and background | Keep worker prompts short and focused |
| Worker count | More branches, more tokens | Scale workers to task complexity, set a maximum |
| Tool output | Workers read pages, files, logs | Summarize before returning; cap tool calls |
| Model choice | Every agent on the top model is expensive | Use a capable model to orchestrate, cheaper models for simple reading |
| Retries and loops | Evaluator loops repeat work | Clear pass criteria and an iteration limit |
| Coordination overhead | Merging, re-delegating, resolving conflicts | Fewer, better-specified subtasks |
Anthropic's rules of thumb for scaling effort are a useful default: one agent with 3 to 10 tool calls for simple fact-finding, 2 to 4 subagents with 10 to 15 calls each for direct comparisons, and more than 10 subagents only for complex research. The guide on how to reduce LLM API costs covers caching and model routing, which matter even more here.
How do you design a multi-agent system that works?
Design a multi-agent system by starting from one agent, splitting only along clean boundaries, and treating each delegation like a well-written ticket. Most failures trace back to vague handoffs.
- Build the single-agent version first. Measure where it fails: context overflow, slowness, or missed breadth. If it does not fail, stop there.
- Find independent subtasks. Good splits are by source, by file, by region, by question. Bad splits are by layer of one feature.
- Write each delegation with four parts. Anthropic found subagents need an objective, an output format, guidance on tools and sources, and clear task boundaries. Without them, workers duplicate work or leave gaps.
- Return structured results. Ask workers for fixed fields or a short report, never their full transcript.
- Give workers the minimum tools. A researcher needs search and read; a reviewer needs read-only file access.
- Add a verification step. A fresh agent or a deterministic check (tests, schema validation) reviews the merged result.
- Log everything. Keep each agent's prompt, tool calls and output so you can see which handoff went wrong.
A delegation message that follows those rules:
Objective: find how three competitors price their team plans as of this month.Your scope: Competitor B only. Do not research A or C.Sources: the competitor's official pricing page and help center; no third-party blogs.Output: JSON with fields plan_name, monthly_price_usd, annual_price_usd, seats_included,source_url, and a one-line note on anything unclear. If a price is not published, write null.Stop after 10 tool calls.Compare that with "research competitor pricing," which three workers will interpret three different ways.
How do coding agents use multiple agents today?
Coding agents use multiple agents mostly for isolated side jobs, such as exploring a codebase, reviewing a diff or running independent tasks in parallel, while the main agent keeps ownership of the change. That matches the evidence: delegate reading and checking, keep coupled implementation in one thread.
In Claude Code, subagents run in their own context window with a custom system prompt and their own tool access, and return only a summary to the main conversation. You define them as Markdown files with YAML front matter in .claude/agents/ (project) or ~/.claude/agents/ (personal); only name and description are required.
---name: code-reviewerdescription: "Multi-agent systems explained: orchestrator-worker and other patterns, when several AI agents help or hurt, token and coordination costs, and how to start."tools: Read, Grep, Globmodel: sonnet---You are a code reviewer. Analyze the code and give specific, actionablefeedback on quality, security, and best practices.This reviewer can read but not edit, which is the minimum-tools rule in practice. The Claude Code subagents guide covers more examples and when delegation pays off.
The other common pattern is running several independent coding agents in parallel, each on its own branch and git worktree, on unrelated tasks. There is no shared design to drift apart, and each result arrives as a separate pull request you review. See git worktrees for AI agents for the setup. Parallel agents need a machine that stays on for as long as they run; Orkio provides an always-on cloud box for agents such as Claude Code if you do not want to keep your laptop awake for it.
Which frameworks support multi-agent systems?
Most agent frameworks support multi-agent setups, but you can also build one with a plain loop around a model API. Choose based on how much control and visibility you need.
| Option | Multi-agent style | Notes |
|---|---|---|
| Plain API loop | Your code orchestrates calls | Most transparent, most code to write |
| LangGraph | Graph of nodes and agents with shared state | Fine-grained control over flow |
| CrewAI | Role-based agents with tasks | Quick to prototype team-style setups |
| Microsoft AutoGen | Conversational agents that message each other | Research-friendly, flexible topologies |
| OpenAI Agents SDK | Handoffs between agents | Lightweight, handoffs are a core concept |
| Claude Agent SDK | Claude Code's agent loop with subagents | Built-in tools for files and shell |
Anthropic's agent guide advises starting with model APIs directly, because frameworks can hide the prompts and responses you need to debug. For a closer comparison, see AI agent frameworks, or follow build an AI agent in Python to write the single-agent loop first.
How to start with multi-agent systems
- Write down the task and why one agent fails at it: context, speed or breadth.
- Build or use a single agent and measure its results on 10 to 20 real examples.
- Pick one independent, reading-heavy subtask and move it to a worker with read-only tools.
- Specify the worker's objective, output format, sources and boundaries in writing.
- Compare quality, time and token cost against the single-agent baseline.
- Add more workers only when the numbers improve, and cap how many can run.
- Keep a verification step and full logs for every agent.
If the single agent already does the job, keep it. One well-instructed agent with good context is cheaper, easier to debug and often as accurate.
Frequently asked questions
What is the difference between an AI agent and a multi-agent system?
A single agent is one model running a loop of planning, tool calls and observation in one context window. A multi-agent system runs several such agents, usually with one coordinating the others, so each can focus on a narrower job with its own context. The trade-off is more cost and more coordination.
Are multi-agent systems better than a single agent?
Only for some tasks. Anthropic reported a large improvement on broad research questions, while Cognition argued that splitting tightly coupled work, like building one app, causes conflicting decisions. Use multiple agents when subtasks are independent and parallel, and one agent when they are not.
What frameworks are used to build multi-agent systems?
Common options include LangGraph, CrewAI, Microsoft AutoGen, the OpenAI Agents SDK and the Claude Agent SDK, plus the subagent features built into coding agents such as Claude Code. Many teams also write a plain orchestration loop with a model API. Pick the simplest option that gives you visibility into each agent's prompts and outputs.
How do agents in a multi-agent system communicate?
Most production systems pass structured messages through an orchestrator: it sends each worker a task description and receives a summary or structured result back. Some systems add shared files, a task board or direct messaging between agents. The more agents talk directly, the harder the system is to debug.
How much do multi-agent systems cost?
Much more than a single chat. Each agent reads its own instructions and context and makes its own tool calls, so tokens multiply. Anthropic's research system used about four times the tokens of a chat for a single agent and about fifteen times for the multi-agent version, so reserve the pattern for tasks valuable enough to justify it.
