Recently, the entire developer community has been buzzing about OpenAI's Codex CLI.
It has truly brought AI programming assistants into the command line, allowing us to converse directly with AI in the terminal to write code, fix bugs, and perform refactoring. With just a few lines of commands, complex programming tasks can be handed over to it.
However, once you start using it, problems arise. Every conversation starts from scratch; it doesn't remember where the previous discussion left off.
The larger the project, the easier it gets lost. It doesn't know which code has been changed, which pitfalls have been encountered, or which solutions have been discussed. More critically, when facing complex tasks, it can only work alone head-down, unable to divide labor and collaborate.
It's like being assigned a very capable assistant, but this assistant has no memory, cannot plan proactively, and doesn't understand team cooperation.
Until a few days ago, I stumbled upon an open-source project on GitHub called oh-my-codex (OMX for short), which shouts the slogan "Make Your Codex No Longer Lonely."
GitHub Project Address:
https://github.com/Yeachan-Heo/oh-my-codex
In just two short months, this project has skyrocketed to over 16,000 Stars, becoming incredibly popular.
It doesn't replace Codex; instead, it adds a workflow engine layer on top of Codex. It transforms the once lone-wolf AI assistant into a development team that understands planning, has memory, and knows how to collaborate.
┌─────────────────────────────────────────────────┐
│ Codex CLI (Execution Engine) │
│ ↑ │
│ OMX Workflow Layer │
│ ├── Deep Interview ($deep-interview) │
│ ├── Plan Approval ($ralplan) │
│ ├── Continuous Execution ($ralph) │
│ └── Team Collaboration ($team) │
│ │
│ .omx/ Persistent Storage │
│ ├── Plan Documents │
│ ├── Interview Records │
│ ├── Execution Logs │
│ └── Project Memory │
└─────────────────────────────────────────────────┘What impressed me the most are its four built-in core skills.
1. First is the $deep-interview deep interview system.
The most headache-inducing part of using Codex previously was when requirements were unclear. We give a vague requirement, and it starts guessing blindly, resulting in something that 80% of the time isn't what we wanted.
OMX's deep interview acts like an experienced product manager, proactively asking for requirement details.
For example, if you say "I want to add a user authentication feature," it won't start writing code immediately. Instead, it will ask first: JWT or Session? Is third-party login support needed? How high are the security level requirements? How should edge cases be handled?
Through rounds of interviews, it turns vague ideas into clear solutions, ensuring everyone understands consistently before taking action.
# Deep Interview Example
$ omx
> $deep-interview "Add user authentication feature to the system"
🤔 Starting deep interview...
Q1: Authentication Method Selection
- Use JWT or traditional Session?
- Is a refresh token mechanism needed?
Q2: Third-Party Login
- Which third-party logins need support? (Google/GitHub/WeChat)
- How to handle the OAuth 2.0 flow?
Q3: Security Level
- Password strength requirements?
- Is two-factor authentication needed?
- Session expiration time?
✅ Interview complete, requirements document generated → .omx/interviews/auth-2026-04-05.md2. Next is the $ralplan plan approval process.
This function solves another pain point: starting work without a plan, only to realize halfway through that the direction is wrong.
OMX converts the requirements obtained from the interview into a detailed implementation plan. It lists which files need changing, what technical trade-offs exist, what pitfalls might be encountered, and the estimated workload.
More critically, it submits this plan to you for approval. You can raise objections, discuss alternative solutions, and adjust priorities.
Only when the plan is truly approved does it enter the execution phase. It's no longer working blindly head-down, but aligning as it goes.
> $ralplan "Approve user authentication implementation plan"
📋 Implementation plan generating...
=== User Authentication Module Implementation Plan ===
[Architecture Decision]
✓ Adopt JWT + Redis solution
✓ Frontend-backend separation architecture
✓ Support Google/GitHub OAuth
[File Change List]
- backend/auth/jwt.ts (New, JWT generation and verification)
- backend/routes/auth.ts (New, Authentication routes)
- backend/middleware/auth.ts (New, Authentication middleware)
- frontend/pages/login.tsx (Modify, Login page)
- database/migrations/001_users.sql (New, User table)
[Technical Trade-offs]
⚖️ JWT vs Session
Choose JWT: Supports distributed, stateless, mobile-friendly
Cost: Cannot actively invalidate, requires blacklist cooperation
[Risk Points]
⚠️ XSS Attack → Use HttpOnly Cookie
⚠️ CSRF Attack → Implement CSRF Token
⚠️ Brute Force → Add login rate limiting
[Estimated Workload] 3-4 days
Approve this plan? (y/n/suggest modifications)3. Then there is the $ralph continuous execution loop.
The name is quite interesting; ralph stands for "relentless alpha," meaning a "executor who never gives up. "
Once the plan is approved, ralph takes over the specific implementation. It doesn't just execute and leave; it continuously verifies, discovers problems, fixes problems, forming a complete closed loop.
For example, after changing code, it automatically runs tests. If tests fail, it analyzes the cause and fixes them, then verifies again until all checkpoints pass.
It's like assigning you an employee who can both work and has a strong sense of responsibility; they won't stop until the task entrusted to them is properly completed.
> $ralph "Execute user authentication implementation plan"
🔄 Ralph continuous execution loop started...
[Step 1/5] Create database migration file
✅ Create 001_users.sql
✅ Execute migration
✅ Verify table structure
[Step 2/5] Implement JWT utility class
✅ Write jwt.ts
🧪 Run unit tests...
❌ Test failed: token expiration time not set
🔧 Fix: Add default expiration time 24h
🧪 Retest... ✅ Passed
[Step 3/5] Create authentication routes
✅ Implement /login interface
✅ Implement /register interface
✅ Add parameter validation
🧪 Integration test... ✅ Passed
[Step 4/5] Implement authentication middleware
✅ Token verification logic
✅ Permission check
🧪 Middleware test... ✅ Passed
[Step 5/5] Frontend login page
✅ UI component implementation
✅ API docking
🧪 E2E test... ✅ Passed
✨ All tasks complete! Fixed 3 issues, ran 28 tests, all passed.4. The most hardcore upgrade is the $team team collaboration mode.
Traditional Codex is like a single-threaded program, doing only one thing at a time. In contrast, OMX's team mode can start multiple Agents working in parallel.
Suppose you need to refactor a large module involving frontend changes, backend API adjustments, database migration, and test supplementation.
In team mode, you can start 3 executor roles at once, responsible for the frontend, backend, and database lines respectively. They work independently in their own tmux sessions without interfering with each other.
Moreover, these Agents can coordinate with each other. For instance, when the backend API is modified, it notifies the frontend that joint debugging can begin. If a module has a breaking change, it automatically synchronizes with other affected members.
> $team 3:executor "Refactor e-commerce module"
🚀 Launching 3 Agent team...
┌──────────────────────────────────────────────────────────┐
│ Team: refactor-ecommerce-2026-04-05 │
├──────────────────────────────────────────────────────────┤
│ Agent-1 [Frontend] tmux session: omx-team-1 │
│ ├─ Processing: Product list component refactoring │
│ ├─ Progress: ████████░░ 80% │
│ └─ Status: Waiting for backend API... │
├──────────────────────────────────────────────────────────┤
│ Agent-2 [Backend] tmux session: omx-team-2 │
│ ├─ Processing: Order service API transformation │
│ ├─ Progress: ██████████ 100% ✅ │
│ └─ Message: Notified Agent-1 API is ready │
├──────────────────────────────────────────────────────────┤
│ Agent-3 [Database] tmux session: omx-team-3 │
│ ├─ Processing: Database table structure optimization │
│ ├─ Progress: ██████░░░░ 60% │
│ └─ Status: Executing migration script... │
└──────────────────────────────────────────────────────────┘
💬 Team collaboration log:
[14:32] Agent-2 → Agent-1: "Order API v2 complete, check docs for new fields"
[14:35] Agent-1 → Agent-2: "Received, starting new interface docking"
[14:38] Agent-3 → All: "⚠️ Added inventory field to product table, may affect existing queries"The status, progress, and logs of the entire project are all recorded in the .omx/ directory.
This directory acts as the team's shared brain. All planning documents, interview records, execution logs, and project memory are structurally stored here.
The next time you open the project, OMX will automatically load this context. It knows what was discussed before, what decisions were made, and what pitfalls to watch out for.
It's no longer starting every conversation from scratch; it truly has project-level continuous memory.
📁 .omx/ # OMX working directory
├── 📋 plans/ # Implementation plans
│ ├── auth-plan-2026-04-05.md
│ └── refactor-plan-2026-04-03.md
│
├── 💬 interviews/ # Interview records
│ ├── auth-interview.md
│ └── feature-clarification.md
│
├── 📝 logs/ # Execution logs
│ ├── ralph-auth-2026-04-05.log
│ └── team-refactor.log
│
├── 🧠 memory/ # Project memory
│ ├── decisions.md # Important decisions
│ ├── pitfalls.md # Known pitfalls
│ └── conventions.md # Code conventions
│
├── 👥 teams/ # Team collaboration
│ └── refactor-ecommerce/
│ ├── status.json # Team status
│ ├── messages.json # Collaboration messages
│ └── worktrees/ # Git worktrees
│
└── ⚙️ state/ # Runtime state
└── current-mode.jsonAdditionally, OMX has a built-in role expert system.
When you start it with omx --madmax --high, it automatically loads a series of professional roles: Architect, Executor, Reviewer, Test Engineer, etc.
When architecture design is needed, call the Architect role. When fast execution is needed, switch to the Executor. When code review is needed, bring in the Reviewer.
Each role has its own professional prompt and workflow, much more professional than a general-purpose assistant.
# OMX built-in 30+ professional roles
🏗️ Architecture & Design
├─ $architect # System Architect - Design technical solutions
├─ $tech-lead # Tech Lead - Technical decisions
└─ $database-designer # Database Designer - Data modeling
⚡ Execution & Implementation
├─ $executor # Fast Executor - Coding implementation
├─ $refactor-specialist # Refactoring Expert - Code optimization
└─ $debugger # Debugging Expert - Problem localization
🔒 Quality & Security
├─ $code-reviewer # Code Reviewer - Quality control
├─ $security-reviewer # Security Reviewer - Security scanning
├─ $test-engineer # Test Engineer - Test coverage
└─ $performance-analyst # Performance Analyst - Performance optimization
📚 Documentation & Communication
├─ $tech-writer # Tech Writer - Documentation writing
├─ $api-designer # API Designer - Interface design
└─ $oncall # On-call Engineer - Incident response
# Usage Example
$ omx --madmax --high
> $architect "Design user authentication architecture"
> $security-reviewer "Review login interface security"
> $executor "Implement JWT authentication logic"Even more thoughtfully, OMX provides a monitoring interface: omx hud --watch.
You can see in real-time what each Agent is doing, how far execution has progressed, and if any problems are encountered. It's like installing a task board for the development team, making everything clear at a glance.
$ omx hud --watch
╔════════════════════════════════════════════════════════════════╗
║ OMX Real-time Monitoring Dashboard ║
╠════════════════════════════════════════════════════════════════╣
║ 🎯 Current Task: E-commerce Module Refactoring ║
║ 📊 Overall Progress: ████████░░ 78% ║
║ ⏱️ Runtime: 2h 15m ║
╠════════════════════════════════════════════════════════════════╣
║ Agent Status ║
║ ┌──────────────────────────────────────────────────────────┐ ║
║ │ 🟢 Agent-1 [architect] Reviewing architecture design │ ║
║ │ └─ File: src/services/order.ts │ ║
║ │ └─ Operation: Analyzing dependencies │ ║
║ ├──────────────────────────────────────────────────────────┤ ║
║ │ 🟢 Agent-2 [executor] Refactoring code │ ║
║ │ └─ File: src/api/products.ts │ ║
║ │ └─ Progress: 15/20 functions optimized │ ║
║ ├──────────────────────────────────────────────────────────┤ ║
║ │ 🟡 Agent-3 [test-engineer] Waiting for code completion │ ║
║ │ └─ Preparing to run integration tests │ ║
║ └──────────────────────────────────────────────────────────┘ ║
╠════════════════════════════════════════════════════════════════╣
║ 📈 Statistics ║
║ ├─ Files Modified: 23 ║
║ ├─ Code Lines: +487 / -312 ║
║ ├─ Tests Passed: 156 / 160 ║
║ └─ API Calls: 1,247 ║
╠════════════════════════════════════════════════════════════════╣
║ 📝 Recent Logs ║
║ [15:42:18] Agent-2: Completed ProductService refactoring ║
║ [15:41:55] Agent-1: Found circular dependency, suggest redesign║
║ [15:40:32] Agent-3: Unit test coverage reached 85% ║
╚════════════════════════════════════════════════════════════════╝
Press 'q' to quit | 'r' to refresh | 't' to toggle team viewMany developers initially hesitate to use AI-assisted programming, not because they think AI isn't strong enough, but because they fear losing control.
They fear it will modify code incorrectly, misunderstand requirements, or that when problems arise, they won't know where to trace them back to.
OMX provides excellent guarantees in this regard. All interview records, planning documents, and execution logs are persistently stored and can be traced back at any time.
If a certain decision goes wrong, you can clearly see why that choice was made at the time, who approved it, and what happened during execution.
Coupled with the worktree isolation mechanism in team mode, each Agent works in an independent git worktree without polluting others. Even if something goes wrong, it can be rolled back quickly.
🔒 Security Guarantee Mechanism
1️⃣ Git Worktree Isolation
main/ ← Main branch (protected)
├── .git/worktrees/
│ ├── agent-1/ ← Agent-1 independent workspace
│ ├── agent-2/ ← Agent-2 independent workspace
│ └── agent-3/ ← Agent-3 independent workspace
✅ No interference ✅ Independent commits ✅ Fast rollback
2️⃣ Complete Audit Logs
.omx/logs/audit.log
├── [2026-04-05 15:30] Agent-2 modified auth.ts
├── [2026-04-05 15:32] Executed npm test (Exit code: 0)
├── [2026-04-05 15:35] Committed "feat: add JWT auth"
└── [2026-04-05 15:37] Merged to main branch
3️⃣ Traceable Decisions
Every important decision is recorded:
- 💡 Decision Content: Why choose JWT?
- 👤 Approver: User confirmed in $ralplan
- ⏰ Timestamp: 2026-04-05 14:25:33
- 📄 Impact Scope: auth.ts, middleware/auth.ts
4️⃣ Fast Disaster Recovery
$ omx team rollback --to-commit abc123
✅ All Agent worktrees rolled back to safe state One-click startup, ready out of the box
Deployment and usage are very simple. After global installation, it can run with a single command:
npm install -g @openai/codex oh-my-codex
omx setup
omx --madmax --highThen, in the Codex session, use the standard workflow to advance tasks:
$deep-interview "Clarify requirements and boundaries"
$ralplan "Approve implementation plan and trade-offs"
$ralph "Continuous execution until completion"
$team 3:executor "Parallel execution of complex tasks"The project also provides detailed configuration requirements: Node.js version 20+, macOS/Linux requires tmux, and Windows requires psmux. These are standard environments that most developers can get started with directly.
📋 Configuration Requirements List
Required Environment:
✅ Node.js >= 20
✅ Codex CLI (npm install -g @openai/codex)
✅ OpenAI API Key
Additional Requirements for Team Mode:
🍎 macOS → brew install tmux
🐧 Linux → sudo apt install tmux
🪟 Windows → winget install psmux
🐧 WSL2 → sudo apt install tmux
Recommended Configuration:
- Memory: 4GB+
- Disk: 2GB available space
- Network: Stable API connection
One-click Verification:
$ omx doctor
[OK] Codex CLI: installed ✅
[OK] Node.js: v20+ ✅
[OK] Prompts: 30 installed ✅
[OK] Skills: 40 installed ✅
[OK] MCP Servers: configured ✅
Results: 9 passed, 0 warnings, 0 failedFinal Thoughts
Looking at the current field of AI programming assistants, there aren't many projects that can make workflow, memory, and collaboration ready out of the box.
OMX's thinking is very clear: it doesn't compete with Codex for饭碗 (rice bowl/livelihood), but instead adds a smarter working mode on top of it.
If you are already using Codex to tinker with various automated developments, or if you want an AI development team that truly understands collaboration and has memory.
Then OMX is definitely worth a try.
From solo combat to team collaboration, this is just the first step.
When every developer can low-cost assemble an AI team that understands planning, knows how to collaborate, and has memory, those requirements that previously took several people a week to complete might now be delivered by one person in a day.
Future competitiveness lies not in how many lines of code you can write, but in how much intelligent collaborative power you can mobilize.
GitHub Project Address:
https://github.com/Yeachan-Heo/oh-my-codex
That concludes today's sharing. Thank you all for taking the time to read. See you next time!