TL;DR: A multi-agent system splits one task across several AI agents - typically an orchestrator that plans and delegates, plus workers that each handle a piece. The win is focus and parallelism: each agent gets a clean context and a narrow job. The cost is coordination: agents cannot read each other's minds, so everything they share must be passed explicitly.
How it works
A single agent hits two walls as tasks grow. Its context window fills with the residue of every step, drowning the current decision in old detail. And one agent can only do one thing at a time. Multi-agent systems attack both: each agent starts with a fresh context containing only its slice of the job, and independent slices can run simultaneously.
The dominant pattern is orchestrator-worker. A lead agent reads the goal, breaks it into subtasks, and spawns a worker for each with focused instructions. Workers report results back; the orchestrator integrates them, spawns follow-ups if gaps remain, and assembles the final answer. A research task illustrates it: the orchestrator splits "evaluate this market" into competitor analysis, pricing research, and regulatory review, three workers investigate in parallel, and the lead merges their findings into one report.
Two other shapes recur. Handoff systems pass a conversation between specialists - a triage agent forwards a billing question to a billing agent, which owns it from there - so exactly one agent is responsible at any moment. Debate or review setups make agents check each other: one drafts, another critiques, a pattern that catches errors a single self-reviewing agent tends to miss. Roles differ in prompt and toolset, not necessarily in model - though many systems give a stronger model the orchestrator seat and cheaper ones the routine work.
The hard part is coordination. Workers do not share memory: anything one learns reaches another only if it is written into a message, a shared file, or a store both can reach. Instructions must travel with enough context to survive the handoff - a vague subtask brief produces a confidently wrong worker. Token costs multiply with every agent, and debugging turns into reading several interleaved transcripts. The practical rule: use multiple agents when subtasks are genuinely separable and parallelizable, and stay single-agent when every step depends on the one before it.
Where it sits in the AI stack
A multi-agent system is a layer of delegation above individual agent loops:
Observability matters more here than anywhere else in the agent stack - understanding why a system of five agents failed requires tracing that stitches all five transcripts into one timeline.
Key tools and implementations
-
Subagent spawning
Agent harnesses that let a lead agent launch scoped child agents as a built-in tool call.
-
CrewAI
A framework organized around role-based agent teams with assigned tasks and processes.
-
LangGraph
Graph orchestration where each node can be an agent and edges define who hands off to whom.
-
Handoff APIs
Provider SDK primitives for transferring a live conversation between specialist agents.
Related entries
- AI agent A system where a language model plans, calls tools, and loops on results to finish a task with minimal supervision.
- Agentic workflow A multi-step process that chains, branches, or loops model calls so an AI system can complete tasks too big for one prompt.
- Agent memory Mechanisms that let an AI agent carry information across steps and sessions beyond what fits in the context window.
- Tracing Recording every step of an AI request as a tree of spans so you can see exactly what the system did.