multi-agent-workforce-planner

Imported from 4444j99/a-i--skills (skills/tools/multi-agent-workforce-planner/SKILL.md). Install upstream with npx skills add 4444j99/a-i--skills --skill multi-agent-workforce-planner. Copyright stays with the author (MIT).

Multi-Agent Workforce Planner

Design parallel agent workstreams for large feature implementations by analyzing dependencies, assigning specialized agents, and maximizing parallelization.

When to Use

• Breaking down large features into parallel work
• Planning multi-file implementations
• Coordinating specialized agent types
• Maximizing development throughput
• Managing complex dependency chains

Core Framework

Feature Spec → Requirements → Dependency Graph → Parallel Streams → Agent Assignment
     ↓              ↓               ↓                  ↓                  ↓
   Input        Breakdown       Identify           Group into        Match to
   Document     into tasks      blockers           workstreams       agent types

Task Granularity

Agent Type Catalog

Agent Selection Rules

Need to understand code? → Explore
Need to design solution? → Plan
Need to run commands?   → Bash
Need to modify files?   → Edit

Planning Process

Step 1: Decompose Requirements

Break the feature into discrete tasks:

feature: "User Authentication System"
tasks:
  - id: T1
    name: "Research existing auth patterns"
    type: research
    agent: Explore

  - id: T2
    name: "Design auth architecture"
    type: design
    agent: Plan
    depends_on: [T1]

  - id: T3
    name: "Implement User model"
    type: implementation
    agent: Edit
    depends_on: [T2]

  - id: T4
    name: "Implement auth middleware"
    type: implementation
    agent: Edit
    depends_on: [T2]

  - id: T5
    name: "Write auth tests"
    type: testing
    agent: Edit
    depends_on: [T3, T4]

  - id: T6
    name: "Run test suite"
    type: verification
    agent: Bash
    depends_on: [T5]

Step 2: Build Dependency Graph

graph TD
    T1[Research patterns] --> T2[Design architecture]
    T2 --> T3[Implement User model]
    T2 --> T4[Implement middleware]
    T3 --> T5[Write tests]
    T4 --> T5
    T5 --> T6[Run tests]

Step 3: Identify Parallel Opportunities

Tasks without dependencies between them can run in parallel:

Phase 1: T1 (solo - must complete first)
Phase 2: T2 (solo - design phase)
Phase 3: T3, T4 (parallel - independent implementations)
Phase 4: T5 (solo - needs both implementations)
Phase 5: T6 (solo - verification)

Step 4: Create Workstreams

Group related tasks into workstreams:

workstreams:
  - name: "Core Auth"
    tasks: [T3, part of T5]
    owner: agent-1

  - name: "Middleware"
    tasks: [T4, part of T5]
    owner: agent-2

Parallelization Strategies

Horizontal Parallelization

Multiple independent features simultaneously:

Feature A ─────────────────────>
Feature B ─────────────────────>
Feature C ─────────────────────>

Vertical Parallelization

Different layers of same feature:

Frontend  ─────────────>
Backend   ─────────────>
Database  ─────────────>
Tests     ─────────────>

Interface-First Parallelization

Define contracts, implement in parallel:

1. Define interfaces/types (blocking)
2. Implement producer and consumer in parallel

phase1:
  - task: "Define API contract"
    agent: Plan
    blocking: true

phase2_parallel:
  - task: "Implement API server"
    agent: Edit
  - task: "Implement API client"
    agent: Edit

Speculative Parallelization

Start likely-needed work early:

main_path:
  - task: "Implement feature"
    agent: Edit

speculative:
  - task: "Prepare test fixtures"
    agent: Edit
    confidence: high  # Will definitely be needed
  - task: "Draft documentation"
    agent: Edit
    confidence: medium  # Might need revision

Progress Tracking

Status Format

Workstream A: [████████░░] 80% (8/10 tasks)
  └─ Blocked: Waiting on API contract from B

Workstream B: [██████████] 100% ✓

Workstream C: [████░░░░░░] 40%
  └─ At Risk: Task 7 failed twice

Task States

Progress Table

| Task | Agent | Status | Blocked By | Notes |
|------|-------|--------|------------|-------|
| T1   | Explore | ● | - | Completed |
| T2   | Plan    | ● | - | Completed |
| T3   | Edit    | ◐ | - | In progress |
| T4   | Edit    | ◐ | - | In progress |
| T5   | Edit    | ○ | T3, T4 | Waiting |
| T6   | Bash    | ○ | T5 | Waiting |

Failure Recovery

Retry Strategy

retry_policy:
  max_attempts: 3
  backoff: exponential
  base_delay: 30s

on_failure:
  - log_error
  - notify_supervisor
  - attempt_recovery
  - escalate_if_exhausted

Recovery Patterns

1. Retry: Same agent, same task
2. Reassign: Different agent, same task
3. Decompose: Break task into smaller subtasks
4. Skip: Mark as skipped, continue with downstream
5. Escalate: Human intervention required

Checkpoint Strategy

checkpoints:
  - after: phase1
    save: ["contracts", "interfaces"]

  - after: phase2
    save: ["implementations"]
    validate: ["types_match", "tests_pass"]

Workstream Template

workstream:
  name: "Feature Name"
  id: WS-001
  owner: agent-type

  objectives:
    - "Primary goal"
    - "Secondary goal"

  tasks:
    - id: T1
      name: "Task description"
      agent: Explore
      estimated: 15min

    - id: T2
      name: "Next task"
      agent: Edit
      depends_on: [T1]
      estimated: 30min

  success_criteria:
    - "All tests pass"
    - "No type errors"

  risks:
    - risk: "Complex integration"
      mitigation: "Early interface definition"

Example: Full Feature Breakdown

Feature: Add User Profile Editing

epic:
  name: "User Profile Editing"

workstreams:
  - name: "Backend API"
    tasks:
      - {id: B1, name: "Research current user model", agent: Explore}
      - {id: B2, name: "Design profile update endpoint", agent: Plan, depends_on: [B1]}
      - {id: B3, name: "Implement PUT /users/:id/profile", agent: Edit, depends_on: [B2]}
      - {id: B4, name: "Add validation middleware", agent: Edit, depends_on: [B2]}
      - {id: B5, name: "Write API tests", agent: Edit, depends_on: [B3, B4]}

  - name: "Frontend UI"
    tasks:
      - {id: F1, name: "Research existing form patterns", agent: Explore}
      - {id: F2, name: "Design ProfileEdit component", agent: Plan, depends_on: [F1]}
      - {id: F3, name: "Implement form component", agent: Edit, depends_on: [F2]}
      - {id: F4, name: "Add form validation", agent: Edit, depends_on: [F3]}
      - {id: F5, name: "Write component tests", agent: Edit, depends_on: [F4]}

  - name: "Integration"
    tasks:
      - {id: I1, name: "Connect frontend to API", agent: Edit, depends_on: [B3, F3]}
      - {id: I2, name: "Write E2E tests", agent: Edit, depends_on: [I1]}
      - {id: I3, name: "Run full test suite", agent: Bash, depends_on: [B5, F5, I2]}

parallel_execution:
  phase1: [B1, F1]  # Research in parallel
  phase2: [B2, F2]  # Design in parallel
  phase3: [B3, B4, F3]  # Implementation
  phase4: [F4, B5]  # Validation + tests
  phase5: [F5, I1]  # More tests + integration
  phase6: [I2]
  phase7: [I3]

References

• references/dependency-analysis.md — Identifying task dependencies
• references/parallelization-strategies.md — Maximizing parallel work
• references/agent-type-catalog.md — Agent capabilities reference
• references/failure-recovery-patterns.md — Handling failures
• references/workflow-integration.md — Ecosystem integration

Related Skills

• product-requirements-designer: For creating feature specifications
• verification-loop: For validating completed work
• deployment-cicd: For deployment after implementation