Skip to main content

Oh My Claudecode Documentation

Transform Claude Code into an intelligent multi-agent orchestration system. You become the conductor, not the performer - delegating complex tasks to specialized AI agents.

New to OMC?

Just say what you want to build. Autopilot activates automatically and handles the rest. No commands needed.

28 Specialized Agents
From architects to designers, each agent excels at specific tasks
Parallel Execution
Run multiple agents simultaneously for maximum speed
Smart Verification
Architect agents verify all work before completion
Automatic Mode Selection
Detects your intent and activates the right mode

#What's New in v4.1.0

Agent Architecture Reform
Unified 28 agents replacing old tiered system. No more -low/-medium/-high suffixes -- each agent has one name and a default model.
Team Coordination System
Native Claude Code team support with TeamCreate, SendMessage, and TaskCreate for real-time multi-agent coordination.
System Prompt Modernization
Optimized for Claude Opus 4.6 with streamlined operating principles and clearer delegation rules.
Skill Consolidation
Cleaner command surface: ralplan is now /plan --consensus, review is /plan --review, and utility skills merged.
Reliability Improvements

v4.1.0 includes better state management, improved error handling, and more robust hook processing for all execution modes.

#Installation

Install Oh My Claudecode globally using npx:

BASH
npx oh-my-claudecode@latest init

This command will:

  • Install the OMC plugin to your Claude Code configuration
  • Set up necessary hooks and state directories
  • Configure default execution preferences
  • Optionally install the HUD statusline

Requirements

  • Claude Code CLI installed and configured
  • Node.js 18+ (for MCP server features)
  • Git (for version control features)

Verify Installation

Run the doctor command to verify everything is set up correctly:

BASH
/oh-my-claudecode:doctor

#Quick Start

Get Started in 3 Steps
  1. Install OMC
    Run npx oh-my-claudecode@latest init in your terminal
  2. Start Claude Code
    Open any project with Claude Code as usual
  3. Just Ask
    Say "Build me a REST API for managing tasks" - autopilot handles the rest

Example Prompts

Here are some example prompts that automatically trigger the right mode:

Prompt What Happens
"Build me a todo app with React" Autopilot activates for full autonomous execution
"Refactor this module until it's clean" Ralph mode - persistent until architect verification passes
"ulw fix all TypeScript errors" Ultrawork - maximum parallelism with smart model routing
"Plan the new authentication system" Planning interview begins to gather requirements

#Conductor Philosophy

The core principle of OMC is simple: you are the conductor, not the performer.

Key Rule

ALWAYS delegate substantive work to specialized agents. NEVER do code changes directly.

What You Do vs. What Agents Do

Action YOU Do Directly DELEGATE to Agent
Read files for context Yes -
Quick status checks Yes -
Communicate with user Yes -
Single-line code change NEVER executor
Multi-file changes NEVER executor / deep-executor
Complex debugging NEVER debugger
UI/frontend work NEVER designer
Documentation NEVER writer

#Execution Modes

OMC provides several execution modes optimized for different scenarios. Each mode has unique characteristics for handling complexity, parallelism, and verification.

#Autopilot

Autopilot

autopilot build me I want a

The flagship experience and recommended starting point. Autopilot provides fully autonomous execution from high-level idea to working, tested code with no manual intervention required.

  • Automatic planning and requirements gathering
  • Parallel execution with multiple specialized agents
  • Continuous verification and testing
  • Self-correction loop until completion
  • Combines best of ralph, ultrawork, and plan modes

Example Usage

TEXT
autopilot: Build a REST API for user management with JWT authentication

# Or simply:
Build me a dashboard that shows real-time analytics

#Ralph

Ralph

ralph don't stop

Persistence mode - the boulder never stops rolling. Ralph continues working until architect verification passes, automatically including ultrawork's parallelism.

  • Never stops until architect verification passes
  • Includes ultrawork parallelism automatically
  • Ideal for complex refactoring and large changes
  • Self-healing: fixes issues as they arise
  • Requires explicit /cancel to stop
Ralph includes Ultrawork

When you activate ralph mode, it automatically includes ultrawork's parallel execution. No need to combine keywords.

#Ultrawork

Ultrawork

ulw ultrawork

Maximum parallelism mode with aggressive agent delegation and smart model routing. Uses the right model tier (haiku/sonnet/opus) for each subtask.

  • Aggressive parallel agent delegation
  • Smart model routing based on task complexity
  • Background execution for long-running tasks
  • Verification checklist before completion
  • Up to 5 concurrent background tasks

Model Routing

Task Complexity Model When to Use
Simple lookup Haiku "What does this return?", "Find definition of X"
Standard work Sonnet "Add error handling", "Implement feature"
Complex reasoning Opus "Debug race condition", "Refactor architecture"

#Ecomode

Ecomode

eco ecomode budget

Token-efficient execution mode that routes to Haiku/Sonnet automatically. A modifier for other modes - saves tokens without sacrificing quality.

  • Routes to cheaper models automatically
  • Budget-conscious execution
  • Can combine with other modes
  • Wins over ultrawork if both specified
  • Ideal for routine tasks and batch operations

#Ultrapilot

Ultrapilot

ultrapilot parallel build

Parallel autopilot - 3-5x faster than standard autopilot. Uses file ownership partitioning to allow multiple agents to work simultaneously without conflicts.

  • File ownership partitioning prevents conflicts
  • 3-5x faster than standard autopilot
  • Up to 5 parallel executor agents
  • Automatic work distribution
  • Coordinated verification at completion

#Team

Team

team coordinated team

N coordinated agents on a shared task list using Claude Code native teams. Team lead creates the team, assigns tasks, and monitors progress with real-time messaging.

  • TeamCreate/SendMessage/TaskCreate tools for coordination
  • Real-time inter-agent messaging
  • Built-in task dependencies (blocks/blockedBy)
  • Graceful shutdown protocol
  • Team lead orchestrates specialized teammates

Architecture

The team lifecycle follows a structured pattern:

  1. TeamCreate - Team lead creates a named team
  2. TaskCreate - Create tasks with descriptions and dependencies
  3. Spawn teammates - Each teammate claims and works on tasks
  4. Monitor - Team lead coordinates via SendMessage
  5. Shutdown - Graceful shutdown_request to all teammates

Example Usage

TEXT
/oh-my-claudecode:team 5:executor "fix all TypeScript errors"

# Or with mixed agent types:
/oh-my-claudecode:team 3:executor,2:test-engineer "implement and test the auth module"

#Swarm

Swarm

swarm coordinated agents

N agents working on a shared task pool with SQLite-based atomic task claiming. Perfect for large task lists that need coordinated execution.

  • SQLite-based atomic task claiming
  • N agents on shared task pool
  • No duplicate work - atomic claims
  • Great for large task lists
  • Self-organizing coordination

#Pipeline

Pipeline

pipeline chain agents

Sequential agent chaining with data passing between stages. Create complex workflows with preset pipelines or custom stage definitions.

  • Stage-based sequential execution
  • Data passing between stages
  • Preset pipelines available
  • Custom stage definitions
  • Error handling at each stage

#UltraQA

UltraQA

ultraqa qa cycle

Quality assurance cycling mode that repeatedly tests, verifies, and fixes until the specified goal is met. Perfect for ensuring code quality.

  • Test, verify, fix, repeat cycle
  • Continues until goal met
  • Automatic issue detection
  • Self-correcting fixes
  • Comprehensive verification

#Agent Overview

OMC includes 28 specialized agents organized into functional lanes. Each agent excels at specific tasks and uses the appropriate model (haiku, sonnet, or opus).

#Agent Lanes

Agents are organized into functional lanes. Each agent has a default model (haiku, sonnet, or opus) optimized for its role:

Build/Analysis Lane

Agent Model Purpose
explore Haiku Internal codebase discovery, symbol/file mapping
analyst Opus Requirements clarity, acceptance criteria, hidden constraints
planner Opus Task sequencing, execution plans, risk flags
architect Opus System design, boundaries, interfaces, long-horizon tradeoffs
debugger Sonnet Root-cause analysis, regression isolation, failure diagnosis
executor Sonnet Code implementation, refactoring, feature work
deep-executor Opus Complex autonomous goal-oriented tasks
verifier Sonnet Completion evidence, claim validation, test adequacy

Review Lane

Agent Model Purpose
style-reviewer Haiku Formatting, naming, idioms, lint conventions
quality-reviewer Sonnet Logic defects, maintainability, anti-patterns
api-reviewer Sonnet API contracts, versioning, backward compatibility
security-reviewer Sonnet Vulnerabilities, trust boundaries, authn/authz
performance-reviewer Sonnet Hotspots, complexity, memory/latency optimization
code-reviewer Opus Comprehensive review across concerns

Domain Specialists

Agent Model Purpose
dependency-expert Sonnet External SDK/API/package evaluation
test-engineer Sonnet Test strategy, coverage, flaky-test hardening
quality-strategist Sonnet Quality strategy, release readiness, risk assessment
build-fixer Sonnet Build/toolchain/type failures
designer Sonnet UX/UI architecture, interaction design
writer Haiku Docs, migration notes, user guidance
qa-tester Sonnet Interactive CLI/service runtime validation
scientist Sonnet Data/statistical analysis
git-master Sonnet Commit strategy, history hygiene

Product Lane

Agent Model Purpose
product-manager Sonnet Problem framing, personas/JTBD, PRDs
ux-researcher Sonnet Heuristic audits, usability, accessibility
information-architect Sonnet Taxonomy, navigation, findability
product-analyst Sonnet Product metrics, funnel analysis, experiments

Coordination

Agent Model Purpose
critic Opus Plan/design critical challenge
vision Sonnet Image/screenshot/diagram analysis

#Agent Selection Guide

Choose the right agent based on your task. Each agent has a fixed default model, but you can override it with the model parameter when delegating.

Task Recommended Agent Lane
Quick file/symbol lookup explore Build/Analysis
Implement a feature executor Build/Analysis
Complex autonomous refactor deep-executor Build/Analysis
Debug a failing test debugger Build/Analysis
System design decisions architect Build/Analysis
Comprehensive code review code-reviewer Review
Security audit security-reviewer Review
Write tests test-engineer Domain Specialists
UI/UX work designer Domain Specialists
Documentation writer Domain Specialists
External SDK evaluation dependency-expert Domain Specialists
Product requirements product-manager Product
Data analysis scientist Domain Specialists

#Agent Domains

Build/Analysis Lane

Core agents for exploring, planning, building, and verifying code.

  • explore - Internal codebase discovery, symbol/file mapping
  • analyst - Requirements clarity, acceptance criteria
  • planner - Task sequencing, execution plans, risk flags
  • architect - System design, boundaries, interfaces
  • debugger - Root-cause analysis, regression isolation
  • executor - Code implementation, refactoring, feature work
  • deep-executor - Complex autonomous goal-oriented tasks
  • verifier - Completion evidence, claim validation
Review Lane

Specialized reviewers for different aspects of code quality.

  • style-reviewer - Formatting, naming, idioms, lint conventions
  • quality-reviewer - Logic defects, maintainability, anti-patterns
  • api-reviewer - API contracts, versioning, backward compatibility
  • security-reviewer - Vulnerabilities, trust boundaries, authn/authz
  • performance-reviewer - Hotspots, complexity, memory/latency
  • code-reviewer - Comprehensive review across all concerns
Domain Specialists

Focused experts for specific technical domains.

  • dependency-expert - External SDK/API/package evaluation
  • test-engineer - Test strategy, coverage, flaky-test hardening
  • quality-strategist - Quality strategy, release readiness
  • build-fixer - Build/toolchain/type failures
  • designer - UX/UI architecture, interaction design
  • writer - Docs, migration notes, user guidance
  • qa-tester - Interactive CLI/service runtime validation
  • scientist - Data/statistical analysis
  • git-master - Commit strategy, history hygiene
Product Lane

Product-focused agents for discovery, research, and analysis.

  • product-manager - Problem framing, personas/JTBD, PRDs
  • ux-researcher - Heuristic audits, usability, accessibility
  • information-architect - Taxonomy, navigation, findability
  • product-analyst - Product metrics, funnel analysis, experiments
Coordination

Cross-cutting agents for critique and visual analysis.

  • critic - Plan/design critical challenge
  • vision - Image/screenshot/diagram analysis

#Magic Keywords

Magic keywords are shortcuts that trigger specific modes. They can be used anywhere in your prompt.

Keyword Effect Example
autopilot Full autonomous execution "autopilot: build a todo app"
ralph Persistence mode "ralph: refactor auth"
ulw Maximum parallelism "ulw fix all errors"
eco Token-efficient mode "eco fix all errors"
plan Planning interview "plan the new API"
ralplan Consensus planning (alias for /plan --consensus) "ralplan this feature"
team Coordinated team agents "team: fix all errors with 5 agents"
ultrapilot Parallel autopilot "ultrapilot: build dashboard"
swarm Coordinated agents "swarm: process all files"
pipeline Sequential chaining "pipeline: analyze, fix, test"

#Skills Reference

Skills are invoked with the /oh-my-claudecode: prefix.

Execution Skills

  • /oh-my-claudecode:autopilot - Full autonomous execution
  • /oh-my-claudecode:ralph - Persistence mode
  • /oh-my-claudecode:ultrawork - Maximum parallelism
  • /oh-my-claudecode:ecomode - Token-efficient mode
  • /oh-my-claudecode:ultrapilot - Parallel autopilot
  • /oh-my-claudecode:team - Coordinated team of N agents
  • /oh-my-claudecode:swarm - Coordinated agents (SQLite-based)
  • /oh-my-claudecode:pipeline - Sequential chaining
  • /oh-my-claudecode:ultraqa - QA cycling

Planning Skills

  • /oh-my-claudecode:plan - Planning interview (supports --consensus and --review flags)
  • /oh-my-claudecode:ralplan - Alias for /plan --consensus
  • /oh-my-claudecode:review - Alias for /plan --review
  • /oh-my-claudecode:analyze - Deep analysis

Utility Skills

  • /oh-my-claudecode:cancel - Stop current operation
  • /oh-my-claudecode:note - Add to notepad
  • /oh-my-claudecode:help - Show all skills (includes learn-about-omc)
  • /oh-my-claudecode:doctor - Diagnose issues
  • /oh-my-claudecode:hud - HUD statusline
  • /oh-my-claudecode:skill - Manage skills (includes local-skills-setup)

#Cancel Operations

Use the unified /oh-my-claudecode:cancel skill to stop any execution mode.

Why /cancel matters

Execution modes use hooks that block premature stopping. These hooks check for state files. Running /cancel cleanly removes these files, allowing the session to end gracefully.

The cancel skill automatically detects and cancels:

  • autopilot, ultrapilot
  • ralph, ultrawork, ultraqa
  • team, swarm, pipeline
  • Planning interviews

If /cancel doesn't work, use:

TEXT
/oh-my-claudecode:cancel --force

#OMC Setup

Run the setup wizard to configure OMC:

TEXT
/oh-my-claudecode:omc-setup

The wizard configures:

  • Default execution mode preference
  • HUD statusline installation
  • MCP server configuration
  • Task tool selection (built-in, beads, or beads-rust)

#Default Execution Mode

Configure which mode activates when you say "fast" or "parallel" without specifying a mode.

The configuration file is at ~/.claude/.omc-config.json:

JSON
{
  "defaultExecutionMode": "ultrawork"  // or "ecomode"
}

Priority Resolution

Priority Condition Result
1 (highest) Both explicit keywords present ecomode wins
2 Single explicit keyword That mode wins
3 Generic "fast"/"parallel" only Read from config
4 (lowest) No config file Default to ultrawork

#HUD Configuration

The HUD (Heads-Up Display) shows real-time status in your terminal.

TEXT
/oh-my-claudecode:hud setup

HUD shows:

  • Current active mode
  • Agent status and count
  • Task progress
  • Token usage

#MCP Server Setup

OMC includes MCP (Model Context Protocol) servers for advanced features.

TEXT
/oh-my-claudecode:mcp-setup

Available MCP tools:

  • LSP tools (hover, definition, references, diagnostics)
  • AST grep (search, replace) for structural patterns
  • Python REPL for data analysis
  • State management tools
  • Notepad and project memory tools

#Hooks System

Hooks are OMC extensions that inject context into conversations via <system-reminder> tags.

Hook Events

Event When It Fires What You See
SessionStart Conversation begins Priority context, mode restoration
UserPromptSubmit After user message Magic keyword detection, skill prompts
PreToolUse:{Tool} Before tool executes Guidance, warnings
PostToolUse:{Tool} After tool completes Delegation audit, verification prompts
Stop Before session ends Continuation prompts (in execution modes)
SubagentStart Subagent spawned Agent {type} started ({id})
SubagentStop Subagent finishes Agent {type} completed/failed ({id})

#Notepad System

The notepad at .omc/notepad.md provides compaction-resilient memory with three tiers.

Section Behavior Use For
Priority Context ALWAYS loaded (max 500 chars) Critical facts: "Project uses pnpm"
Working Memory Auto-pruned after 7 days Debugging breadcrumbs, temporary findings
MANUAL Never auto-pruned Team contacts, deployment info

Usage

TEXT
/oh-my-claudecode:note <content>              # Working Memory
/oh-my-claudecode:note --priority <content>   # Priority Context
/oh-my-claudecode:note --manual <content>     # MANUAL (never pruned)
/oh-my-claudecode:note --show                 # Display notepad
/oh-my-claudecode:note --prune                # Remove old entries

#State Management

All mutable OMC state belongs under .omc/state/ in the worktree.

TEXT
.omc/
  state/
    autopilot-state.json
    ralph-state.json
    ultrawork-state.json
    swarm.db           # SQLite for swarm
  notepad.md
  logs/
    delegation-audit.jsonl

State files control hook behavior. The /cancel skill removes these files to allow graceful termination.

#MCP Tools Overview

OMC v4.1.0 includes powerful MCP (Model Context Protocol) tools that extend Claude's capabilities with external AI consultation, language server integration, and more.

External AI
Consult Gemini and Codex for specialized tasks
LSP Integration
Type info, definitions, references, diagnostics
AST Grep
Structural code search and replace
Python REPL
Persistent environment for data analysis

#External AI Consultation (Gemini & Codex)

OMC can optionally consult external AI models for specialized tasks:

Tool Provider Best For
ask_codex OpenAI (gpt-5.3-codex) Code analysis, planning validation, architecture review
ask_gemini Google (gemini-3-pro-preview) Design consistency, documentation, visual analysis (1M context)

Agent Roles

Codex roles: architect, planner, critic, analyst, code-reviewer, security-reviewer, tdd-guide

Gemini roles: designer, writer, vision

MCP-Direct Replacement Pattern

Instead of spawning Claude agents for analysis tasks, call MCPs directly:

Task Domain MCP Tool Replaces Agent
Architecture analysis ask_codex (architect role) architect agents
Planning ask_codex (planner role) planner agent
Code review ask_codex (code-reviewer role) code-reviewer agents
UI/UX design ask_gemini (designer role) designer agents
Documentation ask_gemini (writer role) writer agent
Graceful Fallback

If external MCPs are unavailable, OMC automatically falls back to Claude agents. No configuration needed.

#LSP Tools

Language Server Protocol integration provides IDE-like features:

Tool Description
lsp_hover Get type info and documentation at a position
lsp_goto_definition Jump to where a symbol is defined
lsp_find_references Find all usages of a symbol
lsp_document_symbols Get file outline (functions, classes, etc.)
lsp_workspace_symbols Search symbols across the workspace
lsp_diagnostics Get errors and warnings for a file
lsp_diagnostics_directory Project-wide type checking (tsc --noEmit)
lsp_rename Rename a symbol across all files
lsp_code_actions Get available refactorings and quick fixes

#AST Grep

Structural code search and replace using AST patterns - more precise than text search.

Pattern Syntax

  • $NAME - matches any single AST node
  • $$$ARGS - matches multiple nodes (for arguments, list items)

Example Patterns

TEXT
# Find all function declarations
function $NAME($$$ARGS)

# Find all console.log calls
console.log($MSG)

# Find null equality checks
$X === null

# Find imports from a specific module
import $$$IMPORTS from '$MODULE'
Tool Description
ast_grep_search Search for AST patterns in code
ast_grep_replace Replace patterns (use dryRun=false to apply)

#Python REPL

Persistent Python environment for data analysis and scientific computing.

Features

  • Variables persist between calls within a session
  • Pre-installed: pandas, numpy, matplotlib
  • Actions: execute, interrupt, reset, get_state
PYTHON
# First call
import pandas as pd
df = pd.read_csv('data.csv')

# Second call (df is still available)
df.describe()

#Background Job Management

External AI consultations can run in the background for better parallelism.

Background Orchestration Pattern

  1. SPAWN - Launch with background: true
  2. CHECK - Non-blocking status with check_job_status
  3. AWAIT - Block when needed with wait_for_job
Tool Description
check_job_status Non-blocking status check
wait_for_job Block until completion (up to 1 hour)
list_jobs List background jobs by status
kill_job Terminate a running job
Dependency Rule

If a downstream decision depends on MCP output, you MUST await before finalizing that decision.

#Verification Tiers

Verification scales with task complexity:

Tier When Agent
LIGHT <5 files, <100 lines, full tests verifier (haiku)
STANDARD Default verifier (sonnet)
THOROUGH >20 files, security/architectural verifier (opus)
Iron Law

NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE. Always: IDENTIFY what proves the claim, RUN the verification, READ the output, then CLAIM with evidence.

#Context Persistence

Use <remember> tags to persist information across sessions:

XML
<remember>Important info here</remember>           <!-- 7 days -->
<remember priority>Critical info here</remember>  <!-- Permanent -->

What to capture:

  • Architecture decisions
  • Error resolutions
  • User preferences

What NOT to capture:

  • Progress (use todos instead)
  • Info already in AGENTS.md