| name | parallel-executor |
| description | Execute complex tasks using parallel subagents. Use for large tasks that benefit from concurrent execution. Automatically plans, decomposes, and orchestrates parallel work. |
Parallel Task Execution
Purpose
This skill invokes the parallel execution system for complex tasks that can benefit from concurrent subagent work.
Arguments
$ARGUMENTS: Description of the complex task to execute
Usage
When invoked with /parallel-executor <task description>, this skill:
- Invokes the
parallel-executor agent to orchestrate the work
- The agent decomposes the task using
parallel-tasks-planner
- Executes independent subtasks in parallel via
task-worker agents
- Coordinates sequential phases based on dependencies
- Verifies results using the
verifier agent
Workflow
Invoke the Parallel Executor Agent
Use the Task tool to invoke the parallel-executor agent:
Task tool call:
description: "Execute parallel tasks"
subagent_type: "parallel-executor"
prompt: |
Execute the following complex task using parallel decomposition:
Task: $ARGUMENTS
Follow your workflow:
1. Use parallel-tasks-planner to decompose the task
2. Validate the plan for file conflicts
3. Execute phases (parallel and sequential)
4. Verify results
5. Report summary
Architecture
/parallel-executor "Add logging to all modules"
│
▼
┌─────────────────────┐
│ parallel-executor │ (orchestrator agent)
│ agent │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ parallel-tasks- │ (planning agent)
│ planner agent │
└──────────┬──────────┘
│
▼ (YAML execution plan)
│
┌──────────┴──────────┐
│ Phase Execution │
│ │
│ Phase 1 (Parallel):│
│ ┌────┐ ┌────┐ │
│ │W1 │ │W2 │ │ (task-worker agents)
│ └────┘ └────┘ │
│ │
│ Phase 2 (Sequential):│
│ ┌────────────┐ │
│ │ W3 │ │
│ └────────────┘ │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ verifier agent │ (verification)
└─────────────────────┘
When to Use
Use this skill for tasks that:
- Span multiple independent modules or files
- Can be logically decomposed into parallel work
- Would benefit from concurrent execution
- Are large enough to justify the planning overhead
Good candidates:
- "Add logging to API, database, and utility modules"
- "Implement CRUD endpoints for users, products, and orders"
- "Add type hints to all modules"
- "Write tests for all service classes"
Not ideal for:
- Small, focused changes to a single file
- Tasks with heavy interdependencies
- Quick fixes or simple refactoring
Example
/parallel-executor Add comprehensive error handling to all API endpoints
This will:
- Plan: Decompose into tasks per endpoint/module
- Execute Phase 1: Add error handling utilities (parallel if independent)
- Execute Phase 2: Update endpoints (parallel per endpoint)
- Execute Phase 3: Add tests (parallel)
- Verify: Run lint and tests
- Report: Summary of all changes
Related
- parallel-tasks-planner agent: Creates execution plans
- task-worker agent: Executes individual subtasks
- verifier agent: Verifies results
- parallel-execution-patterns.md: Reference documentation
