Orchestration Patterns

Wissen

The central challenge in multi-agent systems isn't the individual agent -- it's coordination. Who assigns tasks? Who gets which information? What happens when there's a conflict? The answer lies in the orchestration pattern.

Four patterns have proven themselves in practice. Each solves the coordination problem in a different way:

Pattern 1: Meta-Controller

A central controller agent coordinates all other agents. It receives the task, breaks it into subtasks, delegates to specialized sub-agents, and assembles the results.

                    ┌──────────────┐
                    │  Meta-       │
                    │  Controller  │
                    └──────┬───────┘
                           │
              ┌────────────┼────────────┐
              v            v            v
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ Agent A  │ │ Agent B  │ │ Agent C  │
        │ (Code)   │ │ (Review) │ │ (Test)   │
        └──────────┘ └──────────┘ └──────────┘

The Meta-Controller is typically a powerful model (Opus, GPT-5.6) that makes strategic decisions. The sub-agents can be cheaper models that execute their specific tasks.

Pattern 2: Plan-and-Execute (Deep Dive)

You already know Plan-and-Execute from the intermediate module: An expensive model plans, a cheap one executes. In multi-agent systems, this pattern becomes more powerful because the planner doesn't just define steps -- it orchestrates entire agent teams.

Planner (Opus)
  │
  ├── Step 1: Research-Agent gathers data
  ├── Step 2: Analysis-Agent evaluates (parallel: 3 instances)
  ├── Step 3: Writer-Agent creates report
  └── Step 4: Review-Agent checks quality
                    │
                    └── If issues: Back to Planner

The key difference from the single-task variant: The planner knows the capabilities of each agent and can parallelize steps.

Pattern 3: Blackboard Architecture

Instead of a controller distributing tasks, all agents work on a shared knowledge space -- the "blackboard." Each agent observes the blackboard, recognizes when its expertise is needed, and contributes its result.

        ┌──────────┐  ┌──────────┐  ┌──────────┐
        │ Agent A  │  │ Agent B  │  │ Agent C  │
        └────┬─────┘  └────┬─────┘  └────┬─────┘
             │              │              │
             v              v              v
        ╔══════════════════════════════════════╗
        ║         BLACKBOARD                   ║
        ║  (Shared Knowledge Space)            ║
        ║                                      ║
        ║  - Task: "Analyze System X"          ║
        ║  - Agent A: Security analysis done   ║
        ║  - Agent B: Performance data...      ║
        ║  - Agent C: waiting for B            ║
        ╚══════════════════════════════════════╝

The Blackboard pattern is ideal when no clear task ordering exists, emergent behavior is desired, and loose coupling matters.

Pattern 4: Ensemble Decision-Making

Instead of letting one agent make the decision, you have multiple agents independently answer the same question and aggregate the answers. This is the "Wisdom of Crowds" principle applied to AI agents.

        Task: "Is this code secure?"
                    │
        ┌───────────┼───────────┐
        v           v           v
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ Agent 1 │ │ Agent 2 │ │ Agent 3 │
   │ (Opus)  │ │ (GPT-5) │ │ (Gemini)│
   │ Yes: 85%│ │ No      │ │ Yes: 70%│
   └─────────┘ └─────────┘ └─────────┘
        │           │           │
        v           v           v
   ┌──────────────────────────────────┐
   │  Aggregator                      │
   │  Majority vote: Yes (2:1)        │
   │  But: Agent 2 warns → Escalation │
   └──────────────────────────────────┘

Aggregation variants: Majority Voting, Weighted Voting, Debate (multi-round), and Red-Team / Blue-Team.

Verstehen

Real-World Example: Claude Code

Claude Code (Anthropic's CLI coding agent) uses a Meta-Controller pattern: A main agent coordinates sub-agents for different tasks -- file analysis, code generation, test execution. The controller decides which sub-agent becomes active and when.

Dynamic Re-Planning

The advanced Plan-and-Execute pattern includes an evaluator that checks after each step: Does the result match the plan? If not, control returns to the planner, which can adjust the remaining plan. This gives the system flexibility without losing the cost advantages.

When Blackboard Over Controller?

The weakness of the Blackboard pattern: Without a central controller, coordination problems can arise. Who decides when the task is complete? What happens with contradictory contributions?

Real-World Example: Architecture Review -- A blackboard system for code architecture reviews: A Security-Agent, a Performance-Agent, and a Maintainability-Agent independently analyze the same code. Their findings land on the blackboard. A Synthesizer-Agent reads all findings and creates a consolidated review.

When Ensemble Over Single Decision?

Ensemble Decision-Making pays off for high-stakes decisions where a single error would be costly: security reviews, medical diagnoses, financial assessments. The overhead (multiple agents, more cost) is justified by higher reliability.

Pattern Comparison

Anwenden

Choosing the right pattern is one of the most important architectural decisions in multi-agent systems. Test your understanding with the following scenarios:

Reflect

The four orchestration patterns -- Meta-Controller, Plan-and-Execute, Blackboard Architecture, and Ensemble Decision-Making -- are the foundation of every multi-agent architecture. Choosing the right pattern depends on predictability, cost, and fault tolerance. In the next section, we will look at which frameworks can help with implementation.