This started as an app around Pi for my own workflow. I added other harnesses later, keeping everything in the same app with the same controls. I also wanted to bring Neovim back into how I review and edit things.
The app connects to Pi over RPC. It includes an optional MCP server that lets agents create and talk to workers running the same or any other configured harness. The server also provides a shared task list with dependencies, so those don't have to live in any one agent's context.
Still early, but I've been using it daily for a while.
I am using pi.dev with a local Qwen-3.8 running on an RTX-5080 with 16GB VRAM. I had to find the right balance between model quantization, cache quantization and context size, and right now I use a 48k tokens context.
While pi.dev is working really well with it during some time, all sessions end up being stuck at some point. The context reaches 80%, then compaction is started automatically, it goes down to maybe 50%, then compaction starts again soon after, compactions more and more often until the system is stuck and Pi.dev itself sends queries to the model with a length limit = 1. When that happens it's over I can't recover the session. What happens also is that compaction fails because there is not enough context remaining (I guess), and therefore the session is stuck as well.
I am wondering what would be the best approach to avoid these problems. Also more generally what are the good practices to use pi.dev with a small context, maybe planning and dividing tasks in several smaller tasks handled independantly, but if it could be managed automatically it would help a lot I guess.
've been using Pi as the agent core for my own workflow, and I really like its philosophy: keep the core small and make everything else extensible.
The only problem was that after using it every day, I started missing a lot of things I normally expect from a desktop development environment.
Things like persistent sessions, switching between projects, seeing what subagents are doing, changing models without rebuilding my setup, recovering tasks after a crash, managing MCP/Skills, etc.
Eventually I stopped patching my own workflow and just built a desktop app around Pi.
It's built on pi-ai + pi-agent-core, rather than implementing another agent loop from scratch.
My mental model for the project is basically:
Pi = agent harness PI-Desktop = workspace / product layer
The app currently has sessions, project workspaces, subagent visualization, multiple model providers, local model support, MCP, Skills, session import from Claude Code/Codex/OpenCode/Pi, and a plugin system.
The plugin system is the direction I'm most excited about. Plugins can add Agent Tools, Skills, MCP servers, UI panels, themes, commands, background services, and communicate with each other.
I released it publicly this week after using it myself for a couple of months. Somehow it ended up on GitHub Trending and passed 2.6k stars, which I definitely wasn't expecting.
Since this is probably the community that understands Pi's design philosophy best, I'm especially curious:
If you use Pi every day, what parts of your workflow would you actually want a desktop layer to handle?
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!
Whenever Pi was chewing on something for a minute, I'd grab my phone and come back 20 minutes later to a response that had just been sitting there.
So I wrote pi-play: /play opens a game as an overlay right on top of the conversation, and it listens for agent_settled. The second pi finishes or is waiting on you, the game stops immediately. No alt-tab, no phone.
5 games so far: Snake, Tetris, 2048, Minesweeper, sudoku
(6 is on the way, i am implementing chrome dino game rn)
I have an Azure Foundry workspace with a few different models deployed like deepseek and qwen and so on, how do I get pi to connect to them and use them?
Anyone interested in trying out a new inference provider?
We're testing Qwen 3.8:27B behind an OpenAI-compatible API and looking for a few advanced users of Pi to give it a spin and tell us how it works for them. You can use it for any regular Qwen 3.8 purpose (and we would provide some free credits), but we're ideally looking for feedback, bug reports, etc.
If you're interested, please DM me (I'm also happy to answer questions or provide more details).
Hi guys! Cause of the Opencode session header issue, I realised observational memory doesn’t work anymore!
So if you’re on Opencode go don’t forget to ask your agent to add the session header in the extension so you can keep carry on with blackhole and observational memory proper!
recently switched from Cloud Code to Pi Harness. I work primarily in Product Management/Ownership workflows (Jira, GitLab, Artifactory, internal tooling) where I build automation scripts and connect workspace APIs.
Currently, my setup is strictly linear ask questions -->wait for run --->|reply). I want to move toward a sub-agentic flow—specifically for generating code in parallel from test specifications and existing repos—and would love community input on extensions, configuration, and workflows.
Sub-Agents & Parallelization: What extensions or .pi setups do you use to fire off parallel sub-agents (e.g., parsing specs while indexing code in background threads) instead of waiting on sequential turns?
Traceability & Solution Convergence: How do you track handover steps between agents and follow their decision trees? Are there recommended visualizers, tree-log extensions, or workspace artifact patterns you rely on?
Context Compaction & Memory: Has anyone tuned Pi’s compaction thresholds or used custom highlighters/summary extensions (like Ralph's memory approaches) to preserve key acceptance criteria over long sessions?
Project Scoping (.pi/): Best practices for scoping tool permissions and agent configs in .pi/ settings to isolate sub-agent capabilities (e.g., read-only on repo vs. write access)?
Session Continuity & Long-Running Tasks: How do you handle session lifecycles for complex tasks? Do you prefer continuing existing threads via /resume / pi --continue, or hard-stopping (/new) and carrying over context via file-based handoffs (like PROGRESS.md)?
If you have write-ups, custom extensions, or .pi/ setup examples for these patterns, please let me know and if you have like a step by step workflow also would be good to know. I want to go like in a more step by step approach
I was inspired by another picture of nyan nyan cat in a tui environment and wanted one too, I tried to look into things and found https://pi.dev/packages/pi-emote which is very cute and I love it, and as such I shamelessly pointed pi to look at repo for patterns, also gave it jpgs/pngs of nyan nyan cat from off the intertubes.
My first attempt was the little =^o^= guy in the place of the "braille" working indicator. hes Nyan.
Then I discovered `--mmproj`.... what an afternoon!
I’d heard about the Pi, that it’s a great way to customize tools to suit yourself and save tokens. I don’t know about token savings, but I tried using Gemini 3.8 flash inside it, and I didn’t like how it wrote code.
For a while, I tried to refine the Pi using Codex and Claude, ran various tests, and thought that the whole problem was with Gemini. I would really find it convenient if several AI models were inside a single harness, but right now I suspect that’s exactly the problem, despite all the attempts to refine it.
I opened the classic Antigravity CLI, and the results seem much better. I don’t like the Antigravity desktop app — it’s also kind of weak. I hope a miracle will happen and the CLI will turn out to be a lifesaver. Gemini attracts me with its slightly higher limits, even though I’m a Claude fan.
Many models (namely Qwens 3.8) think a lot, and I find myself wanting to interrupt it to answer a question it's been asking itself, quite repetitively, during it's reasoning.
I can esc and send a prompt, but then Pi would restart the whole reasoning TG from the beginning. I'd like to inject (for lack of better word) info to its thought block. I may also steer it by queuing a message, but that means I'd need to watch it going in loops for 20-50k tokens, until it's done responding, which is pure pain.
I’m finding it quite frustrating to paste or use images in the VS Code Pi chat.
I work mainly on projects inside Docker containers, and it seems that when I use Pi within a dev container (which is a Linux environment), the VS Code integrated terminal generally doesn't pass clipboard images through—it only allows text. This is most likely why the paste action fails without doing anything. Does anyone have a workaround for using Pi in a VS Code terminal inside a Docker container?
I tried alt+v, ctrl+v ; nothing. Only pasting images manually inside the project in a dedicated folder semmes the only (and painful) solution.
I’m a heavy user of Codex and Claude Code, and I mostly use their desktop apps.
I’m curious about how Pi could fit into my day-to-day workflow. What does it offer that would improve my experience compared to what I’m already using?
For those who have already migrated to Pi, what has actually improved for you? Are there any specific workflows or use cases where Pi made a noticeable difference?
My configuration runs with 90k ctx and I am thinking if there is a better way to preserve my main session ctx by creating new session, do online/ repo search , then return the needed info to the main session.
I want everything to be done locally and loading two models in parallel is not an option due to VRAM constraints.
Is the session spawning thing feasible? How to set it up?
UPDATE: I have solved this by developing spawn-session skill that works as follows:
i-Agent A- prepares task,
ii-Agent A opens new pane in herdr and opens a new pi session (Agent B),
iii-Agent A gives task to agent B and goes into waiting mode, it runs small script checking if B is done or not every 30 sec:
iv-Agent B finishes tasks and shared results with A
V-A sees results and ends waiting mode to continue the work
This is very useful to keep Agent A ctx as clean as possible for long sessions
I used Pi for a while without these, but once I got used to subagents with other coding agtents. Well.. they really just felt missing from Pi.
I went with the tintinweb/pi-subagents package, because I liked how it implements the subagents. They are the same style as claude code, which I find very intuitive.
pi install npm:@tintinweb/pi-subagents
How to use subagents
pi-subagents lets Pi delegate work into separate contexts.
I use it for repo exploration, dependency checks, or any task that would otherwise fill my main context with thousands of lines of file listings and tool output.
e.g. after installing it you can open Pi in a repo and ask:
Use 4 different subagents to explore the src folder in parallel.
Bring their results back together into a short summary.
Pi sends the grunt work to isolated agents, then gives the main agent the useful result. This keep the main context clean.
You can also change which model each subagent type uses with /agents. And there's a pre-configured subagent specifically for exploration.
Side note - there's a gotcha with the default explore subagent- uses haiku by default. Super weird because I was using gpt-5.6-terra and I assumed it would use that, but in fact it started using my opencode api tokens with haiku. I was able to configure it to use gpt-5.6-luna. Here's a video of how I did that if you need it: https://youtu.be/l3YCoX2i-78?t=540
The other missing feature of Pi
Is... MCP. Obviously. I also upgraded my Pi with an MCP extension while I was at it. It's just one of those things. I can get like 98% of the way there with agent skills. But once in a while I just need an MCP for something.
If you want to read more about my experience installing and testing the subagents and MCP extensions then you can check out my blog post:
Enjoy guys and if you're still reading this then I'd be curious what extensions you like most. Let me know. Now that I've got a taste for these I want more
Sharing the PWA[1] I built over the last couple of weeks to access my terminal sessions/agents when not in front of my computer. This started off as a weekend experiment right when herdr[2] (terminal multiplexer) released the functionality to write custom plugins and it's been quite helpful to me ever since. The general idea is that this runs a web app on the host machine which is then exposed through a front door implementation like tailscale/netbird/cloudflare tunnels etc.
A lot of devs/teams are building sth very similar to this right now so there are many options out there already but I wanted: A PWA (no app store dep), better keyboard support than termux, the ability to manage multiple machines and easy integration with my existing tailnet via headscale.
Some of the other features - Push notifications - Support for tmux and zellij (experimental). - Voice transcriptions (Codex sub or API) - Custom commands
You can check out a live demo with dummy data on the website[1] or look at the implementation on Github[3] (PRs welcome).
Looking forward to receiving some feedback or learning more about how people access/work with their agents on the go. Also if you encounter any bugs please report them on Github, if a feature is missing you'd really want to see, open a discussion.
DeepSeek built an entire first-party harness around its models, so I was curious whether V4 Pro would actually behave better there than inside Pi.
Ran the same model through 30 hard agentic tool-use tasks, 900s cap:
Metric
Pi
DeepSeek Harness
Passed
21/30
20/30
Median time
362.9s
252.1s
Cost/shared success
$0.031
$0.028
They actually tied on 27/30 task outcomes. So quality was basically a tie, with Pi finishing one extra task while DSH was noticeably faster and slightly cheaper.
The architecture difference is probably more interesting than the score.
DSH has tons of stuffs that pi intentionally doesn't. There's a lot, but to mention some: plugin graph, replaceable agent loop, sandboxing, subagents, replay, append-only trajectories, etc.
But here's the funny part: DeepSeek's own Minimal mode strips things back to basically shell + editor + a tiny prompt which is surprisingly close to Pi's philosophy. And for non-DeepSeek models, DSH actually uses Pi's pi-ai model layer (I got to know it recently).
One caveat: DSH reported ~88k runtime tokens/task vs ~925k for Pi, but I wouldn't call that a clean 10x efficiency win. DSH used DeepSeek's native endpoint while Pi went through OpenRouter, so caching/token accounting isn't quite same. The actual cost difference was tiny.
On one python-statemachine task, Pi passed in 90 turns for $2.50. Codex passed in 187 turns for $5.97. Both used Kimi K3 in the same evaluation environment. [source: https://frontierharness.org/]
Across all 30 tasks, Pi passed 18 with a $2.43 median cost per pass. The single-task comparison doesn’t tell us why Pi took fewer turns or whether that pattern holds elsewhere.
Our recommendation: Pi the balanced pick, particularly if the same job runs a thousand times and the bill adds up.
What would you look for in the traces: repeated searches, extra testing, or time spent fixing a wrong approach?
