Orchestration Mode Decision Matrix

Open Astra provides three multi-agent orchestration modes: Debate Protocol, Specialization, and Meta-Controller. Each solves a different coordination problem. This page explains when to use each and shows a working configuration for each mode.

Comparison at a glance

Mode	Best for	Agent count	Output type	Cost profile
Debate Protocol	Decisions requiring adversarial scrutiny — code review, architecture, risk assessment	2–4 + moderator	Single synthesized verdict	Medium — each agent sees the same input; debate rounds multiply calls
Specialization	Routing requests to domain experts — triage, classification, skill-matched response	1 router + N specialists	Response from one specialist	Low — only one specialist responds per turn
Meta-Controller	Complex tasks requiring parallel subtask execution — research, code generation, report writing	1 controller + dynamic sub-agents	Synthesized from all subtask results	High — spawns and runs many sub-agents

Decision criteria

Question	Answer → Mode
Does the task need multiple perspectives checked against each other?	Yes → Debate
Is the task a routing/classification problem with clear domain boundaries?	Yes → Specialization
Can the task be decomposed into parallel independent subtasks?	Yes → Meta-Controller
Is cost a primary constraint?	Use Specialization (lowest cost) or Debate over Meta-Controller
Does quality require adversarial challenge?	Use Debate — specialization and meta-controller don't challenge each other
Is the output a single expert answer, not a synthesis?	Use Specialization

Debate Protocol

Multiple agents argue for or against a position over N rounds. A moderator agent synthesizes a final verdict that incorporates all arguments. Best for decisions where you want competing perspectives before committing.

Use when: architectural decisions, security reviews, risk assessments, legal/compliance checks, anything where a single agent might miss a critical angle.

Avoid when: the task doesn't have a meaningful "debate" structure (e.g., writing a summary), or cost is a concern — debate multiplies inference calls by participants × rounds + 1.

yaml

# astra.yml — debate protocol setup
agents:
  - id: architect
    systemPromptTemplate: You are a software architect. Critique plans for scalability issues.
  - id: security-reviewer
    systemPromptTemplate: You are a security engineer. Critique plans for vulnerabilities.
  - id: moderator
    systemPromptTemplate: |
      You are a technical lead. Given arguments from multiple reviewers,
      synthesize a final recommendation that addresses all concerns.
    orchestration:
      mode: debate
      participants: [architect, security-reviewer]
      rounds: 2                   # each reviewer gets 2 rounds to argue
      moderator: true             # this agent synthesizes final verdict

Specialization

A router agent classifies the incoming request and hands it off to the correct specialist. The specialist responds directly. The router never runs inference for the response — only for routing.

Use when: you have distinct domains (code, writing, data, customer support) that require different skills or system prompts, and the classification decision is reasonably deterministic.

Avoid when: requests are cross-domain and need multiple specialists collaborating — use Meta-Controller instead.

yaml

# astra.yml — specialization setup
agents:
  - id: router
    systemPromptTemplate: |
      Route the user's request to the correct specialist:
      - "code" for code questions
      - "research" for factual research
      - "writing" for content creation
    orchestration:
      mode: specialization
      specialists:
        code:     code-agent
        research: research-agent
        writing:  writing-agent

  - id: code-agent
    skills: [code-review, codebase-indexing]
  - id: research-agent
    skills: [web-research, deep-research]
  - id: writing-agent
    skills: [document-generation, summarization]

Meta-Controller

A controller agent decomposes a complex task into subtasks, spawns permission-sandboxed sub-agents to execute them in parallel, collects results via the blackboard, and synthesizes a final output.

Use when: the task is clearly decomposable (e.g., "write a full-stack feature" → design + backend + tests + docs), and parallel execution would meaningfully reduce wall-clock time.

Avoid when: subtasks are tightly sequential, the task is simple enough for one agent, or cost must be tightly controlled. See Anti-Patterns: over-provisioning swarms.

yaml

# astra.yml — meta-controller setup
agents:
  - id: project-manager
    systemPromptTemplate: |
      You are a project manager. Given a complex task:
      1. Decompose it into subtasks
      2. Assign each subtask to the best specialist agent
      3. Collect results from the blackboard
      4. Synthesize a final deliverable
    orchestration:
      mode: meta-controller
      maxSubAgents: 8
      blackboard: shared-board
      budget:
        maxCostUsdPerTask: 2.00

  - id: code-writer
    parentId: project-manager
  - id: test-writer
    parentId: project-manager
  - id: doc-writer
    parentId: project-manager

Combining modes

Modes can be nested. A Meta-Controller can spawn a Debate swarm as one of its subtasks, or a Specialization router can hand off to a Meta-Controller for complex requests. Keep nesting shallow — more than two levels of orchestration significantly increases cost and debugging complexity.

Combination	When it makes sense
Specialization → Meta-Controller	Router identifies a "complex task" category and delegates to a controller that decomposes it
Meta-Controller → Debate	Controller spawns a debate sub-swarm for a subtask requiring adversarial review (e.g., security audit within a larger project)
Debate → Specialization	Rarely useful — debate moderators typically don't need to route to specialists