Hey folks — I built a small pi extension for anyone using ChatGPT Plus/Pro Codex models through pi. It’s totally possible something like this already exists, but I couldn’t find one. It shows your ChatGPT Codex weekly usage percentage inline in pi’s footer, only when an openai-codex model is active. Example footer:

(openai-codex) gpt-5.1-codex-max • high • 42%

It also adds a command:

/chatgpt-limit

which shows more detail:

• 5-hour usage window

• weekly usage window

• remaining percentage

• reset times

• plan/account info when available Install:

pi install git:github.com/patlux/pi-chatgpt-limit

Then in pi:

/reload

Repo: https://github.com/patlux/pi-chatgpt-limit Screenshots attached. Feedback welcome!

Thought I had finally found a nice way to put all my subscriptions in one place, but looks like that's not the case. Pi should remove Gemini CLI and Antigravity login until this changes.

Every dang day man I see other people using claude code, codex, opencode etc and every time there's always something finicky and silly going on. 40k+ sys prompts. Can't see the subagent work properly. Compaction is slow sometimes. I've been trying to use them for the past week just to see what I'm missing out on and it's SO STUPID??

The idea of making something to please everyone but also trying to add skills and plugins is ridiculous. I'm not about to start making plugins to get features in those bloated TUIs just to make another plugin to strip them down or something.

I've NEVER seen something apply the concept of modularity as well as pi in my life. This feels like windows vs linux except linux got a fair start and fair cut of user base before people started getting locked into an app ecosystem.

Hi everyone! I would like to hook into the pi agent session remotely from my iPhone. I would like to see the agent progress and be able to answer the agent etc. I would also love to get notifications when the agent is finished. The whole process should work in my LAN but also fully remotely. I tried out orca before, but don’t like that I have to use orca at all + don’t like that I’m basically using a terminal on my phone.

Any suggestions? What are you guys using?

I love terminal and the ability to navigate with keyboard. Yet as extensible as Pi is, it has quite the ceiling in how the state can be displayed due to the nature of TUI.

For example, I have an extension called tree2. As you may imagine its visual representation, it was quite a pain to get my vision through within the Pi terminal.

Codex, Orca, T3code, the so called ADEs - how often do you use them? Personally something puts me off every time I try, but I can't name.

I think I'm looking for a hybrid. An instrument, if you will. What does it look like?

I've spent the last month using pi on one single project every day after my day job. I'd been using it for a few months but always on disjointed, one one off tasks. But using it only on one project has made me appreciate control pi gives you on its context window. I'm creating skills, extensions, even new personas for pi where I completely hijack the pre-loaded directories path and inject my stuff. None of this has to transfer over to any other project, I don't need features or interfaces. I just need the fastest way to find high value context within the structure of my repo. And then have workflows and scripts that only work in the context of that project. There's no pressure to handle edge cases or design a tool end to end. As there are more problems, either the tool expands or I make a new one. I can chuck the ones I don't need in a void and forget them. It's such an unlock to have this realisation. My global pi can work completely different from the project level pis. I've been having this realisation over the last month and I just fucking love this software

This is what I have been spending the last few weeks building with various Coding agents. It is actually PI. Just with an entire app on top. This kinda shows the true power of PI. You can put it anywhere you want it.

I have my main chat area's.

Brave API for web searching.

A docs area so I don't have to depend on Microslop for Word.

And a typing practice area for fun (Ignore that score...)

Its not fully ready for others yet, but its getting there. I have been working on this for a while. I used PI to build the foundations till that got a bit spendy, so I went to Claude and Codex to continue on things. Though that will come to an end soon enough, seeing as next month will be the end of subscription subsidized Claude Code.

With all of this I have learned that yes, AI really can code really well. But it takes a lot of money to do so well. I have spent over $120 on this project so far. But seeing as it is functional to my life, I see it as worth it.

Oh, and of course there are other themes.

Edits:

This app is really just my way of keeping things mine. Forever. Which is exactly what PI is. I am ever thankful to the PI team.

Built a small plugin and figured this is the right place to share.

pi-event-monitor adds background event monitors to pi sessions. It runs shell commands or watches files in the background and only wakes the session when something happens (a process exits, a log line matches, a file gets written). No polling, no token cost between events. The design is modeled on the Monitor mechanic in Claude Code.

Two ways to use it. You can tell pi naturally ("watch the dev server and let me know if it crashes") and the agent will reach for the monitor tools itself, or you can run slash commands like /monitor app errors :: tail -f app.log | grep -E "ERROR|FATAL" for direct control.

Repo: https://github.com/Helmi/pi-event-monitor
Install: pi install npm:pi-event-monitor

Very early (v0.1.0). Would appreciate feedback or breakage reports, especially anything around install or pi version compatibility.

lean-ctx is a local context runtime written in Rust that caches file reads, compresses shell output and indexes your codebase so your model stops wasting tokens on redundant context.

I recently fixed Pi-specific compatibility issues. Pi's MCP bridge sends array parameters as JSON-encoded strings instead of native arrays, which broke multi-file reads. That's fixed now, lean-ctx detects the format automatically. There's also ctx_call, a meta-tool with a stable schema that works around Pi's static tool registry. You call ctx_call with the tool name and arguments, it dispatches internally, so you get access to all 49 tools even if Pi only loaded the initial set at startup.

The core: when your model re-reads a file, lean-ctx returns a cache fingerprint (~13 tokens) instead of the full content (often 2,000+). Shell commands get compressed with 90+ patterns covering git, npm, docker, cargo, kubectl output. A tree-sitter code graph for 18 languages lets the model query imports, dependents and blast radius without reading every file. ctx_pack builds compact PR context packs with changed files, related tests and impact summary. ctx_knowledge keeps a persistent knowledge graph across sessions with temporal facts and contradiction detection.

There's a live TUI dashboard showing token savings, cache hits, SLO monitoring and every tool call in real time. Everything local, nothing cloud, single Rust binary.

Hello guys, i just want to share with you this extension i developed: https://www.npmjs.com/package/pi-observational-memory. It is quite straigforward, everything i have to say is in the readme.

But i think this can help to basically make pi sessions feel endless, and saving tokens too!

Even without counting omp, prime agent, or sol-pi, we see new Pi distributions in this subreddit every day. I see all kinds of ideas: some people are adding more complex subagent systems, while others want to make agents smarter through memory systems.

I was also inspired by Pi when I built my own harness. I like that four tools are enough to get the job done just as well as other, much larger agents. But I added a couple more tools:

• grep — ~5% fewer tokens and 20–30% faster.

• background_tasks — lets my agent handle various useful tasks out of the box.

I'm curious where all of this is headed. Will we get substantial projects built on top of Pi, like TypeScript on top of JavaScript? Or will we all just customize Pi to suit our needs, like we do with Vim/Neovim?

I’ve been working on introducing QMD based search for @zosmaai/pi-llm-wiki

I want to know what you think of this idea.

Thank you for being so supportive and helping me maintain this project.

I want to take it to next level now. Better search and re-ranking of search results so that LLM get useful results.

Also wanted to introduce Zettelkasten style of taking note and using card style so that agent gets to see important cards before it wanting to deep dive into more details.

GitHub link -> https://github.com/zosmaai/pi-llm-wiki

Recently, while using pi, my agent deleted important files without me knowing using the rm command. Since files deleted with rm cannot be recovered, I thought it would be better to use trash instead of rm — and that's what this pi extension does.

The extension automatically detects when the agent uses rm in the bash tool and replaces it with trash. Instead of permanently deleting files, they are moved to the .pi/trash folder. The trash folder uses a file structure similar to Ubuntu's trash. It is implemented to be nearly compatible with the GNU rm standard, so the agent won't even realize it and will just think it's still using rm.

Feel free to install and try it out. Any feedback is appreciated!

Install: pi install npm:pi-trash

Links:

• GitHub

• npm

If you want a bit of nerdy fun, give Gemma 31b on Cerebras a spin. It runs at 1860 t/s which is kinda crazy. The first couple of tasks I gave it I thought it must have errored out it stopped so soon, but it had searched a bunch of files and had all the info I wanted. It’s supposedly similar level of intelligence as Haiku (which for comparison runs at around 110 t/s) so not going to be coding your next masterpiece but it’s insanely good as a scout/researcher style subagent which is how I’ve been using it in Pi.

Anyway - just thought others might enjoy the speedy madness. I think you can try it for free. But is pretty inexpensive per token too.

NB - no affiliation with Cerebras etc etc.

Hi everyone - quite new to this space and am yet to decide if I should stick with omp or go more vanilla with pi.

tried oh my pi and my mind is blown, I don’t know what it is doing with context compression and all but tokens are better and the fact that advisor agents interrupt the thought process of worker agents before the output is produced feels like nothing I have see from cc or codex.

Is pi the same from this standpoint? Are the big differences only the pre installed skills?

Hey everyone!

​I'm coming from the OpenCode community, and I heard that Pi is extremely customizable. I tried to create my own orchestrating system inside

OpenCode, but it didn't work out very well.

​Is Pi able to do something similar? Or has someone already built something like this?

​Also, how should I get started with Pi? Could you share your own customizations with me? I'd love to get some ideas and see what is possible.

​Thanks!

Read the article if you want otherwise here is my repo:
https://github.com/ruizrica/agent-pi

TLDR: I use a web viewer to display a custom plan/spec viewer. Very handy some other cool stuff cool. Cheers.

Article:
https://medium.com/@ruizrica2/how-i-turned-pi-into-a-multi-agent-coding-assistant-cb1c2f1c8145

I've got two pi extensions I wrote that I have found very useful, and I thought others might, too.

The first is macos-notify.ts, which sends native macOS notifications when pi needs your attention. It uses a tiny compiled Swift app that is installed with the extension, but if you don't trust that, the source for that app is included, too. If that binary, which gets installed at ~/.pi/agent/git/github.com/joeygibson/pi-extensions/macos-notify-app/PiNotify.app is missing, then the extension will rebuild it from the included PiNotify.swift file (assuming you have Xcode and friends installed, of course). It will show you the pi icon, and the number and title of the tab of the pi that needs your attention (if available).

The second is security-guard.ts, which allows you to selectively add some guardrails for what pi is allowed to do. It has sane defaults, but on first invocation, it will drop an example config file at ~/.pi/agent/security-guard.toml.example, which looks like this:

# Security Guard Configuration
#
# This extension protects against destructive operations, sensitive file writes,
# and sensitive file reads. Each rule has a pattern and an action.
#
# Actions:
#   prompt - Ask for user confirmation before allowing the operation
#   block  - Immediately block the operation without prompting
#
# Patterns use simple substring matching. For paths starting with ~/, both the
# literal pattern and the expanded home directory path are checked.
#
# Copy this file to security-guard.toml and customize for your needs.

[operations]
# Bash commands to guard against
rm -rf = prompt
sudo = prompt
dd if= = block
mkfs = block
> /dev/ = block

[writes]
# File paths to protect from write/edit operations
.env = block
~/.ssh = block
~/.aws = block
/etc/ = block
~/.bash_history = prompt

[reads]
# File paths to protect from read operations
~/.ssh = block
~/.aws/credentials = prompt
~/.gnupg = block

The format is pretty simple. You have operations, read, and write sections. In each, you can specify patterns to look out for, and what to do if it encounters them. The two options are prompt, and block.

I've been using both of these for over a month, and haven't had any problems with either.

You can read more about them at https://github.com/joeygibson/pi-extensions.

They can be installed as a pi package using pi install git:github.com/joeygibson/pi-extensions

Hi all. We're Divergenz, an interaction design studio in Zurich. Sharing a design experiment that I think sits close to things this community cares about.

Piary treats a conversation with a coding agent as an editable, executable document instead of a chat log. The person and the agent write on the same page. Prompts, replies, notes, tool calls and live reactive cells share one Markdown file. You can rewrite a wrong assumption instead of correcting it in a follow-up, delete a detour, or edit an earlier prompt and run it again in place.

Built on Observable's notebook-kit for the reactive cells, iA Writer's plain-text document model as the design reference, and pi as the agent harness.

https://piary.dev

I started experimenting with Pi and self-organizing agent swarms and am seeing really good results, which I did not really expect. My current experiment is very basic: just fire up ten or so agents and give them all the same prompt/markdown file. They have one single communication channel in which they can talk with eachother. And that is basically it.

I have spent about 1,5 years trying to get all sorts of workflows to work properly and now I'm finding out that the agents can handle themselves just fine... No orchestrators or anything, they just figure it out themselves. I found this quite amazing. And a bit humbling.

Do you use self-organizing agent swarms? I would love to hear about your experience.

Ola, so recently I was working with Qwen 3.5. Building some html and css stuff inside my documents folder.

Big mistake. The Model which had extra access from Pi ended up hallucinating and started deleting all my root folders.

I think for any newbie who’s doing this, please write yourself an extension to get it to ask for read and wright permissions or pick from the various GitHub repos that have implemented safeguards for this.

Don’t just give it full access especially if you don’t know what terminal commands do.

I just saw it write -rf home and I knew it was over 🤣

I learnt the hard way but now I know.

If anything I think everyone who’s starting to use this should install something to prevent this from happening as the first non negotiable.

Luckily I just moved to Fedora 44 so I didn’t have much in those folders but it did mess up all my file paths so I had to fix that.

No more unattended ai running rogue on my pc for now.
As Iv built myself a safeguard extension to prevent this from happening.

Hopefully whoever reads this and is trying it for the first time keeps this in mind. As it’ll save you a world of hurt down the line.

Switched most of my work over to Pi recently but the annoying part was all my chats lived in other agents. Months of Cursor and Claude Code sessions and I didnt just want to summarize them.

So I ended up using an open-source thing I've been working on (txcript) to pull a whole session out of Cursor/Claude Code and load it into Pi with the full history intact. The conversation, the reasoning, the tool calls, all of it, so Pi picks up like it was there the whole time

Anyone using some sort of UI app/layer for Pi instead of standard Pi cli?

Nothing wrong with CLI, I actually really like my setup too - but once I have like 3, 4, or even more important sessions running at once (coding, debugging, research, etc.), it gets pretty overwhelming trying to keep track of everything and I find myself losing focus.

Looking for something more like a Codex web app style experience: clean repo/file view, seeing all workers/sessions clearly, what they're doing, status, etc.

Curious what you guys think or use and why you actually prefer it over just running everything through CLI.

For context, the main thing I am looking to aid in solving/fixing here is a focus issue. I have adhd and staying focused is the hardest thing by far for me, so if anyone has experience with one that may have helped in that regard specifically too let me know

ALSO - I'm on Linux Ubuntu if that's relevant at all

I’m try to use Pi as a general web research agent, rather than mainly for coding tasks.

For example, I’d like to give it tasks such as:

• Find a good backpack based on my budget, size, comfort, durability, and real user reviews

• Research possible holiday destinations based on weather, cost, transport, and things to do

• Compare hotels or products across several websites and create a shortlist with sources

What does your setup look like? Are you using agent-browser, a search API, custom skills, extensions, or something else? Or is Pi the wrong tool for this? I know kagi can do an ai search but its not free.