When you give your agent a simple task, it handles it directly. But when you ask for something complex—like "research our top five competitors and create a comparison report with charts"—your agent needs a different approach. This is where orchestration comes in: a sophisticated coordination system that breaks complex work into subtasks and runs them in parallel for faster, more thorough results.
Orchestration transforms your agent from a single worker into an executive who can delegate. Your main agent becomes a coordinator, planning the work and dispatching specialized sub-agents to handle individual pieces. These sub-agents work simultaneously, and your main agent synthesizes their outputs into a coherent final result.
How Orchestration Works
The orchestration process follows a clear lifecycle. Your main agent doesn't just dive into complex tasks—it thinks strategically about how to approach them, then coordinates execution across multiple workers.
The phases of orchestration:
Planning - Your main agent analyzes your request and decomposes it into distinct subtasks. It decides what needs to be done, in what order, and what kind of work each subtask involves.
Dispatching - Subtasks are assigned to sub-agents. Each sub-agent gets specific instructions about what to accomplish and what output to produce.
Executing - Sub-agents work in parallel on their assigned subtasks. Browser sessions research different sources simultaneously. Computer sessions process data or generate files.
Aggregating - As sub-agents complete their work, your main agent collects the results and synthesizes them into a cohesive response that addresses your original request.
This parallelization is what makes orchestration powerful. Instead of researching competitors one at a time, your agent can research all five simultaneously, dramatically reducing the total time needed.
The Orchestration Plan
When orchestration kicks in, you'll see a todo list appear in your conversation. This is the orchestration plan—a visible representation of how your agent has decomposed the task.
Each item in the plan shows:
- The title and description of the subtask
- Current status (pending, in progress, completed, or failed)
- What type of execution it requires (browser, computer, or internal)
You can watch this plan update in real-time as sub-agents complete their work. Items move from pending to in progress to completed, giving you visibility into the overall progress of your complex request.
Orchestration Phases
The phases aren't just conceptual—you can observe them as your task progresses. The system moves through each phase in sequence, though the transitions happen automatically.
| Phase | What Happens |
|---|---|
| Planning | Main agent analyzes your request and creates the todo list |
| Dispatching | Sub-agents are spawned for each ready subtask |
| Executing | Parallel work is underway across multiple sessions |
| Aggregating | Results are collected and combined into final output |
| Completed | The synthesized result is delivered to you |
The entire cycle typically takes minutes rather than the much longer time it would take to do everything sequentially.
When Orchestration Activates
Not every request triggers orchestration. Your agent uses it intelligently, recognizing when parallel execution would provide meaningful benefit.
Orchestration typically activates for tasks that:
- Require multiple independent steps that could run simultaneously
- Would benefit from parallel research across different sources
- Involve both web research and data processing
- Are complex enough that divide-and-conquer makes sense
Simple requests—answering a question, sending a single message, performing one straightforward action—are handled directly without orchestration. The overhead of planning and coordinating isn't worth it for work that can be done quickly in a single thread.
Recursion for Gap-Filling
Sometimes sub-agents encounter unexpected obstacles or miss pieces of information. Rather than delivering incomplete results, orchestration includes a recursion mechanism that lets your main agent adapt.
If sub-agents miss something important, the main agent can add new subtasks to fill the gaps. It might dispatch an additional sub-agent to retry a failed search from a different angle, or add a new task to gather information that turned out to be necessary.
This recursion continues until the task is complete, with a maximum of three iterations to prevent infinite loops. The result is more thorough outcomes that adapt to what's discovered during execution.
Related: How Sub-Agents Work | Creating Tasks