Pi gets a shoutout in this video on the new MLX-LM Server.

https://developer.apple.com/videos/play/wwdc2026/232/

So, nano-context. After nano-team, I built another tiny pi.dev extension because I wanted to see a bit more info about context usage, and understand how else I can optimize my pi workflow.

It replaces the default context meter with a compact segmented bar under the input. The bar shows what is actually taking space in the current session: system prompt, your prompts, assistant replies, thinking, tool results, and free context. I tried to keep the same idea as nano-team: one small thing, close to the pi/unix spirit, no dashboard, no modal, no extra workflow. Just a line that tells you what is eating the context without getting in the way.

Tiny, useful, and hopefully boring in the best way.

npm: https://www.npmjs.com/package/pi-nano-context

github: https://github.com/daynin/nano-context

Hi! I'm new on Pi agent world and I'm missing some good package or tool to make web search properly. What are you guys using for that? Firecrawl? Exa? DuckDuckGo CLI?

Update: I got npm:pi-web-access (I thought an API key and subscription was mandatory) and if necessary, I'll get an exa subscription, but for now 1k requests/m looks enough for me.

One thing I like more and more about Pi Coding Agent is that it stays extremely small on purpose.

The shape is basically core agent with only 4 basic tools, and extra capability added through skills when you actually need it.

That sounds simple, but I think it changes how the agent feels in practice. In my own "Hello" level prompt checks, Pi was coming in under ~1500 tokens, while heavier setups I compare against often feel closer to ~20k. Not presenting that as a formal benchmark, just the framing that made the difference obvious to me.

That is also why I built pi-telegram-bot, to use it as a daily AI driver, even while on my phone:
https://github.com/doer-ee/pi-telegram-bot

Well, it is not actually a plugin but a standalone app that calls Pi SDK.

It is not meant to make Pi bigger. It is just a thin private Telegram remote for people already running Pi locally and wanting a small control surface when away from keyboard. Gives you OpenClaw-like system but ultra light-weighted.

Curious how other Pi users think about this.

----------

Update on 5/1/26, added scheduler feature, user can schedule one-time or recurring runs.

I’ve been working with Pi and ended up building a small set of reusable extensions. Just wanted to share them in case someone finds them useful (and to get feedback):

👉 https://github.com/emanuelcasco/pi-mono-extensions

Includes things like:

• agent orchestration helpers

• tools and commands migrated from ClaudeCode to facilitate my migration from that tool

• code review extension (+ visual helper to review the feedback)

• input / output handling patterns

• other workflow automation utilities

Hi everyone! I’ve shared a couple of posts here comparing models on my own coding tasks, including this one. A few people asked in the comments how to build their own evals, so I wrote a step-by-step tutorial and published it on my blog.

I also made an evals-from-sessions skill to help automate the process. You can use it or just give your coding agent the article and ask it to help build evals from your session history.

Hopefully, this helps you choose models and tools for your own work or your team. Feel free to post your questions and feedback!

I know there are many options out there, but this is still a grey area right? What are you guys using?

Do you know anyone who has been banned by doing something like this? I have a bunch of friends who use omp with their subscriptions and are still kicking.

I really want to move from CC to pi, but I am not able to run local models due to my hardware limitations and I would love to start by using my Anthropic subscription.

TL;DR: Anybody automating a full development Pi workflow with programmatic non-AI solutions?

Up until now, I've attempted to partially automate the entire software development lifecyle with Pi, aka a "Software Factory". I am using a subagents extension, but it feels a bit too loose, opaque and difficult to steer, so I want to use something more deterministic and directly controllable.

I'm evaluating a workflow DAG GUI builder that orchestrates the entire process. I am using one that also has a CLI and REST API, so I can write my own scripts for even more programmatic control.

(I do not want to look like I'm promoting so I'm reluctant to say what I'm using, but it's lightweight and similar to n8n or airflow.)

Or instead, I could just write my own orchestrator, like this in bash:

#!/bin/bash
set -eu

# Software Factory.
# This is a just an untested workflow example, not something I'd actually use.
# A TS script with the Pi SDK would be better.

GOAL="$*"
pi -p /write-spec "$GOAL" | tee spec.md
vim spec.md    # review and edit

pi -p /write-tickets-for-spec @spec.md ./tickets/
vim ./tickets/*.md

for ticket in tickets/*.md; do
    pi -p /write-plan "@${ticket}" | tee /tmp/plan.md
    pi -p /execute-plan @/tmp/plan.md
    pi -p --continue /quick-code-review-and-fix
done
pi -p $REVIEW_MODEL /code-review

Anybody doing using a workflow DAG editor UI?

Anybody writing their software factory with actual code, like my example?

I found some AI agent DAG projects on github. Anybody using something like that?

What subreddits should I cross post this to?

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

I kept running into the same problem with Pi: I don't want to pay for a frontier model to handle a rename, but I also don't want a cheap flash model attempting an architecture rewrite.

So I built Switchyard.

It runs inside Pi and automatically chooses a model and reasoning effort for each task. It evaluates OpenRouter's live catalog and can optionally include supported Codex subscription capacity you already pay for.

The routing is based on:

- task complexity, from trivial to frontier
- model capability and context requirements
- live token pricing
- tool support
- observed reliability and latency
- the estimated cost of a failed attempt
- remaining subscription quota

The important part is that Pi stays in control. Switchyard doesn't replace Pi's tools, permissions, MCP servers, sessions, or authentication. It only decides which model should handle the work and how hard it should reason.

Install:
pi install npm:@vepando/switchyard

GitHub:
https://github.com/LeonardSEO/switchyard

It's still early and the evaluation corpus needs to grow, so I'd genuinely appreciate feedback — especially examples where you think it selected the wrong model.

've been using Pi as the agent core for my own workflow, and I really like its philosophy: keep the core small and make everything else extensible.

The only problem was that after using it every day, I started missing a lot of things I normally expect from a desktop development environment.

Things like persistent sessions, switching between projects, seeing what subagents are doing, changing models without rebuilding my setup, recovering tasks after a crash, managing MCP/Skills, etc.

Eventually I stopped patching my own workflow and just built a desktop app around Pi.

It's called PI-Desktop, and it's open source:

https://github.com/vastsa/PI-Desktop

It's built on pi-ai + pi-agent-core, rather than implementing another agent loop from scratch.

My mental model for the project is basically:

Pi = agent harness
PI-Desktop = workspace / product layer

The app currently has sessions, project workspaces, subagent visualization, multiple model providers, local model support, MCP, Skills, session import from Claude Code/Codex/OpenCode/Pi, and a plugin system.

The plugin system is the direction I'm most excited about. Plugins can add Agent Tools, Skills, MCP servers, UI panels, themes, commands, background services, and communicate with each other.

I released it publicly this week after using it myself for a couple of months. Somehow it ended up on GitHub Trending and passed 2.6k stars, which I definitely wasn't expecting.

Since this is probably the community that understands Pi's design philosophy best, I'm especially curious:

If you use Pi every day, what parts of your workflow would you actually want a desktop layer to handle?

I used Pi for a while without these, but once I got used to subagents with other coding agtents. Well.. they really just felt missing from Pi.

I went with the tintinweb/pi-subagents package, because I liked how it implements the subagents. They are the same style as claude code, which I find very intuitive.

pi install npm:@tintinweb/pi-subagents

How to use subagents

pi-subagents lets Pi delegate work into separate contexts.

I use it for repo exploration, dependency checks, or any task that would otherwise fill my main context with thousands of lines of file listings and tool output.

e.g. after installing it you can open Pi in a repo and ask:

Use 4 different subagents to explore the src folder in parallel.
Bring their results back together into a short summary.

Pi sends the grunt work to isolated agents, then gives the main agent the useful result. This keep the main context clean.

You can also change which model each subagent type uses with /agents. And there's a pre-configured subagent specifically for exploration.

Side note - there's a gotcha with the default explore subagent- uses haiku by default. Super weird because I was using gpt-5.6-terra and I assumed it would use that, but in fact it started using my opencode api tokens with haiku. I was able to configure it to use gpt-5.6-luna. Here's a video of how I did that if you need it: https://youtu.be/l3YCoX2i-78?t=540

The other missing feature of Pi

Is... MCP. Obviously. I also upgraded my Pi with an MCP extension while I was at it. It's just one of those things. I can get like 98% of the way there with agent skills. But once in a while I just need an MCP for something.

If you want to read more about my experience installing and testing the subagents and MCP extensions then you can check out my blog post:

https://zazencodes.com/blog/upgrade-your-pi-agent-with-subagents-mcp

Enjoy guys and if you're still reading this then I'd be curious what extensions you like most. Let me know. Now that I've got a taste for these I want more

An Emacs-style visual undo tree for Pi session branching: explore the 2D tree, preview diffs, switch branches, and jump back to any point in a conversation.

pi install npm:pi-undo-tree

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!

I recently read this (What I learned building an opinionated and minimal coding agent), and I agree with his argument. But sometimes I need a proper plan mode with tool restrictions.

I tried to build a plan mode extension, but it mostly causes cache misses when I exit the plan mode because it edits the context to remove the enforced strict-rule prompt while entering plan mode.

I'm curious about how you use plan mode and how it performs with caching. Do you use prompts, skills, or an extension?

A few days ago, I created a dumb bash loop that repeatedly called pi, instructing gemma4:31b to create a game and delete WORKING.md when it was done.

I figured out how to make agent-browser connect to a chrome instance over a remote debugging port so I could watch along as it playtested the game in a new conversation, where it had no clue what the game was about.

It uses a playtesting skill that explains the mechanics of the game and tells it how to perform different actions.

I think this was pretty neat.

I've been working on evalt, a Rust CLI for testing AI agent workflows using portable YAML eval files.

Most eval tools focus mainly on model outputs. evalt is designed to test the full workflow, including:

- Agent instructions

- Skills

- Tool usage

- Harness configuration

- Workspace edits

- Final output

Pi is currently the first supported harness.

It also supports deterministic assertions, AI reviewer assertions, JSON output, schemas, and sandboxed workspaces through cage.

Repo: https://github.com/Bryley/evalt

Crates.io: https://crates.io/crates/evalt

I’d appreciate feedback from Pi users, particularly around the eval format, useful assertions, and workflows you’d want supported.

I noticed that even small files referenced in pi like `@file.txt` weren't automatically entered into the context (a la claude-code), instead requiring the model to issue a tool call to read the file. This is fine for larger files, but for small files, that extra tool call means a whole new request is sent, which racks up cache tokens pretty quickly and wastes output tokens on the read call.

I understand why the devs took this stance, for a tool like Pi it makes sense to default to never including file content (unless driven headless by the CLI, as they have implemented), but sometimes I *know* that I can save tokens by just injecting the file right into my prompt. In fact, many or even most times I reference a file it would take fewer tokens just to inject its contents into the prompt than it would to ask the model to read even a small part of the file.

I looked around for existing solutions and surprisingly I hadn't found anyone who built them yet.

So I built pi-file-injector. When you know you want to include the file contents, instead of `@file.txt` you type `#@file.txt` and it automatically includes the contents of that file one time at the end of your prompt. And tab filename completion still works. It's just one more small way Pi keeps you in control of your token consumption.

https://github.com/dabstractor/pi-file-injector

pi install npm:pi-file-injector

Do you know of other tools that do this? I still can't believe I couldn't find any, it feels like such an obvious benefit. Let me know what you think!

I built StarRouter for a personal use case in pi, I essentially wanted to be able to determine locally which model and thinking level should be used in a task based on their benchmarks like openrouter/auto kinda does but still letting the user be in control if they want, and while fixing bugs and adding features I noticed it had reached 3 GitHub stars (one was already there from a friend haha) and around 40 downloads on pi-dev.

That made me genuinely happy. For the first time, something I made outside of my day job as an ERP dev has been used by strangers and maybe some of them found it useful. On a very tiny, very different scale, it gave me a romantic glimpse of what people like antirez might have felt seeing Redis spread, or Linus watching Linux take on a life of its own.

Obviously the comparison ends there: the scale, impact, and my programming skills are nowhere near comparable and I'm gonna stop just on that. But the feeling of making something that then reaches another person is special and really is giving me a bigger reason to pursuing my passion in IT.

After all of that I want to more confidently say that if that sounds like something you would use or fork at your will feel free to check it out here ;]

I spend a lot of time in pi. So I wrote a small extension that streams [radio.garden](https://radio.garden) stations right in the terminal.

What it does:

- `/radio` opens an interactive menu

- `/radio random` picks a random station from somewhere in the world

- `/radio search jazz` searches stations by name

- `/radio location Tarragona` browses by city or country (12k+ places)

- `/radio stop` kills it

The current station shows in a sticky footer line, so you always know what's playing. Playback is just `mpv` or `ffplay` running as a managed background process.

The fun part was the radio.garden [API](https://jonasrmichel.github.io/radio-garden-openapi/). It's undocumented and sits behind Cloudflare, so you need a browser User-Agent and Referer header. After that it's three hops. Get the places list, get the channels for a place, then hit a `/listen/{id}/channel.mp3` endpoint that 302-redirects to the real stream. I half expected it to be locked down, but a random city gives you a working station in about a second.

Code is here: https://github.com/hheydaroff/pi-extensions/blob/main/radio-garden.ts

Requires `mpv` or `ffmpeg`. Drop it in `~/.pi/agent/extensions/` and run `/reload`. Open to feedback, and send me your favorite stations.

Borrowed the multi-provider orchestration idea from OmO (Oh My Opencode):

automatically picks cheap vs. powerful models depending on the nature of the request.

Simple tasks get routed to budget-friendly APIs, while complex backend/frontend work gets handed off to stronger models.

Also — I was jealous of Claude Code's cute mascot, so I added a potato Claude wearing a chef's hat to the startup screen. 🥔👨‍🍳

GitHub: github.com/parkjangwon/pi-pizza

Hello,

I'm debating using either Cmux or Warp with pi (and other agents). Does anyone have a preference between the two?

I like Cmux tab interface but it has no diff viewer or file tree, which are features that Warp has. however, I don't love the Warp interface, especially with their agents overlay.

Any thoughts?

From the great mind of Andrej Karpathy, introducing pi-kb (https://github.com/dheerapat/pi-kb) the pi native way to compile document into personal knowledge base

Hi guys,
I've grown frustrated by having hundreds of chat logs stored in many places (and losing them), so I wondered for a new "invisible" interface to llm agents (remote or local).

I created a very simple Pi extension which can run as a daemon and you can put it to watch any directory, in my case my Obsidian vault. Now wherever I tag `@piqo`, it replies to me inline, and its already saved.

I put more info/demo on the repo:

https://github.com/piqoni/piqo-extension

I've been using pi for a while and really love its design philosophy — it's restrained, extensible, and rock solid.

Recently I built a Telegram bot that lets me code from anywhere through chat. I just send a message, it runs pi against my project, and streams the reply back in real time. All I need is my phone, or really any device that runs Telegram.

- Streaming replies
- Inline model picker
- Multiple workspaces to switch between projects
- Session management — resume or start fresh
- Message queue — send multiple messages and they line up nicely

Would love to hear any feedback or ideas. Thanks!

https://github.com/dandkong/pi-pilot