AI agent orchestration is the layer that decides which agent does what, in which order, with which tools, and what happens when one of them finishes, fails or needs a human. An orchestrator is the component that does the deciding. Two questions sort the field: is the coordination fixed in advance or decided at run time, and is the unit being coordinated one task or a shared list of work. This post covers the three combinations in use in 2026, when splitting work across agents is worth the tokens, and what changes when the thing being orchestrated is a team’s work rather than one person’s task.

What an orchestrator is

In the orchestrator–workers pattern, the orchestrator receives a goal, breaks it into subtasks, hands each to a worker (a sub-agent or a tool), and synthesises the results. Anthropic’s Building effective agents describes the pattern and its cost: the orchestrator owns the top-level context window, so every worker result it reads is context it spends. Our glossary entry has the short version.

The word covers three different setups in practice. The names below are ours, not an industry standard.

Pattern 1: fixed graph (code-driven)

A workflow engine calls models at fixed points. Make scenarios, n8n workflows and Zaps are this: you draw the graph, each node is a step, some steps are LLM calls, and the engine handles retries, branching and fan-out. The model never decides the shape of the work. (Zapier Agents and Gumloop agents are a different mode of the same products: chat-driven, closer to Pattern 2.)

  • Good at: repeatable pipelines, auditability, cost control. The same input produces the same path.
  • Weak at: anything you did not draw. A one-off task does not pay back the time to diagram it.
  • Who orchestrates: the person who built the flow, once.

Pattern 2: dynamic tree (LLM-driven)

A model is the orchestrator. It reads the goal, spawns sub-agents with fresh context windows, and merges what comes back. Claude Code’s sub-agents, OpenAI’s Agents SDK handoffs, CrewAI and LangGraph are this. Anthropic’s multi-agent research system write-up is the reference case: a lead agent fans out to parallel researchers, and the gain comes from the parallel exploration, at roughly 15× the tokens of a chat interaction (Anthropic’s own baseline).

  • Good at: open-ended tasks where the decomposition is not known up front; parallel search; keeping the parent’s context clean.
  • Weak at: cost, latency, and losing the thread when a sub-agent returns something the parent did not expect. The tree lives inside the session that started it.
  • Who orchestrates: the model, inside one session. The frameworks can be deployed for many users, but each tree is one task.

Pattern 3: shared board (board-driven)

The orchestrator sits on top of a shared list of work, not inside one task. Items on the board are the unit. People add items; the orchestrator creates, continues, starts and stops them; each item runs as its own agent with its own configuration; results land back on the card where anyone with access can read, continue or stop them.

This is what TODO for AI’s orchestrator does, so the rest of this section is about ours. The unit it coordinates is the list, not one prompt.

How it works on the board

  • One input, voice or text. The mic button on the board opens the orchestrator; once it is open you can also type to it. You talk to the whole list: “what finished overnight”, “what is blocked”, “send the invoice reminders and draft the two replies”.
  • It does no substantive work itself. Its instructions say so. It reads the board, decides, and dispatches. Before creating anything it matches the request against items already on the board and continues the one about the same subject; a new todo is created only when nothing covers it. Each running item is a real todo with its own agent, model and permissions, in parallel with the others. Board housekeeping and one-command lookups (a PR status, a price, what you decided last week) it does itself.
  • 17 tools. Create, start, message, answer, stop a todo. Read the view, list, catch up on what changed, inspect one item. Update, group, lay out and show on the board. Open and close panels. Connect a tool. One bash on the user’s cloud VM for lookups and bulk edits.
  • Receipts, not promises. A dispatch returns a receipt; when the sub-agent finishes, fails or needs the user, an event comes back to the orchestrator thread. A word-for-word identical brief to the same thread within two minutes is not created twice; the orchestrator gets the first receipt back.
  • The thread is recorded. The orchestrator’s own conversation is stored as a todo of its own (kind: orchestrator), kept off the board and listed separately, so what it was told and what it dispatched are auditable like everything else.
  • Bounded. Up to six tool rounds per turn; then tools switch off and it must answer from what it has, saying what is unfinished. It only dispatches on the board it is on. By default it sees items you created or that are shared with you; the rest of the team’s items come into scope only when you widen that setting.

Why the board, not the tree

Pattern 2 answers “how does one session get a hard task done with many agents”. Pattern 3 answers “where does the team’s agent work live”. The difference shows up in four places:

  1. Visibility. In a tree, the sub-agents’ work is inside the session that started it. On a board, every item shows who asked, which agent ran it and what came back, and a colleague can pick it up.
  2. Configuration per kind of work. The finance agent asks before every write; the engineering agent has a shell on a build machine. A new item takes the agent currently selected on the board; an existing item keeps the one it was set up with. The orchestrator does not pick agents, and an agent’s permissions are not the orchestrator’s to override.
  3. Control that survives the orchestrator. Allow / ask first / block is per tool, per agent. Ask-first is a gate the call waits on, not a preference the orchestrator can talk itself out of. Any run can be stopped mid-task by anyone with access.
  4. Shared context. Every agent starts from the same company context and brand voice, so the orchestrator does not have to re-brief each one.

The honest limit: a board-driven orchestrator is only as good as the agents you configured and the board you keep. It is a dispatcher, not a planner that will invent your process. If your work is one deep research task, Pattern 2 is the better tool; if it is forty small tasks across five kinds of work, the board is.

When multi-agent orchestration is worth it

Rules of thumb that hold across all three patterns:

  • Split when the subtasks need different tools or context. A researcher, a coder and a reviewer want different system prompts and different permissions. One agent with all three jobs gets a compromise prompt.
  • Split when parallelism buys time. Independent lookups run in parallel finish in about the time of the slowest one, rate limits permitting. Dependent steps gain nothing.
  • Do not split to look sophisticated. Each extra agent is a context window, a chance to lose the thread, and a token bill. Anthropic’s ~15× tokens versus chat is the price of parallel exploration, paid whether or not it helped.
  • Keep the orchestrator’s context small. Workers should return distilled results, not transcripts. This is the one engineering rule every pattern shares.

Orchestration platforms, by what they orchestrate

What is being orchestratedCoordinationTools
A fixed pipelinedecided in advanceMake, n8n, Zaps
One hard taskdecided at run time, inside one sessionClaude Code sub-agents, OpenAI Agents SDK, CrewAI, LangGraph; Zapier Agents and Gumloop agents in their chat modes
A team’s list of workdecided at run time, on a shared boardTODO for AI
Agents inside a suiteeither, packaged by the vendorCopilot Studio (Microsoft 365), Agentforce (Salesforce)

The platform comparison with prices is in Best AI agent platforms for business in 2026.

FAQ

What is AI agent orchestration? Coordinating several AI agents or tools on one goal: deciding the order, routing subtasks, passing results between them and handling failures and human approvals.

What is an AI agent orchestrator? The component that does that coordination. It can be code (a workflow engine), a language model (a lead agent spawning sub-agents), or a model on top of a shared board that dispatches items to configured agents.

What is multi-agent orchestration? Orchestration where the workers are themselves agents with their own context windows, rather than single tool calls. Useful when subtasks need different tools or can run in parallel; expensive in tokens.

Is an orchestrator the same as a workflow? A workflow is a fixed graph drawn in advance; its engine is an orchestrator in the narrow sense. The interesting difference is who decides the graph: the person who drew it (Pattern 1) or a model at run time (Patterns 2 and 3).

How does TODO for AI’s orchestrator differ from Claude Code sub-agents? Claude Code’s orchestrator works inside one session on one task. TODO for AI’s works on a shared board: it continues or creates items, each running as a configured agent with its own model and permissions, and the result sits on a card the team can read. It does no substantive work itself.


Sources: Anthropic, Building effective agents and How we built our multi-agent research system. Orchestrator behaviour above is from the TODO for AI product as of 2026-11-06; the team page shows the agent panel and permissions.