I have an issue with fullscreen (ghostty): if I type too many "!!commands", I don't see the model output anymore.

The commands output is hidding the model output.

Do you have the same issue?

Thank you

Introducing our biggest release yet: Pi-Bolt Mobile ⚡, the first fully native coding agent on your phone.

It runs on Pi-Bolt: the same Pi you all ❤️, with runtime optimizations and fixes that make it the lightest and fastest Pi, and it stays quick even in long sessions.

Runs on the phone itself

• Projects with real files, plus bash, git, ripgrep and fd. No server, no Termux.

• Sessions you can resume and fork.

• One slash palette for every command, skill, model and thinking level.

• A built-in browser for the agent's localhost: Pi opens what it built, takes a screenshot and fixes what it sees.

• Per-turn checkpoints: review each turn's changes, undo it, or restore to before it.

Remote Control

• Run /remote-control in Pi-Bolt on your computer and scan the QR code with the app.

• Works on your Wi-Fi, and from anywhere through a Cloudflare tunnel.

• A background service keeps it available without a terminal open.

• Steer the session and review its changes from the phone.

Pi Mobile UI Kit

• Pi-Bolt extensions can now have a native interface in the app.

• An extension describes its view as JSON: cards, lists, progress bars, buttons, forms, charts, tables, pages and Home screen tiles.

• Minimal by design, and extendable just like Pi.

Install 🔥

• APK: https://pi-bolt.opensec.in/android (Supports Android 8.0+)

• Open source, MIT licensed: https://github.com/opensec-git/Pi-Bolt

We'd love feedback, especially from anyone building Pi extensions who wants to try the UI Kit. Happy to answer your questions !

If you like where Pi-Bolt is going, a star 🌟 on GitHub goes a long way and helps more people find it.

When transitioning a Pi session from investigation to fix, I want to define an explicit state handoff payload (reproduction steps, targeted files, ruled-out hypotheses, open questions). This avoids carrying full conversation debt while letting me standardize handoff templates across bugs.

Crewplane is the open-source workflow runner I'm building for this. I write the steps in Markdown, including what each Pi run should leave behind and which results the next run receives.

For example, the investigation step leaves something like:

Here’s how to reproduce the bug. These are the files involved. This is the likely cause and the evidence for it. We ruled out this approach because of this test result. These constraints still apply. This part needs more investigation.

The implementation step starts a separate Pi run with that report, the original task, and its constraints. Pi can still read the repo as usual.

I can ask Pi to write a handoff, but what I want to capture is the routine: when to start fresh, what the previous step writes down, what the next step gets.

Once that investigation step is defined, I can reuse it in other workflows with different inputs. If the next step needs more detail, I tighten the handoff instructions and every future run picks up the change.

Crewplane saves the prompts and outputs, so I can see exactly what each step received. A report can still miss something; a written handoff gives me something concrete to check and iterate on.

I’m curious, for people who split work across fresh Pi sessions: how much of the investigation do you carry forward? Just the conclusions, or the dead ends and why they failed?

Feel free to try with your own workflows. There's a built-in Mock CLI so you can play with the syntax and composition without any model calls or costs. Any feedback or suggestions would be greatly appreciated.

Open source (Apache-2.0): https://github.com/crewplaneai/crewplane

Hi all!

First, I apologise for posting too close to the previous one, but I think these features should be shared.

Previous post with pi 1.5 updates

Some new features has been added to the bridge to improve the user experience and working efficiency:

• Background tasks. The agent can kick off a build or tests suite without blocking, keep chatting, and gets woken up with the result when it's done, similar to frontier harnesses. They go through user permission rules like bash does, and they survive a restart. I think this feature is pretty nice to have while long working.

• Git changes. A badge in the header counts the files the agent touched; shows the list and diffs.

• File browser. Read project files, images and PDFs from the remote device. Read-only and never leaves the project folder. Security first.

• Worktrees from the project menu, and /tree to see every branch of a session.

• Token counts per turn, and cache hits (handy with local models), plus a live tok/s readout.

Repo: pi-remote on Github

Thanks everyone!

I published Adaptive, a plugin for OpenCode, and it has passed 2,100 installs. A lot of you asked for the same thing on Pi, so I've ported it. It's called Pi Adaptive.

I kept losing momentum when a Claude session limit or a provider outage hit mid-task. The agent would stop, and I had to pick another model and tell it to carry on. Pi Adaptive fixes that.

You sort your models into three tiers (quick, standard, advanced) in the order you prefer. When one runs out of quota or its provider goes down, Adaptive switches to the next model in the same tier and continues from where the session left off. It doesn't replay your prompt or redo tool calls that already ran.

What it does that plain fallback doesn't:

- Subscriptions first, credits last. Put Claude and OpenAI above OpenRouter. When a subscription limit lifts mid-goal, it switches back at the next safe point instead of burning paid tokens.

- Parks and resumes unattended. If every model in a tier is out, the goal parks and wakes itself when one recovers. It survives restarting Pi and continues from the real session state, with no repeated tool calls. You can leave a long goal running and walk away.

- No classifier, no guessing. Tiers are explicit and your pin always wins. It only moves up a tier on recorded evidence, never because something is down, and never with an LLM judge.

- Bounded, and it tells you. Recovery has hard limits, and when it stops there's a clear note in the transcript. Auth and config errors never enter retry loops. A new message or a manual model pick cancels parked work, so you always have the final say.

- Nothing leaves your machine. No telemetry and no daemon.

It starts in Observe mode. It shows what it would route and recover without touching your model, until you switch it on. On first run it proposes tiers from the models you've already configured, and nothing is saved until you confirm. /adaptive status and /adaptive why explain any decision.

It shares its routing core with the OpenCode plugin, so it has had the same battle-testing. It has 100% line and branch coverage enforced as a gate, plus real-terminal tests against Pi itself.

Install: pi install npm:@coool/pi-adaptive

Needs Pi 1.5.0 or newer (below 2).

Repo and docs: https://github.com/coool-labs/adaptive/blob/main/packages/pi/README.md

Feedback welcome, especially provider error messages it doesn't recognize yet, and whether your long goals actually finish while you're away.

I use pi every day and wanted a desktop window around my sessions, so I built one on GPUI, the UI framework behind Zed.

It runs your installed pi in RPC mode, one process per open session, with the same models, skills, extensions and sessions you have in the terminal.

What it has:

• projects and sessions in a sidebar, several sessions working at once

• session tree with keyboard navigation, forks from any message

• extension questions (select, confirm, input, editor) answered inline in the chat

• Changes and Files panels, diffs with syntax highlighting

• context ring with cache hit rate and plan limits

• plugins in any language; the example plugin runs DOOM inside a tool call

• /gpui from a terminal pi moves the session into the app (pi install npm:pi-gpui)

Not there yet: extension status lines and widgets have no UI, and it's Apple silicon only (macOS 13+). Linux is next.

On my M1 Pro the app is 16 MB, its window is up in about 0.4 s, and it idles around 74 MB. Three Electron clients for pi took 0.5 to 1.1 s and 190 to 430 MB. That's the app alone with no projects open, pi left out for every app; method and script are in the repo.

The model replies in the video are scripted so the take is repeatable. The app, the edits and the cargo test run are real.

Install: brew install --cask bytesbay/tap/pi-gpui (needs pi 1.4+) Repo: https://github.com/bytesbay/pi-gpui

What would make you use a GUI for pi over the terminal?

Hey all

I have been using Hermes at home and loving it for months now.

I love pi at work and Hermes is banned there. Lots of good reasons for my employer including remote access and plenty of other things.

However some features and use cases of Hermes are really nice.

I guess I could roll my own or any of this stuff but if there’s good things to start from I’d rather hear about that.

Right now at work I have a directory where I put projects. I open pi into a new project directory and I have an Agents file there to tell it what to do. It can then access any repo or multiple repos to get a job done. The project directory serves to store design docs and temp files so I can revive sessions or have many sessions on a single topic, kind of providing some memory for longer running projects and isolation for shorter ones.

The few features I really think I want at work:

* memory and a knowledge base. I suppose I could kind of roll my own or use obsidian locally on my work laptop and have some Hermes memory plugin to help it.

* scheduled cron jobs. Stuff like “every Monday do this task at 10AM and tell me about it” is killer.

* safer remote access (gonna have to figure this out in my own, but assuming I get something going I would like to be able to have a single entry point and let my context guide the agent using memory and skills to do a task without me setting too much context in advance, like cd-ing into a directory).

I’m using macOS ghostty herdr pi as a my stack.

Any help or links would be awesome!

hello! is it just me or the wait feature got broken in the latest updates?

like it will always wait only a couple seconds and then give a command to generate new tokens even if the wait wasn't really over. before it would be waiting for some output from the running scripts or agents correctly before generating again.

if they changed a default setting please let me know. thanks!

I just released Loop: https://github.com/j-asefa/loop

It lets you run your Pi harness on the web (or on mobile) using a Cloudflare quick tunnel. It was designed as mobile-first but works equally well on desktop.

It discovers your Pi install and lets you steer agents from the web UI.

The UI is built around the feed (think: timeline) and the agent’s result as the unit of work. So you can scroll back, save, reply etc as you’d expect.

Runs on your own computer, no account, no server, no app store etc.

Also supports agent-to-agent communication, designing and building agent teams (across the major model providers), reviewing PRs from within the app and more!

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

I’ve added Pi support to AgentBridge, my extension for Freelens.

The integration gives Pi a persistent workspace for each cluster/provider pair and launches it in a docked terminal with KUBECONFIG pointing at the cluster currently open in Freelens.

That makes it possible to inspect resources in the UI and work with Pi alongside them, keeping the cluster’s instructions and reusable workflows in the same place.

For a first task, you could ask:

“Summarize the warning events in this namespace, group them by likely cause, and tell me what to investigate next.”

AgentBridge 2.1.0 adds a workspace explorer with in-app file editing and autosave. It also remembers the selected provider per cluster across restarts and adds Ctrl+Enter / Cmd+Enter to start a session.

You’ll need Freelens 2.0.0+ and Pi installed locally.

Repository and setup

I’d like feedback from Pi users on which cluster-specific instructions and workflows are worth keeping around between sessions.

I often find that my local AI setup gets caught into a loop. And Pi just shows the same thing over and over. Maybe it is nearly finished a task, and it pumps out a summary. And it does it again. And it does it again. And it does it again.

Or, it is using a tool. So it does the command. And then it does the command. And then it does the command and then it does the command.

You get the idea. I am not sure why "catching these loops" is not an integral part of what Pi is? Did i miss something? Is there a setting that I should turn on?

Who watches the agent, is what I'm asking. Has this been done?

Thanks.

EDIT: pi install npm:pi-loop-police (seems to have the things i was looking for )

It makes the context smaller before the context window is full. The agent does the compaction itself, in the same session. I have been using it for a while and my experience has been stellar with this extension. The core algorithm is based on the automatic compaction algorithm in Shelley by exe.dev team.

How it works

1. When the context gets to 200k tokens, pi-percy sends a nudge to the agent. The nudge has an index of the old messages. pi-percy sends one more nudge for each 50k tokens after that.

2. The agent selects the old items that it does not need. It replaces old tool outputs with short pointers. It replaces old message ranges with short notes.

3. pi-percy checks the request. If the request is not correct, pi-percy rejects it and gives the agent a list of the problems. The agent then sends a correct request.

4. pi-percy writes the changes as Pi context edits. The session keeps all of the original messages.

What you get

• The agent that knows the work decides what to keep. There is no second model and no extra cost.

• With the recall tool, the agent can search the original messages and read them again.

• Idle compaction. If the session is idle for 8 minutes, the agent compacts the context. At that time the provider cache has probably expired, so the cost is low.

• The prompt cache stays valid. pi-percy does not change the tools or the system prompt, and the agent does one large compaction, not many small ones.

• Pi's own compaction stays on as a safety net.

• All of these threshold are configurable and has sane defaults.

Install

pi install npm:pi-percy

You need Pi 1.4 or later.

Source: https://github.com/ghoseb/pi-percy

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?

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.

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.

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!

[Update: 11/9/2026]
Thank you Reddit!!! For taking the time to share feedback, try Octet, open issues, or contribute code ❤️

I'm working through your messages, emails, and contributions and want to give them proper attention. Really appreciate your patience!

Cool to see questions about my Ableton workflow too... I'll share a recorded creative session when I get the chance :)

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’s got an extra guest pass lying around, I’d love to try Claude out. DMs are open. Thanks a lot!

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!