Orchestrating Parallel Workers

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

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: qte77
• Source: qte77/claude-code-plugins
• License: Apache-2.0
• Homepage: https://qte77.github.io/claude-code-plugins/

Install and usage instructions live in the source repository linked above.