Skip to main content

​
What is Ultrawork Mode?

Ultrawork mode (triggered by ultrawork or ulw keywords) activates maximum-intensity execution:
  • Parallel agent spawning: Fire 5+ background agents simultaneously
  • Aggressive exploration: Deep codebase analysis before action
  • Relentless execution: No premature stopping, tasks run to completion
  • Smart delegation: Automatic routing to specialist agents
Think of ultrawork as having 5 senior engineers working simultaneously instead of 1.

​
When to Use Ultrawork

​
Perfect for:

ulw implement OAuth authentication with social providers
ulw refactor the payment module to use the new API
ulw fix all TypeScript errors and warnings
ScenarioWhy Ultrawork Helps
Complex featuresParallel research + implementation + testing
Large refactorsMultiple agents work on different files
”Figure it out” tasksAgent explores patterns before deciding approach
Cross-cutting changesSimultaneous updates across many files

​
Not needed for:

  • Simple typo fixes
  • Single-file changes
  • Quick documentation updates
  • Questions about the codebase

​
How to Activate

1

Include the keyword

Add ultrawork or ulw anywhere in your prompt:
ulw build a REST API with rate limiting
or
Implement user authentication. Use ultrawork mode.
2

Watch parallel execution

The agent will:
  1. Spawn multiple explore/librarian agents in background
  2. Research patterns while starting implementation
  3. Use findings from research to guide decisions
3

Track progress

See background agents complete:
[explore] Finding authentication patterns...
[librarian] Searching OAuth documentation...
[sisyphus] Starting implementation...

​
Model-Specific Behavior

Ultrawork adapts its prompt based on the active model:
Optimized for Claude Opus/Sonnet:
  • Aggressive parallel agent spawning (5-10 agents)
  • Heavy use of task() delegation
  • Background mode by default for all research
  • Detailed structured output
// Claude ultrawork characteristics
- Leverages Claude's instruction-following
- Uses todo tracking extensively
- Spawns agents preemptively

​
Ultrawork vs Regular Mode

AspectRegular ModeUltrawork Mode
Agent spawningOn-demand, conservativeAggressive, preemptive
ParallelismSequential where possibleParallel by default
ResearchAs neededDeep upfront exploration
DelegationCareful considerationAutomatic to specialists
StoppingMay pause for clarificationRelentless until complete
CostLower API usageHigher (more parallel agents)

​
Configuration

You can configure per-agent ultrawork behavior: 
{
  "agents": {
    "sisyphus": {
      "model": "anthropic/claude-sonnet-4-6",
      "ultrawork": {
        "model": "anthropic/claude-opus-4-6",
        "variant": "max"
      }
    },
    "prometheus": {
      "prompt_append": "Leverage deep & quick agents heavily, always in parallel."
    }
  }
}

​
Ultrawork Override Fields

FieldDescription
modelSwitch to more powerful model in ultrawork
variantUse higher reasoning effort (max, xhigh)
Ultrawork mode increases API costs significantly due to parallel agent execution. Use for complex tasks where the speed and thoroughness justify the cost.

​
Behind the Scenes

​
Keyword Detection

The keyword-detector hook scans your first message: 
// Pattern matching
Pattern: /\b(ultrawork|ulw)\b/i

// Triggers injection of mode-specific prompt
getUltraworkMessage(agentName, modelID)

​
Dynamic Prompt Injection

Ultrawork adds instructions to the system prompt: 
// Emphasis on structured delegation
- Fire background agents IMMEDIATELY
- Use task() for all research
- Never wait for sequential completion
- TodoWrite for tracking

​
Real-World Examples

​
Example 1: Complex Feature

Prompt: 
ulw implement user authentication with OAuth, JWT, and session management
What happens:
1

Immediate spawning

[explore] Finding auth patterns in codebase...
[librarian] Searching OAuth 2.0 specs...
[librarian] Finding JWT best practices...
[explore] Analyzing session storage patterns...
2

Parallel work

While agents research:
  • Sisyphus starts scaffold (models, routes, middleware)
  • Incorporates findings as they arrive
  • Adjusts approach based on discovered patterns
3

Integration

  • Combines all research findings
  • Implements comprehensive solution
  • Adds tests based on discovered patterns

​
Example 2: Large Refactor

Prompt: 
ulw refactor the API layer to use TypeScript strict mode
What happens:
  1. Discovery (parallel):
    • Map all API files
    • Find type usage patterns
    • Identify migration hotspots
  2. Execution (parallel):
    • Update types in batches
    • Fix errors by file group
    • Verify with LSP diagnostics
  3. Verification:
    • Run tests after each batch
    • Ensure no runtime breaks

​
Tips for Best Results

Be specific about the end goal, but let ultrawork figure out the approach:✅ Good: ulw implement rate limiting for all API routes
❌ Too vague: ulw make the API better
❌ Too detailed: ulw create a RateLimiter class in src/middleware/rate-limiter.ts with...

​
Optimal Prompts

# Clear goal + trust the agent
ulw add comprehensive error handling to the user service

# Scope + success criteria
ulw refactor auth to use the new provider system. Must be backwards compatible.

# Complex multi-part task
ulw implement search with filters, pagination, and sorting

​
Combining with Other Features

​
Ultrawork + Prometheus Planning

# Step 1: Plan with Prometheus
@plan "Build admin dashboard with charts and user management"

# Step 2: Execute with ultrawork
/start-work
Atlas reads the plan and uses ultrawork-style delegation automatically.

​
Ultrawork + Ralph Loop

/ralph-loop "ulw implement and test the payment integration"
Combines ultrawork intensity with Ralph’s persistence.

​
Ultrawork + Skills

ulw implement the checkout flow. Load skills: ["frontend-ui-ux", "playwright"]
Maximum intensity + domain expertise.

​
Monitoring and Control

​
Track Active Agents

With tmux enabled: 
{
  "tmux": {
    "enabled": true,
    "layout": "main-vertical"
  }
}
See all background agents in separate panes.

​
Limit Concurrency

{
  "background_task": {
    "providerConcurrency": {
      "anthropic": 3,
      "openai": 3
    }
  }
}

​
Common Questions

Yes. Parallel agents mean more API calls. A single ultrawork task might use 3-10x the tokens of regular mode. Use for complex tasks where speed and thoroughness justify the cost.
Ultrawork works best with Sisyphus (default) and Hephaestus. Prometheus has its own planning-focused variant. Specialist agents (Oracle, Librarian, Explore) don’t need ultrawork since they’re already focused.
/stop-continuation
This stops all continuation mechanisms including ultrawork delegation.
No, ultrawork is intentionally opt-in due to cost. Add the keyword when needed.

Background Agents

Learn about parallel agent execution

Prometheus Planning

Strategic planning before execution

Agent Model Matching

Which models work best for each agent

Commands

Slash commands for workflows

Build docs developers (and LLMs) love

Get started for freeTalk to us