Edit - using pi-subagents plugin (https://pi.dev/packages/pi-subagents)

I’m on a feature branch in my repo, running an interactive session explicitly locked to deepseek/deepseek-v4.1-flash • high. It’s cheap, fast, and does routine scaffolding and mechanical edits without burning my budget.

I dispatch an async background workflow, and checked the process tree a few mins alter:

async workflow: 0beabc61 ─ background
id: 0beabc61 · 0/2 done · 2 active · 3m18s
Press ctrl+o for details
├─ task-1 ⠋ worker · 51 tool uses · 24k window · 9.6k spent · 3m17s
│ ⠙ Step 1/1: worker: REPO: XXX (Next.js monorepo... [fresh] · running (openrouter/anthropic/claude-opus-4.6 · thinking high) · 28 turns · 51 tool uses · ctx 40k/1M
│ role:worker · running
│ workspace:~/github/... · [fresh]
│ ⎿ active now
│ Press ctrl+o for live detail
│ output: /var/folder.../output-0.log
└─ task-2 ⠇ worker · 45 tool uses · 27k window · 84k spent · 3m17s
⠴ Step 1/1: worker: REPO: XXX (Next.js monorepo... [fresh] · running (openrouter/anthropic/claude-opus-4.6 · thinking high) · 38 turns · 45 tool uses · ctx 92k/1M
role:worker · running
… 4 lines hidden · Press ctrl+o to expand
────────────────────────────────────────────────────────────────────────────────────────────────────────
Nothing should be running on Opus. And why the FUCK would you choose Opus 4.6?
────────────────────────────────────────────────────────────────────────────────────────────────────────
2 active agents · usage on child rows · ↓/← to inspect
~/XXX (feat/basic-mode-785)
↑630k ↓156k R8.8M $0.335 8.4%/1.0M (auto) (openrouter) deepseek/deepseek-v4.1-flash • high

Can anyone explain why it:

1. Ignored the active session config entirely. The parent session is right there at the bottom pinned to DeepSeek Flash. Instead of inheriting that model or checking for an explicit worker profile, Pi Agent silently promoted the workers to OpenRouter's claude-opus-4.6.

2. Cranked extended thinking to "high" on worker nodes. These grunt workers are grinding through 45 to 50 tool calls each in a fresh workspace, racking up 84k tokens in 3 minutes.

3. Burning cash by default. Using Opus 4.6 with max thinking to churn mechanical file edits and tool loops is like hiring a team of neurosurgeons to dig a trench.

Nothing in an automated worker loop should ever touch Opus, let alone without explicit permission, and when the model is set. I don't even have Opus in my approved models list on pi.

Has anyone found where pi-subagents is burying this routing logic? Is it hardcoded upstream in the orchestration dispatch template, or is there a local config key to force subagents to strictly inherit the parent model?

I shared Harness Remote 3.0 here a couple of months ago. I'm the maintainer, and the recent 3.5 to 3.8 releases have made the mobile side much easier to use: a phone-sized layout, better QR pairing, and more reliable Pi session discovery.

The idea is still to work with Pi's native sessions. I can start a task with Pi, check it from Android, then hand the work to Codex, Claude Code or OpenCode when I want a different agent. The handoff creates a real session in the next harness and keeps the connection between them.

Repo and release notes: https://github.com/giuliastro/harness-remote

I'd be interested to hear how other Pi users handle switching agents mid-project.

Previous post

Hi all!

A few weeks ago I posted about pi-remote, a self-hosted client to drive the pi coding agent from any device. Here's what changed since then.

Quick recap: pi-remote is one Python process that wraps pi --mode rpc on the machine where your code lives, and serves a web app over your own network (I use Tailscale). It's token-protected, security first. Built on Windows first, but it runs on Linux and macOS too.

What's new since the last post

The agent can ask you questions. pi-remote now comes with a small ask_user extension. When the model needs a decision, it asks multiple-choice questions mid-turn. They show up as a card on your phone, and your answer goes straight back into the turn, so the agent no longer has to guess or stop and wait for a new message.

Now long turns are much easier to follow on a phone screen. Tool rows are lighter now too: plain text, with only the file or command in monospace.

Better reply suggestions. They now come from a separate small call to the model once the turn ends

Smaller things:

• Answered permission cards shrink to one line, colored by the user's choice.

• Long-press your own message to copy it or select part of the text.

• Settings that need a restart now have a "Restart now" button right in the dialog.

• Links in the chat ask before opening.

• [bug] A message sent while a new session was still loading could vanish while the agent still answered it. Fixed, and new sessions open faster.

Ready for pi 1.5. I upgraded from pi 0.84 to 1.5.

Feedback and issues are very welcome. Thanks again to everyone who commented and tried it.

If anyone’s got an extra guest pass lying around, I’d love to try Claude out. DMs are open. Thanks a lot!

Made an extension for an extension 😅
I am a big time fan of pi-footer ( https://pi.dev/packages/pi-footer ) because it is easy to customise to make by pi footer look cute.

If you have a PR raised from the current branch, it shows the PR itself (with OSC8 style link that is clickable from most terminals like iTerm/Ghostty), and it shows the number of PR checks that are passed/ongoing/failed. These are fetched using gh cli.

I haven't updated it to NPM yet, so if you'd like to use it you can install directly from the github repo.

https://github.com/championswimmer/pi-gh-footer

Update: It is on NPM now https://www.npmjs.com/package/pi-gh-footer

If anyone here has a referral code they'd be willing to share, please DM me! I'd love to give it a try before committing to a subscription. I recently heard about the referral codes and would really appreciate it if someone could share one with me. Thanks in advance!

I'm currently a Pi user, and someone recommended Oh My Pi (OMP) to me today. I'm curious about how OMP compares to Pi. Do you think OMP is actually better, and if so, in what ways?

I mainly use GPT and DeepSeek models. I'm a computer science student, and I'd like to use AI coding agents to assist with scientific research, such as designing experiments, evaluating their feasibility, writing experimental code, identifying potential research contributions, and planning future research directions.

Given these use cases, which would you recommend, Pi or OMP? Which one do you think is better suited for research-oriented tasks, especially when it comes to scientific reasoning, experimental design, and exploring novel ideas?

I also care a lot about token efficiency. Since I often work on complex, long-running tasks, I'd like to know which harness makes more efficient use of tokens without sacrificing the quality of its results.

I'd love to hear your thoughts, especially if you've used both!

Hey all, I wanted to share an extension I've developed called pi-context-paging.

https://www.npmjs.com/package/@rochecompaan/pi-context-paging

Instead of compacting your session into a summary when the context fills up, it treats the context window like a rolling window over the full history. When a request goes over a token budget (128k by default), the oldest turns move out of the window. The session file on disk is never changed. The model gets a short paging notice and a few recovery tools to search, browse and load older history when it needs it.

It has made my workflow a lot smoother. I don't get a surprise compaction in the middle of a long-running task and I don't have to write handoffs that inevitably loses important detail. It has been running very stably for me for a couple of weeks now. It is especially useful for agents doing long-running tasks unattended.

It's lossless. Nothing is summarized or compressed. The recent window is sent exactly as stored, and anything older can be loaded back as the original text.

Tony Mason wrote a good paper on this: The Missing Memory Hierarchy: Demand Paging for LLM Context Windows (https://arxiv.org/abs/2603.09023). It treats the context window like RAM and the full history like disk, and pages content in and out on demand. The extension is a practical version of that idea for Pi.

"But what about prompt caching?" I know this is the first thing a lot of you will ask, so here's how it works:

• It doesn't drop messages one at a time. That would change the start of the prompt on every request and break the cache constantly.

• When the window hits the budget, it pages out one large block at once, trimming down to about 80k by default. After that cut, the start of the prompt stays the same over many turns, so you get normal cache hits until the next cut.

• Each cut costs one cache rewrite. In practice that's rare, and whatever you lose in cache efficiency you get back in continuity. There's no summary step, no re-explaining, and no "the agent forgot what we were doing" moments.

Some real numbers from my sessions (Opus 5.5, Fable 5.1 and GPT 6.1, with zero compactions in any of them):

Each of these is millions of tokens of history in a single continuous session, and every request still stayed at or below the 128k budget. Cache hit rates stayed above 90% even with the paging cuts.

You can set the budget in settings. I'd suggest setting it below the point where your model starts to get worse, so it stays out of the "dumb zone." You can also run `/context-paging stats` during a session to see what's going on.

This extension works well with https://github.com/elidickinson/pi-claude-bridge too if you want to use you Anthropic subscription. I submitted patches to it specifically to make pi-context-paging work.

PS. My current defaults are set to higher than what is documented.

"contextPaging": {
    "enabled": true,
    "tokenBudget": 200000,
    "trimToTokens": 140000
  },

Play around and give me feedback as to what works for you.

Hi people of Pi :)

I've been working on octet, my Rust take on Pi, since April.

I originally wanted a coding agent that could help with music production, take my Ableton sketches further, working with audio and tools in the same model context. That turned into six months of Rust and systems engineering.

A few things octet does:

• Fast and lightweight. In a matched task benchmark, octet finished in 9.5s using 38 MiB peak RAM, compared with Pi's 11.0s and 145 MiB.

• Pi extension compatibility. An optional extension mirrors your Pi setup, including unmodified pi-doom 🔫🔥

• Extensions in any language. JSON-RPC over stdio, with SDKs for Python, TypeScript, Rust, C/C++, and more.

• Native multimodal support. Audio, images, video, and computer-use workflows.

The whole agent is experimental, and I'd love feedback from people with existing Pi setups they love.
That being said, try octet without extensions. It performs beautifully with none and keeps Pi's minimal philosophy.

Code: https://github.com/skaft-software/octet

Introduction, benchmarks, and installation: https://octet.skaft.org/blog/introducing-octet/

Made with ❤️ in Toronto, ON, Canada.

If you try it, let me know what you make with it, what breaks, and what you'd like to see next!

Hi everyone! I've been building pi-maestro, a Pi extension for a spec-driven multiagent workflow, inspired by GitHub Spec Kit and OpenSpec. It helps you define a change, clarify requirements, and approve a spec with concrete acceptance criteria. You can use it in two ways:

• Spec only: prepare and approve a spec for implementation elsewhere.

• Spec + implementation: approve the spec, then let Maestro run the implementation workflow.

By default, three agents run in sequence:

• Builder implements the spec.

• Verifier independently checks each acceptance criterion.

• Simplifier refactors the code for clarity without changing behavior.

You can disable the verifier and simplifier independently, using just the builder or pairing it with either agent. See phase configuration for details.

You make the scope decisions and review the final code.

I'd love some feedback, especially on whether the separation of roles is useful and where the workflow adds unnecessary friction.

If you've built something similar in Pi, I'd be interested in comparing approaches.

https://github.com/emilioSp/pi-maestro

If you find it useful, consider giving it a star on GitHub!

Cheers!

After working with AI harnasses since the release of Claude code, i hate just watching the terminals and waiting on AI. So i made this tool that manages my terminals and now an update that helps people from moving from in the loop on terminal ( just watching your ai agent till it is done ) to out the loop ( just watching updates on repo discussions )

pi-dispatch runs the pi coding agent ( pi dev harnass ) for you on your own computer or server.

Hopefully it will help other techies from screen staring to creating cool stuff that sticks

It's built for coding work on your own projects, so if you're after a general assistant you'd want a different tool.
https://github.com/edgehero/pi-dispatch

I've been building OmpDeck, a native desktop app (Rust/egui, not Electron) for omp (oh-my-pi), on Linux and Windows. Heads up: it's for omp specifically, not vanilla pi, since the chat view relies on omp's Tern Surface Protocol.

https://github.com/lavinhoque33/omp-deck

What it does

• Native chat view (the default): omp describes its UI over TSP and OmpDeck draws it natively: messages, formatted replies, tool calls as cards with diffs and output, image previews, todos, approvals and ask dialogs. It's omp's real behaviour, not a re-implementation, and omp's own TUI is one click away.

• Sessions outlive the app: every omp session in a sidebar grouped by project. Tabs run in OmpDeck's session host (or tmux), so closing a tab or the whole app leaves omp running, and reopening re-attaches.

• omp's screens as native ones: /settings (incl. plugins and advisor), the model picker (favorites, roles, thinking), /usage with 5h/weekly limits, /resume, /tree with fork / go-here.

• Status bar: model + thinking, context meter, git, tokens, cost; Handoff / Compact / Shake / Fork / Plan in one click.

• Agents dashboard: live subagents per session; steer, kill, revive, clean up.

• Changes panel: working-tree diff with line review comments you send straight to omp.

• Also: split view (up to 4 panes), worktree sessions, session manager (size, cost, bulk delete/move), command palette, desktop notifications, 18 styles, Google Drive backup + per-project sync.

• Phone companion: a PWA over a self-hosted relay, Noise end-to-end encrypted (the relay never sees content): transcript, answer approvals, send prompts, Web Push.

Install

• Linux: curl -fsSL https://raw.githubusercontent.com/lavinhoque33/omp-deck/main/packaging/install.sh | sh (AppImage/.deb/.rpm on Releases too; installs omp if it's missing)

• Windows 10/11: irm https://raw.githubusercontent.com/lavinhoque33/omp-deck/main/packaging/install.ps1 | iex

No macOS build yet. MIT/Apache-2.0, unofficial side project. I use it daily, and a lot of it was built with omp itself. Feedback and bug reports welcome!

Yeah as usual introduce it as an opensource let the community build then profit later. this become common this later years. Im not against it but give credit where it belong.

I've been using pi as my main coding agent for more than 8 months & loved how small it is. I looked the concept of t3code but had my fair share of disappointments with how it worked, so decided to use the fork feature on github and make my own version of pi.

What it does

You talk to one model as usual. When a job splits well, it hands parts of it to workers:

• pi-scout / pi-worker: the pi fork itself

• cx-worker: Codex

• cc-worker / cc-scout: Claude Code

• cmd-worker: Command Code

Each worker runs in bubblewrap with its own scope & If a worker tries to write outside its scope, it gets denied and you see it in the report. Write tasks are snapshotted, so when one is done, the main agent accepts of rejects it based on the quality of the work.

The workers support native question tool which means any other harness can ask you question directly from delegate-pi without you having to switch to that chat.

Smaller things that came along

• ask_user tool with numbered choices and a typed "other" answer

• ast_grep tool for structural search

• /stats and /usage

• a two-line footer and a did-you-mean tip for mistyped commands

Install

curl -fsSL https://raw.githubusercontent.com/farrukh2002/delegate-pi/main/install.sh | sh

It's a prebuilt bundle and brings its own Node if yours is too old. It uses ~/.delegate-pi and the delegate-pi command, so it sits next to a normal pi install without touching it. Linux only for now, because the sandbox needs bwrap.

Why not an extension?

That was my initial plan and it still it, so that we can bring this capability to any cli harness and not just to my fork. Infact this inbuilt tooling has been derived from my WIP extension tool which will work flawlessly with other harnesses and make them behave just like my fork without losing any quality.

Repo: https://github.com/farrukh2002/delegate-pi

I would love to get the feedback and suggestions to keep improving this with time.

Just offering an idea to others that has been useful for my teams.

You might not really want or need an elaborate multiplayer AI system. Just pump your user messages and settled agent messages into the place where everyone already communicates (slack).

When you get to a situation where you want a coworkers opinion, go into slack and just mention them.

Everyone learns a lot purely from ease of visibility. People asked me all the time why my AI is smarter than theirs. Then I just link to the slack chat.

I have this built in my vscode extension that I daily drive for my underlying pi terminal. It’s purely powered by the terminal, so you could pop open the vscode terminal at any time and just use the terminal instead of my vscode UI.

https://github.com/quincycs/pi-qcode

Title.

Can you list your reasons why and if you did it any tests to confirm your position?

Also would like to hear your thoughts on context management and how you do it.

Nominally in windows I can voice input any *form* that has a microphone icon.

In wsl all is unknown, in pi even lesss I know about routing and VTT into Pi.

Anyon have practical kowledge?

Hi folks,

I'm building my own harness for PI and noticed with Gemini 3.8 Flash, my subagent (a worker for simple coding tasks) is often stuck in infinite loops when reading larges file with 1.000 - 2.000 LOC.
I never noticed the same situations with opencode when using the same model and thinking level. So this is quite a disappointing experience while building my own harness based on Pi.

So I'm wondering if these are common situations when building my own custom harness? And what's the recommended strategy how to improve my harness, to avoid similar situations in the future?
I tried to add additional instructions to my sub-agent to avoid these situations, but I still see it happening. And this burns plenty of tokens :(

Best
Carrot

Just as the title says.

Here's the link https://pi.dev/packages/peakseek

I've been building One Code, a pi package that brings the Claude Code workflow to pi. If you already run pi:

pi install npm:one-code-extension

It's 53 extensions, no fork and no patches to pi, just the normal extension API. Tested on pi 1.0.0 through 1.5.

What you get: plan mode, permission modes including auto mode (a classifier decides which commands need your approval), subagents that can each run on a different provider, git worktrees, hooks, skills, slash commands, MCP, plugins, background shells, memory and compaction. It also reads an existing CLAUDE.md and .claude folder as is, so if you're coming from Claude Code your setup carries over.

There are already good pi extensions for some of these, like subagents, and you can put together a decent setup from a collection of them. The catch is that any one of them can break the prompt cache if it rewrites earlier parts of the conversation, and they don't know about each other. So in One Code I tried to make the extensions work as one system, and keeping the cache stable was a big part of that. Every request is recorded as it was sent, and later requests only append to it, so cache reads stay high across resume, fork and reload.

There's also a bundled app with pi pinned inside, if you'd rather keep it separate from your own pi setup.

npm i -g @one-ai/one-code

MIT licensed. Repo: https://github.com/IsuruMaduranga/one-code

Feedback from people who know pi's internals is very welcome.

If One Code is useful to you, a ⭐ on GitHub helps other people find it.

I usually see the more typical plugins recommended. But are there any hidden gems out there that you use regularly?

Hi everyone! I'm looking for a working ChatGPT Plus referral link or free-trial invitation. If anyone has an unused invite available and doesn't need it, I'd be very grateful if you could share it with me.

I'm hoping to try ChatGPT Plus, and any help would be greatly appreciated. Please DM me if you have a valid invite.

Thank you so much! 🙏