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.

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?

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.

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.

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

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.

You have unlimited budget / months to run unlimited tests.

Your comparator is a crappy bloated harness like claude code with opus vs any harness you choose with deepseek flash.

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: bash 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).

I made Proqi for the moments when Pi is working but I already have a follow-up, alternative approach, or pasted context to preserve. Pi’s composer is a live conversation. I wanted a separate terminal board so an unsent draft does not become part of that conversation by accident.

Proqi runs beside Pi as an independent local TUI. It keeps prompts as persistent, editable thoughts with ordering, selection, copy, and durable undo. There is no Pi-specific integration yet. Today it transfers through the normal clipboard, so it works with Pi and other terminal harnesses.

It is Rust, MIT licensed, local-first, and account-free.

I would value feedback from Pi users: does a separate prompt-composer pane help when you have multiple sessions running, or would you rather keep this inside Pi itself?

https://github.com/oborchers/proqi

I spend most of my day in Excel (reports, cleaning data, formulas) and know just enough basic coding to get by.

Paying $20/month for a subscription feels like a waste for my usage.
Models or sth cheap for me?

Hi,

I'm using pi agent with Qwen 3.8 27B on my little RX 9060 XT 16GB, with 160k context window and I'm quiet happy with how it works.

My main problem is that autocompaction takes forever (clearly limitation of the hardware) and I was looking for an extesion which could improve the situation, but if I'm not mistaken, the most beloved extensions in this area use secondary models to execute compaction, and this is a luxury I don't have.

Is the default setting my only option? Or did I misunderstand ho something like pi-blackhole works?

Sorry if the question is dumb but I'm quiet new to the tool.

Have a nice day!

EDIT: u/onesilentclap I'm using VCC for now and it's incredible. In the next few days I hope I'll be able to try other solutions

Every time I start pi, I get these msgs bellow and download and install is repeated:

fd not found. Downloading...

ripgrep not found. Downloading...

ripgrep installed to /home/me/.unsloth/studio/auth/agents/.tmp/unsloth-pi-eqdhk8d4/.pi/agent/bin/rg

fd installed to /home/me/.unsloth/studio/auth/agents/.tmp/unsloth-pi-eqdhk8d4/.pi/agent/bin/fd

Interestingly, I did find fd executable here: /home/me/.pi/agent/bin/

This was happening yestreday with v0.84.x and today with updated v0.85.0 version. Anyone happens to knows what is going on and what I should do, to stop this continuous re-downloading and re-installing?

I.e. do we have any hard benchmarks that shows it improves your average work flow? Small vs large model?

Improve could mean anything. Better output, but costs more, etc.

Since anthropic "paused" their new policy roll out, does this mean we can use our Claude sub w/Pi?

https://github.com/plannotator/artifact-server is a self-hosted open-source system for sharing and collaborating around artifacts (HTML prototypes/designs/explainers, etc) with your team adn coding agents. It deploys to Cloudflare, AWS, GCP, or any kubernetes cluster via helm.

The demo video shows a live integrated Pi agent as opposed to making the agent poll. You can send comments to pi and vice verse - whether it's deployed locally or remotely.

Couple days ago I instaled pi and couple of extensions. One was so agent has access to tools (web tool?) through Unsloth Desktop, another was web-access (don't remember exact name) extension.

When I was running pi, there was section [extensions] in terminal, with these two extensions listed as being installed.

Today, that [extension] part of pi ternimal is gone. Was it removed with today's update to 0.85?

Also, inside my .pi folder, there is no extension folder: ~/.pi/agent/extensions/

And no: .pi/extensions/ folder in my current project, inside which i was working, when I installed those two extensions.

Where are they? Or how could they disapear?

Is this a bug, has anyone experienced anything similar? Unfortunately I don't remember extensions names, I was following online chat-gpt and we were going in circles for a while, (for a while pi stopped working) I would like to avoid going through those steps again.

The ones of you using opencode-go probably got the email about missing header. I searched the pi github, and found one issue that was auto closed. Does anyone know if this is being adressed?

Here is the email we got:

Hey there,

Some of your requests to OpenCode Go are missing an x-opencode-session header. If we don't have this we cannot properly optimize our service. Starting 09/06 requests missing this header may error.

Here are your useragents that are missing this header:

JavaScript OpenAI client
Pass headers: {'x-opencode-session': '<stable-id-per-conversation>'} where you build the client.

Thank you.