Multi-Agent Systems

The plain-language idea

A single agent (see the previous lesson) can, in principle, be handed every tool it might ever need and one long system prompt covering every situation. That works, but it doesn't scale gracefully — the more tools and instructions one agent juggles, the harder it is to keep its behavior reliable, since every added tool and instruction is a new way for the prompt to get confused about which rule applies when.

A multi-agent system splits that single generalist into several narrower specialist agents, each with a smaller, more focused toolset and prompt: a research agent that only searches and reads, a coding agent that only writes and edits code, a review agent that only critiques. Coordination between them typically takes one of two shapes:

• Supervisor/orchestrator pattern — one agent's job is purely to break the overall goal into subtasks and delegate each one to the right specialist, then assemble their outputs into a final result. The supervisor doesn't do the specialist work itself.
• Direct handoff — agents pass control to each other directly when a task moves outside their lane (a research agent finishes gathering context and hands off to a coding agent), without a central coordinator making every routing decision.

The reasoning behind why this can outperform one generalist agent is the same reasoning behind why a team of specialists often outperforms one generalist on a complex task: a narrower prompt and toolset is easier to keep correct and predictable than one agent trying to be good at everything at once.

See it in a real thing: a supervisor delegating a "fix this bug and explain it" request

// Rough sketch of a supervisor pattern — conceptual, not a specific SDK's API
async function handleRequest(goal: string) {
  const plan = await supervisorAgent.plan(goal);
  // plan: [{ agent: "research", task: "find where this bug originates" },
  //        { agent: "coding",   task: "write a fix for the identified cause" },
  //        { agent: "review",   task: "check the fix and explain it clearly" }]

  const results: Record<string, string> = {};
  for (const step of plan) {
    results[step.agent] = await specialists[step.agent].run(step.task, results);
  }
  return supervisorAgent.assemble(results);
}

Each specialist here can have a short, focused prompt ("you only research and report findings, you never write code") instead of one agent's prompt having to cover research and coding and review conventions all at once, with rules for when each applies.

What people usually miss

Watch out

• More agents means more total model calls, which means more cost and latency, not less — splitting work across specialists doesn't reduce the total amount of "thinking" being paid for, it usually increases it, in exchange for reliability.
• The supervisor is doing real work too. Planning and delegating is itself a model call with its own prompt and its own chance of misrouting a subtask to the wrong specialist or misassembling the final result.
• Specialization is a reliability tradeoff, not a capability upgrade. A narrower agent isn't smarter than a generalist one — it's just less likely to get confused about which of many instructions applies in a given moment, because it has fewer instructions to begin with.
• Direct handoff and supervisor patterns aren't mutually exclusive. Real systems often mix both — a supervisor for the top-level breakdown, with some specialists handing off to each other directly for a tightly coupled sub-step.
• This only pays off once one agent's toolset/prompt genuinely gets unwieldy. Reaching for multiple agents on a task simple enough for one is adding orchestration overhead for no real reliability gain.

Why this matters in interviews

"When would you use multiple agents instead of one?" is a real system-design question, and the honest answer — narrower, more reliable specialists at the cost of more orchestration and more total model calls — is what separates a candidate who's reasoned about the tradeoff from one who's just repeating that "multi-agent" sounds more sophisticated.