oh-my-cluadecode-cli-orchestration-suite

**Comprehensive Description of *Oh-My-ClaudeCode: Revolutionizing AI-Powered Development with Multi-Agent Orchestration**

Introduction

Oh-My-ClaudeCode (OMC) is a groundbreaking framework designed to streamline the development workflow by leveraging Claude Code’s advanced multi-agent capabilities. Unlike traditional AI-driven development tools, OMC introduces a zero-configuration, team-first orchestration approach, enabling developers to build complex applications—such as full-stack APIs, automation scripts, and design systems—with minimal effort. By integrating seamlessly with tmux, rate-limiting resilience, skill-based learning, and cross-agent collaboration (including Codex and Gemini), OMC transforms how projects are conceptualized, executed, and refined.

The framework is particularly suited for developers who crave efficiency without sacrificing control. Whether you’re managing a solo project or collaborating in a team, OMC’s automated parallelization, real-time feedback loops, and cost-optimized task delegation make it an indispensable companion for modern software engineering.

Core Vision: Zero Configuration, Maximum Power

OMC’s philosophy centers on minimizing friction while maximizing productivity. Unlike other AI-driven orchestrators (e.g., Superpowers or Ouroboros), OMC doesn’t require rigid workflows or memorized commands—natural language commands are its primary interface. Below are the key pillars of its design:

Seamless Installation & Setup

Users start with a one-line command: bash /plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode /plugin install oh-my-claudecode
The omc-setup process handles configuration automatically, ensuring the environment is ready for immediate use. This aligns with OMC’s mantra: “Don’t learn Claude Code. Just use OMC.”

Team-First Orchestration

OMC prioritizes collaborative task breakdown into structured phases (e.g., plan, execute, verify). The canonical workflow is: team-plan → team-execute → team-verify → team-fix
In v4.1.7+, the legacy swarm keyword has been deprecated, replaced by direct team execution, ensuring a cleaner, agent-centric model.

Multi-Agent Parallelism OMC supports 32 specialized Claude agents (e.g., architects, designers, data scientists) to handle different facets of a project. For example:

A TypeScript error fixer might trigger multiple agents for syntax validation, unit tests, and documentation updates.
Agents are auto-routed based on task complexity—simpler tasks use the Haiku model (Claude’s Haiku tier), while intricate reasoning tasks leverage the Opus model.

Persistence & Iterative Refinement Unlike ephemeral tools, OMC features:

Ralph mode: A persistent workflow where tasks loop until complete (verify/fix cycles).
Ultrawork mode: Maximum parallelization for high-speed debugging.
Auto-learned skills: The framework extracts reusable patterns (e.g., handling aiohttp proxy crashes) and saves them in .omc/skills/ directories, ready to inject automatically.

How OMC Works: A Technical Deep Dive

1. Orchestration Modes: Tailored for Every Workflow

OMC offers six primary execution modes, each optimized for specific scenarios:

| Mode | Description | Ideal Use Case | |---------------------|-------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------| | Team | Canonical staged pipeline (plan → execute → verify). | Team-based development with strict task chaining. | | omc team | tmux-based CLI workers for Codex/Gemini/Claude (real panes). | Code reviews, UI design, or parallel debugging in a single session. | | ccg | Cross-model advisor mode (/ask codex + /ask gemini → Claude synthesizes). | Mixed frontend/backend tasks requiring both architectures and UI expertise. | | Autopilot | Autonomous execution with minimal oversight. | Full-stack projects like REST APIs (e.g., autopilot: build a task manager). | | Ultrawork | Maximum parallelism for rapid fixes/refactors. | Debugging codebases with high error rates. | | Pipeline | Sequential, staged processing (strict ordering). | Data transformations or workflow automation. |

Example:

# Team workflow: 3 Claude agents fix TypeScript errors
/team 3:executor "fix all TypeScript errors in src/service.ts"

# Ultrawork mode: Spawn parallel debugging panes
omc team 2:codex "review security vulnerabilities"
omc team 1:gemini "audit UI accessibility"

2. Agent Specialization

OMC’s strength lies in its 32 pre-configured agents, each optimized for a domain:

| Category | Example Agents | |------------------------|--------------------------------------------------------------------------------------------------| | Architecture | Code review, architecture audits, system design | | Design | UI/UX prototyping, accessibility testing, visual hierarchy analysis | | Testing | Unit tests, integration testing, performance profiling | | Data Science | Analytics, ML model optimization, statistical inference | | DevOps & Automation | CI/CD pipeline generation, script optimization |

Agents are context-aware: they learn from prior interactions and adapt dynamically (e.g., a database migration agent might auto-generate SQL scripts based on past migrations).

3. Natural Language Interface

OMC eliminates the need for memorizing complex commands:

Instead of typing omc team 2:codex "review auth errors", you can say: bash /team 2:executor "audit my security vulnerabilities"
For vague ideas, use deep-interview to clarify requirements: bash deep-interview "build a mobile app with analytics"

4. Rate-Limit Auto-Resume

Claude Code’s rate limits can pause tasks. OMC handles this automatically:

   omc wait  # Check and resume paused sessions
   omc wait --start  # Enable auto-resume daemon

This requires tmux (included in most OSes), which OMC detects via session tracking.

5. Custom Skills: Portability

Skills are saved as YAML files in .omc/skills/ and injected automatically. Example:

File: .omc/skills/fix-proxy-crash.md

name: Fix Proxy Crash
description: aiohttp proxy crashes on ClientDisconnectedError
triggers:
  - ["proxy", "aiohttp", "disconnected"]
source:
> Wrap the handler at server.py:42 in try/except ClientDisconnectedError...

Usage:

   /skill add fix-proxy-crash

6. Monitoring & Observability

Real-time insights via:

HUD status line: Shows task progress (e.g., "Team plan: 70% complete"). bash omc hud --preset focused
Session artifacts: Logs saved in .omc/sessions/ for post-mortem analysis.
Agent replay logs (*.jsonl): Debugging past interactions.

3. Advanced Features

A. OpenClaw Integration

OMC forwards session events to OpenClaw, allowing automated workflows via a custom gateway:

   /oh-my-claudecode:configure-notifications  # Choose "OpenClaw Gateway"

Configuration example (~/.claude/omc_config.openclaw.json):

{
  "enabled": true,
  "gateways": {
    "my-gateway": {
      "url": "https://your-gateway.example.com/wake",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  },
  "hooks": {
    "session-start": { "gateway": "my-gateway", "enabled": true }
  }
}

Supported hooks include:

session-start
stop (after response)
keyword-detector
ask-user-question

B. Notification Tags

Customize who receives session summaries via Telegram/Discord/Slack:

# Discord: Notify @alice and role 987654321098765432 on completion
omc config-stop-callback discord --enable \
   --webhook https://discord.com/api/webhooks/... \
   --tag-list "@alice,role:987654321098765432"

# Slack: Notify <@MEMBER_ID> and #team-channel
omc config-stop-callback slack --enable \
   --webhook https://hooks.slack.com/services/TXXXX/... \
   --tag-list "<@U1234567890>,#!channel"

C. Cross-AI Orchestration

OmC supports multi-agent workflows (Claude, Codex, Gemini) for mixed tasks: | Mode | Command Example | |--------------------|-----------------------------------------------------------------------------------------------------| | Team | /team 3:executor "fix TypeScript errors" | | CLI Workers | omc team 2:codex "review security risks" | | CCG Tri-Model | /ccg analyze PR (architecture via Codex, UI via Gemini) |

Example of mixed tasks:

   /ccg refine this codebase
     → Ask Codex: "Identify architecture bottlenecks"
     → Ask Gemini: "Propose UI improvements for dashboard"
     → Claude synthesizes recommendations

4. Comparative Advantages & Use Cases

Why Choose Oh-My-ClaudeCode? | Feature | Value Proposition | |--------------------------|----------------------------------------------------------------------------------------------------| | Zero Configuration | Intelligent defaults simplify workflows (e.g., autopilot: build a REST API). | | Team Orchestration | Structured pipelines (team-plan → team-exec) for complex tasks. | | Natural Language | No CLI memorization—describe workflows in plain English. | | Parallel Execution | Workers auto-spawn (Codex/Gemini/Claude) with on-demand resource usage. | | Cost Optimization | Smart routing (Haiku for tasks, Opus for deep reasoning) reduces token spend by 30-50%. | | Skill Reuse | Extract patterns into reusable skills (e.g., fix-proxy-crash). |

Best For:

Teams: Coordinate agents via /team executor ... for coordinated work.
Code Review: Use omc team 3:codex "audit PR" to parallelize security/arch analysis.
End-to-End Projects: autopilot: build a mobile app handles everything from start to finish.
Burst Tasks: ulw fix-all-errors for high-priority, non-sequential fixes.

5. Installation & Setup

Step-by-Step Guide:

Install via Claude Code Marketplace:

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

Configure Environment Variables: Enable teams in your Claude CLI config:

   { "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
   Save this to `~/.claude/settings.json`.

Run a Quick Task: Start with a simple workflow:

   /deep-interview "I want to build a task management app"
     → OMC prompts Socratic questions to clarify requirements before coding begins.

Update Automatically (if marketplace enabled):

   /plugin marketplace update oh-my-claudecode

Troubleshooting:

Clear plugin cache if updates break workflows:

  /omc-doctor

For CLI-based issues, ensure tmux is installed (see Requirements section).

6. Workflow Examples

Example 1: Task Management App (Autopilot)

autopilot: build a task management app
  → OMC auto-plans architecture, UI design, and back-end logic.
  → Workers run in parallel: Codex for APIs, Gemini for UX, Claude for synthesis.

Example 2: Security Audit with Teams

team 5:executor "audit the project's security risks"
  → Phase 1: Plan (Codex identifies vulnerabilities).
  → Phase 2: Execute (Claude drafts fixes; Gemini proposes UX mitigations).
  → Phase 3: Verify (Team loops until all tests pass).

Example 3: Cross-Agent Analysis (CCG)

/ccg analyze this PR
  → Codex reviews architecture decisions.
  → Gemini critiques UI patterns.
  → Claude compiles consensus into actionable notes.

7. Advanced Customization

Skill Development

Define custom skills in .omc/skills/:

    name: "Deploy to Staging"
    description: "Packs code, pushes to staging branch"
    triggers: ["staging", "deploy"]
    source:
      ```
      npm install -g @aws/cdk
      cdk deploy --all
      ```
  - Add skills dynamically via `/skill add <path-to-file.md>`.
- Auto-learn from past sessions:

bash /learner → Extracts patterns (e.g., "how to fix proxy errors") into reusable skills.

**Custom HUD Configuration**
Set up a real-time status bar for monitoring:

bash /oh-my-claudecode:hud setup → Configure presets like focused or verbose. Usage: OMC now updates your status line automatically during sessions.

---

#### **8. Performance Optimization**

**Token Savings**
- Smart routing minimizes costs by auto-assigning agents (e.g., Haiku vs. Opus based on task complexity).
- **Key Feature**: "Cost optimization saves up to 50% on token usage."

**Rate-Limit Handling**
Use the built-in daemon to resume paused sessions:

bash omc wait --start # Enable auto-resume

- Works via `tmux` session tracking; ideal for long-form projects.

---

#### **9. Integration with OpenClaw**

**Step-by-Step Setup (OpenClaw Gateway)**
1. Install the gateway config script:

bash /oh-my-claudecode:configure-notifications → Choose "OpenClaw Gateway".

2. Override manually if needed via `~/.claude/omc_config.openclaw.json`:

json { "enabled": true, "gateways": { … }, "hooks": { "session-start": { … } } }

3. Trigger events during sessions (e.g., when a task completes).

---
#### **10. Comparative Analysis**

| Feature               | oh-my-claudecode                          | Alternatives                     |
|-----------------------|------------------------------------------|-----------------------------------|
| **Agent Specialization** | 32+ agents for architecture, research     | Claude CLI alone (no specialization) |
| **Orchestration**      | Team-first pipelines with auto-fixes     | Manual CLI commands               |
| **Language Flexibility** | Natural language + keywords              | Command-line only                |
| **Parallelization**    | On-demand tmux workers for mixed AI      | Single-agent execution           |
| **Skill Reuse**        | Auto-learned reusable skills             | None (manual configuration)       |

---

#### **11. Real-World Use Cases**

- **Developers**: Build full-stack apps with one prompt.

bash team 3:executor "create a responsive e-commerce dashboard" → Codex handles backend logic; Gemini manages UI components.

- **Research Teams**: Validate hypotheses across multiple models.

bash /ccg compare these research papers for biases → Claude synthesizes findings with input from Codex and Gemini.

- **Agile Projects**: Iterative design cycles using `ralph` mode.

bash ralph: redesign the checkout flow → Loop: plan → execute → verify fixes until satisfactory.

12. Technical Architecture Insights

Core Components:

Agent Teams: Stage-based orchestration pipeline (Plan → Execute → Verify).
Skill Injection System:

Skills stored in .omc/skills/ (YAML/MD files) auto-activate based on prompts.

HUD Integration: Real-time metrics display via CLI flags:

   omc hud --preset "verbose"
     → Shows agent status, token costs, and progress bars.

Rate-Limit Handling:

Daemon-based auto-resume for API throttling scenarios.

OpenClaw Bridge: Webhook integrations for workflow automation.

13. Developer Customization

Skill Creation Workflow:

Define patterns in Markdown (e.g., fix-proxy-crash.md):

    name: Fix Proxy Crash
    description: Handles aiohttp proxy crashes.
    triggers:
      - ["proxy", "aiohttp"]
    source: extracted
     ```
2. Deploy with:

bash /skill add ./path/to/fix-proxy-crash.md

**Advanced Workflows**:
- **Pipeline Staging**: Use `team-prd` mode for staged validation before execution.

bash team-plan draft API specs; team-exec implement in TypeScript.

---

#### **14. Cost Analysis**
1. Model Selection:
   - Default agents use Claude Max/Pro (optimized for cost).
   - Gemini/Codex CLI workers handle specialized tasks (e.g., UI design).
2. Token Efficiency:

markdown * OMC’s smart delegation reduces model churn by ~40% vs manual prompts. * Example: "Build a REST API" runs optimally via Haiku for initial ideas → Opus for detailed implementation.

---

#### **15. Community & Support**
- **Active Discussions**: Join the [Discord server](https://discord.gg/qRJw62Gvh7) for troubleshooting.
- **Skill Libraries**: Explore curated skill chains:

bash /skill list | grep "task-management" → Example skills: "build-todo-app", "design-ui-flow". ```

Debugging Tips:
Run /omc-doctor to diagnose plugin issues.
Use tmux for isolated session debugging.

Visual Summary of Key Features

oh-my-claudecode workflow Character Representation: An anthropomorphic AI guide ("OMC") representing the project's intuitive, zero-configuration philosophy. This visual ties to:

The "Zero learning curve" promise.
Team orchestration as a collaborative, visual pipeline.

Summary of Technical Benefits

| Feature Category | Impact on Workflow | |----------------------------|---------------------------------------------------------------------------------------| | Multi-Agent Specialization | Tasks routed to optimal agents (e.g., Codex for code reviews; Gemini for design). | | Persistent Execution | Agents don’t abandon tasks midway ("Ralph" mode). | | Skill Reuse | Extracts reusable patterns (YAML/MD files) from sessions. | | Cost Savings | Smart agent delegation cuts token costs by up to 50%. | | Real-Time Feedback | HUD displays progress, agent status, and cost metrics during execution. |

This detailed breakdown encapsulates oh-my-claudecode’s architectural depth, user-centric design philosophy, and integration capabilities. From installation and core workflows (Team mode) to advanced features like OpenClaw automation or skill customization—OMC redefines AI-assisted coding through its hybrid orchestration framework. The accompanying visual aids reinforce the project’s approachability while subtly highlighting its technical sophistication.

Oh-My-ClaudeCode: CLI Orchestration Suite