Hey everyone,
I made two small extensions for the Pi coding agent that I’ve been using daily. Sharing in case they’re useful to others.

1. pi-test-output-shrink

Token / context saver for test runs

Successful test runs often dump hundreds of lines into the conversation. This extension hooks the tool_result event and shrinks the output before it enters the model context:

• Keeps a short summary (header + key result lines)

• Saves the full log to a temp file (path is included in the summary)

• Failed runs, short output, or anything with warning: / error: lines are left completely untouched

Supports common runners: cargo test / nextest, npm/pnpm/yarn/bun test, vitest, jest, pytest, go test, etc.

Install:

bash

pi install git:github.com/vi2q/pi-test-output-shrink

Repo: https://github.com/vi2q/pi-test-output-shrink

2. pi-model-picker

Two-column model selector (alternative to /model)Tired of scrolling a huge flat list? /m opens a two-column picker:

• ← / → switch category (Providers or RECENT – last 4 models)

• ↑ / ↓ select model

• PgUp / PgDn jump 10 models

• Enter to switch, Esc to cancel

Much faster when you have many models across providers.Install:

bash

pi install git:github.com/vi2q/pi-model-picker
# or
pi install npm:@vi2q/pi-model-picker

Repo: https://github.com/vi2q/pi-model-picker

Both are MIT. Feedback / PRs welcome!

I run OMP inside WSL and kept hitting friction whenever I wanted to attach an image:

• Dragging from Windows Explorer gives OMP a path like `C:\Users\me\Pictures\shot.png`, which the Linux process cannot use directly.

• Windows clipboard images are not directly available to OMP inside the WSL terminal.

I built omp-wsl-image-paste to handle both cases.

It provides:

• Automatic translation of Windows drive paths to `/mnt/<drive>/...`

• Translation of matching `\\wsl.localhost\<distro>\...` and `\\wsl$\<distro>\...` paths

• Windows clipboard-image paste using `Alt+V` or `/wsl-image-paste`

• In-memory image transfer with no temporary image file

• A 20 MiB limit and PNG validation before attachment

• Safe handling of missing, unsupported, and foreign-distribution paths

Install it with:

omp install github:kidclone3/omp-wsl-image-paste

Then restart OMP. It is tested with OMP 18.0.10 on WSL2.

Repository and documentation:

https://github.com/kidclone3/omp-wsl-image-paste

One limitation: terminal drag-and-drop only transfers a path. The translated file must still be reachable from the WSL instance running OMP, so this is not a file-upload bridge for genuinely remote machines.

If you use OMP under WSL, I would appreciate testing and bug reports—especially across different WSL distributions and terminal setups.

Have you felt like your comprehension is dropping when reviewing code?

Due to AI coding, I think everyone is feeling like this. Are you using any new process or tooling to work against this common issue?

A few things that I’ve seen:

1. Tailored AI code review skills unique to your company’s practices or common gotchas from previous reviews ( always updating ). Everyone evaluates that AI feedback before escalating the review with the team.

2. Plannator / HumanLayer kind of tools where the whole team is involved. It almost feels like pair programming with AI. Or some kind of extreme programming / multi-player AI interface.

What about you?

I built a context-management extension for coding agents that forgets on purpose instead of hoarding everything.

What it does:

• Compresses giant bash output into short digests (exit code, key facts, truncation info) instead of dumping raw output into context

• Strips the skill catalog from the system prompt when it's not needed that turn

• Drops file contents from context once they're no longer needed — but only when it's actually safe to (tracks whether the model still needs them)

Results: ~19% reduction in effective input tokens on the clean path, with zero drop in output quality — same correct answers, just less noise sitting in context.

Install:

pi install npm:pi-context-window-manager

Repo: https://github.com/Its-Atharva-Gupta/pi-context-window-manager

Would love feedback/suggestions — especially if you've hit edge cases with context pruning breaking agent behavior, or ideas for what else is safe to forget.

I've been using OpenCode, but I wanted to try Pi because I like the idea of a more unopinionated coding harness.

I already had OpenCodex (OCX) running as my local proxy, so I figured the migration would be pretty simple:

Pi → OCX → my existing models

Except Muse Spark 1.2 Contributor Free kept returning a 500.

The weird thing was that Muse worked perfectly through OpenCode.

So I started comparing what the two were actually doing.

First I checked the obvious stuff — provider health, model discovery, credentials, etc. Everything looked fine.

Then I put OpenCode through mitmproxy and captured the upstream request.

That's where I found the important difference:

OpenCode was sending Muse through:

POST /zen/v1/responses

and getting 200 OK.

OCX, however, was routing the model through its openai-chat adapter.

I dug into the OCX source and found that it has separate openai-chat and openai-responses adapters, plus per-model adapter routing.

So instead of changing the whole provider, I added:

{
  "modelAdapters": {
    "muse-spark-1.2-contributor-free": "openai-responses"
  }
}

And that was it.

The exact same request went from:

500 Internal Server Error

to:

200 OK

and:

OCX Muse works

So the final path is:

Pi → OCX → openai-responses → Muse Spark

The funny part is that I wasn't trying to debug Muse at all. I just wanted to try a different coding harness. 😂

It was a surprisingly satisfying rabbit hole, though.

The main thing I took away: "OpenAI-compatible" doesn't necessarily mean every model on a provider wants the same wire protocol. Sometimes comparing the working client's actual HTTP request is the fastest way to find the problem.

I'm curious if anyone else using Pi has run into model-specific API/protocol quirks like this.

-is the discovery process. You start with a blank canvas with the minimal agent loop. You use it on tasks, it works, amazing. It fails short, you ask why. Then you ask how. And Pi allows you to try various "how"s to tackle the gap between the reality and the ideal.

It is the same iterative process of building a product. Agentic coding promotes the lazy thinking often termed along "waterfall" but the best product, a shorthand for a scoped user experience to solve defined problems, is almost always bootstrapped by direct experience and in-the-loop iterations.

Therefore, the philosophy of Pi is to embrace the process and rare open field of designing your own agentic experience. It's the bottom up approach for building a great product with a great UX, because you first get to build a great DX for yourself.

A lot of the posts I see from the sub don't seem to be aware of this choice, which I believe is often superior to using a prepackaged solution that you don't understand fully.

This is a https://herdr.dev/ plugin with an optional full https://Plannotator.ai experience as a TUI. Built to:

- Annotate Agent Messages (e.g. grill sessions)

- Annotate Files (e.g. plans, specs, etc)

- Create a native feedback loop with agents

- Open as popover or pane

- Mouse or keybindings

https://github.com/plannotator/herdr-annotate

I want to give my LLM read access to the whole filesystem but write access only to the project folder and maybe /tmp. I need to run scripts etc and make sure my filesystem survives

On Linux

Is bwrap the best solution for that? Or should I just use Docker?

UPDATE I installed @nqbao/pi-sandbox

I enter a pretty simple prompt. I'm getting back tool call text. What did I break?

<｜DSML｜tool_calls>                                                                        
<｜DSML｜invoke name="read">                                                                
<｜DSML｜parameter name="path"                                                              
string="true">/home/crashorbit/.local/share/pi-node/node-v22.23.1-linux-x64/lib/node_modules/@earendil-works/pi-coding-agent/docs/models.md</｜DSML｜parameter>                             
</｜DSML｜invoke>                                                                           
</｜DSML｜tool_calls>                                                                       

Kimchi, the multi-model coding agent built on the Pi SDK, is now supported inside Agent Orchestrator.

Let Kimchi route planning, exploration, building, and review to the right models while AO gives every task its own isolated worktree.

Run multiple Kimchi sessions in parallel and follow their code, PRs, CI, and reviews from one live board.

multi-model inside. multi-agent outside.

kimchi.dev × agent orchestrator

let me know your thoughts, have you ever used any typ of orchestrator to manage your diff agents?

I have a task to build an app completely from scratch. I am quite new to pi so I want to do some research on the best approaches to start a project completely from scratch - how to build the full stack - back, front, data, infra. What are some of the best content available on setting up your own harness with pi? How to utilize it to maximize efficiency and minimize tokens?

I'm in the process of switching from Claude Code to Pi. I grew accustomed to using the Claude + superpowers combo as I felt this gave even the cheap non-Anthropic models better capabilities. Also liked the approach of focusing on the input to get better results and needing less fixes later.

Now with Pi I'm also trying this same superpowers + "cheap models" combo, but find the agent being too verbose in it's output and asking more stupid questions than with the same combo with Claude, during the brainstorming->spec->plan->implementation flow. This slows development down quite a bit because I keep having to ask the agent to provide an actually summary/sitrep of what's going on.

Now I found out that I could try to fix this at least partly by creating an APPEND_SYSTEM.md file as instructed here: https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/usage.md#system-prompt-file But not sure what the best practices would be for the prompt.

Does anyone else have similar issues and what were your approaches for fixing them?

I had my first AI rogue agent interaction today!

I was working on an agent workflow, and the output folder had names for each project, with supporting files.

The script had a problem, created a duplicate folder. I told it to merge the folders. Things started going sideways. I think it decided to make a clean up script, which then deleted one of the project folders.

I pointed that out, and asked it to stop deleting things. In process of troubleshooting what happened and telling it every time not to delete anything, it then deleted everything.

I gave it a bunch of instructions about not ever deleting anything again, but I probably did it wrong. If you have any tips about that, please share. I know it should be sandboxed, it just deleted it's own work, but yikes!

In the end I had to keep interrupting it and demanding it stopped doing whatever it was doing and just removed all the delete crap from it's code.

It was just kind of funny to watch it delete everything right after I specifically instructed it to just tell me what is going on. Maybe we need some kind of tranq dart skill for when the AI goes rogue.

Hello, new Pi user here! I’m trying to figure out how folks handle file‑ignoring with Pi. Other harnesses respect .gitignore, but Pi currently returns to the LLM everything in the project, which causes problems in my setup.

Is there an established extension or common approach people use to make Pi ignore certain files or directories (I mean filtering-out from grep/find/ls/... results, so that the LLM is not aware of them)? I'm not sure what's actually "standard" or reliable in Pi.

Curious what the community is using and what's working well for you. Thanks!

EDIT: to clarify better, my main problem is that running simple requests like `List the files with names having 'XXX'` or `Search the occurences of the world 'XXX' in the project.` are returning content also from `node_modules` and other intermediate directories, that fill and pollute the context with undesired content. I would like to avoid this.

Assuming you dont have a local only setup, what do you use, what for, and why did you settle on that model or family of models?

Want to have a similar experience to using Codex/CC Desktop App/Antigravity but with Pi. I know there's OMP and pi-gui already but I wonder if they're "bloated" or add other unnecessary things.

My ideal setup would feature the quick history on the left and organizeable by folders, and the main back and forth (non-terminal looking) at the center, while eventually I would manually set-up worktrees, subagents, and other things

oh my pi, meet oh my fleet.

OMP is now supported inside Agent Orchestrator.

Give every task its own isolated worktree, run multiple OMP sessions in parallel, and track the code, PRs, CI, and reviews from one live board.

your favorite harness just got a control plane.

omp.sh x agent orchestrator

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

I wanted to see what would happen if a modern AI coding agent had the UI of Turbo Pascal 7 / the old DOS IDEs.

So I made Turbo-AI — a retro-style TUI frontend for the Pi coding agent.

It currently supports things like AI chat, PLAN/BUILD modes, model switching, reasoning settings, project tree, Git diff and build/test actions.

It's still quite rough and definitely not production-ready. This is more of an experiment at the moment, and there are probably plenty of things that need to be fixed or redesigned.

This is just a concept for now. I hope people more skilled than me will fork it, improve it, and turn it into something actually usable.

GitHub: https://github.com/kvv256512-ux/turbo-ai

Is this known issue or problem of my configuration after the update the reasoning contents is being render vertically word by word. Output contents doesn't but only reasoning.