majiayu000 Parallel Execution
Execute multiple independent tasks simultaneously to maximize throughput and minimize total execution time.
When to Use
- Multiple independent tasks (no dependencies)
- Tasks benefit from concurrent execution
- Maximizing throughput is priority
- Available agents for parallel work
- Results can be aggregated after completion
Core Concepts
Independence
Tasks are independent when:
- ✓ No data dependencies (one doesn't need other's output)
- ✓ No resource conflicts (different files, databases)
- ✓ No ordering requirements (either can complete first)
- ✓ Failures are isolated (one failing doesn't block others)
Example - Independent:
✓ Task A: Review code quality (code-reviewer)
✓ Task B: Run test suite (test-runner)
→ Can run in parallel
Example - NOT Independent:
✗ Task A: Implement feature (feature-implementer)
✗ Task B: Test feature (test-runner)
→ B depends on A's output, must run sequentially
Concurrency
Critical: Use single message with multiple Task tool calls
Correct:
Send one message containing:
- Task tool call #1 → Agent A
- Task tool call #2 → Agent B
- Task tool call #3 → Agent C
All three agents start simultaneously.
Incorrect:
Message 1: Task tool → code-reviewer
[wait]
Message 2: Task tool → test-runner
[wait]
This is sequential, NOT parallel!
Synchronization
Collection Point:
- Wait for all parallel agents to complete
- Collect results from each agent
- Validate each result independently
- Aggregate results into final output
Parallel Execution Process
Step 1: Identify Independent Tasks
Independence Checklist:
- No data dependencies
- No shared writes (read-only or different targets)
- No execution order requirements
- Failures don't cascade
- Results can be validated independently
Step 2: Agent Assignment
Match Tasks to Agents:
Task 1: Review code quality → code-reviewer
Task 2: Run test suite → test-runner
Task 3: Run benchmarks → test-runner
Agent Availability Check:
- Ensure sufficient agents available
- Check for specialization overlap
- Consider workload balance
Step 3: Launch Parallel Execution
Single message with multiple Task tool calls:
<Task tool> → code-reviewer (review task)
<Task tool> → test-runner (test task)
<Task tool> → test-runner (benchmark task)
All agents start simultaneously.
Step 4: Monitor Execution
Track Progress:
Agent 1 (code-reviewer): In Progress
Task: Code quality review
Agent 2 (test-runner): Completed ✓
Task: Test suite
Result: 45/45 tests passed
Agent 3 (test-runner): In Progress
Task: Benchmarks
Step 5: Collect & Validate Results
As Each Agent Completes:
- Collect output
- Validate against success criteria
- Check for errors
- Mark as complete or failed
Step 6: Aggregate Results
## Parallel Execution Results
### Completed Tasks:
1. ✓ Code quality review (code-reviewer)
- Result: 3 minor issues found
2. ✓ Test suite (test-runner)
- Result: All tests passing (45/45)
3. ✓ Performance benchmarks (test-runner)
- Result: All benchmarks acceptable
### Overall Status: ✓ Success (with minor issues)
Execution Patterns
Pattern 1: Homogeneous Parallel
All agents same type, different inputs:
Use Case: Test multiple modules
├─ test-runner: Test memory-core
├─ test-runner: Test memory-storage-turso
└─ test-runner: Test memory-storage-redb
Single message, 3 Task tool calls
Pattern 2: Heterogeneous Parallel
Different agent types, related task:
Use Case: Comprehensive code check
├─ code-reviewer: Quality analysis
├─ test-runner: Test execution
└─ debugger: Performance profiling
Single message, 3 Task tool calls
Pattern 3: Parallel with Convergence
Parallel execution → Single synthesis:
Phase 1: Parallel Investigation
├─ debugger: Profile performance
├─ code-reviewer: Analyze efficiency
└─ test-runner: Run benchmarks
[All complete]
Phase 2: Synthesis
└─ Combine findings, identify root cause
Synchronization Strategies
Wait for All (AND)
Most Common:
- Wait for ALL agents to complete
- Proceed only when all finished
- Useful when all results needed
Wait for Any (OR)
Early Termination:
- Proceed when ANY agent completes successfully
- Cancel or continue others
- Useful for redundant approaches
Wait for Threshold
Partial Completion:
- Proceed when N out of M agents complete
- Useful for resilience
- Handle missing results gracefully
Resource Management
Available Agents
- code-reviewer (1 instance)
- test-runner (1 instance)
- feature-implementer (1 instance)
- refactorer (1 instance)
- debugger (1 instance)
Parallelization Limit: Maximum 5 agents simultaneously (one of each type)
Workload Balancing
Distribute Evenly:
Tasks: [T1, T2, T3, T4, T5, T6]
Agents: [A, B, C]
Distribution:
- Agent A: T1, T4 (2 tasks)
- Agent B: T2, T5 (2 tasks)
- Agent C: T3, T6 (2 tasks)
Error Handling
Independent Failures
Isolation:
- One agent failing doesn't stop others
- Continue collecting successful results
- Report failed tasks separately
Parallel Execution:
├─ Agent A: ✓ Success
├─ Agent B: ✗ Failed (error in code)
└─ Agent C: ✓ Success
Result:
- Collect: Results from A and C
- Report: B failed with error
- Decision: Retry B or proceed without
Partial Success Handling
Strategies:
- Fail Fast: If any fails, stop and report
- Best Effort: Collect all successful results
- Retry Failed: Let successful complete, retry failures
Performance Optimization
Speedup Calculation
Sequential time = T1 + T2 + T3 + ... + Tn
Parallel time = max(T1, T2, T3, ..., Tn)
Speedup = Sequential time / Parallel time
Example:
Tasks:
- Task A: 10 minutes
- Task B: 15 minutes
- Task C: 8 minutes
Sequential: 10 + 15 + 8 = 33 minutes
Parallel: max(10, 15, 8) = 15 minutes
Speedup: 33 / 15 = 2.2x faster
Optimal Parallelization
Identify Bottlenecks:
- Find longest-running task
- Can it be decomposed further?
- Can it be optimized?
- Start slow tasks first
Best Practices
DO:
✓ Verify independence before parallelizing ✓ Use single message with multiple Task tool calls ✓ Balance workload across agents ✓ Set appropriate timeouts for each task ✓ Handle failures gracefully (isolation) ✓ Validate each result independently ✓ Aggregate comprehensively at the end
DON'T:
✗ Parallelize dependent tasks ✗ Send sequential messages thinking they're parallel ✗ Overload single agent while others idle ✗ Skip validation because "it's parallel" ✗ Assume all will succeed ✗ Ignore agent failures
Examples
Example 1: Simple Parallel Review
Task: "Check code quality and run tests"
Analysis: Independent tasks, different agents
Plan:
├─ code-reviewer: Review code quality
└─ test-runner: Run test suite
Execution: [Single message with 2 Task tool calls]
Results:
- code-reviewer: 2 issues found ✓
- test-runner: 45/45 tests pass ✓
Speedup: 2x
Example 2: Multi-Module Testing
Task: "Test all crates in workspace"
Analysis: 3 independent crates, same agent type
Plan:
├─ test-runner: Test memory-core
├─ test-runner: Test memory-storage-turso
└─ test-runner: Test memory-storage-redb
Execution: [Single message with 3 Task tool calls]
Results:
- memory-core: 25/25 pass ✓
- memory-storage-turso: 15/15 pass ✓
- memory-storage-redb: 10/10 pass ✓
Speedup: 3x
Example 3: Comprehensive Quality Check
Task: "Pre-release quality validation"
Analysis: 4 independent checks, maximum parallelization
Plan:
├─ code-reviewer: Code quality (fmt, clippy)
├─ test-runner: Test suite execution
├─ test-runner: Performance benchmarks
└─ debugger: Memory leak detection
Execution: [Single message with 4 Task tool calls]
Results: All checks pass ✓
Speedup: 4x
Integration
Parallel execution is one coordination strategy used by the agent-coordination skill:
Coordination Strategy Selection:
├─ Independent tasks → Use parallel-execution (this skill)
├─ Dependent tasks → Use sequential coordination
├─ Complex mix → Use hybrid coordination
└─ Multiple perspectives → Use swarm (with parallel)
Summary
Parallel execution maximizes efficiency for independent tasks by:
- Concurrent agent execution (single message, multiple tools)
- Independent task validation (no cross-dependencies)
- Synchronized result collection (wait for completion)
- Comprehensive aggregation (synthesize final output)
When done correctly, parallel execution provides significant speedup while maintaining quality and reliability.