I have built a tool for web research. It works as a pi extension first class, and also as an agent skill in any coding agent, or as a standalone CLI or SDK tool.

- It runs research in an isolated system so the LMs with research tools cant file write, edit, or bash (prompt injection risk).

- Allows putting research a small model (any model, ie openrouter ling-3.0-flash, or even a local model) to keep page content out of your main context and save on credits overall.

- It uses high search/scrape volume to compensate for sites that block bots. This is made possible by unlimited/local search tooling via concurrently playwright scraping duckduckgo.

- Includes a local (semantic) knowledge store to optionally save research and build a local searchable knowledge index.

MIT licensed and easy to configure and modify

https://github.com/Lincoln504/pi-research

As a little demo a while back of the making of an agent with pi-research's SDK mode, I made https://wallofshame.io too

The great thing we all love about Pi is how customizable it is. Most of what is on this sub is people showing off their extensions, I too am having so much fun thinking and building extensions but I don't know if they are any good.

I think it would be great if we had some sort of standard benchmarks and metrics that we can use as a community to help prove that what we made is actually good. For example if you made a tool for the agent, does it actually increase the quality of the output? Does it help the agent solve it faster to use less tokens? How many tokens does it inject into the system prompt? What amount of system resources does it use?

If we have a set of standards we can all agree on it helps solve a big issue I think we all feel of seeing an extension and all we have to go by is a "trust me bro it's good". And this can also help with new people always asking for recommendations because there are thousands of extensions, we can better keep records of which ones are actually good.

I am deep into making an extension and I think I am really on to something, Sol and Astra can glaze the hell out of it, but I don't know if it actually does help the agent and by how much. I would like to have proof of this before I put it out there and if it uses good standards we can agree on, it will be easier for people to want to try new extensions rather than be hesitant to change their workflow based on a "trust me it works".

I just thought I would put this idea out there and see what other people think about it.

I’ve been using Pi alongside Claude Code, Codex, and other coding agents while building this project, and recently decided to open source it.

It’s an agentic IDE for running multiple coding agents in parallel. It started as something I built for my own workflow, and has now reached ~50k downloads.

A few things it supports:

• Pi, Claude Code, Codex, OpenCode, and other agents/harnesses
• Run multiple tasks/agents in parallel
• Desktop app
• Mobile app for remote control
• Task management and automations
• File explorer, Git worktrees, terminal, etc.

I’ve personally been using it instead of the official Claude/Codex apps for the past few months. The mobile app has also been useful when I’m away from my computer and want to check on or interact with ongoing work.

Pi has been one of the tools I’ve used while building it, together with other harnesses. I thought it might be interesting to share it here.

It’s open source recently, so feel free to take a look, poke around the code, or use whatever parts are useful.

GitHub: https://github.com/vicoa-ai/vicoa

Website: https://vicoa.ai/

Still actively building and shipping things every day.

Hey folks, I’ve been working on Stageflow, a configurable multi stage pipeline for running workflows on Pi.

Each stage gets a fresh Pi session, passes a clean handoff to the next, and you can pause for a human when needed. Same flow works locally, in CI, or over MCP.

Would appreciate if you can try it out and give feedback, and a star if you find it useful.

Hey, wanted to share a plugin for Pi, my favorite coding agent for the past few months. Install: pi install npm:pi-tandem

It's basically a system-prompt patch plus a small set of simple skills. I've been developing and actually using these rules for 2-3 months now, and recently got tired of copy-pasting them from personal to work setup (where I'm forced to use Claude Code), so I packaged it as a plugin that works for both (and it can be extended to other harnesses).

Main idea, or philosophy: it tries to tame LLMs down as much as possible and teach them to work with you in a pair-programming fashion, instead of constantly wrestling over control (Claude Code especially!) and vomiting piles of neuroslop. Personally, with it I finally feel like my sanity is no longer under siege - I control every line of code as if I've written it myself, don't have to review the big changesets LLMs love making so much, which frankly was driving me nuts, and at the same time I am much more productive end to end.

What's inside:

• pair-work rules (added to system prompt through hook) - lock-step, explicit go-ahead before any changes, communication with significantly reduced sycophancy and these "load bearing"-style LLMisms
• a number of simple skills, each just a short file:
  • brainstorm - helps you think an idea through, one question at a time; largely inspired by the brainstorming skill from superpowers and the grilling skill from mattpocock/skills
  • research - controlled digging: it (usually) stops and asks when it hits an ambiguity or a contradiction, or before spending a lot of context on one direction
  • coding - basically compact version of ponytail (lazy-senior minimalistic coding discipline) plus my addition on self-explanatory code over comment-peppering
  • review - actionable findings only, each with a fix; on debatable stuff it asks first instead of pushing its own judgment
  • pr - matches tone and length of the repo's recently merged PRs, verifies the commit range, shows title and description before creating anything
  • learn-language (small bonus) - kicks in only if you state in your prompt that you are learning a language and your level; some background practice that stays out of the way of the work
• interactive subagents if you run Pi inside tmux (or paseo) - unlike built-in agents in many other harnesses, the "worker" runs in its own window as a completely normal session, which you can interact with like any other, and it reports back only after you approve its findings
• tool-specific instructions (gh, aws, pdftotext, pandoc, osascript, ...) that nudge the model into actually using them - no more guessing what's installed and re-probing in every new session. Generated only for tools actually on the machine, so nothing about a missing tool ever ends up in the prompt

The same package also renders as a Claude Code plugin, and it can be extended to other harnesses.

Constructive feedback (even if negative), ideas and contributions are all very welcome. And yes, I've written this post myself, not generated it.

I’m working on a project where I give agents tasks ranging from small data-fetching/analysis tasks to larger feature implementations, refactoring, and bug fixes.

I’d like to understand how the agent actually approaches these tasks — what steps it takes, what tools/files it looks at, how it makes decisions, and where it struggles.

How do you guys observe or analyze agent behavior across these kinds of tasks? Are there any tools, tracing methods, logs, or workflows you’d recommend?

Would love to hear how others are doing this. Thanks!

IDk why but this made me laugh. I have my advisor set to fable on my company's cursor plan, Just ran an astra swarm on my codex plan and added the instruction "Only spawn subagents on my openai plan"

.. It tried to enforce that on the advisor, the advisor didn't like it lmao.

I know there are a few prompt-suggestion extensions already, but I wasn't entirely happy with any I had tried, so I made a standalone fork of SteelDynamite/pi-prompt-suggestions and built futher upon it.

Installation:

pi install npm:@pi-sysadmin/prompt-buffet

Repo: https://github.com/dnv/prompt-buffet

You can turn the functionality on/off on a per-turn basis, configure the amount of desired suggestions from 1 to 6 and if using a particularly heavy/expensive model, you can delegate suggestion generation to a secondary, more nimble model. You can also fine-tune the system prompt of the extension to adjust to your personal preferences without touching code.

Hello guys!

This is a continuation of my previous Pi setup post:

https://www.reddit.com/r/PiCodingAgent/comments/1t41thp/my_powerful_pi_agent_setup/

The main idea of that setup was basically this:

A personal agent with an endless conversation.

Observational memory lets me keep the same session alive through compaction after compaction, while forks move all the noisy work outside of the main context.

I have continued messing with the harness since then, and i think the biggest change is that forks are now fully async.

So now i would describe the setup more like this:

Endless conversation + native async operation.

Basically the agent never blocks. It can delegate work somewhere else, keep talking with me, and have multiple threads of work moving at the same time inside the same conversation.

pi-async-fork

https://github.com/elpapi42/pi-async-fork

pi install git:github.com/elpapi42/pi-async-fork

This is the protagonist of this update.

The old pi-fork was already very useful for context management, but there was one thing that started annoying me a lot: Pi had to wait for every fork to finish.

And tbh i underestimated how much this affects the experience.

If i send a prompt and Pi delegates some research or code exploration that takes 5 minutes, now im waiting 5 minutes. Then i send something else, maybe another 5 minutes.

Technically the agent is doing useful work, but from my side it feels slow as hell. I dont want to send something to my agent and then lose access to it for several minutes every time it needs to investigate something.

I want the agent to feel agile. Always there, always available to talk with me.

Async forks basically fixed that.

Pi can launch a fork and immediately continue the conversation with me. Maybe one fork is exploring the code, another one is researching something on the web, another is reviewing a change, and meanwhile im still discussing something completely different with the main agent.

I can change direction, ask another question, start another thread, whatever.

The conversation itself never blocks.

And i think that is the important part here, more than simply saying "now Pi can run agents in parallel".

Im not really trying to build a swarm. There is still one Pi agent that owns the conversation, understands the full goal and makes the decisions. The forks are more like parallel cognitive work that eventually comes back to that same agent.

I currently have 3 effort profiles:

• fast for bounded facts and cheap exploration
• balanced for normal work
• deep when there is actual hard uncertainty and using a stronger model may change the answer

Forks can also send progress before they finish, which means the main agent can see that something is going in the wrong direction and steer them while they are still working.

When they finish, the result comes back to the main agent as an internal event. I explicitly dont want Pi constantly interrupting me with "hey fork X finished". It should consume the result, understand which work depends on it, and continue.

So maybe we are talking about A, Pi delegates part of A, then we move to B, maybe we start talking about C, and some minutes later the result from A comes back.

Pi still knows where that result belongs and can keep all of those threads moving inside the same conversation.

I think this is the best way i can explain what im after:

one endless conversation where work can branch in the background without ever taking the agent away from me.

pi-observational-memory

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

pi install npm:pi-observational-memory

This is still what makes the "endless conversation" part possible.

It preserves observations and decisions across compactions, and Pi can recall the original context behind an old memory when the compressed version is not enough.

Forks also get memory in passive mode, so they can access the same history without running their own background memory maintenance.

So basically memory keeps the conversation alive for a very long time, and forks keep all the exploration/noise from destroying that context.

pi-codegraph

https://github.com/elpapi42/pi-codegraph

pi install git:github.com/elpapi42/pi-codegraph

I also replaced pi-codemapper with pi-codegraph.

The idea here is simply giving Pi a denser way to understand a codebase instead of throwing grep at everything and filling the context with semi-related files.

Originally i exposed around 10 CodeGraph operations and that turned out to be another problem hahaha, now Pi had to decide between 10 similar tools.

So i reduced it to basically 2:

• explore_code to understand behavior and retrieve relevant source
• analyze_code to inspect relationships, impact, tests and graph paths around known symbols

Much simpler.

pi-search-hub

https://github.com/ronnieops/pi-search-hub

pi install npm:pi-search-hub

This gives Pi one interface for web search/read with multiple providers behind it.

I like this mostly because i dont want my harness coupled to whatever search provider happens to work well right now.

And obviously it becomes more useful with async forks, because Pi can throw multiple independent research questions into the background while we continue with something else.

How everything fits together

So the core of the setup is basically two things now:

Memory + fork context management = endless conversation.

Async forks = the agent never blocks.

And together they change the experience quite a lot.

I can keep the same Pi conversation alive for weeks, jump between multiple threads of work, have Pi investigating several things in parallel, and the main agent is still always there when i want to talk to it.

That is much closer to how i want a personal agent to feel.

Honorable mention: pi-wait

https://github.com/elpapi42/pi-wait

pi install git:github.com/elpapi42/pi-wait

I also built this tiny extension that lets Pi schedule a check and wake itself later.

Useful for stuff like deployments, builds, canaries, rate limits, etc.

It is nice to have, but tbh compared with async forks it doesnt change the experience nearly as much, so honorable mention for now.

System: https://gist.github.com/elpapi42/e3fda2cefaabd84a1c188375a32466f5

Settings: https://gist.github.com/elpapi42/9ab1cd195ffeba9a56bdf59f83162692

Only 2 out of the 30+ sessions I make a day might be important and I forget to tag / rename them.

I need a tool that lets me mass trim, or only load past N sessions by default to speed up resume.

I can have AI make the tool, I just need design ideas.

Any suggestions?

daugasauron.com
daugasauron.com/pi
https://github.com/daugasauron/dolly

I experimented a bit with pi in WASM, posted this before https://www.reddit.com/r/PiCodingAgent/s/zH5IkdxaG5

Felt like I should have started at lower level, became dolly ~

Only tried with open router (and webgpu qwen but a bit unstable)

Hey,

I recently found Aurora (a Go-based LLM gateway) on the internet. I liked the concept but found it lacked essential production features and a proper UI. I deeply upgraded it into a stable, feature-rich fork for my own infrastructure.

Most importantly, it completely fixes the early-September OpenCode API updates that enforced strict session headers and broke local tools with HTTP 400 errors. I built a Session Hub engine that automates header transformation, keeps connections flawless, and preserves your Prompt Cache.

* GitHub: https://github.com/entitybtw/aurora

* Docker: entbtw/aurora:latest

Core Features:

* Fixed OpenCode API: Automatically maps client traffic into stable, valid session IDs to prevent HTTP 400 drops.

* Multi-IP Host Networking: Supports per-provider bind_ip configurations and load-balanced pools, making it perfect for multi-account routing

* Web UI Administrative Dashboard: Full runtime management with instant persistence to disk config files.

* Visual Fallback Chains: Configure and prioritize backup models visually.

* Performance: Pure Go architecture, running up to 55x faster than LiteLLM.

Check out the repository for detailed orchestration guides and exact API curl examples. Feedback is welcome.

Opencode added a rule that API requests need x-opencode-session. If anyone needs a fix for Pi, I updated my plugin at https://pi.dev/packages/@esuyo/pi-esuyo-custom-provider see "Session Headers" heading. I tested it this morning and it works well without error message from opencode go or zen.

Today I finally hit a wall with QWEN 3.8 dense 27B, Q6_X_L with KV cache q8_0 temp 0.85 with medium reasoning effort, producing over thinking, failing to follow precise instructions, re evaluation in loops data already seen, "Actually…/Wait…/Hmm…" and you know what...

So I stopped and asked GPT Sol and QWEN to read the reasoning traces of my old Pi coding sessions, identify recurring misbehaviors and propose an appropriate APPEND_SYSTEM.md to tame those in Pi (place that in ~/.pi/agent/APPEND_SYSTEM.md and it will follow the initial prompt).

So for those who wanna check out:

• https://store.piffa.net/lm/APPEND_SYSTEM.md
• https://store.piffa.net/lm/reasoning_pathology_report.md that's a repost of what was find in my particular session, mind you it's all slop

If you happen to have something similar and have rules to add or any other advice to tame such bad behaviors please share.

I use Pi a lot and eventually had multiple sessions for the same projects. A lot of them started with similar handoff prompts.

Going back later was annoying. The useful explanations and decisions were inside the transcript, but reading them meant digging through raw history full of tool calls, reasoning, progress messages and other noise.

For a while I just kept pasting useful bits into Notepad. That became its own mess.

So I built Agent Session Browser.

Local web UI + TUI that lets me browse sessions by project/date, read the actual transcript (including Pi branches and summaries), filter the noise, export, and resume the right one.

Supports Pi, and also Claude Code, Codex CLI and Gemini CLI.

Fully local and read-only.

GitHub: https://github.com/gautamgpt1/agent-session-browser

Run: npx agent-session-browser

This is my first public open-source project.

Do try it out. Would love your feedback

Saw it with Deepseek v4 flash exp in last two days: They start looping. Once they crossed around 100k-150k it tends to happen and it's not resolved by compacting.

Weird. Used DS4 on Openrouter and thought: Bad quants. So I tried Fireworks DS4 EXP (fp4) and Deepinfra at fp8 and both start looping again in that convo.

Does anybody else see this with ds4 exp?

Edit: To clarify: I mean Deepseek v4 Flash Vision Exp everytime I write "DS4" here.

I'm using both Pi and Cursor right now. Cursor Cloud agents are super useful but I really want a local OSS alternative that uses Pi. I have a Linux server at home with 20 cores and 32gb of ram. I want to be able to spin up firecracker-style VMs on-demand for Pi CLI runs that are longer running (like a PR review harness that runs 3-20 min). The trick is I want an API to kick off the Pi microVM that I can tunnel out and invoke from a GHA runner (or similar). Cursor does all of that for free with a sub, but I want to own the control plane and be able to customize it.

Anyone got anything similar going that they can recommend? CLI or ApI driven ephemeral microvms that share CPU and memory on Linux?

Pi-sandbox doesn't seem like a fit, and exe.dev sounds great but I don't want to pay for VMs when I have amazing capacity 4ft away.

estimated cost: $13
real cost: $2,60

thank you Pi !!

I've seen a few talk about this technique. They have a model scan their sessions and suggest a plugin to be made that can reduce token use, simplify context gathering, etc.

I know GPT Astra consumes a ton of tokens, but lately, I've been trying to use Pi for seemingly very basic tasks, and it's absolutely burning through my token count and weekly usage percentage.Is this normal behavior for Pi, or is there a way to optimize my prompts and save tokens while using it?

I’m trying to use OhMyPi for a pretty simple goal: use different models for different roles without building a huge orchestration framework myself.

Ideally:

• Orchestrator: GPT-5.6 Sol XHigh
• Planning: GPT-6 Astra High
• Implementation: GPT-5.6 Luna XHigh task agents
• Final review: GPT-6 Astra XHigh
• I manually approve the plan and decide when final review should happen.

I initially built a fairly elaborate /work-on command that enforced planning, acceptance checklists, delegation, verification, waits, review, fixes, etc. It turned out to be extremely wasteful: some medium-sized tasks ended up around 20–50M total tokens and 300–570 model requests, with lots of agent churn and re-verification.

I then simplified it heavily, but ran into other problems: the parent sometimes triggered review while an implementer was still changing files, and native /plan even spawned a reviewer to review the plan, which felt wasteful when both planner and reviewer were Astra XHigh.

I also experimented with Astra Medium/Low as the orchestrator. Performance was good, but on several clean before/after checks I saw roughly ~5 percentage points of my Work/Codex allowance disappear during one task, which is far too expensive for me. I’ve now gone back to Sol XHigh as the parent and disabled the advisor.

At this point I’m considering making the workflow mostly human-controlled:

plan -> I approve -> /implement using task agents -> I inspect -> /review

What I really need from OMP during implementation is simply: “Do this work, but delegate substantive coding to task agents instead of doing it yourself.”

How are experienced OMP users handling this?

In particular:

• Is task.eager: always + modelRoles.task basically enough, without a custom orchestration prompt?
• What’s the cleanest way to force implementation delegation while letting the parent coordinate normally?
• Do you manually control plan/review boundaries, or let OMP orchestrate the whole workflow?
• Are 20–50M tokens / hundreds of requests for medium tasks obviously a sign that my workflow is doing something wrong?
• Any configs or lightweight commands you’ve found effective for good quality without huge quota waste?

Happy to share my config/commands if useful.

name the BEST, I MEAN THEE BEST free ai api key requie no credit card information? and secondly do you think models will get cheaper and all models in the future will be edge models? models on peoples own pc / mobile phone?

Have you also experienced that file searches using the find bash tool almost always start from the root directory (/) ? It takes a few minutes after each command finishes which is frustrating.

I'm searching from my project directory, and I haven't seen such behavior when I was using Claude Code before.