Parallel Worker Orchestration

Target: $ARGUMENTS

Decomposes work into independent units and dispatches them to parallel background agents. Each agent gets its own context window, preventing cross-contamination between unrelated tasks.

When to Use

• Multiple independent tasks (e.g., create 3 unrelated files, research 4 topics)
• Context-heavy work that would pollute the main session
• Parallel file creation/editing in different areas of the codebase

When NOT to Use

• Sequential dependent tasks (output of A feeds into B)
• Single-file changes or trivial edits
• Tasks requiring shared mutable state between workers
• Fewer than 2 independent units

Workflow

1. Decompose

Split the user request into independent work units. Each unit must be:

• Self-contained (no dependency on other units)
• Well-scoped (clear input, clear expected output)
• Worth isolating (non-trivial enough to justify agent overhead)

2. Plan

For each unit, define:

Field	Description
Name	Short identifier (e.g., worker-auth, worker-docs)
Type	worktree for file changes, shared for read-only research
Prompt	Complete, self-contained instructions (no shared context)
Output	What the agent should produce and where

3. Dispatch

Launch all agents in a single message with multiple Agent tool calls. This ensures true parallel execution. Each agent prompt must include:

• Full context needed (file paths, requirements, constraints)
• Expected output format and location
• No references to other agents or their work

4. Track

Use TaskCreate for each dispatched unit to give the user visibility:

TaskCreate: "worker-auth: implement OAuth module" — status: in_progress
TaskCreate: "worker-docs: write API reference" — status: in_progress

Update tasks as agents complete via TaskUpdate.

5. Collect

After all agents finish:

• Read each agent's output
• Validate completeness and correctness
• Synthesize a summary for the user
• Handle any git operations (worktree agents lack Bash)

Agent Isolation Modes

Mode	Use when	File access
worktree	Agent creates/edits files	Isolated copy, lead merges
shared	Agent only reads/researches	Shared repo, no writes

Constraints

• Worktree agents lack Bash — the lead agent handles all git operations (commits, merges, branch management) after collecting results
• Max ~5 parallel agents — diminishing returns beyond this; context scheduling overhead increases
• Self-contained prompts — each agent gets a complete prompt with all necessary context; no shared memory between agents
• Lead agent owns coordination — only the lead creates, tracks, and collects; agents do not spawn sub-agents

Anti-Patterns

• Dispatching a single trivial task as a "parallel" worker (just do it inline)
• Sharing mutable state between agents (they cannot see each other's changes)
• Vague prompts that require agents to ask clarifying questions
• Dispatching dependent tasks in parallel (use sequential execution instead)
• Skipping the collect phase (results must be validated and synthesized)

Quality Check

• Each agent prompt is self-contained and actionable
• No circular or hidden dependencies between units
• All agent results collected and validated before reporting to user
• Git operations performed by lead after collection, not by workers