oh-my-pi (omp) – a terminal AI-agent for coding with a “stitched” IDE

oh-my-pi (abbreviated as omp) is an open end-to-end AI programming agent with the motto “A coding agent with the IDE wired in.” The project created Can Bölük as a fork of the minimalist agent Pi from Mario Zechner. If the Pi is a skeleton with four basic tools, then the Omp turns it into a full-fledged workbench with batteries in the kit.

License - MIT, project site - omp.sh. Over a period of 7 months, the project collected more than 22,000 stars on GitHub.

The model is the moat, the harness is the bridge, and the shell is the bridge. The point is that the same model in a good tie works many times better.

## In short: what an omp can do

Claimed figures from the repository:

• 60+ model providers (Anthropic, OpenAI, Google, xAI/Grok, DeepSeek, local Ollama/vLLM and any OpenAI compatible endpoints);
• 31 embedded tool;
• 14 LSP operations (working with a language server);
• 28 DAP operations (real debugger management);
• **~80,000 lines on Rust in the core.

It runs on macOS, Linux and Windows (without WSL).

## Where did the omp come from: fork Pi

The name plays the bundle “Oh My Zsh → zsh”: as Oh My Zsh is built over the zsh shell, so the omp is built over the Pi.

• Mario Zechner is an intentionally minimal agent. There are 4 instruments in total: read, write, edit, bash. Philosophy is a small readable core to which it is easy to contribute. 84,000 stars.
• omp (Can Bölük) is the official fork that “adds everything you’ve been missing”: LSP editing, real-life DAP debugger, sub-agents, on-the-fly flow correction rules, code execution and “advisor” model.

They are essentially two different answers to the same question. Pi says “Put the plugins for your tasks”, omp – “Everything is already assembled and configured out of the box”.

## Main feature: hashline-editing

This is perhaps the most interesting thing about Omp from an engineering standpoint.

Problem. Regular AI agents edit files in two ways: either send the entire file with a replacement, or refer to line numbers. The first consumes a ton of tokens, the second breaks as soon as the lines have moved (the model is pointing the wrong way).

Omp solution - hashline. Each line is assigned a short hash anchor (2-3 characters) derived from its contents. The model does not point to a line by number and does not rewrite its entire text, but refers to this anchor. A patch with a “rotten” (obsolete) hash is simply rejected rather than applied blindly.

What does that tell you by the numbers:

• On the Grok Code Fast 1 model, the share of successful edits to real code increased from 6.7% to 68.3%, a tenfold increase. The model is the same, the prompt is the same - only the editing format has changed.
• On 180 React tasks across 16 models, the format added an average of ~15 percentage points to success.
• Expenditure of output tokens falls: on Grok 4 Fast – about ** 61%**, on Claude Opus – about 30%.

This is a graphic illustration of the “Harness Problem”: it’s often not the model that’s involved, but the way the tool codes it.

## How it works: Architecture

omp does not “shell” outward by separate processes, but links real implementations directly into the process – the “zero fork/exec” approach. Inside: ripgrep, glob, find, fork bash called brush and another 58 CLI utility.

Four entry points on top of one engine:

1. ** Interactive TUI** is the default terminal interface.
2. One-shot (omp -p) is a one-time run for scripts and CI.
3. *Node SDK is a software access.
4. RPC/ACP over stdio - Integration with editors (e.g., Zed via Agent Client Protocol).

Stack: TypeScript (agent, SDK, TUI), Rust (~80k lines in pi-shell, pi-natives, pi-ast, pi-iso, pi-voice, pi-walker via N-API) and Bun.

## Key opportunities in detail

• LSP sewn into the record. Renames go through workspace/willRenameFiles, so imports and re-exports are updated correctly. Refactoring is “structurally true by construction” rather than “probabilistically true by line coincidence.”.
• Real debugger via DAP. Support for lldb, dlv (Go), debugpy (Python): breakpoints, step-by-step execution, stack and live condition inspection. Useful for data racing, segfaults, and competitive bugs, instead of print.
• Execution of code with re-entry into tools. Persistent Python and Bun-worker can call the tools of the agent through a loopback bridge.
• Time-traveling stream rules. Rules that break the thread in the middle of the token by coincidence regex, insert edits and repeat the request.
• Sub-agents first class. The task tool spreads tasks over isolated workmen returning the result according to the scheme; they are monitored by Agent Hub (Alt+A).
• Advisor model. A reviewer who looks at each move and inserts notes or blockers.
• Joint sessions via /collab – with client “sealed” frames and QR/browser links.
• web search on 23 backends extracted to markdown from arXiv, GitHub, Stack Overflow, packet registries and security databases (NVD/OSV/CISA KEV).
• Internal URLs (pr://, issue://, agent://, conflict://) that make PRs, GitHub, and merge conflicts look like paths in the file system.
• **Puppeteer + host-level computer tool, memory/skills, code revision with P0–P3 verdicts and atomic commit partitioning.
• Inheritance of other people's configs. Picks up settings from Cursor, Cline, Codex and Copilot - "No migration script.".

### Model and routing roles

omp assigns different models for different tasks (ten “roles”): powerful reasoning models on PLAN / ARCHITECT, cheap and fast on TASK / SUBTASK, vision models on VISION, a separate one on COMMIT. There are chains of foulbacks and round-robin keys. This allows you to balance price and quality.

## Installation

# macOS/Linux
curl -fsSL https://omp.sh/install | sh

#Homebrew
brew install can1357/tap/omp

#Bun (recommended method)
bun install -g @oh-my-pi/pi-coding-agent

#Nix
nix run github:can1357/oh-my-pi

#Windows (PowerShell)
irm https://omp.sh/install.ps1 | iex

Source: bun setup, then bun dev.

### How much does it cost

The kernel is free and open (MIT). You pay only for the API of the models themselves – that is, for tokens from the selected provider. Plus, support for 50+ providers allows you to use existing subscriptions (coding plans), without starting a separate API billing. Minus – omp can spend ** more tokens** than more “lean” alternatives, which raises the bill.

## Better than omp

• IDE level of intelligence out of the box. LSP refactoring and a real debugger is something that most terminal agents lack, which is limited to search-replacement and print debugging.
• ** Fewer "misses" when editing.** Hashline gives a multiple increase in editing success on weak/cheap models.
• Not vendor-bound. 60+ providers and OpenAI-compatible endpoints vs. one model, one tool.
• MIT, "open all the way down" - you can read and change anything.
• Zero settings at the start. Works well right away, picks up other people's configs.
• Savings of tokens at the output (due to hashline) - on some models up to ~60%.

## That's worse

• Complexity and bloating. Part of the community considers the omp a "feature-loaded monster" - a monster with excess functions. If you need a small, predictable tool, that's overkill.
• May burn more tokens than minimalist agents - despite saving on edits, the total amount of context and office calls is higher.
• Controversial marketing. The loud statement "beats Claude Code" caused skepticism. In comparison, Standard Compute Claude Code leads in 4 of 6 categories (output quality, autonomy, reliability, convenience), and omp is ahead only in speed and price/value.
• The benefits of LSP/DAP depend on the language and the debuggers installed – these benefits do not work outside supported languages.
• **Memory confusion reports - after pulling upstream changes, the model is sometimes confused about what tools are available.
• **There are no independent benchmarks for overall accuracy of tasks - many numbers come from the author himself.

## What the reviews say

• Betterstack (technical analysis): distinguishes 4 architectural differences - LSP, DAP, role-playing routing models and hashline. The real difference is “most evident” in two scenarios: semantically correct refactoring and debugging through observation rather than logic.
• yuv.ai: presents the omp as "another approach" rather than "definitely better." The growth of 6.7% → 68.3% is about the format of edits, not about the model.
• AkitaOnRails (via Hashnode review): discreetly honest - *It works. It's not bad. It also did not make me say how did I live without this. Not bad. But it didn’t make me feel like I lived without it.
• gasatrya (Pi vs OMP, 2 weeks of testing): After two weeks, the author still returned to the minimalist Pi - omp is more powerful, but unnecessary functions and friction outweighed for his personal workflow.
• stork.ai: explicitly refers to the negative as "too many features/bloat" and that omp "may be too intense" for those who don't need everything at once.

## What do they compare

## Who does and who doesn't

** Suitable:** terminal developers who need an IDE level of intelligence - semantic refactoring, real debugging, auto-generation of commits; teams with complex workflow through sub-agents; those who want to freely switch providers and models.

Not suitable for: those who appreciate minimalism and predictability, who want a minimum consumption of tokens, to whom a “full combine” seems excessive – such people are closer to Pi, Aider or OpenCode.

## Outcome

oh-my-pi is an ambitious attempt to prove that the strapping around the model is as important as the model itself. Hashline editing and embedded LSP/DAP are strong, engineering-based ideas that really improve the quality of editing and debugging, especially on cheap models. The flip side is complexity, increased token consumption and marketing that overtakes independent measurements.

If you need the most “smart” and stuffed agent for the terminal and you are ready to understand – omp is worth a try. If you are for minimalism and control, look at Pi or other lightweight alternatives.

Sources: репозиторий oh-my-pi, omp.sh, betterstack.com, yuv.ai, gasatrya.medium.com, stork.ai, hashnode. *