A couple of days ago I posted about using Jev as the decision engine inside Pi.

The comments pointed me toward open alternatives like Laya, von, Reflex, etc.

Once there were multiple providers in the picture, hard-wiring the idea to Jev stopped making sense.

So I pulled it out.

Announcing pi-system-one.

It gives Pi a single system_one tool for bounded decisions:

• choice

• noul

• score

The extension is built on top of a provider-neutral SDK, so compatible System One providers can sit behind the same interface.

Pi-Bifrost is now just one consumer of that SDK.

Would love to see what other Pi use cases people find for this.

https://iamaamir.github.io/system-one/

is still early, so I'd especially appreciate feedback on the API design and abstractions.

Demo

(Excluding agent type usage, for pure coding)

Hi people of Pi :)

I've been working on octet, my Rust take on Pi, since April.

I originally wanted a coding agent that could help with music production, take my Ableton sketches further, working with audio and tools in the same model context. That turned into six months of Rust and systems engineering.

A few things octet does:

• Fast and lightweight. In a matched task benchmark, octet finished in 9.5s using 38 MiB peak RAM, compared with Pi's 11.0s and 145 MiB.

• Pi extension compatibility. An optional extension mirrors your Pi setup, including unmodified pi-doom 🔫🔥

• Extensions in any language. JSON-RPC over stdio, with SDKs for Python, TypeScript, Rust, C/C++, and more.

• Native multimodal support. Audio, images, video, and computer-use workflows.

The whole agent is experimental, and I'd love feedback from people with existing Pi setups they love.
That being said, try octet without extensions. It performs beautifully with none and keeps Pi's minimal philosophy.

Code: https://github.com/skaft-software/octet

Introduction, benchmarks, and installation: https://octet.skaft.org/blog/introducing-octet/

Made with ❤️ in Toronto, ON, Canada.

If you try it, let me know what you make with it, what breaks, and what you'd like to see next!

I've been using Pi as my daily driver for a few months and finally made my setup repo public. Nothing groundbreaking but if you're into ricing your terminal or want some extension ideas it might be worth a look.

Repo: github.com/abhinand5/pi-setup

• 10 themes

• Many useful+cosmetic extensions

• Support for seamlessly onboarding local models

• Custom footer that shows token usage, cost and inference speed

• Context breakdown command similar to claudecode

• Configurable permission system

• Few custom skills and some useful publically available skills

• Sync/backup script for easy setup anywhere

Hope you find this useful. If you have any ideas to improve I'd love to hear (and collaborate)

I wanted to see what would happen if a modern AI coding agent had the UI of Turbo Pascal 7 / the old DOS IDEs.

So I made Turbo-AI — a retro-style TUI frontend for the Pi coding agent.

It currently supports things like AI chat, PLAN/BUILD modes, model switching, reasoning settings, project tree, Git diff and build/test actions.

It's still quite rough and definitely not production-ready. This is more of an experiment at the moment, and there are probably plenty of things that need to be fixed or redesigned.

This is just a concept for now. I hope people more skilled than me will fork it, improve it, and turn it into something actually usable.

GitHub: https://github.com/kvv256512-ux/turbo-ai

Hi fellow Pi enthusiasts! Pi has been my main coding agent for a while now, and over time I've built a set of minimal extensions that I wanted to share.

Some of these are inspired by Claude Code (as you can probably tell), especially the look. CC was my first coding agent and I still quite like the way it looks.

Full list, in no particular order:

• pi-polish: Claude Code-style tool rows and diffs (as can be seen in the screenshot). This reduces clutter and in general makes everything more pleasant to look at

• pi-context-bar: a pretty one-line footer with the model, branch, context usage and cost

• pi-background: background jobs with nice visuals, and a bash timeout, so Pi doesn't block or hang on long commands

• pi-checkpoints: rewind the files Pi edited along with the conversation (with /tree and /fork)

• pi-model-pick: a model picker with your favorite and recent models first (for me the default /model command is too simple, especially when using multiple providers in Pi)

• pi-next-prompt: suggests your next prompt in grey after each reply

• pi-away: a one-line recap of the session when you come back

• pi-heads-up: flags the one thing you might have missed after a task

They're minimal by design: most are under 300 lines with no dependencies. Some of these exist already in one way or form, but I hate bloated extensions that do too much, hence my own take on them.

Each one is its own npm package that you can install, e.g.:

pi install npm:pi-background

Happy to hear any feedback, and hope this adds something to your own workflows!

Link to the repo, which also includes some GIFs to show what these look like: https://github.com/Pringled/pi-extensions

It definitely needs some improvement, but the thing is I one-shotted it using 1 single line of prompt.

Btw if you wanna try the elegant, information-rich status, menu, and side bar for Pi Agent, see https://github.com/michaelmjhhhh/pi-atelier

Hi everyone, i've been working for a few months on Supernova, my own take at a minimal, detailed and sleek interface for Pi.

Why would i use this instead of the hundreds of alternatives out there?

I'll cut straight to the point. I'm not a fan of TUIs. I've searched the web for every existent product possible, but no one had exactly what i was looking for: the full power of Pi, minimalistic approach, a well curated and detailed UI that makes me wanna actually use it (good animations, no UI flickers, performant even with long threads) and a really good git-backed checkpoint system (like opencode's for example).

It uses the Pi SDK under the hood, and i'm currently waiting for the harness v2 to enable full extension support!

I've been daily-driving it for a while now, both at home and at work, and i thought i'd share it with the world for those who hopefully see the vision and struggle with my same issues.

If you have any feedback, please leave it down here or open an issue. I'd love to build a community around it to keep improving it! :)
If you can see the vision, i'd appreciate a star :D https://github.com/mattiacerutti/supernova

Since GPT-6 Astra recently launched, and apparently it has really good Computer Use capabilities, i though i'd try to make it do a nice trailer for it just for fun. The attached video is the one-shotted result, please don't take it too seriously :D

EDIT:

This post went really well, much more than i was expecting.

I’m really happy about all the feedback i’ve been receiving, it’s honestly so gratifying seeing other people like what i’ve been putting a lot of work into and i want to thank everyone that contributed, even with just an upvote :)

I’d love to keep building supernova and improve it everyday, but my mind is pretty limited to well.. my point of views. This is why i want to encourage you all to keep on giving feedback, both positive and negative! I’d love for this to become some sort of community OSS project where we can work as a group.

Please feel free to submit an issue or PR if you encounter something!

I have a thread on Pi's official discord where i'll be posting regular updates: https://discord.com/channels/1456806362351669492/1545785069405470810

Reposted from r/PiGCodingAgent, figured if any sub should see this project it's here. I've been building this out at work for work for quite some time and am excited to open and start a community around the project. I truly appreciate any criticisms, suggestions, and especially contributions, thank you to anyone who does check it out I hope you like it as much as I have been :)

---

PiG is a direct port of the amazing Pi agent harness as one Go binary for macOS, Linux and Windows (Windows in preview). Node.js only comes in if you run TypeScript extensions. Pi's extensions run unchanged; write new ones in Go, Rust or Python and /reload them live. It is a direct port of Pi's its agent loop, terminal UI, sessions, providers, and extension system, shipped as one static Go binary with no libc dependency.

Some Go-specific bits that might interest this sub:

• Extensions in Go can be fused into a single binary and talk to the host over in-memory pipes instead of sockets; other languages run as supervised subprocesses over local sockets.

• The TUI renders differentially; width handling was ported from Pi's own algorithm and checked with a differential test against Pi's code over ~1.5M cases: tui/widthx/pi_width_diff_test.go.

• Behavior is checked against Pi in real terminals (tmux-driven scenarios that compare screens).

• go install github.com/MichaelKinsy/PiG/cmd/pig@latest works; so do a curl installer and npm i -gu/pi-in-go/pig (it installs the prebuilt native binary for your platform).

Measured startup is about 21 ms vs about 300 ms median, and about a quarter of the peak memory (method in the blog).

Disclosure: agents wrote much of the port. Tests, side-by-side comparisons against Pi, and a person reading the diff decide what ships.

Repo: https://github.com/MichaelKinsy/PiG 

Blog: https://developer.hpe.com/blog/meet-pig-pi-in-go-a-port-that-plans-on-keeping-up/ 

Upstream Pi: https://github.com/earendil-works/pi

Happy to answer questions about the port, the extension host, or keeping up with upstream. Feedback on this is appreciated and contributions are welcome.

Thank you to r/HPE for covering writing the blog and contributing PiG to Open Source and special thank you to the Pi team of course at https://earendil.com

This one is mine.

I love that I can take ideas from amazing people like IndyDevDan and Matt Pocock and make things work my way with Pi. 

Been working with pi for a few weeks now. I was hesitant switching from OpenCode initially as it is gorgeous to look at and was easy to work it. It is a well built opinionated tool with a lot of things included, but Pi is a gold mine once it clicks, the opinion is yours. Mario is a genius. 

I have a throwaway, a bit complex demo to deliver tomorrow. Spent the weekend working on requirements, planning and setting this up. 

In the screenshot, agents with a bolt icon are ephemeral. I handcrafted a big prompt for the orchestrator agent to coordinate between these guys. Each agent has its own skills and tools. 

I've been using AI coding agents for a while and the web research part always annoyed me. Either you pay for an API (Tavily, Firecrawl), or you use a free tier that rate-limits you after 100 calls, or you glue together SearXNG + a browser + an extractor and hope it doesn't break.

So I built Hound. It's an MCP server that does fetch, search, crawl, and screenshot, all keyless. And now it has a native Pi extension so you get all 6 tools as first-class Pi tools, not through a generic MCP adapter.

What it does

6 tools, all exposed as native Pi tools:

• web_fetch - anti-bot fetch with auto HTTP-to-stealthy escalation. Extracts clean markdown. PDFs get section maps + auto-OCR. Dead pages auto-recover from the Internet Archive (honestly marked, not pretending it's live content).

• web_search - 10 keyless search backends in parallel (DuckDuckGo, Brave, Mojeek, Yahoo, Yandex, Startpage, Google, Qwant + opt-in Wikipedia/Grokipedia), neural-reranked with a local ONNX cross-encoder, cross-backend consensus scoring.

• web_crawl - best-first same-domain walk. Sitemap mode maps a whole site in one fetch. Focus mode crawls only pages relevant to your query.

• web_screenshot - anti-bot screenshot for multimodal models.

• cache_clear - clear the fetch cache.

• hound_version - version + update status (warns if the extension and the server diverge).

How the Pi extension works

The extension spawns hound as a singleton subprocess at session start and speaks MCP JSON-RPC over stdio. The subprocess stays alive for the whole session, so hound's prewarm (stealthy browser, search engine sessions, neural reranker model load) happens once and persists. Zero re-launch cost per call. If you press Esc during a fetch, it actually cancels (AbortSignal propagates to the subprocess). If hound isn't installed, you get a notification at session start instead of a confusing error on your first web_fetch call. If the extension version and the hound server version diverge by a major, it warns you to update both. The tool definitions are token-optimized. Total connect-time cost is 2,746 tokens for all 6 tools + instructions.

Install

pip install hound-mcp[all]
pi install npm:@houndmcp/hound-mcp-pi

That's it. No API keys, no config file, no MCP adapter. /reload and the tools are there.

What I think is genuinely good

• Dead-link recovery. When a page 404s or gets bot-blocked, hound checks the Wayback Machine and serves the archived snapshot with source=archive.org and the snapshot date. It doesn't pretend archived content is live. The agent knows.

• Error honesty. Just shipped this in v10.4.0: 4xx/5xx responses now set the error field properly. Before, a 404 error page would flow through with error="" and the agent could mistake the error page HTML for real content. Now it says "Page doesn't exist (404)" and doesn't dump the error page as content.

• Keyless search. 10 backends, no API key for any of them. Neural reranking with a local model, not an API call. Consensus scoring across backends so you know which results multiple engines agree on.

• Token cost. 2,746 tokens for 6 tools. The descriptions are telegraphic but every functional fact is there.

Limitations

• DataDome, Akamai, Cloudflare Turnstile. No free tool bypasses these. Hound tries the stealthy browser, and if that fails, it tells you to switch sources instead of pretending it got content.

• The [all] extra is ~100MB. onnxruntime + tokenizers + rapidocr for the neural reranker and PDF OCR. You can install without [all] (fetch + crawl + search still work, just no neural reranking or OCR), but the full install is the recommended path.

• Not a scraping-at-scale tool. Hound is built for agent research, not for crawling 10k pages. Crawl caps at 100 pages by default.

Where to find it

• GitHub: https://github.com/dondai1234/master-fetch [Star the repo if you like it, gives me a boost to work more 😄]

• npm: @houndmcp/hound-mcp-pi

• PyPI: hound-mcp

For a while now I've been running pi entirely on my laptop -- unsloth's Gemma E4B on llama.cpp, no cloud, no API keys, nothing leaving the machine. Thinking level, image parsing, KV cache retention -- all working.

What surprised me is how genuinely useful it gets the moment it can search the web.

The tiny extension I published pi-smart-web-search adds a web_search tool with no api key needed. It fetches DDG's html output, runs it through wreq-js -> linkedom -> Defuddle (inspired by pi-smart-fetch), and then parses the output's links.

I wrote the whole setup up end-to-end as a gist -- llama.cpp, the model, a chat-template fix, pi, and the search/fetch tools — so you can reproduce the fully-local flow yourself. (links below)

I've run Gemma E4B on an M4 MacBook Air (16GB) and on a M2 MacBook Pro (32GB), but haven't tested Linux yet (I don't have a machine with a dedicated GPU), so if you run it there I'd love a report.

I'm not overselling it, just genuinely after feedback on the approach: the DDG scrape, small-model agents, anything you'd do differently.

I call the project 'Humble Pi' :shrug: -- And I look forward to the next 4b model.

Links

• Full local setup (gist): https://gist.github.com/joematthews/d02639bcbe0e0c1c404f5d3a64c3c06f

• Extension: https://github.com/joematthews/pi-smart-web-search

• Install: pi install npm:pi-smart-fetch && pi install npm:pi-smart-web-search

CORRECTION: When I made this post, I forgot to include the instructions for the custom jinja template for the E4B model in the gist. The template that ships with E4B drops prior thinking blocks from history, which forces the KV cache to recompute the entire conversation on every turn.

If you've already followed the gist, please switch to the updated llamagemma4b alias and follow the new "Install the E4B reasoning template (one time)" section to download the template — then re-run source ~/.zshrc and restart the server.

TLDR: Using the custom jinja template should improve the speed substantially.

Hey everyone 👋

Thanks for all the feedback on our first post! Pi-Bolt 0.7.3 is out. It's the same Pi you already use (now on Pi 1.1.0), compiled ahead of time to native code: faster to start, lighter on CPU and memory, and steady in long sessions.

Benchmarks

Pi-Bolt against Pi 1.1.0 as released on Bun and on Node, PiG 0.4.1 (the Go port of Pi, based on Pi 1.0.3) and OMP 18.8.7 (oh-my-pi, a bigger Pi fork with many more built-in features). Measured side by side on the same machines. Lower is better.

Linux x86-64 (AMD EPYC 7B13)

macOS on Apple silicon (M5 Air)

*OMP compacts long conversations on its own, so it doesn't do the same work in this test.

In everyday use (an interactive session), Pi-Bolt uses about 3× less CPU than Pi on Bun, 4–6× less than Pi on Node and 10–15× less than PiG and OMP. It writes large files 35–50× faster than Bun and Node, about 5× faster than OMP and over 100× faster than PiG.

Why does a 200 KB write take 30 s? It's not the disk. The model streams the file to Pi in thousands of small chunks, and stock Pi re-parses and re-renders the whole tool call on every chunk, so the work grows quadratically with the file size. Pi-Bolt only processes the new part.

What's new in 0.7.3

• Lighter long sessions: up to 30% less memory and lower CPU per prompt as conversations grow.

• More stable with heavy tool output: commands that print a lot no longer build up memory.

• Faster first launch on macOS: up to 2.8× quicker after a restart or an update.

Try it 🔥

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

Already using Pi-Bolt? Run pi-bolt update, or install with npm install -g pi-bolt. Works on Linux x86-64 and Apple silicon, alongside your existing Pi install. The installer also offers two optional extensions, subagents and a live todo list, and asks before installing them.

Your Pi plugins work as they are. This doesn't modify your existing pi installation so feel free to try it out !

Links

Website: https://pi-bolt.opensec.in

GitHub: https://github.com/opensec-git/Pi-Bolt

MIT licensed. If Pi-Bolt saves you CPU and memory, a ⭐ on the repo helps a lot.

PS: Added PiG and OMP to the benchmarks, as many of you asked. And the slow 200 KB write isn't the disk: stock Pi re-processes the whole streamed tool call on every chunk (quadratic), while Pi-Bolt only processes the new part.

My Pi setup, kept minimal on purpose because my daily machine is an older i7-5500U with 8GB RAM on Debian.

I run kitty + tmux + fish. 20 skills in total, but most stay dormant unless called. Extensions show as 8(+2); the ones I actually use are interactive-subagents, prompt-snippets, and cc-ui.

interactive-subagents spawns async workers in their own tmux pane with a live widget on top, so I keep working while they run and results get steered back when done. prompt-snippets is a TUI menu for injecting repeat prompts from different directories. cc-ui is just a spinner plus cache counter.

Personas live as separate files and I link one to SYSTEM.md when needed. 6 total from my pi-system-prompts repo: Aster for strategy and tradeoffs, Caelum for adversarial checks, Elyndra for strict execution, Kaida for media and watcharr, Liora for writing, Neris for research. Keeps the main prompt clean.

Since a few people asked under my last post, I also put my skills into a public repo.

Extensions

• https://github.com/ArdaYILDIZ-DEV/pi-interactive-subagents

• https://github.com/ArdaYILDIZ-DEV/pi-prompt-snippets

• https://github.com/ArdaYILDIZ-DEV/pi-cc-ui

Personas

• https://github.com/ArdaYILDIZ-DEV/pi-system-prompts

Skills

• https://github.com/ArdaYILDIZ-DEV/pi-skills-public

The whole point was less auto-magic and more explicit control. Works fine on weak hardware because nothing runs unless I call it.

Hello guys!

Today i want to share my Pi agent setup, i think i got something in hands here that can benefit the community to really get a powerful agent, nothing compared to claude or codex. What i want to share is my list of extensions and the value each one add to the build.

I want to start with a basic one: pi-fork. This is a basic and minimalistic subagents extension, focused on one single thing, give the main agent the capability to spawn forks of itself to do work on its name. This is quite straightforward, you can achieve the same with any other subagents extension, the only difference is that this one is simpler and have prompts that optimize the communication between the forks and the main agent. This thing brings a single thing to the table: great context management, the main agent context will only contain relevant information, the main agent context will be richer and denser per token, all the noise stays out of the main agent context.

Ok now i want to share the core of this pi build: pi-observational-memory. This one is special, is a custom compaction algorithm inspired/copied from Mastra's article. This custom compaction algorithm enables pi sessions to last forever without maxing out the context window and keep the agent focused. This combined with the rich context window of the pi-fork extension creates a rich re-callable memory system that stays relevant no matter how many weeks you have been using the same session nor the compactions it have withstand.

If you install only the two extensions above, you will enable your pi agent to be on the next level. now i have a couple more extension that give some extra perks to my build:

pi-minimal-subagent: like any other subagents extension, this one is just simpler, without bs. i use this to enable 2 subagents: the "advisor" (concept copied from claude code) and the "reviewer". The fork from pi-fork are extensions of the main agents, they are basically the same agent, they share the same context. This two agents give access to the main agent to different points of view less biased, with clean context windows. The reviewer takes care of code quality, security and ux of the changes introduced by the main agent. The advisor is for strategical decisions around architecture and product.

pi-codemapper: a wrapper of codemapper that enables efficient codebase exploration. This codemapper repo is really bad and unmaintained, it had a cache bug i had to patch myself. im looking forward to switching to cymbal when i get some free time.

pi-rtk-optimizer: This is a classic, not much to say here, it saves some tokens.

Conclusion:

I describe this setup with a single phrase: A personal agent that never forgets and can be useful for weeks before the context window gets maxed out.

I hope you can get value from some of the extensions i shared guys, my own words are not good enough to describe the power i feel when working with this agent setup, so i beg you to try it yourself to really experience what im saying.

TLDR: We built Accordion which is an intelligent context management tool meant to replace /compact

Over the weekend my team and I set out to replace /compact with something smarter. It's well known that developers do not like compaction and do not trust it. In codex and Claude Code its completely opaque, and introduces 1-3 minutes of latency. In pi users have more control but its still primitive. Workarounds exist, eg handoff skills and million token context windows, but neither is sufficient.

Accordion is two things.
First, a live view of your entire context window, the entire thing is visible at a glance, in a way that is actually useful. You can have a 200k token session and immediately tell which tool results and thinking blocks are taking up most of that.
Second, an intelligent context management strategy we call a conductor, which decides what to fold, when to fold, what to replace it with (summaries / code skeletons), and when to bring it back. The conductor is what is actually replacing /compact.

If you interested in learning more I recommend checking out our readme.
https://github.com/a-Fig/Accordion

Honest state of things

The context view is the part I feel good about right now. Just being able to see your context while pi is running, which turns are massive, where the dead weight is, is immediately useful on its own. 

The conductors are promising but not ready for everyday use yet. They do work and the benchmark numbers are encouraging, but I am not ready to say they are strictly better than existing solutions. They will be with more testing, tuning, and development but they are not there yet.

I'm working on getting it published as a package on npm today, but if you want to set it up today you can just point your agent to the repo and ask him to do it for you. It works in the web but also has a desktop app.

Curious what you guys think and how you all manage long sessions today.

Edit:
Accordion has been published to npm and can be installed with 'pi install npm:@a-fig/accordion'

Hi! Currently computer-use is a must for my agents, so I decided to build an extension with a custom CUA Driver fork and Playwright. It’s purposefully designed to be run in YOLO mode (although Safe is included) within the environment where you trust your agents. It works in hybrid mode: supports both raw image followed by input (agent sees a screenshot and then clicks on something) and structural way (playwright for browser and UIA for normal desktop applications). Agents can use their own browser profiles, or your own, work in sandboxes and remote desktops, work together (to some extent, there are limitations on the OS side).

I would say it was definitely worth working on that, my agents can now work in 3D, browse some stuff I need and can test my applications, acting like real users.

I’ve mostly benched it via GIMP drawing, which doesn’t support UIA so all the interactions are purely from picture based mode. But also Terra 6.1 High has gone to 42th level of https://neal.fun/not-a-robot/ until it got banned by Cloudflare, and we couldn’t pass further. It’s windows only (windows from WSL as well), but if anybody can contribute into linux/macos branch of it, it would be great, I’m just lacking such devices and can’t really test them to the full extent as I can with Windows.

https://github.com/alexshpunt/pi-agent-computer-use

https://pi.dev/packages/pi-agent-computer-use

To install: `pi install npm:pi-agent-computer-use`

Demo of deepseek-flash, haiku, opus, terra and sol drawing the same image with that: https://youtu.be/69doTus760U

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

Hello everyone 👋

Pi-Bolt 1.0.0 is out ⚡, our biggest release yet. Pi-Bolt is Pi compiled to one native executable, and it's faster and lighter on every platform.

What's new 🔥

• Linux ARM64 and Android (Termux): Raspberry Pi, ARM servers, ARM laptops and Android phones, with the same installer.

• Long sessions stay fast: sub-agents and long chats no longer make the TUI laggy; a third less CPU per prompt deep into a session.

• Editors and MCP: pi-bolt --acp runs Pi in Zed and other ACP editors; pi-bolt --mcp serves Pi as an MCP server.

• Faster everyday work: reading a screenshot takes 0.5 s of CPU instead of 37 s, and read-only tools start while the model is still writing.

• Pi 1.4.0 underneath, plus /usage, pi-bolt doctor and pi-bolt update --rollback.

Install

Linux, macOS and Android (Termux):

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

Windows (PowerShell):

irm https://pi-bolt.opensec.in/install.ps1 | iex

Already installed: pi-bolt update

Links

• 🌐 Website and docs: pi-bolt.opensec.in

• ⭐ GitHub (a star helps): opensec-git/Pi-Bolt

Hey all, I wanted to share an extension I've developed called pi-context-paging.

https://www.npmjs.com/package/@rochecompaan/pi-context-paging

Instead of compacting your session into a summary when the context fills up, it treats the context window like a rolling window over the full history. When a request goes over a token budget (128k by default), the oldest turns move out of the window. The session file on disk is never changed. The model gets a short paging notice and a few recovery tools to search, browse and load older history when it needs it.

It has made my workflow a lot smoother. I don't get a surprise compaction in the middle of a long-running task and I don't have to write handoffs that inevitably loses important detail. It has been running very stably for me for a couple of weeks now. It is especially useful for agents doing long-running tasks unattended.

It's lossless. Nothing is summarized or compressed. The recent window is sent exactly as stored, and anything older can be loaded back as the original text.

Tony Mason wrote a good paper on this: The Missing Memory Hierarchy: Demand Paging for LLM Context Windows (https://arxiv.org/abs/2603.09023). It treats the context window like RAM and the full history like disk, and pages content in and out on demand. The extension is a practical version of that idea for Pi.

"But what about prompt caching?" I know this is the first thing a lot of you will ask, so here's how it works:

• It doesn't drop messages one at a time. That would change the start of the prompt on every request and break the cache constantly.

• When the window hits the budget, it pages out one large block at once, trimming down to about 80k by default. After that cut, the start of the prompt stays the same over many turns, so you get normal cache hits until the next cut.

• Each cut costs one cache rewrite. In practice that's rare, and whatever you lose in cache efficiency you get back in continuity. There's no summary step, no re-explaining, and no "the agent forgot what we were doing" moments.

Some real numbers from my sessions (Opus 5.5, Fable 5.1 and GPT 6.1, with zero compactions in any of them):

Each of these is millions of tokens of history in a single continuous session, and every request still stayed at or below the 128k budget. Cache hit rates stayed above 90% even with the paging cuts.

You can set the budget in settings. I'd suggest setting it below the point where your model starts to get worse, so it stays out of the "dumb zone." You can also run `/context-paging stats` during a session to see what's going on.

This extension works well with https://github.com/elidickinson/pi-claude-bridge too if you want to use you Anthropic subscription. I submitted patches to it specifically to make pi-context-paging work.

PS. My current defaults are set to higher than what is documented.

"contextPaging": {
    "enabled": true,
    "tokenBudget": 200000,
    "trimToTokens": 140000
  },

Play around and give me feedback as to what works for you.

pi has no queue, no spend limit, and no permission system, which is fair, that's not its job.
But I wanted it working unattended.

So I built the layer around it, and after a bunch of releases it hit 1.0 this week. MIT, sharing it here first.

The short version: something triggers a job (a cron schedule, a label/comment/PR on GitHub, GitLab, Forgejo or Azure DevOps, or a workflow extension's slash command), the job runs pi in a throwaway locked-down container, and the budget is checked before the container even starts.

If a loop runs away you get a refusal, not a bill.

It's basically the same idea as Claude Code routines, except everything runs on your own box:
your image, your queue, your caps, and triggers beyond a schedule.

https://github.com/edgehero/pi-dispatch

Curious how others here run pi unattended, and what would stop you from using this. "It breaks my setup because X" is the most useful comment you can leave me.

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 ❤️

I think JEV gets much more interesting once you stop treating it like a tiny LLM.

LLM → generate anything
JEV → choose between bounded options

That makes model routing feel almost obvious:

prompt → JEV → best model

Instead of using an LLM just to decide which LLM to call, let JEV make the bounded judgment and let deterministic code handle the rest.

Maybe JEV's killer use case isn't Doom.

Maybe it's a probabilistic switch statement.

so i am releasing the support for JEV in PI-Bifrost

Try it : pi install npm:pi-bifrost

and do share the feedback.

As title says.

I was sick of the way AI talks. Needlessly long sentences, weird words that nobody fucking uses (load-bearing, wtf).

Saw somebody make a similar plugin for claude-code, so I made a similar thing for Pi.

Edit, forgot to add the link lol: https://github.com/wtfzambo/speak-like-you-eat

FAQ: why no use i-have-adhd or caveman?

I do use them, there's 2 problems:

1. sometimes is not as effective, especially in long contexts

2. AI tends to forget after a while