LaunchedEditorial Listing

Oh My Pi

Stencil Labs · Oh My Pi (omp): Open-Source Terminal Coding Agent with LSP, Debugger, and Subagents Built In

Open Oh My Pi

Oh My Pi (omp) is a free, MIT-licensed terminal coding agent from Stencil Labs, forked from Mario Zechner's Pi. It reads, edits, and runs code with the model provider you choose, and it ships IDE-style tooling built in: language servers, a real debugger, hash-anchored edits, parallel subagents, browser control, and web search. It suits developers who like Pi's terminal workflow but want a batteries-included agent rather than a minimal core.

PricingFree
Setupmedium
Runs onDesktop · API
APIYes
Open sourceYes
DocsYes
CategoryCoding
Agentic CodingTerminalOpen SourceModel-AgnosticBYOKSubagentsMCPCode ReviewCLISDKLSP

Best for

Terminal-first developers who want one model-agnostic agent with language servers, a debugger, subagents, browser control, and session sharing already built in, and who are comfortable configuring approvals and a fast-moving tool

Not ideal for

Developers who want a small core they extend themselves (upstream Pi fits better), teams that need approval prompts on by default or a stable, slow-changing tool, and anyone who prefers an IDE extension or desktop app

Who it's for

Developers who work from the terminal and want a model-agnostic coding agent with IDE tooling, subagents, and automation interfaces built in

Capabilities

  • Hashline edits: the model patches lines by content-hash anchor, and a patch against a stale file is rejected instead of applied
  • Language-server integration for diagnostics, navigation, symbols, code actions, and renames that update imports and re-exports
  • Debugger control over the Debug Adapter Protocol: launch or attach, set breakpoints, step, and inspect threads, stacks, and variables (for example lldb, GDB, dlv, debugpy)
  • Persistent Python and JavaScript eval cells that can call the agent's own read, search, and task tools
  • ast-grep structural search and rewrites, previewed as a proposed change before they are applied
  • Subagents via the `task` tool, optionally in isolated workspaces, with bundled specialists (scout, designer, reviewer, security-reviewer, librarian) and Agent Hub for watching, messaging, or stopping each worker
  • Built-in browser automation (headless Chromium, CDP-attached apps, or your own Chrome tabs through a relay extension) and an opt-in desktop control tool
  • `web_search` across many search backends, with page extraction for GitHub, package registries, arXiv, Stack Overflow, and docs sites
  • /collab live session sharing through an end-to-end encrypted relay, with full-control or view-only links usable from another terminal or a browser
  • Plan mode, an optional advisor model that reviews every turn, /review with P0 to P3 findings, and `omp commit` for atomic, dependency-ordered commits
  • Model roles (default, smol, slow, plan, commit, vision, and more), per-role fallback chains, and credential rotation across API keys
  • Imports existing rules, skills, and MCP servers from Claude Code, Cursor, Codex, Cline, Windsurf, Gemini, Copilot, and VS Code config folders
  • Configurable tool approvals (always-ask, write, yolo) with per-tool allow, prompt, or deny rules and bash command patterns
  • Interactive TUI, one-shot print mode, NDJSON RPC mode, a Node SDK, and an Agent Client Protocol (ACP) server for editors such as Zed

Limitations

  • The built-in approval mode is yolo: reads, writes, and commands run without prompts until you set `tools.approvalMode` to write or always-ask. The docs recommend a restricted account or container for unattended runs
  • Opening a repository loads its settings, extensions, hooks, tools, skills, and project MCP configuration by design. Flags such as --no-extensions or a config overlay narrow what loads but do not change this trust model, so review untrusted repositories before opening them
  • Very fast release cadence (several releases a week, sometimes several a day), and recent releases have included breaking changes to SDK interfaces
  • Large feature surface with many settings, so it takes longer to learn than upstream Pi's minimal core
  • Terminal-first. Editor use goes through ACP clients such as Zed; no first-party VS Code or JetBrains extension is documented
  • /collab uses the hosted relay at my.omp.sh by default, and no production-ready self-hosted relay is distributed. Collab links are bearer secrets with no account-based identity
  • The Bun package install requires Bun 1.4.4 or newer (the install scripts fetch a prebuilt binary when Bun is not available), and the Alpine musl binary needs libstdc++ and libgcc installed first

Use cases

  • Tracking down a segfault, hang, or wrong value by having the agent attach a debugger and inspect the live process instead of adding print statements
  • Running a cross-package refactor or rename that relies on the language server to update imports and re-exports
  • Splitting an audit or migration across parallel subagents in isolated workspaces, then integrating and verifying the results in the main session
  • Pairing on a live agent session with a teammate, or sharing a view-only link for a review or demo
  • Reviewing a branch or uncommitted work with prioritized findings, then splitting the change into atomic commits
  • Moving from Claude Code, Cursor, or Codex without rewriting existing rules, skills, and MCP server configs

Our take

omp is what you get when someone takes Pi's terminal workflow and decides the agent should already have everything an IDE has. Language servers, a real debugger, structural edits, subagents with isolated workspaces, browser control, and shared sessions are all built in. Hash-anchored edits target the whitespace and string-not-found retries that the project says slow other agents down. The cost is surface area and defaults. There is a lot to learn, releases land several times a week, approvals are off until you turn them on, and repository config loads automatically. It suits developers who will set up approvals and project trust before relying on it and who want one tool to grow into. Anyone who chose Pi for its small core should stay with Pi.

Who should use it

Terminal-first developers who want language-server and debugger awareness in their agent, people who use several model providers or subscriptions and want to route them by role, and teams that want parallel subagents, live session sharing, or an agent they can drive over RPC, the SDK, or ACP.

Who should skip it

Developers who want a minimal, self-assembled agent (use Pi), teams that need approval prompts on by default or a slow, stable release cadence, people working in untrusted repositories without time to lock down project config loading, and anyone who prefers an IDE panel or desktop app.

Strengths

  • Free and open source under MIT, with model costs paid to the provider you choose
  • Language servers, a DAP debugger, structural edits, browser control, and web search work without extensions
  • Hash-anchored edits reject patches against stale files instead of corrupting them
  • Subagents with isolated workspaces, typed results, and a live Agent Hub for steering
  • Works with dozens of providers, including Claude Pro/Max and ChatGPT subscription sign-in and local models
  • Reads existing Claude Code, Cursor, Codex, and Cline rules, skills, and MCP configs without migration
  • TUI, print, RPC, SDK, and ACP entry points for scripting, embedding, and editor use

Weaknesses

  • Approval prompts are off by default (yolo mode) until configured
  • Repository-supplied settings, hooks, and extensions load automatically
  • Fast release cadence with occasional breaking SDK changes
  • Large surface that takes time to learn
  • No first-party VS Code or JetBrains extension

Oh My Pi pricing

Open Source

Free

  • MIT-licensed CLI, SDK, and packages
  • Bring your own API key, subscription, or local model

Note: omp itself is free. Costs come from the model provider, subscription, or hardware you use. The /collab relay at my.omp.sh needs no configuration and no pricing is published for it.

Technical specs

API pricing

Free Node SDK, NDJSON RPC mode, and ACP server; model usage is billed by the provider you connect

Available models

Model-agnostic: dozens of providers via API keys, including Anthropic, OpenAI, Google Gemini and Vertex, xAI, DeepSeek, Mistral, Amazon Bedrock, Azure OpenAI, and OpenRouterOAuth and subscription sign-in, including Claude Pro/Max, ChatGPT (openai-codex), GitHub Copilot, and CursorLocal models via Ollama, LM Studio, llama.cpp, or vLLM, plus custom OpenAI- or Anthropic-compatible endpoints

Where Oh My Pi excels

Debugging a runtime-only bug

The agent can launch or attach a debug adapter, stop at a breakpoint, and read frames and variables, so it reasons from live state rather than guessing from source.

Parallel package audits or migrations

The task tool fans out file-disjoint work to subagents in isolated workspaces, returns structured results, and lets you steer or stop each worker from Agent Hub.

Pair programming with an agent across machines

/collab hands out a full-control or view-only link, so a teammate can follow or steer the host's session from their own terminal or a browser.

Switching from another coding agent

omp reads rules, skills, and MCP server configs already on disk from Claude Code, Cursor, Codex, Cline, and others, so an existing setup works without conversion.

Oh My Pi vs. competitors

Oh My Pi vs. Pi Coding Agent

omp is a fork of Pi and credits it as the base. Pi deliberately keeps a minimal core: MCP is built in, but sub-agents, plan mode, and permission prompts come from extensions you add. omp builds those in, along with LSP, a DAP debugger, hashline edits, browser control, and session sharing, and its permission prompts are configurable approval modes. Choose Pi for a small core you shape yourself, and omp for a batteries-included agent that does more out of the box.

Oh My Pi vs. OpenCode

OpenCode is an MIT-licensed, multi-provider agent with a TUI, a desktop app, a web UI, and ACP support, from the team behind SST. omp is terminal-first with no desktop app, but it builds in LSP and live session sharing (neither is in OpenCode V2 yet), DAP debugger control, hashline edits, and subagents with isolated workspaces, and it documents Claude Pro/Max sign-in, which OpenCode does not.

Oh My Pi vs. Claude Code

Claude Code is Anthropic's commercial agent for Claude models, with official VS Code, JetBrains, desktop, and web clients. omp is free and model-agnostic and can sign in with a Claude Pro/Max subscription, but it has no first-party IDE extension and its approval prompts are off until configured.

Oh My Pi vs. Crush

Crush is Charm's source-available (FSL-1.1-MIT) terminal agent with LSP, MCP, Agent Skills, and permission prompts on by default. omp is MIT licensed, adds an ACP mode for editors such as Zed, and its built-ins also cover DAP debugger control, hashline edits, browser automation, and encrypted live session sharing through a hosted relay, but it runs tools without prompts unless you set an approval mode.

Oh My Pi vs. OpenAI Codex

OpenAI Codex pairs an open-source CLI with IDE extensions, ChatGPT-plan billing, and parallel cloud tasks. omp runs the agent on your own machine and has no hosted cloud tasks, but it can sign in with a ChatGPT subscription and mix OpenAI models with other providers by role in the same session.

Frequently asked questions

What is Oh My Pi (omp)?

Oh My Pi is an open-source coding agent for the terminal, run with the `omp` command. It inspects a repository, edits files, runs commands, and uses built-in language-server, debugger, browser, web search, and subagent tools with the model provider you choose. It is built by Stencil Labs and developed in the open on GitHub under Can Bölük's account (can1357).

How is Oh My Pi different from Pi?

omp is a fork of Pi (pi-mono by Mario Zechner, now maintained by Earendil), rewritten as a batteries-included coding agent. Pi keeps a minimal core: it now includes MCP, but expects you to add sub-agents, plan mode, and permission prompts through extensions. omp ships all of those plus LSP integration, DAP debugging, hashline edits, browser control, a native Rust core, and live session sharing.

Is Oh My Pi free and open source?

Yes. omp is MIT licensed on GitHub (can1357/oh-my-pi). The agent costs nothing; you pay your model provider, use a subscription you already have, or run local models.

Can I use my Claude Pro/Max or ChatGPT subscription with omp?

Yes, according to the provider docs. The anthropic route supports Claude Pro/Max OAuth as well as API keys, and openai-codex uses ChatGPT subscription access, both through /login. Coding plans such as GitHub Copilot and Kimi Code, API keys for many other providers, and local engines such as Ollama, LM Studio, and llama.cpp are also supported.

Does omp ask before running commands?

Not by default. The built-in approval mode is yolo, which runs reads, writes, and commands without prompts. Set `tools.approvalMode` to write (prompts for commands, eval, browser control, and subagents) or always-ask (prompts for every mutation), and add per-tool allow, prompt, or deny rules. ACP sessions in an editor keep the client's permission prompt for bash and edits unless you opt out.

Can I use Oh My Pi inside an editor?

Yes, through the Agent Client Protocol. Run `omp acp` from an ACP client such as Zed, and file reads, writes, and terminals go through the editor. No dedicated VS Code or JetBrains extension is documented.

How do I install Oh My Pi?

On macOS or Linux, run `curl -fsSL https://omp.sh/install | sh`. On Windows, run `irm https://omp.sh/install.ps1 | iex` in PowerShell. Homebrew (`brew install can1357/tap/omp`), Bun (`bun install -g @oh-my-pi/pi-coding-agent`), Nix, and mise are also supported. Then run `omp` in a project and follow the setup wizard to sign in and pick a model.

Integrations & fit

AnthropicOpenAIGoogle GeminiGitHub CopilotCursorOpenRouterAmazon BedrockAzure OpenAIOllamaLM Studiollama.cppMCPZed (ACP)GitHubGoogle ChromeLLDBDelvedebugpy
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on Oh My Pi →

Alternatives to consider

About Oh My Pi

Oh My Pi started as a fork of Pi (pi-mono, the open-source toolkit by Mario Zechner that is now maintained by Earendil) and was rewritten as a coding-first agent. The two now take opposite positions. Pi keeps a small core: MCP is now built in, but sub-agents, plan mode, and permission prompts are left to extensions. omp puts all of that in the box. You run `omp` in a repository, describe the outcome, and the agent works through a large built-in tool set. Edits use hashline patches that point at content-hash anchors instead of retyping lines, and a stale anchor makes the patch fail instead of corrupting the file. Renames and diagnostics go through the project's language servers, and the agent can launch or attach a debugger through the Debug Adapter Protocol (for example lldb, dlv for Go, or debugpy for Python) to set breakpoints and read live variables. Persistent Python and JavaScript cells can call back into the agent's own tools. Structural search and rewrites use ast-grep. A `browser` tool drives headless Chromium or your own Chrome tabs through a relay extension, an optional `computer` tool controls the desktop, and `web_search` chains many search backends. The `task` tool fans work out to subagents, optionally in isolated workspaces, and returns schema-validated results. You can watch and steer each worker in Agent Hub. An optional advisor model can review every turn, /review runs prioritized code review with reviewer subagents, and `omp commit` splits a working tree into atomic commits. /collab shares a live session through an end-to-end encrypted relay, either read-write or view-only, with guests joining from another terminal or a browser. omp works with dozens of providers through API keys, OAuth sign-in (including Claude Pro/Max and ChatGPT subscriptions), coding plans such as GitHub Copilot, and local engines such as Ollama, LM Studio, and llama.cpp. You assign models to roles such as default, smol, slow, and plan. On first run it picks up existing rules, skills, and MCP servers from Claude Code, Cursor, Codex, Cline, Windsurf, Gemini, Copilot, and VS Code config folders. Besides the TUI it runs as a one-shot print command, an NDJSON RPC server, a Node SDK, and an Agent Client Protocol agent for editors such as Zed. The tradeoffs are breadth and defaults. The surface is large and changes several times a week. The built-in approval mode is yolo, so tool calls run without prompts until you configure approvals (ACP sessions keep the editor's permission prompt for shell commands and edits). Opening a repository also loads its settings, hooks, extensions, and MCP configuration by design.

Updates from Oh My Pi

New Featurev18.18.2 adds extension management and session stripping

omp 18.18.2 lets /extensions list and toggle extensions and installed plugins, adds LSP source actions such as Organize Imports, and adds `omp gc --strip` to remove provider replay data from idle sessions. It also changed two SDK interfaces for hosts that embed omp.

New Featurev18.17.0 adds live bash visualization and opt-in auto-update

omp 18.17.0 shows a live execution view of bash commands with variable values and replay, adds opt-in background auto-update through your install method, and lets the Devin provider sign in with Devin CLI or Windsurf Enterprise credentials.

New Featurev18.13.0 adds spend caps that cover subagents

omp 18.13.0 added --warn-cost and --max-cost: omp warns at the first threshold and stops sending model requests at the second, including from subagents. It also added --no-context-files to start a session without AGENTS.md or CLAUDE.md.

Are you the founder? Claim this listing →