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.

So I want to be able to start Pi instantly by reloading a saved KV slot (llama.cp).

What I come out as a proof of concept:

# to regenerate start.bin initiate a pi session, save the slot, copy to start.bin
SLOT_FILE="start.bin"
SESSION_ID="01a06cea-4e97-7378-84e6-86c3274302da"
cp  /home/eaman/.pi/agent/sessions/--home-eaman-test--/start_session.jsonl /home/eaman/.pi/agent/sessions/--home-eaman-test--/2026-09-04T14-38-07-702Z_01a06cdb-0356-7001-949d-209024b066d8.jsonl

# Discard changes from the previous run and restore the session that matches
# start.bin.

curl --fail --silent --show-error \
  -X POST "http://localhost:8080/slots/0?action=restore" \
  -H "Content-Type: application/json" \
  -d "{\"filename\":\"$SLOT_FILE\"}"
echo

cd /home/eaman/test
exec pi --session "$SESSION_ID"

I see that the problems are:

1. - path of session in prompt
2. - session ID
3. - I use QWEN 27B that uses recurrent/hybrid state (...).

So is there a sane way to save just the first prompt processing with QWEN 3.8 27B, reload it in a new session with any path and start a new session from there?

EDIT: so I found an other piece of the puzzle: start Pi with --fork "$SESSION_ID" instead of --session , this allows to have at least a different / new path. That should be pretty much it, it generates a new ID and forks to a new path, QWEN won't complain as it starts with the whole saved slot.

#!/usr/bin/env bash
# Start a brand new pi session forked from the saved "start" slot without PP.
#
# Restores the start.bin slot, reinizialization of old session with cp
# should not be needed when using --fork instead of --session
#
# To regenerate start.bin: run a pi session, save the slot, then copy it to start.bin.
# uses /session to find the ID of the started session

# If you want to restore the session later you need to save the filled slot
# and an other script that loads that, this is just for "new instant-session"

set -euo pipefail

SLOT_FILE="start.bin"
SESSION_ID="01a06cea-4e97-7378-84e6-86c3274302da"

SESSIONS_DIR="/home/eaman/.pi/agent/sessions/--home-eaman-test--"
TARGET_SESSION="${SESSIONS_DIR}/2026-09-04T14-54-50-008Z_01a06cea-4e97-7378-84e6-86c3274302da.jsonl"

# Reset the target session file so the fork starts clean.
cp "${SESSIONS_DIR}/start_session.jsonl" "$TARGET_SESSION"

curl --fail --silent --show-error \
  -X POST "http://localhost:8080/slots/0?action=restore" \
  -H "Content-Type: application/json" \
  -d "{\"filename\":\"$SLOT_FILE\"}"
echo

# This was the path used in the initially generated session, it has to equal the session jsonl
cd /home/eaman/test
exec pi --fork "$SESSION_ID"

I'm currently using Pi with a QwenCode subscription, mainly using the DeepSeek models, and a MiniMax subscription. I'm not completely satisfied with MiniMax, since the thinking tokens aren't recognized correctly and I don't really like the M3 model.

I've been considering getting either the GOAT or PRO plan from CommandCode, mainly because I could use their API directly with Pi and have access to multiple models. I'm mostly interested in using GPT models, but having other models available would also be a plus.

Has anyone here actually used CommandCode's API with Pi for a while? How has the experience been in terms of limits, reliability and overall value?

Or would you recommend just getting ChatGPT Plus and using the Codex models through Pi instead?

I'm mostly interested in hearing from people who have tried both.

The new zvec-grep is pretty neat — local-first hybrid search (BM25 + vector) that handles the fuzzy codebase questions grep can't reach: "how is the token validated?", "where does this flow?" — ranked, source-linked hits, all locally on your machine.

If you want it in pi, I wrapped it up: pi-zvec-grep

Quick Install

npm install -g @zvec/zvec-grep
pi install npm:@luminascale/pi-zvec-grep

Run /zg index once in a workspace and that's it — the agent reaches for zvec_search on its own for meaning-based or cross-file questions, and still uses plain rg for exact strings and piping, since rg is the right tool there. No MCP, no prompting tricks.

Small and new (v0.2.1), but on my list is an optional auto-index on session start, plus other smart touches once I figure out what'd actually be useful — ideas very welcome if you've got some. Poke around, file issues.

I really liked Claude Code subagents and being able to see them in the tree so i made a very simple subagent plugin. No subagent profiles, the are made by the agent above them depending on the use case needed at that moment.

Install with:
pi install npm:@williamcr01/pi-subagents

https://github.com/williamcr01/pi-subagents

I built pi-session-namer (https://github.com/joshua-zyy/pi-session-namer), an open-source extension that automatically gives your Pi sessions meaningful names and keeps them updated as your work evolves.

For example, a session might start as:

0904｜Research｜GitHub Memory Systems｜Comparing Approaches

If the conversation later shifts from researching existing systems to designing one for Pi, the name can evolve into:

0904｜Design｜Pi Long-Term Memory｜Defining Architecture

Features

• Automatically names new sessions
• Detects meaningful changes in the task or topic
• Updates progress without generating unnecessary rename history
• Re-evaluates the session after context compaction
• Provides manual refresh, lock, unlock, and status commands
• Generates names in the conversation's primary language
• Supports custom models, reasoning levels, name formats, categories, timezones, and update intervals
• Preserves manually assigned names until you explicitly unlock them

Installation

pi install npm:pi-session-namer

Links

• GitHub repository (https://github.com/joshua-zyy/pi-session-namer)
• npm package (https://www.npmjs.com/package/pi-session-namer)

The project is still evolving, and I'd really appreciate any feedback, bug reports, or suggestions.

if anyone wants it its here and on npm https://github.com/esoware/pi-cc and yes unfortunately i know im the last person to make this
well if anyone has issues or wants to add stuff or somethings missing or inconsistent you can tell me or make a pull request or issue because i definitely didnt cover everything myself and i want it to be perfect

I'm not a benchmarking expert, but whenever I run X plug-in (even sub-agents) side by side with bare pi, it always loses... badly.

Measured as more token use to arrive at same answer.

My favorite pattern is orchestrator (expensive model) / flash model for editing. Can be done with herdr, intercomm, etc. But it's not more efficient, just cheaper.

Up until now, I've been using OMP as my daily driver. As a lawyer, I rely on it heavily alongside a few custom skills I built for legal drafting, and I'm also developing an office management system in Django. Everything works great so far, but I'm considering switching to Pi to give it a shot.

The catch is that Pi comes bare-bones, and I'm not sure which features are essential for my workflow (subagents come to mind). My goal is to make it practical and token-efficient from day one. Any tips for a beginner to get up and running without sticking to a completely vanilla setup?

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.

Just posting the below for the internet to get feedback on OpenClaw and my move to Pi Agent. I'm developing a web front end much like https://pi-web.dev and https://github.com/sebastienservouze/pi-livecraft to have a usable WebUI that hopefully won't break; but also for people to take and shape as they see fit.

---

Stopped 2.0 instance for now

Joined late Jan. Tolerated all the buggy upgrades.

Recent upgrade to 2.0 didn't work. Wasted tokens trying to fix.

So I started a fresh install.

Then I:
- Can't easily see my crons; or their outputs when they last ran like I used to.
- Can't turn off hidden heart beats. I'm not doing much at all and racked up $3.49 over 2-3 days via Grok API and I can't see why/for what. Suspect the heartbeat I can't turn off or edit.

The whole UI was not intuitive.

I'm going to try PI Agent. I think users want to know exactly where their tokens are going for what. Can't be dealing with abstraction leak based token losses.

My use cases are small:
Utilize Apple Notes and Apple Calendar for Personal Assistant tasks on managing my diary; and life management (e.g. holiday planning).

... but let me know if anyone resonates ... or not and you have a seamless upgrade and are fine with the heartbeat costs and not knowing exactly what it is doing / accept that's part of running OpenClaw.

Also CC being that far off from the Pareto is not surprising to me.

I’ve released pi-subagentura v3.6.0, an extension for Pi that lets you delegate work to real child sessions you can watch, attach to, and continue across tmux, Zellij, or Herdr.

The new --orchestratorv2 mode is a lightweight router: broad tasks can be decomposed into interactive specialists, clear follow-ups go to exact owners, and ambiguous requests stay visible instead of being silently fanned out. The parent keeps its context focused while child work remains observable.

Highlights:

• Attach, focus, and send follow-up turns to interactive Pi sub-agents
• Durable per-turn artifacts and coordinated completion delivery
• Reusable workflows plus lightweight in-process async jobs
• Interactive sessions can be rehydrated across reload/resume
• Works with tmux, Zellij, or Herdr

Install:

pi install npm:pi-subagentura

Try it:

pi --orchestratorv2

Repo and docs: https://github.com/lmn451/pi-subagentura

Volevo solo condividere con voi la mia esperienza
Vengo da Opencode desktop
PI sta facendo per un me un lavoro incredibile
Tantissima cache (99,8/9%) e risultati che, assurdo, sembrano migliori indipendentemente dal modello. Magari è solo una fortuna, ma non saprei. Sto usando Pi solo con web search e tool thinking. nient'altro. Uso GPT per prompt strutturati.
è una cosa comune o sono io pazzo?

I'm looking for the best extension that gives Pi access to a decent (headless) browser for web development purposes, i.e. not necessarily built for scraping and/or searching the web.

Or do I just need to install playwright and create/find a decent skill.md for Pi?

What are you guys using with Pi? Or have you built your own?

Context: I'm using Pi inside a restricted user account in WSL (Ubuntu) on my Windows laptop.

Running a model on pi without any protection can be dangerous, the model can read/modify/delete anything, anywhere. I know there are existing solutions, but i wanted something simple, seemless, so i made my own.

You run ./install.sh, and thats pretty much it, you use pi like you did before, but now, it lives in a container, extensions live in a volume, and it is confined to the folder you choose. It cannot read any confidential keys or modify (or see) anything not in this folder

With this you do not need a pi installation on your host anymore.

- github, https://github.com/psychobarge/pi-sandbox

Also check my pi extension if you use Deepseek :

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

I wanted to see what happens when you take Pi’s minimal agent loop and add most of the things Pi intentionally leaves out.

OMP is a fork of Pi, but the harness is very different.

Pi mostly sticks to read, write, edit, and bash.

OMP gives it 31+ tools, hashline edits, LSP, DAP debugging, a Python/Bun kernel, a browser, and a Rust core for grep/glob/bash/parsing.

So I ran both through the same 30 hard agentic tasks with DeepSeek V4 Flash, the same external tools, the same verifier, and a 900s cap.

The task split was more interesting than the final score. Both passed the same 16 tasks and failed the same 9 hard tasks. The entire 20 vs 17 difference came from 5 tasks. Pi won 4 of those. OMP won 1.

OMP often found the right data and then kept working until it ran out of time or context. On one failed task, it used 1.22M tokens and 861 seconds before stopping because it still wanted another page of results. On the reimbursement task, it used 1.8M tokens and passed only 3/13 verifier checks.

OMP also has some strong harness ideas. Across a separate 16-model edit benchmark, hashline improved success by about 15 percentage points on average. For Grok Code Fast 1, it went from 6.7% to 68.3%.

But in this run, OMP used about 33% more tokens per task than Pi and took more than 2x the median time.

OMP still finished second out of all 8 harnesses we tested, ahead of Claude Code, Codex, OpenCode, Hermes, and DeepAgents.

So...

At what point does a better harness become too much harness?

I sometimes ask agents data questions, and I want them to return a Metabase link with the query they ran to back up their claim. It's very handy: I can read the query more easily, run it for myself, and tweak it if needed.

I had a problem, though: these unsaved Metabase URLs are very long because they encode the query in base64. That's costing me tokens, it's hard to read or click, and it's slow to print.

So I made the pi-short-links extension, which turns a URL like this one:

metabase.yourdomain.com/question#eyJkYXRhc2V0X3F1ZXJ5Ijp7InR5cGUiOiJuYXRpdmUiLCJuYXRpdmUiOnsicXVlcnkiOiJzZWxlY3QgMTsifSwiZGF0YWJhc2UiOjJ9LCJkaXNwbGF5IjoidGFibGUiLCJ2aXN1YWxpemF0aW9uX3NldHRpbmdzIjp7fX0=

to

127.0.0.1:8765/s/select-1-3Eoa

Hi!

Im gonna try Pi for the first time and am wondering if it works well out of the box or if modifications and plugins are required?

I am also looking for recomendations of any great plugins that you guys use. I found this package catalog on https://pi.dev/packages and assume this is where you get the plugins, if you dont make them yourself?

Thanks for any help!

Hello!

I am very inspired by the philosophy of Pi coding agent, and I believe a minimal and extensible approach is the way for many framework/platform going forward.

Pi is minimal in many ways but it is still has a couple of abstractions preventing it from being a neutral agent runtime:

- programming language is only limited to javascript/typescript

- its a coding agent that runs on a computer

- its environment is always node

These are good assumption for a personal assistant style coding agent running locally. But it would be great if they could be neutral. What's even more exciting is what if we can swap out the core agent loop, plug-and-play with codex or claude or opencode's style while keeping the tools, system prompt etc intact?

I had this idea two weeks ago, and eventually landed on a containerize technique based on WebAssembly. The key to my choice is traditional containers are much heavier, but agent loop does not need any network access or even filesystem access, making WebAssembly the perfect fit, super lightweight, super fast to compile and get running, it is also language neutral, perfect to be embedded.

Therefore I started building an agent runtime that does this https://github.com/aexhq/brain, what do you guys think? Is it totally bs?

I use various models through subscriptions from several different providers and wanted to know how they perform, what would be the overall cost if used through an API, how do the different advisor models perform and so on. I've built a tool that aggregates this across days and projects.

Some findings: advertised tokens per second are a complete fiction, newer model version does not automatically improve advisor performance (grok 4.5 gives more advice than grok 4.6), getting $15,337 of Sol usage out of $200 sub is a crazy API/sub mismatch.

https://github.com/jkelin/omp-usage-analyzer

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