orchestrator

Orchestrator Agent 🎯

A technical lead coordinator that manages complex projects by breaking them down and orchestrating multiple specialized agents to work together efficiently.

Overview

The Orchestrator agent acts as your AI project manager, specializing in:

• Project Breakdown: Decomposing complex tasks into manageable phases
• Agent Coordination: Deploying the right specialists for each task
• Parallel Execution: Managing multiple agents working simultaneously
• Risk Management: Identifying and mitigating technical challenges
• Progress Tracking: Monitoring and reporting project status

When to Use

This agent automatically activates when you:

• Have complex, multi-step projects
• Need to coordinate multiple development tasks
• Want strategic technical planning
• Require architecture design and implementation
• Need to manage parallel workstreams

Trigger Phrases

• "build a complete"
• "implement full"
• "coordinate development"
• "plan architecture"
• "orchestrate"
• "manage project"

Example Usage

Full Feature Development

"Build a complete user authentication system with OAuth, 2FA, and audit logging"

System Architecture

"Plan and implement a microservices architecture for our e-commerce platform"

Complex Integration

"Coordinate the integration of payment processing with Stripe, including webhooks and refunds"

Migration Project

"Orchestrate the migration from MongoDB to PostgreSQL"

The Three-Phase Execution Model

Phase 1: Research & Analysis (Parallel)

The orchestrator deploys specialized agents to gather information:

Deploying agents for research:
- Code Archaeologist → Explore existing codebase
- Requirements Analyst → Clarify specifications  
- Tech Stack Analyst → Identify dependencies
- Risk Assessor → Find potential challenges

Phase 2: Planning & Design

Synthesizes findings and creates strategy:

## Technical Plan
- Architecture decisions
- Task breakdown with dependencies
- Resource allocation
- Timeline estimation
- Success criteria

Phase 3: Implementation & Delivery (Coordinated)

Executes plan with specialized agents:

Task assignments:
- Backend Expert → API development
- Frontend Developer → UI components
- Database Specialist → Schema design
- Test Engineer → Test suite

Sample Orchestration

E-Commerce Feature Example

## Project: Shopping Cart with Checkout

### Phase 1: Research (15 min)
Parallel Tasks:
✓ Analyze existing user model
✓ Review payment integrations
✓ Check inventory system
✓ Identify UI components

### Phase 2: Planning (10 min)
Architecture Design:
- Cart service (stateful)
- Payment gateway integration
- Inventory check middleware
- Email notification queue

Task Breakdown:
1. Database schema (2h)
2. Cart API endpoints (3h)
3. Payment integration (4h)
4. Frontend components (3h)
5. Testing suite (2h)

### Phase 3: Implementation (In Progress)
Active Tasks:
🔄 Database Expert: Creating cart schema
🔄 Backend Dev: Building cart service
⏳ Frontend Dev: Waiting for API
⏳ Test Engineer: Writing test specs

Orchestration Patterns

1. Feature Development Pattern

Research → Design → Implement → Test → Deploy
         ↓
    Parallel execution where possible

2. Bug Investigation Pattern

Reproduce → Investigate → Root Cause → Fix → Verify
    ↓            ↓
Multiple agents  Parallel debugging

3. Refactoring Pattern

Analyze → Plan → Incremental Changes → Validate
   ↓                    ↓
Current state    Maintain functionality

4. Migration Pattern

Map Current → Design Target → Plan Migration → Execute → Verify
      ↓             ↓              ↓
  Dependencies  New architecture  Rollback plan

Agent Delegation Strategy

The orchestrator maintains an expertise matrix:

Task Type	Primary Agent	Support Agents
API Development	backend-specialist	api-architect, security-expert
UI Implementation	frontend-developer	ux-designer, accessibility-expert
Database Design	database-architect	performance-optimizer
Testing	test-engineer	qa-specialist, security-tester
Documentation	documentation-expert	technical-writer
Deployment	devops-engineer	security-auditor

Communication Protocols

Status Updates

## Project Status: User Authentication

### Phase: Implementation
### Progress: 65%

### Completed ✅
- Database schema design
- Basic auth endpoints
- Password hashing setup

### In Progress 🔄
- OAuth integration (GitHub, Google)
- Session management
- Email verification

### Upcoming ⏳
- 2FA implementation
- Audit logging
- Security testing

### Blockers 🚫
- Waiting for OAuth app credentials
- Email service selection pending

Task Handoffs

## Handoff: Backend → Frontend

### Completed Work
- User registration API
- Login/logout endpoints
- Profile management

### API Documentation
- Endpoints: See /docs/api/auth
- Authentication: JWT in headers
- Response formats: JSON

### Next Steps
- Build login form component
- Implement JWT storage
- Create profile page

Advanced Orchestration

Competing Solutions

"Deploy 3 agents to propose different architectures:
1. Microservices approach
2. Monolithic approach
3. Serverless approach

Compare on: scalability, complexity, cost, and time-to-market"

Risk Mitigation

"Orchestrate a security audit:
1. Code review for vulnerabilities
2. Dependency scanning
3. Penetration testing simulation
4. Compliance check"

Performance Optimization

"Coordinate performance improvements:
1. Profile current bottlenecks
2. Propose optimizations
3. Implement changes
4. Verify improvements"

Customization

Project Templates

Add project-specific orchestration patterns:

# In ~/.claude/agents/orchestrator.md
## Custom Patterns
### Mobile App Release
- Beta testing phase
- App store preparation
- Staged rollout plan

Team Structure

Define your preferred team composition:

### Default Team Composition
- 1 Tech Lead (orchestrator)
- 2 Backend Developers
- 2 Frontend Developers
- 1 Database Expert
- 1 Test Engineer
- 1 DevOps Engineer

Integration Examples

With Project Management

"Create Jira tickets for each phase of the project"

With CI/CD

"Orchestrate deployment pipeline setup with staging and production"

With Documentation

"Coordinate documentation updates across all teams"

Best Practices

1. Clear Objectives

• Define success criteria upfront
• Set measurable goals
• Establish timelines

2. Efficient Coordination

• Maximize parallel work
• Minimize dependencies
• Clear communication

3. Risk Management

• Identify risks early
• Have contingency plans
• Regular checkpoints

4. Quality Gates

• Code review checkpoints
• Test coverage requirements
• Performance benchmarks

Combining with Other Agents

The orchestrator naturally works with all agents:

Complex Project Example

Orchestrator coordinates:
├── Code Reviewer → Quality checks
├── Test Runner → Test coverage
├── Security Auditor → Vulnerability scan
├── Performance Expert → Optimization
└── Documentation Expert → User guides

Success Metrics

The orchestrator tracks:

• ✅ Task completion rate
• ⏱️ Timeline adherence
• 🎯 Quality metrics
• 🔄 Integration success
• 📊 Test coverage
• 🚀 Deployment readiness

Tips for Success

1. Start with Clear Requirements: Better input = better orchestration
2. Trust the Process: Let the orchestrator manage complexity
3. Review Checkpoints: Validate at phase transitions
4. Iterate: Refine the plan as you learn
5. Document Decisions: Keep architectural records

---

Remember: The Orchestrator is your AI technical lead, turning complex projects into coordinated success stories. Let it handle the complexity while you focus on the vision!