Multi-Agent System
A multi-agent system, in the context of modern AI, is an architecture in which multiple distinct AI agents — often each built on an LLM with its own role, instructions, or toolset — collaborate, communicate, or negotiate with one another…
Definition
A multi-agent system, in the context of modern AI, is an architecture in which multiple distinct AI agents — often each built on an LLM with its own role, instructions, or toolset — collaborate, communicate, or negotiate with one another to accomplish a task that would be harder for a single agent to complete alone.
Overview
As LLM-based agents have matured beyond single-turn question answering into systems that can plan, use tools, and take multi-step actions, a natural extension has been to compose multiple such agents together rather than relying on one general-purpose agent to do everything. In a multi-agent system, individual agents are typically given specialized roles (for example, a 'planner' agent that breaks a task into steps, a 'researcher' agent that gathers information, a 'coder' agent that writes code, and a 'reviewer' agent that critiques output), and a orchestration layer or protocol governs how they communicate, hand off subtasks, and reach a final result. Common coordination patterns include sequential pipelines (each agent's output feeds the next), a manager/orchestrator pattern (a central agent delegates subtasks to specialist agents and integrates their responses), debate or critique patterns (multiple agents propose and critique each other's answers before converging, intended to surface errors a single agent might miss), and fully decentralized peer-to-peer communication. Open-source and commercial frameworks such as AutoGen, CrewAI, LangGraph, and OpenAI's Swarm/Agents SDK provide scaffolding for defining agent roles, message passing, and shared state or memory across agents, and Anthropic's Model Context Protocol has been used to standardize how agents discover and invoke shared tools within such systems. Multi-agent systems can improve performance on complex tasks by decomposing them into more tractable sub-problems each agent can specialize in, and by introducing checks (like a reviewer agent) that catch errors a single monolithic agent's output might contain. However, they also introduce new failure modes and costs: increased latency and token/compute cost from multiple LLM calls, coordination failures where agents miscommunicate or loop unproductively, compounding errors if one agent's mistake propagates unchecked to downstream agents, and added engineering complexity in designing robust handoff and error-recovery logic. Multi-agent design is an active area of both research and applied engineering, with ongoing debate over when the added complexity of multiple specialized agents outperforms a single well-designed agent with strong tool access.
Key Concepts
- Composes multiple specialized AI agents rather than relying on one general-purpose agent
- Common patterns: sequential pipelines, manager/orchestrator delegation, debate/critique, peer-to-peer
- Agents typically have distinct roles, instructions, and sometimes distinct toolsets
- Orchestration layer manages communication, task handoff, and shared state/memory
- Frameworks include AutoGen, CrewAI, LangGraph, and OpenAI's Agents SDK/Swarm
- Can improve task decomposition and error-catching via reviewer/critique agents
- Introduces added latency, cost, and coordination-failure risk compared to a single agent
- Model Context Protocol (MCP) is increasingly used to standardize shared tool access across agents
Use Cases
Frequently Asked Questions
From the Blog
8 Metrics for Evaluating RAG and Agent Systems
No single metric tells you whether a RAG or agent system works, because retrieval, grounding, task completion and cost fail independently. These eight metrics cover the distinct failure modes, what each one catches that the others miss, and how to compute each on your own data.
Read More AI & Technology9 Agent Failure Modes to Test Before You Launch
Agents fail in a small number of recognisable ways, and nearly all of them can be provoked deliberately before a user finds them. This article names nine failure modes, from invented tool calls to stale memory and irreversible actions, and gives a concrete test for each that belongs in a pre-launch suite.
Read More AI & TechnologyAgent Cost Control: Step Limits, Budgets and Early Exits
Agent cost is controlled by three mechanisms: a hard step limit, a per-run token budget checked before each call, and an early exit when the answer is already good enough. This article shows how to implement all three, plus model routing per step type.
Read More AI & TechnologyAgent Error Recovery: Retries, Fallbacks and Dead Ends
An agent recovers from a tool failure only if the failure reaches it as a readable observation rather than an exception. This covers turning errors into structured observations, deciding what the runtime retries versus what the model retries, and setting the give-up rules that stop a run looping forever.
Read More