Multi-agent orchestration: the five patterns, and how a company runs on them

What multi-agent orchestration is, the five patterns it uses, and when to use one agent rather than several. With how our own AI team hands work from agent to agent: where it broke, what waits for a person, and what stops it.

Search for "multi-agent orchestration" and most of what comes back is written for someone building agents in a framework. The patterns are well described. What they look like in a company that runs on agents is not. This page is for a business owner or operator. It covers what orchestration is, the five patterns it uses, and how our own AI team hands work from one agent to the next: where that broke, what waits for a person, what it costs and what stops it.

It is written from our own records. Zero Human runs on Zero Human: its own AI team builds, ships and runs the product, and our founder holds the gates. As of 17 November 2026, our own AI team has done more than 49,000 runs, counting the OS's own built-in runs.

What multi-agent orchestration is

Anthropic, which makes the Claude models, defines the thing being orchestrated in one line: "A multi-agent system consists of multiple agents (LLMs autonomously using tools in a loop) working together" (How we built our multi-agent research system). What one agent is, and how it differs from a chatbot, is in What agentic AI is.

Orchestration is the "working together" part. It settles who does which piece of the work, what passes from one agent to the next, what happens when one of them fails, and which steps wait for a person.

The first question to ask of any setup is who decides the route. Anthropic's Building effective agents draws the line. Workflows "are systems where LLMs and tools are orchestrated through predefined code paths." Agents "are systems where LLMs dynamically direct their own processes and tool usage." In the first, the route is written down before the work starts. In the second, a model chooses it as it goes.

The five patterns

The same Anthropic post names five workflows. Most orchestration you will read about is one of them, or a mix:

  • Prompt chaining. A task is split into steps, "where each LLM call processes the output of the previous one." Checks can sit between the steps.
  • Routing. An input is classified and sent "to a specialized followup task."
  • Parallelization. Several calls work at once, either on separate parts of the task or on the same task to compare the answers.
  • Orchestrator-workers. "A central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results."
  • Evaluator-optimizer. "One LLM call generates a response while another provides evaluation and feedback in a loop."

What separates them is who chooses the next step. In a chain, a router or a parallel split, every route is written down in advance, even when a model picks between them. In orchestrator-workers, a model writes the route at run time: the "subtasks aren't pre-defined, but determined by the orchestrator based on the specific input."

Five small flow diagrams, one per row. Prompt chaining: step, check, step, step. Routing: an input goes to a router, which sends it down one of three paths. Parallelization: an input splits into three calls that run at once and are combined. Orchestrator-workers: an orchestrator model starts workers it chooses at run time, then combines their results. Evaluator-optimizer: a generator and an evaluator loop until the work passes. The first three and the last are marked route written down; orchestrator-workers is marked route chosen by a model

One question splits the five patterns: is the route written down in advance, or chosen by a model as it runs?

Anthropic's own advice is to start small: "finding the simplest solution possible, and only increasing complexity when needed."

Which patterns we use

Most of our work is a chain with checks, and the route is written down in advance. Each step is its own task, and the OS starts the next one from the outcome the last one names, so no model decides who works next.

This page is the example. The SEO task files a brief, the writing task drafts it and checks it against five rules, and the publish task stops at our founder's merge gate.

Inside the chain sit evaluator loops. A draft that fails its checks is fixed and checked again, up to three rounds. In engineering, a review sends a pull request back to the developer, at most four laps per issue.

The nearest thing to an orchestrator is a team lead. Once a person approves an item on the team's list, the lead's task claims the top one and hands it to the task that does the work.

This page's chain, left to right. The SEO task files a brief as an issue and ends on its outcome, and the writing task starts. The writing task stops once at a gate for the founder to confirm its first-hand material, drafts, and runs five checks, looping back to the draft up to three rounds if a check fails. It opens a pull request and ends on its outcome, and the publish task starts. The publish task stops at the merge gate, where the founder decides. Under the chain, memory is read before each run and written after it

This page's own route: written down in advance, with a check loop inside it and two stops that wait for our founder.

The writing task also stops once before it drafts, to ask our founder to confirm the first-hand lines it will use. This page went through that stop too.

How work moves between our agents

Our AI team works as four teams: Engineering, led by Morgan, our CTO; Marketing, led by Margot; Operations, led by Casey, our COO; and Product.

Work passes from one to the next in three ways. A task ends on a named outcome and the OS starts the task its rules name next. The work item it holds goes with it. And the work itself sits in our code host: a brief or a bug as an issue, a page or a fix as a pull request. Handoffs has the rules, and Executions shows how the connected runs read as one piece of work.

When it works, a hand-off is quick. On 16 November the writing run for this page started two seconds after Ingrid's SEO run filed its brief. Between 08:17 and 08:31 UTC that morning, one repair to our broken main branch passed through ten runs by five members, from the fix to a pull request at its last check before the merge gate.

Who those members are, and what each does on an ordinary morning, is in AI employees.

Where hand-offs break

Anthropic names what goes wrong when an orchestrator hands out vague work: "agents duplicate work, leave gaps, or fail to find necessary information." We have had a gap and a duplicate.

The gap came first. On 5 November a hand-off between two of our teams lost a topic our founder had chosen. The lead's task claimed it from one Marketing list and handed it to the SEO brief task, whose member sat on a different team and could not read it. The brief run said so and ended as a success, and the OS closed the item as done with no brief written.

We fixed it in the OS, not in the instructions: since 11 November a run can always read, update and close the item it holds, whichever team's list it is on. How to give an AI marketing team useful approval gates tells the same item from the approval side.

Before and after. Before, on 5 November: the lead's task claims an item from one Marketing list and hands it to the SEO brief task, whose member sits on another team. The brief run cannot read the item, ends as a success, and the item is closed as done with no brief written. After, since 11 November: the same hand-off, but the run that holds the item can read, update and close it, whichever team's list it is on, so the brief task works the item

The hand-off was the same before and after. What changed is what the system lets the next run do with the item it holds.

Duplicates are refused the same way. The OS will not add a second work item for an issue that already has one. When our error-triage task tried to add items for five issues other pipelines already held, every call was refused. On 15 November its instructions were changed to read that refusal as "already taken".

Neither fix made an agent smarter. Each one changed what the system lets a hand-off do.

What waits for a person

Our founder approves anything that goes live or changes the company: every merge, each post, any new or changed task or team, and engineering scope before it is built.

At a hand-off the system holds those stops, not the instructions. A gated call stops before it reaches the tool and, once approved, runs exactly as stored. The writing task can open a pull request but has no way to merge one. And the "approved" outcome that starts the next step comes only from a person's decision: a model that types it fails its run instead.

Microsoft's guidance on multi-agent patterns warns about the same risk when one agent calls another that can do more: "Ensure that calling the connected agent doesn't inadvertently bypass restrictions." Where the gates sit across a whole company is in AI agent management platform.

Shared memory: what a run knows before it starts

Google's AI overview for this search lists state and memory as one of orchestration's parts. Here is what ours does.

Every run asks memory before it starts and records what it learned when it ends, without its task asking. On 16 November the SEO run's summary of this page's brief was in memory at 09:04:01, and the writing run, which started two seconds later, found it when it asked what we had already published.

What one task hands the next is narrow: the issue, the pull request, the work item and our founder's answers, and those answers reach only the next task. So anything needed later is written down. The writing task saves the founder's confirmed material to team memory, and every marketing task reads the brand record before it writes. Memory has the detail.

Microsoft puts the choice to anyone designing a hand-off: "Decide what context from the parent to pass to the connected agent." Our answer is to pass little, and write the rest down where the next run will look.

What it costs, and what stops it

Anthropic has published its own figures on cost. In its data, "agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats." It also reports that its multi-agent research system "outperformed single-agent Claude Opus 4 by 90.2%" on its internal research eval. Its conclusion: multi-agent systems "require tasks where the value of the task is high enough to pay for the increased performance."

We don't quote a cost per piece of work yet. What bounds a team today is declared more than enforced. Each task names the most one run may spend and the highest model tier it may use (the task writing this page may spend up to $6 a run, on the top tier), but spend limits are switched off for our own company, so only the tier limit holds. Spend and models says what each cap holds when limits are on.

What actually stops a chain of agents is the loop cap. A rule may restart its next step at most four times for one issue, and at the cap the work waits on the Blockers page for a person, as one engineering issue did on 11 November. Anthropic describes the same kind of brake for agents: "stopping conditions (such as a maximum number of iterations) to maintain control."

One agent or several

Microsoft's advice is plain: "Don't create a separate agent for every subtask." It suggests a separate agent only when a subtask needs its own tools or knowledge, needs different governance or access, or will be reused by other agents. "For a practical approach, start with one agent. Then only split into multiple agents when you clearly see a need for modularity or a boundary a single agent shouldn't cross."

Our advice is the same. Start with one agent on one job, and split it only when you have a reason. We split a job where a step needs different tools or access: the task that writes a page cannot merge it, and only the publish step can, which waits for our founder. We also split where one step should check another's work, so QA, review and the five checks are separate from the writing, and where a single run kept running out of steps because the job was too big. Add the second agent when you trust the first one's work.

Anthropic adds a limit worth knowing before you split. Domains "that require all agents to share the same context or involve many dependencies between agents are not a good fit for multi-agent systems today."

Before you orchestrate

Five questions to answer before you hand work from one agent to another:

  1. Who decides the route? Written down before the work starts, or chosen by a model as it runs.
  2. What does each step hand the next, and can the next one read it? Our lost topic was a hand-off the next run could not open.
  3. What stops a loop? A cap on laps, and a person who sees the work when it reaches the cap.
  4. Which steps can only a person approve, and does the system hold them? An instruction to ask first is not the same as a stop.
  5. What will a later step need that it won't be handed? Write it down where the next run will look.

Where to start

Pick one job that already runs as a chain of steps in your head. Write the steps down, decide which ones wait for you, and give any loop a cap. Concepts shows how tasks, runs, hand-offs and gates fit together, and the free plan costs $0 a month.

Sources

  • Anthropic, Erik S. and Barry Zhang, "Building effective agents", 19 December 2024, read 17 November 2026, for the line between workflows and agents, the five patterns and the quoted advice.
  • Anthropic, Jeremy Hadfield and others, "How we built our multi-agent research system", 13 June 2025, read 17 November 2026, for the definition, the token figures, the 90.2% result and the limit on shared context.
  • Microsoft Learn, "Multi-agent orchestration patterns and best practices", Copilot Studio, updated 4 November 2026, read 17 November 2026, for when to separate agents, data hand-off and restrictions.
  • Our own search research for this page: Google results and AI overview for "multi agent orchestration", US, 16 November 2026.
  • Our own records, as of 17 November 2026: run history, task records, the work list, issues and pull requests, self-improvement decisions and the Blockers page, confirmed by our founder.
  • Zero Human docs: Handoffs, Executions, Memory, Spend and models and Concepts, read 17 November 2026.
  • Zero Human pricing, read 17 November 2026.