Documentation

Learn how to install and run the OmO harness inside Codex for complex codebases.

Overview

LazyCodex packages oh-my-openagent (OmO) inside Codex as the agent harness for complex codebases. Think LazyVim for lazy.nvim, but for Codex.

What you get

OmO gives Codex a full agent harness: discipline agents (Sisyphus orchestrates Hephaestus, Oracle, and Librarian), parallel execution, multi-model routing, a skills system, hooks and lifecycle, and verification defaults. LazyCodex packages that harness as a repeatable Codex setup.

The harness workflow

Use {your prompt} ultrawork when the job needs project memory, planning, parallel agents, and verified completion to run as one coordinated loop.

How it fits together

LazyCodex is a thin distribution layer. The core engine is OmO. LazyCodex is maintained by Sisyphus Labs.

Credit: The LazyCodex name idea is inspired by LazyVim. The Ultragoal and UltraQA ideas are inspired by oh-my-codex, reimplemented from concept for this Codex setup.

Installation

One command installs the OmO agent harness for Codex without a global package install.

Install

npx lazycodex-ai install

This is exactly equivalent to npx --yes --package oh-my-openagent omo install --platform=codex.

Autonomous one-liner

npx lazycodex-ai install --no-tui --codex-autonomous

Prerequisites

  • Node.js — any maintained LTS; npx ships with it. Bun is not required: the installer runs on plain Node.
  • The OpenAI Codex CLI

Do NOT use npm install -g or bun add -g. Always invoke via npx.

Install from the Codex marketplace (experimental)

The npx installer above stays the primary path. As an additive, experimental alternative you can install from inside Codex itself: type /plugins, open the Add Marketplace tab ("Add a marketplace from a Git repo or local root."), and enter https://github.com/code-yeongyu/lazycodex, then install omo from the sisyphuslabs marketplace. Or from the CLI:

codex plugin marketplace add https://github.com/code-yeongyu/lazycodex
codex plugin add omo@sisyphuslabs

On the next launch, approve the omo hooks in Codex's startup review — hooks never run before approval. The first approved session prints LazyCodex bootstrap running in background — restart the session when it completes while a background worker finishes the setup (config blocks, agent roles, bin links, a pinned sg binary for the ast_grep MCP); restart when it is done. The marketplace path never touches Codex permission settings — autonomous mode remains the explicit npx lazycodex-ai install --no-tui --codex-autonomous choice.

Upgrade with codex plugin marketplace upgrade sisyphuslabs. The next startup review shows the hooks as Modified — expected after every upgrade, because the plugin files changed and the previous trust hashes no longer match — re-approve them and the following session re-runs bootstrap on the new version. If anything looks pending or degraded, npx lazycodex-ai doctor explains what and why.

Windows

Native Windows works with both install paths.

  • Node: npx lazycodex-ai install needs Node.js on PATH (LTS recommended). On marketplace installs the bootstrap step provisions a pinned Node LTS runtime into %USERPROFILE%\.codex\runtime\node\ automatically when node is missing — installing Node yourself first also works and skips the download.
  • Git Bash: required for shell hooks. The installer and the marketplace bootstrap both try winget install --id Git.Git -e --source winget when Git Bash is missing. If Git lives somewhere custom, set OMO_CODEX_GIT_BASH_PATH to a path like C:\Program Files\Git\bin\bash.exe.
  • where bash shows C:\Windows\System32\bash.exe: that is the WSL launcher, not Git Bash — LazyCodex intentionally ignores System32 and WindowsApps bash.exe shims when resolving Git Bash. Install Git for Windows or point OMO_CODEX_GIT_BASH_PATH at a real Git Bash so the resolver finds it.
  • Troubleshooting: the Windows marketplace bootstrap writes a transcript to %USERPROFILE%\.codex\plugins\data\omo-sisyphuslabs\bootstrap\ps-bootstrap.log; degraded lines look like degraded component=node reason=... hint=npx lazycodex-ai doctor. Run npx lazycodex-ai doctor for the full health report.

Let an agent do it

It is strongly recommended to let an LLM agent run the install and walk the setup for you. The agent handles subscription detection, model selection, and provider auth automatically.

Feature coverage

LazyCodex is most useful as a harness for complex codebases: project memory, planning, execution, verified completion, skills, hooks, model routing, and diagnostics.

Built-in workflows

Start with /init-deep when the repository is too large or too old to explain from memory. It generates hierarchical AGENTS.md context so agents can find the right files before they change code.

Use $ulw-plan when the work needs decisions before implementation, $start-work when a plan should be executed, and $ulw-loop when you want the agent to keep going until the result is verified.

Feature coverage

The three command pillars stay simple:

  • $ulw-loop keeps moving until verified completion
  • $ulw-plan turns fuzzy work into a decision-complete plan
  • $start-work executes a plan with durable Boulder progress

Skills add specialist judgment around those pillars:

Skill Use it for
review-work Multi-angle post-implementation review
remove-ai-slops Behavior-preserving cleanup of AI-looking code
frontend-ui-ux Designed UI work instead of generic layout filling
programming Strict TypeScript, Rust, Python, or Go discipline
LSP Diagnostics, definitions, references, symbols, and renames
AST-grep Structural search and rewrite across code
rules Project instructions from AGENTS, rules, and instruction files
comment-checker Feedback after edit-like operations

Where skills live

OmO can load skills from project and user locations such as .opencode/skills, ~/.config/opencode/skills, .claude/skills, .agents/skills, and ~/.agents/skills.

LazyCodex installs the Codex Light setup with:

npx lazycodex-ai install

That installer wires the Codex marketplace plugin as omo@sisyphuslabs while keeping the public package alias easy to remember.

ultrawork mode

ultrawork is the headline mode. Typing ultrawork (or the short alias ulw) anywhere in your prompt activates maximum-precision, outcome-first, evidence-driven orchestration.

"Plan, execute, verify, and keep the evidence attached."

Usage

ulw add authentication

What it enforces

  • Strict TDD: RED → GREEN → SURFACE → CLEAN
  • At least 3 realistic QA scenarios
  • Real manual-QA channels (HTTP call, tmux, browser)
  • A binding verification gate that loops until the work is genuinely done

$ulw-loop

$ulw-loop is a self-referential development loop that runs until verified completion.

How it works

The agent works continuously and emits <promise>DONE</promise> when it believes the task is complete, but that does NOT end the loop. An Oracle must verify the result first. The loop ends only after the system confirms Oracle verified it. If verification fails, it continues with the message: "Oracle verification failed. Continuing ULTRAWORK loop."

Syntax

$ulw-loop "task description" [--completion-promise=TEXT] [--strategy=reset|continue]

Limits

The iteration cap is 500 in ultrawork mode (100 in normal mode).

$ulw-plan

$ulw-plan is the strategic planning consultant (Prometheus). It turns an idea into a decision-complete work plan. It is a planner, NOT an implementer. When you say "do X" it produces a plan for X and never writes product code.

The flow

  1. Socratic interview
  2. Parallel codebase exploration
  3. Metis gap analysis
  4. Writes the plan to plans/<slug>.md
  5. Optional Momus high-accuracy review

Output

Questions, research, and a work plan you can hand to $start-work.

$start-work

$start-work executes a Prometheus work plan until every top-level checkbox is done.

How it works

  • Durable Boulder state in .omo/boulder.json survives across turns and sessions
  • A Stop-hook re-injects the next turn until the plan is complete
  • Independent sub-tasks fan out to parallel subagents
  • Strict TDD plus five evidence gates: plan reread, automated verification, manual-QA, adversarial QA, cleanup
  • Progress is recorded to a ledger

Syntax

$start-work [plan-name] [--worktree <absolute-path>]

Done

It prints an ORCHESTRATION COMPLETE block when every checkbox is checked.