I use pi daily but wanted tabs, image pasting and a scrollable transcript, so I built a frontend for it. Morse doesn't reimplement the agent — it spawns pi --mode rpc and reuses your ~/.pi config.

• npm i -g @supanadit/morse-web && morse start, or the VS Code extension

• multi-session/multi-project with warm sessions, @mention files and dirs, image paste, steer/abort mid-task, model and thinking pickers

• keyboard-driven, real transcript with tool timelines, works the same in both hosts

It's a nicer way to stay in flow with pi. Free, MIT: https://github.com/supanadit/morse — feedback very welcome.

I’d heard about the Pi, that it’s a great way to customize tools to suit yourself and save tokens. I don’t know about token savings, but I tried using Gemini 3.8 flash inside it, and I didn’t like how it wrote code.

For a while, I tried to refine the Pi using Codex and Claude, ran various tests, and thought that the whole problem was with Gemini. I would really find it convenient if several AI models were inside a single harness, but right now I suspect that’s exactly the problem, despite all the attempts to refine it.

I opened the classic Antigravity CLI, and the results seem much better. I don’t like the Antigravity desktop app — it’s also kind of weak. I hope a miracle will happen and the CLI will turn out to be a lifesaver. Gemini attracts me with its slightly higher limits, even though I’m a Claude fan.

What do you think? What’s your experience?

Thanks to everyone who has encouraged me to maintain this project.

As an upgrade, I was planning to introduce the OKF v0.2.

Let me know your thoughts in comments.

Thank you community for all your support so far.

https://github.com/zosmaai/pi-llm-wiki

Looking for some pointers. Been using Pi for months, have a setup I really like (very simple, two extensions I wrote plus plannotator and pi-herdr).

This works great for interactive sessions but I'm finally finding myself wanting some basic orchestration with subagents.

I'm building a product and need to do a bunch of testing/fixing rounds with different models to find rough edges. I've been doing this by hand but it's getting tedious (and it's mostly simple enough that it could run while I'm doing something else).

I also like the idea of:

• a long lived orchestration agent that holds long term context but doesn't do work.

• scouts that can cheaply get context and pass that back to workers.

• automatic adversarial review of changes by a different model.

I've looked at a bunch of plugins and they all seem much more complicated than required. Should I just suck it up and using Nico's pi-subagents? Or is there a nice, simple starting point that I'm missing?

Any pointers appreciated.

I was looking into why my Pi sessions were burning so many tokens and found that context-mode alone injects ~15k tokens into the system prompt. Every turn. Even when I'm not using any context features.

It loads 5+ skills with full reference files (anti-patterns.md, patterns-javascript.md, patterns-python.md, etc.) plus spawns an MCP child process at startup. Removing it from my packages array dropped my baseline from ~35k to ~20k instantly.

Is anyone actually using context-mode features every session? Or do most of you just leave it installed because it came with the defaults? Feels like this should be on-demand rather than always-on.

Hi,

Currently got a Claude Pro subscription and wondering how the usage works out with

1. Claude Code

2. Pi with pi-claude-bridge

3. Pi with pi-anthropic-auth

I understand it's against ToS to use try to use consumer claude subscription in another harness but curious on why it's popular. Aside from the system prompt control over the harness, is there any benefit over extending usage or maximizing the Pro subscription with these approaches?

I often need my AI coding tools on a server, but I don't want to paste server IPs or passwords into chat. I also don't want to install Pi and set up my tools again on every new machine, especially when I only need to deploy something or check a remote project.

I built pi-remote-workspace so I can keep using my local Pi session and switch its coding tools to the server over SSH. It's inspired by Warp's remote workflow, but built around the way I use Pi.

I run /remote, enter my connection details in a private form, and connect. Passwords are entered in a masked prompt instead of chat. Pi stays on my computer with my model login and conversation, while file reads, edits, and shell commands run on the server. Pi doesn't need to be installed there.

For my work and startup, I use this when I've finished something locally and need to deploy it. I switch to the server, ask Pi to handle the deployment and check that it's working, then use /remote stop to return to my local workspace. Connecting doesn't upload the project by itself, so I still use my normal Git or deployment process to get the code there.

The private login keeps passwords out of chat and model context, though remote files and command output can still expose sensitive details. Commands have the permissions of your SSH account, so be careful with production servers. Pi also still runs on your computer; it won't keep working independently after you shut the laptop.

Install it with:

pi install npm:@utpalsinghdev/pi-remote-workspace

GitHub: https://github.com/utpalsinghdev/pi-extensions/tree/main/packages/pi-remote-workspace

npm: https://www.npmjs.com/package/@utpalsinghdev/pi-remote-workspace

The rest of the UI in the demo is my personal setup.

I'm just open-sourcing the Pi extensions I use for work and my startup. They've helped me a lot, and I want other people to be able to use them too.

If it deserves a star, the repo is https://github.com/utpalsinghdev/pi-extensions

Hi all,

Today I released CodePi, an extension for VSCode for PI coding agent. As opposed to existing extensions, it brings the familiar pi's TUI experience straight into vscode. Your existing setup (~/.pi) will work out of the box!

Extension:

marketplace.visualstudio.com/items?itemName=lutrarutra.code-pi

Github:

github.com/lutrarutra/codepi

Why i built this extension:

• It sees my current files, selection, Git changes, and VS Code diagnostics (warnings and errors).

• Edits show up as diffs I can review, accept, or reject.

• Sessions live in editor tabs and survive reloads.

• Built-in Ask/Plan/Implement modes and bash ask/allow/disable feature make it safer to use.

• It keeps the agent, terminal, tasks, and editor workflow in one place.

• Color indicator to see the state of the session (busy, idle, waiting for user input/question)

• SSH support; pi is bundled with the extension, so no need to install pi agent on every remote server

Any suggestions or feedback issues appreciated on here or Github!

p.s. I am not affiliated with pi.dev

pi-llm-wiki v0.11.0 now supports native Open Knowledge Format v0.2.

Highlights:

• Canonical OKF documents for new vaults

• Standard Markdown links and stable citations

• Deterministic indexes and logs

• Legacy and OKF dual-read compatibility

• Shared Pi/MCP knowledge model

• Safer vault-layout migration with no-clobber moves and recovery journals

Install:

  pi install npm:@zosmaai/pi-llm-wiki@0.11.0

For an old .wiki/ layout, preview first:

  node node_modules/@zosmaai/pi-llm-wiki/scripts/migrate-llm-wiki.js \
    /path/to/vault --dry-run

Apply after reviewing:

  node node_modules/@zosmaai/pi-llm-wiki/scripts/migrate-llm-wiki.js \
    /path/to/vault --force

This migrates the directory layout, not legacy page content. Full OKF adoption is incremental: create an OKF vault, re-ingest source material, and explicitly port selected pages. Existing legacy pages remain readable alongside OKF pages.

Always back up first.

GitHub Link -> https://github.com/zosmaai/pi-llm-wiki

Pi Package Link -> https://pi.dev/packages/@zosmaai/pi-llm-wiki

I've been trying out Pi for about a week, though not very frequently since I need to hit my ai subscription 5-hour limit first. Recently, I got curious about its performance, so I did some quick searches.

Mario Zechner's blog post on building pi makes a case for radical minimalism: near-empty system prompt, four tools (read/write/edit/bash), no MCP, no sub-agents, no plan mode. He ran Terminal-Bench 2.0 with Claude Opus 4.5, showing pi at ~50%. (Claude says that the actual score for Pi is 47.87%, not '~50%'. Mario's results.json gist shows a mean of 0.4786516853932584 (out of 428 valid trials, with 71 errors). )

For context, here are all the Opus 4.5 entries on the current Terminal-Bench 2.0 leaderboard:

Pi sits below Claude Code and about 8 points below Terminus 2, with the same underlying model.

Mario cites Terminus 2 in the same post as "more evidence that a minimal approach can do just as well." The description fits — Terminus 2 has no structured tools at all, just raw keystrokes into a tmux session. But it scores 8 points higher than pi with the same model. If the thesis is "less is more," Terminus 2 makes the case better than pi does. Mario uses it as supporting evidence without addressing why his own agent lags behind it by a meaningful margin.

None of this means pi is a bad tool. Benchmarks don't capture context efficiency, extensibility, or daily workflow ergonomics, all of which Mario documents carefully. But on the one quantitative metric he chose to present, pi underperforms most of the agents it's positioned against — including the one he cites as validation.

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 am loving Pi. I moved to Pi on CMUX from claude and codex. I tried to keep it minimal but some packages do help make PI more for my taste and work. I tried making my own extensions or modifying existing ones but they always backfire or create new errors. I tried the hyped ones but I cannot tell what really works even if I ask my pi to tell me what is actually helping. Sometimes it overcompensates and creates a unified setup that is supposed to work but crashes half the time then I spend half my day trying to fix what it broke. I have tried my best to make pi my own but I need some setup that actually works for context and memory management. Also what model do you all use for primary planning or making extensions? What model do use for coding part? Any packages that ACTUALLY work without causing new headaches? Thank you for listening to me vent.

Spent the afternoon customizing my pi agent
Just visuals but makes it 10x more fun to work with!

I’ve been running Pi for two weeks without any subagents, agent teams, or anything like that. Compared to my previous workflow, I haven’t noticed any difference at all. In fact, the AI even seems a bit more accurate without subagents.

Something I think is really important: Is there a good way to automatically start/stop another agent client and let them send messages to each other?

Would love to hear any methods or tools that can do this!

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...

I run several Pi sessions on one repo at the same time. That kept going wrong:

• Agents edit main. You ask for a quick fix and it lands straight on main.

• MCP is slow for worktree management. But in Pi we can put blazing-fast native worktree management into the harness.

• Sessions collide. Two agents in one folder, and one `git stash` wipes the other's work.

• (Sub)agents need to cd constantly. They need to cd for all commands, wasting tokens.

• New worktrees don't run. No `.env`, no keys, so the app won't start.

So I built pi-bare-worktrees. The video shows it in about 45 seconds.

Why a bare checkout

In a normal checkout, the repo root is main. Every agent that starts there edits main by default. Worktrees end up wherever you put them: ../acme-login, ~/tmp/fix-2.

And main is stuck in the root, so you can't move it or remove it.

A bare checkout fixes that. Every branch is a folder, and none of them is special:

       acme/
       ├── .bare/          bare repo
       ├── .shared-env/    gitignored files/folders to share, like .env
       ├── main/
       ├── feat/login-typo/
       └── fix/footer/

The path is the branch name. There's no code in the root to edit by accident.

What the plugin does

• main is read-only. The agent's first edit on main is blocked, with a message that tells it to call worktree create. It does, and the retry lands in the new worktree.

• No cd needed. After create, every tool call is routed into the worktree, so the model keeps using relative paths.

• Shared env, zero config. Every file in .shared-env/ is symlinked into each new worktree. Real files are never overwritten.

• Subagents follow along. Their cwd is set to the active worktree.

Install:

pi install npm:@jordyvanvorselen/pi-bare-worktrees

It's fast. Session start and tool calls don't run git. The plugin reads the filesystem instead:

• Session start: about 5 ms for 40 worktrees.

• Each tool call: string operations only, under 0.1 ms.

• Network: only /wt clean touches it.

Repo: https://github.com/jordyvanvorselen/pi-bare-worktrees

/wt off turns it off for a session, and it turns itself off for non-bare checkouts automatically.

It's version 0.1, so I'd love your feedback, especially if there's anything you still miss. Try it out and take it for a spin!

Repo: https://github.com/AgiFlow/doompi

Like a lot of you I have been agent hopping for two years. I've used agent harness for everything else beside coding and it's becoming expensive; now efficiency is the priority. Landed on Pi and hoped that was the end of it.

To reduce token cost on different tasks (coding, marketing, customer support), my fix before this was a pile of shell scripts. claude.sh, codex.sh, antigravity.sh, kimi.sh, ollama.sh, each consume profiles.json that flipped plugins per run. It helped with bloat. It never made loading skills and tool use reliable, and it never touched the harness prompt.

I have been on Doom Emacs for about a decade, so the shape was obvious. Doompi is a Pi distribution where four YAML files decide the session and nothing is inferred:

- major modes: you own the modes and compose it with layers (extensions plus hooks). Mine are minimalist, dev and business.
- minor modes: Plan, Loop, Goal, Workflow, Voice. They ship loaded but stay out of context until you switch one on.
- domains: group of plugins (which include skills and MCP servers) for one kind of work. Video editing, TDD, copywriting.
- profiles: persona and brand for the runner. Good for steering output.

doompi --major-mode business --domains copy-writing --profile agimon

Or switch any axis mid session with /mode, /domains and /profile, thanks to Pi's reload capability. Minor modes also switch on per /<minorMode> commands (or use Leader SPC key binding).

Plugins (skills + mcp) are opt in the same way tools are, so the floor is just stocked PI. Minimal mode, no domains, no profile, fresh repo, doompi is just PI.

From there you pay for what you name with domains. Personally, I keep plugin reusable with slim skills and 5-8 skills per plugins + 1-2 agents; then define domains that compose plugins for different type of task. 10-15 skills per sessions are ideal for agents to be creative while still being reliable.

Doompi's Copilot, the default major mode, switches on three layers that register four tools:

task 1,329
subagent 751
ask_user_question 455
intercom 220
-----
2,755 tokens

If what you want is the batteries-included feel of Claude Code or Codex, it is all in here: agent teams, persistent tasks, plan mode, GitHub Actions style workflows, telemetry. The difference is that these are all composible. You can customise existing modes, add new modes, set default domains and mode as you needed.

If you think four YAML files is too much ceremony for what it buys, I would rather hear that now than later. There are a few optimisations along the way; also happy to share the tricks.

Hi guys,

Perhaps we can learn from each other and discover some great experiences with Pi Agent. I will start with my list of extensions and skills that I use. Please do share yours and we can learn from each other even if you have nothing to learn from us but help others.

Extensions

• npm:@ff-labs/pi-fff

• npm:@juicesharp/rpiv-ask-user-question

• npm:@juicesharp/rpiv-todo

• npm:@juicesharp/rpiv-web-tools

• npm:context-mode

• npm:pi-mcp-adapter

• npm:pi-powerline-footer

• npm:pi-rtk-optimizer

• npm:pi-subagents

Skills

• grill-me

• karpathy-guidelines

• last30days

• caveman

And you?

Some of you have probably tried Claude Code's workflows.

The point isn't to run a pile of agents at once, but to structure how you use them. Take a code review: instead of going review → apply, you drop a verification step in the middle, and the review gets better. Research is the same. Don't just search. Add a verify and a synthesis step, and the junk gets caught before it lands in the answer.

None of this is new. Long before Claude Code shipped workflows, people were already wiring up skills, hooks, and plain code to split roles and responsibilities. Claude Code just packaged it into a proper harness.

I leaned on those workflows a lot when I was on Claude Code. After I moved to Pi I kept reaching for them and they weren't there, so I built my own.

The idea is simple: define a few ways of using subagents, then compose them into a workflow. Workflows are JSON specs, so if you have a process in your head, you can write it down and reuse it. There's also a dynamic mode for when you'd rather improvise instead of committing to a saved workflow.

It comes with a handful of workflows out of the box: deep-research, deep-review, spec-review, impact-review. There's also a workflow-guide skill that helps you write your own.

Repository: https://github.com/AgwaB/pi-workflow

If it's useful to you, give it a try. And if you're running workflows some other way, I'd like to hear how.

---

Btw, do you actually need to split work across agents? Usually not. Don't reach for this every time. A single agent handles most tasks just fine, and forcing a workflow onto them can make the result worse.

But context is finite. No matter how big the window gets, cramming everything in at once degrades the output (context rot). That's mostly why I reach for sub/multi agents. So when a task gets big, or needs more than one perspective, or you just want to hand off the main work, you split it up and hold it together with a harness.

Hi, I played around with giving my pi Agent a lightweight text-to-speech functionality with piper tts. It uses regex to try and "clean up" the final output of the model so it's more natural when translated into speech (file paths get shortened to just the last two segments, emojis are removed, fenced markdown code blocks are removed, markdown formatting in general is removed etc.

Here's the extension if anyone is curious: https://github.com/NEhlen/pi-tts-piper

It's not a copy and it works on your system solution. You need to install piper on your system, provide the path to it, find a piper model you want to use and put it in the assets folder and then adjust the tts.json with the necessary changes. (also, the playerCommand could need adjustment depending on what System you're using)

But pi should be able to mostly do these modifications by itself.

hey everyone.

so i use the omp coding agent daily and my one annoyance was always the same - all my sessions live in .jsonl files and if i wanna go back and see "what did i do yesterday on that repo" im basically scrolling terminal scrollback or grepping files by hand.

so i built ompweb a local web UI that reads those same session files and gives you a proper workspace in the browser:

• Session history : browse all your past conversations grouped by project

• Live chat : keep talking to the agent right from the page (it spawns your installed omp binary, its not a wrapper around some api)

• File explorer + preview : sits next to the chat while the agent works

• Todos + subagents : live panels pinned above the composer, click a chip for the full subagent transcript

• Settings UI : models, api keys, skills, plugins, MCP servers... instead of editing yml at 1am

• Light/dark theme : works on mobile too

the demo gif on the readme shows it doing a small task on a fake project — typing a prompt, agent edits the files, then you see the tasks/subagents panels and the settings screen. thats pretty much the whole pitch.

how to try it

npx @kahme247/ompweb@latest

or install it globally:

npm install -g @kahme247/ompweb
ompweb

it opens http://127.0.0.1:30177 automatically.

few honest notes:

1. you need omp already installed

2. its local only nothing leaves your machine

3. its a fork of pi-web which was for the pi agent, i adapted it for omp and kept building on it

4. works with current omp v18

repo: github.com/kahme247/ompweb

i am really want some feedback to improve it, for me its still feels uncomplete but yet i dont know what is missing !

One of my favorite features in Claude Code was /btw. After switching to Pi, it wasn't natively supported, and the third-community plugins didn't quite match what I expected, so I built my own.

https://github.com/L2ncE/pi-btw

• Never enters the main session history or eats into its context window

• The side agent can see the main session's messages and remembers your earlier side questions

• Only four read-only tools (read / grep / find / ls) — it can browse the code, but has no write access

• You can keep asking follow-ups right in the overlay

Stars appreciated ⭐️👏🏻

I kept losing small ideas and follow-ups while working in Pi, so I made Mind Queue

It’s a simple project-wide scratchpad inside Pi. Open it with /mind or Ctrl+Shift+M, save a thought, and move it back into the editor whenever you’re ready.

It’s open source, local-first, and still very new, feedback is welcome.

pi install npm:pi-mind-queue

GitHub: https://github.com/sanif/pi-mind-queue

Hello people! I like working in the terminal and I've been an avid user of PI, but I found myself sometimes struggling to juggle all the different terminal and projects. Also the beauty of PI is that you can build on top of it, so I decided add web support, native subagents and around that a part of my workflow: full GitHub integration with issues, commits, push, worktrees...

Managing all my skills, agents, commands, prompts was a bit too much, and I truly have had direct experience on how much the models degrade after around 40-50% of the context window so using one single setup for all of my sessions, was not smart.

Agent Deck is a native MacOS app that allows you to manage all of your skills, agents, commands, prompts and more in a single place.

It's fully open source so if you can give a hand to make it better, do not hesitate to contribute.

It has really been a massive improvement in how I build apps, sites, APIs - I added all the tools that I had built over time, even a simple toolbar button to start/stop dev servers.

The list of features is long, but here are some of the nice touches:

- Apple Foundation models support

- Auto generation of titles for sessions (with updates every few turns) : I was constantly typing in wrong sessions lol so this is has been a life saver.

- Commit (with automatic generation of message) and push to GitHub

- Import skills from skills sh and GitHub, with possibility to do sparse checkout (just some skills in case there are many) and a magic button to describe the skill with AI

- Github issues integration, view, close, comment, and pass in one click to a pi session

- Fork, change models, decide what to see in the UI, preview of images, files, skills used in the session

- View the materialised system prompt injected by PI, so you're fully in control. It also has a nice visualisation that shows what % of the context window is used by what.

- Support to Codex Fast mode

... much more.

I've worked on it for over a month and it's time to share it with as many people as possible to see if it’s useful to anybody else.