name: Agent Orchestrator
slug: agent-orchestrator
description: Coordinate multiple AI agents and skills for complex workflows
category: meta
complexity: multi-agent
version: "1.0.0"
author: "ID8Labs"
triggers:
- "orchestrate agents"
- "coordinate agents"
- "multi-agent workflow"
- "agent orchestrator"
- "delegate to agents"
tags:
- multi-agent
- orchestration
- coordination
- delegation

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:
2. What's the end goal?
3. What are the components?
4. What expertise is needed?
5. Map to available agents/skills:
6. Which agents have relevant capabilities?
7. What's each agent's specialty?
8. What tools/MCPs do they access?
9. Decompose into subtasks:
10. Break along expertise boundaries
11. Identify dependencies
12. Determine execution order
13. Delegate to appropriate agents:
14. Assign subtasks with clear instructions
15. Provide necessary context
16. Set success criteria
17. Specify output format
18. Monitor execution:
19. Track progress
20. Identify blockers
21. Handle failures
22. Integrate results:
23. Collect agent outputs
24. Resolve conflicts
25. Synthesize into coherent whole
26. Validate final result

Workflow 2: Parallel Agent Execution

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

Workflow 3: Sequential Agent Pipeline

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

Workflow 4: Adaptive Agent Selection

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

Workflow 5: Error Recovery & Fallback

1. Detect agent failure:
2. Task not completed
3. Output quality insufficient
4. Timeout exceeded
5. Error thrown
6. Diagnose failure cause:
7. Was task unclear?
8. Was agent wrong choice?
9. Was input malformed?
10. Was dependency unavailable?
11. Attempt recovery:
12. Retry with same agent (if transient error)
13. Retry with different agent (if capability mismatch)
14. Simplify task and retry (if too complex)
15. Escalate to human (if unrecoverable)
16. Log failure and recovery
17. 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:
2. What's inconsistent?
3. Which agents disagree?

4. What's the nature of disagreement?

5. Evaluate sources:

6. Which agent is more authoritative for this?
7. What's the confidence level?

8. What's the reasoning?

9. Resolve using strategy:

10. Authority: Trust the specialist
11. Voting: Majority wins (if multiple agents)
12. Synthesis: Combine best of both

13. Escalate: Ask human to decide

14. Document resolution:

15. What was the conflict?
16. How was it resolved?
17. 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