Introduction
If you've been watching the coding agent space, you already know the pattern: a slick GUI wrapper around a model, a chat panel glued to your editor, and a pricing page that pretends the model isn't the whole product. OH MY PI (shipped as omp) is taking a different swing. It's a terminal-native coding agent written in Rust, with real IDE plumbing — LSP for completions and diagnostics, DAP for debugging, subagents for parallelism, and a memory layer they call hindsight that's supposed to learn from past sessions.
That's a lot of ambition for a tool most people haven't heard of yet. I've spent enough time with terminal agents like OpenHands and mini-swe-agent to know which features matter in practice and which ones look great in a launch tweet. Here's an honest read on where omp lands.
Key Features
LSP integration in the terminal
This is the headline feature for me. Most terminal agents are flying blind — they read files, pattern-match, and hope. OH MY PI speaks the Language Server Protocol, which means it gets the same completions, go-to-definition, and diagnostics your editor gets. For typed languages especially (TypeScript, Rust, Go), this is the difference between an agent that hallucinates function signatures and one that actually knows what's importable.
DAP debugging from the agent loop
The Debug Adapter Protocol support is unusual. The agent can set breakpoints, step through code, and inspect runtime state inside the terminal session. In practice this matters for the gnarly bugs where reading the code isn't enough — you need to see what the value actually is at line 47. Most agents punt on this and tell you to run the debugger yourself.
Subagent orchestration
omp can fan out work to subagents running in parallel. Useful for the kind of task where you'd otherwise sit through a 20-minute serial loop — bulk refactors, multi-file migrations, exploratory searches across a large repo. Conceptually similar to what Claude Code's Agent tool does, but native to the runtime instead of bolted on.
Hindsight memory
The pitch: the agent remembers what worked and what didn't from previous sessions, so it doesn't re-litigate the same mistakes. This is the feature I'm most curious about and most skeptical of. Memory in coding agents is hard — too little and it's stateless, too much and it confidently applies stale knowledge. Worth testing on a real codebase before believing the marketing.
Time-traveling rules and plan mode
Structured workflow primitives. Plan mode lets you scope the work before execution; the rules system lets you constrain behavior conditionally. If you've used Cursor's rules or Claude Code's CLAUDE.md, this is in the same family.
Rust-native engine
The whole runtime is Rust, not a Node.js or Python wrapper calling out to a model. The practical effect: low-latency agent loops, smaller memory footprint, and fewer of the "why is my CLI eating 2GB of RAM" surprises.
Pricing Breakdown
| Plan | Price | What you get |
|---|---|---|
| Free | $0/mo | Core coding agent, terminal interface, LSP integration |
| Pro | Custom | Subagents, DAP debugging, hindsight memory, time-traveling rules |
The free tier is generous enough to actually evaluate the tool — LSP alone makes it useful. The Pro tier is where the differentiated features live, and "Custom" is doing a lot of work in that pricing cell. At time of writing there's no published Pro price, which is a yellow flag if you're planning around a team budget. Expect that to firm up as the product matures.
Pros
- Full IDE tooling without the IDE. LSP plus DAP in a terminal agent is rare. If you live in tmux and vim, this is the closest thing to having Cursor's intelligence without Cursor's UI.
- Fast. Rust runtime means the agent loop itself isn't the bottleneck. Latency you feel is mostly the model, not the orchestration layer.
- Hindsight memory is a real differentiator. Most coding agents start every session from zero. If hindsight delivers on the pitch, it compounds over weeks of use.
- Subagents are useful, not just a buzzword. Parallelism actually changes what's tractable in a session — bulk migrations stop being an afternoon.
Cons
- Terminal-only. If you're a GUI-first developer or your team isn't comfortable in a shell, this isn't your tool. Cursor or GitHub Copilot will be a softer landing.
- Very early stage. Limited docs, small community, no public track record. You're an early adopter, which means you'll hit edges no one has documented yet.
- Pricing is opaque. The Pro tier being "Custom" makes it hard to plan, and it suggests the product hasn't decided whether it's a developer tool or an enterprise sale.
- The competitive landscape is brutal. Cursor, GitHub Copilot, Replit, OpenHands — these are well-funded products with millions of users. omp has to be meaningfully better, not just different.
Who Is It For
omp is built for a specific kind of developer: terminal-native, opinionated about tooling, comfortable being early on a tool. If you SSH into remote machines to code, if you've already written your own dotfiles for three coding agents, if you treat your shell as your IDE — this is interesting to you.
It's not for: developers who want a polished out-of-the-box experience, teams that need predictable pricing and SLAs, anyone who prefers a GUI for debugging. For those use cases, the incumbents are safer bets.
Verdict
OH MY PI is a technically ambitious product. The combination of LSP, DAP, subagents, hindsight memory, and a Rust runtime is genuinely differentiated — none of the bigger players ship all of that in a terminal-native form factor. As a thesis, it's the right one: agentic coding shouldn't require a GUI IDE.
As a product today, it's early. The docs are thin, the community is small, the Pro pricing isn't public, and it's competing against entrenched incumbents with order-of-magnitude larger user bases. The features are real, but the surrounding experience needs time.
Recommendation: Try it on the free tier if you're a terminal-native developer. The LSP integration alone is worth the install. Hold off on Pro until pricing is published and the hindsight memory has more public track record. Worth watching closely — if omp executes, this is what terminal coding looks like in 2027.
Rating: 6.8/10 — strong concept, real technical chops, early-stage rough edges.