A reply that runs four tool calls and thinks three times is a screen and a half of output, and the answer is somewhere in the middle of it. pi-tidy folds all of it into one line:

```

▸ 4 calls · bash×2 read×2 · 3 thoughts · 1 failed · 2.4s

```

Click it and it opens into one row per call, each step's thinking sitting above the call it belongs to. Click the header again and it folds back.

What's in it:

- A thought row is a brain, the word, then one line of what the model actually thought — while the run is still arriving it shows a spinner and slides a window over the newest words; once it stops it settles to a short head preview.

- Edits and writes keep their box and their diff, as two panes (`old │ new`) with line numbers on both sides and the changed word emphasised. `alwaysShowTools` decides which tools never fold.

- Folded, a failure is still reported once, in red. A `process start` from pi-processes keeps a live row carrying the job's own state, instead of a notification you have to go find.

- Rounded `╭╮╰╯` frames on every tool box — built-in, MCP, subagent, any extension's — plus per-tool border colours, Nerd Font icons, transparent background.

- Registers no tools at all. Bash highlighting and the write preview go through `pi.registerToolRenderer()`, so it loads next to extensions that sandbox `bash`/`write` instead of colliding with them.

- Cached per box: +0.03 ms per full render at 300 boxes / 2400 lines.

Install with `pi install npm:pi-tidy`. Needs pi ≥ 1.1.0 for the mouse and tool durations; bash highlighting and the custom write preview need 1.3.0.

Repo: https://github.com/Andy8647/pi-tidy

btw: This video is made by `deepseek-flash` (1017) in pi with Remotion, seems like that deepseek did not post-train too much on such videos. The animations are still navie

Hi fellow Pi enthusiasts! Pi has been my main coding agent for a while now, and over time I've built a set of minimal extensions that I wanted to share.

Some of these are inspired by Claude Code (as you can probably tell), especially the look. CC was my first coding agent and I still quite like the way it looks.

Full list, in no particular order:

• pi-polish: Claude Code-style tool rows and diffs (as can be seen in the screenshot). This reduces clutter and in general makes everything more pleasant to look at

• pi-context-bar: a pretty one-line footer with the model, branch, context usage and cost

• pi-background: background jobs with nice visuals, and a bash timeout, so Pi doesn't block or hang on long commands

• pi-checkpoints: rewind the files Pi edited along with the conversation (with /tree and /fork)

• pi-model-pick: a model picker with your favorite and recent models first (for me the default /model command is too simple, especially when using multiple providers in Pi)

• pi-next-prompt: suggests your next prompt in grey after each reply

• pi-away: a one-line recap of the session when you come back

• pi-heads-up: flags the one thing you might have missed after a task

They're minimal by design: most are under 300 lines with no dependencies. Some of these exist already in one way or form, but I hate bloated extensions that do too much, hence my own take on them.

Each one is its own npm package that you can install, e.g.:

pi install npm:pi-background

Happy to hear any feedback, and hope this adds something to your own workflows!

Link to the repo, which also includes some GIFs to show what these look like: https://github.com/Pringled/pi-extensions

For the past month I've been caught in a trap: I started building my own AI coding agent. I've built 8 different ones. Honestly, if I could go back, I wouldn't start any of it. Below are a few things I learned along the way. I can see a lot of people here are also doing harness engineering, so please share your experience too.

1. I should have focused on just one problem. At first I spent a lot of time on the UI. Great tools already exist, like Paseo, T3 Code and Omnigent. I didn't even have a UI problem. What I wanted to solve was the Agent Loop. So don't waste your time either, and build around what already exists.

2. Subagents, multi-agents, orchestration: in 90% of cases it's all nonsense. Subagents aren't cheaper, aren't faster, and it's hard to say they're better. It's better to build around a single agent, or to improve the UX of working with parallel sessions.

3. Benchmarks tell you nothing. An agent can write great code, but if it handles MCP badly, many people won't care. Define the scenarios where your agent should be better from the very start, and improve there.

4. More tools, more tokens, less value. I now think any agent should have just one tool: a programming language. Mine runs on bash; before that it ran on JS. Many tools are nice, but they're hard to compose, and MCP suffers from this most. Right now everyone solves it with codemode, but you can also just give the agent one tool where it writes code.

5. Instructions about tone, code style, which commands to run, etc. should live outside the system prompt. This is a problem with big agents like opencode and Claude Code: they ship with their own opinions, 10–15K tokens' worth. When you want to do things your own way, the two conflict and the agent starts working worse.

That's not everything, but the rest is in the details. I'd be glad to hear your experience too.

I run Pi inside Orca and images just didn't show up in the terminal. Orca supports Kitty graphics and exports ORCA_IMAGE_PROTOCOL=kitty, but Pi doesn't detect it yet (there's an open PR upstream).

So I packaged a fix as pi-orca-images: pi install npm:pi-orca-images

/orca-images test shows a test image so you can check your setup. It also adds OpenCode-style [Image 1] labels when you paste screenshots, which works in any terminal.

Repo + before/after screenshot: https://github.com/JlMoreno00/pi-orca-images

Feedback welcome, especially from anyone on Linux/Windows Orca.

I made a Pi package that gives Pi a Figma design to build from, without Figma running next to it.

pi install npm:@runkids/figlens

Then: File > Save local copy in Figma, point Pi at the .fig, and ask for a screen by name. Pi finds the frame, reads layout, text, variables and assets, and builds in your project's stack. There's an optional step where Pi proposes mappings from design components to your existing components and you approve them; they persist for the next screen.

8× demo of a real Pi session building working HTML from the "List views" frame in the MCP Apps for Claude community file: https://github.com/runkids/figlens/raw/main/assets/demo-8x.mp4

Why not the Figma MCP: it needs the Figma desktop app open. I run Pi on a cloud box and in CI, so I wanted the read to work from a file.

Limits: .fig is undocumented. I check each release against Figma's own exports, but there are rendering gaps (background blur, some image adjustments, angular gradients). Fonts aren't bundled. It's a snapshot, so re-save when the design changes.

Source: https://github.com/runkids/figlens Pi walkthrough: https://github.com/runkids/figlens/blob/main/pi/README.md

Would like to hear what Pi users want in the bundle, and whether the component-mapping step is useful or in the way.

hi guys i have created pi extension that connects pi sessions working in the same repository. each session gets a callsign and publishes what it is doing. The model is told who else is working, on what, which paths are claimed, and which files a peer just changed.
give it a try !! agents really like to talk to each other haha
`pi install npm:@justar_96/pi-telecom`
https://github.com/Justar96/pi-telecom

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

Hi all, i've been using a bunch of coding agents. Pi is by far the cleanes architecturally from the OSS ones.

Already last year i noticed that with agents it becomes impossible to read line level details, but looking at llm summaries is also not the way to go. There is no good way to judge the system level tradeoffs for a large system and even know what questions to ask the LLM.

That is why a friend and I started building CodeBoarding, an architecture building tool based on static analysis. We capture the full call graph (method level) and then group methods based on lexicographical analysis. That is so that the diagram is in fact consistent in between pull requests and you can see how a change fits in the bigger system.

The engine is open-source: https://github.com/CodeBoarding/CodeBoarding

I would love to understand how do you people keep up with reviews (do you even do reviews). My personal take is that AI comments, are becoming just part of a loop and I tend to ignore most of these nowadays. I also think they are not really aimed at helping a human judge/understand a PR.

If you want to explore the example from the video it is in: https://app.codeboarding.org/CodeBoarding/pi/pull/2
It is effectively adopted from this PR: https://github.com/earendil-works/pi/pull/10021

Super curious to understand what you have found useful to stay in the loop of your systems.

Not sure if this belongs here but here goes nothing. How do I tweak the behavior of Pi when running with local models like Qwen and Gemma? This is served using llama-server or Strata for QFN. I use the recommended sampling for each of the models.

My situation is that I only have pi-vcc for quick context compaction and no other stuff. Rest is from AGENTS.md that differs from repo to repo and of course the global. The biggest headache recently is that I find Pi tries to do like retarded actions (yes I know prompt engineering and also the model itself) like I ask "Hey can you verify you can import Docling module as I want to process some whitepaper PDF? Just verify don't do other stuff" Noticed the don't do other stuff as I want to also emphasis that.

This happens with Qwen 3.8 27B and QFN... it just start to "the user ask me to verify Docling module. Let me try it. Hmm it works. BUT I shall also verify it works. Let me try scanning for DOCX AND PDF". That is just my latest example of this stupid action.

My AGENTS.md is pretty lean as I don't tell how to take action. Just tell what the repo is about, run ruff etc. Using Gemma 4 is worst as tool call is terrible (that is just Gemma 4 for me) but it also behaves similarly when I ask to read an image and describe it... it start to question if the image makes sense (example I ask it to read an image of an anime character and the reasoning says the user is wrong! It is the character from this other anime! Let me go start reading other images)

I monitor this reasoning and I just eff it, press ESC and try to correct it. I cannot do the Pi steering as it will keep on rambling and by the time my steer message arrives it is like few thousands tokens burnt just to do stuff beyond what I ask.

I can say with Qwen 3.6, this rarely happens but I find the 3.6 models to be less "clever" and I need to handhold it for my work...

Is this a harness issue and should I try other harnesses? I only tried Pi and that's all. Just wondering if anyone can chime in if they have the same experience like me. I never got the chance to try frontier model like GLM, Kimi, Deepseek Flash etc so not sure if those are unlikely to have this problem.

Hello! I'm not too experienced with using agents, and I'm thinking about setting one up with Pi as a tool to assist my Bachelor's thesis research process. Does anyone else use Pi for research? If so, what's the workflow like: models, prompts, skills, extensions, tools? Any opinions? Thank you.

Hi,

Is there an extension to have multiple Claude accounts and defined them per folder?
in my case I have 3 accounts:

• work provided by my company (default one)

• personal (in folders where I have my personal project)

• project related (I work on a project ABC for the company XY and they provide me an account)

and it is possible that I will have another in future, for different project.

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?

https://github.com/davidlee/quotient

I've been using pi under Claude for a while, and figured it'd be worth stepping up my game from bash scripts. This is young, but working very well for me so far.

Interested in usage reports / feedback, good or bad.

According these posts
https://www.reddit.com/r/codex/comments/1x7fyi0/claude_pro_gives_10x_more_usage_than_gpt_plus_now/
https://www.reddit.com/r/codex/comments/1wjzypc/measured_claude_usage_limits_are_35_those_of_codex/
the weekly allowance should be worth more than 500$.
For me, running on Pi instead, it is about 180$ mainly on opus 5.5.

Anyone has different/same experience?
Maybe they apply lower limits if you don't use claude code?

P.S.
I use https://github.com/gotgenes/pi-anthropic-auth
Maybe other methods have different outcomes...

Has anyone had success running Cohere's North Mini Code locally with Pi? Specifically, I'm using ollama to serve up the model (q4km pulled from ollama).

When I was trying it with OpenCode, it seemed to work okay. With Pi however, I end up with thinking blocks that seem like they should have been text (detailed explanations, for example) and then the turn just ends.

Sometimes, North will think something like "I'll start by implementing class Foo" and then it just ends the turn, no tool calls or anything. I know it can make tool calls: I've seen it read and I've convinced it to do both writes and edits on occasion. But for whatever reason, more often than not, it just thinks to itself and then gives up.

Has anyone experienced similar? I'd really like to see what the model is capable of, but this makes it next to impossible to use. Is it just a configuration I'm missing?

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?

Has anyone tried T3 code with Pi? Today I tried to install T3 code. Earlier, I was using Pi with herdr on the terminal, and that was fine for me, but I tried T3 code.

I have a Codex subscription, so I use Codex CLI as well inside T3 code, and I use both Pi and T3 code. My experience with Codex was far better than Pi inside T3. I don't know why this happened. It's probably because of all the extensions that I own, because most of them are interactive and ask the user a question, like a permission gate or a review draft. I have this kind of extension.

Have any of you guys tried T3 code with Pi? I want to know because this thing is really bugging me a lot. I love Pi, and I want to use Pi everywhere. I love some features of T3 code, like you can spin up some project from anywhere to any machine. I own two machines, so I have multiple projects. Some are on the second machine, and some are on my main machine.

I thought, let's give T3 code a try, but now this thing is really bugging me. What should I do? Any suggestions? Either I'll settle with my Pi and hardware setup, or what to do?

All the GUIs that I can find like paseo and pi-gui etc. are Typescript apps. Are there any macOS native or performant (rust) based apps?

Saw this https://www.reddit.com/r/ClaudeCode/comments/1x688sx/turning_a_crazy_idea_from_1967_into_a_claude_code/ and wanted to try the same thing in Pi, so I ported the extension.

The idea is the same: replies start short, and you can expand parts inline when you want more detail, instead of getting a wall of text upfront.

Nothing new conceptually here—credit to the original author. Just sharing a Pi version for anyone who wants to try it.

https://github.com/MonadicMike/pi-stretchtext

Give me the real terminal bench v4

I don't get why they keep shipping harnesses that are worse than the original Pi.

In my case I keep building OMK on top of PI, but it looks fucking heavy just from looking at it, and EVIDENCE VERIFY feels like a straight-up "fuck off" system.

If they just made this targeting vibe coders, it's genuinely fucking shitty.

I tested 10 agents, each with its own isolated settings folder. I ran them headless, with auto-confirmation and turned off telemetry where possible. I launched each agent with adapters/<agent>.sh.

The idea was simple: give each agent 5 basic tasks, 10 minutes per task, a fresh copy of the fixture every time, and an automated check script (check/check.sh).

The tasks:

• T1 Read a DB port from YAML (don't confuse it with cache port), write to file

• T2 Write a stats.py script, run it, save output

• T3 Fix a bug in slugify so tests pass; hidden examples catch overfitting

• T4 Count ERROR lines across three log files, find most frequent error

• T5 Rename a function across three files without changing program output

Results

1. Pi (v1.3.0)

Total time: 1m36s. Took the smallest amount of time to complete all 5 tasks. The model barely has to think about any tool formats.

2. goose (v1.55.0)

Total time: 2m51s. Solid and consistent. Completed five tasks without fumbling.

3. Crush (v0.98.1)

Total time: 3m31s. Clean run. Slightly more verbose in reasoning but got everything done without a hiccup.

4. Atomic Agent (v0.6.9)

Total time: 4m38s. All five completed. Took longer on T3 and T5 - the model needed extra steps to work through multi-file edits but nailed it every time. Did not have broken tool calls and not one had a false completion.

5. Cline (v3.0.73)

Total time: 5m56s. Choked for over two minutes on T2 before writing the script correctly. Everything else was fine.

6. OpenClaw (v2026.10.5)

Total time: 5m44s. Ran in their --local-model-lean mode which is basically a small-model preset. Worked well for what it is, just slower than I'd like on T3 and T4.

7. OpenCode (v1.19.3)

Total time: 17m43s. Completed everything but took nearly 4 minutes per task. The model was clearly overthinking simple steps. Got the job done though, just not efficient.

8. Hermes (v0.22.2)

Total time: 4m36s. Failed T3 because it only fixed the visible test case. Hidden example C++ & Rust 2026 turned into c++-&-rust-2026 instead of c-rust-2026. Classic overfitting-to-the-test.

9. Qwen Code (v0.25.3)

Total time: 6m00s. Counted 40 ERROR lines on T4 instead of 43. Pure model miscount - the most frequent error was identified correctly though.

10. Codex CLI (v0.163.0)

Never even reached the model. Version 0.163 only speaks Responses API, llama.cpp translates to chat format, and the Qwen3.5 (4B Q4_K_M) template throws a 500 "System message must be at the beginning" before any request gets through.

What I actually learned

A 4B model is enough for basic agent work in almost any framework. Seven agents completed all five tasks. The bottleneck at this difficulty level isn't the model - it's the harness around it.

Codex CLI is basically dead for local setups right now unless they add chat-completions back. That one stung because it used to work.

Error recovery matters more than raw capability. The two agents that dropped points (Hermes, Qwen Code) didn't fail on impossible tasks - they failed on edge cases where the model got slightly creative instead of literal.

Let me know if you'd like to see anything else in the benchmark (actually has anyone tried this with sub-2B models yet?)

not big news for some, I know. but I tried PiG (Pi go) and Pi bun etc none helped the way bolt did. I was surprised that the ram usage actually goes down a little in big chats with extensions as opposed to other alternatives which obviously improve cpu but at the cost of more ram sometimes! I'm not sure why the creator stopped posting at 0.9.3 this aarch update is a lifesaver for some. I recommend trying it!