Many agents working together: multi-agent systems

What you’ll learn

This is lesson 8 of Track 20 (AI Agents and Tool Use) and the fifth lesson of Phase 2, The design patterns that make agents work. The previous lesson ended on a plan whose steps looked like separate jobs, which raises a natural question: should one agent do all of them, or should each job go to a different agent built for it?

That is the idea behind multi-agent systems, and it is one of the most-hyped patterns in the field, which is exactly why this lesson spends as much time on when not to use it as on when to. You will learn what a multi-agent system is (several specialized agents held together by a coordinator or a pipeline), the three real advantages (specialization, parallelism, modularity), and the cost the marketing usually leaves out (coordination: communication overhead, more failure points, who-decides-what ambiguity, harder debugging, more latency). The throughline is that the real question is fit, not ranking: not whether multi-agent is “better,” but whether a given task splits cleanly enough that specialists beat one well-designed generalist, and whether that is worth the coordination cost.

The track structurally mirrors Microsoft’s “AI Agents for Beginners” (MIT-licensed), with the Berkeley CS294 LLM Agents course as a depth reference. Full attribution is in this lesson’s references.

Where this fits

This lesson follows planning directly: a plan names sub-tasks that often look like separate jobs, and this lesson asks whether those jobs should go to separate agents. It also extends the tool-definition lesson to the system level (a single agent with too many tools that confuses itself is one reason to split into specialists with smaller toolboxes). The next lesson, Agents that self-check, turns the agent’s attention on itself: metacognition is a reflection step that raises a single agent’s reliability without adding a second one, a cheaper alternative to coordination cost.

Before you start

Prerequisites: the earlier lessons in the track, especially Planning (the immediately prior lesson; a plan’s sub-tasks are what raise the split-or-not question) and The tool-use design pattern in depth (specialization is that lesson’s tool-definition point applied at the system level). You do not need to code. If you understand a single agent as a model in a loop with tools, you have the background; a multi-agent system is just several of those that have to communicate.

By the end, you’ll be able to

Describe what a multi-agent system is and the two shapes that hold it together (a delegating coordinator or a handoff pipeline)
Name the three advantages of splitting work across agents (specialization, parallelism, modularity)
Name the coordination cost the source material usually omits (communication overhead, more failure points, who-decides-what, debugging and latency)
Judge by fit, not ranking, when specialized agents beat one well-designed generalist
Apply the start-with-one-split-when-you-hit-a-wall path to a concrete task

Time and difficulty

Read time: about 11 minutes
Practice time: about 15 minutes (a self-check, two applied design exercises, and flashcards)
Difficulty: standard