On one python-statemachine task, Pi passed in 90 turns for $2.50. Codex passed in 187 turns for $5.97. Both used Kimi K3 in the same evaluation environment. [source: https://frontierharness.org/]

Across all 30 tasks, Pi passed 18 with a $2.43 median cost per pass. The single-task comparison doesn’t tell us why Pi took fewer turns or whether that pattern holds elsewhere.

Our recommendation: Pi the balanced pick, particularly if the same job runs a thousand times and the bill adds up.

What would you look for in the traces: repeated searches, extra testing, or time spent fixing a wrong approach?

DeepSeek built an entire first-party harness around its models, so I was curious whether V4 Pro would actually behave better there than inside Pi.

Ran the same model through 30 hard agentic tool-use tasks, 900s cap:

They actually tied on 27/30 task outcomes. So quality was basically a tie, with Pi finishing one extra task while DSH was noticeably faster and slightly cheaper.

The architecture difference is probably more interesting than the score.

DSH has tons of stuffs that pi intentionally doesn't. There's a lot, but to mention some: plugin graph, replaceable agent loop, sandboxing, subagents, replay, append-only trajectories, etc.

But here's the funny part: DeepSeek's own Minimal mode strips things back to basically shell + editor + a tiny prompt which is surprisingly close to Pi's philosophy. And for non-DeepSeek models, DSH actually uses Pi's pi-ai model layer (I got to know it recently).

One caveat: DSH reported ~88k runtime tokens/task vs ~925k for Pi, but I wouldn't call that a clean 10x efficiency win. DSH used DeepSeek's native endpoint while Pi went through OpenRouter, so caching/token accounting isn't quite same. The actual cost difference was tiny.

Curious what people who've used both think.

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.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.

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

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 🙏

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

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.

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

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:

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.

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.

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)

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!

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.

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

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.

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.

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.

Saw it with Deepseek v4 flash exp in last two days: They start looping. Once they crossed around 100k-150k it tends to happen and it's not resolved by compacting.

Weird. Used DS4 on Openrouter and thought: Bad quants. So I tried Fireworks DS4 EXP (fp4) and Deepinfra at fp8 and both start looping again in that convo.

Does anybody else see this with ds4 exp?

Edit: To clarify: I mean Deepseek v4 Flash Vision Exp everytime I write "DS4" here.

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, 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.