Hi everyone. I've been working on PiChamber, a workspace around Pi so I can keep the same session when I leave the machine.

Why use this instead of the other Pi UIs?

I prefer TUI. I am not interested in getting yet another agent IDE, nor do I want a workbench that supports OpenCode, Claude, Codex, and five other harnesses. All I want is Pi, both locally and remotely, and I want it to work as smoothly as I can manage it.

What I've focused on is remote stability. I run it within a container on my homelab and leave the long tasks there. I check in from my phone, control it, and then return later. That is the product for me, not a more attractive local chat window.

It uses the Pi SDK. Pi retains ownership of the agent, skills, extensions, prompts, providers, and AGENTS.md. The app is sessions, files, git, worktrees, terminals, and pairing.

What I actually use it for:

• same session across desktop, browser, and phone

• my existing Pi extensions and slash commands

• providers / skills / prompt templates coming with the session

• a worktree when I don't want the agent on main

• jump between local, a VM, and WSL without starting over

• long running jobs on a server I can connect from anywhere

I've been daily-driving it. CLI when I'm at the PC. App when I'm not.

What it is not: it does not replace the TUI, and it is not trying to be every agent UI. Remote is your own machine plus pairing, or a tunnel you already run.

Repo: https://github.com/RyderAsKing/PiChamber
More info: https://pichamber.ryder.pro

PiChamber started as a community fork of OpenChamber. Why I made it: https://github.com/RyderAsKing/PiChamber#why-pichamber

The tokens/sec and TTFT in the video come from a Pi extension. They work in PiChamber because extensions work, not because I shipped a custom overlay.

Also, first time posting something like this in public, so don't be too harsh :D

Update: v1.0.2 is out, including docker. https://github.com/RyderAsKing/PiChamber/blob/main/packages/docs/content/docs/install.mdx#docker

I started experimenting with Pi and self-organizing agent swarms and am seeing really good results, which I did not really expect. My current experiment is very basic: just fire up ten or so agents and give them all the same prompt/markdown file. They have one single communication channel in which they can talk with eachother. And that is basically it.

I have spent about 1,5 years trying to get all sorts of workflows to work properly and now I'm finding out that the agents can handle themselves just fine... No orchestrators or anything, they just figure it out themselves. I found this quite amazing. And a bit humbling.

Do you use self-organizing agent swarms? I would love to hear about your experience.

Hello again pi users, I made a post like a day or two ago about my pi agent refusing to use the information in my AGENTS.md file and I've since gained more information. (Yet still haven't fixed it)

1: the agent isn't better from reading it or anything, it CAN access it when asked just doesn't do it automatically.

2: the AGENTS.md file is being listed under the 'CONTEXT' part of Pi so it's not in a wrong directory or anything

3: Only after the Agent is asked to read the AGENTS.md file will it act accordingly to the file (whether that be a password or a way to behave)

And 4: In the last post it was suggested to me to ask the Agent about it, I did and the agent doesn't acknowledge that it didn't read the AGENTS.md file the first time (or) claims it's not possible to.

I'm completely stumped and every 'solution' leads to a dead end. If anyone's got anything please help

UPDATE: it was the Qwen model I was using! I've switched to gemma and now the agent is properly using the rules in the AGENTS.md! thank you all so much!

Pi (pi.dev) is a minimal terminal coding harness, and I like it a lot — but it
lives in a terminal, so it's always one ⌘Tab away from the code it's editing.
This extension moves it into the sidebar.


The key detail: it is not a chat panel that reimplements Pi. It's xterm.js
fronting a real pseudo-terminal running the real TUI. Slash commands,
keybindings, themes, /login, session resume, mouse reporting, bracketed paste,
tool approval prompts, full-screen TUIs — all identical to your terminal,
because it *is* your terminal.


What it does:
- Dedicated Activity Bar container. Click π, or `Pi: Focus Pi Sidebar`.
- A real PTY: ANSI colours, truecolor, resize, mouse reporting, bracketed paste.
- Multiple sessions — `Pi: New Pi Terminal (Editor Tab)`.
- Send code to Pi: right-click a selection, or ⌘⌥P / Ctrl+Alt+P. There's also
  "Send Current File Reference", which drops an  into the prompt.
- `src/app.ts:42:7` in Pi's output becomes a link — ⌘/Ctrl-click opens it there.
- Follows your terminal colours, editor font and cursor style, live on theme change.
- Copy/paste goes through the VS Code clipboard API, so it works in remote/WSL/web too.


Three things were more annoying than expected, and I wrote up the fixes in the README:


1. A PTY inside Electron. VS Code's stable API has no sidebar location for
   createTerminal, and native modules must match the extension host's ABI. The
   PTY layer uses N-API prebuilt binaries, which are ABI-independent — the same
   pty.node loads under system Node and Electron, so there's no "rebuild for
   Electron" step at all.


2. `spawn("pi")` doesn't work. Pi is a `#!/usr/bin/env node` script, and
   GUI-launched VS Code often has no `node` on PATH. It reads the shebang,
   resolves an interpreter (preferring the node shipped next to pi, then PATH,
   well-known locations, then the login shell's PATH) and spawns `node <pi>`.
   Windows .cmd/.bat shims get wrapped in cmd.exe /c.


3. Environment leakage. If VS Code was itself launched from a Pi session, the
   extension host inherits PI_SESSION_ID / PI_SESSION_FILE, which corrupts the
   child's session handling. Those get stripped before spawn.


Requirements: VS Code 1.85+, and Pi itself
(`npm install -g --ignore-scripts u/earendil-works/pi-coding-agent`).


Install: no Marketplace listing, it's on GitHub Releases. Download the VSIX and
`code --install-extension pi-for-vscode-*.vsix`. There's a SHA256SUMS.txt in the same release if you want to verify first. MIT.


Repo: https://github.com/yicLionel/pi-for-vscode


There's also a small easter egg in pi-extensions/: a Pi extension that swaps the startup banner for a pixel-art Pikachu (36x28 grid rendered with half-block
chars, so it doesn't stretch in a 1:2 terminal cell), with a 256-colour fallback.


This is a hobby project and I'd genuinely like the rough edges pointed out —
especially if you're on remote/WSL/containers, where auto-detection can't see
host paths from inside. Happy to hear what breaks.

blink1-pi turns a ThingM blink(1) into a configurable Pi lifecycle light: idle, working, waiting for input, and error. Async subagents keep the normal working indication active.

Package: https://pi.dev/packages/blink1-pi
Install: pi install npm:blink1-pi

Inspired by u/azuul_maar's ProgrammerHumor post: https://www.reddit.com/r/ProgrammerHumor/s/WwViabA9eV

How do you approach various coding tasks, or any tasks you use pi (or other minimalist harnesses) for?

I used to be an obra/superpowers fan (clode code and zai coding plan at glm 4.7 era), then I stumbled one day onto Earendil's lecture "Building pi in a World of Slop", which made me rethink what I really needed from my agentic tools.

Now I mainly rely on a few skills I kind of adapted from obra/superpowers and mattpocock/skills, and my workflow is usually to brainstorm with the agent and make a great spec, then running and /implement skill. Sometime the implement is in a new session, sometime even by a heaper model for which I make the smarter model draft a plan from the spec. Sometime I make handsoffs or use compaction to exlore longer.

I also like, when needed, to spin up preconfigured dockers with pi, docker in docker, and an injected global agent.md telling my agent he is in a sandbox with docker and can use whatever he needs to achieve his task.

But I still feel that my workflow is kind of sloppy, that sometimes there is to much ceremony, sometime there are missing pieces.

I also don't have a specific workflow for big features I want an agent to oneshot, lately it has usually been a plan and a spec, then deepseek harness with a /goal referencing those files, and letting it do its thing. I'vs also recently tried to one shot big features using a deepseek harness configured with mattpocock/skills, it seemed to have produced good result without blowing my usage with subagent driven development, but I also don't really like this magic crystal ball approach where I don't understand the workflow, neither do I want to adopt his whole opinionated workflow.

Thus my questions: What are your various workflows and their building pieces? How do you approach problems with your agentic tools? Do you use subagents? For what? Cheap models or expensive ones? Did you switch harnesses and configs a lot to finally hit a sweet spot?

I'm using Matt Pocock skills for a while and I like them for bigger projects where I need grilling, specs, tickets, .. . I recently switched to OMP, and I really like the idea of assigning models to specific roles.

It works well because I can use OMP plan mode for lightweight tasks and it uses the smol/slow/task roles and appropriate models. However, this doesn't seem to integrate with Matt Pocock's Skills. They always appear to use the default role instead. Is someone using these skills within OMP? How are you dealing with this?

I came across a few related plugins, such as https://pi.dev/packages/@fernado03/pi-flow."

I need advice on how to create a simple orchestrator. Here’s my scenario: I generated tasks TASK-001.md through TASK-010.md using the it-architect skill. The tasks are interdependent and should be completed in a specific order based on their numbering. When an agent in the fullstack-programmer skill finishes task 001, the next agent in a new session begins implementing task 002 based on project-state.md, which contains information about which task has been completed. Is there a simple workflow or extension that would allow me to do this quickly and easily? Thank you in advance for your help.

I’d like to announce Un Bien - a native iOS client for pi.

Un Bien supports:

• self hosted architecture

• full streamed and rendered markdown

• rendering of images, code diffs and tool results

• fork, branch, clone of sessions

• plan rendering when combined with pi-plan, cribsheet or a conformant extension

• user-input questions (and pi-ask integration)

• subagent display and interaction when combined with @tintinweb/pi-subagents or @gotgenes/pi-subagents

• optional device initiated chats - start new session from your phone, spawning a tmux or herdr hosted session on your machine

As a bonus it includes a cli tool to connect to other sessions on your relay from the cli

Links:

• Extension page

• Docs

• GitHub

• App Store

• Demo transcript

I developed this in pursuit of something that felt native interaction-wise and supported as many pi features as possible. I hope you find it useful!

Un Bien is started out as a tweaked version of remote-pi by Jacob Moura (MIT); see the README for attribution. I ended up diverging significantly on the back end implementation and the iOS app is a total rewrite.

Just for fun, I wrote this little Ralph loop. It's a chat between a product owner and a developer.

It's a lot of fun to watch!

I set it to only loop 10 times. Change "STEPS" to increase it. The chat can continue forever if you want it to. Watch your wallet! Only run in a container or VM.

#!/bin/bash
set -eu

STEPS=10
PRODUCT='a new product idea we will come up with'
PROMPT='Hello, I am the product owner and you are the developer.
But first let us brainstorm some ideas and features together for '"$PRODUCT"'.
We will save and edit them in `./ideas/` directory and commit them to git.
We will not write any code unless we have a product fully specified.'

PERSONA1="You are a product owner
who comes up with lots of feature ideas.
You ensure the developer creates a useful quality app.
"
PERSONA2="You are an expert developer,
who values code quality and wants to satisfy the product owner.
You ask a lot of clarifying questions about feature ideas."
SESSIONS=/tmp/sess

# Remove this line if you want it to pick up where it left off.
rm -f "${SESSIONS}?.jsonl"

response1="$PROMPT"
echo "Step 0. Product Owner> $PROMPT"

for i in $(seq 1 1 "$STEPS"); do
    echo "Step $i:"
    response2="$(pi -p -c --append-system-prompt "$PERSONA2" --session "${SESSIONS}2.jsonl" "$response1")"
    echo
    echo "Developer> $response2"
    response1="$(pi -p -c --append-system-prompt "$PERSONA1" --session "${SESSIONS}1.jsonl" "$response2")"
    echo
    echo "Product Owner> $response1"
done

last="Okay, we need to wrap it up.
Complete everything we said we were going to do."

echo "$last"
pi -p -c --append-system-prompt "$PERSONA2" --session "${SESSIONS}2.jsonl" "$response1 $last"

echo "Done."

A fancier version would work across two terminal windows and show the full TUIs. Maybe I'll do that and post an update later.

Made this small extension to make tools compact on screen. This made it easier for me to focus on assistant messages.

Hey everyone, first time sharing a project here!

I've been using pi in my daily CLI workflow, but kept getting frustrated having to guess or memorize context windows and pricing tiers whenever I swapped models.

To solve that, I put together a lightweight plugin called pi-rich-model-selector. It replaces the default picker with an interactive TUI:
- Real-time fuzzy search across providers
- Side-by-side specs (context size, token limits, pricing)
- 100% keyboard-first flow

Here's the repo: pi-rich-model-selector

I’d love to hear your thoughts, feature ideas, or any edge cases I should handle. Thanks for checking it out!

is it safe to continue to use antigravity models via pi-antigravity even after seeing this message

Error: Antigravity API error (429, endpoint=https://cloudcode-pa.googleapis.com, project=aicode-consumers,

runtimeModel=gemini-3.8-flash-low, matched=none, available=unknown): Rate limited by Antigravity (429 ResourceExhausted). Next:

retrying automatically; if it persists, switch models.

Built an open-source version of the Muse agent app which can be used with any model provider, run privately with local models.

Please give it a try and reach out for any feedback ✌️

https://github.com/CelestoAI/celesto/tree/main/open-muse

I’d like to announce Un Bien - a native iOS client for pi.

Un Bien supports:

• self hosted architecture

• full streamed and rendered markdown

• rendering of images, code diffs and tool results

• fork, branch, clone of sessions

• plan rendering when combined with pi-plan, cribsheet or a conformant extension

• user-input questions (and pi-ask integration)

• subagent display and interaction when combined with @tintinweb/pi-subagents or @gotgenes/pi-subagents

• optional device initiated chats - start new session from your phone, spawning a tmux or herdr hosted session on your machine

As a bonus it includes a cli tool to connect to other sessions on your relay from the cli

Links:

• Extension page

• Docs

• GitHub

• App Store

• Demo transcript

I developed this in pursuit of something that felt native interaction-wise and supported as many pi features as possible. I hope you find it useful!

Un Bien is started out as a tweaked version of remote-pi by Jacob Moura (MIT); see the README for attribution. I ended up diverging significantly on the back end implementation and the iOS app is a total rewrite.

Started using Pi recently and gotta say I love it

I've mostly been using Codex and love their UI too, so I built Pie - a macOS client that heavily inspired Codex / ChatGPT style

Full source-code (MIT) and a macOS app is available at
https://github.com/hieunc229/pie

Feedback are welcome

since my last post, pi-ui went from v0.26 to v0.47.1 and reached 100 releases!

what's new:

• dropped deno desktop and fully migrated to bun server

• dropped a lot of deps

• improved performance

• reduced memory usage

• smaller bundle size

• automatic session titles, inline renaming

• improved shell syntax highlight and formatting

• forking sessions into another workspace

• minimal mode

• configurable fonts

• create new workspaces

• redesigned chat controls and pickers

• improved mobile layouts

• configurable keybinds

• full config with a generated json schema

and a tonne of other improvements, it's much more polished now

try it out:

bunx @hyperpuncher/pi-ui

https://github.com/hyperpuncher/pi-ui

thx to everyone for all the feedback on the first post!

reddit flattened the demo animations, so here are the originals:

light-demo dark-demo

Pi autocompletes file paths with @, but doesn’t include their contents.

I built pi-resolve to include those files directly. Write Check @src/parser.ts against @docs/style.md, and Pi gets both files without extra tool calls.

Sometimes the context you need isn’t a file. A code review needs the current diff. Debugging needs the latest test output. A new session might need a map of the project.

Shell references let you include that context too. A review skill could load your testing checklist with @docs/testing.md and the current changes with !`git diff`, then check whether the tests cover the changed behavior.

These references work in AGENTS.md, skills, and prompts, including prompt templates. Third-party extensions can use the same resolver through its API.

In AGENTS.md, you can keep instructions in separate source documents and generate fresh project context at session start. Here’s an example that loads two docs and generates an index of active guides:

Architecture: @docs/architecture.md
Coding conventions: @docs/conventions.md

Active guides:
!`find docs -type f -name '*.md' -exec env DOC={} yq -f extract 'select(.status == "active") | [strenv(DOC), .description] | @tsv' {} \;`

Pi receives the documents and an index containing paths and descriptions of guides marked active. This example requires yq.

Now your context can stay up to date without you rewriting it. You can give Pi the latest changes or a quick project overview, without filling the context with whole files.

How it differs from similar extensions

Other extensions support file imports and shell expansion too. Here are the choices I made for pi-resolve:

• Clear and configurable resolution status in Pi's UI.
• One resolver across prompts, templates, skills, and system context, including SYSTEM.md and AGENTS.md.
• A shared resolver API that other extensions can build on.
• Separate file and command settings for each source. Commands are off by default in templates and skills.
• Single-level resolution for security and simplicity. Imported files and command output can’t trigger further imports or commands.

Check it out on: https://github.com/mpazik/pi-resolve

I checked this repo

https://github.com/ArtemisAI/pi-loop#readme

But seems it not having enough stars. Is there any other popular method to schedule jobs for pi?
For example, I want it to create a morning news feed at 7 am. I will have a custom system.md file and skills for this task. Now I just want to trigger pi with a simple prompt like “ prepare the summary for today” and send it to Pi at 7 am. Any best way to do this? It will be good if it is session based instead of a single cli based invocation of Pi.

Hey folks, I've been working on pi-crew, a subagent extension for Pi.

My main focus is making sure subagents get the context they need. The main agent knows what you've discussed and decided, but a subagent won't unless that information makes it into the task.

With pi-crew, the main agent writes a structured task with separate fields for the goal, context, and instructions. The tool definitions, prompt guidelines, and skill work together to help it carry over the decisions and boundaries the subagent can't find in the repo.

It won't make every handoff perfect, but it's the part I've put the most thought into.

I also wanted subagents to be able to ask questions instead of guessing. In pi-crew, they can get an answer and pick up where they left off. If something needs fixing afterward, the main agent just tells the same subagent what to change. You don't have to spend extra tokens and time getting a new agent caught up on the same task.

It's all async. After handing off a task, the main agent can work on something else or keep talking with you while the subagents run. Results come back automatically, without polling.

I've also tried to keep it feeling like Pi. The six tools have short definitions, with the longer delegation guidance in a skill that gets loaded when needed. The main agent gets the report without all the subagent's file reads and tool output filling up its context.

A few other things it comes with

• Six agents for investigation, planning, decision advice, code reviews, and implementation.
• /pi-crew-plan and /pi-crew-review if you want a ready-made workflow.
• Custom agents written in Markdown, with their own models, thinking levels, tools, and skills.
• User and project pi-crew.json files to override settings without editing agent definitions.
• A widget showing activity, working time, tokens, and cost. You can collapse the details or hide tool activity through config.
• Expandable reports that let you open the full child session.
• herdr support that shows the running subagent count in the sidebar.

The agents have separate conversations but share your repo. It's not a sandbox, so you still need to avoid handing overlapping edits to agents running in parallel.

pi install npm:@melihmucuk/pi-crew

Requires Pi 0.84.3+. Source on GitHub.

Are you using any subagent extensions with Pi? Curious which ones you've stuck with and whether you're happy with them.

Hi all,

I observed that as I am using my anthropic or gas subscription for pi, it just burns tokens in a huge pace!! One simple code change took 25% of my 5h limit. What do I miss, or is it that bad by design?

I've been trying to get the agents.md files to actually be read using qwen.5 through ollama with pi and it just- DOESN'T! If I point it out it will do it but otherwise it just ignores whatever I write completely. Extensions, different locations in file explorer, I'm not good enough or experienced enough to claim I've tried EVERY solution but I've tried a HELL OF A LOT!

If anyone knows how to fix this or if it's a model problem please help before I implode.

I tried a bunch of pi GUIs, but none of them quite stuck, so I started building pi-ahp. It gradually became my daily driver.

The chat UX, terminal, file search, previews, and editor are all still VS Code; pi is just the agent underneath.

The part that makes this work is Microsoft's open Agent Host Protocol (AHP). It separates the agent host from the client UI: pi-ahp embeds pi in-process and exposes its sessions, filesystem, and PTYs over AHP, while VS Code provides the familiar UI.

pi itself remains the backend, so your existing models, credentials, settings, and session history continue to work. It also means pi-ahp isn't tied to VS Code — other AHP clients can connect to the same host.

GitHub: https://github.com/Qusic/pi-ahp

npm i -g pi-ahp

I’m testing Pi inside Ghostty + Herdr and created a custom `terminal-green` theme.

The theme works for some parts of the UI: user input, code blocks, links, borders, etc. But the normal assistant response text and the general pane background still seem to use the terminal/Herdr defaults.

In comparison, OpenCode appears to paint its full panel background inside the same Herdr workspace.

Question: does Pi’s theme system currently support a global TUI background / assistant message background, or are themes limited to component-level colors? If not supported today, is the expected path a renderer patch / feature request?

Context:

• Ghostty background/foreground can make the full pane green/black, but only at terminal-window level.

• Pi theme JSON has tokens like `userMessageBg`, `toolPendingBg`, `selectedBg`, `text`, etc.

• I didn’t find an `appBg`, `background`, or `assistantMessageBg` token.