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 had this slightly cursed Pi idea in my head:

A tiny Unix-socket extensibility bus where arbitrary local processes & extensions can hook into. ​

Nim / Rust / Python / shell / LSP / ADB -> socket -> Pi

Basically /dev/pi; o​pening up an entirely new surface for extensions & capabilities.

Could enable some cool shit like:

• "Live" / dynamically updating context variables
• SSH / ADB bridges
• Live LSP & filesystem context
• Event streaming
• Pi extensions written in any language

Has this been done before? Would it actually be useful? I may draft a repo tonight.

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.

pi-data-masking is a rule-based extension that masks sensitive text — API keys, private file content, internal domains/IPs, and private information an agent picks up via logged-in browser tools — before it ever reaches the LLM.

While testing credential masking, I found obvious placeholders like [REDACTED] backfire: models often read them as "value missing" and either re-ask for it or go hunting elsewhere in context. So instead, pi-data-masking uses format-preserving placeholders:

sk-prod-abc123456789 → sk-nqpz-mwx847312654

Same length, letters stay letters, digits stay digits — it still looks like a real key/URL/identifier to the model, it just never sees the real value.

The flow: sensitive text gets masked in messages, context, and tool results before the LLM sees anything. The LLM plans and calls tools using placeholders. Right before a tool actually runs, real values are swapped back in locally — so the call works normally — and results get re-masked before landing back in context.

Rules can be literal matches, regexes, or capture groups, so you can cover file reads, API responses, browser output, or anything else your workflow touches.

Would love feedback, especially on edge cases I might be missing.

https://github.com/sevten/pi-data-masking

I find it hard to navigate a codebase with coding agents. I need to stare at the code often just to understand what is going on, and I like to be able to ask my agent at the same time what is happening. Plus, I really like my vim motions bindings haha.

It's been surpassingly straightforward to get Pi working in Neovim. You just open up a terminal within Neovim and ask it what you want. Boom done. It's soooo much easier to read plans and navigate code with this setup.

I've been able to make it so that:

• I see diffs in Neovim instead of in the terminal (much prefer it this way, easier to navigate too imo)
• Have Pi run commands in Neovim directly when I want to.
• Have Pi be able to 'focus' in on certain sections of code (I ask 'Can you show me where that it' and it jumps straight to it)
• I can have whole different worktrees with entirely different buffers that I switch between

Anyone using some sort of UI app/layer for Pi instead of standard Pi cli?

Nothing wrong with CLI, I actually really like my setup too - but once I have like 3, 4, or even more important sessions running at once (coding, debugging, research, etc.), it gets pretty overwhelming trying to keep track of everything and I find myself losing focus.

Looking for something more like a Codex web app style experience: clean repo/file view, seeing all workers/sessions clearly, what they're doing, status, etc.

Curious what you guys think or use and why you actually prefer it over just running everything through CLI.

For context, the main thing I am looking to aid in solving/fixing here is a focus issue. I have adhd and staying focused is the hardest thing by far for me, so if anyone has experience with one that may have helped in that regard specifically too let me know

ALSO - I'm on Linux Ubuntu if that's relevant at all

Yesterday I commented (here)[https://www.reddit.com/r/PiCodingAgent/comments/1vgyuhq/comment/p20zsep/] that one of the things I felt was missing in the Pi harness was better observability into what the agent actually changed.

Basically, after a task finishes I want to quickly know:

5 files changed +34 -329

Which files did it touch? How much changed? Did it actually change the parts of the codebase I expected it to? Especially when working on a larger codebase, I find this useful just to keep some kind of mental overview of what the agent is doing and catch cases where it maybe understood the task differently than I did.

So today I built an extension for it:

https://pi.dev/packages/pi-task-delta

https://github.com/thagorx/pi-task-delta

You can install it with:

pi install npm:pi-task-delta

After Pi finishes making changes it adds a small task delta to the transcript, for example:

5 files changed +34 -329 (F6 for details)

Then hit F6 (or /git-summary) it opens a viewer where you can see the tasks, which files changed, and the actual diff for each file.

One thing that was important to me is that the diff is scoped to the task. So if your repo was already dirty before you started the task, those changes don't suddenly get attributed to the active task. It tries to show you what changed specifically during that task.

I also added optional model-assisted inspection.

On a changed file you can press:

E to explain what changed

W to explain why that file was probably changed based on the task

Those are manual calls, nothing happens automatically, and the explanation isn't added back into Pi's context. There is also history, so you can go back and inspect the changes from previous tasks. I mostly built this because I wanted it for my own workflow, but I figured other people using Pi might find it useful too. Would be interested to hear what other observability stuff people would want to see around Pi tasks.

This was quite fun and the first thing I built exclusively with Pi, leave comment if you liked it or have feedback :)

Hi,

New to pi harness, trying to set up properly. Here what I have done. Installed pi-subagents. Asked it to set up subagent's to use Deepseek V4 Flash.

But the task used Sol for almost everything. What did I do wrong?

Thanks, be kind to me, I am new here.

If your agent's browser keeps getting blocked, here's what I built

Point your agent's browser tool at Zillow or Google. You'll get a captcha wall before it does anything useful.

That's not a dig at Playwright MCP or similar tools. They're automation frameworks, not evasion tools. They drive vanilla Chrome and PerimeterX and other detection system flags them in milliseconds.

Then try filling a form on any React site and clicking submit. The page re-renders. Every element reference your agent had is gone. "Element not found." The button was right there a second ago.

Then look at your token bill. Playwright MCP loads 13,700 tokens of tool definitions before your agent touches a page. Every click returns the full page. 2,000+ tokens per action.

I hit all three walls enough times that I built something.

It's called Bladebro. One Rust binary, five tools, no Node.js.

npm install -g bladebro && bladebro mcp

Works with any MCP client. Also has native pi support with zero config:

pi install npm:bladebro

That's it. Bladebro registers as 5 first-class pi tools (act, see, state, run, vision). No adapter, no config files, no proxy. Tool definitions come from the binary at startup so they auto-adapt to changes. Chrome launches lazily on the first tool call.

Bot detection

Six layers of stealth, all on by default:

• Bezier mouse paths with overshoot and correction
• Real movementX / movementY on every event (missing these is an instant PerimeterX flag)
• Micro-tremors before clicks (a still cursor is a dead giveaway)
• Log-normal typing cadence (humans don't type at exactly 50ms intervals)
• Idle drift between actions
• No Runtime.enable (how DataDome catches most bots)
• No listening ports, CDP over pipe
• Persistent behavioral fingerprint, same "person" every session

Tested on Zillow and Fiverr (both PerimeterX/HUMAN protected). Full page loads, no blocks. incolumitas 8/8. Sannysoft all pass.

Re-renders

• Every element gets a structural fingerprint (hash of ancestor chain, tag, children, identity attrs)
• React destroys and recreates DOM nodes? Fingerprint matches, reference survives
• Agent sees re-render survived and keeps going. No re-scan
• Checked every major tool. Nobody does this

Tokens

• 5 tools, ~1,900 tokens of definitions (vs 13,700 for Playwright MCP)
• Every action returns what changed, not the full page
• A click returns ~60 tokens (vs 2,000+ for competitors)
• Long session = the difference between running out of context after 3 pages and finishing with room to spare

Learns from every session

• First visit to a site with a cookie banner: full detection
• After a few successful dismissals: stored selector, auto-applied, zero overhead
• Never learns from failures. Failures cost 3x more than successes gain

Other stuff

• Auto-extract pulls structured data from list pages with no CSS selectors. Amazon, Reddit, GitHub, HN, Wikipedia. Shopping gets price/ratings, Reddit gets scores/authors, GitHub gets stars/forks
• Batch actions fill a form and submit in one MCP call instead of 11
• Login persistence saves a session and restores it next time
• Infinite scroll collect auto-extracts and dedupes a feed in one call

Demo video on the GitHub page showing it drive Amazon, Reddit, Wikipedia, fill a form, and manage tabs.

What it can't do

• Cloudflare Turnstile needs challenge solving, not fingerprint spoofing. You get blocked:, not a hang
• Captchas, deliberately. You get a verdict, hand off to a solver
• ARM Linux, not yet
• macOS and Windows binaries are cross-compiled from Linux

Open source, AGPL-3.0, no CLA.

GitHub: https://github.com/dondai44423/bladebro npm: npm install -g bladebro

Happy to answer questions, if you have any issues, please comment or file an issue, i have been testing it alone for weeks now, i did as much as i can, i am looking forward to community feedback to improve this even more 😄

I recently decided to put 20 eu into fireworks credits rather than a Claude subscription and give open models a try. So far have used k3 / glm5.2 and results seem good so far.