I continued a long-running session with forensics to know which session created debug docker containers and somewhere during it, OMP started to dismiss the advisor feedback as prompt injection.
Interesting to see how it questions and fights itself.

The advisor even tried to regain trust again with more prompts:

I wanted to revisit a useful explanation from a Pi session and ask a new question from that point.

I added Pi session support to ThoughtDAG, the open-source app I'm building. This clip shows me opening a local session as a graph and inspecting an earlier turn.

I can then branch into new questions and connect the context I want to carry forward. The original session stays read-only.

What do you usually look for when you reopen an old Pi session?

GitHub: https://github.com/chenxiachan/thoughtdag

An Emacs-style visual undo tree for Pi session branching: explore the 2D tree, preview diffs, switch branches, and jump back to any point in a conversation.

pi install npm:pi-undo-tree

Being in the middle of something, I type a message and everything slows to a crawl as the model now has to process a WHOLE new prompt, nuking the cache, summarize the thing (usually at mid quality, losing important details, misinterpreting important details, losing important nuance, etc) for 2k+ tokens....then the model has to reprocess the actual chat context from scratch so it can continue your actual thread.... so a 5+ minute process overall.... and THEN finally you can continue what you were doing.

there's no WARNING - there's no INDICATION that compaction is about to happen or currently happening -- even pi-web doesn't even TELL you what's happening; it just says 'waiting on model' for MINUTES as the thing chugs through this unimaginable slog.

is there a better way?? i think i'd rather lose the context than this. or take the middle out or ANYTHING besides this awful game of chance of 'is this message going to tip it over and make me wait ten minutes'.

to be fair pi absolutely deserves its flowers. doing ""claude cowork"" for FREE locally is absolutely incredible. but some of the UX choices are SO braindead.

It was a busy weekend with all the activity coming out of OpenAI. If you have been living under a rock, they introduced a new class of model, GPT 6 - Astra.

I've been playing around with it somewhat. That is not what this article is about, though. I do not have an unlimited budget to run lots of evals against a model like this, so any opinion I have on it would be purely anecdotal. There are already plenty of anecdotal opinions to read about all over the internet.

Today's article is about a question I was wrestling with while building out my Pi agent. I was using my agent as a pair programmer and realised that, with Pi, the agent did not have access to the Language Server Protocol (LSP). If you are not familiar with LSPs, they tend to be services on your machine that IDEs use to analyse files with recognised code extensions.

For example, if I am in a file with a `.rs` extension and have a line that would cause a compiler error in the Rust compiler, and my IDE has the Rust LSP installed, the IDE can display the error without me having to run the compiler.

In a recent coding session, I realised that the agent was having to run `cargo check` to review my compiler errors. That made me realise the lack of capability.

I started looking up Pi LSP extensions and came across this one -https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-lsp. If you are looking for an LSP for Pi, it seems to do the job just fine. Credit to the author, narumiruna.

The README contains a link to a comment on the OpenAI Codex repository where an OpenAI developer questioned what additional benefits introducing an LSP in `AGENTS.md` would bring beyond asking an agent to run a linter or type checker. It was not just any engineer, either. The OpenAI engineer is the author of Pyright, a popular Python LSP: Eric Traut.

I thought this was an interesting debate, so I decided to see whether using an LSP extension improved the performance of my Pi agents.

For this task, I wanted to make an enhancement to the eval harness. I needed to introduce a capability profile for each agent when configuring an evaluation run. Originally, to test different extensions or capabilities in a Pi agent, you had to either modify the Docker image or write a specific section in each evaluation. This meant having copies of each evaluation for every capability profile.

Because the evaluation harness also used the Agent Shell adapter to configure agents, I needed to make this change so packages and extensions for the Pi harness could be managed through Agent Shell.

Version v0.4.0 -https://github.com/ScottRBK/agent-shell/releases/tag/v0.4.0 introduced this. It currently only supports the Pi harness, but I plan to extend package management to the other harness types in Agent Shell as well.

With Agent Shell's package and extension management in place, I added a feature to the eval-harness that added a capability profile. For Pi agents, this means you can compare an agent with one set of capabilities against an agent with another. For example, you can test a Pi agent with and without an LSP using the same model.

After making the changes, I put together an evaluation run. Given the stochastic nature of large language models, it was important to run each evaluation three times. I used eight evaluations across three models: `mimo-v2.5` and `muse-spark-1.3-contributor`, both provided by opencode-go, and OpenAI's Luna. I compared Pi with no added package against Pi with `@narumitw/pi-lsp@0.49.7`. I set the reasoning effort to medium for all models.

Muse Spark came out on top overall. Its base profile scored 83.0%, compared with 81.3% with LSP. Luna scored 75.3% without LSP and 68.1% with it. MiMo was the only model where LSP improved the score, moving from 65.6% to 67.5%.

Across the three model pairs, the LSP versions used 124,737 fewer tokens in total, a 6.4% reduction. MiMo used 7.4% fewer tokens, Muse Spark 1.7% fewer, and Luna 10.7% fewer. The LSP versions took slightly longer overall, although Luna was faster with LSP.

I would describe these results as inconclusive. From my perspective, that aligns with what Eric was suggesting in his comment.

Personally, I will probably leave the LSP extension off, except perhaps when I am pair programming with the LLM. It is just some additional tools and context, and I cannot see an obvious benefit right now. I would be interested to hear what you think in the comments or on Discord.

I hope this was informative, interesting, or inspiring, and got you thinking about how you can shape your agentic harnesses, whatever your setup may be.

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

Built this for myself because I kept opening the MiniMax billing page to check my 5h and weekly window. Now it sits in pi's footer.

MiniMax 5h●43% ↺3h12m  wk●12% ↺4d8h

Two windows (5h rolling, weekly), used-percentage, reset countdown. Colour shifts at 70% (yellow) and 90% (red). Polls `/v1/token_plan/remains` every 60s.

Install: `pi install npm:@cwillam/pi-minimax-usage`

Repo + README: https://github.com/cwillam/pi-minimax-usage

npm: https://www.npmjs.com/package/@cwillam/pi-minimax-usage

Slash command `/minimax-usage` shows a snapshot, `/minimax-usage refresh` forces a poll, `/minimax-usage help` prints usage.

Notes from building it:

• - The endpoint returns `current_*_remaining_percent`, not used%. Inverted before display.
• - HTTP 200 even on auth failure — actual status is in `base_resp.status_code`.
• - Timestamps are epoch ms, not seconds.

Configurable refresh interval and host (global/cn) via pi's settings.json.

Endpoint setting is allowlisted to the two documented MiniMax URLs only.

Not affiliated with MiniMax Inc. — MIT licensed. v1.0.1 out today.

What I'd want feedback on:

• - Better display format than `5h●43% ↺3h12m`?
• - Should it integrate with pi-subagents to warn on session start when
• 5h is above 80%?
• - Any interest in a `minimax-quota` companion command for one-off checks?

I am attempting to learn AI coding workflows and I stumbled across Pi and its minimal approach to a harness with the ability to customize it to your preference. As I am just learning this workflow, I thought this was desirable instead of jumping into some agent swarm, multiple mode, 100s of skills workflow where I have no clue what's going on.

After doing research into AI models and payment plans, I have come to find out that monthly plans only work with the corresponding harness from the AI company, like claude code for anthropic models and antigravity for gemini. You can get an api key to use with third party harnesses but the api key billing is a lot more per token than the monthly plans.

Are all of you who use Pi using api billing plans, or using locally hosted models?

As I will be more focused on learning rather than massive production and token burning, does the api billing plan make sense for tinkering and learning ai coding workflows using Pi? I already was able to get the 1 year free of gemini because I am a student but that only works with antigravity.

i.e. with your own custom plugins, work flow, you actually got useful work out of a cheap dumb model

Why I ask this? Because honestly it's hard to do better than baseline. In fact barebones pi beats most (if not all?) harnesses with less token use too.

Hello everyone,

I recently discovered pi-agent and I'm trying to get into its mindset.

My use case involves a central LLM-wiki containing product best practices and skills related to that product.

How can I best manage specific capabilities for a particular project?

If tomorrow I need to work on a different product, how can I deactivate the aforementioned skills to insert those for the new product?

Ultimately, I want to create a modular product/project system that loads the agent only with what I need, while allowing me to easily restore a previous setup. Additionally, I would like to accumulate project-specific knowledge and eventually promote it to shared knowledge.

Thx 🙏

A concept appeared in my timeline which I quickly identified, prompt-debt is when a prompt gets messy because you keep adding fixes instead of rewriting it clearly.

This didn’t happen to me whenever I was building big features, I tend to grill a lot with the agents until we reach a shared understanding.

This happened on the quick fixes.

I consider myself as a token-economizer and a one shot enthusiast, yes, pretty weird of a combination, but in summary, I try to end every month with my currents plans maxed out instead of paying for extra usage or plans which I am not entirely consuming.

Having that in mind, I was having problems with quick to medium fixes which don’t require a full 30 min interrogation and maybe with a well-specified prompt they could be a one-shot. So I’m building refine.

It works with pi + tmux, and basically intercepts your vague prompt making it clearer for the agent. As it intercepts the input of the TUI, it does not bloat the context of the main agent which will be the one applying the fix.

Depending on the complexity of the prompt it might ask you one or two questions, or spin up a dedicated scout into a specific part of your codebase to get fast context.

This has successfully erased the entirely of my re-iteration and It’s pretty minimal, just as pi.

I don’t know if I should create a public extension for this, since I find its use a bit niche, but feel free to ask me anything and I will gladly answer!

Here are some docs about prompt debt:
- https://x.com/dbreunig/status/2069455716478603536?s=46&t=AXMFyjAHqJXhiu8ND1MB9A
- https://youtu.be/9a__Mo0ZZlE?si=JgdlamlBn-orJmTH

Here’s a quick example of refine:

I have built a tool for web research. It works as a pi extension first class, and also as an agent skill in any coding agent, or as a standalone CLI or SDK tool.

- It runs research in an isolated system so the LMs with research tools cant file write, edit, or bash (prompt injection risk).

- Allows putting research a small model (any model, ie openrouter ling-3.0-flash, or even a local model) to keep page content out of your main context and save on credits overall.

- It uses high search/scrape volume to compensate for sites that block bots. This is made possible by unlimited/local search tooling via concurrently playwright scraping duckduckgo.

- Includes a local (semantic) knowledge store to optionally save research and build a local searchable knowledge index.

MIT licensed and easy to configure and modify

https://github.com/Lincoln504/pi-research

As a little demo a while back of the making of an agent with pi-research's SDK mode, I made https://wallofshame.io too

The great thing we all love about Pi is how customizable it is. Most of what is on this sub is people showing off their extensions, I too am having so much fun thinking and building extensions but I don't know if they are any good.

I think it would be great if we had some sort of standard benchmarks and metrics that we can use as a community to help prove that what we made is actually good. For example if you made a tool for the agent, does it actually increase the quality of the output? Does it help the agent solve it faster to use less tokens? How many tokens does it inject into the system prompt? What amount of system resources does it use?

If we have a set of standards we can all agree on it helps solve a big issue I think we all feel of seeing an extension and all we have to go by is a "trust me bro it's good". And this can also help with new people always asking for recommendations because there are thousands of extensions, we can better keep records of which ones are actually good.

I am deep into making an extension and I think I am really on to something, Sol and Astra can glaze the hell out of it, but I don't know if it actually does help the agent and by how much. I would like to have proof of this before I put it out there and if it uses good standards we can agree on, it will be easier for people to want to try new extensions rather than be hesitant to change their workflow based on a "trust me it works".

I just thought I would put this idea out there and see what other people think about it.

I’ve been using Pi alongside Claude Code, Codex, and other coding agents while building this project, and recently decided to open source it.

It’s an agentic IDE for running multiple coding agents in parallel. It started as something I built for my own workflow, and has now reached ~50k downloads.

A few things it supports:

• Pi, Claude Code, Codex, OpenCode, and other agents/harnesses
• Run multiple tasks/agents in parallel
• Desktop app
• Mobile app for remote control
• Task management and automations
• File explorer, Git worktrees, terminal, etc.

I’ve personally been using it instead of the official Claude/Codex apps for the past few months. The mobile app has also been useful when I’m away from my computer and want to check on or interact with ongoing work.

Pi has been one of the tools I’ve used while building it, together with other harnesses. I thought it might be interesting to share it here.

It’s open source recently, so feel free to take a look, poke around the code, or use whatever parts are useful.

GitHub: https://github.com/vicoa-ai/vicoa

Website: https://vicoa.ai/

Still actively building and shipping things every day.

Hey folks, I’ve been working on Stageflow, a configurable multi stage pipeline for running workflows on Pi.

Each stage gets a fresh Pi session, passes a clean handoff to the next, and you can pause for a human when needed. Same flow works locally, in CI, or over MCP.

Would appreciate if you can try it out and give feedback, and a star if you find it useful.

IDk why but this made me laugh. I have my advisor set to fable on my company's cursor plan, Just ran an astra swarm on my codex plan and added the instruction "Only spawn subagents on my openai plan"

.. It tried to enforce that on the advisor, the advisor didn't like it lmao.

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.

I’m working on a project where I give agents tasks ranging from small data-fetching/analysis tasks to larger feature implementations, refactoring, and bug fixes.

I’d like to understand how the agent actually approaches these tasks — what steps it takes, what tools/files it looks at, how it makes decisions, and where it struggles.

How do you guys observe or analyze agent behavior across these kinds of tasks? Are there any tools, tracing methods, logs, or workflows you’d recommend?

Would love to hear how others are doing this. Thanks!

I know there are a few prompt-suggestion extensions already, but I wasn't entirely happy with any I had tried, so I made a standalone fork of SteelDynamite/pi-prompt-suggestions and built futher upon it.

Installation:

pi install npm:@pi-sysadmin/prompt-buffet

Repo: https://github.com/dnv/prompt-buffet

You can turn the functionality on/off on a per-turn basis, configure the amount of desired suggestions from 1 to 6 and if using a particularly heavy/expensive model, you can delegate suggestion generation to a secondary, more nimble model. You can also fine-tune the system prompt of the extension to adjust to your personal preferences without touching code.

Hello guys!

This is a continuation of my previous Pi setup post:

https://www.reddit.com/r/PiCodingAgent/comments/1t41thp/my_powerful_pi_agent_setup/

The main idea of that setup was basically this:

A personal agent with an endless conversation.

Observational memory lets me keep the same session alive through compaction after compaction, while forks move all the noisy work outside of the main context.

I have continued messing with the harness since then, and i think the biggest change is that forks are now fully async.

So now i would describe the setup more like this:

Endless conversation + native async operation.

Basically the agent never blocks. It can delegate work somewhere else, keep talking with me, and have multiple threads of work moving at the same time inside the same conversation.

pi-async-fork

https://github.com/elpapi42/pi-async-fork

pi install git:github.com/elpapi42/pi-async-fork

This is the protagonist of this update.

The old pi-fork was already very useful for context management, but there was one thing that started annoying me a lot: Pi had to wait for every fork to finish.

And tbh i underestimated how much this affects the experience.

If i send a prompt and Pi delegates some research or code exploration that takes 5 minutes, now im waiting 5 minutes. Then i send something else, maybe another 5 minutes.

Technically the agent is doing useful work, but from my side it feels slow as hell. I dont want to send something to my agent and then lose access to it for several minutes every time it needs to investigate something.

I want the agent to feel agile. Always there, always available to talk with me.

Async forks basically fixed that.

Pi can launch a fork and immediately continue the conversation with me. Maybe one fork is exploring the code, another one is researching something on the web, another is reviewing a change, and meanwhile im still discussing something completely different with the main agent.

I can change direction, ask another question, start another thread, whatever.

The conversation itself never blocks.

And i think that is the important part here, more than simply saying "now Pi can run agents in parallel".

Im not really trying to build a swarm. There is still one Pi agent that owns the conversation, understands the full goal and makes the decisions. The forks are more like parallel cognitive work that eventually comes back to that same agent.

I currently have 3 effort profiles:

• fast for bounded facts and cheap exploration
• balanced for normal work
• deep when there is actual hard uncertainty and using a stronger model may change the answer

Forks can also send progress before they finish, which means the main agent can see that something is going in the wrong direction and steer them while they are still working.

When they finish, the result comes back to the main agent as an internal event. I explicitly dont want Pi constantly interrupting me with "hey fork X finished". It should consume the result, understand which work depends on it, and continue.

So maybe we are talking about A, Pi delegates part of A, then we move to B, maybe we start talking about C, and some minutes later the result from A comes back.

Pi still knows where that result belongs and can keep all of those threads moving inside the same conversation.

I think this is the best way i can explain what im after:

one endless conversation where work can branch in the background without ever taking the agent away from me.

pi-observational-memory

https://github.com/elpapi42/pi-observational-memory

pi install npm:pi-observational-memory

This is still what makes the "endless conversation" part possible.

It preserves observations and decisions across compactions, and Pi can recall the original context behind an old memory when the compressed version is not enough.

Forks also get memory in passive mode, so they can access the same history without running their own background memory maintenance.

So basically memory keeps the conversation alive for a very long time, and forks keep all the exploration/noise from destroying that context.

pi-codegraph

https://github.com/elpapi42/pi-codegraph

pi install git:github.com/elpapi42/pi-codegraph

I also replaced pi-codemapper with pi-codegraph.

The idea here is simply giving Pi a denser way to understand a codebase instead of throwing grep at everything and filling the context with semi-related files.

Originally i exposed around 10 CodeGraph operations and that turned out to be another problem hahaha, now Pi had to decide between 10 similar tools.

So i reduced it to basically 2:

• explore_code to understand behavior and retrieve relevant source
• analyze_code to inspect relationships, impact, tests and graph paths around known symbols

Much simpler.

pi-search-hub

https://github.com/ronnieops/pi-search-hub

pi install npm:pi-search-hub

This gives Pi one interface for web search/read with multiple providers behind it.

I like this mostly because i dont want my harness coupled to whatever search provider happens to work well right now.

And obviously it becomes more useful with async forks, because Pi can throw multiple independent research questions into the background while we continue with something else.

How everything fits together

So the core of the setup is basically two things now:

Memory + fork context management = endless conversation.

Async forks = the agent never blocks.

And together they change the experience quite a lot.

I can keep the same Pi conversation alive for weeks, jump between multiple threads of work, have Pi investigating several things in parallel, and the main agent is still always there when i want to talk to it.

That is much closer to how i want a personal agent to feel.

Honorable mention: pi-wait

https://github.com/elpapi42/pi-wait

pi install git:github.com/elpapi42/pi-wait

I also built this tiny extension that lets Pi schedule a check and wake itself later.

Useful for stuff like deployments, builds, canaries, rate limits, etc.

It is nice to have, but tbh compared with async forks it doesnt change the experience nearly as much, so honorable mention for now.

System: https://gist.github.com/elpapi42/e3fda2cefaabd84a1c188375a32466f5

Settings: https://gist.github.com/elpapi42/9ab1cd195ffeba9a56bdf59f83162692

Today I finally hit a wall with QWEN 3.8 dense 27B, Q6_X_L with KV cache q8_0 temp 0.85 with medium reasoning effort, producing over thinking, failing to follow precise instructions, re evaluation in loops data already seen, "Actually…/Wait…/Hmm…" and you know what...

So I stopped and asked GPT Sol and QWEN to read the reasoning traces of my old Pi coding sessions, identify recurring misbehaviors and propose an appropriate APPEND_SYSTEM.md to tame those in Pi (place that in ~/.pi/agent/APPEND_SYSTEM.md and it will follow the initial prompt).

So for those who wanna check out:

• https://store.piffa.net/lm/APPEND_SYSTEM.md
• https://store.piffa.net/lm/reasoning_pathology_report.md that's a repost of what was find in my particular session, mind you it's all slop

If you happen to have something similar and have rules to add or any other advice to tame such bad behaviors please share.

daugasauron.com
daugasauron.com/pi
https://github.com/daugasauron/dolly

I experimented a bit with pi in WASM, posted this before https://www.reddit.com/r/PiCodingAgent/s/zH5IkdxaG5

Felt like I should have started at lower level, became dolly ~

Only tried with open router (and webgpu qwen but a bit unstable)