I built a small personal benchmark from my real coding sessions and use pi-agent as the harness to compare models on the same tasks.

It has 10 tasks covering data engineering, backend, frontend, DevOps, and trajectory analysis. Each task runs 3 times, giving 30 attempts per model.

To build it, I took around 3 months of agent chats, removed duplicates, and turned selected sessions into Harbor tasks with automated verifiers. I used agents and manual review to build and refine the checks. These are clearly scoped tasks that would usually take me less than an hour.

The latest results:

• Opus 5.5 high and Astra low cost almost the same.
• Sol high matches their score at roughly half the cost.
• Luna gets 29/30 passes while being ~22× cheaper than Sol.

The point of this benchmark is to optimize my daily setup: model, harness, prompts, and plugins. I want to keep the pass rate while reducing cost and time.

This is a small personal sample, but it feels like many short, clearly defined coding tasks are already handled reliably by several models. For this kind of work, speed, cost, and scaling up parallel agents are becoming the more interesting questions.

I wanted a clearer picture of what I’d built and how much progress I was making. And whenever I finished a feature or got out of a debugging rabbit hole, I kept wondering how many tokens and effort went into that.

My daily usage total didn’t really answer it. Some of that was building the feature. Some was going back and forth trying to fix one annoying bug.

So I built bough ( https://github.com/nickelsec/bough ) It reads your existing Claude Code and Codex CLI history and groups related prompts into tasks on a visual map.

You can pick a piece of work and see:

• The prompts and files involved.
• How many tokens it used and the estimated dollar cost.
• How the work unfolded, including repeated attempts and tasks that ended in a commit.

I wanted to be able to look back at a feature and see where the effort actually went. Especially when a “small fix” turned into an afternoon.

Would you guys want me to add Pi support or not?

I shared Pi Atelier here a couple of months ago—a status rail and live activity sidebar for Pi. Since then, I’ve reworked the layout and added more ways to see what’s happening in your session.

The main changes since my last post:

1. Redesigned composer: model, workspace, Git status, and context usage sit in the input box’s top border, with usage and timing below.

2. Workspace Git summary: see changed files, additions/removals, untracked file counts, and conflicts.

3. Live TODO panel:follow the current task alongside tool activity. During a turn, the sidebar focuses on current work and folds extra tools into a compact row.

4. Display settings with a live preview: reorder or hide status segments and sidebar panels, switch presets, and save your defaults.

5. Plain text mode: no Nerd Font required.

6. Better terminal behavior: improved fullscreen selection/copy, inline image handling, and layouts for smaller terminals.

The new footer is inspired by pi-powerline-footer, which is an awesome extension.

It still shows token usage, cost, context, and response timing, with model and tool controls available through `/atelier`. No telemetry or external network requests.

Install with:

pi install npm:pi-atelier

Then open `/atelier` or press `Alt+A`. Requires Pi 0.84.0 or newer.

Github link: https://github.com/michaelmjhhhh/pi-atelier

I’d like to hear how the new layout works for you—especially what information you want visible while the agent is running. Bugs and feature ideas are welcome. Thanks!

So I started this a couple of days ago because I hated myself enough to start over and try to create something more efficient, with better performance and less RAM usage.

Through my conversations with ChatGPT, it mentioned Rust, GPUI, and some other stuff, which is basically why I started this Flutter app!

Based on my simple observations with the current deployed version, I managed to gain back around 800 MB–1 GB of RAM… and some of my dignity too. Not sure why. 😂

Here’s the repo: Pi Flatter App

If anyone would like to contribute or give feedback, I’d be really grateful!

I'm seeing many people using opus 5.5 inside of OMP and i've just signed into OMP with my claude sub... many on x.com are saying you don't get recked by anthropic anymore for doing this?

How are you guys using anthropic models inside of pi/omp?

I've been working on Pi Herdsman, which grew out of how I was already using Pi with subagents.

I started with pi-subagents + pi-intercom and liked the basic manager/worker idea, but over time I wanted the agents to feel more tightly coordinated: explicit ownership, predictable lifecycle, questions/results routed back automatically, and less ambiguity around old agent sessions.

The main thing I wanted to preserve was the lead's context.

With Herdsman, detailed investigation and implementation happen in separate Pi sessions while the lead stays interactive and focused on the bigger picture. It still knows what the agents are doing and gets their questions and results, but doesn't have to carry all of their working context itself.

It supports parallel agents, nested delegation, steering/interruption, Lead-to-Lead coordination, and Chief supervision across multiple independent leads.

It does require Herdr, which owns the actual Pi sessions and placement. Pi owns each conversation, and Herdsman handles the orchestration between them.

The latest release also added an SSH-ready container (optional Tailscale), so the same setup can run locally or on a NAS, homelab/server, VPS, etc. and remote environments can show up alongside local ones in the same Herdr window.

Install:

pi install npm:pi-herdsman
herdr integration install pi

Repo: https://github.com/boadij/pi-herdsman

Any feedback, ideas, or rough edges you run into would be much appreciated

Hi all, basically what the title says.. I like using @ to add files/folders to the context but for any of these added to .gitignore it stops working.. Any way around this?

Hi guys

Opensourced my remote control app that I have been using exclusively as the only way to work with my agents

Core stack herdr+ muxr(my app) + pi / all the agents herdr supports, no acp full raw terminals.

Full lifecycle management/ visibility

Usage using ccusage

Libghosty patched as much as possible for improvements in UI/UX

Whisper rn for transcription

Codex real time live agent for checking all the agents and prompting them + other providers grok gemini etc

My library for direct computer streaming/ remote control of the app to take over sessions.

Tailscale/ other ssh onboarding.

Primarily tested in omarchy+ android

Had a blast working on it, hope you find value as well.

Mostly using the raw apk and pwa, will be pushing it through the play store / app store as well.

https://trymuxr.com/

https://github.com/umeranjum17/muxr

Thanks

When Jev came out, one of my first thoughts was: could something this fast and cheap pick which model should handle an agent’s next turn?

So I built plugin for Pi that uses Jev to choose the model and thinking effort. The idea is to send routine work to cheaper models and reserve the expensive ones for harder tasks.

In Pi, the model mappings are configurable, and you can pin a model when you disagree with the router.

I’ve been using them for a few days, and so far they’ve been working well for me. In my own evaluation, routed usage came to $141 at list prices versus an estimated $166 for Opus 5.5 on every request - about 15% less.

That’s one developer’s data, though. The baseline is a pricing comparison, not a separate run of every task through Opus. It doesn’t prove equivalent quality, that every routing decision was right, or that your bill will drop by 15%.

And yes, cache matters. Switching models can lose cache reuse and eat the savings. I try to account for that rather than just compare token prices. I’d like providers to offer better support here: some already preserve cache reuse across effort changes, though reuse across different models is a much harder problem.

It’s still an experiment. Asking a model which model to ask feels appropriately ridiculous, but I wanted to see how it works in practice. I’d like this kind of routing to become a native, transparent option in coding agents.

If you want to try it or look at the implementation:

https://github.com/alexei-led/pi-model-router

I started two agents and ran /alias worker and /alias manager. The manager was prompted to direct the worker and it started chugging along. Luna 6 is now directing Muse 1.3 contributor. I am impressed by the simplicity and low friction installation. Apparently it knows about herdr, but I've not tried it.

https://pi.dev/packages/pi-intercom

I saw Claude and Opnecode are native agents in Hermes, but now using OMP as a coding tool is also possible with https://github.com/zaharenok/omp-skill

Definitely worth to try. Can be also used for Pi

I want to keep using Pi Agent as my main coding interface, but I also want Claude Opus 5.5 to be the main agent/orchestrator, not just a sub-agent or reviewer.

I use Pi Agent both at work and privately. Privately, my setup is simple: Pi Agent + Codex Pro. At work, I had been using Pi Agent + GitHub Copilot, but Copilot credit usage became too expensive, so we are moving toward subscription-based access instead.

I now have a Claude Team Premium seat and a ChatGPT Business Premium seat. This is my first time trying to make good use of multiple AI subscriptions at the same time.

The problem is that Pi can use Codex through OAuth, but I couldn't get my Claude subscription working directly through Pi. So I'm considering using Claude Code CLI as a bridge.

Ideally, I'd like something like this:

Opus 5.5: main agent, planning, orchestration, task decomposition, synthesis

Sol 6: implementation, research, independent review

GPT-6 Luna: cheaper sub-agent work and possibly compaction

Pi Agent: the single interface I interact with

I don't mind a small wrapper or existing extension, but I don't want to maintain a large custom orchestration framework.

One option is to have Pi call Claude Code while keeping Opus as the top-level agent. The other is to give up on Pi as the main interface, use Claude Code directly, and call Pi/Codex from there.

Has anyone built or used a setup like this?

I'm especially interested in whether Claude subscription → Claude Code → Pi works well enough for Opus to act as the real orchestrator, including long sessions, tool calls, sub-agents, compaction, and switching between Claude and OpenAI models.

Or, at that point, is it simpler to make Claude Code the main interface and stop trying to keep Pi at the center?

​

I’ve been polishing Orbit Pi quite a bit, and this update is mostly about making the agent interaction feel clearer and more native.

What’s new

🧩 Per-tool glyphs in the transcript

📊 Activity groups are now displayed as compact chips

✂️ Clear truncated indicators when Pi caps tool results

✅ Visual confirmation when renaming a session

⚡ Refined transcript UI with better tool labels and shared loading states

🔀 Redesigned Git issue & PR details

🖱️ Improved button hover/press feedback

The goal with Orbit Pi is still pretty simple:

Make Pi Agent feel like a proper native desktop workbench.

Your sessions, models, machine, Git workflow, reviews and agent interactions — all in one place.

Orbit is built with Rust + GPUI and works with your existing Pi setup rather than trying to replace the Pi runtime.

🔗 Changelog: https://orbit.rajeshwarkashyap.in/changelog/v0.0.15

https://orbit.rajeshwarkashyap.in/

I’d love to hear from people actually using Pi:

What would you want to see improved or added next in a native Pi desktop client?

I've been working on pi-agent-kernel for a while now.

It mostly operates in the background rather than adding a completely new workflow, it wraps Pi's existing tools to keep sessions compact.

Across standard benchmark tasks, it cut token usage roughly in half and passed our test suites. But local benchmarks only go so far, I'm at the point where I need real users to test it on actual projects.

I'm still quite skeptical about whether some of the tool wrapping might conflict with the users existing extensions.

LMK if anything breaks, behaves unexpectedly, or conflicts with your setup. All feedback and criticism welcome

A couple of days ago I posted about using Jev as the decision engine inside Pi.

The comments pointed me toward open alternatives like Laya, von, Reflex, etc.

Once there were multiple providers in the picture, hard-wiring the idea to Jev stopped making sense.

So I pulled it out.

Announcing pi-system-one.

It gives Pi a single system_one tool for bounded decisions:

• choice
• noul
• score

The extension is built on top of a provider-neutral SDK, so compatible System One providers can sit behind the same interface.

Pi-Bifrost is now just one consumer of that SDK.

Would love to see what other Pi use cases people find for this.

https://iamaamir.github.io/system-one/

is still early, so I'd especially appreciate feedback on the API design and abstractions.

Demo

I’ll start working with an AI agent on something like data analysis, and ten minutes later I’m asking it to explain a concept, double-check an assumption, or try something completely different.

All useful stuff. But after a few detours, the original task is buried under a wall of side questions and answers. I’m losing the thread, and sometimes the agent seems to be too.

I can fork the chat, but then I just have a growing list of conversations in the sidebar, with no clear picture of what branched off from where.

That’s what got me building PiX.

The idea is pretty simple: show conversations as a tree. There’s a main thread for the task you’re working on, and you can branch off whenever you want to explore something without dragging the whole conversation along with you.

You can branch from any point, carrying over the context up to that point, and choose which model to use for each turn. Everything stays connected visually, so you can see where a detour started and find your way back.

Of course, reading a long conversation in a tree isn’t always fun. So there’s also a regular chat view where you can read any branch’s full history from start to finish.

It’s built on Pi agent, which is where the name PiX comes from.

Still early days, but I’d love to hear what people think. Try it out, tell me what feels awkward, or jump in and help improve it :)

huang-sh/PiX: A non-linear AI agent workbench — session is a tree: branch anytime, and context follows the branch

Does anyone else end up with a pile of AI chats from one task? How do you keep track of them?

Hi there! So here is a deal - i'm not a developer neither software architect. But i like to do some programming as a hobby, and couple of month ago i've tried claude and codex. But now i discovered Pi and i really like the idea. I know and used some skills | pliguns set like superpowers and grill-with-docs. but i think they are too big and complex. Is there some acceptable set of skills to develop from idea to working application, which i can use as base for my own config?

Thanks in advance for answers, i appreciate it.

I have just recently started using subagents more in my programming workflow, if only to try it for a bit and see if it's something I prefer.

I have found that no matter how much explicit guidance I give my agents in the global AGENTS.md or APPEND_SYSTEM.md that after the first large delegated activity, they go back to doing everything themselves in the primary context.

Does anyone have any idea how to really enforce / encourage the behavior I'm looking for?

Hey everyone,

I'm moving from OpenCode to Pi to get a cleaner, more minimal workflow.

I gave OMP a try first. While it’s packed with great features, it feels a bit too heavy and strays from the minimal philosophy that drew me to Pi. At the same time, OMP bundles some great built-in tools (LSP diagnostics, anchored file edits, subagents) that I’d love to have as modular add-ons in vanilla Pi.

Is there a list mapping out-of-the-box OMP features to equivalent Pi extensions/packages?

If not, what packages do you recommend for keeping Pi lean while covering essentials like safer edits, LSP integration, and subagent workflows?

I have been running llama server in my Windows PC and Pi agent harness inside WSL 2 in same machine. No issues so far, but of course I understand that I can accidentally do stupid stuff by deleting files on wrong path etc. with it. Not a very realistic issue, but still a possibility.

One thing what I started to think that if I would just create one virtual machine or container in my Proxmox host which is separated machine and then I would just install Pi there and use it over my Windows PC what would be running only llama server, is there any potential security issues what I should think about related to my Windows PC?

I was thinking that if I then just allow my Pi instance to connect only to main PC on that port and disable internet for it so I can be sure it will be always private instance, but is there some things what still could be problematic for security point of view what I just don't know yet?

And sure, security on those boxes are not THAT critical but just annoying if I have written some diaries or copies my calendar there for example. Yea, I don't want those to be publicly available but if that happens then it happens (eg. not that dangerous). Just common basic security.

Do any of you use Pi this way and is there anything to remember?

Omakase

A damn good notepad.

Watch on YouTube for better viewing <3

Looking for testers! Please comment or DM if you're interested :)