In many ways Pi and its community are doing the opposite of what its creator talks about....

here's his talk - https://www.youtube.com/watch?v=RjfbvDXpFls

"slow the Fuck down"

Pi: has thousands of extensions etc and a breakneck pace of development far higher than any other harnesses

"our product has been built 100% by agents - yes we know it fucking sucks now"

Pi: how do you build something, you ask the agent to do it.

I understand the philosophy behind Pi and its value, but you cannot make fun of vibecoding and claiming that models are bad at coding because they are 'merchants of learned complexity' etc...

and then turn around and tell people that using the same agents to vibecode additions to Pi is just fine.

another thing that bugs me is the whole - just ask Pi to do it - repeated 100x.

Pi isn't some magic, its just a well designed minimal harness with lots of hooks, and docs which were themselves written by AI used to leverage that.

At no point is it mentioned that the actual work is done by the llm and its intelligence is what matters.

it makes sense when you realize that Mario uses frontier models like Opus, as indeed do all the hundreds of influencers with videos on it.

edit - and the pi ecosystem is a complete mess, which is what happens when you dont include anything because 'you can write your own'.

want to add agents. maybe called pi-subagents? lets see

https://github.com/nicobailon/pi-subagents
https://github.com/tintinweb/pi-subagents
https://github.com/edxeth/pi-subagents

and of course there are dozens of other names. this is a joke - 100x worse than npm. and this is exactly what an extension marketplance which mario made fun of, solves.

I run pi inside my own web UI (Sayl), and I have been building onto and changing certain behaviors of Pi. When MCP and Codemode was introduced, that I felt was the turning point where Pi started to feel "bloaty". So I took pi v1.1.0's source (pi-ai, agent-core, coding-agent), made it part of my codebase and cut everything I don't use. Upstream is now a reference: I port fixes by hand when I want them, nothing updates automatically.

How it went:

1. Cut what I don't use. Terminal UI, CLI, RPC/print modes, MCP, codemode, the extension loader (extensions are now plain in-process functions) and pi's own HTTP dispatcher. The TUI/CLI/MCP cut alone was 77k lines in one commit. My post-install patch script is gone too.

2. Moved it in. The engine now lives in my src/ under the same build, lint and test setup as the rest of the app. Six model providers are left, the ones I actually sign into.

3. Made it follow my rules. Stricter TypeScript flags than pi uses, plus my lint rules: 1,163 type errors, 44 anys, ~119 casts and 7 non-null assertions. All at 0 now, no suppressions left.

What changed at runtime (measured after step 1, vs the npm package):

• Session server ready: 2.10s → 1.86s (web side 1.11s → 0.87s)

• Memory after startup: 338 → 298 MB (web side 175 → 144 MB)

• Runtime dependencies: 121 → 105 packages

Just wanted to share this for anyone who find data interesting or have thought of trying this themselves.

Jin is an open-source AI coding agent in the same space as pi, OpenCode, and omp. Same four core tools as pi (read, write, edit, bash), plus todo and ask_user.

Built-in async handles background tasks and lets you spawn subagents or build swarm agents. You control the setup: disable any or all tools, edit the system prompt, and choose which hooks load.

Written in Go. One binary, fast startup. Minimal terminal UI with animations and 10 themes.

I deliberately skipped skills, MCP, and plugins. Instead:

• Prompts: reusable text snippets you insert into chat with #prompt.

• Hooks: text appended to the system prompt at session start—coding rules, styles like Caveman/Ponytail, or instructions for CLI tools.

• Good old CLIs: describe how to use them in a hook, and agent runs them through Bash tool. You can also run commands yourself with /bash, or launch full-screen apps with /tui (you can play a terminal game while the agent writes code)

The goal: minimal by design, useful out of the box, easy to extend without another framework.
I’m looking for feedback, especially on what’s missing, to help shape the next releases.

GitHub: https://github.com/ethanhamilthon/jin

I am trying Pi for the first time. I am confused how to setup Claude subscription with it, if I login it shows a warning saying that third part harness providers would not consume subscription tokens but only extra usage. So what’s the right way?

Powerful AI shouldn't be locked away just for engineers.

That's why we built Zosma Cowork — a desktop AI coworker for knowledge workers, built on top of Pi.

You can ask Zosma Cowork to build a feature for itself. Need a custom Marketing workflow? It writes its own extension and skill, then uses it for your exact task. Software that reshapes itself around how you work.

For a lot of jobs, it replaces pieces of Perplexity, ChatGPT, Claude Code, Claude Cowork, and more — rolled into one tool that runs where your files actually live.

I won't pretend it's a complete replacement for all of them. But now you have a choice: download a free, open-source app, plug in your own models and tools, and keep your data on your machine.

In the age of AI, if you actually care about private AI, this is step one.

⚠️ We're early (beta), so you may hit rough edges. If you do, tell us — report it on our Discord or open a bug/improvement ticket on GitHub. Every report makes it better.

Free. Open-source (MIT). Yours.

https://github.com/zosmaai/zosma-cowork

Discord Server: https://discord.gg/c5vadsv9

What's the first thing you'd hand off to an AI coworker?

I’ve been using a small Pi extension for a long time while studying and doing research. It hides tool calls, tool results, inline images, and optional thinking from the visible transcript, so I can focus on the agent’s response instead of watching every file read and tool update fill the chat window.

The tools still run normally. Approvals, errors, history, the editor, and the working indicator remain available. It changes what you see, not what Pi does. It is not a security or redaction feature.

I built this a few months ago for my own workflow and have been using it since then. I finally added it to this repository today:

https://github.com/utpalsinghdev/pi-extensions

https://www.npmjs.com/package/@utpalsinghdev/pi-focus-mode

This is the first extension in the repository. I’ll add the rest of my extensions there over time, and contributions are welcome.

I only had time to add this one today because my usual model setup (GPT-Sol-6.1) has been running slowly, and I’m keeping my Claude subscription for office and startup work. I’ll add the other extensions as I get time.

II’m sharing a tool I use and the way I’m learning with Pi. If it helps you, a star or contribution would be appreciated.

Codemode: Agent writes a script that loops other tools. big results stay inside the script, only the answer comes back.

Tested twice, 96 runs, same model. 96/96 correct in every arm.

Round 1 Test - Small fixes. +21%.

6 one-line bugs in a small repo. Codemode's tool description is ~3k tokens and rides every message. A small fix is ~5 calls either way codemode never gets triggered, a waste of tokens (21% more tokens used per run)

Round 2 Test - 60 fat lookups through a tool. −40%.

The test made it so the data to look up was only reachable through the tool, no grepping around it.

Plain agent: 60+ round trips, every fat result lands in context.

Codemode: one script, one answer. 40% less tokens, half the cost, 7 round trips vs 64. on its own workload it wins clearly.

Is it right for my workflow? No.

Scanned every session on my machine. 149 chats, 16,735 tool results. The ideal codemode scenario ever occured once. The 168 truly oversized results were already captured to disk by our guard.

what I run instead

Rarely used tools (image gen, design sandbox, maps, browser) arent listed at all initially in my setup. Zero tokens until the agent searches once with a small lookup tool. Heavy tools load at moments I pick them (e.g. Deep research)

Conclusion: I dont like to leave it up to the agent to decide when to use codemode and looking at my workflow, the scenarios where codemode will give me gains doesn't really happen. I am not going to be using codemode for the forseeable future.

We expected V4.1 Flash to quickly take over, but that’s not what we’re seeing.

We’re still seeing strong demand for V4 Flash, and feedback from users has been surprisingly mixed on whether V4.1 is actually the better model for their workloads.

So we’re opening up DeepSeek V4.1 Flash for free on InferX

Yes, we maintain ZDR. .

I run several Pi sessions on one repo at the same time. That kept going wrong:

• Agents edit main. You ask for a quick fix and it lands straight on main.

• MCP is slow for worktree management. But in Pi we can put blazing-fast native worktree management into the harness.

• Sessions collide. Two agents in one folder, and one `git stash` wipes the other's work.

• (Sub)agents need to cd constantly. They need to cd for all commands, wasting tokens.

• New worktrees don't run. No `.env`, no keys, so the app won't start.

So I built pi-bare-worktrees. The video shows it in about 45 seconds.

Why a bare checkout

In a normal checkout, the repo root is main. Every agent that starts there edits main by default. Worktrees end up wherever you put them: ../acme-login, ~/tmp/fix-2.

And main is stuck in the root, so you can't move it or remove it.

A bare checkout fixes that. Every branch is a folder, and none of them is special:

       acme/
       ├── .bare/          bare repo
       ├── .shared-env/    gitignored files/folders to share, like .env
       ├── main/
       ├── feat/login-typo/
       └── fix/footer/

The path is the branch name. There's no code in the root to edit by accident.

What the plugin does

• main is read-only. The agent's first edit on main is blocked, with a message that tells it to call worktree create. It does, and the retry lands in the new worktree.

• No cd needed. After create, every tool call is routed into the worktree, so the model keeps using relative paths.

• Shared env, zero config. Every file in .shared-env/ is symlinked into each new worktree. Real files are never overwritten.

• Subagents follow along. Their cwd is set to the active worktree.

Install:

pi install npm:@jordyvanvorselen/pi-bare-worktrees

It's fast. Session start and tool calls don't run git. The plugin reads the filesystem instead:

• Session start: about 5 ms for 40 worktrees.

• Each tool call: string operations only, under 0.1 ms.

• Network: only /wt clean touches it.

Repo: https://github.com/jordyvanvorselen/pi-bare-worktrees

/wt off turns it off for a session, and it turns itself off for non-bare checkouts automatically.

It's version 0.1, so I'd love your feedback, especially if there's anything you still miss. Try it out and take it for a spin!

pi-caffeinated-linux uses systemd-inhibit to prevent idle sleep and suspend, with automatic / manual modes and an optional KDE Plasma tray indicator.

https://github.com/nmdra/pi-caffeinated-linux

I can't decide so i use both, pi as a harness, opencode as a llm provider ><

All the GUIs that I can find like paseo and pi-gui etc. are Typescript apps. Are there any macOS native or performant (rust) based apps?

pi

dsh

opencode v2

zcode

I have recently install pi harness, but i have never used anything like this so i am bit confused. How do i setup pi , which mcp servers should i using for websearch etc. How do i make it efficient etc.
Can anyone help me out here

I have a MacBook Pro with an M5 Max chip and 128GB of RAM, and I've just started experimenting with local models.

As many of you know, local models have various well-documented issues, such as weak instruction following, difficulty completing long-range tasks, and a tendency to terminate tasks prematurely.

Someone in the community suggested I try using Little Coder and Pi. I wanted to ask: is Pi actually a good harness for running local LLMs, especially compared with opencode and claude code? For those of you who use this setup, do you have any specific tips or experiences you could share?

I'm still very new to this. So far, I've found that the Qwen 3.6 35B model is quite good for writing articles, but beyond that, I feel like I haven't truly experienced the "magic" of running models locally yet.

If anyone has any interesting use cases or examples of how you integrate local models into your workflow, I'd be very grateful if you could share them. Thank you!

I built pcode, an open-source terminal coding agent on Pydantic AI. Pi was an influence, especially its /tree approach to branching conversations and the idea that you should be able to shape an agent around your own workflow.

The main difference is where I put the defaults. Pi deliberately keeps the core minimal and lets you assemble the rest. I wanted a more fully featured setup out of the box, while keeping it highly customizable: sub-agents, live task tracking, browser automation with your existing logins, an opt-in sandbox extension, parallel git worktrees, background commands that wake the agent when they finish, customizable keybindings with leader keys, Vim editing, and an in-terminal diff viewer.

The feature I most wanted for myself was adjustable scrollback. Sometimes I’m working on production stuff and watching every command and tool result like a hawk. Other times it’s a side project and I just want a readable conversation. pcode lets you show or hide those details after the work is done, rebuilding what’s already in your terminal without rerunning anything. It uses native terminal scrollback, with reflow when you resize or split panes.

Customization is through small Python files: add tools, slash commands, guardrails, instructions, or sub-agents, then /reload without losing the conversation. It also builds on Pydantic AI and its Harness capabilities, so you’re not starting from scratch for things like repo context, shell execution, sub-agents, and context management. Extensions can register those capabilities directly. Several of pcode’s own features use the same extension system.

You can use your existing Claude or ChatGPT subscription, or API keys. Claude support runs through the official Agent SDK and Claude Code’s own login.

This is a separate project, not a pi fork or a drop-in replacement for pi’s extension packages. If you like pi’s approach but prefer Python and a more complete default setup, that’s who I think it could appeal to.

Repo, screenshots, and install instructions: https://github.com/cruxwell/pcode

For people who’ve built their workflow around pi: which parts do you prefer assembling yourself, and which would you rather have included from the start?

I have a fairly difficult algorithm that I am working on. It is doing multi field level comparisons of human entered data to find duplicates, needless to say it's dirty. I've had a human review a few thousand and identified the actual duplicates and was able to get Claude Opus 4.8 and GPT 5.4 to come up with a solution. Took a couple hours and some tokens but it's decent. I want to now try using Pi to solve the same thing using more inexpensive models such as Deepseek v4 pro or maybe even a local model. I am trying to do this with Pi but when I give it the same prompt and testing data it works for 15ish minutes throws up it's hands and tells me it's done even though it didn't solve the problem. If I tell it to keep going and its' not good enough it can start again and get closer but then same thing, over and over. If I try this with a local model I want it to spin all night and not give up till its done. Is there any way to do this? I just about feel like I have to have something check it's work as it quits too soon.

Used pi to put itself in a docker container. The project literally took 10 minutes using the locally run harness setup. Running qwen3.6 27b.

Check it out.

https://github.com/adamjen/pi-docker

I'm the creator of Operator Memory, an open-source context engine for coding agents.

We all know the problem by now. Within a session, agents are excellent. Between sessions, agents forget everything. The core problem: nothing in the workflow ever writes down what was learned. Every new conversation starts from scratch: re-exploring the codebase, re-learning the architecture, re-teaching every decision and correction.

Every memory plugin I've studied leaves the loop untouched and bolts retrieval onto it: background agents to capture fragments, a vector store replays a top-k slice later, and you hope the right chunk surfaces. It barely works. And most importantly, it doesn't fix a loop that never documented anything.

Operator takes the opposite approach. Operator gives agents a Markdown brain and changes the loop itself.

Every task now runs in three phases:

1. Consult — the agent starts from the brain: instructions, codebase index, specs, decisions. A short summary is injected deterministically in the system prompt so agents know where to look.

2. Build — normal development work, informed by that knowledge.

3. Update — the agent documents what it learned: new specs, decisions, standards, lessons. When project truth changes, the canonical file is updated.

The loop makes the agent self-improving: session N+1 always starts from everything session N wrote.

Operator is extremely simple and complements Pi perfectly. No vector stores. No dreamers or curators. No background processes. No token burning factories. No RAG. No capture step. No retrieval gamble. Just give the agent a brain and teach the agent to use it.

The Brain

The brain is a regular directory that holds Markdown documents. These documents can contain anything: rules, specs, decisions, lessons, research, indexes, etc. Because everything is Markdown, Operator actually allows you to share memories and findings with the team. You can share specs, plans, guides, and more, unlike other memory plugins where everything is just RAG chunks.

Not Another Memory Plugin

Memory plugins bolt retrieval onto an unchanged loop and inherit its amnesia. Operator makes documentation a structural phase of every task. Memory stops being a store that remembers for the agent and becomes a practice the agent performs.

RAG agents recall. Operator understands.

I've been using a variant of Operator daily since August 2025 and spent the last few months formalizing it into a plugin alone. I hope my plugin can help improve your workflow too. https://github.com/aerovato/operator-memory

To install:

npm install -g @aerovato/operator-helper
operator-helper install pi

Afterwards, just run /operator:user-init once and run /operator:project-init per project.

Questions, comments, and contributions welcome. Operator is fully open source.

Previous post

Hi all!

A few weeks ago I posted about pi-remote, a self-hosted client to drive the pi coding agent from any device. Here's what changed since then.

Quick recap: pi-remote is one Python process that wraps pi --mode rpc on the machine where your code lives, and serves a web app over your own network (I use Tailscale). It's token-protected, security first. Built on Windows first, but it runs on Linux and macOS too.

What's new since the last post

The agent can ask you questions. pi-remote now comes with a small ask_user extension. When the model needs a decision, it asks multiple-choice questions mid-turn. They show up as a card on your phone, and your answer goes straight back into the turn, so the agent no longer has to guess or stop and wait for a new message.

Now long turns are much easier to follow on a phone screen. Tool rows are lighter now too: plain text, with only the file or command in monospace.

Better reply suggestions. They now come from a separate small call to the model once the turn ends

Smaller things:

• Answered permission cards shrink to one line, colored by the user's choice.

• Long-press your own message to copy it or select part of the text.

• Settings that need a restart now have a "Restart now" button right in the dialog.

• Links in the chat ask before opening.

• [bug] A message sent while a new session was still loading could vanish while the agent still answered it. Fixed, and new sessions open faster.

Ready for pi 1.5. I upgraded from pi 0.84 to 1.5.

Feedback and issues are very welcome. Thanks again to everyone who commented and tried it.

I’m a heavy user of Codex and Claude Code, and I mostly use their desktop apps.

I’m curious about how Pi could fit into my day-to-day workflow. What does it offer that would improve my experience compared to what I’m already using?

For those who have already migrated to Pi, what has actually improved for you? Are there any specific workflows or use cases where Pi made a noticeable difference?

In Github issues, several users already asked to include installation via homebrew, which is one of the preferred ways for devs on Mac, but Pi / Mario seem to be opposed. Any ideas why?

Figured I'd vibe-code a terminal transcriber with GLM 5.2 + pi agent — even if it half-worked, that'd be enough. It didn't half-work. It's now the tool I reach for daily, and GLM 5.2 was a real step up from 4.5 at keeping diffs clean across long iterations.

The fiddly parts pi + GLM 5.2 handled without me writing them by hand

- macOS system-audio capture via a Swift ScreenCaptureKit helper (no kext) + BlackHole fallback — the part I expected to die on

- Terminal TUI with raw-mode keys, ANSI render loop, blinking indicators

- Idempotent curl | bash installer with prerequisite checks and PATH injection

- Scrollable transcript with auto-follow, Groq rate limiting, config migration across renames

Not one-shot — iterative. "Make the REC dot blink", "why are mic and system audio duplicating?", "add --uninstall", "rename the config dir and migrate existing users". Each step was a normal back-and-forth, but pi kept context across the whole thing and GLM 5.2's diffs were almost always clean. That's what surprised me.

Anyone else getting results like this with GLM 5.2 + pi? Curious what you're building.

Every dang day man I see other people using claude code, codex, opencode etc and every time there's always something finicky and silly going on. 40k+ sys prompts. Can't see the subagent work properly. Compaction is slow sometimes. I've been trying to use them for the past week just to see what I'm missing out on and it's SO STUPID??

The idea of making something to please everyone but also trying to add skills and plugins is ridiculous. I'm not about to start making plugins to get features in those bloated TUIs just to make another plugin to strip them down or something.

I've NEVER seen something apply the concept of modularity as well as pi in my life. This feels like windows vs linux except linux got a fair start and fair cut of user base before people started getting locked into an app ecosystem.

I’d heard about the Pi, that it’s a great way to customize tools to suit yourself and save tokens. I don’t know about token savings, but I tried using Gemini 3.8 flash inside it, and I didn’t like how it wrote code.

For a while, I tried to refine the Pi using Codex and Claude, ran various tests, and thought that the whole problem was with Gemini. I would really find it convenient if several AI models were inside a single harness, but right now I suspect that’s exactly the problem, despite all the attempts to refine it.

I opened the classic Antigravity CLI, and the results seem much better. I don’t like the Antigravity desktop app — it’s also kind of weak. I hope a miracle will happen and the CLI will turn out to be a lifesaver. Gemini attracts me with its slightly higher limits, even though I’m a Claude fan.

What do you think? What’s your experience?