executing-work-in-parallel

name	Executing Work in Parallel
description	Coordinate concurrent task execution through agent delegation. Plan independent work, manage dependencies, and execute multiple agents simultaneously. Use when handling multiple unrelated tasks, research investigations, or layer-based implementations that can run concurrently.

Executing Work in Parallel

Core Pattern

Parallel execution prevents context saturation and accelerates work through concurrent processing. Key principle: implement shared dependencies first, then launch independent agents simultaneously.

When to parallelize

• 2+ independent tasks — Different files or modules without interactions
• Research investigations — Multiple agents exploring different aspects
• Layer-based work — Database → API → Frontend stages
• Multi-file refactoring — Changes without interdependencies

When NOT to parallelize

• Single file modification — Use direct tools
• Sequential operations — Tasks building on each other
• Shared resource conflicts — Multiple agents modifying same file
• Complex interdependencies — Most tasks depend on others

Execution Framework

Phase 1: Task Analysis

1. Map all tasks — Comprehensive list of everything needed
2. Identify dependencies — Document what depends on what
3. Group independent work — Find tasks running simultaneously
4. Validate groupings — Confirm groups are truly independent

Phase 2: Implementation

Step 1: Shared Dependencies Implement first alone (shared types, interfaces, schemas, core utilities). Never parallelize these—they block other work.

Step 2: Parallel Execution Use single function_calls block with multiple Task invocations:

<function_calls>
  <invoke name="Task">
    <parameter name="description">First parallel task</parameter>
    <parameter name="subagent_type">appropriate-agent</parameter>
    <parameter name="prompt">Detailed context and instructions...</parameter>
  </invoke>
  <invoke name="Task">
    <parameter name="description">Second parallel task</parameter>
    <parameter name="subagent_type">appropriate-agent</parameter>
    <parameter name="prompt">Detailed context and instructions...</parameter>
  </invoke>
</function_calls>

Step 3: Wait and Reassess Let agents complete, then:

• Review results
• Identify newly unblocked work
• Plan next batch

Step 4: Repeat Continue batching until complete.

Common Patterns

Layer-Based

Stage 1: Database schema + Type definitions + Core utilities
Stage 2: Service layer + API endpoints + Frontend components
Stage 3: Tests + Documentation + Configuration

Feature-Based

Stage 1: Independent feature implementations
Stage 2: Integration points between features
Stage 3: Cross-cutting concerns

Research-First

Stage 1: Multiple research agents investigating aspects
Stage 2: Consolidation and planning from findings
Stage 3: Parallel implementation of requirements

Agent Delegation Checklist

✅ Provide complete context

• Exact file paths to read for patterns
• Target files to modify
• Existing conventions to follow
• Expected output format

✅ Use appropriate agents

• programmer — API, services, data layers, components, pages, styling
• Explore — Semantic searches, flow tracing
• senior-engineer — Testing and verification
• orchestrator — Complex multi-agent work

✅ Respect dependencies

• Type dependencies (interfaces others use)
• Core utilities and shared functions
• Database schemas and migrations
• API contracts and payloads
• Never parallelize dependent tasks

Thresholds

Metric	Threshold
Minimum tasks to parallelize	2 independent tasks
Optimal group size	3-5 independent tasks
Maximum concurrent agents	7-8 (diminishing returns)

Critical Reminders

1. Implement shared dependencies alone first — Types, interfaces, schemas, base utilities
2. Single function_calls block per batch — All parallel invocations in one call
3. Exact file paths — Agents need explicit guidance
4. Think between batches — Reassess what's unblocked after each stage
5. Monitor context limits — Split complex tasks rather than overload agents
6. Quality over speed — Correctness and correctness always supersede parallelization