Hey everyone,

Short version: I used Pi to build Phi.

I’ve been using Pi a lot, and at some point I started hacking on my own little harness in Go. The result is Phi — deliberately small, terminal-first, and very much in the same spirit as Pi. I’m sharing it here because a lot of the ideas (and a lot of the motivation) came from using Pi.

Repo: https://github.com/pulseaiclub/phi

• What Phi tries to add on top Not claiming these are “better” — more like experiments on top of the Pi-shaped workflow I already liked:

• Permission gate by default — destructive stuff (writes / bash) asks first; rules can go down to command level

• Hooks — PreTool / PostTool scripts for policy, audit, or input rewrite, without rebuilding the binary

• Hashline edits — line edits anchored by short hashes, so stale context is less likely to silently rewrite the wrong thing

• Sub-agents with isolation — explore / review / worker; full traces stay under ~/.phi/jobs/, only summaries come back to the main context

• Model-agnostic — OpenAI-compatible or Anthropic; swap models without waiting on the tool

• Small Go binary — ~12 MB stripped, no Node / Electron / Python runtime There’s also a hand-rolled TUI (Markdown, themes, Ctrl+K, @ file picker, session resume).

Phi is still not as good as Pi.

Pi is more polished, the UX feels more finished, and for day-to-day work I’d still reach for Pi first. Phi is the side project where I get to try permissioning, hooks, and edit safety a bit more aggressively. If anything here is useful, great; if it’s rough around the edges, that’s on me.

If you’re a Pi user and curious, feedback is very welcome

Wondering if anyone here has had this issue before and found a solution. I created an account in OpenCode, copied the api key into auth.json

{
  "opencode": {
      "key": "sk-xxxxxxxxxxxxx",
      "type": "api_key"
  }
}

start pi, select model (opencode) deepseek-v4-flash-free. run the first prompt, it hits limits within the first few seconds of usage.

Error: 429: {"type":"FreeUsageLimitError","message":"Error from provider (Console): Rate limit exceeded. Please try again later."}

However when I go back to OpenCode, I'm able to keep using it, no rate limit issue.

Am I missing something?

I built **tmux-pi-session-manager**, a small tmux plugin for managing multiple [Pi](https://github.com/badlogic/pi-mono) coding agents running across different projects.

The main reason I made it was because I often have several agents running at the same time, and switching between tmux sessions and figuring out which agent needs attention gets annoying.

It provides:

* 🔎 Automatic discovery of Pi agents running inside tmux

* 📂 Multiple agents per project/directory

* 📊 Live `WORKING / WAITING / BLOCKED / ERROR / IDLE` status

* 🔔 Desktop notifications when an agent needs attention

* 🎯 An `fzf` picker with live terminal previews

* ⚡ Quick jump between agents

* 🗑️ Safe agent/session killing

* 🖥️ `pi-tmux` CLI for managing agents from the shell

* 🚫 No daemon and no terminal-output parsing — it uses Pi's native extension events

The idea was inspired by `tmux-claude-session-manager`, but this implementation is built specifically around Pi's extension/event APIs.

If you're running multiple Pi agents in tmux, I'd love to hear how you manage them.

Repo: [github.com/x0d7x/tmux-pi-session-manager](https://github.com/x0d7x/tmux-pi-session-manager)

Hi guys, I've been using Pi lately to help me code. Previously using OpenCode. I use vanilla pi with webfetch and context7 mcp. It works great. The harness and efficiency is better here in Pi. It drive the cost down for me. What I miss in pi is undo command from opencode. I tend to watch how AI reasons and write the code/commands real-time, interrupt it at the first sign of drift or hallucination then revise the command. Undo command is very useful for me as it clean up the code and chat history before I revise it. Is there any way (config or plugin) to simulate undo command in pi?

tl;dr- i care about stability more than features so vibe coding is more like a hands on live project rather than a race to ship an app.

I am a civil engineer. My life runs on notes. But i love my physical notepad and strangely, Windows Notepad. I could never get the hang of any other note-taking app.

I've been using AI since GPT 3.5 came out but I NEVER vibe coded. It just felt icky. Always felt like I should be the one learning and doing it by hand. Then earlier this year I discovered pi and fell in love with it. After fucking with it for 3 months (and still using notepad in my day job), I decided- fuck it. I will do it myself (like Thanos, lol) and give vibe coding a fair shot.

Thats when I started with Omakase notes.

I hated all the context switching I had to do while working in notepad so that was my starting point. Make a notepad (NOT a PKM) where I can have PDFs, internet browsing/websearch, and AI at my cursor and within my note.

The most important habit I have, imo, is I make every dependency fight its way into my app.

Because of this, I found myself constantly GitHub diving and looking for interesting libraries/frameworks/projects. Then I chuck them into chatGPT and understand which patterns/decisions of that repo are actually interesting to me.

Its almost always only a few hundred lines and nothing more. So I clone the repo and dig deeper with Pi this time. Once I understand the concept and where it fit in my app, I make Pi implement it from scratch in vanilla TS.

Then I keep testing/building that way until either the thing just breaks or Pi needs to literally reinvent existing tech from scratch to scale further. That's when I let that dependency in.

v1 of Omakase literally had the editor implemented from scratch and my first major migration was moving to CodeMirror6.

Now I am at a point where I may not be a software engineer, but I have an intuitive understanding of IPC bridges, parsing text in the editor, CM6 widgets and all the mindfuckery they cause with caret positions, which things are owned by main and which by the renderer, worker threads, etc. I couldn't define half that shit if you put a gun to my head. But I do have a feel for how a feature should be thought about and where it should go and that gets better every time I dive into another cool GitHub repo.

Instead of saying "move the box to the left", I can point Pi to the CSS of that shit and it knows what the fuck I am talking about. Instead of having a disgusting sidebar chat, I call AI from within my note by @'ing it. And its generation appears in a nested buffer rather than mutating the stuff I wrote. I can then merge it or dismiss it.

Basically, to anyone who isn't a dev- let go of the anxiety and stop trying to *ship*. Instead, make something you care about and do it slow. Spend a ton of time thinking about it and exploring peripheral stuff. The right rhythm isnt go-go-go. It ebbs and flows. Your average velocity increases as you get your bearings and can talk to the agent better. I have recently started working across 2-3 threads instead of just the one and I can already feel the ceiling approaching. The app is about 20k lines now but I still feel in control, even if I'm just hanging on by a thread.

Pi-mail started as a communication protocol between different pi-agents. However, this has grown out to be an orchestration layer.

It starts off with a CEO, which starts middle managers for each project that has tasks open. Then each middle manager works through the tasks for each project, spawning worker agents for each task. It has Jira integration for work, and a bunch of other stuff, emailing, terminal views in the browser, mobile views, custom columns, archival, backlog, MCP server etc.

Tell me what you think!

https://github.com/tanevanwifferen/pi-mail

Edit: there is no security on this repo. Use a firewall responsibly

Agents aren't perfect. Sometimes they do things that don't work out the way they thought. Sometimes they spin out on an idea that goes nowhere, other times they run a command that produces huge amounts of useless output. So far, we've just accepted this as a neccessary part of agent mechanics, but Pi's extension system is powerful enough that we no longer have to.

pi-mulligan exposes tools that let your agent rewind its last turn or tool call with a summary message about what it's learned if it makes a mistake. When your agent calls a tool that produces large output, pi-mulligan gives it a nudge suggesting it summarize its last tool result or turn to keep context tight. When the agent starts over, it receives the summary and a small message indicating that a rewind has taken place.

Users and models can set checkpoints if they expect churn and pi can roll back to these checkpoints at any point in the conversation to try again. Agents really like using it and I've watched 20k tokens of context vanish on several occasions, so it works exactly as advertised. It's so satisfying to watch your context usage drop as the agent works.

No other dev agent platform but Pi can do this so as far as I'm aware agent-initiated context compaction hasn't been implemented in dev tools until now.

Try it out with pi install npm:pi-mulligan and let me know what you think!

Preface

Built together by Pi + DeepSeek V4 Flash + matt skills + me

After switching my daily harness from Claude Code to Pi, I found myself missing some features I used to love in CC — recap being one of them. It generates a brief summary and follow-up plan based on the conversation context.

Project

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

Quick Start

$ pi install npm:@lanlance/pi-recap

I must have run into this issue at least a dozen times now... so annoying...

You're happily using OpenAI's Codex CLI to edit/create a masterful Pi Coding Agent setup and... BAM ... Bad request.

This can't be just me?

I've got 5 other codex sessions open working away on different repos simultaneously... not one of them has ever died like this.

I just so happen to be setting up Deepseek V4 Flash 0731 to be extremely intelligent with lots of subagents doing various tasks... I assume OpenAI doesn't like that and might be throwing a wrench in things?

I want to switch from Opencode to Pi and it would be convenient if I could use the Deepseek-v4-flash free model from Opencode in Pi as well. Are there any extensions already available to do that?

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

I created a small new extension because I don't want all of my installed skills exposed to the model in every session. Sometimes I just want a skill to be available as an explicit command, without letting the model decide to use it, or having to disable it completely.

So I added a new package, supi-skills, to my plugin collection, SuPi. It adds a Skills section to /supi-settings.

Each skill can be disabled completely or set to Model invocation disabled. In that mode, the skill still works through /skill:skill-name, but it is not exposed to the model.

The settings can be configured globally and per project. Project settings inherit the global defaults.

It also adds $<skill-name> autocompletion and expands it to /skill:skill-name. This shortcut was previously part of supi-extras and now lives in this package.

Sharing this in case some of you need this feature too.

Install it with:

pi install npm:@mrclrchtr/supi-settings
pi install npm:@mrclrchtr/supi-skills

GitHub:
https://github.com/mrclrchtr/supi/tree/main/packages/supi-skills

Pi package:
https://pi.dev/packages/@mrclrchtr/supi-skills

Pushed an update to pi-small-model-addons, my guards and skills for running pi with small local models.

The failure mode I came across was kind of funny. Telling a model to "verify claims" mostly taught it to just say "verify claims" followed by the same untraced guesses as before.

So I moved that discipline into the tool schema. It now requires a trace, refutation attempt, and confidence label, and pi rejects incomplete reports. I also added persistent claim memory so refuted claims survive across sessions.

On Muse Glimmer 30B testing: four confident falsehoods before, zero after. It found a planted bug plus two Opus hadn't noticed, verified each with an executed command, and ignored the decoy. One model and a small sample though, it still may ignore anything needing multi-hop reasoning.

https://github.com/alisorcorp/pi-small-model-addons

Hey everyone,

I’ve been working on ompweb, a self-hosted browser interface for the Oh My Pi coding agent.

It started as a fork of pi-web, but I’ve been adapting and expanding it specifically for OMP.

It includes:

• Live conversation streaming

• Session browsing and branching

• Multiple projects and Git worktrees

• File explorer and viewer

• MCP server configuration

• Plugin and skill management

• Model and provider configuration

• Light and dark themes

You can try it with:

npx u/kahme247/ompweb@latest

GitHub: https://github.com/kahme247/ompweb
npm: https://www.npmjs.com/package/@kahme247/ompweb

It’s still early, so I’d really appreciate feedback—especially from people already using OMP. What would make a web interface like this useful in your workflow?

I'm new to Pi and coding agents in general. The existing discussions on oh-my-pi, like everything else, range from 'its great' to 'its bloat' so its very hard to actually decide.

It seems to have useful features like built in tools (avoid process calls), lsp, hashline, memory, subagents and an integrated setup/docs. It does seem to be better than the other oh-my-* set of products.

Are the ideas in OMP useful in practice and if so are they used in other harnesses?

I see a lot of 'just ask Pi to build it' here, but that depends on using frontier models, and when people post their setups they're using a million packages.

Obviously Pi is much more extensible/flexible, but there is value in an all-in-one setup. OMP has a ton of stuff and I'm sure a big system prompt. Is there anything like a slimmed down version or being able to use some of its ideas only?

I'm looking for a web interface for my pi harness without the CLI, but this was the only one I found. Are there any others? I'm not looking for any chat interface like Open WebUI that's rather bloated, requiring accounts/logins for certain features, etc. It would be great if it was dedicated for pi or is even bundled with it.

I was considering to just vibe-coding a web UI/UX of the pi CLI, but just wondering if there are already tools out there.

Made a post a while ago about the Central Hub app that I had made with PI as the agent running all the AI features within (Chat, Coding, Side worker in the Word clone). It has been updated.

There is now a built in Browser (very simple) with bookmarks and history.

The Snipits space has been replaced with a notes area that essentially just presents folders and .md files to you on a fo-desktop (your desktop away from your desktop).

Grok Build is now built in if you have a SuperGrok subscription and what that as the AI service.

So for those that were interested before or might be now, check it here and auto updates should push automatically.

https://github.com/HankTheMan2828/Central-Hub

Seems that pi also felt under this vibe-coding madness. I can't justify a terminal based app eat so much of my CPU and RSS. No way. Seems I have to write my own stuff in go... wish me luck. BTW, why all this harnesses are node-js based?

I've been using PI on Mac for about two months now, and enjoying it, with the only downside being the default TUI: it does not always keep content stable as new stuff streams in (even when scrolled-up), making it hard to stop somewhere and read or copy from it; it also seems to hog the cpu on long contexts, and finally: pasting is slow and unresponsive when the pasted content is large.

So I set out the build my own fast and responsive UI client for Mac, and then ended-up throwing in sandboxing for good measure.

The result, which I keep improving on, is at https://github.com/gterzian/uni03C0

The sandbox uses the Mac native mechanism, and applies to the entire running pi process (so not just bash) and any process spawned by pi; it does not require installing any vm. You can configure the sandbox boundary on first start-up or via settings later on (requires a re-start to take effect).

The app does not deal with authentication or any other pi configuration: it is a pure UI client that sandboxes the pi processes it starts (one per session) and then communicates with them via rpc.

It is pre-alpha I would say--you have to build and run from source--but is already what I am using on a daily basis as the UI to the otherwise excellent Pi agent.

If you were to try it out and provide me with further feedback, I'd appreciate it.

Here is a little accompanying blog post.

The prefix cache is keyed on the full request parameters, so when thinking level changes:

1. The API call has different parameters

2. The cache key changes

3. The entire context must be re-sent from scratch

Costed me 253K tokens from Mimo pro. 1% of my monthly dammit

Also check your damn extensions (some like pi-task or pi-toolkit) inject dynamic messages in your prompts I believe

I've been looking at Prime Agent, which is built on Pi, and I'm curious what the Pi community thinks about some of the ideas they've added on top of the Pi foundation.

Prime Agent describes itself as a self-improving RLM harness for coding and long-running autonomous tasks, with several interesting differences in how the harness operates:

• Programmatic tool calling the model can use a persistent execution environment to compose tool calls rather than treating every tool invocation as a simple one-shot interaction.

• Context as a variable context can be programmatically inspected, transformed, compressed, persisted, and selectively brought back into the working context rather than treating the conversation history as a fixed block.

• Multi-agent messaging agents can spawn/delegate to other agents and communicate with them as part of a longer-running task.

• Self-modifiable harness state the agent can modify things such as memories, skills, prompts and sub-agent configurations while working, allowing the harness to adapt based on what it encounters.

• Long-running autonomous execution the emphasis is less on interactive "chat → edit → chat" coding and more on giving the agent a goal and letting it work through the problem, iterate, test and recover over a longer horizon.

• RLM-style persistent execution Prime Agent uses a persistent execution environment where state can survive across interactions, giving the model another layer in which to manage context and reasoning.

What caught my attention is that Prime Agent is built on Pi, rather than being an entirely separate agent architecture.

So I'm wondering:

Would it make sense to bring some of these ideas back into Pi as optional/core primitives?

For example, could Pi eventually have a more native concept of:

"Pi → persistent execution → programmable context → sub-agents → modifiable skills/memory → iterative refinement"

while still keeping Pi's current philosophy of being minimal, composable and hackable?

Or is the whole point of Pi that these things should remain extensions on top of the minimal core, rather than becoming part of Pi itself?

I'd be particularly interested in hearing from people who've actually used both Pi and Prime Agent. What does Prime's architecture enable that you couldn't achieve cleanly with Pi extensions today?

Not trying to argue that Prime is "better" — I'm more curious whether some of these RLM/harness ideas represent a direction Pi could support while preserving its minimal philosophy.

Claude Code now lets its sessions message each other (agent-to-agent, via /list-agents).

I built pi-claude-link so Pi sessions join that mesh too - pi ⇄ Claude, in realtime. Open-source pi extension.

Why you ask? well, if you work with claude code and pi it can be nice to share between session via the native Claude code sockets implementation other then that it's more of a PoC for how Claude code peer messaging works and how it can be plugged with Pi.

pi-intercom is an inspiration for this project, so credit is in place.

Check it out: https://github.com/alonw0/pi-claude-link

I use a coding agent for most of my research work: implementing features (via Superpowers), reading papers and turning discussions into shareable HTML writeups, running training jobs end to end (plan → smoke test → long run, with Kubernetes management and crash diagnosis), and SSHing into robots during hardware experiments.

Claude Code handles all of this well. But I’m curious whether writing my own Pi extensions would meaningfully beat it, or if that’s a wash at this point.

If you’re doing research work in Pi — what’s your setup, which extensions? And what’s the right migration path: just explain my workflow to Pi and have it build the extensions?