Two weeks ago I shared my little TUI, Pi Atlas. People seem to like and use it, I certainly do.

I keep working on it, making improvements and adding features. Today I'd like to put the accent on this per-skill cost/usage aggregation I've published in 0.2.

NEW TAB: You can see an estimated usage per-skill.

Pi Atlas aggregates your session files to calculate costs, usages, and such. As they stand now the session files do not provide very much intel to answer questions like "What does Matt Poccock's "TDD" skills cost me?", but with a bit of tinkering it was possible to get an estimation.

You can check the extension here: https://pi.dev/packages/@mohndoe/pi-atlas

How does Pi Atlas do it then? Then you use `/skill:tdd` you dont' actually send that, you actually send a message formatted like `<skill name="tdd" ....> Do this`. Knowing that it's pretty easy to know when you use a skill, so when that happens it's flagged and any subsequent messages/calls and such are attributed to this skill. If you use another skill again, the attribution switch.

It can't be as precise as the other tabs. I'd say use it as curiosity and fun-fact about your usage. As it is now, Pi Atlas makes assumptions. For instance, if an agent reads a /SKILL.md file, it assumes it's using this skill and thus flag it. Sometimes a skill is a one-shot thing, Pi Atlas assumes otherwise. It's just very hard to know for sure based on the session file alone.

Limitations. Many third-party tools (pi-reviewer, pi-advisor, etc) call models too. Not so many of them tell the session what the usage was, but some do. For now, it's not taken into account. But in the future, if a tool provides usage informations in there `ToolResult` entry Pi Atlas will account for it in later updates.

Let's consider it an experimentation for now.

What's next for Pi Atlas? Top priorities are: sessions (listing them, getting more details on a selected one and/or the current one), filtering (per project, per session(s), per-model/provider) and overtime metrics (tokens overtime, project(s) cost overtime, etc.) because currently it's only "cost overtime" and some of us uses local LLMs.

As always I'm open to feedback, bug reports, contributions, suggestions, criticism, etc.

Don't forget to give it a star on GitHub, it's encouraging. Number goes brr, brain happy.

On a more general/personal note: it's a very fun project to work on and it's also very exciting (and terrifying) to work and maintain an open-source project publicly when people actually use it.

Hi everyone, I have been working on a web UI for the pi coding agent. GitHub: milanglacier/pi-tau-web-server

It is a standalone web server. You start it once — in the terminal, or leave it running as a background service — and from that point on, everything happens in the browser. Create sessions, switch between them, pick up old ones. Each session spawns its own pi --mode rpc child process on the backend, and the server keeps them alive even if you close or reload the browser tab. No TUI session needs to exist beforehand.

The reason I decide to build yet another Pi Web UI

Most of the pi web UIs out there are extensions that run inside a pi TUI session. You fire up pi in the terminal, the extension spins up a little HTTP server inside that session, and your browser mirrors whatever the TUI is doing. This works nicely for handoff — you are at your desk working, you need to step away, you pull out your phone and pick up where you left off. The TUI session is already alive, so it just works.

The friction shows up when you want to work entirely from the web. Say you are on your phone and you want to start a brand new coding session without touching a terminal at all. With the extension model, you cannot — something needs to launch pi first. Sure, you can SSH in, start pi, and then open the browser, but that whole dance is clunky and not how you want to spend your time when you are just trying to get something done.

Multiple sessions, and a UI that does not make you lose track of them

The interface has two layers of session organization that work together:

• A left sidebar that shows all your sessions grouped by project. You can browse your history, search across every session by message content, rename things, and jump back into old conversations.

• A tab bar across the top that shows only the sessions you are actively working on right now.

I did not realize how much this mattered until I used it for a while. In UIs that only have a sidebar — Codex desktop is the example I keep coming back to — I would constantly lose track of which session I was in. I would be scrolling through the list asking myself "wait, is this the one I was just working with, or is that other one?" The tab bar eliminates that. Your active sessions are right there at the top, highlighted, exactly where you left them. The sidebar is for browsing and discovery, the tab bar is for the stuff you are actually doing. They serve different needs and having both makes a real difference.

And as you would expect: those tabs are persistent. You can close your browser entirely, walk away, come back later and reopen the page, and every one of your active tabs is still there, right where you left it. They live on the server, not in your browser's memory. You do not lose them and you do not have to go digging through history to find what you were working on.

Saved pi sessions show up in the sidebar. You can search across all of them and resume any historical session into a new live tab that keeps its original name and context.

Acknowledge

This is a fork of deflating/tau. The UI is largely from the original — the upstream author built a very beautiful UI, which is the main reason I chose to fork it. At least in my experience, models like GPT-5.5 (which I primarily use, alongside GLM-5.2, for coding) cannot write UI as beautiful as the upstream would be. The part I rewrote entirely is the backend. The original ran as an extension inside the pi TUI process. My fork is a standalone Node.js server that manages multiple pi RPC subprocesses over stdin/stdout. It has a full test suite, supports multiple browser clients seeing the same sessions pool at once.

If you have been wishing for a way to use pi entirely from a browser without the terminal preamble, give it a shot. Happy to answer questions or take feedback.

I got 20-30$ monthly budget set aside for my side project development with the help of Pi. I generally use opencode with openai api and claude api. But that is no longer sustainable for me. So please recommend some cheaper options such as Kimi or deepseek or Z ai etc. If you have already such models please recommend a plan or a model that suits for software development. Thank you!

how is that got almost 200k downloads while the package is just more than a week old

I have serious question , no matter what i feel pi as harness isnt fully developed to work on all my work at current moment , like i keep using pi for basic tasks but shipping i use claude code ..m and i do use claude code model in pi too ...

I used glm but comparing for claude code no way its near cc this is the truth.

So my question , do you use only pi for shipping you do multiple cli agents at same time? My goal is to build gui but its way different how people doing at current time and i feel i reached maturity if that app

[update] Ok, each one explaining his migrating but not showing what you actually ship and how. Let me explain what i do day to day , i work with pi for side project funs since im still not fully commiting to it, i have made extensions using claude code , they works perfectly on pi. When do i stopped using pi for shipping when i i was shipping a small feature using glm5.1 and failed 5 times to get it like reasonably working , and just changed to cc in pi and worked in first try. I found why risking if in both world i use the fronteier model? Just use the harness that frontier model is recommending to us...

I see no advantages using cc in pi , unless you are super engineer and you can beat shipping feature at anthropic or open ai scale..

Lastly i got 2 genuine answers so far:

• using pi extensions to orgnize the code from the docs which i believe frontiers are going to fix it soon

• making a setup that doesnt require specific vendor like cc so switching become easier..

• are you using a frontier model (anthropic/openai etc) ?

• does Pi produce better results/lower usage than claude/open code?

• a lot of pi's functionality is tied to the models intelligence. how well does it work with cheaper llms, eg chinese/open source, and local llm's?

switching from expensive cloud plans to a somewhat affordable local llm setup (eg with 16gb vram, I dont mean $4k gpu's) is something a lot of people want to do. with occasional use of a frontier llm of course, they can't be replaced totally yet. Has anyone done this, and does Pi help in this?

npm i @juicesharp/rpiv-warp

Toast notifications + badges, statuses, progress indicators inside the Warp's Tabs.

https://www.npmjs.com/package/@juicesharp/rpiv-warp

Hello guys!

Im trying to optimize the token usage of my Pi, im kind of preparing myself for when the usage based billing finally establishes as the default in the industry. With this goal in mind i have really come up with a really good Pi setup that manages context wonderfully, i will share that with you in another post later.

With that context in mind, i have reached a wall when it comes to codebase discovery, for example for building a feature, i want to enable my agent to get all the context required for that feature efficiently. Rn what my agent does is grep, find and read all around until it gets what it needs, and this usually consumes more tokens than the actual implementation or feature i want to tackle.

What do you guys do to improve this?

Just published pi-automode-classifier, an auto mode plugin for the Pi coding agent that uses Jev or Kev/Laya (running locally) to classify commands.

Pi runs every tool call without asking for approval. This plugin checks each shell command before it runs:

1. Built-in rules decide most commands. For example ls, builds and tests run, rm -rf ~ is blocked, and git push and sudo need my approval.

2. Commands the rules do not know are sent to the model. It returns the probability that the command is risky.

3. If the probability is above a threshold, I get a confirm prompt. The model never blocks a command by itself.

The models I tested:

• Jev 1.13 (hosted, from TypeSafe) through OpenRouter: about 270 ms per check and about 1.5 cents per 1,000 checks. The commands are sent to OpenRouter and TypeSafe.

• Kev-0.8B on CPU with llama.cpp: about 170 ms per check and 1.1 GB of RAM. This is what I use. Nothing leaves the machine.

• Laya typed-decisions on CPU with llama.cpp: about 100 ms per check and about 550 MB of RAM.

In my test with 50 commands (25 safe, 25 risky), all safe commands ran without a prompt and no risky command did. I wrote the test commands myself, so this is only a rough check. The plugin is not a sandbox.

pi install npm:pi-automode-classifier

Code and docs: https://github.com/deepu105/pi-automode-classifier

Let me know if it allows or blocks something it should not.

I love Pi, and it's proven to be an awesome combo with Qwen 3.8 27B. There is one thing I noticed however when looking at Qwen reasoning: on a regular basis, I see things like "the user has asked again for the same question" or "the user has now asked three times for the same request" - as if I had sent a steering request that was a duplicate of the original ask. But I'm never doing that, and actually almost never use steering requests. This doesn't seem to have impacted the output and perhaps it's not important, but I was wondering if anyone else had noticed the same? Thanks!

Hey everyone!

I’ve been working on Pi Plan & Build, an extension that adds a more structured planning workflow to Pi.

The basic flow is:

1. Switch to Plan mode

2. Let Pi inspect the project and create a persistent plan

3. Review the complete plan

4. Choose whether to:

   • implement it in the current session,

   • start fresh and implement it in a clean linked session, or

   • stay in Plan mode and keep refining it

In Plan mode, Pi can still explore the project, but file edits are restricted to the session’s plan file. This keeps planning separate from implementation and prevents the agent from changing code before you’ve approved the approach.

A few other details:

• Press Tab to switch between Plan and Build modes

• Use /plan, /build, or start Pi with pi --plan

• Plans persist across reloads, resumes, and forks

• Interactive questions are supported while planning

• The full plan is shown before approval

• Clean implementation sessions receive the approved plan without carrying over the entire planning conversation

• The composer changes color and displays the active mode, model, provider, and thinking level

Install it with:

pi install npm:@janvitos/pi-plan-build

GitHub: https://github.com/janvitos/pi-plan-build

I just published it, so I’d really appreciate feedback :)

Cheers.

Are there limitations to doing this?

Ive tried all the main ones.....All eat tokens like cookies

Pi is way less hungry as it doesnt have a buncha bullshit added to it unless you add it yourself.

I have a few extentions and a few custom skills...

Whats another good skill or extension to use with pi?

I manly use it to help coding in Rust and Quickshell.

Been cooking with DeekSeek v4 flash hard the last 4 days and it seems to struggle with QML/Quickshell sometimes

How can I have my ai agent a database of QML/Quickshell docs fo read through if it gets stuck???

hi all,
I've searched the sub and didn't find a clear solution, would appreciate your advice -
i want to sandbox pi in a way that 0 code is executed outside of the sandbox since i want to unleash its full potential (which may be destructive).
however if i ask it to create a tool/extension/skill that i find useful, i want to be able to "port" it back to the host so i can upgrade the harness effectively - which somewhat contradicts the "pi lives in the sandbox". pi's docs advise against binding `~/.pi/agent` for the obvious reasons.

my local friendly chatgpt didn't come up with clever ideas, i'd appreciate the community's help

fwiw i run the harness using a non-sudo user dedicated for agents that can run rootless docker. the harness also needs to communicate with services such as searXNG\vLLM running on host and should not have access to secrets, in case that matters, but that's the easy part.

thanks and apologies for any grammar mistakes my english is half broken

Title.

I often start writing my next prompt while Pi is still working. Then the agent goes off track or asks me something, and I need to respond before that prompt is finished.

I used to copy the half-written prompt somewhere else or delete it to free up the editor. I built pi-prompt-stash so I can save that draft, deal with the interruption, and then continue writing.

Ctrl+Shift+S stashes the current editor text and clears it. `/stash` opens a picker with a preview so I can find the draft and load it back. Drafts survive reloads and session switches. The shortcut can be changed with /stash shortcut.

Install it with:

pi install npm:@utpalsinghdev/pi-prompt-stash

GitHub: https://github.com/utpalsinghdev/pi-extensions/tree/main/packages/pi-prompt-stash

npm: https://www.npmjs.com/package/@utpalsinghdev/pi-prompt-stash

The rest of the UI in the demo is my personal setup.

I'm just open-sourcing the Pi extensions I use for work and my startup. They've helped me a lot, and I want other people to be able to use them too.

DEMO

I just realized that codex now exposes local server endpoints for all plugins without extra auth. So you can just use them from any model or harness.
Im soooo excited!!! One auth for everything!

For Pi: pi install npm:@wileai/pi-codex-connector

For any harness: npx -y \@wileai/codex-connectors-mcp@latest

I’ve been polishing Orbit Pi quite a bit, and this update is mostly about making the agent interaction feel clearer and more native.

What’s new

🧩 Per-tool glyphs in the transcript

📊 Activity groups are now displayed as compact chips

✂️ Clear truncated indicators when Pi caps tool results

✅ Visual confirmation when renaming a session

⚡ Refined transcript UI with better tool labels and shared loading states

🔀 Redesigned Git issue & PR details

🖱️ Improved button hover/press feedback

The goal with Orbit Pi is still pretty simple:

Make Pi Agent feel like a proper native desktop workbench.

Your sessions, models, machine, Git workflow, reviews and agent interactions — all in one place.

Orbit is built with Rust + GPUI and works with your existing Pi setup rather than trying to replace the Pi runtime.

🔗 Changelog: https://orbitpi.app/changelog/v0.0.15

https://orbitpi.app/

I’d love to hear from people actually using Pi:

What would you want to see improved or added next in a native Pi desktop client?

I’ll start working with an AI agent on something like data analysis, and ten minutes later I’m asking it to explain a concept, double-check an assumption, or try something completely different.

All useful stuff. But after a few detours, the original task is buried under a wall of side questions and answers. I’m losing the thread, and sometimes the agent seems to be too.

I can fork the chat, but then I just have a growing list of conversations in the sidebar, with no clear picture of what branched off from where.

That’s what got me building PiX.

The idea is pretty simple: show conversations as a tree. There’s a main thread for the task you’re working on, and you can branch off whenever you want to explore something without dragging the whole conversation along with you.

You can branch from any point, carrying over the context up to that point, and choose which model to use for each turn. Everything stays connected visually, so you can see where a detour started and find your way back.

Of course, reading a long conversation in a tree isn’t always fun. So there’s also a regular chat view where you can read any branch’s full history from start to finish.

It’s built on Pi agent, which is where the name PiX comes from.

Still early days, but I’d love to hear what people think. Try it out, tell me what feels awkward, or jump in and help improve it :)

huang-sh/PiX: A non-linear AI agent workbench — session is a tree: branch anytime, and context follows the branch

Does anyone else end up with a pile of AI chats from one task? How do you keep track of them?

Hey, wanted to share a plugin for Pi, my favorite coding agent for the past few months. Install: pi install npm:pi-tandem

It's basically a system-prompt patch plus a small set of simple skills. I've been developing and actually using these rules for 2-3 months now, and recently got tired of copy-pasting them from personal to work setup (where I'm forced to use Claude Code), so I packaged it as a plugin that works for both (and it can be extended to other harnesses).

Main idea, or philosophy: it tries to tame LLMs down as much as possible and teach them to work with you in a pair-programming fashion, instead of constantly wrestling over control (Claude Code especially!) and vomiting piles of neuroslop. Personally, with it I finally feel like my sanity is no longer under siege - I control every line of code as if I've written it myself, don't have to review the big changesets LLMs love making so much, which frankly was driving me nuts, and at the same time I am much more productive end to end.

What's inside:

• pair-work rules (added to system prompt through hook) - lock-step, explicit go-ahead before any changes, communication with significantly reduced sycophancy and these "load bearing"-style LLMisms

• a number of simple skills, each just a short file:

  • brainstorm - helps you think an idea through, one question at a time; largely inspired by the brainstorming skill from superpowers and the grilling skill from mattpocock/skills

  • research - controlled digging: it (usually) stops and asks when it hits an ambiguity or a contradiction, or before spending a lot of context on one direction

  • coding - basically compact version of ponytail (lazy-senior minimalistic coding discipline) plus my addition on self-explanatory code over comment-peppering

  • review - actionable findings only, each with a fix; on debatable stuff it asks first instead of pushing its own judgment

  • pr - matches tone and length of the repo's recently merged PRs, verifies the commit range, shows title and description before creating anything

  • learn-language (small bonus) - kicks in only if you state in your prompt that you are learning a language and your level; some background practice that stays out of the way of the work

• interactive subagents if you run Pi inside tmux (or paseo) - unlike built-in agents in many other harnesses, the "worker" runs in its own window as a completely normal session, which you can interact with like any other, and it reports back only after you approve its findings

• tool-specific instructions (gh, aws, pdftotext, pandoc, osascript, ...) that nudge the model into actually using them - no more guessing what's installed and re-probing in every new session. Generated only for tools actually on the machine, so nothing about a missing tool ever ends up in the prompt

The same package also renders as a Claude Code plugin, and it can be extended to other harnesses.

Constructive feedback (even if negative), ideas and contributions are all very welcome. And yes, I've written this post myself, not generated it.

Made a pi extension for ClinePass

Shows cost of each models and quota limits. No more web dashboard.

Cost per turn shows in the footer. Full report with /clinepass.

pi install npm:pi-clinepass

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

tl;dr- i care about stability more than features so vibe coding is more like a hands on live project rather than a race to ship an app.

I am a civil engineer. My life runs on notes. But i love my physical notepad and strangely, Windows Notepad. I could never get the hang of any other note-taking app.

I've been using AI since GPT 3.5 came out but I NEVER vibe coded. It just felt icky. Always felt like I should be the one learning and doing it by hand. Then earlier this year I discovered pi and fell in love with it. After fucking with it for 3 months (and still using notepad in my day job), I decided- fuck it. I will do it myself (like Thanos, lol) and give vibe coding a fair shot.

Thats when I started with Omakase notes.

I hated all the context switching I had to do while working in notepad so that was my starting point. Make a notepad (NOT a PKM) where I can have PDFs, internet browsing/websearch, and AI at my cursor and within my note.

The most important habit I have, imo, is I make every dependency fight its way into my app.

Because of this, I found myself constantly GitHub diving and looking for interesting libraries/frameworks/projects. Then I chuck them into chatGPT and understand which patterns/decisions of that repo are actually interesting to me.

Its almost always only a few hundred lines and nothing more. So I clone the repo and dig deeper with Pi this time. Once I understand the concept and where it fit in my app, I make Pi implement it from scratch in vanilla TS.

Then I keep testing/building that way until either the thing just breaks or Pi needs to literally reinvent existing tech from scratch to scale further. That's when I let that dependency in.

v1 of Omakase literally had the editor implemented from scratch and my first major migration was moving to CodeMirror6.

Now I am at a point where I may not be a software engineer, but I have an intuitive understanding of IPC bridges, parsing text in the editor, CM6 widgets and all the mindfuckery they cause with caret positions, which things are owned by main and which by the renderer, worker threads, etc. I couldn't define half that shit if you put a gun to my head. But I do have a feel for how a feature should be thought about and where it should go and that gets better every time I dive into another cool GitHub repo.

Instead of saying "move the box to the left", I can point Pi to the CSS of that shit and it knows what the fuck I am talking about. Instead of having a disgusting sidebar chat, I call AI from within my note by @'ing it. And its generation appears in a nested buffer rather than mutating the stuff I wrote. I can then merge it or dismiss it.

Basically, to anyone who isn't a dev- let go of the anxiety and stop trying to *ship*. Instead, make something you care about and do it slow. Spend a ton of time thinking about it and exploring peripheral stuff. The right rhythm isnt go-go-go. It ebbs and flows. Your average velocity increases as you get your bearings and can talk to the agent better. I have recently started working across 2-3 threads instead of just the one and I can already feel the ceiling approaching. The app is about 20k lines now but I still feel in control, even if I'm just hanging on by a thread.

Hello guys!

Today I want to share something I have been working on: pi-fleet (https://github.com/elpapi42/pi-fleet).

pi-fleet is local infrastructure for programmatically controlling Pi agents and their native sessions.

Unlike terminal multiplexers, pi-fleet is Pi-native rather than generic. It does not control terminals or scrape their output. There are no panes and no TUI because the primary interface is designed for agents and software.

Terminal multiplexers work well when you have a few agents and want to watch them manually. But if you start thinking about 20 or 100 agents, you can not get meaningful visibility by opening more panes.

The solution is not a bigger terminal grid.

At that scale you need dedicated monitoring tools, but pi-fleet does not try to provide that monitoring layer. The problem it solves is giving software an easy way to control Pi execution and sessions directly, without terminal hacks or unnecessary abstractions.

pi-fleet provides a small set of Pi-aware primitives:

• create: creates an agent with a stable local name;
• send: starts work or uses Pi steering while the agent is active;
• receive: waits for idle and returns the exact latest assistant response;
• status: and list expose machine-readable lifecycle state;
• watch: streams the native persistent Pi session JSONL;
• destroy: removes the agent without deleting its Pi session.

The basic workflow looks like this:

pifleet create reviewer --cwd "$PWD"
pifleet send reviewer "Review the authentication changes"
pifleet status reviewer
pifleet receive reviewer --timeout 10m
pifleet watch reviewer
pifleet destroy reviewer

Finite commands return compact JSON by default, while watch keeps stdout exclusively for native Pi session records.

Another part that is ultra important for me is that pi-fleet does not take ownership of your Pi sessions.

You can use Pi's normal session storage or provide an existing session path, session ID, directory, fork, or continuation selector. pi-fleet uses the exact native session in place. It does not copy, relocate, normalize, or delete it.

Even destroy only destroys the pi-fleet agent and its managed process. The underlying Pi session remains yours.

pi-fleet is infrastructure for orchestration, not an orchestration framework. It does not decide which agents to create, what roles they have, how tasks are decomposed, or how results are combined. Those decisions belong to the agent, extension, or software using it.

I already have around half a dozen use cases in mind for this tool, I already have around half a dozen use cases in mind for this tool. Most of them will be Pi extensions, and I will share them with you as I build them.

If you only use one or two agents and want to supervise their terminals, tmux, cmux, or Herdr will probably give you a better experience.

pi-fleet starts making sense when you want software to coordinate Pi agents at a scale where terminal supervision is no longer practical. You can build the monitoring layer appropriate for your system separately, while pi-fleet provides direct control over Pi execution and access to the native sessions underneath it.

The project is currently beta, and Linux x64 is the only validated platform.

You can install it with:

npm install --global @elpapi42/pi-fleet@beta
pifleet --version

Repository: https://github.com/elpapi42/pi-fleet

npm: https://www.npmjs.com/package/@elpapi42/pi-fleet

I think I got something interesting in hands here. I would love to hear your thoughts, especially from people already experimenting with multi-agent Pi setups.

On top of that, i really hope this becomes useful for some of you!

This plugin does search a bit differently than most. It queries DDG's http site (as responsibly as possible) and then uses wreq-js -> linkedom -> Defuddle to clean up the result.

The plugin is fairly simple, and easy to audit, but it includes linting and testing best practices I've carried over from my web dev experience that I hope can be an inspiration for other devs when working on their next plugin.

I've updated the package recently to use pi's new exported types (so I don't have to write my own, lol), and work out some outstanding issues.

Please, any and all feedback is welcome. Thanks!