“Oh My Pi”/OMP is trying to build a coding-agent “operating system”, rather than just another coding chatbot.

I’ve been looking at Oh My Pi (OMP), and what I find interesting about it is not really the number of features it has. A lot of coding agents already have things like subagents, MCP, code search, terminal access, and so on. What stands out about OMP is the way these pieces are put together. It feels less like “another coding agent” and more like an attempt to give an AI agent the same kind of semantic, runtime, execution, memory, and orchestration primitives that an IDE has.

The first thing that caught my attention is hashline editing. OMP does not primarily rely on the usual “here’s a chunk of old text, replace it with this new text” editing approach that you see in tools like Claude Code or Cursor. Its edit tool uses hash-anchored lines, so the model can refer to specific lines using their hashes when making changes. This sounds like a small implementation detail, but I think it matters a lot for agent reliability. One of the most annoying failure modes of coding agents is not necessarily that the model doesn’t understand what it needs to do, but that it makes the edit in the wrong place or applies an edit against stale context. Hashline editing is an interesting attempt to solve that problem at the tool-protocol level.

Another feature I find pretty interesting is persistent Python/Bun execution that can call the agent’s own tools. This is more than just giving the model a Python or JavaScript tool. Code running inside the persistent Python or Bun workers can call back into the agent’s tools, such as read, search, and task. So you can have a persistent computational environment that is also connected to the agent’s own capabilities. That starts to feel more like giving the agent a programmable workspace rather than just handing it a collection of independent tools.

Then there’s autonomous project memory. This is particularly interesting compared with the way Claude Code uses something like CLAUDE.md to persist project instructions and knowledge. CLAUDE.md is useful, but fundamentally it is a document that humans or agents have to maintain. OMP takes a more autonomous approach to memory, where the system can accumulate durable knowledge from previous sessions and bring relevant knowledge back into future sessions. I think this is a much more interesting direction for long-running coding agents. If you’re working on the same codebase for weeks or months, you don’t necessarily want to keep manually writing down every convention, architectural decision, or weird project-specific fact. You want the agent to gradually learn the project.

The context and compaction machinery is another area where OMP seems to take long-running agents seriously. It has things like snapcompact, handoff, shake, and context-full, which are different mechanisms for dealing with context pressure and keeping an agent going over long sessions. This matters because the experience of an agent working on a small bug for ten minutes is very different from an agent working on a large migration for several hours. OMP seems much more explicitly designed for the latter. Its snapcompact package is particularly interesting because it is a specialized context-compression system rather than simply throwing the entire transcript into another LLM and asking it to summarize everything. The idea is that context management itself becomes part of the agent architecture.

Multi-agent orchestration is also built into the workflow rather than being treated as a checkbox that says “yes, we have subagents.” OMP has concepts like orchestrate and workflowz that are designed around actually coordinating multiple agents and turning them into a workflow. That’s an important distinction. There is a big difference between having a button that launches another agent and having an agent system that can structure a task into research, implementation, review, verification, and other stages. The latter starts looking more like an actual agentic development environment.

Another thing I like is how provider- and model-agnostic OMP is. It doesn’t seem to assume that there should be one model doing everything. You can define model roles, for example:

modelRoles:
  default: claude-sonnet
  smol: gpt-4.1-mini
  slow: claude-opus
  vision: gemini
  advisor: claude-sonnet

That opens up a much more interesting way of thinking about model selection. You might use a small and cheap model for routine work, a stronger model for difficult reasoning, a vision model for image-related tasks, and another model as an advisor or second opinion. The agent architecture doesn’t have to be tied to a single model provider. Given how quickly models change, I think this is an increasingly important property.

I also like that OMP doesn’t necessarily ask you to throw away all the tooling you’ve already built around other coding agents. It can discover existing configuration from things like .claude, .cursor, .windsurf, and other environments, including rules, skills, and MCP servers. That’s a pretty pragmatic decision. If you’ve already spent months building up your agent configuration, switching to another agent shouldn’t mean rebuilding everything from scratch.

And finally, the extension system is unusually deep. OMP extensions aren’t just custom prompts. They can access the same tool API, slash-command registry, hotkeys, and TUI primitives used by the built-in functionality. That means the system is extensible at a much deeper level than simply adding another instruction to the model. You can actually extend the agent’s environment and behavior.

This is probably the part that ties everything together for me. If I ask, “What happens when the coding agent has direct access to the same semantic, runtime, execution, memory, and orchestration primitives that an IDE has?”, OMP seems to be unusually aggressive about pursuing exactly that question.

And that’s why I find OMP interesting. It’s not necessarily that each individual feature is something nobody else has ever done. Cursor has a very sophisticated IDE, Claude Code has a strong agentic workflow, and both can be extended in various ways. What feels different about OMP is the underlying direction: instead of building an AI assistant around a handful of tools, it seems to be trying to build a more complete operating environment for the coding agent itself.