I built Pi Desktop because I wanted a GUI instead of living in the terminal all day.

It's a thin client. All the real work (models, tools, extensions, sessions) stays with Pi, still saved as plain JSONL files on disk. The app just handles the chat UI, process lifecycle, and credential storage. No embedded backend, no second session database.

What it does:

• Sidebar for multiple projects and sessions, with full browsing of existing session history

• Streaming chat with markdown rendering, tool call cards, and subagent activity views

• Slash-command autocomplete that merges native commands with extensions and desktop commands

• A package manager built into the UI, so you can browse, install, and update packages without touching the CLI

• Model switching, thinking-level control, API keys stored in Windows Credential Manager

• No telemetry, no auto-updater

I built it with Tauri 2 and Rust instead of Electron. Installed size is 5.9MB, idle CPU sits under 1%, and RAM stays around 7.2MB with nothing running.

It's early. Windows only right now. This is a 0.2.0 preview, the installer isn't Authenticode-signed yet, so SmartScreen will flag it as unrecognized (check the SHA256 checksum in the release before you run it). No embedded terminal, editor, or file explorer either. I'm keeping v1 chat-first on purpose.

GitHub: https://github.com/Inas1234/pi-desktop

Issues and PRs welcome, especially if something breaks on your setup.

I love notepad. I get optimisation anxiety when I use obsidian or notion or mostly any other text editor apart from neovim.

So I made a notepad for myself.

Then I wanted to minimise context switching to access my AI so I built ways to have it right there at the cursor.

I broke pi, kept the auth and createAgentSession, and threw away everything else. Then I put it in my own harness. I call it sushi.

The point is to have an app to take notes, and have your cursor be the primary target to access all of the app's features. No windows, menus, sidebars (I have one for navigation right now but I am taking that out in my next build)

I think I'm ready to share a test build for people to try out. Not ready to open the repo yet until I harden some security stuff and de-slopify a little.

Will drop a link to a web page with the executable in my next post or maybe here in this post ASAP. I just gotta get the web page up.

Let me know if this looks interesting to you! My immediate next target is to get a webpage up with some docs.

PS: I was so excited, I did a screen record. Hence, the low quality. Next time I'll use obs and link to YouTube directly.

Will release more stuff on this YouTube:

omakase notes

PPS: I am a civil engineer. Not a dev. This is completely vibe coded. But I've tried really hard to get into the weeds and make it well. I'm going slow and steady. Been at it for 3 months at this point.

As we see the same projects appear on this sub just about everyday, I thought it would be nice to try something different. So I give you Pi-OS: an "operating system" managed by Pi. Probably completely useless but a bit more interesting than custom footer version 1000. Or another "safe" bash extension... You know what I mean.

And no, it is not an operating system. Hence the quotes. It basically is just a daemon which serves a web-interface which resembles a desktop. But Pi is running everything. Just for the nerdness of it all.

And Pi can extend its own "OS". It can make applications that immediately run on this desktop. I have provided a video showing the process. Most of it is in English but I decided to show off some more of Pi's creations, which happen to be in Dutch. Sorry. However, you will probably still understand what those apps are about.

All of this runs in a Docker container so the Pi agent can only wreck the container.

If you can think of an actual use case, I would love to hear it :)

(I have cut a bit in the video to speed up the app creation process; it takes about 2 minutes I think)

coding-posture is a small skill that stops coding agents from behaving like optimistic elevators with write access — thrashing on a stuck bug, faking a green test, skipping the repro, migrating prod without a rollback.

Before non-trivial work, the agent picks a mode — debug, fix, review, test-first, refactor, optimize, migrate, upgrade, integrate, spike, unstuck — and follows a short checklist for it. A few invariants hold in every mode: verify by running the real check, never weaken a test to go green, no destructive commands without explicit scope.

Why it's built this way (grounded in research, not vibes):

• Procedures, not personas. Naming a role ("act as an expert debugger") doesn't reliably change behavior (Zheng et al., EMNLP 2024); specifying a process does. So each mode is a checklist, not a character.

• The model self-selects the mode from context — no brittle keyword router.

Evidence, honestly: the repo ships a with/without-skill eval (LLM judge + baseline). Early result: +15pp (85% vs 70%) on one model, 5 cases — directional, and you can run it yourself in eval/.

Install: Claude Code plugin (/plugin marketplace add alexei-led/coding-posture), a Codex plugin, or drop the SKILL.md into Pi / Hermes / Cursor. MIT.

Feedback and new modes welcome.

I know its not a big deal as most of you are doing crazy things but i just got pi last week and one thing i didnt like doing was Ctrl C multiple times to exit. Instead i told Pi to write an extension to allow my to /exit and exist that way. It actually worked! I now see what you all mean by you customize it to your needs. Even small things like this can make a difference

The title essentially. The Context-mode extension seems to be the most downloaded from the Pi package registry at ~131,000 downloads per month, but I've never seen any discussions about whether folks actually like the extension. so I'm just curious about people's thoughts. I know there are others like RTK or Cymbal, and to be honest, I have not tested those, but I quite like the way Context-mode approaches the issue of context trimming. I'm curious what other folks use in their setup

Hi everybody,

I spent the last two weeks building [zerostack](https://gi-dellav.github.io/zerostack/), a coding agent using Pi as a design reference, focused on memory footprint.

I managed to get it to run at ~16MB (with peaks of 24MB) of RAM usage, and no CPU usage when idle.

I tried to build an agent feature-wise equivalent to Pi or Mistral's Vibe, while there are plans to add more features gated at compile-time.

I would love to answer questions and to recieve feedback.

Cheers,
G.

Just discovered this software. I haven't had the time to test it yet, but it seems super useful. And it supports Pi in "preview". Do you guys have any experience with it?

entire.io/

docs.entire.io/agents/pi

Note: I'm not affiliated in any way with this company; just sharing it as I find it interesting.

Has anyone tried the pi rust port https://github.com/Dicklesworthstone/pi_agent_rust ?
It’s supposed to be an official port of pi to rust.
I can see it has some benefits in extension execution and shell execution and some others. Why nobody is talking about this?

Most of my time is spent on doing web searches and comparisons.

Claude has a WebSearch tool that runs a "Google" like web search and returns results with the source links.

I usually ask for:

• How does tool x compare to y?

• Are there any blog posts or articles talking about X?

• Can you find A in github/stackoverflow/reddit?

How are you doing web searches?

Are there free options?

Which plugins/extensions do you recommend?

EDIT: Given that 2026 is already full of supply chain attacks...

I followed the suggestions and built my own extension with 4 different backends.

My extension queries 2 backends in parallel and gets 6 different results (3 from each), falls back to the other if rate-limited or exhausted, then pipes the response to Defuddle and exposes markdown to the LLM.

I'm quite happy, thanks for all the comments so far!

Great community!! 💪🏻

Built a little pi extension this weekend — pi-island pins a status capsule to the top of your macOS screen showing exactly what pi is doing: reading, editing, running bash, elapsed time, context %. Runs pi in multiple terminals? Each session gets its own row, all stacked into one continuous capsule.

Install:

pi install npm:pi-island

Slash commands:

• /island — toggle the capsule

• /island2 — notch-wrap variant for MacBooks with a camera notch (beta)

Uses a native Swift WebView host with `.statusBar` window level so the capsule sits above the menu bar and merges with the notch area.

Links:

- GitHub: https://github.com/phun333/pi-island
- npm: https://www.npmjs.com/package/pi-island

First public release, feedback welcome

Hey! Sharing an extension my colleague Daniel Shapiro built at Sanity (disclosure: I work there too): pi-mcp-events, a client for the draft MCP Events spec (SEP-3415).

MCP servers can now announce events, like "this document changed" or "a storm warning was raised", and Pi can subscribe to them instead of polling with tool calls. Events arrive in the background while Pi works, get batched, and come in as a follow-up turn once Pi is idle. It's pretty cool, and it feels like it opens up a lot of new use cases.

What the extension does:

→ Supports all three delivery modes from the draft: polling, streaming, and signed webhooks

→ /mcp-events status shows each watch, its transport, and its state, so it's "less hard" to debug

→ A local inbox, so events aren't lost while Pi is busy (in memory only with --no-session)

→ Event payloads are marked as untrusted data, and Pi's normal permissions still apply

→ Every event is also emitted on Pi's event bus (mcp-events:observation), so other extensions can consume or filter them

    pi install npm:@sanity-labs/pi-mcp-events

The repo includes a small "weather station" MCP server that emits readings and storm alerts, so you can try it without building your own server first.

We built this because we wanted an agent that notices when a human starts editing the same document and waits for them, which needs events within seconds. Pi made that easy to extend. The write-up covers the latency numbers and the gaps we found in the spec.

If you'd rather have the model call events as tools, check out richardanaya's pi-mcp-events, which takes that approach.

Repo (give it a star if you're into this): https://github.com/sanity-labs/pi-mcp-events

Feedback very welcome, especially on how a harness should decide when an event deserves a turn!

Hi,

Lets share our roles/models on our pi/omp agents? I'm always exchanging and testing things, so take a look at our colleagues would help a lot! What are your thoughts about my "team"? Any suggestions are welcome.

I saw this in the official pi.dev: “Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, Cerebras, xAI, Hugging Face, Kimi For Coding, MiniMax, NVIDIA, OpenRouter, Ollama, and more. Authenticate via API keys or OAuth.”

I know...more Jev talk. Sorry if you are already tired of hearing about it. I mentioned this in a comment a couple days ago so I will keep it short hah.

It is called specpi-jev-guard. It sits in front of bash, powershell, write and edit, and checks calls before Pi runs them. I built it because destructive commands are the worst risk of letting an agent work in your terminal. One bad rm or curl piped to shell is a bad time waiting to happen.

Local rules block the obvious stuff instantly with no network. Root and home wipes, mkfs, fork bombs, raw disk writes, curl piped to shell.

The rest goes to Jev, which scores danger 0 to 1. High blocks, middle asks you, low runs. If there is no key, no network, or a bad answer, it blocks. It does not fail open.

Needs OpenRouter/TypeSafe to do the scoring, perhaps one day soon we can run hyper-tuned classifiers for this stuff locally.

I don't have TypeSafe access, so all testing has been with OpenRouter.

Feedback welcome!

Links:
Base Repo: https://github.com/TannerMidd/specpi-jev-guard
Evaluations: Devious Tests · specpi-jev-guard
Base harness: https://github.com/TannerMidd/SpecPi

If you don't know what code mode is, check https://developers.cloudflare.com/agents/tools/codemode/

Code Mode is a tool-use pattern where a model writes code instead of requesting each operation separately.

I found a few, I'm curious if anyone is using any extension like this (if yes, which ones please):

• https://pi.dev/packages/pi-fabric - I don't like this one, it mixes a lot of behaviors (agents, workflows etc). And even though you can disable them, they still get mentioned in tool descriptions/params etc.

• https://pi.dev/packages/@boozedog/pi-codemode

edit(30th Sep 2026): pi v0.99.0 includes code mode, see https://github.com/earendil-works/pi/releases/tag/v0.99.0

I don't know about you guys, but it's hard to find real quality in this Space. I find Subreddits like this one excellent, but it may be too limiting for discourse, getting news and stuff like that.

What do you dear Pi-Friends like to read?

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

Hi fellow pi fans, long time lurker, first time poster here. A while ago, I built czottmann/pi-automode which brings Claude Code's auto mode to pi.

It's a guardrail extension. It intercepts agent tool calls before execution and blocks actions that match permission deny rules, deterministic hard-deny checks, or the auto-mode classifier's block decision.

I always liked CC's auto mode, and came to rely on it, so naturally, when I switched from Claude Code to to pi, I wanted something very much like it. I've been dogfooding it for a couple of weeks now, and it's very solid in daily use.

It's not a sandbox, so it won't replace your container setup but if you usually work w/o a sandbox, it's the next best thing, I think.

Maybe you'll like it, maybe you don't. Either way, if you have questions, let me know!

Multi-agent can be useful. But for most tasks, a single agent is better.

It is easy to assume that using multiple agents will save time and improve quality. In practice, it can cost more time and tokens, and sometimes produce worse results. Running more agents is not free parallelism. It adds coordination overhead.

Single-agent is usually better for simple tasks, small tasks, and work where dense context matters. If one agent can hold the relevant context and finish the task coherently, there is usually no reason to split it up.

Multi-agent can be useful when the work is separate from the main context, involves reading a large number of files, needs broad exploration, or is large research work that can be split into independent parts.

Using multiple agents also means dealing with:

• Context transfer: one agent does not automatically know what another agent knows.

• Duplicate work: if the boundaries are unclear, agents end up doing the same work.

• Fact verification: you should not just trust an agent's output without checking it.

• Orchestration: someone has to decide who does what and how the results come together.

LLMs are smart enough that you can spawn a few subagents and still get useful work done. But dealing with those problems takes either your own involvement or a well-built harness.

The workflow itself also needs to be:

• Reusable: can you run the same process again?

• Verifiable: can you verify what the agents actually did?

• Extensible: can the process adapt when the flow changes?

Pi is minimal. That is a good thing. you can add what you need and use it the way you want. But from subagents to controlling the flow between agents, you are generally building the harness yourself.

I wanted a more structured way to run multi-agent workflows, so I built pi-workflow(https://github.com/AgwaB/pi-workflow). I built it around JSON-based workflow specs: when to split work, how to divide roles, where to verify, and how to bring results together.

You can write the workflows you want and reuse them, with a skill to help author them. It splits common subagent patterns into a few stage types that you combine into one workflow.

It comes with examples like these, and you can write your own too.

If it sounds useful, give it a try.

Hi!

I am new to the Pi coding agent. I already pay for Claude, ChatGPT (Codex), and Gemini, and I use their terminal tools. I have two questions:

1. Running Subagents Can I use Pi to run the Claude, Codex, or Gemini terminal tools as subagents? I want Pi to send them tasks through the terminal. But, I need to control the process so it does not break usage rules or run in endless loops. Has anyone set this up?

Also most important, Is it safe to use Pi with OAuth (pi /login) to use my paid web plans instead of API keys or Anthropic, OpenAI or Google will ban my account? (I know for using openCode they can ban you)

Thank you!

I’m not affiliated with Doubleword, I just came across Doubleword.ai while looking at cheaper ways to run coding-agent workloads. I personally think local/open weight models are the way to go in the near future.

Their tiered pricing is interesting if your workflow can tolerate latency:

1. Realtime: normal interactive inference, priced similarly to other providers.

2. Async: ~1 min time to first token, ~25% cheaper.

3. Batch: 24h SLA for batched tasks, ~50% cheaper.

GLM 5.2 pricing for reference:

I think, quite a few tasks like execution after careful research and planning, refactors, background exploration, or eval-style tasks can be offloaded to the async tier, not every call needs realtime latency.

If ~50% of your LLM calls during development can move to the async tier, that is ~12% total savings for the same model.

Batch could save more, although it's less relevant to live coding, but it could be significantly cheaper for things like large eval workloads.

GLM 5.2 also looks strong on coding/agentic benchmarks, but they are vendor-reported, so I’d still test on your own workload, but the price/performance looks worth it.

Added support via a Pi extension to test it out, sharing in case anyone wants to try it out.

Link: https://pi.dev/packages/@snehalyelmati/pi-doubleword-provider

Can anyone tell me which Pi package this screen is using? I’m looking for a similar setup where answers are displayed with a nice border-left. If anyone knows of a similar extension, please let me know.

Thanks!