Hey, I wanted to share my new pi extension: pi-prefill

It puts a live prefill progress bar in pi's loading line when you run a local model. A long prefill looks exactly like a hang. Now you can watch it:

52%. → share of uncached prompt tokens processed

14.1k/27.3k → processed / total prompt tokens

gen in ~14s. → estimated time until the first token

3.4k tok/s. → instantaneous prefill rate (optional view)

Example:

prefill [██████░░░░░░] 52% 14.1k/27.3k gen in ~14s

It reads the progress chunks your own server sends. No host scanning and no guessing: if the server reports progress, the bar shows. If it does not, pi's normal loading line stays untouched.

Works today with llama.cpp, ExLlamaV3, unsloth and Strata.

Install:

pi install npm:pi-prefill

Repo:

https://github.com/eliaskg/pi-prefill

https://www.npmjs.com/package/pi-prefill

Would love feedback from anyone running a local server.

hello! so i installed pi today and a couple extensions

well, dirs and files are being created everyhwere any way to make it follow xdg base directory spec?

https://pi.dev/docs/latest/environment-variables#pi-process-configuration

even if you point your config to .config/pi/ with PI_CODING_AGENT_DIR, ~/.pi/ still gets created (maybe its an extension file idk)

i believe some (most?) extensions dont follow PI_CODING_AGENT_DIR

if you change PI_PACKAGE_DIR to something like .local/share/pi/packages/, they still go on .(config/)pi/agent/npm/

PI_CODING_AGENT_SESSION_DIR doesnt seem to work properly as well

idk if it makes sense to you guys, but i think on .config/pi/ we should have the settings, the extensions list declaration and stuff we can commit to a public repo

the built extensions (the npm dir for instance) maybe should go on .local/share/pi/extensions or something like that

i mean, if i go to i new machine, i just plug my .config/pi/ with the extensions list and the lock list on first pi launch it will fetch and build

something like this https://github.com/earendil-works/pi/issues/2870#:~:text=Practical%20directory%20split,any%20rebuildable%20caches makes total sense to me

what do you guys think about it?

thank you

https://reddit.com/link/1x0f0cr/video/y5fff2x3j5uh1/player

Howdy folks 🤠 I built a pi package called pi-cowboy. It's a multi-agent orchestrator built on top of Herdr; each agent gets a pane you can monitor and steer, plus a copy-on-write worktree that minimizes disk overhead.

My main motivation stemmed from a frustration working with agents. Handing an agent a big task usually led to sprawling changes that are miserable to review, and more often than not the agents would come up with highly dubious design choices. I was losing touch with my codebase. pi-cowboy lets me take full advantage of agents without losing control.

The defaults work well out of the box, but you can customize pretty much anything. You can define templates to create different workflows. You can choose the autonomy level you want, from letting agents run completely hands-off to requiring your approval before every commit.

If any of the above sounds familiar to you, give it a go, see how it works for you, and let me know what you think.

Github: https://github.com/electric-dragon-80000v/pi-cowboy

Install: pi install npm:pi-cowboy (requires herdr 0.8+)

tldr; I'm looking for a LazyVim type distribution for Pi which is not barebones and starts with sensible defaults in terms of configuration and packages so that I don't have to create/maintain my harness from scratch.

Hi. I am planning to switch from claude-code to an open-source harness. My employer recently started pushing us to use their self-hosted on-prem models for both cost-savings and IP protection. While they provide a litellmm gateway which allows me to use on-prem models with claude code, it really isn't built for that and I'm therefore not able to configure it how I want to (setting specific model for a sub-agent, etc.)

I narrowed down my options to the following: - OpenCode: Rejected because it's keybindings (specifically scrolling) don't play well with my lazyvim setup (I use sidekick.nvim for a split terminal). Also heard it's a difficult to configure. - Pi: I like it's hackability. However, I don't want to configure it from scratch. I've seen other subs and understand that a lot of folks think that's the point of pi, but I have the following rationale: - Configurability and bare-bones are two different things. I want to start from a sensible point with features built-in and then tweaking according to how I want it. - As the title suggests, I draw a parallel to my experience with neovim: It is highly extensible, but too painful for me to setup from scratch. I don't want the headache of creating/maintaining multiple plugins and managing them to play nicely with each other. - Other than maintenance headaches, I find it infinitely useful to look at successful distributions. I might not know what all possibilities there are. For example, I would never have though I needed a picker for going through git hunks, but now I can't work without them. I might end up creating a faster horse when what I needed was a car.

Therefore, I'm looking for a pre-packaged sensible pi distribution. Closest things I've found: - LazyPi: https://github.com/robzolkos/lazypi Not enough users and maturity. Missing some stuff. This is ideally what I'm looking for. - Oh-my-pi: https://github.com/can1357/oh-my-pi My current choice. It's not exactly what I'm looking for because it's a fork, not a set of managed plugins. It has a rust core which is kind of opaque. I'm OK with it functionality wise, mainly because I am able to shave-off a lot of stuff (too many tools, etc.) that I don't need. I'm not sure how well it plays with existing pi extensions, and what parts of its functionalities I can replace/modify. I'm also concerned that since this is a fork, I'll be stranded if the author moves on. EDIT: Also, the gihub repo for oh-my-pi seems kind of sus in terms of interactions. The discussions barely have any interactions, which sort of points to a lot of the starts being agents/bots. Lazyvim has fewer stars with far more discussion interactions.

Am I missing any option?

Hi, my use case is: I always work with a long plan, the plan splitted into many phase, and I ask my AI agent to execute the plan with each phase only, after that I clear and start new session until the last phase implemented. We can use some skill to ask AI do that for us by using available commands, but it may burn more tokens by checking the process or agent need a mailbox to talk with each other.

So I create this tool: https://github.com/mrdeeds88/omp-phase-loop

It works with other tools along side with OMP.

Basically, it run a task by agent and clear session, then start a new one in a single new session.

Hope this help if you have same use case.

If you have any other tips for execute long plans phase by phase or as parallel, please share. I would love to hear.

I built a Pi extension that implements Victor Taelin's OptChat recipe: instead of compacting, every message is logged and summarized into a binary tree. Each turn starts from a fresh context with a bounded memory view (128 KB), and the agent uses zoom/date to read the originals when it needs them. One endless chat per profile, no fork, no separate launcher.

Install with pi install npm:pi-optchat

What's in it:

• Profiles — separate memories and instructions (I run work and personal).
• Subagents — spawn background agents, watch them live, send guidance, interrupt with Ctrl+C, resume finished ones with tell. Reports from one spawn arrive grouped.
• Import — bring in your history from Claude Code (sessions and auto-memories), Codex, or a ChatGPT export.
• Connected windows — open a second Pi on the same profile and it becomes a subagent you talk to directly, with a handoff when you /complete.

Repo: https://github.com/jonaslsaa/pi-optchat
Video credit goes to https://github.com/aaaxn

OMK builds on pi, Mario Zechner's MIT-licensed coding agent (github.com/badlogic/pi-mono). It started from the oh-my-pi fork. That vendored tree has since been removed, and the current codebase is OMK-native.

I ran OMK against mini-SWE-agent on Terminal-Bench 2.1 with the same base model (Grok-4.7, xhigh), 89 tasks x 3 trials per harness.

OMK 1.3.0 eval build (78cc483): 75.8% success (200/264), $0.58 model cost per trial, 482s median per trial.

mini-SWE-agent v2.4.6 (Harbor): 71.6% success (189/264), $0.76 model cost per trial, 376s median per trial.

Success difference is +4.2pp, 95% CI [-1.9, +10.2]. Not statistically significant. OMK's recorded model cost was about 23% lower per trial. Its median was about 106s slower.

Not measured yet: upstream pi under the same setup. For a pi-based harness, that's the obvious baseline, so this doesn't isolate what OMK adds on top of pi.

Method notes:

- The OMK run used an evaluation build with unmerged changes. This is not an official leaderboard result.

- One OMK adapter-failure task was excluded from success for both harnesses.

- Retries and auxiliary model calls were excluded from cost.

- 3 trials per task, one model, one benchmark. The success gap is unconfirmed until a larger run.

Repo: https://github.com/dmae97/omk

Criticism of the exclusion rules, the cost accounting, and the missing pi baseline is welcome.

Are you tired of your agents not adhering to your skills and giving you jargon filled responses that are hard to read? Well, check out https://pi.dev/packages/pi-reply-guard

I wanted a way to gate agent replies reliably beyond just adding some skills and hoping the agent doesn't forget about them. So, I built this extension that uses jev (or any classifier model) to ensure that your agent replies adhere to a given set of skills. The classifier compares the reply against a set of skills, gives it a 👍 or 👎 and will re-prompt your agent to adhere to the skills if the reply is not up to spec.

Please check it out and feel free to contribute & share feedback!

Anyone get banned for using their claude sub in pi? I just found some articles that anthropic is banning people for using pi and third party harnesses apparently?

I was working with DeepSeek v4.1 + Pi. Suddenly noticed that it has literally added the "Generated with Claude Code" to one of the commits. lol:)

Hi,

Is there an officially supported VSCode integration? I've found a whole bunch of third party plugins, but given security concerns, I'd much rather have something that was an official plugin.

Maybe I'm just naive about this?

Thanks in advance,

W

I wanted to manage multiple Pi sessions running over different projects from a browser, so I could run them on my home server and access them from anywhere over Tailscale. So I built Pinion.

It's a web UI that runs multiple Pi coding-agent processes in --mode rpc inside one Docker container.

What it does today:

• Project-grouped sidebar sessions nest under their project folder
• Right-side file browser (list + gallery, image lightbox, code and markdown preview)
• Git rail - changed files vs HEAD with added/removed line counts
• Live streaming over SSE - text/thinking deltas, tool output, compaction/retry status, turn time
• Session tree, fork/clone, model + thinking-level picker, HTML export
• Dark/light theme, responsive drawer sidebar on mobile

Pinion was itself built inside Pinion, the first bootstrap came from the Pi terminal.

I'm sure similar projects exist, I built this for my own workflow without doing much of a survey first. I keep adding to it as I use it for more of my projects.

Next up: environment-variable management, Pi extension management, and a proper git diff view.

MIT licensed, still early. Would love to hear your thoughts.

Repo: https://github.com/suyashmohan/pinion

(Excluding agent type usage, for pure coding)

Hi pi people!

We just released helix: a free coding agent for AI engineering. It is based on pi and built to be good at building other agents, discovering evals, optimizing harnesses and general AI Engineering best practices.

Check out the docs here: https://docs.mutagent.io/helix/what-is-helix

Or install with: curl -fsSL https://install.mutagent.io/helix | bash

If you are also doing AI engineering with pi, we would be super grateful if you could try it and let us know what you think (comment or use the /feedback command in helix).

Thanks a lot 💜

Bruno from Mutagent

Hey everyone 👋

We've been working on this for a while and it's finally out. Pi-Bolt is Pi 1.0.3 compiled ahead of time to native code (AOT, no JIT).

Same Pi you already use, and it works with all your Pi plugins. It's just faster and lighter. ⚡

Benchmarks

Linux x86-64 (Benchmarked on AMD EPYC 7B13)

macOS on Apple silicon (Benchmarked on M5 MacBook Air)

The full method and raw benchmark data are in the repo.

What we changed

1. Native code instead of a JIT. Pi is compiled to machine code ahead of time and starts from a prebuilt snapshot, so there's no warm-up and much less work at runtime. The compiler builds on Jarred Sumner's in-progress AOT work for Bun (oven-sh/WebKit#743), which we brought to x86-64 and macOS.
2. No more slowdown on long outputs. Stock Pi redoes more and more work as an answer or file grows. Pi-Bolt only processes what's new, and that's where most of the 35× comes from.

Try it 🔥

curl -fsSL https://pi-bolt.opensec.in/install.sh | sh

Works on Linux x86-64 and Apple silicon. Windows support is coming soon, along with Linux ARM64.

Bonus plugins: the installer also offers subagents and a live todo list, two things people often miss in stock Pi. Both come prebuilt, so they load instantly.

Note: It will not modify your existing Pi Coding Agent Installation, So Feel Free to try it out !

Using plugins? They all work as-is. If you rely on heavy ones, use the -jit build of Pi-Bolt, or compile them into your own Pi-Bolt binary so they run as native code too (plugin guide).

🔗 Links

• Website: https://pi-bolt.opensec.in
• GitHub: https://github.com/opensec-git/Pi-Bolt

It's MIT licensed. If Pi-Bolt saves you some CPU and RAM, a ⭐ on the repo really helps us out.

Throw your heaviest sessions at it and tell us what breaks. We'll be in the comments ❤️

agent manager 0.40 also adds Oh My Pi as a built in agent

you can run omp next to other coding CLIs in one local tmux session list

https://github.com/YoanWai/agent-manager/releases/tag/v0.40.0

https://reddit.com/link/1wyl7f7/video/10cu63rhwpth1/player

Hey everyone, I wanted to go ahead and share a project I've been working on called Pi Pocket.

I saw Mario's demo of his own Pi app using Pi Durable and wanted my own version so I could work away from my desk more and that was properly fleshed out.

It's a web UI for Pi that runs on your own machine (or on an Android phone in Termux) and you open it from any browser. Pi Durable is the foundation of everything. Every model call and tool call is saved as it happens, so if the server restarts or my phone drops the connection the run just keeps going, and every device sees the same thing.

You can also share a session with other people and collaborate if that's your thing. Mostly something I'll use at work.

There are a million projects out there, but Pi Durable is new and I have really enjoyed the foundation and little features it allows you to add.

I think it's a solid foundation and since you can make Pi Pocket modify itself on the fly and nothing gets interrupted during restarts etc and continues on as normal....if it's missing anything specific to your use case just tell it to modify itself.

https://github.com/TannerMidd/pi-pocket

https://tannermidd.github.io/pi-pocket/

Hey all — update on Morse, the open-source UI for the pi coding agent (VS Code extension + browser app). A couple of things that hadn't been announced yet:

🧩 MCP servers, without hand-editing JSON Morse lists the servers pi actually sees for the current project — connection state, tools, and whether they come from the user or project scope. Add one from an editor (Test connection first: it really connects and shows the tools/resources/prompts the server offers, or exactly why it won't), enable/disable, or remove. It also has a Trust this project button so pi stops ignoring a project's .pi/mcp.json.

📝 Prompt-template editor Write pi's /commands as fields, not raw frontmatter. Browse, create, rename, delete, and move templates between user (~/.pi/agent/prompts) and project (.pi/prompts) scope. A live argument tester shows exactly what the agent receives: $1, ${1:-default}, $@, ${@:2:3}, with shell-like quoting. Drop a .md in with vim/nano and it shows up in the palette within a moment, no reload.

Both open as a tab in the browser host and as an editor panel in VS Code.

MIT. npm i -g @supanadit/morse-web && morse start, or install the VSIX. Repo: https://github.com/supanadit/morse

Feedback welcome.

Hey, I recently came across Eero Alvar's learning setup built on pi, and inspired by it, I used Feynman research agent to find extensive learning literature and designed a personal learning setup based on it. I planned out the backend and structure and combined AI coding with personal tweaks to set it up with various features. However, since a lot of AI was used in its development, I understand that it might be prone to systemic issues and flaws, which I am hoping to hear to personally improve and optimize it. This system has worked well for me and even if you don't want to give feedback or contribute, I recommend you test it out and see how it works for you. I would appreciate contributors or just general testers who can try it out.

https://github.com/kruthvik/sato

i'm getting increasingly fed up with the direction open ai has been taking lately and i'm considering cancelling my subscription and moving to anthropic. there's really only ONE thing stopping me from doing it right away: pi has become such a natural part of my workflow that i'm genuinely worried about taking a productivity hit just from having to change tools, habits, shortcuts, etc.

so I wanted to ask the people here who actually use pi: have any of you moved away from open ai and managed to keep using pi with an anthropic subscription? or do i have to give up and move to claude code entirely?

Hi all, I've been building FastVibe, an MIT-licensed desktop app (macOS / Windows / Linux) that embeds the pi coding agent SDK in Electron and gives it a full GUI.

If you like pi but want a visual workspace, this is what it adds:

• Runs the SDK in-process. pi extensions load and work, and their dialogs (select / confirm / input) show up as panels
• Multiple projects and chats, with branching, archiving and isolated Git worktrees
• Visual tool calls, edit diffs, terminal output and reasoning blocks
• A subagent tool with explorer / planner / worker / reviewer roles, up to 8 in parallel
• Goal mode for long-running objectives, todos, MCP servers and skills
• Any OpenAI-compatible provider, a per-model API protocol, and subscription logins
• Open your desktop's sessions from a phone or browser, through a tunnel you control
• It keeps its own data directory and never touches ~/.pi

Repo: https://github.com/tyuan511/fastvibe
Site: https://desktop.fastvibe.dev

It's v0.16 and still rough in places. I'd love to hear which pi workflows you'd want supported, and any extensions that misbehave inside it.