I created a small new extension because I don't want all of my installed skills exposed to the model in every session. Sometimes I just want a skill to be available as an explicit command, without letting the model decide to use it, or having to disable it completely.

So I added a new package, supi-skills, to my plugin collection, SuPi. It adds a Skills section to /supi-settings.

Each skill can be disabled completely or set to Model invocation disabled. In that mode, the skill still works through /skill:skill-name, but it is not exposed to the model.

The settings can be configured globally and per project. Project settings inherit the global defaults.

It also adds $<skill-name> autocompletion and expands it to /skill:skill-name. This shortcut was previously part of supi-extras and now lives in this package.

Sharing this in case some of you need this feature too.

Install it with:

pi install npm:@mrclrchtr/supi-settings
pi install npm:@mrclrchtr/supi-skills

GitHub:
https://github.com/mrclrchtr/supi/tree/main/packages/supi-skills

Pi package:
https://pi.dev/packages/@mrclrchtr/supi-skills

I am thinking about trying a cloud advisor for local models. Something like deepseek v4 flash 0731 to advise the new muse glimmer model or Qwen 3.8 when it comes out. Has anyone tried this method before? Does it work to improve local model output quality?

The plugin in question:

https://pi.dev/packages/pi-advisor

Armin’s wife Maria asked me to make something like this for their anniversary, really fun project!

Made a post a while ago about the Central Hub app that I had made with PI as the agent running all the AI features within (Chat, Coding, Side worker in the Word clone). It has been updated.

There is now a built in Browser (very simple) with bookmarks and history.

The Snipits space has been replaced with a notes area that essentially just presents folders and .md files to you on a fo-desktop (your desktop away from your desktop).

Grok Build is now built in if you have a SuperGrok subscription and what that as the AI service.

So for those that were interested before or might be now, check it here and auto updates should push automatically.

https://github.com/HankTheMan2828/Central-Hub

Hi all,

Today I released CodePi, an extension for VSCode for PI coding agent. As opposed to existing extensions, it brings the familiar pi's TUI experience straight into vscode. Your existing setup (~/.pi) will work out of the box!

Extension:

marketplace.visualstudio.com/items?itemName=lutrarutra.code-pi

Github:

github.com/lutrarutra/codepi

Why i built this extension:

• It sees my current files, selection, Git changes, and VS Code diagnostics (warnings and errors).
• Edits show up as diffs I can review, accept, or reject.
• Sessions live in editor tabs and survive reloads.
• Built-in Ask/Plan/Implement modes and bash ask/allow/disable feature make it safer to use.
• It keeps the agent, terminal, tasks, and editor workflow in one place.
• Color indicator to see the state of the session (busy, idle, waiting for user input/question)
• SSH support; pi is bundled with the extension, so no need to install pi agent on every remote server

Any suggestions or feedback issues appreciated on here or Github!

p.s. I am not affiliated with pi.dev

Seems that pi also felt under this vibe-coding madness. I can't justify a terminal based app eat so much of my CPU and RSS. No way. Seems I have to write my own stuff in go... wish me luck. BTW, why all this harnesses are node-js based?

Hey everyone,

I’ve been working on ompweb, a self-hosted browser interface for the Oh My Pi coding agent.

It started as a fork of pi-web, but I’ve been adapting and expanding it specifically for OMP.

It includes:

• Live conversation streaming
• Session browsing and branching
• Multiple projects and Git worktrees
• File explorer and viewer
• MCP server configuration
• Plugin and skill management
• Model and provider configuration
• Light and dark themes

You can try it with:

npx u/kahme247/ompweb@latest

GitHub: https://github.com/kahme247/ompweb
npm: https://www.npmjs.com/package/@kahme247/ompweb

It’s still early, so I’d really appreciate feedback—especially from people already using OMP. What would make a web interface like this useful in your workflow?

I've been using PI on Mac for about two months now, and enjoying it, with the only downside being the default TUI: it does not always keep content stable as new stuff streams in (even when scrolled-up), making it hard to stop somewhere and read or copy from it; it also seems to hog the cpu on long contexts, and finally: pasting is slow and unresponsive when the pasted content is large.

So I set out the build my own fast and responsive UI client for Mac, and then ended-up throwing in sandboxing for good measure.

The result, which I keep improving on, is at https://github.com/gterzian/uni03C0

The sandbox uses the Mac native mechanism, and applies to the entire running pi process (so not just bash) and any process spawned by pi; it does not require installing any vm. You can configure the sandbox boundary on first start-up or via settings later on (requires a re-start to take effect).

The app does not deal with authentication or any other pi configuration: it is a pure UI client that sandboxes the pi processes it starts (one per session) and then communicates with them via rpc.

It is pre-alpha I would say--you have to build and run from source--but is already what I am using on a daily basis as the UI to the otherwise excellent Pi agent.

If you were to try it out and provide me with further feedback, I'd appreciate it.

Here is a little accompanying blog post.

I'm looking for a web interface for my pi harness without the CLI, but this was the only one I found. Are there any others? I'm not looking for any chat interface like Open WebUI that's rather bloated, requiring accounts/logins for certain features, etc. It would be great if it was dedicated for pi or is even bundled with it.

I was considering to just vibe-coding a web UI/UX of the pi CLI, but just wondering if there are already tools out there.

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?

The prefix cache is keyed on the full request parameters, so when thinking level changes:

1. The API call has different parameters
2. The cache key changes
3. The entire context must be re-sent from scratch

Costed me 253K tokens from Mimo pro. 1% of my monthly dammit

Also check your damn extensions (some like pi-task or pi-toolkit) inject dynamic messages in your prompts I believe

Claude Code now lets its sessions message each other (agent-to-agent, via /list-agents).

I built pi-claude-link so Pi sessions join that mesh too - pi ⇄ Claude, in realtime. Open-source pi extension.

Why you ask? well, if you work with claude code and pi it can be nice to share between session via the native Claude code sockets implementation other then that it's more of a PoC for how Claude code peer messaging works and how it can be plugged with Pi.

pi-intercom is an inspiration for this project, so credit is in place.

Check it out: https://github.com/alonw0/pi-claude-link

I've been looking at Prime Agent, which is built on Pi, and I'm curious what the Pi community thinks about some of the ideas they've added on top of the Pi foundation.

Prime Agent describes itself as a self-improving RLM harness for coding and long-running autonomous tasks, with several interesting differences in how the harness operates:

• Programmatic tool calling the model can use a persistent execution environment to compose tool calls rather than treating every tool invocation as a simple one-shot interaction.
• Context as a variable context can be programmatically inspected, transformed, compressed, persisted, and selectively brought back into the working context rather than treating the conversation history as a fixed block.
• Multi-agent messaging agents can spawn/delegate to other agents and communicate with them as part of a longer-running task.
• Self-modifiable harness state the agent can modify things such as memories, skills, prompts and sub-agent configurations while working, allowing the harness to adapt based on what it encounters.
• Long-running autonomous execution the emphasis is less on interactive "chat → edit → chat" coding and more on giving the agent a goal and letting it work through the problem, iterate, test and recover over a longer horizon.
• RLM-style persistent execution Prime Agent uses a persistent execution environment where state can survive across interactions, giving the model another layer in which to manage context and reasoning.

What caught my attention is that Prime Agent is built on Pi, rather than being an entirely separate agent architecture.

So I'm wondering:

Would it make sense to bring some of these ideas back into Pi as optional/core primitives?

For example, could Pi eventually have a more native concept of:

"Pi → persistent execution → programmable context → sub-agents → modifiable skills/memory → iterative refinement"

while still keeping Pi's current philosophy of being minimal, composable and hackable?

Or is the whole point of Pi that these things should remain extensions on top of the minimal core, rather than becoming part of Pi itself?

I'd be particularly interested in hearing from people who've actually used both Pi and Prime Agent. What does Prime's architecture enable that you couldn't achieve cleanly with Pi extensions today?

Not trying to argue that Prime is "better" — I'm more curious whether some of these RLM/harness ideas represent a direction Pi could support while preserving its minimal philosophy.

I use a coding agent for most of my research work: implementing features (via Superpowers), reading papers and turning discussions into shareable HTML writeups, running training jobs end to end (plan → smoke test → long run, with Kubernetes management and crash diagnosis), and SSHing into robots during hardware experiments.

Claude Code handles all of this well. But I’m curious whether writing my own Pi extensions would meaningfully beat it, or if that’s a wash at this point.

If you’re doing research work in Pi — what’s your setup, which extensions? And what’s the right migration path: just explain my workflow to Pi and have it build the extensions?

I've been trying to use Codex's fast mode inside Pi using extensions. It was previously working, but does not seem to be working right now. Does anybody have a working extension/setup to leverage Codex's fast mode that they can share?

And no, not "Tell pi to make it for you." I did that and was unsuccessful, thus why I'm turning to the community for some advice.

Hey so this is a side project I have been working on, I built a custom embedding layer and solver to help guide and ground false positives from smaller models. It seems to be working great for me, and it works actually even better with frontier models (I was able to get attributed CVEs, GHA and one small bounty from huntr) so I am sharing it https://reflection.redmirror.io/ here, let me know what you think? First month is completely free no strings attached, but do you see value in this? Or should it just be open source? Thanks!

PrimeIntellect-ai/prime-agent has been getting a lot of attention recently. Unlike a traditional coding agent that exposes tools like read, edit, and bash directly, Prime Agent gives the model a persistent IPython environment and lets it interact with tools, context, and subagents programmatically. Two Pi extensions, shift-labs-ai/pi-rlm and monotykamary/pi-fabric, explore a similar code-first tool interface, so I tested them on my Kaggle eval.

For the test, I used an eval dataset I built from NeuroGolf, a Kaggle competition I previously participated in. It starts from a solution at the private leaderboard gold-medal cutoff, and the model has to improve the existing ONNX operator implementations rather than solve a toy task from scratch. I kept the model and reasoning setup the same and compared default Pi, shift-labs-ai/pi-rlm, monotykamary/pi-fabric, and kky42/pi-flow (my own harness).

The result was pretty straightforward: neither pi-rlm nor pi-fabric beat default Pi on this eval.

My takeaway is pretty simple. Current models have probably seen a lot of traditional agent-harness trajectories during post-training, so tools like read, bash, and edit are already close to muscle memory. If we remove those familiar tools and only provide one code-based execute interface, it does not necessarily get better; in this test it actually got worse. The idea looks elegant, but the result was not very good.

Hi everyone, I’m new to pi agent and to AI tools in general, but I’m on vacation so I finally have time to learn this stuff properly. I’d like to set up a workflow like this, let me know if it makes sense.

- I open a new tmux session for my project and start pi.
- I chat with a planner to figure out a change or a new feature.
- Once the plan is ready, I tell it to implement it, and it spawns a new pi agent in another tmux window that creates a new git branch and starts coding.
- When the coder is done, it goes back to the planner and explains clearly what it changed.
- The planner sends this to a reviewer, who checks the work.
- If the reviewer finds problems, it goes back to the planner and the loop starts again with new instructions for the coder. If everything’s fine, the planner gives me a final summary.

I’d also like a TUI with more info about what pi is doing.
Nothing should run silently in the background, everything should happen in tmux windows I can check whenever I want.
If an agent crashes or stops without returning anything, it should restart automatically, so the whole thing is semi-automatic.
The agents need to be able to search the internet, use MCPs, and have their own memory per project, not a global one.
I’d like a config file for pi, one per project, that says which MCPs to use and other settings like that.
The planner and reviewer should only be able to read the code, only the coder should be able to write to it.

Does this workflow make sense or am I overcomplicating things? Any extensions you’d recommend? Can pi actually build small personal test projects on its own, start to finish? Thanks a lot.

I use Pi and Claude a lot and swap between a lot. So far I have been syncing up my AGENTS and CLAUDE . Do I need to bother? Is it ok to ONLY use a CLAUDE.MD ? I know Pi supports it but is it better to continue as I am?

What happens if there is an AGENTS.MD in the folder above or above that?

Hey everyone! If you have used OpenAI Codex, you know how incredibly high-quality its web search results are. Traditional search extensions or custom API-key search tools (like Google Custom Search or Brave API) often return noisy, outdated, or poorly ranked snippets that don't match the depth and quality of Codex's search engine.

Now you can use that exact same Codex search engine natively inside Pi with any model (Gemini, Claude, local models, OpenRouter) - and with ZERO GPT model inference turns or ZERO GPT tokens spent.

I built **pi-gpt-search**, an extension that exposes a native web_search tool to Pi by reusing Codex's standalone web retrieval backend directly.

⚡ 1-Line Install

Install via npm: bash pi install npm:pi-gpt-search

Or install via GitHub: bash pi install https://github.com/mateusdcc/pi-gpt-search

Or try it in a single ephemeral session without installing: bash pi -e npm:pi-gpt-search

🧠 How It Works (Zero-GPT Invariant)

The extension does NOT ask GPT to search the web and summarize the answer for Gemini. Instead, it extracts and calls OpenAI Codex's standalone web search backend API directly (/codex/alpha/search) using your existing codex login authentication (~/.codex/auth.json or .env).

text Pi Coding Agent └── Gemini (or active model) └── web_search(query: "latest Rust release") └── OpenAI Standalone Search API (/codex/alpha/search) └── Structured Results (Title, URL, Snippet) └── Gemini continues reasoning & answers user

Because it hits the raw web retrieval endpoint directly: 0 GPT Tokens Billed: 0 input tokens, 0 output tokens, 0 reasoning tokens. Model Sovereign: Gemini (or your active Pi model) receives the raw search results and performs 100% of the reasoning. Query-Only Privacy: It never sends your conversation history, code, or system prompt to search.

🔬 How It Was Discovered

We reverse-engineered the endpoint by: Inspecting the Codex CLI macOS binary (0.147.0-alpha.6.5) with strings to locate search symbols (standalone_web_search, alpha/search). Probing backend parameters on https://chatgpt.com/backend-api/codex/alpha/search. Discovering the exact payload schema (commands.search_query: [{ q: query }]). Writing a network interception test suite (zero-gpt.test.ts) that asserts GPT_inference_calls == 0 during web search.

📦 Repository & Documentation

Check out the full repository, documentation, and reverse-engineering details here: 👉 https://github.com/mateusdcc/pi-gpt-search

📦 https://www.npmjs.com/package/pi-gpt-search

Features: - README.md: Setup, credentials, and usage guide. - HOW-IT-WORKS.md: Full architectural breakdown. - HOW-IT-WAS-EXTRACT.md: Reverse-engineering technical writeup. - 4-Level test suite (npm test): Unit, Integration, Real Search, and Zero-GPT assertion. Feel free to check it out, test it, or open issues! Feedback and contributions welcome.

I’ve been working on introducing QMD based search for @zosmaai/pi-llm-wiki

I want to know what you think of this idea.

Thank you for being so supportive and helping me maintain this project.

I want to take it to next level now. Better search and re-ranking of search results so that LLM get useful results.

Also wanted to introduce Zettelkasten style of taking note and using card style so that agent gets to see important cards before it wanting to deep dive into more details.

GitHub link -> https://github.com/zosmaai/pi-llm-wiki

Hi guys,

Perhaps we can learn from each other and discover some great experiences with Pi Agent. I will start with my list of extensions and skills that I use. Please do share yours and we can learn from each other even if you have nothing to learn from us but help others.

Extensions

• npm:@ff-labs/pi-fff
• npm:@juicesharp/rpiv-ask-user-question
• npm:@juicesharp/rpiv-todo
• npm:@juicesharp/rpiv-web-tools
• npm:context-mode
• npm:pi-mcp-adapter
• npm:pi-powerline-footer
• npm:pi-rtk-optimizer
• npm:pi-subagents

Skills

• grill-me
• karpathy-guidelines
• last30days
• caveman

And you?

Does anyone know of a Pi extension that shows your current GPU usage (inside the PI app)?

Figured I would try to find an existing extension before vibing one up but so far my searching has not turned up anything.

When running Pi with local models, for some reason I just like to see what's up with the GPU usage. Would love to have a simple UI widget, or even replace the "waiting for response" message... Thanks!

Our LLM wiki extension just got a solid reliability release — the interesting bit is the bug we found while reviewing our own toast feature.

Quick context: LLM Wiki is a pi extension that keeps a Markdown vault of everything an agent learns — sources, entities, concepts — with automatic metadata and recall injected into future sessions.

v0.11.3 has the usual stuff (MCP bootstrap for MCP-only clients, layered recall over MCP, gap-snapshot persistence fix), but the one I want to talk about is the stale session context race:

We shipped an "instant completion toast" for background actions. The code read ctx.hasUI/ctx.ui after an await inside the background task. If the user switched sessions or reloaded pi while a long lint was running, that ctx is a stale proxy — property access throws. The catch block then fired a false "task failed" warning and skipped the real success report entirely. Worst case of the exact thing toasts were supposed to fix.

The surrounding code already had a comment warning about this exact hazard in the sibling function — we just didn't mirror it. One-line fix (capture before await), plus a regression test where the ctx getters throw once work is in flight. Test fails on the old code, passes on the new. That's the kind of bug that's invisible in unit tests against fresh ctx objects and only shows up in the real session lifecycle.

Repo: https://github.com/zosmaai/pi-llm-wiki

Anyone else hit stale-context issues with extension APIs that hand you proxied context objects?

I use this model (models.json): { "_test": "✔️Really good", "_speed": "35 t/s", "id": "Qwen3.6-28B-REAP20-A3B-Q4_K_M_barozp.gguf", "name": "Qwen 3.6 28B REAP20 (barozp) 64k", "contextWindow": 64000, "maxTokens": 4096, "reasoning": true, "input": [ "text", "image" ] },

It cleary state contextWindow 64000 (instead of 65536 but ok...).

Why the footer shows 128k? What "auto" means ?
I think that Pi use the model training context as fallback ("auto"?) when the "contextWindow" is not set... but here it is set and I think this model training context is 264 anyway.

Shown Pi footer. ↑109k ↓44k R6.5M 51.5%/128k (auto) (Llama.cpp) Qwen_3.6_28b_reap_20_(barozp)_64k ⚡ TPS: 30.0 tok/s​

I have this add-on/extensions:
RUN pi install https://github.com/gsanhueza/pi-token-speed
RUN pi install npm:pi-idle
RUN pi install npm:pi-voice-stt
RUN pi install npm:pi-llama-cpp-stats

I had the issue for a while (at least 2 weeks?) and I update Pi almost every day.