M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
O

oh-my-openagent

Community
Multi-agent coding harness for complex codebases, spanning OpenCode and Codex CLI
How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #227 of 438
Stars
★ 70.7k Very popular
Runtime
Node.js · Bun
Credentials
Optional API key
License
Other / unspecified
Last commit
Tools
8
52FMRS · D

The README quotes several social-media endorsements (e.g., replacing a Cursor subscription, clearing thousands of eslint warnings) that are self-selected third-party testimonials not independently verified here. It also cites a tweet claiming Anthropic blocked OpenCode 'because of us' — this is the project's own framing of a linked third-party post, and this profile does not independently verify that claim.

Strongest · Maintenance 14/20 Weakest · Reliability 7/20

Reliability
7/20
Security and permissions
9/20
Maintenance
14/20
Documentation
13/20
Setup experience
9/20
Why each score
Reliability 7/20
No server manifest was cached and the README contains no tool input/output schemas, real invocation traces, or CI/test evidence, so declared capabilities ('5 built-in MCPs', '54+ lifecycle hooks', etc.) cannot be verified against real behavior. The project references a 'Doctor Command' diagnostic and 'Session Recovery' feature, but neither is backed by reviewable evidence in the provided material. 983 open issues suggest a nontrivial volume of reported failures in a complex system. Per the static calibration rule, scores above 12 require verifiable execution evidence, which is essentially absent here — scored 7.
Security and permissions 9/20
Telemetry is enabled by default (opt-out only), sending a SHA256-hashed install identifier to PostHog on a recurring basis — a persistent, disclosed-but-default-on external data flow. Installation modifies global config files (e.g., ~/.codex/config.toml, opencode.json) and writes into locations like ~/.local/bin. The Codex Light installer explicitly offers an 'autonomous full-permissions mode,' which if enabled reduces confirmation friction for agent actions. The README also instructs users to have an LLM agent fetch and execute a remote installation doc 'end to end' without summarizing — a workflow pattern structurally susceptible to prompt injection if that remote document were ever compromised. No evidence of malware, credential theft, or irreversible unconfirmed destructive defaults was found, so this does not fall into the red-line band, but permission scoping and confirmation disclosure remain incomplete — scored 9.
Maintenance 14/20
The project shows strong star count, an explicit ROADMAP, active Discord community, multilingual READMEs, and a visible 'building in public' cadence, indicating an identifiable and active maintainer (code-yeongyu / Sisyphus Labs). However, the GitHub license field is NOASSERTION while the README badge shows a non-standard 'SUL-1.0' license, leaving licensing governance ambiguous and potentially restricting downstream rights; 983 open issues also suggest a sizeable maintenance backlog. High activity offset by licensing/governance gaps yields a score of 14.
Documentation 13/20
Documentation is well-layered, with dedicated pages for installation, features, configuration, and Team Mode, plus multilingual README variants — broad coverage. However, the tone is heavily promotional, and concrete technical details (tool parameter tables, rate/cost limits, explicit troubleshooting guidance) are thin or absent from the material provided — e.g., no parameter specification for the built-in MCPs or explicit cost/limit disclosures. Scored 13.
Setup experience 9/20
An install path exists (bunx/npx one-liners with a guided TUI), but the actual process is multi-step and involves choosing between Ultimate/Light editions, subscription detection, model matching across 11 agents, multiple provider authentications, and editing global config files. The maintainers explicitly recommend having an LLM agent perform the install to avoid human error, which itself signals a fragile manual path. No CI or test evidence was provided to substantiate install reproducibility, so per the static calibration ceiling the score stays below 15; combined with process complexity, scored 9.

Static review · not runListed 2026-08-06

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Developers already on OpenCode or Codex CLI who want multi-model agent orchestration
  • Teams wanting automated hierarchical AGENTS.md generation and project rule injection
  • Users comfortable granting an agent broad autonomous edit/execution permissions for speed

Not for

  • Users who want a small, single-purpose MCP tool server with a minimal attack surface
  • Workflows requiring strict human review of every file edit or command before it runs
  • Projects requiring vendor-official support rather than a community-maintained plugin
  • Users not running OpenCode or Codex CLI as their agent host

Required permissions

  • Read/write access to the project codebase (for autonomous code edits)
  • Ability to execute shell/terminal commands (tmux integration, git-bash component)
  • Network access for bundled MCPs (Exa web search, Context7 docs, grep_app GitHub search)
  • API keys/subscription auth for multiple LLM providers (Anthropic, OpenAI, Kimi, GLM, Gemini, Copilot, etc.)
  • For the Codex Light edition, write access to `~/.codex/` config, plugin cache directories, and `~/.local/bin`

Risks and side effects

  • Agents have broad autonomous file-edit and command-execution permissions; `ultrawork` mode does not stop until it decides the task is complete, risking large unreviewed changes
  • The Codex Light installer offers a `--codex-autonomous` full-permissions mode that removes command-confirmation gating
  • Anonymous telemetry (hashed machine ID, at most once per day) is enabled by default and must be manually opted out
  • Third-party community project; the README notes an in-progress multi-harness refactor, so behavior may shift between versions
  • Requires credentials/subscriptions from multiple third-party model providers, expanding the credential surface
  • The `omo` bin alias collides with an unrelated third-party npm package, risking accidental installation of the wrong tool

Setup

Before you start

Runtime：Node.js · Bun

Other optional settings (4)
OMO_DISABLE_POSTHOG optional Set to 1 to disable the main plugin's anonymous telemetry (enabled by default); no key needed.
OMO_SEND_ANONYMOUS_TELEMETRY optional Set to 0 to opt out of the main plugin's daily anonymous install-count event.
OMO_CODEX_DISABLE_POSTHOG optional Set to 1 to disable anonymous telemetry for the Codex CLI Light edition.
OMO_CODEX_SEND_ANONYMOUS_TELEMETRY optional Set to 0 to opt out of the Codex Light edition's daily anonymous telemetry event.

Ultimate edition (OpenCode): run bunx oh-my-openagent install; the TUI walks through subscription detection, model selection across the 11 agents, and provider auth, and registers the plugin in opencode.json. Light edition (Codex CLI): run npx lazycodex-ai install (non-interactive recommended: --no-tui --codex-autonomous); the installer writes to ~/.codex/plugins/cache/sisyphuslabs/omo/, a local Codex marketplace cache, marketplace/plugin/agent blocks in ~/.codex/config.toml, and component CLIs in ~/.local/bin. Use --platform=both to install both editions. Do not run bunx omo/npx omo — that bin alias collides with an unrelated third-party npm package of the same name.

MCP config · JSON 
{"plugin": ["oh-my-openagent"]}

Works in clients that read an "mcpServers" key. For clients such as VS Code that use a different key, the configurator below converts it.

.vscode/mcp.json
{
  "plugin": [
    "oh-my-openagent"
  ]
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Generate and validate client config

Check that it works

After installing, type ultrawork (or ulw) in OpenCode and confirm tools like lsp_diagnostics and team_status appear in the tool list; you can also run bunx oh-my-opencode doctor to verify plugin registration.

Troubleshooting

  1. Run `bunx oh-my-opencode doctor` (or oh-my-openagent doctor) to verify plugin registration, config, models, and environment
  2. Confirm `opencode.json`'s plugin array includes `oh-my-openagent` (or the legacy `oh-my-opencode` entry)
  3. Check config resolution: project-level `.opencode/oh-my-openagent.json[c]` files are walked up to `$HOME`, with the closest one winning
  4. For the Codex Light edition, inspect `~/.codex/config.toml` for the marketplace/plugin/agent blocks and check `~/.codex/plugins/cache/sisyphuslabs/omo/`
  5. Avoid `bunx omo`/`npx omo`; use `oh-my-openagent`, `oh-my-opencode`, or `lazycodex-ai` instead
  6. If Team Mode's team_* tools don't appear, confirm `team_mode.enabled` is set to true in the config and restart opencode

Things to try

Once connected, you can ask your AI assistant things like:

  • Use lsp_rename to rename the function handleAuth to authenticate, then run lsp_diagnostics to check for errors.
  • Use lsp_goto_definition to find the definition of the ConfigService class, then lsp_find_references to list all usages.
  • With Team Mode enabled, use team_create to set up a team, team_task_create to assign refactor tasks, and team_status to check progress.
  • Use team_send_message to tell team members to prioritize fixing errors reported by lsp_diagnostics.

Tools 8

lsp_rename writes
Renames a symbol across the codebase via Language Server Protocol integration.
lsp_goto_definition read-only
Jumps to a symbol's definition via LSP.
lsp_find_references read-only
Finds all references to a symbol via LSP.
lsp_diagnostics read-only
Retrieves LSP diagnostics (errors/warnings) for the codebase.
team_create writes
Creates a new Team Mode session with a lead agent and parallel members.
team_send_message writes
Sends a message between the team lead and team member agents.
team_task_create writes
Creates a task item for a team member to work on.
team_status read-only
Reports the current status of team members and their tasks.

Use cases

Autonomous multi-agent coding (Sisyphus, Hephaestus, Prometheus, etc.) on complex codebases in OpenCode
One-word `ultrawork`/`ulw` invocation that plans, delegates, and drives a task to completion
Team Mode for adversarial plan review (hyperplan) or parallel security research with multiple agents
Lightweight portable components (rules, LSP, ast-grep, comment checking) inside Codex CLI without full agent orchestration

Supported clients

OpenCode
Codex

Listed from the project's documentation, not tested by this site.

Overview

oh-my-openagent (aka omo/lazycodex) is a community-maintained coding-agent harness shipped in two editions: Ultimate (for OpenCode, with 11 agents, 54+ lifecycle hooks, built-in MCPs, and Team Mode) and Light (for Codex CLI, with portable components like rules injection, comment checking, git-bash, LSP, ultrawork, and ulw-loop). It orchestrates multiple LLM providers (Claude, GPT, Kimi, GLM, Gemini, and others), bundles MCP servers for web search (Exa), docs (Context7), and GitHub code search (grep_app), and adds LSP and ast-grep tooling so agents can autonomously drive coding tasks to completion.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 64.1k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision d8858c83778e Data synced 2026-11-04 Read the FMRS scoring method