Agent Orchestration

Agent Orchestration Skill

Overview

A coordination framework ensuring parallel agents work cohesively under master Claude orchestration. This skill is domain-agnostic - it provides the methodology for coordinating ANY multi-agent work, regardless of the domain.

Cardinal Rule: YOU (master Claude) are the ORCHESTRATOR, not a task dispatcher. Agents are specialists with bounded autonomy, not independent actors.

For domain-specific standards, also invoke:

• web-frontend-standards - Dark mode, design tokens, PWA, accessibility
• backend-systems-protocols - Database, API contracts, auth, error handling

Type

workflow / coordination

When to Use

Trigger this skill when:

• Launching 2+ parallel agents for any task
• Any work where agent outputs must integrate seamlessly
• Multi-file changes that must remain consistent
• Complex tasks being split across multiple agents

Keywords: parallel, agents, coordinate, orchestrate, multi-agent, dispatch, integration, consistency

The Problem: Siloed Parallel Work

When agents run in parallel without coordination:

• Each makes independent decisions
• Naming conventions diverge
• Patterns conflict
• Approaches fragment
• Integration requires extensive rework

Siloed agents = fragmented output. This is a failure mode.

The Solution: Master Coordinator Pattern

┌─────────────────────────────────────────────────────────────┐
│                   MASTER CLAUDE                              │
│            (You - the orchestrator)                          │
│                                                              │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ PRE-FLIGHT  │→ │  DISPATCH   │→ │ POST-FLIGHT │          │
│  │  - Context  │  │  - Bounded  │  │  - Review   │          │
│  │  - Manifest │  │  - Aligned  │  │  - Unify    │          │
│  │  - Contracts│  │  - Tasked   │  │  - Integrate│          │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
└─────────────────────────────────────────────────────────────┘
                           │
           ┌───────────────┼───────────────┐
           ▼               ▼               ▼
    ┌──────────┐    ┌──────────┐    ┌──────────┐
    │ Agent A  │    │ Agent B  │    │ Agent C  │
    │ Bounded  │    │ Bounded  │    │ Bounded  │
    │ Context  │    │ Context  │    │ Context  │
    └──────────┘    └──────────┘    └──────────┘

Phase 1: Pre-Flight (NEVER SKIP)

Purpose: Establish shared reality before ANY parallel dispatch

Pre-Flight Checklist

• Analyzed FULL scope of work
• Identified ALL interdependencies between tasks
• Defined shared conventions (naming, patterns, structure)
• Listed constraints agents MUST follow
• Listed anti-patterns agents MUST avoid
• Created coordination manifest
• Invoked domain-specific skills as needed

Coordination Manifest Template

Every agent receives this context:

## Coordination Manifest

### Project Context
[Brief description of what we're building]

### Shared Constraints (MUST FOLLOW)
- Naming: [convention]
- File structure: [where things go]
- Patterns: [required patterns]
- Anti-patterns: [forbidden approaches]

### Domain Standards
[Reference domain skills: web-frontend-standards, backend-systems-protocols, etc.]

### Your Bounded Task
[Specific assignment with clear boundaries]

### Integration Points
[How your work connects to other agents' work]

### Escalation Triggers
[When to stop and report back vs. make a decision]

Phase 2: Dispatch (Bounded Autonomy)

Purpose: Launch agents with clear boundaries and shared context

Dispatch Rules

1. Every agent gets the coordination manifest
2. Specify explicit boundaries - what they own, what they don't
3. Define integration interfaces - how their work connects to others
4. Set escalation triggers - when to stop and ask vs. proceed

Agent Prompt Template

You are working as part of a coordinated multi-agent team.

## Coordination Manifest
[Paste manifest here]

## Your Specific Task
[Bounded, specific assignment]

## Your Boundaries
- You OWN: [specific files/components/functions]
- You do NOT touch: [other agents' territory]
- Interface with: [how your work connects]

## Constraints (Non-Negotiable)
[List from manifest - agents MUST follow these]

## Escalation
If you encounter:
- Decisions affecting other agents' work → STOP, report back
- Conflicts with constraints → STOP, report back
- Uncertainty about scope → STOP, report back

Phase 3: Post-Flight (Integration)

Purpose: Unify agent outputs into coherent whole

Post-Flight Checklist

• Reviewed ALL agent outputs
• Checked for naming conflicts
• Verified pattern consistency
• Identified duplicated code/logic
• Resolved style/approach divergence
• Unified shared utilities
• Integration tested complete system
• ONLY THEN: mark task complete

Common Integration Issues

Domain Skill Integration

When the task involves specific domains, invoke the relevant skills BEFORE pre-flight:

Pattern:

1. Invoke domain skills to get standards
2. Include those standards in coordination manifest
3. Dispatch agents with manifest
4. Post-flight includes domain-specific verification

Anti-Patterns (What NOT to Do)

NEVER do these:

1. Dispatch without manifest - Agents will make conflicting decisions
2. Skip pre-flight - "They'll figure it out" = guaranteed rework
3. Vague boundaries - "Work on the UI" → overlapping/conflicting work
4. No post-flight review - Miss integration issues until user finds them
5. Assume consistency - Always verify, never assume
6. Let agents pick patterns - YOU decide, agents implement
7. Skip domain skills - Generic coordination without domain standards = inconsistency

Red flags you're about to violate this skill:

• "Just split it up and run parallel"
• "They can coordinate themselves"
• "Ship it, we'll fix inconsistencies later"
• "Each agent can choose their approach"

Quick Reference

Minimal Pre-Flight (Small Tasks)

Even for quick parallel work:

1. Define naming convention
2. Specify file ownership
3. State integration point
4. Dispatch

Full Pre-Flight (Complex Tasks)

1. Invoke domain skills
2. Create detailed manifest
3. Define all constraints
4. Document integration points
5. Set escalation triggers
6. Dispatch with full context

Post-Flight Verification

1. Review all outputs
2. Check naming consistency
3. Verify patterns match
4. Integration test
5. Mark complete

Real-World Impact

Without coordination:

• 3 agents build 3 different patterns
• Contracts don't match between components
• Approaches conflict
• Integration takes longer than the parallel work saved

With coordination:

• Unified patterns from first agent dispatch
• Contracts defined before implementation
• Single approach throughout
• Integration is merge, not rework

The math:

• Skip coordination: save 10 min, waste 2 hours on integration
• Follow process: invest 15 min, seamless integration

Domain-agnostic coordination methodology Combine with domain skills for complete guidance