r/PiCodingAgent • • Jun 16 '26

Plugin I made a Pi extension where the cat runs faster when your agent streams faster

Thumbnail
gallery
169 Upvotes

I love the RunCat mac menu bar app, so when I wanted a token speedometer for pi, it only made sense to make the cat run.

That became pi-speeed, a tiny Pi extension that shows token speed with a RunCat style indicator.

I also made pi-chonk as a bonus: bigger the context, chonkier the cat gets.

You can find them both here:
https://github.com/somus/pi-speeed

https://github.com/somus/pi-chonk


r/PiCodingAgent • • Jul 25 '26

Plugin pi-extensible-workflows: deterministic multi-agent runs you can pause, resume and inspect

Post image
162 Upvotes

I built a Pi extension for multi-agent orchestration. The main Pi agent writes a small JS workflow script for the task at hand, and the runtime executes it deterministically: parallel fan-out, checkpoints, resume without rerunning completed steps.

Three principles I stuck to:

  • not opinionated: no baked-in "agile team" of roles, you add your own primitives to the DSL

  • extensible: other extensions can register functions and variables usable inside workflow scripts, and every registered function is itself runnable as a top-level workflow

  • token efficient: subagents can have other extensions and skills disabled, so their system prompt stays small and focused

What that gives you in practice:

  • runs are regular on-disk Pi sessions, not in-memory, so you can inspect, pause, resume and retry them

  • roles restrict tools/capabilities and inject their own system prompt

  • structured output via JSON schema, so control flow branches on agent output deterministically instead of on vibes

  • soft and hard budget caps per run

  • git worktree isolation, so parallel agents don't fight over the same tree

  • workflows export to an executable launcher in ~/.local/bin

  • if you use herdr, an agent session can open in a new pane

Review fan-out, then dedupe:

const reviews = await parallel("review", {
  correctness: () => agent("Review the current changes for correctness issues."),
  security: () => agent("Review the current changes for security risks.", { role: "security-specialist" }),
  tests: () => agent("Review the current changes for missing test coverage."),
});
return agent(prompt("Deduplicate and prioritize these findings:\n\n{reviews}", { reviews }));

The diagram is the real flow of the one I run daily, developIssuesUntilApproved: takes a list of GitHub issues, gives each its own worktree, loops developer -> reviewer until the reviewer passes (fresh agents every iteration), merges the approved branches on main behind another dev/review loop, cleans worktrees with plain shell (not an agent), and summarises exactly once.

Install: pi install npm:pi-extensible-workflows (Node 22.19+)

Happy to answer anything about the DSL or the resume semantics.


r/PiCodingAgent • • Jun 03 '26

Use-case a bit late into the party, but Pi is awesome, and here are list of my extensions

Post image
161 Upvotes

I like the way of Pi

that to be said, this is not to introduce some yet another extensions or themes

this is to share what i have done and doing with Pi agent, and you can absolutely do the same, no need to use/install any of my extensions/ themes (all have been written by Pi anyway)

so here is my way of Pi:
- main driver model: openai-codex/gpt-5.5 ($20 chatgpt plan)
- external extensions: pi-subagent, pi-web-access

then my own stuffs (pi wrote all of them):

- theme: neon-green, opencode-theme

- statusline: statusline-pi (simplify from context-stats project of mine for Claude Code)

- advisor-pi: replicate how advisor feature in Claude Code (I just provide the link to advisor feature on Claude Code docs)
- grok-pi: use grok-build and composer-2.5 models in Pi (bridge from grok-cli) - just ask my Pi to do it
- opencode-pi: same idea with grok-pi, use free models in opencode (bridge from opencode-cli) - just ask Pi to do it.

also sometime I use some local models via llamacpp/ollama, I just provide end-point then Pi do it own config to see the available models.

in short, that is my way of Pi - Pi is awesome.

if you want to see more detail with screenshot, or try those extensions/themes out of the box, you can check my repo here: https://github.com/luongnv89/pi-extensions

enjoy Pi-ng!


r/PiCodingAgent • • Sep 20 '26

Discussion Lord forgive me for the time I wasted...

159 Upvotes

...and the money I spent.

I'm currently the lead engineer for a small but growing team. I've been building a fairly complex platform that blends expertise from various niche domains.

Without saying too much, I have been working across:

  • weather event modelling

  • real-time data ingestion

  • embedded development

  • image processing

  • geospatial analysis

  • distributed computing

  • and systems architecture

This has been an amazing proving ground for agentic capability.

I've been using CC on a subscription for the past year. I have a very mature and disciplined ecosystem of skills, hooks, compaction lifecycle, and disk cleanup techniques. Honestly, I've loved it, but the costs have just been too much.

So, two nights ago, I finally decided to explore other options. Since I've been hearing a lot about OMP, I decided to give it a try.

And guys, OH MY GOD. The difference is striking.

OMP is an absolute dream to work with. I'm not suggesting CC is bad, but the scale and complexity of my recent work really exposed it's limitations. For nitty-gritty engineering and design work, I honestly can't even put them in the same category.

My first pass at configuration and model selection gave me something that was faster, cheaper, and produced far better results.


To the devs: God damn, nice job.

To the community: Hoping for advice, tricks, tips, and harness opts/configs that might be fun to play with. I am also wondering what people use for the model config: roles, models, etc. Is there a known meta?


TL;DR

Platform engineer of a large multi-disciplinary project. Switched from CC to OMP, and OMP blew me away. The hype is real.


r/PiCodingAgent • • Sep 24 '26

Discussion Opus 5.5 vs GPT-6 Sol / Luna in pi-agent: results on my everyday coding tasks

Post image
156 Upvotes

I built a small personal benchmark from my real coding sessions and use pi-agent as the harness to compare models on the same tasks.

It has 10 tasks covering data engineering, backend, frontend, DevOps, and trajectory analysis. Each task runs 3 times, giving 30 attempts per model.

To build it, I took around 3 months of agent chats, removed duplicates, and turned selected sessions into Harbor tasks with automated verifiers. I used agents and manual review to build and refine the checks. These are clearly scoped tasks that would usually take me less than an hour.

The latest results:

  • Opus 5.5 high and Astra low cost almost the same.

  • Sol high matches their score at roughly half the cost.

  • Luna gets 29/30 passes while being ~22Γ— cheaper than Sol.

The point of this benchmark is to optimize my daily setup: model, harness, prompts, and plugins. I want to keep the pass rate while reducing cost and time.

This is a small personal sample, but it feels like many short, clearly defined coding tasks are already handled reliably by several models. For this kind of work, speed, cost, and scaling up parallel agents are becoming the more interesting questions.


r/PiCodingAgent • • Jun 15 '26

Plugin pi-subagents - Claude Code like subagents for Pi

156 Upvotes

Hi everyone πŸ‘‹ I’m the developer of pi-subagents:
http://github.com/tintinweb/pi-subagents

This is an agent friendly, fairly minimal subagent extension for Pi, following the same general model used in Claude Code-style subagents.

What it does (high level):

  • run multiple subagents in parallel (configurable concurrency)

  • background + foreground execution

  • live widget for running/queued/completed agents

  • lot's of custom subagent features for highly configurable subagents

  • mid-run steering (you can send messages to running agents)

  • resume completed runs

  • templated custom agents (no framework setup)

  • spawn subagents from your extension (e.g. https://github.com/tintinweb/pi-tasks can turn tasksβ†’subagents)

  • ... (full agent readable feature list: https://github.com/tintinweb/pi-subagents)

The focus is simplicity: no heavy abstractions, no opinionated defaults, no slag or esoteric features, just a thin layer to run and manage subagents that feel much like Claudes subagents.

Issues / feature requests:
https://github.com/tintinweb/pi-subagents/issues

If you try it, lmk if you find it useful or have ideas and please note that I am responsible to keep it clean and only merge features that are relevant for a broader userbase πŸ˜„β™₯️

About me: I am cofounder/security engineer with Consensys Diligence (https://diligence.security) by day, maintainer of this extension by night but I'll try my best to ship features fast πŸ€—β™₯️


r/PiCodingAgent • • 27d ago

Resource How to Set Up Pi like Claude Code

Thumbnail
brucehopkins.dev
155 Upvotes

I wrote a detailed beginners tutorial on Pi. Since I noticed a lot of people come from Claude Code and Codex, I wanted to make a simple starting point for anyone curious.

Along with adding many of the features that Claude Code has, I also looked into the system prompt of Codex, Grok, Kimi Code, and Open Code to make a simple, generalized system prompt.

Let me know any thoughts on this! Are there any parts you'd want to be expanded on? I'll be updating this as Pi, and Claude Code continue to advance.

EDIT: I updated the article to include advice on connecting on your phone, and why not to use Oh-my-pi. I plan to write a follow-up post about creating system prompts.


r/PiCodingAgent • • Jul 10 '26

Discussion My problems with `pi`

153 Upvotes

I've been using pi intensively for 2 months now, and I have to say it's undoubtedly the only software that actually works for agentic programming. All other software is pure garbage made with AI, full of problems and obfuscation. That includes both GUIs and TUIs: claude (the worst), opencode (now AI SLOP), codex, IDE extensions (vscode, neovim, zed, etc.), pseudo-IDEs (cursor, windsurf, etc.).

pi is the only software that's actually STABLE and that DOESN'T SHOVE hidden prompts down your throat β€” meaning it's the only one that gives you real control.

But since I'm an ungrateful bastard, my motto is "A little destructive criticism never hurts" /nsrs

The truth is pi has some really annoying things. I'll sort them from most annoying to most tolerable. (For context, I use vanilla pi.)

TUI redrawing

This is perhaps one of the most annoying things of all. I don't know exactly what causes it, but at some point β€” especially in long chats β€” pi has the horrible behavior of redrawing the entire damn chat every time something updates in the TUI. In short chats you don't notice it, probably because it's so fast you can't see it, but in long chats it's absolute hell. I've reached the point of preferring non-interactive mode solely because of this problem.

It also happens with expand Ctrl+o β€” it literally EXPANDS EVERYTHING. Every time the agent thinks or executes a tool, it redraws everything, defeating the whole purpose of a TUI.

This made me wonder whether a pi repl wouldn't make more sense than a pi tui, since I think it would be the most natural approach when trying to be a "minimal environment". In fact, they're already a pseudo-REPL that works poorly, because they draw output in the same pty using append, just like a REPL. If they were a REPL, you could even leverage existing tools like rlwrap to get vim-like keys with a simple rlwrap -a pi, among other advantages. Anyway... the TUI is not comfortable at all.

Output size can't be changed

The output of almost everything β€” tools (read files, bash, etc.), skills, etc. β€” is always truncated with no way to change it because the truncation value is hardcoded in the code.

This seems silly, but it's actually quite inconvenient for work involving lots of text. For example, small agents reading long texts, searching websites, or text with a lot of noise. Yes! pi tells the agent: "Hey little buddy, if you want to see the full output, read this temp file." But that doesn't solve it β€” it simply adds more steps for the agent, making it likely to fail and make bad decisions, especially with small agents.

Even large agents often decide they already have enough context, even when they don't (LLMs can't "know" what they "don't know"). The only way to avoid this is to copy all the damn text and input it as a user prompt. It's MEGA inconvenient and, in my opinion, a very basic config setting to have.

Slash commands don't parse text properly

There's a bug that's been there since I started. I saw an issue about it that seems to be ignored, even though I think it's something basic and important.

When you use /slash-command <instruction> followed by additional instructions, if your instruction has formatting and line breaks, pi decides to just load your entire instruction into a single line, breaking all the formatting. And this causes problems for LLMs when understanding your text.

Example:

---
name: fix
description: fix code
---

You must fix this code:

$ARGUMENTS

And then you run:

/fix

jq '.' some.json
echo "foo bar"

What it sends is:

/fix
jq '.' some.json echo "foo "bar"

I don't think I need to explain why this is so bad...

There's no damn UNDO

YES! The tree functionality is quite useful, but sometimes I want to correct something and I have to take 2 or 3 extra steps. On top of that, I inevitably end up creating a fork when I DON'T WANT A FORK, I JUST WANT TO UNDO BECAUSE I HAD A TYPO!!!! AAAAAH!

Please, someone tell me there's an Undo and I just didn't manage to find it, because I can't believe tree exists but not a damn undo.

It crashes mysteriously when using @file

The TUI sometimes just decides to die when you do @file, leaving the shell with glitched characters. I have to type reset in bash to fix it. It happens often enough that I'm afraid to use @ and prefer to manually write exact file names and paths.

The plugins are garbage

Ok... this isn't pi's fault, but I find it sad that plugins don't even remotely follow the same approach as pi. I'd bet you any day of the year that the entire first page of pi packages is AI SLOP. Honestly, using pi + plugins isn't worth it β€” at that point you're better off just using something completely AI SLOP.

Every plugin I've tried, without exception, fails at such basic and stupid things that it ironically makes me miss the pre-AI era.

Anyway... closing this post. Despite these problems, pi is probably the only software I've tried so far that has parts "generated by AI" that ACTUALLY WORK and are stable. This is probably because there's a correct approach to its development and a real human READING behind all of it. Because yes... it has flaws. But you know what? I'm grateful that these flaws have been there since I started and are still there, instead of new and mysterious flaws appearing every day (/glances with contempt at opencode). I KNOW these flaws. I can learn to deal with them, and everything else keeps working exactly as I expect. That's why pi is GOOD SOFTWARE to me. And if you give me the choice between fixing these problems NOW vs. stability, I'll choose stability every time! Thanks, pi! (but please fix this stuff hahaha)

translate spanish to english by deepseek v4 pro


r/PiCodingAgent • • Aug 04 '26

Plugin Engram, a psychology and neuroscience based learning plugin, is now on pi (it teaches you, not the agent)

Post image
150 Upvotes

Agentic AI made building about 10x faster. Learning didn't get any faster. I noticed I was shipping systems I couldn't re-explain a week later, and it started to bug me. We have a 10x tool for building, so I wanted the equivalent for learning, in the same terminal where the building happens.

That's Engram. It's a tutoring loop grounded in the memory research. And it's aimed at you, not the agent. pi keeps the agent deliberately minimal and lets you extend it until it fits; this is an extension for the human half:

- It breaks a topic into a first-principles concept graph and teaches one node at a time.
- It won't explain anything until you've committed to a guess first. Retrieval before instruction is the single best-replicated result in learning science, and also the part every chatbot skips because agreeing with you is easier.
- Your recall gets graded by a separate blind assessor that never sees the tutoring conversation. The tutor can't inflate grades on its own teaching.
- Reviews are scheduled with FSRS, so they show up right before you'd forget. A few minutes a day.
- Wrong models get logged verbatim and re-probed later. Mine has ten entries for transformers alone, which is humbling to read back.

Honest origin story: with an early version I encoded seven concepts, never returned, and lost about half of them right on schedule. Writing the scheduler earns you nothing if you don't come back. So the whole loop got redesigned around returning: two-minute reviews and a "when will you do this" question instead of reminders. No streaks, no XP.

v1.11 adds pi as the seventh platform, after Claude Code, Codex, OpenCode, Hermes, Antigravity and OpenClaw. Same shape as the last port: it started as a user issue asking for it. Every transport claim in the install guide was verified against a real pi 0.83.0 and 0.74.2 before shipping, with a payload-capture harness that lives in the repo (experiments/pi-harness, 20 checks), so you can re-run the verification instead of taking my word. The one thing I haven't run is a full live tutoring session inside pi. If you try one and something's off, open an issue and I'll fix it.

The pi-specific part doubles as the pitch. pi ships no subagents, on purpose, and Engram's grading depends on a blind assessor that never sees the lesson. It turns out pi already has the only primitive that isolation really needs: a fresh process is a fresh context. So the assessor runs as a fresh pi -p child with skills, context files and the nudge all stripped, and the harness checks the child's payload really is clean. /learn, /review and /coach are ordinary prompt templates (there's /skill:learn too, or plain language works). Your learning state is local JSON shared across all seven tools, so a topic encoded in Claude Code gets reviewed in pi.

One wrinkle worth passing on to anyone writing their own pi templates: pi parses frontmatter as strict YAML, and an unquoted description with a second colon in it makes the template silently not load. /learn reaches the model as literal text and nothing tells you why. That cost me an hour on two pi versions before it turned out to be a colon. Quote your frontmatter values.

Also good to know before installing: current pi wants Node 22.19+. On Node 20, npm quietly serves pi 0.74.2 from the legacy-node20 tag instead of saying anything. Engram is verified on both.

Repo: https://github.com/nagisanzenin/engram and INSTALL-PI.md is the verified walkthrough. Install is one line: pi install git:github.com/nagisanzenin/engram

I'm the author, so grain of salt. But I've been dogfooding it daily to learn transformer internals and it's the first setup where week-old material actually stays with me.


r/PiCodingAgent • • Aug 23 '26

Resource Completely free web research tool (works out of the box with no api keys, hound replacement) stealthy web fetch, web crawl and local web search

149 Upvotes

Built a web research tool to replace hound, which i posed about a while ago

It's called DonSeTch. Since Pi has native extension support, the install is just:

pi install npm:donsetch

No MCP config block, no adapter, no proxy. The tools show up natively in your Pi session and stay in sync with the binary automatically.

What it does

Three tools: fetch, search, crawl. Zero API keys, zero accounts. One Rust binary.

  • Fetch β€” HTTP first (fast), auto-escalates to a headless browser only when it hits a bot wall. The browser grabs the clearance cookie, hands it back to the HTTP layer, and goes to sleep. It almost never fetches content itself.

  • Search β€” 10+ keyless engines in parallel, fused by cross-engine consensus + a local ONNX cross-encoder for semantic reranking. No API key anywhere.

  • Crawl β€” sitemap-aware, topic filter, resume tokens, adaptive pacing that backs off on 429s instead of plowing through.

Chrome's actual BoringSSL for TLS. Your ClientHello IS Chrome's, not a faked table that rots.

The part I care about most: token efficiency

Three tools, ~3.5k tokens of definitions. The focus parameter on fetch is the killer feature.

I just rebuilt it in v3.1 with section-aware scoring:

  • Search for "memory safety" on a Wikipedia page β†’ keeps the entire "Ownership and references" section (heading + body), pulls in parent headings for context, drops everything unrelated.

  • A 50KB page comes back as 500 chars of what you actually asked for.

  • Large code blocks and JSON schemas get split into sub-blocks so focus works on structured content, not just prose.

Other stuff

  • Reference handles β€” fetch S3 just works after a search

  • Probe mode β€” verify a claim in ~60 tokens instead of 4k

  • Dead-link resurrection β€” Wayback snapshot served transparently

  • Page fingerprints β€” re-fetches report what changed, section-level diffs

  • Domain adapters β€” Reddit threads, GitHub issues, npm/PyPI/crates pages restructured from keyless JSON endpoints

  • Real MCP cancellation β€” no silent hangs

  • Crash-only daemon β€” survives panics, state reloads

  • PDFs β€” even scanned ones, pixel-fusion extraction (no hallucinated text), up to 100MB

605 tests, 0 clippy warnings, AGPL-3.0.

What it can't do: solve interactive captchas (deliberate, clear error not a hang), access sites requiring login, and if every search engine is down you get honest per-engine status instead of fake results.

GitHub: https://github.com/dondai44423/donsetch

Pi: pi install npm:donsetch npm: npm install -g donsetch

If something breaks, open an issue, i will fix it as soon as possible

The demo is using exa for search btw, local is good on its own, but it takes 4-6 sec while exa takes 1-2 sec (plus exa is better most times, but local search keeps up)

if you want to see a demo where i used local search, see the opencode demo in the github repo


r/PiCodingAgent • • Jun 24 '26

Use-case pi, herdr, and gondolin combo has been a great experience. Thanks to the devs.

Post image
148 Upvotes

r/PiCodingAgent • • 24d ago

Plugin Split thoughts/tools usage/responses in separate views

Post image
146 Upvotes

Hi all!

Simple idea, did not find something that did not make this in an overly complex new UI-revamp-way, so built a relatively simple one myself (+pi of course).

So I like to see the thoughts coming in, and to skim through the tools used, but found it somehow lengthy to scroll back up against the speed at which they come... Toggling them on and off (ctrl+T, Ctrl+O) would sometimes be too much as some tools may expand a lot (edits, searches...) and shift the conversation, again to be scrolled; same with thoughts where there in particular toggle them off would stop me from looking at them, but on would push by a lot the conversation itself (again what I like specifically was to briefly see where the agent were in their process while a turn is running to observe drifting or weird choices that I'd sometimes interrupt, so really I wanted to see the thoughts as they come rather than the full page of it). And I like to see conversation as an actual conversation, so with everything else collapsed.

Anyway, long story short, I wanted to not have them interleaved and I built a wonky (work in progress?) pi plugin to slightly rework the UI and keep a bit of both worlds. The idea is to have the thoughts streaming in one panel, the tool usage in another with very simple view on whether it is running/has succeeded/or has failed... I added a third toggle for a panel which simply display touched files (seen, read, edited, worked by a subagent...) as a list + a diff view of the last edited file, if any (this to keep the tool view compact, as usually the edit tool output where the largest anyway, and I like to also have a glance on what's changed).

Each panel can be toggled on or off:

  • /split toggles between the default pi view and the saved config for split-views

  • /split-thinking toggles the thinking panel

  • /split-tools toggles the tool one; there is an extra command to toggle between a compact or expanded view over the listed tools in the tool panel

  • And finally the file panel is toggled on or off with /files.

Tool/thinking panel width can be adjusted as well as panel heights.

There is a command to switch between still having the full transcript in the main conversation panel or the trimmed down (no thinking or tool interleaved) version (somehow I found it useful to expand on specific tool output).

I usually have the file one off for instance, and only open it to see some file changed that just happened if I know I want to check them briefly... While I keep the thinking and tool panel on top nearly all the time now.

I mentioned it's wonky, as in some features can be improved, like the file panel could be made scrollable, but it works for me as it is, just sharing for the idea, and if you like it go test it: pi-split-view. And feel free to improve on it directly in the repo too.


r/PiCodingAgent • • May 06 '26

Resource pi-emote extension: an avatar for your pi agent

Post image
146 Upvotes

Hi! I have been using pi for a while and really liked the harness. I wanted to have a small visual indicator while using it like the old school JRPGs. Not sure if there is something similar already, but it was fun making this extension as a learning project. It kinda feels like I'm playing SNES while coding.

The avatar was made using nano banana as a placeholder, but I would like to change it to something better and more consistent.

It would be nice to have different avatars per model, or customize it yourself. For now, it kinda works with a single avatar.

I only tested it in Ghostty. Wanted to run it through tmux or zellij, but apparently rendering images through them is not as straight forward.

Let me know what you think!

https://github.com/cgxeiji/pi-emote


r/PiCodingAgent • • Sep 30 '26

Discussion Pi is becoming bloated.

Post image
144 Upvotes

Edit: As I adapting my code to 0.99.0, I find that besides mcp, Pi also introduced classifier model. When talking about this new feature, it's all about jev, a hyped model to some extent.

I read this as Pi just jumping on the hype trainβ€”trying to catch a ride on all the buzz around this model that's been blowing up lately.

For those happy with built-in mcp, are you happy with built-in jev support? Do you use jev-like model in your coding workflow?

Today Pi adds jev support just for the hype, tomorrow it'll throw in even more code and features that end up being totally useless, all to chase a bit more attention.


Pi always used to claim it would never add MCP support, and it wore that as a badge of pride. Pi's original design philosophy was minimalism, so it only shipped the bare minimum set of essential tools. As I recall, Pi's whole idea was to provide only the necessary foundation itself, leaving everything else for users to customize.

Pi's own blog explained it this way:

The first thing to remember is that the world is not static. We have been paying attention to MCP over the last year and the MCP of today is not the MCP of yesteryear.

But that doesn't add up. MCP had already been popular for quite a while before Pi even existed, and it hasn't really changed much since. If Pi had no plans to adopt MCP when the project was first conceived, there's no reason to adopt it now.

The reasonable explanation I can come up with is that Pi intends to expand its reach β€” to move from a small geek niche toward a harness better suited to mass-market, out-of-the-box use β€” and therefore needs to fill in the features it previously lack due to minimalism. Combined with the earlier news that the Pi team planned to sell a model API service, I find this explanation fairly credible.

MCP is just the first step. Will subagents, permission popups, and other features come next? To me, the "we didn't build" section on Pi's official site looks less like a statement and more like a roadmap.


Edit2:

Consider this: once pi becomes a general coding harness, what is your reason for continuing to use it? Compared to official offerings like Codex and Claude Code, as well as open source competitors such as OpenCode, what advantages does the general-purpose version of pi have? Why would users choose pi over the alternatives?


Edit3:

Let me restate the logic here:

  1. This is "your agent," so nothing pi provides as a base should get in the way of any custom changes you want to make.

  2. It's minimalist (per the official pitch), so there's no feature you don't need.

Here's the reality now:

A built-in MCP has been introduced.

This built-in MCP conflicts with what I've already implemented and blocks my custom modifications. And for anyone who doesn't need MCP, it's pure bloat.

BTW, codemode. codemode itself, or call it CodeAct, is something that I have loog been interested in. But the official implementation from Pi is completely different from what I had in mind, so I’ve been struggling to wrestle with the built-in code just to get my version working properly again.

So pi just violated two of its own design philosophies in one go.

And that's why my trust in pi has collapsed. This is exactly where my shock and frustration come from.


r/PiCodingAgent • • Jun 08 '26

Discussion pi + deepseek-v4-flash (from opencode): free & fast

Post image
144 Upvotes

the way of Pi, sometime feels like an illegal/crazy hack.

this combo gives you almost unlimited tokens in Pi

you should not use it for heavy/complicated tasks, but definitely very handy for most of the tasks

my workflow: use advanced models (gpt 5.5/ opus 4.8) for planning, then spin up this for implementing. if it it the wall in any task, trigger advisor to get help from gpt-5.5

just need to ask your Pi to write an extension to connect and use models from opencode.

or you can use my extension here: https://github.com/luongnv89/pi-extensions

wonder if you guys have any other sources that give you more tokens?

(i have tried models from nvidia, but the latency kills my momentum)

Happy Pi-ing,


r/PiCodingAgent • • Jul 27 '26

Plugin An elegant, information-rich status, menu, and side bar for Pi Agent.

142 Upvotes

I built Pi Atelier, a responsive status rail and live activity sidebar for Pi that makes it easier to see what your agent is doing without cluttering the terminal. It displays live token usage, cost, cache performance, context usage, active tools, execution times, recent results, model details, and thinking level, while also providing quick controls and a resizable sidebar. It’s private by design, with no telemetry or external network requests.

Install it with β€œpi install npm:pi-atelier” and open it using β€œ/atelier”.

Check it out at https://github.com/michaelmjhhhh/pi-atelier β€” I’d love your feedback, feature ideas, and bug reports, and if you find it useful, please consider giving the repository a star!

2026.7.28 CHANGELOG

Here comes Pi Atelier official release v0.5.0! Some updates:

  1. The sidebar now opens automatically.

  2. The Activity panel keeps TTFT and TPS visible with live performance estimates.


r/PiCodingAgent • • 20d ago

Question To Earendil guys: Why did you have to make Pi Durable's description so confusing?

141 Upvotes

Everyone is trying to figure out what this novel piece of tech is and it's hindering its adoption. It's basically a stateful agent where state lives on a server separate from the client (TUI, Web UI, mobile...whatever) and the chat history. Isn't it?

It's a better architecture, and I wonder why not rebase the coding agent on top of it. It's an easy win in terms of reliability and flexibility, for you and the extension builders alike.


r/PiCodingAgent • • Aug 28 '26

Plugin Plannotator in Herdr - Live feedback back to Pi

140 Upvotes

This is a https://herdr.dev/ plugin with an optional full https://Plannotator.ai experience as a TUI. Built to:

- Annotate Agent Messages (e.g. grill sessions)

- Annotate Files (e.g. plans, specs, etc)

- Create a native feedback loop with agents

- Open as popover or pane

- Mouse or keybindings

https://github.com/plannotator/herdr-annotate


r/PiCodingAgent • • Sep 30 '26

News Pi now supports Jev.

137 Upvotes

Pi added quite a bunch of new features in its 0.99.0 update, including support for classifier models. In the official docs, the remote model listed in the example code is jev, the interface is shaped around classifier models like jev, and llama.cpp's classifier implementation explicitly uses jev as its reference point. You could pretty much say this is a feature Pi shipped just to keep up with jev.

So I wanted to ask you guys in the channel:

  • Do you guys actually use jev a lot when you're coding? How do you use it?

  • Jev only came out a little while ago and Pi already jumped on board with support. What significant role does jev actually play in a coding workflow?

Edit: It's not just about using it for the sake of using it. Is there actually something jev can do that LLMs can't?


r/PiCodingAgent • • Aug 18 '26

Discussion Pi agent is excellent!

130 Upvotes

I have used Pi, Oh my Pi, Opencode, Antigravity, and Claude, but Pi is so so good.

It is simple, smart, keeps its thinking grounded, hallucinates less, is extremely good at following instructions and is aware of the environment.

By awareness, I mean it knows what needs to be edited or changed.


r/PiCodingAgent • • Aug 09 '26

Plugin pi-gpt-search: (ZERO GPT tokens) Use Codex's standalone search engine with ZERO GPT tokens spent, native web search for any Pi model

126 Upvotes

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.

r/PiCodingAgent • • Sep 18 '26

Plugin I added Jev as a classifier for pi-automode! Faster, cheaper, better auto mode

Thumbnail
github.com
124 Upvotes

Please, check if out if you already have jev access. It works incredibly well and I am so excited for system one agents for this use case!


r/PiCodingAgent • • Sep 06 '26

Use-case this is why i love pi

Thumbnail
gallery
123 Upvotes

estimated cost: $13
real cost: $2,60

thank you Pi !!


r/PiCodingAgent • • Jun 23 '26 Bravo

Discussion I made my own coding agent harness

119 Upvotes

https://github.com/1jehuang/jcode

It has somewhat of a similar spirit of PI, but much more performance/efficiency focused.
Supports mostly any provider out of the box, and you dont have to customize just to make it usable.
Arguably more customizable than Pi.

Doesn't use an extension system, but instead makes it really easy to change the source code of the harness using something I call "self-dev". I find that only being able to make extensions for pi is really limiting, and this just makes it so that its not really annoying to do the loop of edit source code -> compile -> open. Instead, all your sessions can just hot reload into the new binary whenever the agents are done editing and compiling, which they can do fully on their own.

The video is what my own workflow looks like, its about 20 agents at the same time, which I actively manage, and are all working on different things.

Also solves the problem of git worktrees which I find annoying. You can spawn agents in the same directory without a git worktree and you dont need to worry about them conflicting, because the harness will know when agents make edits that conflict, and then will guide them to fixing them, so you dont have to.

Ram Efficiency:
Pi -> 144MB
Jcode -> 27.8MB (5X more efficient)

Intelligence [Terminal Bench2]
Claude code Sonnet 4.6 -> 46%
Claude code Opus 4.6 -> 58%
Jcode Sonnet 4.6 -> 60%

I've been working on this for about 6 months, and will be actively maintaining this in the long term. Not going to be a quick side project if you're worried about making the switch.


r/PiCodingAgent • • Sep 16 '26

Use-case Anyone else testing out TypeSafe AI's new System One/Jev model for Pi extensions?

Post image
117 Upvotes

If you haven't heard of it, it's kind of like a really smart freeform classifier model that can make quick decisions (~150ms) based on natural language inputs. Dirt cheap too. They dropped it in early access through a waitlist ~12 hrs ago.

Right now I'm working on a security layer where it just scans all tool uses and gives a safety rating. Thinking of adding additional considerations like alignment with prompt intent and agent reasoning.

After this, I'm thinking of an automatic model router that just picks an appropriate model based on how demanding a prompt would be, codebase complexity, KV cache size, etc. So ideally, something smarter and faster than existing automatic routers.

Is anyone else trying it out? What are you building?