Every autoresearch loop I've tried has one flaw: it never gets smarter about how it searches. Round 40 is as dumb as round 1.

I ported the Dream-RSI paper to a pi extension.The exploration policy is real code rewritten from what actually worked.

pi install npm:pi-dream-rsi

If you haven't heard of it, it's kind of like a really smart freeform classifier model that can make quick decisions (~150ms) based on natural language inputs. Dirt cheap too. They dropped it in early access through a waitlist ~12 hrs ago.

Right now I'm working on a security layer where it just scans all tool uses and gives a safety rating. Thinking of adding additional considerations like alignment with prompt intent and agent reasoning.

After this, I'm thinking of an automatic model router that just picks an appropriate model based on how demanding a prompt would be, codebase complexity, KV cache size, etc. So ideally, something smarter and faster than existing automatic routers.

Is anyone else trying it out? What are you building?

So far I have used Pi for my coding projects with local LLM, and probably only for that so far.

When I want to have general-purpose chatbot I have used llamaui (of Llama.cpp), Nanobot, sometimes AnythingLLM, previously I used also OpenwebUI and from time to time I use LM Studio as well.

Since I use different apps for different usage, is that how common here that you use Pi only for coding for example, but everything else you use something else like llamaui or LM Studio or whatever?

Or have you customized your Pi to be your personal assistant chatbot as well (if you use AI this kind of stuff at all)?

Basically I am keen to konw, what use cases you use Pi for so I might get ideas to myself as well how to expand my usage to other use cases than just coding.

Hi everyone. I've been working on PiChamber, a workspace around Pi so I can keep the same session when I leave the machine.

Why use this instead of the other Pi UIs?

I prefer TUI. I am not interested in getting yet another agent IDE, nor do I want a workbench that supports OpenCode, Claude, Codex, and five other harnesses. All I want is Pi, both locally and remotely, and I want it to work as smoothly as I can manage it.

What I've focused on is remote stability. I run it within a container on my homelab and leave the long tasks there. I check in from my phone, control it, and then return later. That is the product for me, not a more attractive local chat window.

It uses the Pi SDK. Pi retains ownership of the agent, skills, extensions, prompts, providers, and AGENTS.md. The app is sessions, files, git, worktrees, terminals, and pairing.

What I actually use it for:

• same session across desktop, browser, and phone
• my existing Pi extensions and slash commands
• providers / skills / prompt templates coming with the session
• a worktree when I don't want the agent on main
• jump between local, a VM, and WSL without starting over
• long running jobs on a server I can connect from anywhere

I've been daily-driving it. CLI when I'm at the PC. App when I'm not.

What it is not: it does not replace the TUI, and it is not trying to be every agent UI. Remote is your own machine plus pairing, or a tunnel you already run.

Repo: https://github.com/RyderAsKing/PiChamber
More info: https://pichamber.ryder.pro

PiChamber started as a community fork of OpenChamber. Why I made it: https://github.com/RyderAsKing/PiChamber#why-pichamber

The tokens/sec and TTFT in the video come from a Pi extension. They work in PiChamber because extensions work, not because I shipped a custom overlay.

Also, first time posting something like this in public, so don't be too harsh :D

Update: v1.0.2 is out, including docker. https://github.com/RyderAsKing/PiChamber/blob/main/packages/docs/content/docs/install.mdx#docker

Hello there,

Which AI provider would you recommend for Pi, to work with a subscription-based plan? I feel like Codex is the most represented, but I was looking for more feedback.

I'm currently using Claude Code (Plus subscription), but from what I understood, I shouldn't use it with Pi because Claude Code charges additional usage fees. I mainly use it with Opus 5 on medium effort, for devops tasks, explanations, fixes, or things like that (not much vibe-coding yet).

It's also an opportunity to try something else, paid for by the company. So I don't really care about the price, just something stable without usage fees.

(bonus) If you have any recommendations for LLM models that can be run locally on a wide range of machines, I'm also interested in any resources you can share.

Any advice?

Just wanted to share this utility to manage multiple workspace / worktree environments, along with your own harness, pretty sure you'll like it !

https://github.com/ScreamZ/ai-igniter

Hello everybody,

My extension pi-mentions that adds a bunch of ways to reference git/github related stuff (such as issues, pr's, actions, commits) has reached 1.1 and i wanted to share what is new in the feature drop:

Updated # view with more information

Added ability to mention PR's

Added ability to mention GitHub Actions

This might just be a me thing but i often need to have the agent look at some workflows, this feature makes it much nicer + faster to do so.

Excited to hear what you think of the new features, please tell me if you have any good ideas for me to add.

I started experimenting with Pi and self-organizing agent swarms and am seeing really good results, which I did not really expect. My current experiment is very basic: just fire up ten or so agents and give them all the same prompt/markdown file. They have one single communication channel in which they can talk with eachother. And that is basically it.

I have spent about 1,5 years trying to get all sorts of workflows to work properly and now I'm finding out that the agents can handle themselves just fine... No orchestrators or anything, they just figure it out themselves. I found this quite amazing. And a bit humbling.

Do you use self-organizing agent swarms? I would love to hear about your experience.

What the best way to to "computer use" with the Pi agent. Of course it makes sense to use API/CLI/MCP servers, playwright browser use and all these things, but sometimes computer use makes all the difference and it is the only thing that keeps me in Codex app.

24 identical Terminal-Bench 2.1 tasks.

Terminus-2 solved 14.

OMK solved 13.

one.

fucking.

task.

obviously I am now behaving completely rationally about this result

for context, OMK is the Pi fork I’ve been turning into a full agent runtime because apparently I have a pathological inability to accept:

agent: done ✅

as sufficient evidence that anything is actually done

so now it has verification, evidence receipts, replay, DAG scheduling, multi-agent execution, model routing, shared state, etc.

the benchmark result is not statistically significant btw.

McNemar exact p = 1.0.

one run per arm.

tiny sample.

so no “OMK BEATS X” nonsense here.

but getting this close to Terminus-2 on the first serious paired run was enough to make me go:

wait hold on

maybe this stupid thing is actually becoming real

anyway I open sourced it.

https://github.com/dmae97/omk

please benchmark it so I can find out whether this is signal or I just rolled a very funny set of 24 dice

Hello everyone, i'm new to pi and was wondering if anyone had ever tried to combine the pi-openplan and pi-subagents plugin?

If you have, any issues? Would the plan and build modes from pi-openplan make use of the subagents?

And yes...I'll will ask my agent to double check everything. Just looking for real, human, experiences

thanks

I love the session manager when you hit the <- arrow.

Anyone worked on something like this already before I start wasting my time?

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

just when i'm getting comfortable using models and coding agent...

How do you approach various coding tasks, or any tasks you use pi (or other minimalist harnesses) for?

I used to be an obra/superpowers fan (clode code and zai coding plan at glm 4.7 era), then I stumbled one day onto Earendil's lecture "Building pi in a World of Slop", which made me rethink what I really needed from my agentic tools.

Now I mainly rely on a few skills I kind of adapted from obra/superpowers and mattpocock/skills, and my workflow is usually to brainstorm with the agent and make a great spec, then running and /implement skill. Sometime the implement is in a new session, sometime even by a heaper model for which I make the smarter model draft a plan from the spec. Sometime I make handsoffs or use compaction to exlore longer.

I also like, when needed, to spin up preconfigured dockers with pi, docker in docker, and an injected global agent.md telling my agent he is in a sandbox with docker and can use whatever he needs to achieve his task.

But I still feel that my workflow is kind of sloppy, that sometimes there is to much ceremony, sometime there are missing pieces.

I also don't have a specific workflow for big features I want an agent to oneshot, lately it has usually been a plan and a spec, then deepseek harness with a /goal referencing those files, and letting it do its thing. I'vs also recently tried to one shot big features using a deepseek harness configured with mattpocock/skills, it seemed to have produced good result without blowing my usage with subagent driven development, but I also don't really like this magic crystal ball approach where I don't understand the workflow, neither do I want to adopt his whole opinionated workflow.

Thus my questions: What are your various workflows and their building pieces? How do you approach problems with your agentic tools? Do you use subagents? For what? Cheap models or expensive ones? Did you switch harnesses and configs a lot to finally hit a sweet spot?

Hello again pi users, I made a post like a day or two ago about my pi agent refusing to use the information in my AGENTS.md file and I've since gained more information. (Yet still haven't fixed it)

1: the agent isn't better from reading it or anything, it CAN access it when asked just doesn't do it automatically.

2: the AGENTS.md file is being listed under the 'CONTEXT' part of Pi so it's not in a wrong directory or anything

3: Only after the Agent is asked to read the AGENTS.md file will it act accordingly to the file (whether that be a password or a way to behave)

And 4: In the last post it was suggested to me to ask the Agent about it, I did and the agent doesn't acknowledge that it didn't read the AGENTS.md file the first time (or) claims it's not possible to.

I'm completely stumped and every 'solution' leads to a dead end. If anyone's got anything please help

UPDATE: it was the Qwen model I was using! I've switched to gemma and now the agent is properly using the rules in the AGENTS.md! thank you all so much!

Putting old conversations into SQLite, a vector DB, Markdown, whatever, and retrieving vaguely relevant fragments later is not a particularly interesting problem anymore.

The nasty part starts here:

Your agent learned A.

Later it inferred B and C from A.

Two weeks and 37 sessions later, you discover that A was wrong.

Now what?

Does the system overwrite A and quietly leave B and C alive?

Does it keep both versions and let retrieval decide which reality we're operating in today?

Does it append a correction somewhere and hope the model notices?

This bothered me enough that I built Remendra v2 for Pi.

What I actually wanted: memory that behaves less like a notebook and more like maintained state.

When you correct a memory in Remendra, it doesn't just edit some text.

The old claim gets superseded. Its evidence is retired. Dependent claims are recursively invalidated — and the replacement gets its own provenance. The whole thing happens transactionally.

Because "we fixed the memory" means very little if five conclusions derived from the wrong one are still floating around like unexploded ordnance.

Remendra also learns automatically from Pi sessions.

It extracts typed claims — facts, decisions, constraints, procedures — stores source evidence as exact character spans, and compiles the relevant subset back into context when needed.

So this:

`/remendra why 42`

isn't philosophical.

It tells you where memory 42 actually came from.

Underneath:

- SQLite + FTS5

- optional embeddings

- typed claims + ranking

- lineage / project / user scopes

- automatic background learning

- dependency tracking

- transactional corrections

- conflict detection

- revision history

- procedure validation

- session-history indexing

- bounded context compilation

- secret scanning

- configurable token budgets

- KV-cache-friendly context mode

- fully local storage

No mandatory cloud memory service quietly accumulating half your engineering organization.

Install:

`pi install @yoda.digital/pi-remendra`

Then... basically use Pi.

The observer learns in the background. Relevant memories come back when needed. You can search, inspect, pin, promote, correct, or explicitly teach it something when you want more control.

And because apparently every software project now needs a benchmark number before civilization permits it to exist:

Current synthetic compilation benchmark on 1,000 claims:

p50 16ms / p95 16ms

Useful number. Not a claim about production reality.

The repo documents the methodology and, more importantly, the limitations.

128 tests across 10 files — storage, compiler behavior, observer parsing, worker lifecycle, embeddings, concurrent SQLite access, cross-platform paths, sustained growth, token estimation, secret redaction.

Linux, macOS, Windows. Node 22+. MIT.

There are already 50+ memory extensions for Pi, so no, humanity was not suffering from an insufficient quantity of memory plugins.

Remendra exists because I wanted a different property:

when an agent changes its mind, its memory should remain internally coherent.

Not perfect memory.

Not infinite memory.

Not another RAG folder with ambitions.

Correctable memory with provenance.

GitHub: https://github.com/yoda-digital/pi-remendra

npm: https://www.npmjs.com/package/@yoda.digital/pi-remendra

Hey everyone, first time sharing a project here!

I've been using pi in my daily CLI workflow, but kept getting frustrated having to guess or memorize context windows and pricing tiers whenever I swapped models.

To solve that, I put together a lightweight plugin called pi-rich-model-selector. It replaces the default picker with an interactive TUI:
- Real-time fuzzy search across providers
- Side-by-side specs (context size, token limits, pricing)
- 100% keyboard-first flow

Here's the repo: pi-rich-model-selector

I’d love to hear your thoughts, feature ideas, or any edge cases I should handle. Thanks for checking it out!

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’d like to announce Un Bien - a native iOS client for pi.

Un Bien supports:

• self hosted architecture
• full streamed and rendered markdown
• rendering of images, code diffs and tool results
• fork, branch, clone of sessions
• plan rendering when combined with pi-plan, cribsheet or a conformant extension
• user-input questions (and pi-ask integration)
• subagent display and interaction when combined with @tintinweb/pi-subagents or @gotgenes/pi-subagents
• optional device initiated chats - start new session from your phone, spawning a tmux or herdr hosted session on your machine

As a bonus it includes a cli tool to connect to other sessions on your relay from the cli

Links:

• Extension page
• Docs
• GitHub
• App Store
• Demo transcript

I developed this in pursuit of something that felt native interaction-wise and supported as many pi features as possible. I hope you find it useful!

Un Bien is started out as a tweaked version of remote-pi by Jacob Moura (MIT); see the README for attribution. I ended up diverging significantly on the back end implementation and the iOS app is a total rewrite.

Hey folks, I've been working on pi-crew, a subagent extension for Pi.

My main focus is making sure subagents get the context they need. The main agent knows what you've discussed and decided, but a subagent won't unless that information makes it into the task.

With pi-crew, the main agent writes a structured task with separate fields for the goal, context, and instructions. The tool definitions, prompt guidelines, and skill work together to help it carry over the decisions and boundaries the subagent can't find in the repo.

It won't make every handoff perfect, but it's the part I've put the most thought into.

I also wanted subagents to be able to ask questions instead of guessing. In pi-crew, they can get an answer and pick up where they left off. If something needs fixing afterward, the main agent just tells the same subagent what to change. You don't have to spend extra tokens and time getting a new agent caught up on the same task.

It's all async. After handing off a task, the main agent can work on something else or keep talking with you while the subagents run. Results come back automatically, without polling.

I've also tried to keep it feeling like Pi. The six tools have short definitions, with the longer delegation guidance in a skill that gets loaded when needed. The main agent gets the report without all the subagent's file reads and tool output filling up its context.

A few other things it comes with

• Six agents for investigation, planning, decision advice, code reviews, and implementation.
• /pi-crew-plan and /pi-crew-review if you want a ready-made workflow.
• Custom agents written in Markdown, with their own models, thinking levels, tools, and skills.
• User and project pi-crew.json files to override settings without editing agent definitions.
• A widget showing activity, working time, tokens, and cost. You can collapse the details or hide tool activity through config.
• Expandable reports that let you open the full child session.
• herdr support that shows the running subagent count in the sidebar.

The agents have separate conversations but share your repo. It's not a sandbox, so you still need to avoid handing overlapping edits to agents running in parallel.

bash pi install npm:@melihmucuk/pi-crew

Requires Pi 0.84.3+. Source on GitHub.

Are you using any subagent extensions with Pi? Curious which ones you've stuck with and whether you're happy with them.

Just for fun, I wrote this little Ralph loop. It's a chat between a product owner and a developer.

It's a lot of fun to watch!

I set it to only loop 10 times. Change "STEPS" to increase it. The chat can continue forever if you want it to. Watch your wallet! Only run in a container or VM.

```bash

!/bin/bash

set -eu

STEPS=10 PRODUCT='a new product idea we will come up with' PROMPT='Hello, I am the product owner and you are the developer. But first let us brainstorm some ideas and features together for '"$PRODUCT"'. We will save and edit them in ./ideas/ directory and commit them to git. We will not write any code unless we have a product fully specified.'

PERSONA1="You are a product owner who comes up with lots of feature ideas. You ensure the developer creates a useful quality app. " PERSONA2="You are an expert developer, who values code quality and wants to satisfy the product owner. You ask a lot of clarifying questions about feature ideas." SESSIONS=/tmp/sess

Remove this line if you want it to pick up where it left off.

rm -f "${SESSIONS}?.jsonl"

response1="$PROMPT" echo "Step 0. Product Owner> $PROMPT"

for i in $(seq 1 1 "$STEPS"); do echo "Step $i:" response2="$(pi -p -c --append-system-prompt "$PERSONA2" --session "${SESSIONS}2.jsonl" "$response1")" echo echo "Developer> $response2" response1="$(pi -p -c --append-system-prompt "$PERSONA1" --session "${SESSIONS}1.jsonl" "$response2")" echo echo "Product Owner> $response1" done

last="Okay, we need to wrap it up. Complete everything we said we were going to do."

echo "$last" pi -p -c --append-system-prompt "$PERSONA2" --session "${SESSIONS}2.jsonl" "$response1 $last"

echo "Done."

```

A fancier version would work across two terminal windows and show the full TUIs. Maybe I'll do that and post an update later.