Oh My OpenAgent: an opinionated orchestration layer for coding agents

Everything you need to know about code-yeongyu/oh-my-openagent: a harness for OpenCode and a slimmed-down edition for Codex CLI that combine agent roles, hooks, tools, and project rules.

What Oh My OpenAgent is

Oh My OpenAgent (also omo, and formerly oh-my-opencode) is an automation project for coding agents. Its Ultimate edition installs as an OpenCode plugin; its Light edition, distributed via LazyCodex, installs portable components inside Codex CLI. It is not a model: it organizes how an agent uses models, tools, rules, and subagents.

Visual comparison of two environments: a futuristic command center with multiple holographic agents for the Ultimate edition, and a minimalist single-operator terminal for the Light edition.

The repository frames its use case as handing off large tasks to an agent: the user states the goal and the system plans, delegates, looks up documentation, edits code, and preserves checks. The documentation clearly distinguishes the two editions:

Ultimate / OpenCode: 11 specialized agents, more than 54 lifecycle hooks, built-in MCP, commands, team mode, ulw-loop, and Hashline edits.
Light / Codex CLI: rules, a comment checker, Git Bash, LSP, ultrawork, ulw-loop, work continuity, and telemetry; it deliberately lacks team orchestration, since the project attributes that surface to Codex CLI itself.

The origin: from Oh My OpenCode to a multi-environment harness

The GitHub API dates the creation of code-yeongyu/oh-my-openagent to December 3, 2025. Its author is YeonGyu-Kim (code-yeongyu), whose account is identified with the bio “Hacker”, a Seoul location, and a stated affiliation with @sionic-ai.

The name carries a history of transition: the documentation explains that the package and binary were published as oh-my-opencode and that the new name is published in parallel during the change. The configuration recognizes both oh-my-openagent and the legacy entry, though the latter emits a warning. The Codex edition is called LazyCodex, and the README clarifies that its name is inspired by LazyVim; it is not the name of the Codex marketplace.

The author’s account in the README is deliberately personal: it states having spent $24,000 in LLM tokens on personal projects, having tried tools and configurations, and having settled on OpenCode. That experience serves as justification for a product with many pre-set decisions. It also documents a tension with providers: it claims Anthropic blocked OpenCode over how it used their models; this is a claim by the project linked to a post on X, not an independent confirmation from Anthropic. Hence its current emphasis on an open marketplace of providers and on not depending on a single model.

Cyberpunk workstation with holographic screens showing TypeScript code, GitHub metrics, and a roadmap document, with the silhouette of a hacker in Seoul in the background.

Philosophy and principles

The stated philosophy is prioritizing agent performance on extensive tasks, not minimizing visual complexity for the person maintaining the repository. Its ROADMAP.md sums up that stance: the agent thinks, decides, and executes; the person kicks off the work.

Five neon-lit figures represent the specialized agents Sisyphus, Prometheus, Oracle, Librarian, and Explore arranged in a futuristic grid.

Principles verifiable in the documentation:

Assign roles, not just models: Sisyphus orchestrates; Prometheus plans; Oracle reviews architecture and debugging; Librarian searches documentation and code; Explore quickly scouts the codebase. The category of work selects a chain of models and providers.
Planning before execution: Prometheus interviews the user and drafts plans in .omo/plans/; Metis detects gaps, and Momus and Oracle can review the plan in parallel.
Context and rules as infrastructure: AGENTS.md and .omo/rules/** load automatically. /init-deep generates hierarchical AGENTS.md files to distribute context by directory.
On-demand tools: MCP servers tied to skills spin up for the task and shut down afterward, instead of permanently occupying context.
Checks against stale edits: Hashline tags lines with a content hash; if the file changed since it was read, it rejects the edit instead of applying a stale line reference.

Futuristic code editor where each line carries a neon content hash; an AI cursor attempts to edit a stale line and a glowing red holographic shield rejects the change.

The trade-off is a very interventionist posture: more hooks, agents, permissions, and configuration paths increase automation possibilities, but they also widen the operational surface that needs reviewing.

How it works

Installation and activation

For OpenCode, the documented command is bunx oh-my-openagent install; for Codex CLI, npx lazycodex-ai install. The non-interactive Codex alternative is npx lazycodex-ai install --no-tui --codex-autonomous. The README expressly warns that npx omo should not be used, since it corresponds to a different, unrelated npm package.

On Codex, the installer writes the omo@sisyphuslabs plugin, agent definitions, and SHA-256 hook trust states to ~/.codex/config.toml. Hooks must be approved at the next Codex startup; per the guide, they do not run before that approval. The autonomous mode of the npx installation can configure approval_policy = "never", sandbox_mode = "danger-full-access", and network access; that is an explicit decision that deserves security review before accepting it.

Dark-mode terminal showing the installation command bunx oh-my-openagent install alongside holographic warnings about SHA-256 hook approval.

Workflow and features

The main shortcut is typing ultrawork or ulw: in Ultimate it triggers full orchestration, and in Light it activates the corresponding Codex component. For precise work, the guide recommends entering planning mode and using /start-work so Prometheus interviews, prepares, and submits the plan for review.

Futuristic holographic table with blueprints, file trees, and floating .omo/plans/ directories, being reviewed by translucent AI entities.

In Ultimate, Team Mode is optional. A leader can spin up to eight members in parallel, watch activity via tmux, and use team_* tools for messages, tasks, status, and shutdown. Two skills sit on top of that layer: hyperplan, which pits five critics against the plan, and security-research.

Futuristic command center visualizing Team Mode: a central leader coordinates eight parallel terminal panes with real-time coding activity and task status.

The built-in tools include LSP for diagnostics, navigation, symbols, and renaming; ast-grep; a tmux terminal; and MCP for web search, documentation, and code. The Light edition shares LSP, rules, ulw-loop, and its own limited MCP servers, but not the agents or team_*.

Official and semi-official status

The status is semi-official and platform-bounded:

Oh My OpenAgent’s documentation states that the Light edition installs via the Codex CLI plugin marketplace, with the sisyphuslabs marketplace and the omo plugin. This means Codex can manage its installation, updates, and hook approval; it does not mean OpenAI endorses the methodology, its safety, or its results.
For OpenCode it presents itself as a host plugin, not a native OpenCode feature.
The README claims Ultimate’s compatibility with Claude Code elements — hooks, commands, skills, MCP, and plugins — but ROADMAP.md classifies future adapters for Claude Code, Amp, and Droid as exploratory, not confirmed.

No certification, sponsorship, or formal standard designation from OpenAI, OpenCode, Anthropic, or another provider was found. With 67,005 stars and multiple adaptations, it functions in practice as a visible reference for the multi-agent harness pattern, but that is an interpretation of adoption, not an official status.

The ecosystem

Author repositories and upcoming components

A query of code-yeongyu’s public repositories returned these related projects, some reused by the architecture:

code-yeongyu/lazycodex — a Codex harness with project memory, planning, execution, and verified completion; 3,051 stars and 192 forks. It is the repository and installer tied to the Light edition.
code-yeongyu/senpi — an opinionated fork of badlogic/pi-mono with extensions; 324 stars and 44 forks. ROADMAP.md identifies a Senpi adapter and an omo.json configuration already deployed first in that environment.
code-yeongyu/lsp-tools-mcp — LSP tools exposed as an stdio MCP server, consumed by Codex LSP and Oh My OpenAgent; 7 stars and 9 forks.
code-yeongyu/codex-rules — a Codex plugin that injects project rules via hooks; 9 stars. The same rule-loading principle appears in the Light edition.
code-yeongyu/pi-rules and code-yeongyu/pi-goal — Pi extensions for rules and persistent goal tracking; 8 and 17 stars, respectively.

The technical plan divides the code into a pure TypeScript core, MCP servers, static skills, specific adapters, and platform launchers. It declares 19 extracted core packages and places OpenCode, Codex, and Senpi as current adapters; the relationship between these repositories is therefore not just thematic, but part of the reuse strategy.

Neon monolith inscribed with "67,005 stars" surrounded by satellite nodes representing community forks, plugins, and adaptations in a vast network.

Ports, forks, and community extensions

Searching GitHub repositories by exact name turned up ports and plugins, including non-English work:

HanTechnology/oh-my-openagent-toolkit — a companion kit for OpenCode, with routing and skill surfaces; 37 stars and 4 forks.
junlin-233/oh-my-lite-openagent — a lightweight subagent plugin compatible with OpenCode; 8 stars.
eugenejahn/oh-my-openagent-copilot — a multi-agent orchestration port for GitHub Copilot CLI; 7 stars.
oneforce/oh-my-openagent-gemini — an adaptation for Gemini CLI described in Chinese; 2 stars.
zaxcler/oh-my-openagent-swtich — a configuration for switching models and agents, with a Chinese description; 3 stars.
Vera-l7/oh-my-openagent-droid — an adaptation for Factory Droid that lists agents, ultrawork, Hashline, and hooks; no stars in the search result consulted.
andersou/oh-my-openagent-vscode-extension — a VS Code extension; 2 stars.

These are third-party repositories found via search, not distributions approved by the author. Their figures do not certify compatibility, maintenance, or safety; in particular, a port can copy the branding without sharing the code or guarantees of the original.

Repo numbers

Measured: August 1, 2026, GitHub API and page.

Metric	Value
Stars	67,005
Forks	5,467
Real subscribers	221
Commits	11,775
Open issues reported by the API	956
Branches / tags shown on GitHub	152 / 245
Primary language	TypeScript
License	Sustainable Use License 1.0
Created	December 3, 2025
Latest release	`v4.19.4`, August 1, 2026

The commit count comes from the last page indicated by the API’s pagination header. The top contributors returned by the API were code-yeongyu (9,060 contributions), github-actions[bot] (696), sisyphus-dev-ai (252), justsisyphus (239), and MoerAI (203). The language breakdown places TypeScript first, followed by JavaScript, HTML, Shell, and Python.

The license deserves attention: it allows internal enterprise, non-commercial, or personal use, and conditions distribution and modifications; it is not a permissive open-source license. Additionally, open_issues_count can include open pull requests; it should not be read as issues exclusively. watchers_count mirrors the star count in GitHub’s general response, so subscribers_count is reported here as the real subscriber figure.

How to contribute

No independent CONTRIBUTING.md file or pull request template was found in the sources consulted. There is a concrete process for priority work: the README and ROADMAP.md ask readers to first read the multi-environment refactor roadmap and to label pull requests tied to it with ROADMAP.

The roadmap requires conservative extractions: move logic to the TypeScript core, re-export it from the old location, verify tests, and only then remove duplication. That procedure, together with the proposed separation between core, MCP, skills, adapters, and launchers, offers a verifiable criterion for architecture contributions. For general changes, the repository does not document, in the material retrieved, an additional branching flow or PR template.

How the community received it

The reception found is mixed and concentrated in comments within broader coding-agent discussions, rather than in a big Hacker News launch of its own:

In the OpenCode thread 47460525, with 1,274 points and 95 comments, grapheneposter said they tried the tool when Oh My OpenAgent was starting to spread and found it “very unstable”, so they went back to internal tooling. This is a personal-experience objection, not a reproducible evaluation.
In 47633396, with 1,099 points and 177 comments, josh_p said they were satisfied using it on OpenCode with two model families; they valued that the author tailors instructions to each model, though they also questioned whether that differentiation actually mattered. The same comment mixes praise with methodological caution.
In 48278610, with 323 points and 52 comments, regexorcist highlighted planning and execution via subagents with distinct roles. That comment in the thread offers no measurements or a controlled comparison, so it is evidence of usage, not of quantified performance.
In 48553224, with 1,151 points and 217 comments, jeremyjh explained that they automate subtask distribution and model swaps based on usage limits, and stated they run it in an isolated box with no outside communications. This illustrates advanced use of role assignment, but it does not invalidate the telemetry the project itself documents as enabled by default.
In 48847407, with 151 points and 23 comments, mdgld called the hook and plugin system “gigantic”, though they still listed it among the setups they had tried. This is a concrete criticism of the architecture’s weight, consistent with Ultimate’s large configuration surface.

The project does document default anonymous telemetry, with at most one event per day per machine and an installation identifier with SHA-256; it can be disabled via configuration or the OMO_DISABLE_POSTHOG and OMO_SEND_ANONYMOUS_TELEMETRY variables. That is a fact from the project’s own documentation, not an independent privacy audit.

Oh My OpenAgent versus other proposals

Proposal	Verifiable overlap	Verifiable difference
`gsd-build/get-shit-done`	A metaprompt system, context engineering, and spec-driven development for Claude Code.	An HN user characterized it as similar to Oh My OpenAgent; the source found does not establish technical equivalence. GSD had 64,783 stars in the API consulted.
`Yeachan-Heo/oh-my-codex`	Adds hooks, agent teams, and a HUD to Codex.	Oh My OpenAgent’s README acknowledges that the Ultragoal and UltraQA ideas were inspired by it, but claims to reimplement them. Oh My Codex had 32,370 stars.
`code-yeongyu/lazycodex`	Shares an author and targets memory, planning, execution, and verification in Codex.	It is the lightweight Codex track associated with this ecosystem, while Ultimate keeps OpenCode’s 11-agent orchestration.
`code-yeongyu/senpi`	Part of the roadmap’s adapter strategy.	Senpi is a Pi-oriented fork; the guide marks OpenCode as Ultimate’s current main host.

The useful comparison is not just about stars: Oh My OpenAgent stands out when you want a harness that enforces roles, hooks, and model routing. It can be overkill when the priority is keeping a small, easily auditable integration.

Use cases and who this repository can help

Teams working with OpenCode who need to hand off a broad programming task can use Ultimate to kick off ultrawork, prepare a plan with Prometheus in .omo/plans/, request reviews from Metis, Momus, or Oracle, and delegate exploration or documentation to the corresponding roles. When the work allows for parallelism, Team Mode lets you spin up to eight members, track tasks and messages from tmux, and shut down the team when finished; LSP, ast-grep, and Hashline provide checks during editing.

Codex CLI users who prefer a more bounded layer can install LazyCodex to use rules, LSP, ulw-loop, work continuity, and telemetry without Ultimate’s team orchestration. It is also a starting point for those who want to organize per-project instructions with AGENTS.md and .omo/rules/**. Before enabling the autonomous install, they should review the permissions, the hooks pending approval, and the telemetry, since the documented mode can configure broad system and network access.

Resources

Repository: https://github.com/code-yeongyu/oh-my-openagent
Documentation and installation: https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/installation.md
Orchestration: https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/orchestration.md
Roadmap and contribution: https://github.com/code-yeongyu/oh-my-openagent/blob/dev/ROADMAP.md
Skills and features: https://github.com/code-yeongyu/oh-my-openagent/tree/dev/docs
Codex edition: https://github.com/code-yeongyu/lazycodex
Discord community: https://discord.gg/PUwSMR9XNk
Community conversations and reviews: https://news.ycombinator.com/item?id=47460525, https://news.ycombinator.com/item?id=47633396, https://news.ycombinator.com/item?id=48278610, https://news.ycombinator.com/item?id=48553224, https://news.ycombinator.com/item?id=48847407

Note: this article combines the README, the documentation, ROADMAP.md, the license, the GitHub API, and Hacker News conversations retrieved on August 1, 2026. Figures correspond to that point in time.