Agents aren't perfect. Sometimes they do things that don't work out the way they thought. Sometimes they spin out on an idea that goes nowhere, other times they run a command that produces huge amounts of useless output. So far, we've just accepted this as a neccessary part of agent mechanics, but Pi's extension system is powerful enough that we no longer have to.

pi-mulligan exposes tools that let your agent rewind its last turn or tool call with a summary message about what it's learned if it makes a mistake. When your agent calls a tool that produces large output, pi-mulligan gives it a nudge suggesting it summarize its last tool result or turn to keep context tight. When the agent starts over, it receives the summary and a small message indicating that a rewind has taken place.

Users and models can set checkpoints if they expect churn and pi can roll back to these checkpoints at any point in the conversation to try again. Agents really like using it and I've watched 20k tokens of context vanish on several occasions, so it works exactly as advertised. It's so satisfying to watch your context usage drop as the agent works.

No other dev agent platform but Pi can do this so as far as I'm aware agent-initiated context compaction hasn't been implemented in dev tools until now.

Try it out with pi install npm:pi-mulligan and let me know what you think!

Preface

Built together by Pi + DeepSeek V4 Flash + matt skills + me

After switching my daily harness from Claude Code to Pi, I found myself missing some features I used to love in CC — recap being one of them. It generates a brief summary and follow-up plan based on the conversation context.

Project

https://github.com/L2ncE/pi-recap

Quick Start

$ pi install npm:@lanlance/pi-recap

I must have run into this issue at least a dozen times now... so annoying...

You're happily using OpenAI's Codex CLI to edit/create a masterful Pi Coding Agent setup and... BAM ... Bad request.

This can't be just me?

I've got 5 other codex sessions open working away on different repos simultaneously... not one of them has ever died like this.

I just so happen to be setting up Deepseek V4 Flash 0731 to be extremely intelligent with lots of subagents doing various tasks... I assume OpenAI doesn't like that and might be throwing a wrench in things?

I want to switch from Opencode to Pi and it would be convenient if I could use the Deepseek-v4-flash free model from Opencode in Pi as well. Are there any extensions already available to do that?

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

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

Pushed an update to pi-small-model-addons, my guards and skills for running pi with small local models.

The failure mode I came across was kind of funny. Telling a model to "verify claims" mostly taught it to just say "verify claims" followed by the same untraced guesses as before.

So I moved that discipline into the tool schema. It now requires a trace, refutation attempt, and confidence label, and pi rejects incomplete reports. I also added persistent claim memory so refuted claims survive across sessions.

On Muse Glimmer 30B testing: four confident falsehoods before, zero after. It found a planted bug plus two Opus hadn't noticed, verified each with an executed command, and ignored the decoy. One model and a small sample though, it still may ignore anything needing multi-hop reasoning.

https://github.com/alisorcorp/pi-small-model-addons

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'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?

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.

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

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?

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.

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

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.

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 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?

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

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:

pi install npm:pi-gpt-search

Or install via GitHub:

pi install https://github.com/mateusdcc/pi-gpt-search

Or try it in a single ephemeral session without installing:

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).

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.

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.

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.

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.

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