Definition
A multi-agent system (MAS) is an architecture in which two or more AI agents — each with a distinct role, prompt, model, or tool set — coordinate to complete a task that a single agent would handle worse, slower, or not at all. Instead of one generalist working alone, you get a team: a researcher, a critic, a coder, a coordinator.
The term predates today's models — it comes from decades of distributed-AI research on swarms, negotiation, and emergent coordination — but in 2026 it almost always means LLM-driven agents. The key thing to understand up front is that more agents is not automatically better. A multi-agent system buys you specialization and parallelism at a real cost in tokens, latency, and coordination complexity, and the central skill is knowing when that trade is worth making.
How It Works
A multi-agent system takes a goal, splits it across agents, and coordinates their work back into a single result. Three decisions define it. First, who does what: each agent gets a narrow role with a tailored prompt and tool set — a "researcher" with web search, a "reviewer" with no tools but instructions to find flaws — because a focused agent with three tools outperforms a generalist juggling thirty. Second, who is in charge, the control question that fixes the topology: in a centralized design a supervisor decides which worker handles what and merges the outputs, while in a decentralized design peer agents hand work to each other directly with no coordinator. Third, how they talk — agents exchange information by passing messages or by reading and writing shared state; when that coordination is a pipeline the developer designed rather than something the agents work out themselves, it becomes an agentic workflow.
The costs of this coordination are concrete. Anthropic reported that its multi-agent research system consumed roughly 15x the tokens of a single-agent chat — because every agent is its own chain of LLM calls and the supervisor adds more on top. Latency stacks the same way: in a three-level hierarchy where each coordinator makes a 2-second call, that is roughly 6 seconds of overhead before a single worker even starts — an illustration of how depth adds delay, not a fixed figure. You accept those costs when parallelism and specialization win them back, and not otherwise.
Types
Multi-agent systems are organized by topology — who talks to whom and who is in charge. Three patterns dominate 2026 production systems:
- Supervisor / orchestrator-worker — the most common shape. A lead agent reads the goal, dispatches subtasks to specialist workers, and synthesizes their results. Its strength is control: the supervisor can enforce per-branch token budgets, cancel a worker that wanders, and produce a clean audit trail.
- Hierarchical — supervisors of supervisors. Used only for genuinely large tasks, because each added level multiplies coordination latency and cost.
- Network / swarm — peer agents hand work to each other directly with no central coordinator. Flexible and resilient to any single agent failing, but harder to predict and debug, and prone to loops where agents bounce a task back and forth.
These map onto the classical distinctions the field was built on — cooperative teams, competitive market-based agents, and the emergent behavior of swarms — but for building LLM systems, topology is the choice that actually matters. For the orchestration patterns inside a single agent's loop, see agentic workflows.
Real-World Applications
Named, in-production uses as of 2026:
- Research systems — Anthropic's multi-agent research feature uses a lead agent that spawns parallel subagents to explore different facets of a question at once, then synthesizes their findings. Research is the canonical fit because the subtasks are genuinely independent.
- Software engineering — some coding platforms run a planner-coder-reviewer split, though this is contested: Cognition (makers of Devin) argued in 2025 that long coding tasks need one shared context and that splitting them across agents fragments understanding and produces conflicting work.
- Customer operations — a triage agent classifies an incoming request and hands it to a specialist agent (refunds, technical, billing), each with access to only the systems its role needs.
- Business automation — orchestration platforms like n8n let teams wire specialist agents into a pipeline that routes and processes work end-to-end.
The pattern that fits is one where the work genuinely divides into independent or specialized parts. Where a task is a single line of reasoning, splitting it across agents tends to hurt.
Key Concepts
Specialization is the main reason to go multi-agent: narrow roles with focused tools and prompts outperform one generalist context trying to do everything. The deepest design tension is context sharing vs. isolation — isolated contexts keep each agent focused and cheap but risk agents making conflicting assumptions, while a shared context keeps everyone aligned but grows large and expensive. Getting that balance wrong is the root of most multi-agent failures — which is why what each agent stores and shares across turns is the province of agent memory.
The plumbing is increasingly standardized. Communication protocols connect the pieces: function calling and the Model Context Protocol (MCP) link agents to tools, while the Agent2Agent Protocol (A2A) lets agents delegate to one another across vendors — the single agent-to-agent standard since IBM's ACP merged into it in August 2025. On top of these, orchestration frameworks — CrewAI, AutoGen, LangGraph, and the OpenAI Agents SDK — supply the coordination logic (roles, message routing, shared state, retries) so you design the team rather than the machinery.
Challenges
These failure modes are specific to running several agents rather than one, and they are why multi-agent is not a default. The headline problem is that cost explodes: the 15x token figure above is the rule, not an outlier, because each agent is a full agent loop and coordination piles calls on top — so you can pay an order of magnitude more for a modest quality gain. Just as damaging is context fragmentation. When agents hold separate contexts they decide on partial pictures and produce work that does not fit together — the coder implements what the planner never intended. This is Cognition's core argument against multi-agent for coherent tasks, and it is exactly the failure that shared state is meant to prevent.
The other two problems compound with scale. Errors propagate: one agent's mistake becomes another's input, so a researcher that hallucinates a fact feeds it downstream as ground truth, and a wrong result can pass through several agents before anyone catches it. And coordination latency grows with depth, because every hop between agents is another LLM call in the critical path — deeper hierarchies get slower even when the underlying work is fast.
Future Trends
- Standardized inter-agent protocols — A2A and ACP aim to do for agent-to-agent delegation what MCP did for tools: let agents from different teams and vendors interoperate without bespoke integration.
- Cross-organization agent networks — as those protocols mature, agents built by different companies will delegate to one another, forming systems no single team controls end-to-end.
- Cheaper coordination — smaller, faster models handling the routing and supervision roles, reserving expensive frontier models for the steps that truly need them, to blunt the token-cost problem.