max-subagents-parallel

name: max-subagents-parallel description: Use when starting ANY non-trivial task to maximize parallelism - spawns multiple subagents, creates task graphs, identifies independent work streams

Maximum Parallelism Mode

Overview

Default to parallel, not sequential. Before executing ANY multi-step task, first map dependencies then spawn maximum concurrent agents (target: 8-10 per wave).

Strategies

Three execution strategies available (default: recursive):

The Pattern

digraph max_parallel {
    rankdir=TB;

    "Receive task" [shape=box];
    "Select strategy (recursive/ensemble/sweep)" [shape=box];
    "Map all subtasks (target 8-10)" [shape=box];
    "Identify dependencies (blocks/blockedBy)" [shape=box];
    "Group into parallel waves" [shape=box];
    "Spawn agents for Wave 1 (up to 10 independent tasks)" [shape=box];
    "Wait for Wave 1 completion" [shape=diamond];
    "Spawn Wave 2 (tasks blocked by Wave 1)" [shape=box];
    "Continue until all waves complete" [shape=box];
    "Synthesis Wave - merge & validate all results" [shape=box, style=bold];

    "Receive task" -> "Select strategy (recursive/ensemble/sweep)";
    "Select strategy (recursive/ensemble/sweep)" -> "Map all subtasks (target 8-10)";
    "Map all subtasks (target 8-10)" -> "Identify dependencies (blocks/blockedBy)";
    "Identify dependencies (blocks/blockedBy)" -> "Group into parallel waves";
    "Group into parallel waves" -> "Spawn agents for Wave 1 (up to 10 independent tasks)";
    "Spawn agents for Wave 1 (up to 10 independent tasks)" -> "Wait for Wave 1 completion";
    "Wait for Wave 1 completion" -> "Spawn Wave 2 (tasks blocked by Wave 1)" [label="done"];
    "Spawn Wave 2 (tasks blocked by Wave 1)" -> "Continue until all waves complete";
    "Continue until all waves complete" -> "Synthesis Wave - merge & validate all results";
}

Execution Rules

1. ALWAYS Map Before Acting

Before ANY implementation:

1. List ALL subtasks — target 8-10 per wave (don't stop at 2-3)
2. For each pair: "Does A need B's output?" → B blocks A
3. Tasks with no blockers = Wave 1 (parallel)
4. Tasks blocked only by Wave 1 = Wave 2 (parallel after Wave 1)
5. After all waves: Synthesis wave (MANDATORY)

2. ALWAYS Use Parallel Tool Calls

WRONG - Sequential:

Task("Explore auth module")
[wait for result]
Task("Explore database module")
[wait for result]
Task("Explore API module")

RIGHT - Parallel (single message, multiple tool calls):

Task("Explore auth module")     // These all spawn
Task("Explore database module") // in a single message
Task("Explore API module")      // executing concurrently
Task("Explore state mgmt")     // Keep going —
Task("Explore config layer")   // target 8-10 agents
Task("Explore error handling") // per wave

3. Match Model to Task Complexity

4. Use TaskCreate with Dependencies

TaskCreate("Implement auth service")     // id: 1
TaskCreate("Implement user model")       // id: 2
TaskCreate("Implement API routes")       // id: 3, blocks: [1, 2]
TaskCreate("Write integration tests")    // id: 4, blockedBy: [3]

Tasks 1 and 2 run parallel. Task 3 waits for both. Task 4 waits for 3.

5. Mandatory Synthesis Wave

After all execution waves complete, ALWAYS spawn a synthesis agent:

Task("Synthesize and validate all results from Waves 1-N", subagent_type="general-purpose", model="opus")

The synthesis agent must:

• Merge findings from all agents into a coherent summary
• Flag contradictions or conflicts between agent results
• Validate completeness — did we miss anything?
• Produce the final deliverable

Quick Reference

Example: Feature Implementation (Recursive Strategy)

Task: "Add user authentication"

WRONG (sequential):

1. Research auth patterns [wait]
2. Implement user model [wait]
3. Implement auth service [wait]
4. Add API routes [wait]
5. Write tests [wait]

RIGHT (parallel waves, 10 agents):

Wave 1 (parallel - no dependencies, 6 agents):
  - Task("Research auth patterns in codebase", model="haiku")
  - Task("Research existing user model code", model="haiku")
  - Task("Research API route patterns", model="haiku")
  - Task("Research middleware patterns", model="haiku")
  - Task("Research test patterns", model="haiku")
  - Task("Research config/env for auth secrets", model="haiku")

Wave 2 (parallel - after Wave 1, 3 agents):
  - Task("Implement user model", model="sonnet")
  - Task("Implement auth service", model="sonnet")
  - Task("Implement auth middleware", model="sonnet")

Wave 3 (after Wave 2):
  - Task("Add API routes", blockedBy=[user_model, auth_service, middleware])

Wave 4 (after Wave 3):
  - Task("Write tests", blockedBy=[api_routes])

Wave 5 (Synthesis - MANDATORY):
  - Task("Validate auth implementation: review all changes, run tests, check security", model="opus")

Result: 5 waves with up to 6 agents in Wave 1. Massively faster than sequential.

Example: Ensemble Strategy

Task: "Should we use Redis or PostgreSQL for session storage?"

Wave 1 (ensemble - same question, 3 models):
  - Task("Analyze: Redis vs PostgreSQL for session storage given our codebase", model="haiku")
  - Task("Analyze: Redis vs PostgreSQL for session storage given our codebase", model="sonnet")
  - Task("Analyze: Redis vs PostgreSQL for session storage given our codebase", model="opus")

Wave 2 (synthesis):
  - Task("Compare 3 independent analyses, flag agreements/disagreements, produce recommendation", model="opus")

Example: Sweep Strategy

Task: "Understand this new codebase"

Wave 1 (sweep - 10 agents, maximum breadth):
  - Task("Explore: project structure and entry points", model="haiku")
  - Task("Explore: database models and schema", model="haiku")
  - Task("Explore: API routes and controllers", model="haiku")
  - Task("Explore: authentication and authorization", model="haiku")
  - Task("Explore: frontend components and state", model="haiku")
  - Task("Explore: test infrastructure and coverage", model="haiku")
  - Task("Explore: build system and CI/CD", model="haiku")
  - Task("Explore: configuration and environment", model="haiku")
  - Task("Explore: error handling and logging", model="haiku")
  - Task("Explore: third-party integrations", model="haiku")

Wave 2 (synthesis):
  - Task("Synthesize all 10 explorations into architecture overview", model="opus")

Trigger Phrases

When user says any of these, invoke /max-subagents-parallel:

• "do this in parallel"
• "spawn multiple agents"
• "maximize parallelism"
• "work faster"
• "parallelize this"

Anti-Patterns (NEVER DO)

• Starting with step 1 before mapping all steps
• Sequential tool calls when parallel is possible
• Using Opus for file exploration
• Single-threaded investigation of independent failures
• Waiting for one search before starting another unrelated search
• Stopping at 3-5 agents when 8-10 would be more effective
• Skipping the synthesis wave

The Iron Law

If tasks are independent, they MUST run in parallel.
Sequential execution of independent tasks is a bug.