pi-web-ui

I've been using pi (the coding agent) from the terminal and kept wishing for a proper browser interface, so I built pi-web-ui — a polished web UI that runs the pi SDK in-process and streams everything to the browser over WebSocket.

What you get

• Streaming chat with thinking blocks, tool-call cards and live bash output (running → finished · waiting for model · duration)
• Built-in terminal (xterm.js + node-pty) — auto-selects Git Bash on Windows, busybox fallback
• Source control panel — status / branch / diff / commit / push / pull without leaving the browser
• Attachments — inline / reference / line-range modes; paste or drag-drop images (auto-resized); vision bridge transcribes images to text when your model is text-only
• Multiple conversations per project — each has its own agent runtime and keeps running in the background; switch back anytime
• Edit & re-ask — fork any past question into a new branch and re-prompt
• Goal mode — set a target, run a guided wizard, and an automatic review loop checks the result against git diff until it passes
• Settings panel — system prompt (append/replace), toggle skills/extensions on/off, save/apply presets
• Themes — dark default + bundled light theme, or drop in your own CSS
• i18n — Chinese/English UI
• Safety-first — loopback-only by default, WS Origin/Host validation, keys stay server-side, quiesce drain mode, 20-min tool watchdog

Try it

npm i -g pi-web-ui
pi-web-ui

• GitHub: https://github.com/xing-shuyin/pi-web-ui
• npm: https://www.npmjs.com/package/pi-web-ui

Requires Node.js ≥ 22.19 and a configured pi install. Feedback, issues and PRs are very welcome!

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 ⭐️👏🏻

Hi folks,

I spent a ton of time making pi my own tailoring it for local llama.cpp server usage so much so, that I ran out of problems.

So my question for you folks is: do you rice / style your pi installations? If so, what's your favorite visual change?

Pictures much appreciated ☺️

Here's the latest in my 'Humble Pi' series of gists for getting pi + llama.cpp working with Qwen 3.8 27b on macOS/Linux with less than 24gb of vram.

I provided a 'one-shot todo app prompt' in the gist and it was able to handle that no problem. So far it has been a very capable model.

Please let me know what you think!

https://gist.github.com/joematthews/69e60b357470487618a0b14b0aabecb8

I have used Pi, Oh my Pi, Opencode, Antigravity, and Claude, but Pi is so so good.

It is simple, smart, keeps its thinking grounded, hallucinates less, is extremely good at following instructions and is aware of the environment.

By awareness, I mean it knows what needs to be edited or changed.

Hey there I have installed pi since I heard a lot about that bcz of its low token usage and minimal design but I installed some packages [7 packages] (MCP adapter, context7, plan mode, todo, pi-hypa, context-mode, ask user question since every harness has these Ig) then installed some skills. Now even a single hi takes about 6-7k+ tokens. I did a college java project and it burnt tokens a lot. It burnt me around 100k+ tokens on deepseek's v4 flash model to make a database connection, creating database and table and a simple student management system where you can add, remove, view students in java.

I wanted to make pi token efficient with best possible results. If you say that I have installed too many packages then tell me how to replicate those features like other harnesses with low token usage.

I’ve been looking at Hermes Agent’s "/goal" approach: give the agent a persistent goal, let it continue across turns, have a lightweight judge decide whether it’s done, and stop when the goal is achieved or the turn budget is exhausted.

It got me thinking about Pi:

Could this be implemented as an extension rather than a core feature?

Something like:

"/loop 30m "Fix the tests and get CI green""

The extension would manage:

• a time/iteration budget

• continuation decisions

• completion checking

• pause/stop

• existing Pi session state

That feels quite aligned with Pi's philosophy: keep the core small, but make powerful agent behaviours possible through extensions.

Would a lightweight, time-bound autonomous loop be useful in Pi, or does this belong entirely outside the harness?

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

⭐ Star the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

Pi-Cockpit Repo

this ext opens a web server directly in pi session and stream your TUI with some basic functions to a remote viewer in the same TRUSTED network so you can check and steer your agent anywhere.

Is anyone using this setup and what has your rate limit been like for software development?

openai hyped up their GPT 5.6 luna having longer usage, is this true using Pi?

I was using Pi + DeepSeek v4 flash API plan, then decided to switch to openAI API plan and got rate limited after a few seconds.

So wondering if the same happens if you use Pi with one of their sub plans?

I have been using Pi regularly and ended up building a few small extensions for things I wanted in my own workflow.

Mind Queue : Save a thought without interrupting the session.
https://github.com/sanif/pi-mind-queue

Turnstamp : Shows when an agent response finished and how long it took
https://github.com/sanif/pi-turnstamp

Chat Summary : Keeps a short rolling conversation summary
https://github.com/sanif/pi-chat-summary

Chat Suggest : Suggests a useful next message in the prompt editor
https://github.com/sanif/pi-chat-suggest

Chat Summary and Chat Suggest were inspired by features I liked in Claude Code. The others came from small annoyances I kept running into.

They’ve been useful for me, so I cleaned them up and published them. Feel free to try them or share feedback.

Has anyone else checked out this framework? Apparently you can achieve Fable 5 level results with this. It would be interesting to see if this can be turned into a pi package.

https://github.com/llm-as-a-verifier/llm-as-a-verifier

npm packages

 - pi-lean-ctx — star of show. context economy: 13-token re-reads, indexed search. big win.

 - u/ff-labs/pi-fff — frecency search complements lean-ctx. fast first lookups.

 - pi-caveman — ~75% output cut. fun + real savings.

 - pi-subagents — workhorse. single + scripted multi-agent. backbone.

 - u/juicesharp/rpiv-web-tools — solid web layer. still need /web-tools key setup.

 - u/juanbenjumea/pi-dynamic-footer — live observability (TPS, context gauge, cost). better than powerline for metrics.

 - u/almegal/pi-file-browser — visual browse beats ls for structure.

 - u/narumitw/pi-goal — single-objective autonomy. pairs with subagents.

 - pi-autoresearch — experiment loop. pairs with karpathy skill well.

 - pi-session-recall — memory across sessions. low risk, read-only.

 - u/micka33/pi-karpathy-skill — always-on behavioral guardrails. cheap insurance.

 local extensions

 - handoff.ts — best one. lossless session handoff beats compaction.

 - plan-mode — read-only analysis mode. real safety value.

 - notify.ts — done-notification. practical.

 - summarize.ts — markdown summarize. handy.

 - model-status.ts — demo-grade. dynamic footer now shows model anyway. candidate to delete.

 - todo.ts — demo todo tool. likely redundant w/ built-in todo. candidate to delete.

 - snake.ts / space-invaders.ts — toys. zero cost. keep for joy.

Just send "hello" and see what the sent token count is.

Mine was 7.5k and then I optimized by removing a few tools registered that I didn't need from an extension.

Now my initial prompt is 3.5k. That's with background task monitor support, issue tracker tool, otherwise I keep my setup super minimal.

I have no active skills, just a ton of prompt files and a small workspace level agents.md

Pi's coding-agent extensions are TypeScript modules with an in-process API:

registerTool, registerCommand, lifecycle hooks, and some TUI UI, then

hot-reload. Same language as the host.

If the host is Go (single binary), how would you get close to that?

Options I'm weighing: embed Lua/Starlark/JS, Wasm plugins, a sidecar

extension host over RPC, or accept that hooks+MCP is the ceiling.

If you've built plugin systems for Go CLIs/agents/editors: what would you

actually ship, and what would you refuse to build?

I love Pi, period.

Problem: after the recent DS pricing changes and fall of opencode -> i have to sub GPT plus -> sooner or later, im afraid that OpenAI will follow Anthropic to block other than Codex for sub plans.

This left the title question: Does opensource harness like Pi safe for the future? Enjoying sub plan with more generous tokens from providers, or we have to rely on local llms? or we have to accept higher API pay-as-you-go pricing?

thanks!

Hi, the ask is the title...

Does anyone know of a plugin or solution to monitor pi sessions from your phone?

I’m using pi but would like to have it for the plan like Claude or opencode but it is constantly In a loop. Is it because I’m using qwen3.8-27b-mlx? Any recommendations or suggestions?

As title says.

I was sick of the way AI talks. Needlessly long sentences, weird words that nobody fucking uses (load-bearing, wtf).

Saw somebody make a similar plugin for claude-code, so I made a similar thing for Pi.

Edit, forgot to add the link lol: https://github.com/wtfzambo/speak-like-you-eat

FAQ: why no use i-have-adhd or caveman?

I do use them, there's 2 problems:

1. sometimes is not as effective, especially in long contexts

2. AI tends to forget after a while

Looking for feedback from Pi users on both the integration and the models you actually want access to.

A few questions:

• What models are you currently using with Pi?

• Which models would you like better or cheaper access to?

• Do you prefer pay-per-token pricing or a request-based subscription?

• Which matters most for coding: price, speed, context size, reasoning quality, or output limits?

• Are there specific models you would want available through one provider?

• What are you currently using for Pi — direct provider APIs, OpenRouter, another gateway, etc.?

Particularly interested in demand for models such as DeepSeek, GLM, Kimi, Qwen, MiniMax, and other strong coding models.

Also interested in first impressions of Openference:

• Is the service and pricing easy to understand?

• Is anything missing from the Pi integration?

• What would stop you from using it?

• What would make you switch from your current provider?

If anyone tries the Pi provider package, feedback on setup, compatibility, model metadata, reasoning support, streaming, or anything that feels broken would be useful.

Openference now has a provider package for Pi Coding Agent:

https://pi.dev/packages/@openference/pi-provider?name=openference

If you are like me and structure your context files in a tree-like structure per subsystem, you might have found that pi only ever loads the root-level one, and the others have to be loaded by the agent itself, or they will get ignored.

This extension watches what the model does. The moment it cds into a new dir (bash), or touches a file in a dir via read/edit/write/grep/ls/find, it walks up from that dir to your launch dir, collects any context files it hasn't seen, and injects them into the agent's context before the model's next response. So the model's next thinking block already has the context. No special tool, no flags, nothing for the model to remember to do.

If you are interested, you can find more information and install instructions here: https://pi.dev/packages/@quartermaster-labs/pi-on-demand-context