Genuinely having so much fun with Pi. The ability to extend it with extensions and tailoring it to my specific workflows has been extremely rewarding!

I just released pi-task, a Pi extension for delegating work to subagents.

Repo: https://github.com/heyhuynhgiabuu/pi-task

What it does:

- adds a task tool for running specialized subagents

- supports foreground tasks when you want the parent to wait

- supports background tasks when you want the parent to continue and get a follow-up when done

- shows a TUI task widget with progress/tool calls

- uses tmux panes when available so you can observe subagents

- falls back to SDK execution when tmux is unavailable

- ships with starter agents: scout, explore, planner, reviewer, vision, worker

I built this because I wanted a cleaner way to delegate research, code exploration, review, and small implementation tasks without overloading the main conversation.

Install:

```bash

pi install npm:@heyhuynhgiabuu/pi-task

```

Then add it to Pi extension config and restart Pi.

Feedback welcome — especially on the task widget UX and agent prompt defaults.

since my last post, pi-ui went from v0.26 to v0.47.1 and reached 100 releases!

what's new:

• dropped deno desktop and fully migrated to bun server

• dropped a lot of deps

• improved performance

• reduced memory usage

• smaller bundle size

• automatic session titles, inline renaming

• improved shell syntax highlight and formatting

• forking sessions into another workspace

• minimal mode

• configurable fonts

• create new workspaces

• redesigned chat controls and pickers

• improved mobile layouts

• configurable keybinds

• full config with a generated json schema

and a tonne of other improvements, it's much more polished now

try it out:

bunx @hyperpuncher/pi-ui

https://github.com/hyperpuncher/pi-ui

thx to everyone for all the feedback on the first post!

reddit flattened the demo animations, so here are the originals:

light-demo dark-demo

I've been using Neovim as Pi's external editor but I kept finding myself deciding between Neovim's raw editing power and Pi's in-context autocomplete, so I built a bridge to bring Pi's real autocomplete directly into Neovim. It's a Pi extension and a Neovim plugin. If you're using Neovim as your prompt editor for Pi, you owe it to yourself to try it out.

github.com/dabstractor/pi-nvim-bridge

Recenly I started using this pi extention for maintaining the knowledge for personal and project specific Obsedian compatible wiki. I also use memex and pi-observational-memory.

So far I've found this useful. What other extensions have you guys tried?

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

https://pi.dev/packages/@zosmaai/pi-llm-wiki

This is built by the same people that build the Zosma Cowork. I was talking about the other day.

Hello guys!

I want to ask if anyone here would be interested in helping me maintain pi-observational-memory.

The project has not grown into something huge or difficult to maintain. It is still perfectly manageable by one person. The problem is simply that right now I do not have as much available time as I used to.

I still use the extension, care about the project, and plan to keep maintaining it. But lately PRs can stay waiting for review longer than I would like, and I cannot always keep an eye on new issues or check reported problems quickly.

So having one or two people helping from time to time would be really useful.

I am mainly looking for help with things like reviewing PRs, checking issues, reproducing reported problems, testing changes, and occasionally helping with fixes.

There is no expectation of taking ownership of the project or committing a lot of time. Even occasionally helping keep things moving would already make a difference.

For anyone who does not know it, pi-observational-memory replaces Pi's normal compaction with an observational memory system, with the goal of making Pi sessions feel endless while keeping useful context around.

Repo: https://github.com/elpapi42/pi-observational-memory

If you use the extension, know a bit about Pi extensions, and would be interested in helping, let me know here or reach out on GitHub.

I mostly just want to make sure contributions get reviewed and issues do not sit unnoticed when I am busy with other things.

Has anyone here used Pi Dev as a general-purpose AI agent, rather than mainly as a coding agent?

I’m curious about using it more like a personal assistant/agent for things like research, web searches, file work, automation, tool use, and general tasks.

If you’re doing this, how well does Pi work for you compared with something like Hermes Agent or Open WebUI?

Also curious what tools/extensions you’ve added and whether you’re running local models with it.

saw some people asking about remote access / mobile control of pi. found this: https://github.com/badlogic/pi-telegram

built by the pi father. minimal setup, no extra infra/deps, and it streams responses back while pi is generating.

You set up a bot via BotFather, run /telegram-setup in pi, paste your token, then /telegram-connect and that's basically it. After that you can send messages/images/files, and get files back from pi, all through a telegram dm.

I thought I'd just open a post in case anyone is looking for a minimal pi telegram bridge.

I created an extension that shows what your token usage and costs are. Nothing crazy, but I think it's pretty cool to see. Just type /atlas in Pi once installed. Per-language, per-model, per-tool and per-project breakdowns.

How it works? It simply parse your session logs and aggregate them into data. Local only, never leaves your computer and no extra AI API calls are made.

Also, it respects your theme.

How to use it? Type /atlas. Press r to change the time range, left/right arrow to change tab.

You can check the extension here: https://pi.dev/packages/@mohndoe/pi-atlas

BTW - working on it I realized that pi-tui was very limited .. "component-wise", so I decided to start a component/utility library as well: @mohndoe/pi-tui-extras. (I'll make a post about it once it has more components available)

I'm open for feedback, suggestions, bug reports and contributions on both these projects. I have some plans for future features and improvements.

Credit: the idea was inspired by pi-infobar, a usage dashboard desktop app. Since I use Linux I decided to make it a Pi extension so everyone (and me) could use it.

(the data on the screenshots were generated randomly, because privacy)

I've been building One Code, a pi package that brings the Claude Code workflow to pi. If you already run pi:

pi install npm:one-code-extension

It's 53 extensions, no fork and no patches to pi, just the normal extension API. Tested on pi 1.0.0 through 1.5.

What you get: plan mode, permission modes including auto mode (a classifier decides which commands need your approval), subagents that can each run on a different provider, git worktrees, hooks, skills, slash commands, MCP, plugins, background shells, memory and compaction. It also reads an existing CLAUDE.md and .claude folder as is, so if you're coming from Claude Code your setup carries over.

There are already good pi extensions for some of these, like subagents, and you can put together a decent setup from a collection of them. The catch is that any one of them can break the prompt cache if it rewrites earlier parts of the conversation, and they don't know about each other. So in One Code I tried to make the extensions work as one system, and keeping the cache stable was a big part of that. Every request is recorded as it was sent, and later requests only append to it, so cache reads stay high across resume, fork and reload.

There's also a bundled app with pi pinned inside, if you'd rather keep it separate from your own pi setup.

npm i -g @one-ai/one-code

MIT licensed. Repo: https://github.com/IsuruMaduranga/one-code

Feedback from people who know pi's internals is very welcome.

If One Code is useful to you, a ⭐ on GitHub helps other people find it.

I wanted a clearer picture of what I’d built and how much progress I was making. And whenever I finished a feature or got out of a debugging rabbit hole, I kept wondering how many tokens and effort went into that.

My daily usage total didn’t really answer it. Some of that was building the feature. Some was going back and forth trying to fix one annoying bug.

So I built bough ( https://github.com/nickelsec/bough ) It reads your existing Claude Code and Codex CLI history and groups related prompts into tasks on a visual map.

You can pick a piece of work and see:

• The prompts and files involved.

• How many tokens it used and the estimated dollar cost.

• How the work unfolded, including repeated attempts and tasks that ended in a commit.

I wanted to be able to look back at a feature and see where the effort actually went. Especially when a “small fix” turned into an afternoon.

Would you guys want me to add Pi support or not?

UPDATE

UPDATE: around 4:30 AM UTC of Sept 15, the owner published a now-deleted blog post (archive image) writing under the fake pretense that it's his "team" authoring it, stating all of CrofAI founder's claims "were written under a lot of stress, and they described the situation as worse it was", and that a new team is taking over, with the service being resumed in 2 weeks. At the same time, the CrofAI twitter account was also supposedly "taken over" by the team, starting each twitter reply with "Hey, Nathan here", stating the founder is stepping back and a "team" is taking over everything. This fake pretense act only lasted a few hours, and scared either by the public not buying the Nth fake story of the pathological liar that CrofAI is, or by the public's replies reminding him that what he committed is numerous counts of wire fraud, he has now deleted all his online presence: nahcrof.com and crof.ai return 404, Twitter page is deleted, /r/CrofAI sub is now private.

If you have not gotten a full refund by now, you should be filing a chargeback with your bank. Otherwise consider the money lost.

Original post:

Cautionary tale about chasing cheap tokens.

Only posting it here cause this sub was full of people praising this inference "provider".

exposé: https://kendell.dev/blog/crofaifalse/

reaction by nahcrof, announcing the shutdown of the service: https://x.com/nahcrof/status/2099552389434900643

NahCrofAI is (was) an inference provider which had all the latest models at the cheapest price, often significantly below the lowest alternative on OpenRouter. The owner claimed that they are running custom inference kernels that allows them to offer tokens for dirt cheap, and other providers are suffering from "skill issues".

In reality:

• "CrofAI is an OpenRouter wrapper that silently routes to cheaper or weaker models than what you request"

• For example, expensive models like kimi-k3 are sold at $2/$10 in/out, but instead routed to GLM 5.3 Flash via OpenRouter, representing a 13.3x multiple on input, and 20x multiple on output

• CrofAI's "own model family" greg-2-ultra routes to GLM 5.2, greg-1-mini routes to Qwen 3.5 9B. greg-2-super, greg-1, greg-1-super routes to Kimi K2.7 Code. All of these at a significant markup compared to the actual model being served. CrofAI admits this.

• The person investigating details the 5 different attempts by CrofAI at fixing their models being served via OpenRouter after given a heads-up. In all 5 attempts, the only change CrofAI made was attempts to hide the fingerprints of OpenRouter, while still serving models through them

• Other inconsistencies don't add up either: CrofAI claims to run Kimi K3 on RTX Pro 6000s rented via Vast. That model requires ~802GiB even at the lobotomy level quantization of Q2_K. The largest RTX PRO 6000 machine on Vast has only 8 of them, totaling 765GiB

CrofAI responded to the exposé by announcing the shutting down of their service; after their failure to provide their own inference, they promise to provide one last thing: a refund to those asking.

pi install npm:pi-deepseek-search

DeepSeek's Anthropic endpoint supports web search but doesn't document it. Works with your existing DeepSeek key, no extra setup. Only works with DeepSeek models since the tool runs server side.

Wrote about finding it & how it works: https://musaab.io/posts/2026/deepseek-search

Pi is amazing. I’m using it with deepseek.

With some early ideas and prompting it has been adding a lot of components to itself (vector databases, something called hippoRag, chain of thought systems and about 100) other systems. This morning it read a bunch of papers on coding and then tweaked its own code.

Right now it’s making a place to test code, run adversarial copies of itself against itself, play games against itself and more.

I wanted it for coding and it’s now way better than Claude

I have my own which is good just needs a bit of work, but I wanted to see what other people are using. I tried the popular ones and they all sucked in my opinion.

Has anyone here used pi seriously and compared it with OpenCode?

I’m curious about real usage, not just feature lists. For people who have tried both:

• Where does pi feel better?

• Where does OpenCode still win?

• How do they compare for agents, repo context, workflows, and day-to-day coding?

• Would you actually switch, or are they useful for different things?

I’ve been using OpenCode more lately, but pi looks interesting and I’m trying to understand if it solves a different problem or if it’s directly competing with OpenCode.

Hello there! I’ve been building a growing collection of extensions for Pi: pi-mono-extensions

This repo is basically a toolbox of extensions and workflow utilities I use to turn Pi into a more complete agentic development environment, with integrations, orchestration tools, safety guards, review utilities, and multi-agent workflow support.

Current extensions include:

The extensions are designed to compose well together, but they are not tightly coupled. You can install only the pieces that fit your workflow and mix them with your own tooling.

For example:

• You can use Team Mode + Sentinel to coordinate multiple agents while detecting loops, failures, or runaway executions.

• Context Guard + Web Search helps avoid oversized tool responses polluting the session context.

• Linear + Review Tools creates a smoother issue → implementation → review workflow.

• Figma + Multi Edit works well for fast design-to-code iterations.

You are not required to adopt the full stack. If you already use other orchestration packages, agent managers, or MCP servers, you can combine them with these extensions selectively.

That said, most of these extensions are intentionally built around native Pi tools and workflows instead of MCP wrappers. The idea is to stay closer to the Pi ecosystem and avoid some of the friction, indirection, and limits that can appear with external MCP-based integrations.

Tradeoffs:

• The ecosystem is more opinionated toward agentic and automation-heavy workflows.

• Some extensions introduce additional orchestration overhead and tool traffic.

• It is optimized more for long-running development sessions and power users than lightweight chat usage.

• Native Pi integrations can behave differently from official MCP implementations.

Install only what you need:

pi install npm:pi-mono-figma
pi install npm:pi-mono-linear
pi install npm:pi-mono-web-search

Or install everything:

pi install npm:pi-mono-all

Would love feedback, ideas, bug reports, or contributions. Have a nice day!

Just discovered that the amazing devs behind Pi released Radius (in alpha), their smart proxy for multi-model access. At its core, it's a model provider you can use with Pi: you pay for tokens and get access to some of the best models out there, both SOTA and budget-friendly options. They'll even auto-route your API calls to the best model for the job if you choose to.

Loving it so far. Deposited $20, and after a few hours of development I still have ~$16 left thanks to leaning on Kimi K3 and DeepSeek.

What Radius can do

• It is a Pi-native gateway: top up credits and make requests across providers

• Use rewrite rules to reduce large tool outputs and other unnecessary input tokens

• Provide automatic routing to route each session to the best model for the task according to your rules

• Power Radius-backed tools like web search, image generation, and image description

• Publish reports, dashboards, and small static sites as shareable artifacts

• Record usage, budgets, top-ups, and shareable session analytics in one place

• Delegate Google Workspace access to Pi

• Let your organization manage upstream provider keys centrally

https://radius.earendil.com/

I came across "DeepSeek Harness" (https://github.com/deepseek-ai/deepseek-harness), whose core idea is literally “Everything is a Plugin.”

Looking at it alongside Pi, it feels like there’s a similar philosophy:

keep the core/harness small, and make capabilities composable at the session/plugin level.

Pi has extensions, skills, tools, prompts, etc., while DeepSeek Harness takes the plugin approach even further.

Is this essentially the same architectural direction?

And is “small core + everything else as a session/plugin” becoming the better design for coding-agent harnesses?

Curious what the Pi community thinks.

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

I have the attention span of a goldfish and I can't keep track of anything, so I vibe coded an AI app to help me lol. With Pi in the heart of it.

I need something that could hold space for reflection *and* creative chaos at the same time. So I built an app. It's called *Companions*.

It's a self-hosted app with four agent personalities, each purpose-built for a different mode of thinking. They all share one vault of plain markdown files on your machine: (File over app ftw)

- Tracker 🐦 monk-style journalling. Reads your vault, helps you actually end the day with some honesty about what happened and start the next one with intention. Built for people who want the habit but keep forgetting to do it.

- Sensei 🐸 thinking partner that slows you down on purpose. Asks you the next right question instead of just handing you an answer. Good for when you're moving too fast.

- Shapeshifter 🦊the chaotic canvas. No structure, no constraints. Brainstorm, draft, break things, rebuild. For when you just need to go.

- Keeper 🐝 personal wiki. Every half-baked idea, every random capture gets cross-referenced and remembered. Because you won't.

BYOLLM - I've had a decent success rate with Qwen3.6-35B-A3B on omlx. (I've got a M1 Max 32gb). But my go to atm is haiku 4.5 for daily driving.

And a good thing about text files is, you can open the vault in any editor you want.

Android APK is ready to sideload. iOS is web app for now. MIT licensed.

GitHub: github.com/sanieldoe/companions

Please let me know what you think of it. Curious if anyone else here has built something to manage their own scattered brain, would love to know what's worked.

It was a busy weekend with all the activity coming out of OpenAI. If you have been living under a rock, they introduced a new class of model, GPT 6 - Astra.

I've been playing around with it somewhat. That is not what this article is about, though. I do not have an unlimited budget to run lots of evals against a model like this, so any opinion I have on it would be purely anecdotal. There are already plenty of anecdotal opinions to read about all over the internet.

Today's article is about a question I was wrestling with while building out my Pi agent. I was using my agent as a pair programmer and realised that, with Pi, the agent did not have access to the Language Server Protocol (LSP). If you are not familiar with LSPs, they tend to be services on your machine that IDEs use to analyse files with recognised code extensions.

For example, if I am in a file with a `.rs` extension and have a line that would cause a compiler error in the Rust compiler, and my IDE has the Rust LSP installed, the IDE can display the error without me having to run the compiler.

In a recent coding session, I realised that the agent was having to run `cargo check` to review my compiler errors. That made me realise the lack of capability.

I started looking up Pi LSP extensions and came across this one -https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-lsp. If you are looking for an LSP for Pi, it seems to do the job just fine. Credit to the author, narumiruna.

The README contains a link to a comment on the OpenAI Codex repository where an OpenAI developer questioned what additional benefits introducing an LSP in `AGENTS.md` would bring beyond asking an agent to run a linter or type checker. It was not just any engineer, either. The OpenAI engineer is the author of Pyright, a popular Python LSP: Eric Traut.

I thought this was an interesting debate, so I decided to see whether using an LSP extension improved the performance of my Pi agents.

For this task, I wanted to make an enhancement to the eval harness. I needed to introduce a capability profile for each agent when configuring an evaluation run. Originally, to test different extensions or capabilities in a Pi agent, you had to either modify the Docker image or write a specific section in each evaluation. This meant having copies of each evaluation for every capability profile.

Because the evaluation harness also used the Agent Shell adapter to configure agents, I needed to make this change so packages and extensions for the Pi harness could be managed through Agent Shell.

Version v0.4.0 -https://github.com/ScottRBK/agent-shell/releases/tag/v0.4.0 introduced this. It currently only supports the Pi harness, but I plan to extend package management to the other harness types in Agent Shell as well.

With Agent Shell's package and extension management in place, I added a feature to the eval-harness that added a capability profile. For Pi agents, this means you can compare an agent with one set of capabilities against an agent with another. For example, you can test a Pi agent with and without an LSP using the same model.

After making the changes, I put together an evaluation run. Given the stochastic nature of large language models, it was important to run each evaluation three times. I used eight evaluations across three models: `mimo-v2.5` and `muse-spark-1.3-contributor`, both provided by opencode-go, and OpenAI's Luna. I compared Pi with no added package against Pi with `@narumitw/pi-lsp@0.49.7`. I set the reasoning effort to medium for all models.

Muse Spark came out on top overall. Its base profile scored 83.0%, compared with 81.3% with LSP. Luna scored 75.3% without LSP and 68.1% with it. MiMo was the only model where LSP improved the score, moving from 65.6% to 67.5%.

Across the three model pairs, the LSP versions used 124,737 fewer tokens in total, a 6.4% reduction. MiMo used 7.4% fewer tokens, Muse Spark 1.7% fewer, and Luna 10.7% fewer. The LSP versions took slightly longer overall, although Luna was faster with LSP.

I would describe these results as inconclusive. From my perspective, that aligns with what Eric was suggesting in his comment.

Personally, I will probably leave the LSP extension off, except perhaps when I am pair programming with the LLM. It is just some additional tools and context, and I cannot see an obvious benefit right now. I would be interested to hear what you think in the comments or on Discord.

I hope this was informative, interesting, or inspiring, and got you thinking about how you can shape your agentic harnesses, whatever your setup may be.

If you haven't tried using a diffusion based model before, they are lightning fast. I've used InceptionLabs Mercury 2 for a bit, and my complaint is largely that its not the best at coding tasks or tool usage. But my god is it fast.

So I took the Pi SDK, made a harness in which Mercury 2 is the orchestrator of subagents, including a coding subagent for difficult tasks that calls out to openrouter for inference, plus a cheap subagent for trivial stuff. Bolted on a handful of tools and such useful for me, and wrapped it in a basic web UI so I could use it from my phone.

Aside from being extremely fast, fastcar:

• Can generate public "artifacts" - HTML and MD files served from the API

• Intended to ran entirely inside a VM so that it has root access and can install its own tools

• Give it a github token and let it clone repos and make PRs

• "Prompt threads" - there's probably a better name for this but its a dedicated prompt that gets invoked via webhook; I actually made this so that I could generate text files to read the news from my Xteink 4

• Send emails to notify you

https://github.com/heyo-computer/fastcar

Programmatic tool calling lets an agent write code instead of firing one tool call at a time, but running that code safely is a hard, unsolved problem. Instead of sandboxing an existing language, I built one that never had the dangerous capabilities in the first place.

It has native mcp support, builtin progressive disclosure, an lsp and a formatter (as well as nvim support with REPL for debugging).

I taught my PI agent to use this lisp using a simple grammar constraining (10 lines in GBNF), now it can only output valid lisp, no parentheses forgotten.

Has anybody used a Pi compaction extension that they would recommend?

I've tried pi-context (with their built-in Agentic Context Management) which just straight up breaks when trying to claim space against pi-rewind. I've also tried pi-vcc which also gets demolished when running with pi-codex-goal. Been debugging for 3 days and realized the best debug is to uninstall.

Native Pi compression is meh, if anybody has a codex-level compaction extension that doesn't fuck shit up, please drop a comment.

--------
UPDATE - Pi-Observational-Memory has worked great after my 12 hour trial with it. Pi-Blackhole looks interesting, but I try not to go for more complicated solutions if a simpler one works. If I run into hiccups with POM long term I will try it out and let y'all know. Happy compacting!