Building Smarter, More Reliable, and Faster Claude Code Workflows with 19 OMC Agents

1. Claude Code Mechanism

Claude Code runs a tool‑enhanced agent architecture. Each iteration follows a reasoning loop: think → call tool → process result → think again . The system is organized into four layers: UI (CLI/IDE), Claude Code Core (session, permission, context management), Agent Loop (the multi‑turn reasoning cycle), and the LLM + tool subsystem.

Tools are split into local utilities (Read/Write/Bash/Grep) and MCP servers (Context7, Lark Doc). Simple tasks use a single agent; complex tasks can spawn child agents via Anthropic’s experimental Agent Teams (star topology) where a leader coordinates multiple expert agents. A key limitation is that delegating to a sub‑agent is manual – the user must specify the sub‑agent, its model, and its context.

2. OMC Architecture Design

OMC adds a four‑layer pipeline on top of Claude Code: Hooks → Skills → Agents → State . This pipeline automates the delegation, routing, and persistence of multi‑agent workflows.

Pipeline Overview

user input → Hooks (event detection) → Skills (behavior injection) → Agents (task execution) → State (progress tracking)

Hooks Layer

Hooks intercept Claude Code lifecycle events without consuming token context. OMC registers 20 hook scripts that cover the 11‑13 native events. Key hooks include: keyword‑detector (triggered on UserPromptSubmit) – detects magic keywords and activates the corresponding Skill. persistent‑mode (triggered on Stop) – blocks premature termination when ultrawork or ralph is active. pre‑compact (triggered on PreCompact) – saves critical information to a notepad before context compression. subagent‑tracker (triggered on SubagentStart / SubagentStop) – tracks the status of child agents.

Skills Layer

OMC defines 31 Skills (28 user‑callable + 3 internal). A Skill is composed as:

[execute] + [0‑N enhancements] + [optional guard]

Execution Skills ( default, orchestrate, planner) perform the main work. Enhancement Skills ( ultrawork, git‑master, frontend‑ui‑ux) add parallelism, auto‑commit, or UI improvements. Guard Skills ( ralph) enforce completion before the agent can stop.

Examples: default + git‑master – normal development with automatic commits. autopilot + ralph – end‑to‑end feature generation with strict verification.

Agents Layer

Nineteen specialized agents are organized into lanes. Each lane has a default Claude model (Haiku, Sonnet, or Opus) and a clear responsibility:

Build/Analysis lane : explore (codebase discovery, model = haiku).

Analyst lane : analyst (requirements analysis, model = opus).

Planner lane : planner (task ordering, model = opus).

Executor lane : executor (code implementation, model = sonnet).

Verifier lane : verifier (test validation, model = sonnet).

Debugger lane : debugger (root‑cause analysis, model = sonnet).

Security‑Reviewer lane : security‑reviewer (vulnerability audit, model = sonnet).

Code‑Reviewer lane : code‑reviewer (API contract review, model = opus).

Domain lanes : test‑engineer, designer, writer, git‑master (task‑specific expertise).

Coordination lane : critic (plan gap analysis, model = opus).

State Layer

State is persisted under the .omc/ directory, allowing knowledge to survive context compression and enabling cross‑session memory.

.omc/
├── state/
│   ├── autopilot-state.json
│   ├── ralph-state.json
│   └── team/
├── notepad.md
├── project-memory.json
├── plans/
└── notepads/
    └── {plan‑name}/
        ├── learnings.md
        ├── decisions.md
        └── issues.md

Model Routing

OMC routes tasks to three model tiers to balance cost and quality:

LOW – claude‑haiku‑4‑5; used for fast look‑ups and simple tasks such as explore or writer. Low token cost.

MEDIUM – claude‑sonnet‑4‑6; used for code implementation, debugging, and testing (e.g., executor, debugger).

HIGH – claude‑opus‑4‑7; reserved for architecture design and strategic analysis (e.g., architect, planner, critic).

The README and community reports claim this tiered routing saves roughly 30‑50 % of token usage.

3. Installation & Configuration

OMC can be installed as a Claude Code plugin or as a global CLI.

Marketplace plugin (recommended):

/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode
/plugin install oh-my-claudecode

npm CLI: npm i -g oh-my-claude-sisyphus@latest Project‑level configuration is stored in CLAUDE.md (generated by /omc-setup) and version‑controlled. Global defaults live in ~/.claude/CLAUDE.md. OMC reads JSONC files ( .omc/omc.jsonc and ~/.config/claude-omc/config.jsonc) with precedence: defaults → user → project → environment variables (e.g., OMC_MODEL_LOW).

Diagnostic commands verify the environment: /oh-my-claudecode:omc-doctor – runs a health check. omc stats – token‑usage analysis. omc agents – shows agent availability. omc tui – interactive dashboard.

4. High‑Frequency Engineering Scenarios

Scenario 1 – Legacy Refactoring (Autopilot / Ralph)

Command:

autopilot: refactor the auth module, improve error handling and add input validation

The keyword‑detector hook matches the autopilot prefix and launches a five‑stage pipeline: explore (Haiku) – scans the auth module and builds a dependency graph. analyst (Opus) – analyses existing problems and constraints. planner (Opus) – creates a refactoring plan; critic reviews the plan. executor (Sonnet) – applies the changes. verifier (Sonnet) – runs tests to confirm the refactor succeeded.

In ralph mode the same pipeline repeats until all verification steps pass. The persistent‑mode hook blocks the Stop event, and progress is recorded in ralph-state.json so the loop can resume after context compression.

Scenario 2 – Bulk TypeScript Fixes (Ultrawork)

Command:

ultrawork fix all TypeScript errors in the project

The ultrawork hook launches multiple executor agents in parallel, each handling a subset of files. The subagent‑tracker hook monitors each child agent, aggregates results, and reports which files were fixed and which still contain errors. This parallelism dramatically reduces the number of sequential loops compared with a single‑agent approach.

Scenario 3 – Multi‑Module Bug (Team Mode)

Command:

/team 3:executor "fix the payment timeout bug affecting checkout flow"

Three executor agents share a common task list; each has its own context window. A leader agent coordinates and selectively shares information. The workflow follows

team‑plan → team‑prd → team‑exec → team‑verify → team‑fix

. Team mode requires enabling the experimental flag CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in ~/.claude/settings.json. OMC also supports tmux‑based CLI workers (e.g.,

omc team 1:claude "investigate the payment timeout root cause"

).

5. Efficiency Comparison & Recommendations

Mode selection guide

Team – complex multi‑module bugs; five‑stage pipeline with shared task list; triggered by /team N:agent.

Autopilot – end‑to‑end feature development; fully autonomous with minimal config; triggered by autopilot: prefix.

Ultrawork – batch repairs and parallel refactoring; maximum parallelism; triggered by the ultrawork keyword.

Ralph – tasks requiring strict verification; loops until all checks pass; triggered by ralph: prefix.

Recommendation: start with autopilot for everyday development, switch to ultrawork for parallel workloads, and use team or ralph when strict completion guarantees are needed. Model tiers can be overridden with environment variables such as OMC_MODEL_HIGH=sonnet to trade quality for cost.

6. Summary

OMC extends Claude Code’s single‑agent capabilities into a coordinated multi‑agent system through a clear Hooks → Skills → Agents → State pipeline. Nineteen agents, thirty‑one skills, and tiered model routing enable automated, reliable, and cost‑effective workflows for refactoring, bulk fixes, and multi‑module bug resolution. The system shines for complex automation, while simple single‑file edits may not require the full stack. Customization is limited by hard‑coded magic keywords, but environment‑driven model overrides provide practical cost control.