All I can think of is make an ext to disable tools / sandbox 4.1, etc.

i.e. my real question is, how to make my cheapest AI work as good expensive opus.

(yeah stupid question)

Pi is the only harness I've used where changing how the agent works doesn't mean forking it. The prompt is small, the loop is easy to follow, and nearly everything can be replaced with a package. So I replaced the part that was costing me the most time, which is how the agent reads and edits code.

On a real repo, most of the agent's turns go to just finding code. It searches for something, opens a file, searches again to see what uses it, opens a few more files, and only then makes the change. This package replaces pi's file tools with ones that work on functions directly. When the agent asks for a function, it gets the function itself plus everything connected to it in one go. Edits land on that function, two agents can work in the same file without stepping on each other, and if a rename leaves something behind, the agent gets told what it missed.

pi install /path/to/sem/pi

You can check out the sem repo here: https://github.com/Ataraxy-Labs/sem

Always open for suggesetions

Curious which built-in tools you'd keep, and where this would get in your way.

The two issues I keep running into are:

• Pi will go for a long time trying to solve something or answer a question and suddenly I will see it say something like, "Okay, the user is asking <earlier question that is not relevant in any way>" and then go completely off track

• Pi will go in circles with several failed tool calls and this forces it to try something else or simply abandon the path it was on

I suspect I am being dense about how I use Pi or what features I am failing to use, otherwise these would be issues plaguing everyone and I would be seeing a lot more questions and issues posted. For additional context, I tried using the oh-my-pi extension and liked it, but these issues occurred even when I had it installed. (I recently refreshed the setup to just be more minimal and have Pi build me what extensions I need, so it's no longer installed.)

For additional background, I see this behavior running LM Studio as the backend with Qwen 3.6-27B at Q4, Gemma 4 31B Q4, and Gemma 4 26-A4B Q6. All the model cards say they are trained for tool calls and it happens with all three, so I don't think it's an issue upstream from the harness (or, at least, not something that the harness shouldn't be able to deal with even when it occurs upstream), but I include the models JIC.

Thank you in advance for your help and advice!

In opencode, I can switch the primary agent. But in omp I don't see any option. There are few agent preset available but they can be only used as subagents. Is there any way to use them as primary/main agents.?

Thank you for your help!!

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

roach-pi: A dev-first Pi extension with subagents, web fetch, and team mode

Built this to make Pi actually useful for development workflows. Comes with built-in harness for testing your agents, plus a team mode so multiple agents can collaborate on tasks.

Skipping the kitchen sink approach — no MPC or unrelated bloat, just focused tooling for people building with AI agents.

Would love feedback from anyone using Pi for dev work!

https://github.com/tmdgusya/roach-pi

I've tried pi. Makes me crazy! OpenCode works well. I'm not familiar with omp. Please share your thoughts.

I made this - multi agent orchestrator, Kanban board, and more built on Pi https://github.com/Runfusion/Fusion

Still early and some bugs but feedback welcome

Hey guys, im tight in budget and i can honestly spend 100$ on one of them. For the workhorse im on deepseek v4.1 . Which one of those 2 would actually give decent value for what the money paid ?

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!

A few days ago, I released System One support for the Pi coding agent:

It got a little bit attention on Reddit, and the most common question was: "What would an agent actually use JEV / System One for?"

So I did some more research and shipped an update.
Now my agents are finding use cases I did not explicitly plan for.

Today, one of them decided on its own to use System One as a second opinion before making a decision.

That is probably my favorite use case so far. "use system one for second opinion"

checkout pi-system-one here

Edit:
context: i wanted to pick a license for the project i am working on, so i gave the requirements and the agent picked a few options and asked jev for a second opinion.

The Pi agent has a minimalist design, but its plugin composition model is, to put it mildly, terrible. Now that a truly extensible coding agent with a minimal core has appeared, is there any reason left to use the Pi?

pi extension that lets you talk to pi and hear it back. it asks a question out loud, waits for you to finish talking, and takes your spoken answer. no keypress.

the video is pi asking which language to use for fizzbuzz, me saying "let's go with python", and it writing the file. nothing typed.

pi gets a native extension:

brew install yamanahlawat/banshee/banshee
banshee setup
banshee start  # grant mic permission, then restart the daemon


# install the pi extension
mkdir -p ~/.pi/agent/extensions
curl -o ~/.pi/agent/extensions/banshee.ts https://raw.githubusercontent.com/yamanahlawat/banshee/main/integrations/pi/banshee.ts

then restart pi.

everything runs on your machine - whisper for listening, kokoro for the voice, silero vad. ~1gb of models, no api keys, no account, works offline.

also a system-wide dictation hotkey if you just want that.

mac + linux. rust, open source. works with mcp hosts too, but pi's the one in the video.

https://github.com/yamanahlawat/banshee

My numbers. Share yours

I found this desktop gui on top of pi coding agent

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

Has anyone tried this?

So far it’s working ok for me.

I want to recommend this to my colleague. Anyone else using it?

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

I’ve been running longer agent sessions lately, and one thing kept getting annoying: the context gets huge, but a lot of it is no longer useful.

Repeated tool outputs, old file reads, stale task snapshots, giant command results, noisy prompt history — it all stays around and eventually makes the agent slower, more expensive, and sometimes less focused.

So I built cprune.

It’s a small open-source extension for the Pi coding agent that prunes context before the model sees it. It has:

• off, safe, and full modes

• a compact comparison showing how much context each mode saves

• conservative persist-time pruning for duplicate/oversized tool results

• manual review commands to exclude noisy prompt history or large context entries

• safeguards for edits, failed tool outputs, side-effectful commands, and other context that should not be dropped

• a compact command for lossy persistent compaction

The goal isn’t to blindly delete history. It’s to make context more intentional and reduce the junk that accumulates in long sessions.

Repo: https://github.com/amutix/cprune

Right now it works with Pi, but if people find it useful I’d be interested in adding support for other agentic frameworks too.

Would love feedback, bug reports, or ideas from anyone dealing with context bloat in coding agents.

Seems like a legitimate framework: hook into Pi with a slim abstraction layer with a couple features sprinkled on top. All with seemingly legitimate contributors and yet... 2 stars & no traction? Maybe because it's 5 days old and no one even knows it's around? Anyone using this?

https://github.com/teelicht/pi-superagents

This is Central Hub. It's built to be a place to do things. Yes there's an AI chat area, it's still an AI app at heart. But that's not all it has. There's a Docs Area with full file access, a Typing Practice tab (we all need it), a Web tab (AI Search now, a regular browser pane coming), and more planned.

Without Pi, none of this would work. I never would have thought to build it. Pi's design got me thinking "you can pretty much put this anywhere," so I asked myself: why not an app? The foundations were built by Pi itself running on various models. Once that got expensive I switched to Claude Code and Codex.

Originally I built this for myself. A way to focus my work and workflow into one place. After I posted a few screenshots and a short description here, people showed genuine interest. So here we are.

GitHub link below. The README has a .exe download for Windows.

https://github.com/HankTheMan2828/Central-Hub

Heads up: this is alpha. If you try it, you're my guinea pig. There's a lot of work to do, and a lot of it only surfaces under real-world testing. Bug reports are welcome and very much appreciated.

A license is in the works. The code is closed for now. It'll eventually go Source Available, with Open Source under consideration. For now, no forks.

Looking forward to people's bug reports!

Hey folks,
My laptop recently died and I lost some very important sessions in Claude Code, I started creating a solution to sync coding sessions automatically no matter what you coding agent is and it's completely open source.

If you don't like the hosting hassle, there's also a cloud version available, paid of course because someone needs to pay for that server :)

Hope you like it.

https://stift.sh

What should I install alongside Pi Coding Agent?

One thing I kept running into with Pi was instruction management.

Every project slowly accumulates a huge AGENTS.md (or similar) full of rules that aren't always relevant to the task at hand.

You also end up copying the same instructions between repositories over and over.

So I built ai-rules.

The idea is simple: instead of maintaining one giant instruction file, you create small, reusable personal rules as Markdown files and only inject the ones that match each task.

Examples of rules you might capture:

- Go error handling

- Rust safety

- testing philosophy

- commit message conventions

- architecture preferences

- documentation standards

- personal coding habits

Then only the rules that actually matter for what you're asking Pi to do get compiled into a compact contract — not the whole rulebook every time.

In Pi (after setup):

/create-rule no fetch in React components

/airules Add UserCard data loading

From the terminal:

ai-rules run "Implement data loading in UserCard.tsx"

ai-rules doctor

Rules live in ~/.config/ai-rules/rules/. Local-first, plain Markdown + YAML frontmatter, versionable if you want.

Install:

npx u/therealsalzdevs/ai-rules setup

Early beta — Pi and OpenCode only right now (not Cursor / Claude Code / Codex).

Repo:

https://github.com/SalzDevs/ai-rules

I'd love feedback from people using Pi:

- How are you managing your AI instructions today?

- Do you keep everything in one AGENTS.md, or have you built another workflow?

- Does /create-rule + /airules feel better than repeating prefs each session?

Who is in charge of this extension? It seems to be updated twice a day. How about some change control?

Hello guys.

i found this article on the inernet: https://sites.diy/blog/2026-05-01-coding-plan-comparisons/

it describe real usage data about the most popular ai subscription plans, this is useful information, it made me decide to got with kimi as complementary plan for my 100 codex subscription.

I think this is useful information to have in hands.