# What is agent orchestration?

> Agent orchestration coordinates how agents, tools and handoffs run together. Five common patterns exist, and one agent is often enough.

Source: https://www.honeyhive.ai/learn/agent-orchestration (updated 2026-10-31)

Agent orchestration is the control layer that decides which agent or tool runs next, what each one sees, and how results come back together. [Microsoft's](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) Azure Architecture Center describes five common patterns for it: sequential, concurrent, group chat, handoff and magentic. Many systems need none of them, because one agent with tools is enough.

Orchestration builds on the ideas in [what are AI agents](/learn/what-are-ai-agents) and [agentic workflows](/learn/agentic-workflow). If you are starting out, see [how to build AI agents](/learn/how-to-build-ai-agents).

## Who controls the flow

The [OpenAI Agents SDK docs](https://openai.github.io/openai-agents-python/multi_agent/) split orchestration into two styles:

- LLM orchestration "uses the intelligence of an LLM to plan, reason, and decide on what steps to take."
- Code orchestration means "determining the flow of agents via your code," which the docs say makes tasks "more deterministic and predictable, in terms of speed, cost and performance."

Most real systems mix the two. [Microsoft's](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) sequential pattern, for example, defines the next agent deterministically, "not a choice given to agents," while its handoff pattern lets agents decide when to transfer control.

## Start with one agent

Microsoft [says](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) to "use the lowest level of complexity that reliably meets your requirements." It calls a single agent with tools "often the right default for enterprise use cases" and notes that multiagent setups add "coordination overhead, latency, and failure modes." It lists prompt complexity, tool overload and security boundaries as reasons that can justify the extra complexity. Anthropic [gives](https://www.anthropic.com/engineering/building-effective-agents) the same advice: find "the simplest solution possible, and only increasing complexity when needed".

Multiple agents can pay off. In Anthropic's research system (described in June 2025), a lead Claude Opus 4 agent with Claude Sonnet 4 [subagents](/learn/subagents) "outperformed single-agent Claude Opus 4 by 90.2%" on Anthropic's internal research eval. The same post says multi-agent systems use about 15 times more tokens than chats, and that domains where agents must share the same context or have many dependencies are a poor fit ([Anthropic](https://www.anthropic.com/engineering/multi-agent-research-system), June 2025).

## The five patterns

All rows are from [Microsoft's guide](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns).

| Pattern | How it works | Best for | Watch out for |
|---|---|---|---|
| Sequential | Agents chained in a predefined order; each takes the previous output. Also called a pipeline or prompt chaining | Step-by-step refinement with clear dependencies | Early failures propagate; no parallelism |
| Concurrent | Several agents work on the same input at once, then results are combined (fan-out/fan-in) | Independent views on one problem; latency-sensitive work | Contradicting results need resolving; resource-heavy |
| Group chat | Agents share one conversation thread and a chat manager controls turn order | Consensus, brainstorming, maker-checker review | Conversation loops; hard to control with many agents |
| Handoff | One active agent at a time; agents decide when to transfer control | Tasks where the right specialist emerges during processing | Infinite handoff loops; unpredictable routing |
| Magentic | A manager agent builds and adapts a task ledger and assigns work | Open-ended problems with no known solution path | Slow to converge; stalls on ambiguous goals |

[Anthropic's](https://www.anthropic.com/engineering/building-effective-agents) orchestrator-workers pattern, where "a central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results," sits close to the magentic and concurrent patterns.

## Handoffs versus agents as tools

The OpenAI Agents SDK separates two ways to delegate. With a handoff, a triage agent routes the conversation and the specialist "becomes the active agent for the rest of the turn." With agents as tools, a manager agent "keeps control of the conversation and calls specialist agents" through `Agent.as_tool()`. The docs suggest the second when a specialist should handle a bounded subtask without taking over the user-facing conversation ([OpenAI](https://openai.github.io/openai-agents-python/multi_agent/)). See [the OpenAI Agents SDK page](/learn/openai-agents-sdk-framework) for the framework. [LangGraph](/learn/langgraph-framework) models orchestration as an explicit graph.

## Running it in production

Anthropic [lists](https://www.anthropic.com/engineering/multi-agent-research-system) the problems its team met running a multi-agent system: errors that compound because agents are stateful, non-deterministic behavior that made debugging hard and led to full production tracing, deploys that interrupt agents mid-task, and lead agents that wait on subagents.

[Microsoft's](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) advice is to "instrument all agent operations and handoffs," track metrics per agent, and test with scoring rubrics or LLM-as-judge evaluations, since agent outputs are nondeterministic. The [agent observability](/learn/agent-observability) and [LLM evaluation](/learn/llm-evaluation) pages cover both. Protocols like the [Model Context Protocol](/learn/model-context-protocol) standardize how agents discover and invoke tools ([Microsoft](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns)).

## Tracing orchestrated agents

Handoffs and subagent calls only make sense when they appear as one trace. HoneyHive traces multi-step agents built with frameworks such as LangGraph; see the [HoneyHive LangGraph integration docs](https://docs.honeyhive.ai/v2/integrations/langgraph) for setup.

Related: [multi-agent systems](/learn/multi-agent-systems).

## FAQ

### What is the difference between agent orchestration and multi-agent orchestration?

Orchestration covers any control of the steps in an agent system, including one agent looping over tools. Multi-agent orchestration is the case where several specialized agents share the work. Microsoft's guide treats [multiagent orchestration](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) as one step up from a single agent with tools.

### Should I orchestrate with code or with an LLM?

The [OpenAI Agents SDK docs](https://openai.github.io/openai-agents-python/multi_agent/) say code orchestration makes tasks "more deterministic and predictable, in terms of speed, cost and performance". LLM orchestration lets the model plan and decide, which suits open-ended tasks.

### When is one agent enough?

Often. Microsoft [calls](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns) a single agent with tools "often the right default for enterprise use cases" and advises using "the lowest level of complexity that reliably meets your requirements".

### How do I debug an orchestrated system?

Instrument every agent call and handoff, and trace the whole run. See [agent observability](/learn/agent-observability).