Agent Orchestrator

What this skill does

# 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

| Action | Command/Trigger |
|--------|-----------------|
| Delegate complex task | "Orchestrate agents for [task]" |
| Run agents in parallel | "Run these tasks in parallel: [tasks]" |
| Create agent pipeline | "Create pipeline: [agent1] → [agent2] → [agent3]" |
| Select best agent | "Which agent should handle [task]?" |
| Coordinate workflow | "Coordinate [workflow] across agents" |
| Handle agent failure | "Agent [X] failed on [task], recover" |
| Integrate agent outputs | "Synthesize outputs from [agents]" |

## 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

| Agent/Skill | Specialty | Best For | Avoid For |
|-------------|-----------|----------|-----------|
| **General-Purpose** | Broad tasks | Quick tasks, general coding | Complex orchestration |
| **Operations Manager** | Project coordination | Workflows, timelines, resources | Writing code |
| **UI Builder** | Frontend design | Components, layouts, styling | Backend logic |
| **Database Designer** | Schema design | Tables, relationships, RLS | Frontend work |
| **API Designer** | Endpoint design | RESTful APIs, validation | UI/UX |
| **Testing QA** | Test creation | E2E tests, test plans | Feature development |
| **Performance Optimizer** | Speed optimization | Metrics, caching, lazy loading | Initial development |
| **Deployment Automation** | CI/CD | Vercel, environments, pipelines | Coding features |
| **Prompt Engineer** | AI optimization | Improving prompts, AI workflows | Non-AI tasks |
| **Skill Creator** | Skill development | Building new skills | Daily tasks |
| **Workflow Designer** | Process design | Complex workflows | Simple tasks |
| **Chain Builder** | Prompt sequences | Multi-step AI tasks | Single prompts |

### MCP/Tool Access

| Agent | Available MCPs/Tools |
|-------|---------------------|
| **General-Purpose** | All (Playwright, Supabase, GitHub, Firecrawl, Memory) |
| **Operations Manager** | GitHub (PRs, issues), Memory (tracking) |
| **UI Builder** | Playwright (testing), Memory (design decisions) |
| **Database Designer** | S