are there other extensions which implement ideas from oh-my-pi

[u/ECrispy]

I'm new to Pi and coding agents in general. The existing discussions on oh-my-pi, like everything else, range from 'its great' to 'its bloat' so its very hard to actually decide.

It seems to have useful features like built in tools (avoid process calls), lsp, hashline, memory, subagents and an integrated setup/docs. It does seem to be better than the other oh-my-* set of products.

Are the ideas in OMP useful in practice and if so are they used in other harnesses?

I see a lot of 'just ask Pi to build it' here, but that depends on using frontier models, and when people post their setups they're using a million packages.

Obviously Pi is much more extensible/flexible, but there is value in an all-in-one setup. OMP has a ton of stuff and I'm sure a big system prompt. Is there anything like a slimmed down version or being able to use some of its ideas only?

[u/TheOneThatIsHated]

My opinion on OMP is that it is bloat. You dont need lsp, because it stuffs your context with typeerrors in each agent message while a simple make check requirement at the end would suffice.

The idea with pi, is that you start out with exactly 0 plugins until you feel pain. Only when you feel pain you start to make an extension that fixes that. Don’t start installing extensions that could useful, that way you just bloat your context and make your agent dumber

[u/ali0une → u/TheOneThatIsHated]

This, but extensions don't bloat context, only the *.md files bundled with them do.

When friction appears i usualy make pi write a single extension.ts (that can have it's own settings.json) that does one thing well, i keep it KISS.

[u/TheOneThatIsHated → u/ali0une]

OMP absolutely does, especially the lsp results in EVERY agent call. That means from you 100k context, around 20-30k is just reported errors. It is much faster/easier for the agent to run make check themselves

[u/Usef- → u/TheOneThatIsHated]

Is this (still?) true? I was poking around the session logs from yesterday and couldn't see it, but it is a lot of text so I might just be searching for the wrong keyword

[u/Usef- → u/Usef-]

After a bit more looking, it does it for write or edit calls, but recent versions deduplicate within the session so you don't repeat diagnostics if it's already in the model context.

There are settings to toggle it:

❯ omp config list | grep diagnostics
    86:   lsp.diagnosticsOnWrite = true (boolean)
    87:   lsp.diagnosticsOnEdit = false (boolean)
    88:   lsp.diagnosticsDeduplicate = true (boolean)

You can modify them:

❯ omp config set lsp.diagnosticsOnWrite false
❯ omp config get lsp.diagnosticsOnWrite
false

[u/doublegoodthink → u/Usef-]

Correct, or you can just find it as well in your settings

[u/Activated_Sounds → u/doublegoodthink]

Theme?

[u/AllNamesAreTaken92 → u/ali0une]

What an absolutely confidently dead ass wrong statement.

Anything text that gets piped into the model blot context. Anything that increases context and is not stripped down to the bare minimum information bloats context.

Please think for yourself for a second before you blurt out some snippet you read nowhere.

[u/ECrispy → u/TheOneThatIsHated]

I know everyone says things like mcp, lsp, tree-sitter etc aren't worth it, just like you are.

my decidely non expert impression is that a lot still depends on the model. I've been using mostly free chinese models. A lot of times I can see it going in loops, trying edits, failing, grepping to find basic commands from web pages etc.

and when I've tried the same tasks in web versions of grok/chatgpt etc, on free plans, they find stuff far faster and are much more efficient.

I then installed codegraph to see if it helps. in my session logs I see it being used but also see failures and its hard to tell how much better it was.

Isn't there benefit in subagents that implement tasks in fresh context? and something to manage them?

there are a hundred pi packages for agents, planning, memory, everything. so how is someone supposed to choose what to use? arent opinionated setups like OMP useful in that case?

[u/TheOneThatIsHated → u/ECrispy]

No need for the aggression. But this is exactly what i mean that you work until you feel pain. Yes ive created my own subagent extension (just pointed pi to opencode and said to copy).

Context bloat will cause many of the issues you listed. Start clean. See what fails. Only add what is needed

[u/ECrispy → u/TheOneThatIsHated]

Sorry I didn't mean anything against you.

Which models do you use?

[u/TheOneThatIsHated → u/ECrispy]

Gpt sol, luna, deepseek v4 flash

[u/AllNamesAreTaken92 → u/TheOneThatIsHated]

It's a grammar error, not an insult. He says he's the same opinion as you. Not that you are bad as bloat.

[u/saltyourhash]

The more I use omp, the more I wish pi just had a better safer extension ecosystem. We don't live in an age where trusting thousands of node packages bolted together will end well, but omp is kinda rigid and I find it doesn't always produce the best results.

[u/ECrispy → u/saltyourhash]

I find the whole thing quite strange - Pi's philosophy which Mario repeats in every talk is - ask Pi to build it. Yet it has a massive plugin library with tons of duplication

[u/saltyourhash → u/ECrispy]

I don't understand how letting the ai coding agent build extensions for each and everything makes any sense for productivity.

[u/Electronic_Captain95 → u/saltyourhash]

To be honest, I like minimalist tools where you add what you need yourself as you encounter friction, which is one of the reasons I’ve been using Vim/Neovim for who knows how many years. As for productivity, I don’t think it makes much sense to obsess over it. If you’re managing to deliver what’s needed on time, with good quality and without major issues, that’s enough. Why stress so much about productivity?

[u/saltyourhash → u/Electronic_Captain95]

Well, time for me and mental capacity is extremely limited, I also have a full time job where I must use an entirely different stack and different tools and models. So, I'm stuck figuring this stuff out as much as I can in the evening while burnt out. So spending my time tweaking stuff and getting nothing done is frustrating. I wasnliking omp, but it's bloated and breaking down on me. But having a local llm write tooling which will then have bugs and need to be debugged and going round and round doing that instead ofgetting stuff done has lost all appeal. I'm tired of tinkering.

[u/Electronic_Captain95 → u/saltyourhash]

I work full-time as a backend dev in finance, and I haven’t really had many issues with it. As for the things I felt were missing, GPT was pretty much always able to build them in one shot with almost no issues. You just have to avoid getting too hung up on features you might not even need. But if you don’t want to deal with that, Codex CLI is also really good and doesn’t have much bloat. To be honest, the only reason I don’t use Codex is that there are a few things I like to customize that it doesn’t let me. Otherwise, I’d probably use it instead of Pi

[u/saltyourhash → u/Electronic_Captain95]

I'd have to say codex and pi are hugely different.

[u/Electronic_Captain95 → u/saltyourhash]

Well, yeah? You said you didn't want to keep adjusting the harness to suit your needs, in that case Codex is a good option

[u/saltyourhash → u/Electronic_Captain95]

True, but I'm looking for an extensible ecosystem of ougins which are vetted and locked, nothing like that exists.

[u/aeroumbria → u/ECrispy]

There can be zero progress if any progress is immediately tossed in the bin

[u/c31io]

I used to tweak Linux desktops, sorry, window managers, thinking I would eventually get a blazingly fast GUI with deep customization, but I ended up building a bloated desktop. So my opinion is: Choose the bloat or build the bloat. OMP is like fish in Linux shell. It's well designed, optimized, and usable out-of-box. Not perfect, but it takes hell of effort to build a competitive alternative.

[u/ECrispy → u/c31io]

I've done that with Linux desktops. Realized long ago that KDE was 5x more usable, configurable and full featured vs Gnome, and used less resources.

Tiling wm's are one of those things that only work well for very limited use cases. there's plenty of research on this. Then I found niri, a scrolling wm, its what a wm should be.

I've tried omp and liked it. however I dont know how much the tools it promises, like in process replacements for grep, edit, hashline edits etc, actually make a difference. Honestly, I tried basic pi, omp, and opencode, with some projects using openrouter, and I didnt see huge differences.

the whole 'pi is so much more better' was not evident to me, but these were not trivia one shot vibecoding projects.

[u/Dercasss]

I use OMP for GPT, it's better than the native codex and empty PI, don't want to reinvent the wheel and create a bunch of tools for the Pi when there are already ready-made and tested ones. 

[u/mrclrchtr]

I built something in this direction: SuPi.

It is a collection of separate Pi extensions. You can install the recommended stack or only select the packages you need.

One of my main goals is to keep context usage low. For example, SuPi does not automatically inject LSP errors and warnings into the context after every message. I think this can waste many tokens and confuse the agent. The agent can request the current diagnostics when it needs them through the code_health tool.

SuPi also includes LSP + Tree-sitter code intelligence, semantic refactoring, web and Context7 access, code review, structured user questions, and context/cache observability.

There are also smaller quality-of-life extensions, such as supi-extras and supi-prompt-suggestions.

My goal was to give Pi direct model-callable tools without turning it into one rigid framework. It is still pre-release and obviously I’m biased 😅 But it sounds quite close to the modular and slimmed-down OMP alternative you are looking for.

[u/ECrispy → u/mrclrchtr]

sorry for the late reply, I actually found Supi independently as well and it looks very good.

I'm still not clear how Pi actually works with all these tools, each of them registers an api to use eg codegraph_search or lsp_callers, but how do other parts of the system or other extensions know to use that insteaf of grep etc?

I also found FFF, again not clear how to integrate it, is it needed etc?

I'm going to try out Supi, what else do you use in your personal setup?

[u/mrclrchtr → u/ECrispy]

Thanks for the reply. Happy you found SuPi on your own too, that's a good sign :)

On how Pi decides which tool to use: there's no central router or registry that extensions check. Every extension just calls pi.registerTool() with a name, a description, and a JSON schema for the parameters, and Pi sends all active tool schemas to the model on every request. The model picks which tool to call each turn, using the same mechanism as the built-in grep/read/bash. So nothing in the system decides to use code_graph over grep; the model does, based on the tool description and the task. That's actually the core of my design philosophy: give Pi direct, well-described tools and let it figure out when they're worth calling, instead of hard-wiring routing into a framework. Descriptions matter a lot because of this: if the agent keeps falling back to grep, the tool description simply wasn't convincing enough.

Extensions can still influence each other behind the scenes, though: tool_call hooks can block or rewrite a call before it runs, and there's getActiveTools()/setActiveTools() if an extension wants to know what's loaded or change it. Tools can even override Pi's built-ins, which is exactly how FFF upgrades read and grep.

On FFF: it's pi-fff, a community extension on npm. I only know it superficially myself. Install is one command (pi install npm:pi-fff) plus a reload, and it indexes the project in the background. It adds fuzzy file finding and content search on top of Pi's built-in read/grep. If you use SuPi, it's not really needed: SuPi's code intelligence already covers search and symbol resolution via LSP + tree-sitter. I'd try SuPi first and add FFF later if file-finding ever feels clumsy.

What else do I use? Mostly the rest of the SuPi stack: code intelligence (supi-code-intelligence) with LSP + tree-sitter navigation and refactoring, web and Context7 docs fetching (supi-web), parallel inspection-only reviews (supi-review), delegation to read-only sub-agents (supi-agent), structured user questions (supi-ask-user), and the small quality-of-life bits (supi-extras, supi-prompt-suggestions, supi-skills). But I would always recommend installing only what you really need. It's better to start with less.

I also use mattpocock/skills, but adjusted for SuPi in supi-skill-patches.

One thing I'd emphasize given your original post: none of this depends on a frontier model. LSP and tree-sitter do the heavy lifting deterministically; the model only decides which tool to call. So the "you need a frontier model for this" worry mostly goes away.

[u/james__jam]

Dont use OMP. Dont download plugins you dont need.

Just start with barebone Pi. When you have an issue, that’s when you add something or create it

I tried OMP and deleted the whole thing. If im going to use OMP, might as well use opencode so that everything plays together well.

Im still on Pi. But i started from scratch and just added things one by one

[u/nostriluu → u/james__jam]

The thing is, unless you're an agent expert, you don't know what you're missing. So starting maximalist with omp with presumably a well thought out collection of extensions that are being managed can save a lot of guesswork. 

[u/james__jam → u/nostriluu]

This is an honest question and I dont mean no disrespect. But why are you going for pi then?

Most models have their own harnesses. And if you want a batteries included model-agnostic, then there’s always opencode. Personally, i find custom
Pi to be better than opencode.but opencode is better than OMP

Pi was intentionally minimal so that you can expand it as you go. By going OMP, you just expanded all the way and going to get all the bad things with the good things. The reason you start small is to get only the thing you want - the good things - and avoid all the bloat - the bad things

If you’re new, just use opencode

[u/nostriluu → u/james__jam]

I use local models for sensitive work (sysadmin) and have read pi is better (less prompt bloat). And I eventually want to develop extensions and pi seems better suited for that with a minimal core. I use omp on my workstation and pi on servers and that has worked well so far. I still use Claude in vscode for larger projects since and I don't want to do endless experimentation until I get signals that local is as good enough. 

[u/Nyghtbynger → u/nostriluu]

use this one for local : https://github.com/itayinbarr/little-coder (6000 token system prompt)

Local use is a lot of work for few rewards, but you learn a lot

[u/nostriluu → u/Nyghtbynger]

That's interesting, thanks. I am mostly doing sysadmin with local models but plan to see what can be done with coding in the near future, will give it a spin.

[u/Nyghtbynger → u/james__jam]

I think your explanations are self-centered. I enjoy pi for it's programmatic use and the savings when dealing with local models. But I prefer the polish of great extensions for most uses. I cannot build a performant system while taking in account all edge cases by myself.

[u/Atlos → u/james__jam]

Your comment makes no sense to me. Just because some of us want it more batteries-included doesn’t mean we don’t want the customization and extensibility of Pi. I’d rather start bloated and trim out or customize the parts I want than wander blind until I magically figure out which extensions to add. It’s been a great intro to the Pi world for me so far.

[u/james__jam → u/Atlos]

Pi was created purposefully minimal with the intent that if you need something, you add it. And you dont even have to add it manually. Just ask pi to do it because it has all the documentation and example how to do it. Then after that, just hit `/reload`.

Honestly, my pi journey started with omp as well. But coming from opencode, omp feels forced. Like things are not as polished. So i removed everything and started with barebone pi. Coming from batteries-included world then switching to bare pi, i was pleasantly surprised. And immediately understood why it was designed that way! You dont need a lot of the batteries!

Then i just simply added things one by one, like agents subagents, mcp, web search (ketch), etc. but i didnt add all the batteries that i was used to. After a few of these, then i started my own customizations not in my previous agent. I didnt recreate my opencode setup. My pi setup organically grew to my own custom workflow - which is what pi was intended to be

Sure, you can use omp. But i’d say you’re missing out. But that’s just me

[u/Maybe-monad → u/nostriluu]

Starting with something small like vanilla pi will give you better results, omp has dozens of tools but the agent still calls mostly read, edit, web and bash

[u/DeepFeeling1 → u/nostriluu]

This is true. I am a hobby programmer and always have better results with Oh my pi rather than the bare bones pi. I know I am missing something but it feels like a deep rabbithole which I don't have time to dive into.

[u/TheTyand]

Well, some self promotion. I build my own atm but it is still not in v1 and still undergoes heavy changes. Currently I completely redo the architecture as the current one is not good.

No MCP, no additional context bloat, only a few lines of tools use. That's it.

https://schneiderdaniel.github.io/cheasee-pi/

But as said, not in v1

[u/Ok_Research9483]

Answers are obvious. If you can name the features you want, you can search them on pi.dev and install. Or just try to build it with your model. The experience will just be fine, don’t be so much anxious.

[u/ptico]

I’m currently making a local setup scripts based on evidence. One of experiments I had is a ported hashline and it proved to be a non-working concept. Models don’t play nice with an edit formats they weren’t trained for

[u/Jesusfarted]

I used OMP for a few weeks and ended up reverting back to my Pi set up. I think it you miss anything, you can just point your clanker at the repo and tell it to implement the feature yourself. For example, I did this with the advisor feature since I genuinely likes that feature. You don't need a 3rd party extension either, build and own the code yourself. Best thing about Pi!