DOCSEARCHbyAlgolia
Submit Docs

oh-my-openagent

repository·dev·Indexed 12 days ago

https://github.com/code-yeongyu/oh-my-openagent

An orchestration layer for AI coding agents and models (such as Claude Code and Codex) designed to prevent vendor lock-in. Version 5.0.0-beta.6 includes the oh-my-opencode plugin featuring multi-model orchestration, parallel background agents, and LSP/AST tools. It provides components like lsp-tools-mcp for Language Server Protocol capabilities via MCP, and various Codex plugins including codex-lsp for post-edit diagnostics and codex-comment-checker for automated comment validation.

Tokens
951.4K
Snippets
2.8K
Records
3.9K
Agent score
99%

What's inside oh-my-openagent

  2. Overview of codex-telemetry

    dev

    The codex-telemetry component is a Codex plugin that emits a single anonymous daily-active event (omo_codex_daily_active) to PostHog whenever a Codex session starts.

    To protect privacy, the component:

    • Sends the event at most once per UTC day per machine.
    • Uses a SHA256-hashed installation identifier derived from omo-codex:${hostname} instead of the raw hostname.
    • Explicitly disables PostHog person profiles.
    • Never sends prompt contents, file contents, API keys, or user-identifying data.

  3. Overview of oh-my-openagent features

    dev

    oh-my-openagent provides a suite of advanced agentic and developer productivity tools:

    Agent Ecosystem

    • Sisyphus: The main orchestrator agent.
    • Prometheus: The planner agent.
    • Oracle: Used for architecture and debugging.
    • Librarian: Handles documentation and code search.
    • Explore: Performs fast codebase grepping.
    • Multimodal Looker: For multimodal capabilities.
    • Background Agents: Ability to run multiple agents in parallel like a development team.

    Developer Tools

    • LSP and AST Tools: Support for refactoring, renaming, diagnostics, and AST-aware code search.
    • Hash-anchor Edits: Uses LINE#ID references to verify file content before applying changes, ensuring surgical precision even with outdated lines.
    • Context Injection: Automatically injects AGENTS.md, README.md, and conditional rules into the context.
    • Session Tools: Tools to list, read, search, and analyze session history.
    • Productivity Tools: Includes Ralph Loop, Todo Enforcer, Comment Checker, and Think Mode.

    Integrations and Compatibility

    • Claude Code Compatibility: Full support for hooks, commands, skills, agents, and MCP.
    • Built-in MCP (Model Context Protocol): Includes websearch (Exa), context7 (documentation), and grep_app (GitHub search).
    • Model Fallbacks: The fallback_models configuration allows mixing simple model strings and detailed per-fallback object settings in a single array.
    • File-based Prompts: Load prompts from files using the file:// protocol in agent configurations.

  4. Overview of codex-rules

    dev

    The codex-rules plugin injects local project rule files into the model context using Codex lifecycle hooks. It is a port of pi-rules designed to provide context-aware instructions based on the current session and file operations.

    Key behaviors:

    • SessionStart & UserPromptSubmit: Loads static project instructions once per session.
    • PostToolUse: Watches for the apply_patch tool by default and injects file-specific rules as additional context.
    • PostCompact: Clears the per-session injection cache after conversation compaction to allow relevant rules to be reintroduced.
    • Deduplication: Prevents the same rule from being repeated within a session.

    Note: PostToolUse output is context-only; it populates hookSpecificOutput.additionalContext and does not modify the original tool output.

  5. Overview of codex-lsp

    dev

    The codex-lsp plugin provides Codex with post-edit diagnostics and explicit Model Context Protocol (MCP) tools for language-aware code operations. It ports the standalone LSP runtime from pi-lsp-client to work within the Codex ecosystem.

    Key features include:

    • Post-edit diagnostics: Automatically checks files for errors after tools like apply_patch, write, edit, or multiedit are used.
    • Language-aware MCP tools: Provides tools for navigation and refactoring (e.g., goto_definition, rename).
    • Blocking feedback: If diagnostics contain errors, the plugin returns PostToolUse blocking feedback to Codex, providing the diagnostics as context so the agent can fix the file.

  6. Overview of Oh My OpenAgent

    dev
    Oh My OpenAgent (OMO) is a tool designed for developers who juggle multiple AI agents like Claude Code, Codex, and various open-source models. It provides a tested, streamlined workflow by orchestrating these tools, allowing you to move away from single-provider ecosystems and towards an open market of models. The project is currently refactoring towards a multi-harness agentic OS to support multiple agent harnesses including OpenCode, Codex, Pi, and others.

  7. Overview of the Go Programmer Skill

    dev

    The Go Programmer skill enforces a strict, production-ready Go development standard for 2026. It compensates for Go's lack of certain type-system features (like sum types or exhaustive checking) by using a specific bundle of linters and strict coding patterns.

    Core Principles:

    • Parse, don't validate: Use smart constructors (New*) to transform raw input (HTTP/RPC/CLI) into validated domain structs. Once in the domain, validation is assumed complete.
    • Error Handling: Use (T, error) everywhere. Never panic in library code. Use %w for wrapping and errors.Is/errors.As for assertion. Use typed error structs for branching logic.
    • Sealed Interfaces: Implement sum types using unexported methods to seal interfaces, then use type switch for dispatching.
    • Context Discipline: context.Context must always be the first parameter. Avoid context.Background() in leaf functions and ensure all goroutines support context-driven shutdown.
    • Codegen over Hand-writing: Use sqlc for databases, oapi-codegen for OpenAPI, and connectrpc/connect-go for RPC to avoid manual marshalling errors.

  8. Understand Node.js Runtime Licenses for CodeGraph Platform Bundles

    dev

    The CodeGraph Platform Bundles include various dependencies with specific licensing terms. This document outlines the licenses for components such as OpenSSL and other runtime dependencies.

    Key components mentioned:

    • OpenSSL: Located at deps/openssl, licensed under the Apache License, Version 2.0.
    • General Runtime Dependencies: Subject to the Apache License, Version 2.0 terms as detailed in the provided legal text.

  9. Core Features of oh-my-openagent

    dev

    oh-my-openagent provides a comprehensive suite of tools for LLM-driven development. Key features include:

    • Agent Ecosystem: Includes specialized agents like Sisyphus (Main), Prometheus (Planner), Oracle (Architecture/Debugging), Librarian (Doc/Code Search), Explore (Codebase grep), and Multimodal Looker.
    • Background Agents: Ability to run multiple agents in parallel, mimicking a real development team.
    • LSP & AST Tools: Full support for refactoring, renaming, diagnostics, and AST-based code searching.
    • Hash-anchored Edit Tool: Uses LINE#ID references to validate content before any changes, ensuring surgical precision and eliminating "stale line" errors.
    • Context Injection: Automatically injects AGENTS.md, README.md, and conditional rules into the context.
    • Claude Code Compatibility: Full compatibility with Claude Code's hook system, commands, skills, agents, and MCP.
    • Built-in MCPs: Includes websearch (via Exa), context7 (documentation), and grep_app (GitHub search).
    • Session Management: Tools to view, read, search, and analyze session history, including automatic recovery from errors, context window limits, or API failures.
    • Diagnostic Tool: Use the doctor command to validate plugin registration, configuration, models, and environment settings.
    • Model Flexibility: Supports fallback_models configuration using a mix of simple model strings and per-fallback objects. Supports loading prompts from files using the file:// protocol.
    # Run built-in diagnostics
bunx oh-my-opencode doctor

  10. Use the Programming skill for code tasks

    dev

    The programming skill must be used for any work involving .py, .pyi, .rs, .ts, .tsx, .mts, .cts, or .go files. It follows a strict philosophy of type-safety, modern toolchains, and architectural honesty.

    Core Principles:

    • Strict Types: Use the type system as a proof system to make illegal states unrepresentable.
    • Parse, Don't Validate: Untrusted input is parsed into typed values at the boundary (using Pydantic v2, serde, or Zod) and never re-validated inside the logic layer.
    • Semantic Primitives: Use NewType (Python), newtype tuple structs (Rust), or branded types (TypeScript) so that distinct concepts (e.g., UserId vs string) cannot be mixed.
    • Exhaustive Matching: Always use exhaustive variant matching for enums/discriminated unions. Avoid if/elif/else for discriminating on tagged variants.
    • Minimalism: The best code is the code never written. Prioritize YAGNI, reuse existing patterns, and leverage standard libraries or dependencies before writing new code.

  11. Overview of OMO Components and Hooks

    dev

    The Oh My OpenAgent ecosystem consists of several specialized components that integrate with Codex via hooks, MCP (Model Context Protocol), or skills:

    ComponentLanguageCodex hooksDescription
    rulesTypeScriptSessionStart, UserPromptSubmit, PostToolUse, PostCompactInjects AGENTS.md, CLAUDE.md, and .omo/rules/** into context
    comment-checkerTypeScriptPostToolUse (apply_patch, edit, write)Blocks AI-slop comment patterns in generated code
    git-bashTypeScript + MCPPreToolUse (Bash), PostCompact, MCP serverExposes git_bash on Windows; provides reminders
    codegraphTypeScript + MCPSessionStart, PostToolUse, MCP serverProvisions CodeGraph and exposes MCP tools
    lspTypeScript + MCPMCP server + post-edit hooksExposes LSP diagnostics, navigation, symbols, and rename
    ultraworkTypeScriptUserPromptSubmit keyword detectorDetects ulw/ultrawork keywords and links agent TOMLs
    ulw-loopTypeScriptUserPromptSubmit, PreToolUse, StopMulti-goal orchestration with evidence audit trails
    start-work-continuationTypeScriptStop, SubagentStopContinues .omo/boulder.json plans when Codex pauses
    telemetryTypeScriptSessionStartEmits anonymous daily active telemetry

    Note on Coexistence: The Codex CLI Light edition and the OpenCode plugin can run side-by-side. They both read the unified omo.jsonc surface but use harness-specific views ([opencode], [senpi], and [codex]).

  12. What is Ultrawork mode?

    dev

    Ultrawork (or ulw) is a high-precision, outcome-first directive for the omo-senpi agent. When activated, the agent shifts into an 'Expert coding agent' role focused on delivering verified, end-to-end working code proven by evidence.

    Key Characteristics:

    • Precision: Maximum precision, outcome-first, and evidence-driven.
    • Memory-Centric: The agent must actively record and reference memory, consulting it before asking the user and saving durable facts, decisions, and corrections.
    • Tiered Execution: Work is classified into LIGHT or HEAVY tiers to determine the depth of testing and review required.
    • Evidence-Based: Success is not defined by passing tests alone, but by captured evidence (e.g., HTTP status lines, terminal outputs, or browser screenshots) that proves user-facing behavior works.