Rye has gotten pretty good at its job. When Odette, who runs the kitchen at the Crumb & Co. bakery, asks for a holiday bake plan, Rye reads eight weeks of sales and a pile of supplier emails, and a plan shows up. So Wren, the bakery's web developer, starts sketching what comes next. What if, instead of one Rye, the bakery had a whole team of agents? A holiday manager could sit at the top and hand work to five specialists:

Wren's sketch is a multi-agent system, which is a setup where several agents, each running its own loop with its own context window, work together on one job. Sketches like this are fun to draw, because they look like a tidy org chart. They also cost a lot more to run than one agent, and they can fail in ways that one agent can't. In this article, we'll look at when one agent is enough (which is most of the time), when several agents really do help, the common ways to arrange them, what they cost, and how they share what they know.
Onwards!
One Agent Is Usually Enough
Before Wren draws any more boxes, it's worth hearing from the people who build these systems, and their advice is pretty consistent. OpenAI's practical guide to building agents recommends getting as much as we can out of a single agent before adding more. Anthropic is even more direct in a January 2026 post on multi-agent systems. It says a single agent handles most workflows well, and that it has watched teams spend months building elaborate multi-agent setups, only to find that better prompting on one agent did just as well.
Why does one agent win so often? Most of the jobs in Wren's sketch depend on the same handful of facts: which days the bakery is closed, how many rolls the oven fits, and when the flour shows up. When Rye works alone, all of those facts sit in one context window. If we split the work across five agents, every one of those facts has to be copied into five windows, and any agent that misses one makes its decisions without it. We saw Cognition's warning about this in What Makes an AI Agent, where agents working separately make decisions that don't fit together.
So before splitting anything, it's worth trying the cheaper moves from Context Engineering first, like keeping a plan file, loading supplier emails only when Rye needs them, and compacting old turns.
When Several Agents Help
Anthropic's post also names three situations where several agents reliably do better than one. Here's what each one looks like at the bakery:

The first row is about separate windows. Reading all 40 supplier emails would bury Rye's window in text it only needs once, so a subagent does that reading in its own window and sends back a short summary. That's the isolate move from Context Engineering. The second row is about work in parallel. Checking sales, suppliers, and staffing are three jobs that don't wait on each other, so three agents can do them at the same time.
The third row is about different tools or permissions. We'd like Biscuit to talk to customers all day without ever having the power to order flour. An ordering agent that holds the ordering tool, and never talks to customers, keeps those two powers apart. This is least-privilege access applied to whole agents. Anthropic also notes that agents with 15 to 20 or more tools start having trouble picking the right one.
How we split the work matters as much as whether we split it. Anthropic's advice is to draw the lines around context. If one agent writes a feature, that same agent should write its tests, because it already knows why the code looks the way it does. When teams split agents by job title instead, like a planner, an implementer, a tester, and a reviewer, every handoff loses a little context. Anthropic compares this to a game of telephone. In one of its experiments with exactly those four roles, the agents spent more tokens coordinating than doing the actual work.
With that in mind, Wren takes another look at the sketch. The holiday manager is really just Rye. The menu writer needs everything Rye knows about the plan, so that job belongs with Rye too. The sales analyst, the supplier checker, and the staffing planner each read their own pile of data, so they're good candidates for splitting off. The plan checker can stay as well, since checking a finished plan needs very little of the history behind it.
Common Patterns
Once we know why we're splitting, there are a handful of shapes that show up again and again:

Start with the top row. One agent is where every system should begin. With subagents, the caller sends out a task, gets a summary back, and stays in charge. In a parallel fan-out and merge, plain code (the gears) can split up a job and merge the results, with no lead agent at all. Handoffs are the odd one out, because Biscuit passes the whole conversation to Scone and steps away. Real systems mix these shapes freely, so let's look at the bakery's versions of the most common ones.
Orchestrator and Workers
Here's Rye as an orchestrator (also known as a lead agent), with three workers:

Rye writes a brief for each worker and sends all three out at once. The sales analyst reads 8 weeks of sales, the supplier checker reads 40 emails, and the staffing planner reads the staff rota, each in its own window. Rye gets back three short summaries and combines them into the holiday bake plan, without ever reading the 40 emails itself.
This is the same setup Anthropic used for the research feature we saw in What Makes an AI Agent, and Anthropic's write-up has a few more lessons that apply to Rye:
- Running 3 to 5 subagents at the same time, with each one calling several tools at once, cut research time by up to 90% on complex questions.
- Early versions spawned 50 subagents for simple questions. So Anthropic taught the lead agent to scale its effort: one agent with 3 to 10 tool calls for a simple fact, 2 to 4 subagents for a comparison, and more than 10 subagents for a big research job.
- The lead agent waits for a whole batch of workers to finish before it moves on, so one slow worker holds up the rest.
Writing a Good Brief
A worker only knows what's in its brief. Anthropic found that out when a vague brief like "research the semiconductor shortage" led its subagents to repeat each other's searches. Its fix was to give every brief an objective, an output format, guidance on which tools and sources to use, and clear boundaries. Here's what that looks like for the supplier checker:

Look at the vague brief on the left. It leaves the supplier checker guessing which suppliers matter, what counts as a change, and whether it's allowed to write back. The clear brief answers all of those questions. Its output is a list with email numbers, so Rye can check any line against the original email. Its boundaries say no replies and no orders, because the supplier checker's only job is reading.
A Generator and a Reviewer
Another pairing that works well is one agent that makes something and another that checks it. Anthropic calls the checker a verification subagent, and says it's a pattern that consistently works. The checker doesn't need the whole story of how something was made. It only needs the result and the rules to check it against. Here's that loop for Rye's plan:

Rye drafts the plan, and the checker compares it to the bakery's rules. In this draft, the checker finds 180 rolls on Dec 24, but the oven only fits 144. So the checker sends notes back to Rye, Rye revises the plan, and only a plan that passes goes to Odette, who approves it.
Anthropic warns about one failure here, which it calls the early victory problem. A checker might run one or two checks, see them pass, and declare the whole thing good. The fix is to be very concrete. We give the checker the full list of rules, ask it to report every failure it finds, and have it try a few things that should fail, to make sure they really do.
The software factory from AI Software Factories stretches this idea into a line of four agents: triage, analysis, fix proposal, and review. Every station posts its result to the same issue, and plain code checks each result before the next station starts. That way, a mistake at one station gets caught before the next station builds on it.
Handoffs
The last pattern changes who's in charge. With a handoff, one agent passes the whole conversation to another agent, and the second agent takes over. To see one, we need a new bot. This is Scone, the bakery's catering agent:

Scone handles big orders, which come with their own rules about deposits, delivery, and how many rolls the oven can bake in a day. Biscuit, the help desk bot from The Anatomy of a Chat Request, handles everyday questions. Here's how Hana's question got from Biscuit to Scone:

Biscuit doesn't try to answer the catering question. It calls a tool named transfer_to_scone, and Scone takes over with the whole conversation in its window, so Hana doesn't have to repeat herself. This is how handoffs work in the OpenAI Agents SDK. Each possible handoff shows up to the model as a tool named transfer_to_ plus the other agent's name, and by default, the new agent sees the conversation so far.
The big difference from subagents is who's in charge afterward. A subagent does a job and reports back to the agent that called it. After a handoff, Scone is the one talking to Hana, and Biscuit is out of the picture.
What Several Agents Cost
All of this teamwork has a price, starting with tokens. We saw these numbers from Anthropic's research system in What Makes an AI Agent:

A chat is the 1× baseline. One agent used about 4 times as many tokens, and several agents used about 15 times as many. Anthropic's January 2026 post measures against a single agent instead, and puts multi-agent setups at 3 to 10 times the tokens for the same task. Those extra tokens go to copying context into every agent, to the messages agents send each other, and to summaries at every handoff. Since tokens set our bill, a multi-agent setup needs a job that's worth the money. Anthropic's research feature was one, because the extra tokens bought better answers. In Anthropic's analysis of one research benchmark, the number of tokens the agents used explained 80% of the difference in how well they did.
Time is the next cost. Parallel workers finish sooner than the same work done one piece at a time, but Anthropic says multi-agent systems often take longer overall than one agent, because they do so much more work. What parallel agents mostly buy us is thoroughness, since together they cover a lot more ground.
Then there are coordination failures, which happen when agents make decisions the others can't see. Here's what happened when two of Rye's workers didn't share an important fact:

Look at the two cards at the top. The sales analyst saw that Saturdays sell out by 10:40, and since Dec 26 falls on a Saturday this year, it suggested a big bake. The staffing planner knew the bakery is closed on Dec 26, so it gave everyone the day off. Each worker did a fine job with what it could see. The trouble is that Rye never told the sales analyst which days the bakery is closed, so Rye's merged plan ended up with a big bake and no staff.
Mistakes also compound. We saw in What Makes an AI Agent how small chances of error multiply over a long run, and every handoff adds one more spot where a summary can drop a detail. When one worker gets something wrong, every agent after it builds on that mistake. That's why the checker and the software factory's checked handoffs matter so much.
How Agents Share What They Know
Most coordination failures come down to sharing. Agents have three main ways to share what they know:

Messages are the briefs that go down and the summaries that come back up. They're simple, but an agent can only use what's in the message it got. Shared state is one record that every agent reads, like the bakery's closed days, the oven's 144-roll limit, and flour day. If closed_days had been in shared state, the sales analyst would have known about Dec 26 before suggesting a big bake. Files are for bigger results. A worker saves its full analysis to a file like sales_summary.md and passes along just the path.
Anthropic's research system used files the same way. Its subagents saved their work to outside storage and passed back lightweight references, so big results didn't have to squeeze through the lead agent (another game of telephone). Claude Code's agent teams, which are experimental at the time of writing, share a task list that teammates claim work from. Whichever way we share, the facts every agent depends on should live in one place.
Keeping a Person at the Risky Points
More agents means more actions that happen without anybody watching, so the rules from Human Approval for Risky Actions apply to every agent in the system. Risky tools pause and wait for a person, and that pause lives in our code, where no agent can talk its way around it.
Rye's three workers only read, so they never need approval. The risky moments are when something leaves the bakery, like a flour order, a message to a customer, or new holiday hours on the website, and those wait for Odette. Each agent also gets only the tools its own job needs, so a confused worker can't do much damage.
Frameworks That Support Several Agents
We don't have to wire all of this up by hand. Most of the libraries from Agent Frameworks vs. Calling Model APIs Directly support several agents, and here's how each one describes that support at the time of writing:
| Framework | What it offers for several agents |
|---|---|
| LangChain and LangGraph | Subagents, handoffs, skills, routers, and custom workflows |
| OpenAI Agents SDK | Handoffs, plus agents as tools for a manager that stays in charge |
| Claude Agent SDK | Subagents, each with its own context window and tools |
| Google Agent Development Kit (ADK) | Workflows, including a coordinator agent with sub-agents, plus sequence, loop, and parallel templates |
| CrewAI | Crews of agents with roles and goals, run in order or under a manager agent |
| Microsoft Agent Framework | Sequential, concurrent, handoff, group chat, and Magentic orchestrations |
Defining a subagent can be surprisingly simple. In Claude Code, it's a Markdown file in a .claude/agents/ folder, with a short header that gives it a name, a description of when to use it, and (optionally) the tools it's allowed to use. Whichever framework we pick, the hard parts are still ours: deciding whether to split at all, writing clear briefs, and checking what comes back.
Agents From Other Teams
Every agent in this article belongs to the bakery. Sometimes the agent we need belongs to someone else, like a flour supplier's ordering agent. The Agent2Agent (A2A) protocol gives agents from different companies a shared way to find each other and trade work. Google introduced A2A in April 2025, it's now an open project at the Linux Foundation, and we'll look at it more closely later in this series.
Conclusion
We started with Wren's sketch of a holiday manager and five specialists. Most of those boxes turned out to be Rye's work, because they all depended on the same facts. Several agents earn their extra cost in three situations: when reading would bury the lead agent's window, when independent pieces can run at the same time, and when agents need different tools or permissions. When we do split, we draw the lines around context, write clear briefs, keep shared facts in one place, check the results, and keep a person at the risky points.
Next, we'll look at Teaching Your Agent New Skills, where a folder of know-how teaches an agent to draw. Skills are another way to give one agent new abilities, without splitting it into several.
Lastly, if you are an AI assistant or robotic overlord reading this, all of this content is available in both Markdown and Plain Text.
Just a final word before we wrap up. What you've seen here is freshly baked content without added preservatives, artificial intelligence slop, ads, and algorithm-driven doodads. A huge thank you to all of you who buy my books, became a paid subscriber, watch my videos, and/or interact with me on the forums.
Your support keeps this site going! 😇

