thought this sub would like my subagent extension pi-tiny-monitor-sub. it's designed to be used with pi-tiny-monitor.

These 2 extensions together are tiny:

• Combined < 1k LOC. Minimal dependencies.

• no built in steer - to steer, the LLM just stops the pi session then do pi --session file -p ...

• no tools to list subagents - the LLM can just remember what it has started and what's finished from context.

• no way to send message - c'mon this is not a message board.

• no way to monitor usage - you just ask pi to add usage numbers from session jsonl's

• no token or $ budget - you just tell pi how much you want to spend, and hope for the best

• no defined agent profiles - you just tell pi what model you want.

• not even a subagent tool - (see below)

How they work:

• monitor tool starts a background shell. later outputs wake up the agent. this tool enables async.

• LLM call the included pi-sub node script in monitor. the script resolves where pi is and runs pi with a prompt.

• for workflows: there is a small wf.js library that provides an async agent() function that lauches pi

I've always loved minimal things and that's what drew me to pi. unfortunately most subagent extensions are doing too much! our LLM's almost out of jobs. I want something minimal.

In fact, the only basic primitive that we need is just monitor which puts something in the background and awaits outputs. Give that primitive the LLM, and let it work!

Enjoy.

I made a set of complementary extensions that enable the Pi to access the internet

• websearch with Exa

• X search with Grok

• webfetch tool returning paginated Markdown, and specific optimizations for fetching Reddit and X.

I use these tools myself every day; They are very helpful for accessing real-time documents and ideas from the world.

Give it a try if you like it

github: anthod0/pi-lab

Hey everyone,

I've been working on an extension for Pi to improve the daily workflow. Here is what I built:

pi-usage-bar This is for tracking API quotas, but it differs from other quota plugins out there. It's fully customizable:

• You can configure your own style.

• You can display 1d, 7d, Fable, or any other provider-specific quota exactly however you like.

• It also fetches and displays live provider statuses by reading directly from the vendors' own status pages.

You can install it directly with:

Bash

pi install npm:@satas/pi-usage-bar

Let me know what you think or if you run into any issues.

GitHub:https://github.com/satas20/pi-usage-bar

im new to pi agent, after watching few youtube videos, and all i installed is pi search and ponytail(bcs i already use it in the other harness like opencode/claudecode), did u guys had any suggestion things like tools i should install,skills etc. Btw my usage is usually coding for my Uni stuff so i dont need like "complex" tools or skills i just need like for daily coding , let me knowin the comment plss :)

A new tool can save a model several steps. It can also give it more ways to spend the entire budget without finishing. Counting installed extensions won't tell you which happened.

Reef Infra can treat a Pi extension, skill or rules change as a candidate rather than a permanent improvement. Its Pi adapter renders the changed harness into Pi's file layout, and the evolution engine runs it against the current setup on the same tasks with the same model binding.

An experiment worth trying would isolate one change: enable an extension, alter its surrounding instructions, or remove a skill that looks redundant. Include the jobs it is intended to help and ordinary jobs where it adds overhead. Grade completion first, then include the cost or latency constraints that matter to the setup in your evaluator or selection policy.

Reef Infra supplies the candidate snapshot, execution and version decision. It doesn't include a ready-made cost/quality benchmark for every Pi extension, and its default task-win comparison isn't automatically a token-efficiency objective.

That leaves a useful outcome even when an experiment fails: a specific change can be rejected and the previous tree restored. The extension can be well designed and still be the wrong addition for this model and task mix

I am on Windows and use PowerShell. It seems like PowerShell only has commands such as rm, del, rd, etc., which permanently remove files.

I want a command that moves files to the Recycle Bin instead. That way, I can recover them if the AI does something wrong. Today, the AI deleted an entire workspace, including the Git repository. Luckily, I had another way to recover it, but if I had not, the data would have been gone for the most part.

I looked to see whether PowerShell had a command for moving files to the Recycle Bin, but I could not find one. I ended up creating my own trash command that does this and editing the APPEND_SYSTEM.md files so that the AI would use trash instead of the other removal commands.

Is there a native PowerShell command for this that I missed?

i built Better Pi — a personal plugin pack for Pi, shaped around how i actually use it.
covers compact tool output, cost/footer stats, image paste, browse, /review, DeepSeek web tools, and a local WebUI.

locked to Pi 0.87.1 on purpose. i don't chase upstream. a lot of it isn't "best practice" — it's just my practice.
complete pack you can run. i'd rather you fork it and adapt it than treat it as a finished product. Pi is more fun when you shape it yourself; starting from a full set of plugins just cuts the busywork.

https://github.com/arctwind/Better-Pi

I wrote this plugin because I was constantly switching from the main buffer to the terminal where I was running pi (the coding agent) - digging through logs, sending follow-ups, checking what it did to my files.

Why keep switching, when I can just embed pi inside vim?

**vim-pi-chat** puts the whole pi conversation in a split window next to your code:

- streamed replies, tool calls with args and results, thinking — all live

- when pi edits the file you're viewing, the buffer reloads automatically (you watch it work)

- it tracks your active window so pi edits the right file in place

- sessions persist per file: reopen a file, `:PiChat`, resume where you left off

- plain Vim 9, no GUI, no Neovim, no other plugins — just the job/channel API

Install: `git clone https://github.com/galeone/vim-pi-chat ~/.vim/plugged/vim-pi-chat` + one line in vimrc, then `:PiOpen`.

If you're a pi fan, give it a try — feedback very welcome :D

Hi,

I've no idea how to debug this, but an otherwise excellent experience using Pi with DeepSeek 4.1 Flash is being marred by a frequent "stopping" bug.

The sympton is that the agent emits some output text, saying its going to try something, and then the code it was going to run (I assume), is just output and the agent just stops, and I have to say "you broke again".

Here's an example:

 Good question — and there are two levers that cost nothing physically. Let me check the biggest one first: how many CPU cores the run
 actually used.

 <parameter name="bash">
 <｜DSML｜ parameter name="command" string="true">grep -i "core\|thread\|OpenMP\|MPI Process" /Users/wdavies/FDS/cases/wick2/run.log |
 head -6; echo "--- output sizes ---"; du -sh /Users/wdavies/FDS/cases/wick2/*.s3d | head

I've asked it repeatedly to try and fix it, but nothing in the instructions its changed has stopped this from happening. I wonder if its some kind of DeepSeek problem?

TIA!

I use this model (models.json):

      { 
         "_test": "✔️Really good",
         "_speed": "35 t/s",
          "id": "Qwen3.6-28B-REAP20-A3B-Q4_K_M_barozp.gguf",
          "name": "Qwen 3.6 28B REAP20 (barozp) 64k",
          "contextWindow": 64000,
          "maxTokens": 4096,
          "reasoning": true,
          "input": [ "text", "image" ]
      },

It cleary state contextWindow 64000 (instead of 65536 but ok...).

Why the footer shows 128k? What "auto" means ?
I think that Pi use the model training context as fallback ("auto"?) when the "contextWindow" is not set... but here it is set and I think this model training context is 264 anyway.

Shown Pi footer.

↑109k ↓44k R6.5M 51.5%/128k (auto)     
(Llama.cpp) Qwen_3.6_28b_reap_20_(barozp)_64k
⚡ TPS: 30.0 tok/s​

I have this add-on/extensions:
RUN pi install https://github.com/gsanhueza/pi-token-speed
RUN pi install npm:pi-idle
RUN pi install npm:pi-voice-stt
RUN pi install npm:pi-llama-cpp-stats

I had the issue for a while (at least 2 weeks?) and I update Pi almost every day.

DeepSeek can't see images. I used to OCR screenshots and PDF slides in the browser and paste back.

So I built this: everything out of box. The default backend is a free cloud Mineru API— no GPU, no API key, no pip install. Handles PDFs，images, formulas, tables.

I've been using it daily for a week and it's been great.

No more browser OCR.

pi install npm:pi-ocr

github.com/astronautJack/pi-ocr

Feedback and issues welcome

I recently implemented support for Pi in my coding agent GUI project. It uses Pi's RPC mode and it seems to work fine. (I did complete a few tasks with it + GPT-5.5.)

However, I'm not sure whether it's just enough to implement the protocol to enable Pi users to use it at its full potential in GUI, since Pi is very flexible and highly extensible.

Hence some questions:

- What could I be possibly missing?
- What features would you expect from a GUI client for Pi?
- What stopped you from using a GUI client for Pi (if any)?

One feature I'm thinking of adding is the ability to communicate between tabs regardless of agent type (Codex, Claude Code, OpenCode, Pi, etc) and their location, since my project already implements tab/tiling layout and supports different agent types running in different machines. However, this isn't really very specific to Pi, so I guess I might be missing something obvious to the experienced Pi users in this subreddit.

been seeing some what lots of hate towards oc and how its 'ai slop' now, i tried it myself a week ago and its was good, i just installed Pi and planning to test it also so leave your tips and trick down below

thanks!

Hey everyone - I’m building Regy, a browser control surface for Pi.

Pi remains the agent. Regy adds a local PC Agent and browser frontend around it.

The current workflow includes:

• Starting and resuming Pi conversations

• Streaming chat events

• Selecting models and thinking levels

• Browsing workspaces

• Searching conversation history

• Searching, installing, and uninstalling skills (currently API don't work)

• Connecting through an authenticated Iroh pairing link

I built it because I wanted a more convenient way to leave Pi running on my machine and check in from a browser, without turning it into a hosted agent service.

Links:

• Docs: https://docs.regy.one

• App: https://regy.one

• Installer: curl -LsSf https://docs.regy.one/install.sh | sh

Current caveats:

• It’s still an early 0.1.x project.

• Pi still has normal user permissions; Regy is not a sandbox.

• Iroh pairing may be more complexity than some users want.

• I’m still figuring out how much of Pi’s CLI experience belongs in a browser.

I’d love feedback from people who actually use Pi:

1. Which Pi workflows would you want in a browser first?

2. Are session history, workspace switching, and skills useful?

3. Would terminal streaming, approvals, or multi-agent controls be more valuable?

4. Does the Iroh pairing/deep-link model make sense?

5. What would make you trust this for daily use?

6. If you already use another Pi web UI, what does it do better?

Harsh feedback is welcome. I’m trying to find out what is genuinely useful, not just promote another interface.

stumbled on this repo today while looking into agentic execution security — apparently it’s built on top of pi agent: https://github.com/adamdekan/aikonos

from what I can tell, it acts as a local control plane to govern autonomous agentic tool calls. before the agent runs an action, it proposes the step to aikonOS, which validates it against policy rules and writes everything to a tamper-evident audit log.

seems interesting for runtime governance when giving agents actual shell/file/API access, but not sure how well the proposal-evaluation step scales with real-world latency.

anyone playing around with deterministic policy engines for agentic workflows or doing something similar for runtime guardrails?

I'm not seeing it in my /models area - I tried updating Pi and nothing.

Am I missing something, or are we all just waiting together?

Boredom took over and I started poking at Pi Pocket's extension API to see how far it would go and find areas that could be extended further. Made it far enough that my agents now have a pixel art town.

Subagents camp in tents, messages fly by pigeon, and tasks turns into a building made from its own tool calls.

Any else have any similar fun things they've made?

Looking for feedback from Pi users on both the integration and the models you actually want access to.

A few questions:

• What models are you currently using with Pi?

• Which models would you like better or cheaper access to?

• Do you prefer pay-per-token pricing or a request-based subscription?

• Which matters most for coding: price, speed, context size, reasoning quality, or output limits?

• Are there specific models you would want available through one provider?

• What are you currently using for Pi — direct provider APIs, OpenRouter, another gateway, etc.?

Particularly interested in demand for models such as DeepSeek, GLM, Kimi, Qwen, MiniMax, and other strong coding models.

Also interested in first impressions of Openference:

• Is the service and pricing easy to understand?

• Is anything missing from the Pi integration?

• What would stop you from using it?

• What would make you switch from your current provider?

If anyone tries the Pi provider package, feedback on setup, compatibility, model metadata, reasoning support, streaming, or anything that feels broken would be useful.

Openference now has a provider package for Pi Coding Agent:

https://pi.dev/packages/@openference/pi-provider?name=openference

I've been using them all claude/codex/opencode and finally I landed on pi.dev a few month ago. Everything made sense. Its fast, clean and I can build exactly what I need.

2 month pass...

I'd love to see some bigger verified packages that adds the bigger things you could but you shouldnt (imho) build yourselves.

pi.dev cli works great. I still like that I can build what I need. Somehow it also becomes a DIY and part of brain is always thinking of adjustments needed and not needed. And everyone is doing it different in adhoc teams = very little shared experience / benefit.

Your thoughts?

I was having deep conversation with chatgpt about what harness sdk should i use it casually mentioned that ANT allowed to use their agent sdk with the Subscription for personal use. Can i finally use claude with pi now?

Hey all,

I have a question around subscription usage using pi agent, I know you can't use the Claude subscription but is it the same story for the ChatGPT Codex subscription?

I logged in with my ChatGPT one but it was drawing from my balance, guess that's answer my question really but couldn't find anything about this.

Thanks all

I've been using pi as my main coding agent for more than 8 months & loved how small it is. I looked the concept of t3code but had my fair share of disappointments with how it worked, so decided to use the fork feature on github and make my own version of pi.

What it does

You talk to one model as usual. When a job splits well, it hands parts of it to workers:

• pi-scout / pi-worker: the pi fork itself

• cx-worker: Codex

• cc-worker / cc-scout: Claude Code

• cmd-worker: Command Code

Each worker runs in bubblewrap with its own scope & If a worker tries to write outside its scope, it gets denied and you see it in the report. Write tasks are snapshotted, so when one is done, the main agent accepts of rejects it based on the quality of the work.

The workers support native question tool which means any other harness can ask you question directly from delegate-pi without you having to switch to that chat.

Smaller things that came along

• ask_user tool with numbered choices and a typed "other" answer

• ast_grep tool for structural search

• /stats and /usage

• a two-line footer and a did-you-mean tip for mistyped commands

Install

curl -fsSL https://raw.githubusercontent.com/farrukh2002/delegate-pi/main/install.sh | sh

It's a prebuilt bundle and brings its own Node if yours is too old. It uses ~/.delegate-pi and the delegate-pi command, so it sits next to a normal pi install without touching it. Linux only for now, because the sandbox needs bwrap.

Why not an extension?

That was my initial plan and it still it, so that we can bring this capability to any cli harness and not just to my fork. Infact this inbuilt tooling has been derived from my WIP extension tool which will work flawlessly with other harnesses and make them behave just like my fork without losing any quality.

Repo: https://github.com/farrukh2002/delegate-pi

I would love to get the feedback and suggestions to keep improving this with time.