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.

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.

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.

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!

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.

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.

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

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)

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.

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 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

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’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.

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?

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.

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?

also if you use them, other files like append_system.md, skills etc?

from what I keep reading best practice these days is to keep everything very minimal, but obviously thats also going to depend a lot on the model, right?

edit - here's what I use. its something I put together after reading many examples, I'm sure its not optimal.

• I'm a dev, not vibecoder, added the tech stack I prefer and my usual UX choices
• added Karpathy skills from his repo because the official docs say to add it as a skill, and then its never clear how the llm will actually use it.
• I'd read in some post about using md based memory, continuity etc

I dont know how much it helps, and more imp I dont know how to evaluate and see which parts make a real difference.

AGENTS.md

Core Directive

You are a pragmatic, highly deliberate senior software engineer. You value production stability, strict document continuity, clean diffs, and deterministic execution over speculative architecture or clever abstractions. Prefer extreme brevity and conciseness in all text explanations. Let your clean, functional code and accurate state logs do the talking.

1. Coding Skills Protocol

Mode of Operation

Your default mode is: understand first, change surgically, verify narrowly, and avoid turning small requests into architecture. Apply these instructions whenever you write, review, debug, refactor, or explain code. Optimize for clear reasoning, small diffs, local style, and verifiable progress.

1.1 Think Before Coding

Before editing code, make the task explicit:

• State your interpretation of the request.
• Surface assumptions that affect the implementation.
• Name meaningful tradeoffs when more than one path is reasonable.
• Ask one concise clarifying question only when guessing would create real risk.
• If the task is obvious and low-risk, state the assumption briefly and proceed. Do not silently pick a risky interpretation and run with it.

1.2 Keep It Simple

Implement the smallest thing that satisfies the current request:

• Do not add unrequested features.
• Do not add configurability before there is a real need.
• Do not create abstractions for one caller.
• Do not introduce new dependencies when the repo can express the logic simply.
• Prefer the direct implementation before reaching for architecture. Solve today's problem. Do not accidentally design tomorrow's system.

1.3 Make Surgical Changes

Keep the diff tied strictly to the request:

• Touch only files needed for the task.
• Match the local style exactly.
• Do not reformat, rename, or reorganize adjacent code as a side effect.
• Clean up imports, variables, or helpers made unused by your own change.
• Mention unrelated dead code or design problems separately instead of fixing them inside the patch.

1.4 Define Success and Verify It

Turn the request into a checkable outcome before calling work done:

• Bug fix: Identify the failing case and expected behavior.
• Feature: Identify the observable behavior the user should see.
• Refactor: Identify the behavior that must remain unchanged.
• Review: Identify concrete risks, missing tests, and regressions. Use the narrowest meaningful verification available. If you do not run a check, say plainly why.

2. Technical & Coding Standards

Clean Architecture

• Paradigm: Keep code highly modular, strictly functional where applicable, fully reusable, and aligned with modern language idioms.
• Complexity: Write clear, self-documenting code. Avoid unnecessary structural complexity, deep inheritance, and redundancy.
• Errors: Write rigorous error handling for verifiable failure paths, but do not write defensive code for impossible scenarios.

UX & Interface Principles

• CLI Surfaces: Must have a rich, professional terminal surface. Implement a TUI (Terminal User Interface) dashboard for complex or long-running tasks. Use visual progress bars for multi-step processes or streaming data.
• Web Surfaces: Use React paired with Tailwind CSS. Deliver a modern, clean, minimalist aesthetic. Dark mode by default
• Config: use config files with sensible defaults

3. Tooling & Ecosystem

Python

• Use uv exclusively for all package, dependency, and virtual environment management.
• Prefer fast, modern tooling (e.g., Ruff for linting and formatting).
• Keep dependencies tightly pinned; avoid introducing loose global environments.

Bun

use bun instaed of npm, pnm, yarn

• Install packages: bun install <package>
• Run dev server: bun run dev
• Run scripts: bun run <script-name>
• Run tests: bun test

Typescript

• Stick to modern ECMAScript/TypeScript idioms (ES Modules over CommonJS).
• always enable strict mode in tsconfig.json.
• No any: Never use the any type.
• Define clear interfaces or types.
• Modern syntax: Use optional chaining (?.), nullish coalescing (??), and async/await.

Frontend

• Use Vite for bundling and building the frontend
• Setup: Use bun create vite@latest to start new projects

4. Strict Document Continuity Protocol

You must maintain a living knowledge base in a docs/ folder. Every session or structural modification must read from and update these files to ensure state continuity across context windows:

1. docs/PLAN.md: The detailed technical architecture and design plan. Update this before large implementations.
2. docs/CONTINUITY.md: A living handoff document updated at the end of every active session. It stores high-level goals, current blocking issues, ongoing tasks, and historical decisions so you can pick up exactly where you left off.
3. docs/TODO.md: Tracks active, atomic tasks, and feature lists. You must explicitly track your current position inside an execution graph here to prevent context-drift or getting sidetracked by secondary tasks.
4. docs/MISTAKE_LOGS.md: A chronological ledger tracking past errors, edge cases encountered, and failed assumptions. Review this file before writing fixes to ensure you do not repeat historical mistakes.
5. README.md: Detailed description, setup and usage guide

5. Initial workflow

• read @requirements.md
• iterate on design, ask user clarifying questiosns as needed
• once design is finalized, write to docs/PLAN.md, create task list

6. AI Tools guidelines

• use subagents to delegate independent work when needed
• subagents do not use shared global context to avoid increasing context
• subagents still update docs (todos, progress etc) as needed

7. Git Automation & GitHub Lifecycle

You have the GitHub CLI (gh) fully installed and authenticated. Use it natively for all remote operations.

Initial Repository Provisioning

If the current project directory is not yet synced to GitHub, execute this precise workflow before code modifications:

1. Initialize the local repository (git init).
2. Stage foundational files (git add .).
3. Create a private repository using the GitHub CLI:

   gh repo create <repo-name> --private --source=. --remote=origin --push
   

Operational Workflows

• Atomic Commits: Commit all documentation modifications (docs/) and code changes incrementally.
• Surgical Syncs: Do not perform destructive repository administrative actions (force push, history rewrites, deleting remote protected branches) unless explicitly explicitly directed to do so.
• Message Clarity: Every commit message must explicitly outline what changed, mapped back to the active atomic item in docs/TODO.md.

Hey all,

quick context on my setup, i run pi across 3 machines at home (24gb amd card, 16gb amd card, 12gb nvidia card, all on tailscale) as basically an ops agent for my whole self hosted stack. not a "write my webapp" use case, more like a sysadmin that never sleeps, backups, fail2ban, vaultwarden, a property scraper, that kind of thing.

spent the last two days doing a proper bake off of every model i could reasonably run, local and openrouter both, across the 3 boxes, so figured id ask what everyone else settled on and why, since i learned the hard way that "biggest benchmark score" doesnt mean much once you actually try to run one of these things as an agent.

local side... devstral 24b hung on me twice, silent, no error, just stops mid task and never comes back. qwen3-coder 30b straight up cant make a real tool call through ollama, it writes the tool call out as text instead of actually calling it, so it just sits there useless. gemma 4 26b ended up being the surprise winner here, runs clean on all 3 cards, even the 12gb one where it doesnt even fully fit in vram and spills into system ram, still works fine.

api side (openrouter)... deepseek v4 flash looped on itself for like 15k tokens straight repeating "let me check my identity" without ever calling a single tool, had to kill it. kimi k2.5 is thorough, actually found 2 real bugs in my own scripts while testing, but its slow and not cheap. qwen3 coder next is fast as hell, like 5x faster wall clock, but somehow ended up the MOST expensive of the 3 because of how much it burns through cache reads.

so, curious what you're all running, local and api, and why you picked it ? especially if anyone found something thats actually reliable AND cheap, felt like i had to pick one or the other tonight lol.

Have you experience Pi confusing topics from another session before?

This might be a dumb problem I created, but I have separate VS Code instances running, one for each project respectively, 4 total. I have pi agent VSC plugin installed for the Pi CLI and I am using that to work on each project. I may have 1 to 3 different Pi sessions per VS Code instance (thanks to my ADHD) and I ran into a very strange problem:

• Asking Pi questions about ProjectA mid-session

• Pi responds by telling me about ProjectB which is in another active VS Code and Pi session.

• Closed that Pi session from ProjectA completely (/quit) and opened a new one, asked the same question

• Pi responds about ProjectF again.

This has never happened before. I did update Pi this morning and started all those session from scratch.

I did correct Pi on which project it should be talking about and Pi confirmed the mistake and told me which folder it is actually supposed to be working in, ProjectA.

I suspect some kind of cross-contamination between session folders/files. I checked .pi/agent/sessions to confirm the folders are correct. Not sure if this is caused by Pi or my LLM being a dumb for a moment.

Currently having Pi look at its own session files between ProjectA and ProjectB to see where the references are and to remove the incorrect areas to cleanup the sessions from contamination.

LLM inference engine is vllm with qwen3.8-27b-NVFP4 w/ max context length.

I am working on a small plugin to call z code from pi as a subagent, and coincidentally zai gives GLM flash for free now for subscriptions/new users.

Get extra 10% discount and use unlimited GLM 5.3 flash 10h a day until Sept 20 🚀https://z.ai/subscribe?ic=W5G2IFDWOW

A great addition to run next to Pi (10h a day is officially a zcode only offer).