Ultrawork
Fan out independent work items to multiple agents in parallel when sequential execution would waste time.
Overview
Ultrawork is a journey-wide agent skill that runs independent work items through parallel agent delegation with dependency-aware planning—usable whenever a solo builder needs faster throughput before committing to a seri
Install
npx skills add https://github.com/yeachan-heo/oh-my-claudecode --skill ultraworkWhat is this skill?
- Parallel execution engine for independent tasks with intent grounding and evidence-backed summaries
- Dependency-aware task graphs for non-trivial work before agents run
- Explicit routing: use ralph when you need persistence and verification; autopilot for full autonomous pipelines
- Triggered by ultrawork, ulw, or explicit parallel execution requests
- Component protocol only—does not provide persistence, verification loops, or long-lived session state by itself
- Documented as level-4 skill in oh-my-claudecode stack
Adoption & trust: 535 installs on skills.sh; 36k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have several independent tasks and one agent chewing through them sequentially while wall-clock time piles up.
Who is it for?
Power users orchestrating oh-my-claudecode (or similar) with multiple parallelizable subtasks and no need for ralph-level persistence in that session.
Skip if: Single linear tasks, sessions that require verified completion loops, or fully autonomous pipelines—use ralph or autopilot per the skill's Do_Not_Use_When rules.
When should I use this skill?
Multiple independent tasks can run simultaneously, or the user says ulw, ultrawork, or asks for parallel agent execution without guaranteed verification loops.
What do I get? / Deliverables
Multiple executor agents run concurrent work with a grounded task graph and a short evidence-backed execution summary, without falsely implying verified completion.
- Dependency-aware task graph guidance
- Evidence-backed concise execution summary from parallel runs
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Implement three unrelated API endpoints by delegating each to a parallel executor after ultrawork builds the dependency graph.
Run concurrent spike agents on competing integration approaches before picking one stack.
Execute parallel test-fix passes on isolated modules that do not share failing fixtures.
Triage two unrelated production regressions with simultaneous investigator agents.
Generate multiple independent draft assets in parallel when outlines are already fixed.
How it compares
Parallel delegation component inside a larger stack—not a replacement for ralph persistence or autopilot end-to-end autonomy.
Common Questions / FAQ
Who is ultrawork for?
Solo builders using Claude Code multi-agent setups who routinely split work into independent chunks and want a documented parallel execution protocol instead of ad-hoc fan-out.
When should I use ultrawork?
During Build for parallel implementation or research, during Ship for concurrent fix/review passes, or during Operate when unrelated remediation items can run at once—whenever tasks are independent and you say ultrawork or ulw.
Is ultrawork safe to install?
It increases concurrent agent activity and filesystem or shell side effects from delegates; review the Security Audits panel on this page and scope permissions per subtask.
SKILL.md
READMESKILL.md - Ultrawork
<Purpose> Ultrawork is a parallel execution engine and execution protocol for independent work. It emphasizes intent grounding, parallel context gathering, dependency-aware task graphs for non-trivial work, and concise evidence-backed execution summaries. It is a component, not a standalone persistence mode -- it provides parallelism and routing guidance, but not persistence, verification loops, or long-lived state management. </Purpose> <Use_When> - Multiple independent tasks can run simultaneously - User says "ulw", "ultrawork", or wants parallel execution - You need to delegate work to multiple agents at once - Task benefits from concurrent execution but the user will manage completion themselves </Use_When> <Do_Not_Use_When> - Task requires guaranteed completion with verification -- use `ralph` instead (ralph includes ultrawork) - Task requires a full autonomous pipeline -- use `autopilot` instead (autopilot includes ralph which includes ultrawork) - There is only one sequential task with no parallelism opportunity -- delegate directly to an executor agent - User needs session persistence for resume -- use `ralph` which adds persistence on top of ultrawork </Do_Not_Use_When> <Why_This_Exists> Sequential task execution wastes time when tasks are independent. Ultrawork enables firing multiple agents simultaneously and routing each to the right model tier, reducing total execution time while controlling token costs. It is designed as a composable component that ralph and autopilot layer on top of. </Why_This_Exists> <Execution_Policy> - Fire all independent agent calls simultaneously -- never serialize independent work - Always pass the `model` parameter explicitly when delegating - Read `docs/shared/agent-tiers.md` before first delegation for agent selection guidance - Use `run_in_background: true` for operations over ~30 seconds (installs, builds, tests) - Run quick commands (git status, file reads, simple checks) in the foreground - Resolve intent and uncertainty before implementation; explore first, ask only when still blocked - For non-trivial tasks, produce a dependency-aware plan with parallel waves before execution - Keep delegated-task reports concise: short summary, files touched, verification status, blockers - Manual QA is required for implemented behavior, not just diagnostics </Execution_Policy> <Steps> 1. **Read agent reference**: Load `docs/shared/agent-tiers.md` for tier selection 2. **Ground intent first**: Confirm whether the request is implementation, investigation, evaluation, or research; do not code before that is clear 3. **Gather context in parallel**: - direct tools for quick reads/searches - exploration/docs agents for broad context 4. **Classify tasks by independence**: Identify which tasks can run in parallel vs which have dependencies 5. **Create a task graph for non-trivial work**: - Parallel Execution Waves - Dependency Matrix - acceptance criteria and verification steps per task 6. **Route to correct tiers**: - Simple lookups/definitions: LOW tier (Haiku) - Standard implementation: MEDIUM tier (Sonnet) - Complex analysis/refactoring: HIGH tier (Opus) 7. **Fire independent tasks simultaneously**: Launch all parallel-safe tasks at once 8. **Run dependent tasks sequentially**: Wait for prerequisites before launching dependent work 9. **Background long operations**: Builds, installs, and test suites use `run_in_background: true` 10. **Verify when all tasks complete** (lightweight): - Build/typecheck passes - Affected tests pass - Manual QA completed for implemented behavior - No new errors introduced </Steps> <Tool_Usage> - Use `Task(subagent_type="oh-my-claudecode:executor", model="haiku", ...)` for simple changes - Use `Task(subagent_type="oh-my-claudecode:executor", model="sonnet", ...)