Agent Orchestrator

The Agent Orchestrator skill coordinates multiple specialized AI agents, skills, and tools to accomplish complex tasks that benefit from distributed expertise. It acts as a conductor, delegating subtasks to appropriate agents, managing dependencies, integrating results, and ensuring coherent final outputs.

This skill understands the capabilities of available agents (general-purpose, operations-manager, specialized skills), determines optimal task decomposition, manages inter-agent communication, handles failures, and synthesizes diverse outputs into unified results. It's the meta-layer that makes multi-agent collaboration effective.

Use this skill for complex projects requiring diverse expertise, tasks that benefit from parallel execution, or workflows where specialized agents outperform general-purpose approaches.

Core Workflows

Workflow 1: Decompose Task & Delegate

1. •Analyze the complex task:
   • •What's the end goal?
   • •What are the components?
   • •What expertise is needed?
2. •Map to available agents/skills:
   • •Which agents have relevant capabilities?
   • •What's each agent's specialty?
   • •What tools/MCPs do they access?
3. •Decompose into subtasks:
   • •Break along expertise boundaries
   • •Identify dependencies
   • •Determine execution order
4. •Delegate to appropriate agents:
   • •Assign subtasks with clear instructions
   • •Provide necessary context
   • •Set success criteria
   • •Specify output format
5. •Monitor execution:
   • •Track progress
   • •Identify blockers
   • •Handle failures
6. •Integrate results:
   • •Collect agent outputs
   • •Resolve conflicts
   • •Synthesize into coherent whole
7. •Validate final result

Workflow 2: Parallel Agent Execution

1. •Identify parallelizable subtasks:
   • •Which tasks are independent?
   • •Which share no dependencies?
   • •Which can run concurrently?
2. •Prepare parallel execution:
   • •Assign subtasks to agents
   • •Provide isolated contexts
   • •Set timeout limits
3. •Launch agents in parallel:
   • •Initiate all at once
   • •Maintain separate contexts
   • •Monitor all executions
4. •Coordinate completion:
   • •Wait for all to finish
   • •Handle stragglers
   • •Manage timeout failures
5. •Aggregate results:
   • •Collect all outputs
   • •Merge related findings
   • •Resolve inconsistencies
6. •Synthesize final output

Workflow 3: Sequential Agent Pipeline

1. •Design pipeline flow:
   • •Order agents by dependencies
   • •Define handoff points
   • •Specify data transformations
2. •Execute pipeline sequentially:
   • •Agent 1: Process initial input → Output A
   • •Validate Output A
   • •Agent 2: Process Output A → Output B
   • •Validate Output B
   • •Agent N: Process Output (N-1) → Final Output
3. •Manage state between agents:
   • •Pass relevant data forward
   • •Maintain context where needed
   • •Discard temporary artifacts
4. •Handle pipeline failures:
   • •Identify failed stage
   • •Retry or use fallback
   • •Don't propagate bad data
5. •Validate end-to-end result

Workflow 4: Adaptive Agent Selection

1. •Assess task requirements dynamically:
   • •What capabilities are needed?
   • •What's the complexity level?
   • •What constraints exist?
2. •Select best-fit agent:
   • •Match capabilities to requirements
   • •Consider agent availability
   • •Factor in performance history
   • •Choose specialist over generalist when appropriate
3. •Delegate with context:
   • •Provide task-specific instructions
   • •Include relevant background
   • •Set clear expectations
4. •Evaluate agent performance:
   • •Did it meet criteria?
   • •Was quality sufficient?
   • •Was time acceptable?
5. •Learn for future selection:
   • •Track which agents excel at what
   • •Note failure patterns
   • •Refine selection logic

Workflow 5: Error Recovery & Fallback

1. •Detect agent failure:
   • •Task not completed
   • •Output quality insufficient
   • •Timeout exceeded
   • •Error thrown
2. •Diagnose failure cause:
   • •Was task unclear?
   • •Was agent wrong choice?
   • •Was input malformed?
   • •Was dependency unavailable?
3. •Attempt recovery:
   • •Retry with same agent (if transient error)
   • •Retry with different agent (if capability mismatch)
   • •Simplify task and retry (if too complex)
   • •Escalate to human (if unrecoverable)
4. •Log failure and recovery
5. •Continue workflow if recovered

Quick Reference

Best Practices

• •

  Match Expertise to Task: Use specialized agents for specialized work

  • •Operations Manager for project coordination
  • •UI Builder for component design
  • •Database Designer for schema work
  • •Don't use general-purpose for everything
• •

  Provide Clear Context: Each agent needs to understand its role

  • •What's the larger goal?
  • •What's this agent's specific responsibility?
  • •What's the expected output?
  • •How does it fit in the workflow?
• •

  Manage Dependencies: Make execution order explicit

  • •Agent B needs Agent A's output
  • •Agent C can run parallel to A and B
  • •Agent D waits for B and C
• •

  Validate Handoffs: Don't pass bad data between agents

  • •Check output format
  • •Verify completeness
  • •Validate against schema
  • •Fail fast if something's wrong
• •

  Handle Failures Gracefully: Agents will fail sometimes

  • •Have fallback agents
  • •Implement retry logic
  • •Don't cascade failures
  • •Log for post-mortem
• •

  Optimize Communication: Minimize inter-agent chatter

  • •Pass only necessary data
  • •Use structured formats
  • •Avoid redundant information
  • •Compress when appropriate
• •

  Monitor Progress: Know what's happening

  • •Track which agents are active
  • •Identify bottlenecks
  • •Detect failures early
  • •Provide status updates
• •

  Synthesize Thoughtfully: Integrate diverse outputs coherently

  • •Resolve conflicts
  • •Maintain consistency
  • •Preserve important details
  • •Create unified narrative

Agent Capabilities Map

Available Agents/Skills

MCP/Tool Access

Orchestration Patterns

Pattern 1: Expert Panel

Task → [Expert A, Expert B, Expert C] → Synthesize → Decision

Use when: Need diverse perspectives on same problem Example: Architecture decision → [Performance expert, Security expert, Maintainability expert] → Recommendation

Pattern 2: Assembly Line

Task → Agent A → Agent B → Agent C → Output

Use when: Sequential transformations needed Example: Design → Implement → Test → Deploy

Pattern 3: Divide & Conquer

Task → Split → [Agent 1: Part A, Agent 2: Part B, Agent N: Part N] → Merge → Output

Use when: Large task divisible into independent parts Example: Multi-page app → [Agent per page] → Integrate

Pattern 4: Supervisor-Worker

Supervisor analyzes → Delegates to Workers → Workers execute → Supervisor integrates

Use when: Central coordination needed Example: Project manager → [Feature developers] → Integration

Pattern 5: Collaborative Refinement

Agent A: Draft → Agent B: Critique → Agent A: Revise → Validate → Output

Use when: Quality improves through iteration Example: Writer → Reviewer → Writer → Final

Pattern 6: Specialist Routing

Analyze task → Route to appropriate specialist → Specialist executes → Return

Use when: Different task types need different agents Example: Issue triage → [Bug to QA | Feature to Developer | Ops to DevOps]

Delegation Templates

Standard Delegation

**Agent**: [Agent name]
**Task**: [Clear, specific task description]
**Context**: [Relevant background information]
**Inputs**: [Provided data/resources]
**Expected Output**: [Format and content requirements]
**Success Criteria**: [How to know it's done well]
**Constraints**: [Limitations or requirements]
**Deadline**: [If time-sensitive]

Parallel Delegation

**Parallel Execution**: [N agents]

**Agent 1**: [Agent name]
- Task: [Task 1]
- Output: [Output 1]

**Agent 2**: [Agent name]
- Task: [Task 2]
- Output: [Output 2]

**Integration**: [How to combine outputs]

Pipeline Delegation

**Pipeline**: [Agent A] → [Agent B] → [Agent C]

**Stage 1**: [Agent A]
- Input: [Initial data]
- Task: [Transform 1]
- Output: [Intermediate 1]

**Stage 2**: [Agent B]
- Input: [Intermediate 1]
- Task: [Transform 2]
- Output: [Intermediate 2]

**Stage 3**: [Agent C]
- Input: [Intermediate 2]
- Task: [Transform 3]
- Output: [Final output]

Coordination Strategies

Real-Time Coordination

• •When: Agents need to interact during execution
• •How: Shared context, message passing, state updates
• •Trade-off: More complex but more flexible

Batch Coordination

• •When: Agents work independently, integrate at end
• •How: Collect all outputs, then merge
• •Trade-off: Simpler but less adaptive

Hierarchical Coordination

• •When: Clear authority structure
• •How: Supervisor delegates, workers report back
• •Trade-off: Clear but potentially bottlenecked

Peer-to-Peer Coordination

• •When: Agents are equals collaborating
• •How: Shared workspace, mutual awareness
• •Trade-off: Flexible but needs clear protocols

Conflict Resolution

When agents produce conflicting outputs:

1. •

   Identify the conflict:

   • •What's inconsistent?
   • •Which agents disagree?
   • •What's the nature of disagreement?
2. •

   Evaluate sources:

   • •Which agent is more authoritative for this?
   • •What's the confidence level?
   • •What's the reasoning?
3. •

   Resolve using strategy:

   • •Authority: Trust the specialist
   • •Voting: Majority wins (if multiple agents)
   • •Synthesis: Combine best of both
   • •Escalate: Ask human to decide
4. •

   Document resolution:

   • •What was the conflict?
   • •How was it resolved?
   • •Why this choice?

Performance Optimization

Reduce Overhead

• •Don't orchestrate when single agent suffices
• •Minimize handoffs and data passing
• •Use parallel execution for independent tasks
• •Cache repeated computations

Load Balancing

• •Distribute work evenly across agents
• •Avoid bottlenecks at single agent
• •Consider agent capacity and speed
• •Use queuing for burst workloads

Failure Isolation

• •Don't let one agent failure crash workflow
• •Use circuit breakers for unreliable agents
• •Have fallback options
• •Implement timeout limits

Monitoring & Observability

Track these metrics:

• •Agent utilization: How busy is each agent?
• •Task completion time: How long per agent?
• •Success rate: Which agents succeed/fail?
• •Handoff efficiency: How smooth are transitions?
• •Integration quality: How well do outputs combine?
• •Error rate: Where do failures occur?
• •Cost: Token usage per agent

Example Orchestrations

Feature Development Workflow

**Orchestrator**: Coordinate feature development

1. **Requirements Analysis** (Operations Manager)
   - Clarify requirements
   - Define scope
   - Identify constraints

2. **Parallel Design Phase**
   - **UI Builder**: Design components
   - **Database Designer**: Design schema
   - **API Designer**: Design endpoints

3. **Integration Review** (Orchestrator)
   - Ensure designs are compatible
   - Resolve conflicts
   - Approve for implementation

4. **Implementation** (General-Purpose)
   - Build based on approved designs

5. **Quality Assurance** (Testing QA)
   - Generate E2E tests
   - Run test suite
   - Report issues

6. **Fix Issues** (General-Purpose)
   - Address failing tests

7. **Deployment** (Deployment Automation)
   - Deploy to staging
   - Verify deployment
   - Deploy to production

Content Creation Pipeline

**Orchestrator**: Create technical blog post

1. **Research** (General-Purpose + Firecrawl)
   - Gather sources
   - Extract key information

2. **Parallel Analysis**
   - **Prompt Engineer**: Analyze for clarity
   - **Workflow Designer**: Identify structure
   - **Output Formatter**: Determine format

3. **Draft** (General-Purpose)
   - Write based on research and analysis

4. **Review & Edit** (Prompt Engineer)
   - Review for quality
   - Suggest improvements

5. **Revise** (General-Purpose)
   - Apply feedback

6. **Format** (Output Formatter)
   - Format for target platform

7. **Generate Metadata** (General-Purpose)
   - SEO metadata
   - Social snippets