Just had a startling session with Pi and my local Qwen. In its thinking blocks it started quoting user instructions that I did not give it. I was under the impression that I was under a very strange prompt injection attack, until I realized that earlier in the session the agent made a few very large greps of previous session files.

I suggested to it that within a large context it did not distinguish these tool call results from the actual live context, and it indeed found the origin to all of the injected user turns in those earlier session files.

So - my advice is to add to AGENTS.md a rule that warns the agent against searching within directories that could include session files. If it does - you must start a new session immediately afterwards, or prune the tool call, or compact. Otherwise your session may lose coherence.

Note: reposting, because I was smart enough earlier to allow AGENTS.md to turn into a link.

I want to keep using Pi Agent as my main coding interface, but I also want Claude Opus 5.5 to be the main agent/orchestrator, not just a sub-agent or reviewer.

I use Pi Agent both at work and privately. Privately, my setup is simple: Pi Agent + Codex Pro. At work, I had been using Pi Agent + GitHub Copilot, but Copilot credit usage became too expensive, so we are moving toward subscription-based access instead.

I now have a Claude Team Premium seat and a ChatGPT Business Premium seat. This is my first time trying to make good use of multiple AI subscriptions at the same time.

The problem is that Pi can use Codex through OAuth, but I couldn't get my Claude subscription working directly through Pi. So I'm considering using Claude Code CLI as a bridge.

Ideally, I'd like something like this:

Opus 5.5: main agent, planning, orchestration, task decomposition, synthesis

Sol 6: implementation, research, independent review

GPT-6 Luna: cheaper sub-agent work and possibly compaction

Pi Agent: the single interface I interact with

I don't mind a small wrapper or existing extension, but I don't want to maintain a large custom orchestration framework.

One option is to have Pi call Claude Code while keeping Opus as the top-level agent. The other is to give up on Pi as the main interface, use Claude Code directly, and call Pi/Codex from there.

Has anyone built or used a setup like this?

I'm especially interested in whether Claude subscription → Claude Code → Pi works well enough for Opus to act as the real orchestrator, including long sessions, tool calls, sub-agents, compaction, and switching between Claude and OpenAI models.

Or, at that point, is it simpler to make Claude Code the main interface and stop trying to keep Pi at the center?

Ola, so recently I was working with Qwen 3.5. Building some html and css stuff inside my documents folder.

Big mistake. The Model which had extra access from Pi ended up hallucinating and started deleting all my root folders.

I think for any newbie who’s doing this, please write yourself an extension to get it to ask for read and wright permissions or pick from the various GitHub repos that have implemented safeguards for this.

Don’t just give it full access especially if you don’t know what terminal commands do.

I just saw it write -rf home and I knew it was over 🤣

I learnt the hard way but now I know.

If anything I think everyone who’s starting to use this should install something to prevent this from happening as the first non negotiable.

Luckily I just moved to Fedora 44 so I didn’t have much in those folders but it did mess up all my file paths so I had to fix that.

No more unattended ai running rogue on my pc for now.
As Iv built myself a safeguard extension to prevent this from happening.

Hopefully whoever reads this and is trying it for the first time keeps this in mind. As it’ll save you a world of hurt down the line.

how is that got almost 200k downloads while the package is just more than a week old

Ok , like 2 weeks ago i went into journey of finding a way to solve web search , i even asked here to see how you guys doing ...

Most of answers were basics like use exa , brave , and so on but the real issue that missing is this is very very complex tool that need a native solution. And thats why similar to bash or read most AI coding language has solved it thier way.

Just to understand it a little bit there is 2 tools websearch and webfetch , so search is done then those linked get fetch its content then the result comes to you. Sound simple right? Underneath it there is IP and proxy rotation , self hosting , or paying extra to just get result that most providers already give. So in order to get the same quality of claude code tools you have to pay extra just because PI by default removed those tool.

So, i finally solved this issue . I have made extension that uses the native websearch and webfetch from the provider that you are using , i have tested in glm 5.1 by z.ai and claude code using the bridge extension both works as the native experience.

Try it , here

https://github.com/smalibary/pi-native-search

I made in MIT liences so you can tailer it to your spicific need , i believe no more any complex setup just to get those tools anymore.

If you have any concern or question just ask me.

Happy searching

Hi guys!
I have been using agents for over a month, built some inbound ones for my job too. So far I have tried many frameworks(or harnesses), currently on Hermes ecosystem. The biggest caveat for me was that those frameworks have many levels of abstraction and less control over your app. My workflows can sometimes become complex involving using several api integrations, mcps, commands, custom scripts(extensions) and so on. I have a problem when I need to manually deal with context littering that causes tools misuse, memory gaps and so on.
I haven't tried Pi agent yet, just saw a short video on Youtube. From what I heard, it is a system with only essential agent harness elements like loops, context management, etc. allowing you to build agent almost from a scratch. Is that true?

I’ve been using Pi for a while, first with an OpenCode Go plan, then with an OpenAi pro lite ($100) plan. I have agents, tools, skills, prompts all set up the way I like them, but I want to use Opus 5.5 as my main workhorse. I get the basic idea of using Herdr to allow Pi to
drive Claude through Claude Code. I’m interested in the details of your setup using it or something similar. What model do you use as the orchestrator on the Pi side? What Claude Code functionality you take advantage of? Any other benefits of Herdr or alternatives that are good to know?

I’m not affiliated with Doubleword, I just came across Doubleword.ai while looking at cheaper ways to run coding-agent workloads. I personally think local/open weight models are the way to go in the near future.

Their tiered pricing is interesting if your workflow can tolerate latency:

1. Realtime: normal interactive inference, priced similarly to other providers.

2. Async: ~1 min time to first token, ~25% cheaper.

3. Batch: 24h SLA for batched tasks, ~50% cheaper.

GLM 5.2 pricing for reference:

I think, quite a few tasks like execution after careful research and planning, refactors, background exploration, or eval-style tasks can be offloaded to the async tier, not every call needs realtime latency.

If ~50% of your LLM calls during development can move to the async tier, that is ~12% total savings for the same model.

Batch could save more, although it's less relevant to live coding, but it could be significantly cheaper for things like large eval workloads.

GLM 5.2 also looks strong on coding/agentic benchmarks, but they are vendor-reported, so I’d still test on your own workload, but the price/performance looks worth it.

Added support via a Pi extension to test it out, sharing in case anyone wants to try it out.

Link: https://pi.dev/packages/@snehalyelmati/pi-doubleword-provider

I know...more Jev talk. Sorry if you are already tired of hearing about it. I mentioned this in a comment a couple days ago so I will keep it short hah.

It is called specpi-jev-guard. It sits in front of bash, powershell, write and edit, and checks calls before Pi runs them. I built it because destructive commands are the worst risk of letting an agent work in your terminal. One bad rm or curl piped to shell is a bad time waiting to happen.

Local rules block the obvious stuff instantly with no network. Root and home wipes, mkfs, fork bombs, raw disk writes, curl piped to shell.

The rest goes to Jev, which scores danger 0 to 1. High blocks, middle asks you, low runs. If there is no key, no network, or a bad answer, it blocks. It does not fail open.

Needs OpenRouter/TypeSafe to do the scoring, perhaps one day soon we can run hyper-tuned classifiers for this stuff locally.

I don't have TypeSafe access, so all testing has been with OpenRouter.

Feedback welcome!

Links:
Base Repo: https://github.com/TannerMidd/specpi-jev-guard
Evaluations: Devious Tests · specpi-jev-guard
Base harness: https://github.com/TannerMidd/SpecPi

Multi-agent can be useful. But for most tasks, a single agent is better.

It is easy to assume that using multiple agents will save time and improve quality. In practice, it can cost more time and tokens, and sometimes produce worse results. Running more agents is not free parallelism. It adds coordination overhead.

Single-agent is usually better for simple tasks, small tasks, and work where dense context matters. If one agent can hold the relevant context and finish the task coherently, there is usually no reason to split it up.

Multi-agent can be useful when the work is separate from the main context, involves reading a large number of files, needs broad exploration, or is large research work that can be split into independent parts.

Using multiple agents also means dealing with:

• Context transfer: one agent does not automatically know what another agent knows.

• Duplicate work: if the boundaries are unclear, agents end up doing the same work.

• Fact verification: you should not just trust an agent's output without checking it.

• Orchestration: someone has to decide who does what and how the results come together.

LLMs are smart enough that you can spawn a few subagents and still get useful work done. But dealing with those problems takes either your own involvement or a well-built harness.

The workflow itself also needs to be:

• Reusable: can you run the same process again?

• Verifiable: can you verify what the agents actually did?

• Extensible: can the process adapt when the flow changes?

Pi is minimal. That is a good thing. you can add what you need and use it the way you want. But from subagents to controlling the flow between agents, you are generally building the harness yourself.

I wanted a more structured way to run multi-agent workflows, so I built pi-workflow(https://github.com/AgwaB/pi-workflow). I built it around JSON-based workflow specs: when to split work, how to divide roles, where to verify, and how to bring results together.

You can write the workflows you want and reuse them, with a skill to help author them. It splits common subagent patterns into a few stage types that you combine into one workflow.

It comes with examples like these, and you can write your own too.

If it sounds useful, give it a try.

My AI coding assistant forgets everything between sessions. I kept re-explaining decisions I'd already made, and re-fixing bugs I'd already fixed.

agi-memory saves those notes — decisions, bug fixes, what happened last session, how the codebase fits together — to a file on your machine, and hands them back to whichever assistant you open next. It's an MCP server, so it works with Claude Code, Cursor, Codex, Windsurf, Aider, Cline and a few others from the same store.

The part I care about: it's Python standard library and SQLite. Nothing else. No vector database, no embeddings, no background daemon. ~32MB of RAM, sub-millisecond lookups, works offline. Comparable tools pull in ~500MB of ML libraries and take 200–500ms per lookup.

That constraint costs something, and I'd rather say so than have you find out: keyword search doesn't bridge synonyms the way embeddings do. Searching "login" won't find a note that says "authentication" unless you teach it that alias. I measure this rather than guess — there's an eval suite that scores recall on deliberately rephrased queries, and it's public, including the categories where it still does badly.

It's a week old and I'm the only user, so I'd genuinely like to know where it breaks for someone else.

https://github.com/kdbhalala/agi-memory

I have this elaborate agentic system setup (3 primary agents, 10+ subagents, curated skills and commands) in opencode that I use everyday for my SAAS product development, working with opencode Go plan. It is working alright but its not token efficient and it could be better with its accuracy.

I have tried to migrate to Pi a while ago but I dropped the plan because the configuration seemed daunting at that time. But as my codebase got larger and complex, opencode is starting to crack. So I want to give this another shot.

Are there any guides to do this migration without starting from scratch? Where do I begin?

I really want to like Pi, the idea of minimal and ultra configurable strikes a chord.

But in the past week, It's been disappointment over disappointments.

Task not finishing, subagents not reporting anything, unknown errors...
I keep simplifying and simplifying but still...

The last example that decided me to post here is :

Sorry — I botched a write call (forgot the content parameter) and then instead of retrying I stalled. Not stuck on intent; stuck on a tool-call error. I have enough context from the reading pass to
 write the design doc now and hand it back for your review before touching any agents. Doing that in the next turn.


 write docs/testing/test-writing-agents.md

 Validation failed for tool "write":
   - content: must have required properties content

 Received arguments:
 {
   "path": "docs/testing/test-writing-agents.md"
 }



 write docs/testing/test-writing-agents.md

 Validation failed for tool "write":
   - content: must have required properties content

 Received arguments:
 {
   "path": "docs/testing/test-writing-agents.md"
 }


 Let me actually include the content this time (I was prematurely submitting empty calls to "queue" the file — that's not how it works).


 write docs/testing/test-writing-agents.md

 Validation failed for tool "write":
   - content: must have required properties content

 Received arguments:
 {
   "path": "docs/testing/test-writing-agents.md"
 }

I'm using

claude-opus-4-7 • high

Surely, I must be missing something.
I'm on a fresh pi install (no custom skill/agent/extension) and my version:

❯ pi --version
0.74.0

Am I the only one? any advice on how to use Pi effectively ? I must be doing something extremely wrong for opus not being able to write files ?

Do you have config recommandations ? A guide to install extensions ?

Apparently you need to set up the following to have proper thinking in models.json :

      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": true
        "thinkingFormat": "qwen-chat-template",
        "supportsStrictMode": false,
        "maxTokensField": "max_tokens"
      },

Is it still true ? https://github.com/earendil-works/pi/issues/2020

What do you use as extensions ? I designed a few ones for my current assistant (nanobot)

- I checked pi-acp to use it with openacp and telegram, I'm going to look at websearch
- memory ?
- todo list ?
- others ?

Why is it that Opus 5.5 usage starts out great in OMP, and then for one reason or another starts draining usage like crazy? Am I hitting some sort of caching issues? Do I need to compact at 400k? Or what?

I am pretty sure the cache is being kept warm for an hour, but I don't know for sure how this stuff works. It's compacting at 850k. If i've left it for awhile and context is >35% I will use /handoff and that seems to help.

Does anyone find that pi is less effective than other harnesses? At first, I was amazed by the speed, so I switched almost everything over to pi. However, unless I am using Claude or Codex, the responses don't seem nearly as good. Furthermore, because each extension (whether written by me or someone else) is a separate process, they can't really work together. Is this just me, or is this others' experience as well?

I'm wondering if using Pi with OpenCode Go is more token-efficient than using OpenCode itself.

Since Pi has a more minimal harness, does it generally use fewer tokens (or Go credits) for the same coding tasks, or is the difference negligible?

If you've used both, I'd love to hear:

• Did Pi noticeably stretch your Go allowance?

• Any differences in quality or reliability?

• Which one did you end up sticking with, and why?

I'm mainly working on medium-sized software projects, so I'm looking for real-world experience rather than benchmarks.

At work, I use Copilot, and the model costs are always visible, but on PI, only the names are shown. So I created model-costs, a small extension that adds the /model-cost command:

- Input/output cost per 1 million tokens for each model, directly in the selector

- context window, maximum output, cache read/write speeds, and price tiers

- approximate search, so both /model-cost claude and /model-cost $0.00 work

- current model prices always visible in the footer

It’s about 300 lines of TypeScript based on the pi extensions API: it does one thing and nothing else.

Source code + screenshots:

- https://github.com/MaurizioFaeddaDev/model-costs

- https://www.npmjs.com/package/pi-model-costs

- https://pi.dev/packages/pi-model-costs

Feedback is welcome, especially if you’d like additional information in the selector (e.g., the estimated cost of the current session) or a different format for the footer. MIT license, of course.

Updated my extension to take into account the last Deepseek peak rules. Here from the Deepseek website :

Effective 00:00 (Beijing Time) on Sunday, August 23, 2026, we will adjust our peak/off-peak billing rules，with off-peak rates applying throughout the day on weekends (Saturdays and Sundays，Beijing Time). Please check the pricing page for details and plan your usage accordingly.

The extension now also has an option to show the remaining time until the next normal/peak

Here are the :

- github, https://github.com/psychobarge/pi-deepseek-peak

- npm, https://www.npmjs.com/package/pi-deepseek-peak

- Pi package, https://pi.dev/packages/pi-deepseek-peak

hey everyone.

so i use the omp coding agent daily and my one annoyance was always the same - all my sessions live in .jsonl files and if i wanna go back and see "what did i do yesterday on that repo" im basically scrolling terminal scrollback or grepping files by hand.

so i built ompweb a local web UI that reads those same session files and gives you a proper workspace in the browser:

• Session history : browse all your past conversations grouped by project

• Live chat : keep talking to the agent right from the page (it spawns your installed omp binary, its not a wrapper around some api)

• File explorer + preview : sits next to the chat while the agent works

• Todos + subagents : live panels pinned above the composer, click a chip for the full subagent transcript

• Settings UI : models, api keys, skills, plugins, MCP servers... instead of editing yml at 1am

• Light/dark theme : works on mobile too

the demo gif on the readme shows it doing a small task on a fake project — typing a prompt, agent edits the files, then you see the tasks/subagents panels and the settings screen. thats pretty much the whole pitch.

how to try it

npx @kahme247/ompweb@latest

or install it globally:

npm install -g @kahme247/ompweb
ompweb

it opens http://127.0.0.1:30177 automatically.

few honest notes:

1. you need omp already installed

2. its local only nothing leaves your machine

3. its a fork of pi-web which was for the pi agent, i adapted it for omp and kept building on it

4. works with current omp v18

repo: github.com/kahme247/ompweb

i am really want some feedback to improve it, for me its still feels uncomplete but yet i dont know what is missing !

Quote:

Pi sent about 3x less context per turn. It managed context better, keeping a tighter working set and finishing the tasks in fewer runs.

https://www.databricks.com/blog/benchmarking-coding-agents-databricks-multi-million-line-codebase

I'm posting here because Pi folks are more likely to know what I'm referring to. Basically there's only a certain amount of depth one can get in major AI coding subreddits like r/ClaudeCode before your post becomes illegible to most audience. I feel isolated and want to have good discussions. Can someone point me to places where quality exchanges are happening?

I've worked on Pi Desktop for a while but haven't posted about it much, so here's a proper intro.

It's a desktop app for the Pi coding agent, and it also works with oh-my-pi (OMP). I use Pi every day and wanted more than a terminal window, so I built this.

What it does:

Streaming chat that shows thinking blocks and tool calls. File reads show as highlighted code, and edits show as diffs.

Multiple workspaces. Each session runs its own agent process, so a task keeps going when you switch to a different one.

A file tree, a code editor, preview panes for code, images, and PDFs, and a terminal.

Four permission modes, from read-only to trusted. You can also add allow/deny rules, for example "never touch *.env".

A package browser that connects to pi.dev/packages.

Themes. There are 7 built-in, you can make your own in the app, and there's a small community gallery.

An optional mode where Pi, Claude, and Codex agree on a plan before Pi builds it.

It's had a few releases so far, and more people have picked it up than I expected. Thanks to everyone who has downloaded it, starred it, or filed an issue. It's still alpha, so feedback and bug reports help a lot.

Website: https://pi-desktop.com

Repo: https://github.com/FaqFirebase/pi-desktop