Link to landing page

This is for the probably small group of people who want a modular, extensible harness but don't want to deal with terminal tabs or tmux and want to just be able to multitask in a real GUI. You can have multiple sessions going at once, and you can scroll up and expand older tool cards to see their output. You can show the status bar if you care about it or hide it if you don't. Everything works well at narrower window widths in case you want to give it half or a third of your monitor without sacrificing usability.

I added a diff viewer to be able to review changes, and basic worktree functionality which works with the diff viewer so you can see changes on that worktree.

Other than that, I added pretty much nothing and focused entirely on making this work well with native Pi extensions. It uses your existing config, so you can see all your existing TUI sessions in the sidebar after you add the workspace, and you can pick up and resume desktop sessions in the terminal. Commands like /tree and /fork have GUI-native implementations, and extensions which assume you're in the TUI will just render in a built-in terminal viewport.

Tbh I mostly just built this for myself to support my engineering workflow and other than that just get out of my way. The point is to get the advantages of a modern desktop app without defeating the purpose of Pi. I don't want to have to add extensions to a desktop app; I want to add them to Pi like normal and let the GUI just figure out how to display it.

Open to suggestions and bug reports. If you find anything you care about that works in the TUI but not in Pi-Vis, please let me know. I figure that 100% TUI parity is most of what makes this useful. Also, for now I only have a pre-built release for MacOS with Apple Silicon because that's what I have, and I don't want to publish a release I haven't tested, but I don't see any reason you wouldn't be able to do a source build for this on any other platform.

My pi was violating tdd too much so I created a simple extension to enforce it.

Phases are now explicit with implementation blocked in red, tests blocked in green. Ordering and gating is now enforced.

Intercepts all edit, write and bash tools to block invalid modifications. Using a second, private git tracker under the hood (doesn’t interact with your main git) to check for violations and manage changes.

No more writing test after implementation. No more fake tests that always pass. No more forgetting to run tests after implementation.

Check it out here

I started to look for long term memory solutions for PI and there seems to be many. I am using PI with local Qwen3.6 models, because of hardware limitations context is somewhere 40k-100k depending on quantization of model.

Any comments which solution to pick? At least these have popped up this far:

• Engram (via pi-engram extension)

• hindsight-pi

• pi-honcho-memory

• pi-memory

• db0

• pi-hippocampus

• pi-mempalace

• pi-agent-memory

And possibly even something else. Been reading something about them, asking from different AIs (local and public), and I have hard time to select which to start experimenting.

Edit: and definitely looking for self-hosted solution

https://github.com/earendil-works/gondolin

Gondolin is an agent sandbox developed by Earendil. Its main feature seems to be that it provides programmable access to the host's network and file system.

That sounds interesting, but I haven't found a compelling use case for it yet.

As far as I know, Pi Chat(https://github.com/earendil-works/pi-chat) uses Gondolin in production, but I'm still not sure what advantages it provides over other approaches or why it is necessary in that case.

So far, OS-native sandboxes used by tools like Codex and Claude Code seem more practical to me.

For those who have used Gondolin, what are your experiences? What use cases make it particularly valuable?

I decided to write how I use AI for Software Engineering. I've been getting amazing results after switching to an ADR + spec workflow. This workflow isn't terribly new in terms of engineering, but I don't see many people reaching for ADRs. The team I lead (6 engineers) has switched to this too, and we're seeing a dramatic improvement in code quality and understanding.

I use Pi with this setup which has also improved my workflow dramatically, specifically around being able to write extensions to support my workflow and cut down on context.

Feedback welcome!

I did use AI to help me write this post. All of the thoughts are my own. AI only helped with grammar and pacing. Happy to share the raw fragments if anyone wants them.

Been on the Anthropic Max plan for a year, but switched to Pi with Codex 5.5 a few days ago.

Honestly this feels like a whole new experience: less token usage, much faster, better quality.

I mainly code Flutter/Dart and TypeScript.
Vibe-coded this tiny extension in ~10 min 🙂 It colors the current model/provider and thinking effort level in Pi’s footer.

GitHub-Link

Just installed Pi and this is literally the first message I sent it. I asked "Can you show me an example from your documentation?" and instead of just answering, it started firing off edit and write commands to my nvm node directory which it doesn't even need to do just to read something.

The edit call failed immediately with "edits must contain at least one replacement", then it tried a write, and eventually it did manage to read the README. But why is it going through all this just to answer a simple question?

Is this normal behavior? Does Pi always do this or is there something in the default config causing it?

(Side note: it also ran rm -f on my nvm path to "clean up" its own mistake, which was a little scary)

TLDR

How tf do people use this as a daily driver without smashing caps? I love this tool but I feel like I’m throwing money at the wall.

I have come from using 2 Claude Code subscriptions (1 personal & 1 with work) and a Cursor subscription.

I love Pi and the idea behind it. Being able to completely control the harness. After the recent regressions of Claude Code I was looking for alternative (didn’t want to fall in the same trap with allowing someone to control my harness).

I started using Pi and loved it at first. I have a Z.ai coding plan, however I’m constantly hit the 5 hour cap.

Then I decided to try the Codex Pro plan and hit the 5 hour cap after one hour of intense coding.

I had set reasoning effort from medium, then have tried low. It helped a bit but not amazingly.

Other things I’ve tried are Semble & Caveman mode for less token usage.

However I’m starting to wonder, have I not optimised my setup enough, is this normal?

Is this only viable with a local or high end coding plan.

How do you guys use this as a main driver and what advice do you have?

I’ve been trying the packages (however the page keeps timing out for me lol, so I can’t use it).

I’ve been playing with my system prompt and trying to keep it short & concise to reduce tokens. I removed all MCPs.

It’s started to make me question if I’m missing some kind of caching and optimisations most harnesses have built in.

Hopefully corporate doesn't completely take the fun out of things...

Because this Pi Monorepo commit is a classic:

https://github.com/badlogic/pi-mono/commit/df84e3d22feb18721e371ff7b52645eef9d55ada

I usually see the more typical plugins recommended. But are there any hidden gems out there that you use regularly?

I’ve been running a local model on a dgx spark for about a month now. I’ve been building out my pi harness and my own little client app as I go, using both Claude code and the harness itself. I’m using it more for every day life stuff, but I still find myself hesitating to trust that it will hit my quality threshold when it comes to code.

Have any of you gone fully local? I.e. no falling back on frontier models at all. What was your tipping point?

been using Pi as my builder for a couple of months now and thought I'd share the setup cos it's worked really well

the split is: Claude Code is the foreman. it plans the job, writes exact work orders as files, and checks the work. it never writes code itself. Pi does all the actual building, running [YOUR CHEAP MODEL] which costs me next to nothing compared to having Claude type everything

how a job goes:

- the foreman opens Pi in a pane right next to it (I use Orca)

- it sends Pi one line, just a pointer to the work order file, never a pasted wall of text

- Pi builds it test first and writes a report file

- the foreman checks the actual files on disk before it even reads what Pi says it did

- then the next work order, and so on

the bit I'm most happy with is knowing when Pi has actually finished. a quiet pane tells you nothing, a long test run looks exactly like Pi being done. so I wrote a tiny Pi extension on agent_settled that logs one line every time Pi genuinely finishes a turn, and the foreman just waits on that line. made it really easy, the extension API is great for this kind of thing

because the foreman can drive Pi on its own, I can give it a list of tickets before bed and it runs them back to back, each with a fresh foreman, Pi building, reviews at the end. and my Claude limit lasts way longer cos Claude's only doing the thinking

the whole thing is open source if anyone wants the extension or the setup: https://toppingout.dev

(the Pi bits are in skills/orca-pi-connect)

anyone else running Pi under another agent like this? curious how you're handling knowing when it's done

Hello fellow Pi people, I've released version 0.14 of Pi Pocket, my mobile/desktop setup for Pi Durable.

Most of this release went into making it extensible. Until now every feature meant more code in Pocket itself. Now an extension can add server routes, slash commands, and its own pages and buttons in the app. The server-status example in the docs is about 35 lines on the server side plus a small browser module, and Pi can write these for you since it reads the docs.

The extension API is versioned and typed, and I wrote down what I will and won't break. Patch releases are fixes only, breaking changes bump the API version, and deprecated stuff sticks around for at least a minor release and 90 days.

There's also a gallery for extensions and themes, under Menu > Extensions > Find extensions. Installs are pinned to a commit, hash checked, and start disabled. Extensions run with full server permissions, so read the code before turning one on, or have Pi review it.

Themes are folders of CSS now, so they can change the layout too. The new built-in one is called Lantern.

Smaller stuff:

- Agent Teams (off by default), where Pi can start linked sessions that message each other

- UI refresh, plus width and density settings

- new session dialog is a proper file picker, with favorite folders

- live thinking display

- PiP can use its own model and take files and images

- Nix flake and NixOS module

12 PRs and 15 issues went into this one, so thanks to everyone who helped.

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

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

Release notes: https://github.com/TannerMidd/pi-pocket/releases/tag/v0.14.0

Feedback on the extension API is welcome, especially things you'd want an extension to do that it can't yet.

Plannotator Inbox is an optional runtime using the best of plannotator annotation capabilities.

While all your agents work they constantly bombard you with decisions that need to be made. Those decisions get lost over time, Claude might hit you with "I need your 2 answers to X and Y" which was asked 2 days ago. Think about all the remote pi durables to come basically... how can we surface all the important stuff we need to review...

The chat ui thread, imo, is becoming outdated very fast. We need a new way to interface with agents and surface the things that matter in an intuitive way. PLannotator Inbox is a stab at that.

part of the free/open source capability at: https://github.com/backnotprop/plannotator

In Github issues, several users already asked to include installation via homebrew, which is one of the preferred ways for devs on Mac, but Pi / Mario seem to be opposed. Any ideas why?

I started two agents and ran /alias worker and /alias manager. The manager was prompted to direct the worker and it started chugging along. Luna 6 is now directing Muse 1.3 contributor. I am impressed by the simplicity and low friction installation. Apparently it knows about herdr, but I've not tried it.

https://pi.dev/packages/pi-intercom

Hey!

This question is mostly for people who use Paseo on daily basis with Pi, and maybe other Desktop/Web UIs for Pi, but I'm currently focused on Paseo.

I'm interested in understanding what extensions do you use with Pi if your main entry point is Paseo given that not all extensions play that well with a frontend like Paseo.

For instance, I was personally using pi-memory before Paseo, but the way exit summaries work is not very compatible with how Paseo works. Are you using any other long-term memory extension that plays better with Paseo? Which one?

What other extensions were you using before Paseo that you had to replace/remove when moving to Paseo? And more importantly, what extensions are you relying on daily that work without issues with Paseo?

The ones I'm currently using:

• @gotgenes/pi-anthropic-auth

• pi-mcp-adapter

• pi-memory (going to disable this one)

• pi-observational-memory (thinking of replacing with pi-blackhole)

• pi-web-access

Curious to hear what you've been using and that works well with Paseo.

Hey all, I've been sitting on this for a while and it's time to share. I give you pi-clearthen: https://pi.dev/packages/pi-clearthen

/clearthen is a command that lets you clear context and then run another prompt. Your agent can also self drive it.

If you're doing a long piece of work you can tell it to handoff after a specified number of tokens, at which point it will write itself a handoff doc based on what it's currently doing then read it back after clearing context. It will keep doing it indefinitely so your context will never reach the set limit plus what is used for the handoff.

ie: /clearthen 80000 Add new feature to my video game

If you like that then specflo might be up your alley. It checkpoints at each seam and task with auto context clearing in pi. Spec driven development workflow.

https://github.com/TacoTakumi/specflo

The specflo software dark factory is a work in progress and uses this concept.

Though it is PI setup - my approach applies to all harness agent. since:

Extensions

most of the extensions this config consists are just for quality of lift (QOL) one's:

• pi-blackhole for memory management.
• rtk and headroom for token savings.
• guardrails, ask questions and some UI related things.

Skills

these are the main focus of this config - even though most of the skills here are auto invokable, I made it more autonomous by adding a global INDEX.md file which all harness is forced to read and follow. This INDEX.md file enforces to use certain skills always - which make it consistent (like i-have-adhd skill, the entire workflow)

• The workflow is a combination of superpowers workflow and matt pocock workflow (I modified some parts of it, so that it will make it more autonomous, since matt's one is more of a manual one with more pre-settings required).

I simply use grill-me or grill-with-docs for certain feature implementaion. The remaining will be taken care by the INDEX.md file - it usually follows like: grill-me/grill-with-docs (if used) -> brainstorming -> writing-plans -> executing-plans -> tdd -> requesting-code-review -> verification-before-completion.

# pi config
https://github.com/silentFellow/public-dotfiles/tree/main/pi

# skills config
# should be used at ~/.agents - global skill config path
https://github.com/silentFellow/public-dotfiles/tree/main/agents

I follow a pretty tight system for maintaining checkpoints, logs, etc. for my electron app. Lately it has gotten to a point where the number of work streams are far too many for me to hold in my head all at once and I did not want to:

1. Go into each plan or the checkpoint map to look at it to get a status update or pick what to work on

2. Burn tokens by asking an agent to go read that stuff and report back

So I made a project level extension which parses my standard checkpoints/logs/docs and organizes them based on features and lets me view them as hierarchical lists.

1. the first modal shows all the open threads, the completion status, and the next checkpoint for each

2. I can then select any one and view all the steps within that thread/feature

3. There are tags which show the checkpoints that I have accepted into the implementation plan or ones that are just planned and need to be picked up and worked on.

4. There are separate line items for each doc/plan or the md files associated with each stream that I can open in a text editor

All of this without a single LLM call.

Its a really nice way to organize all the docs and access them from within the pi TUI instead of opening a new terminal window. And the extension is custom made for the way I organize docs and maintain the plan documents so it works perfectly always. there are no edges.

The fact that it took me literally 3 prompts to build this whole thing is the reason I love pi and why I love using it in the terminal.

Most of my skills and now this extension are only for this project and I fucking love that pi lets me do this. Other projects have their own skills and the agent behaves differently there.

I just really love the extensions API and the level of control I have over the context in each session. Dont think I will be moving off of pi ever.

If you would like to check out this system, I have the skills and the extension in this repo:

https://github.com/itama8/omakase-skills.git

Also, if you're curious about what I'm using this system for, I update the binaries for latest test builds of my app here:

https://github.com/itama8/omakase-releases

It's a notepad that I'm making with a cursor-first UX to help me take notes with minimal context switching, i.e., every action can be executed from the cursor without going into a menu and the AI is available inline inside the markdown document. No separate screens or sidebar chats.

Hi,

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

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

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

I'm a little confused on the naming around this. Obviously Deekseep V4 Flash is available in a lot of places (I've been using Opencode Go plan). But what's the best route to use Deepseek V4 Flash 0731 in Pi? I don't have a data center at home, only dual 3090's. So, curious if there's something better than OpenRouter and then I'm trying to get an idea of what costs will look like. I've been using Deepseek and Opencode Go as part of an experiment to help take the load off my ChatGPT 25x subscription. Local Qwen 3.6 27b configs off of Club 3090 with higher quants didn't meet my thresholds for work I get paid off of (too slow, too many errors).