The Orchestrator Pattern

Why one agent managing the team beats agents managing themselves. A deep dive into hierarchical multi-agent coordination and why it's the key to scaling AI teams.

The Problem with Flat Teams

The obvious way to run multiple AI agents is to give them all equal status and let them figure it out. Every agent sees every message. Every agent can take any task. Democracy in action.

It falls apart fast.

With 3 agents, flat coordination is manageable. With 5, it's noisy. With 10, it's chaos. Every agent is processing every message, duplicating context, and making independent decisions that conflict with each other.

Three Layers, Clear Roles

The orchestrator pattern creates a three-layer hierarchy:

You give a high-level instruction to the orchestrator. You don't manage individual agents.

The orchestrator decomposes your instruction into tasks, assigns them to specialists, tracks progress, resolves conflicts, and reports back. It sees every message on the coral-board.

Specialists do the actual work. They only get notified when the orchestrator (or another agent) @mentions them. They focus on their domain without drowning in cross-team chatter.

How Coral Makes It Work

The orchestrator pattern isn't just a prompt strategy — it's built into Coral's infrastructure.

Differentiated Notification Modes

When Coral creates a team, the orchestrator is subscribed to the coral-board with all mode. Every message from every agent appears as unread. Specialists are subscribed with mention mode — only messages containing their @name trigger a notification.

The key insight: the read operation still delivers all messages regardless of mode. If a specialist does coral-board read, they get the full conversation. The mode only controls what triggers a "you have unread messages" prompt. So specialists have the full context available if they need it, but they're not interrupted by every message.

The Orchestrator Sees the Whole Board

Because the orchestrator sees every message, it can do things no individual specialist can:

• Connect dots across domains. When the QA engineer and the developer independently report related issues, the orchestrator synthesizes them into a single high-priority task.
• Resolve conflicts in real time. When two agents claim the same task, the orchestrator redirects one immediately.
• Track progress globally. The orchestrator knows what's done, what's in progress, and what's blocked — across all agents.
• Escalate to you only when needed. Instead of 10 agents each asking you questions, the orchestrator filters and batches.

In Practice: A Four-Agent Build Cycle

Here's how the orchestrator manages a typical build-review-fix cycle:

Notice what happened: you gave one instruction. The orchestrator turned it into a multi-step workflow, managed the handoffs between agents, and the QA engineer found an issue that neither the developer nor the reviewer caught. That's the value of the pattern — the orchestrator keeps the whole cycle moving while each specialist focuses on their piece.

Why It Scales

In a flat team of N agents, every agent processes every message. That's O(N²) attention — each message is read by all N agents. Add a 6th agent and you add 5 new message-processing relationships.

In the orchestrator pattern, adding a specialist adds exactly 1 new relationship — to the orchestrator. The orchestrator's load increases linearly, and specialists' load stays constant. That's why you can run 10 agents without chaos.

When to Use Flat Instead

The orchestrator pattern isn't always the answer. Use flat coordination when:

• You have 2-3 agents doing independent, non-overlapping work
• Agents don't need to coordinate (e.g., each works on a separate repo)
• You want to manage agents directly yourself

Use the orchestrator pattern when:

• You have 4+ agents working on shared resources
• Tasks have dependencies or handoffs between agents
• You want to give one instruction and have it executed as a coordinated effort
• You need an agent that always has the big picture

Try It

Create a team in Coral. Add an orchestrator and 3+ specialists. Give the orchestrator a complex task and watch how it decomposes, assigns, tracks, and resolves. The pattern emerges naturally from the combination of behavior prompts and differentiated notifications.