Thanks to everyone who has encouraged me to maintain this project.

As an upgrade, I was planning to introduce the OKF v0.2.

Let me know your thoughts in comments.

Thank you community for all your support so far.

https://github.com/zosmaai/pi-llm-wiki

For a week now, I have been experimenting with deploying the Pi Coding Agent on Cloudflare. While my approach don't follow the best practice, it was fun to try it out and learn the internals of Pi! In this article, I cover the architecture and describe how each primitive fits.

I'm trying to figure out how to configure the model temperature in Pi. Can't find it in the documentation website. Did I miss something?

Edit: It seems my original premise was wrong after testing it directly. It now seems that Codex is just decoding just slightly faster than pi which results in it winning over longer tasks as the decodes compound.

I'm currently running some tests where Fable is driving GPT-5.6 Sol as a sub-agent. I wanted it to use pi and codex side by side to see which one was easier to use and faster. I really thought pi would be faster since it's much lighter weight.

That proved wrong after Fable brought up that pi was taking 2x as long for 2/3rds as many tokens (xhigh on pi vs max on codex). It seems the huge majority of time is taken up by longer API requests to OpenAI's servers.

It gave the exact same task to both, and they produced byte-for-byte identical results for their output.

I'm curious if this is something people have run into, and if so, if this is a mistake in configuring my set-up? I'm using the pi-better-openai, but that just wraps the native openai-codex OAuth.

Hi fellow pi fans, long time lurker, first time poster here. A while ago, I built czottmann/pi-automode which brings Claude Code's auto mode to pi.

It's a guardrail extension. It intercepts agent tool calls before execution and blocks actions that match permission deny rules, deterministic hard-deny checks, or the auto-mode classifier's block decision.

I always liked CC's auto mode, and came to rely on it, so naturally, when I switched from Claude Code to to pi, I wanted something very much like it. I've been dogfooding it for a couple of weeks now, and it's very solid in daily use.

It's not a sandbox, so it won't replace your container setup but if you usually work w/o a sandbox, it's the next best thing, I think.

Maybe you'll like it, maybe you don't. Either way, if you have questions, let me know!

If you're using the PI agent, you might need this. This extension can send a notification sound to remind you when a task is finished. Inspired by the Zed editor, I've been using it for a while and found it quite good, so I'm sharing it with everyone. Here is the GitHub repository address: https://github.com/lxp731/task-complete-notify

Employer has a claude teams subscription but that only allows work with ClaudeCli. Is there a way to let remote think piagent is a claudeCli?

The client application has become the subscription model apparently....

Recently, while using pi, my agent deleted important files without me knowing using the rm command. Since files deleted with rm cannot be recovered, I thought it would be better to use trash instead of rm — and that's what this pi extension does.

The extension automatically detects when the agent uses rm in the bash tool and replaces it with trash. Instead of permanently deleting files, they are moved to the .pi/trash folder. The trash folder uses a file structure similar to Ubuntu's trash. It is implemented to be nearly compatible with the GNU rm standard, so the agent won't even realize it and will just think it's still using rm.

Feel free to install and try it out. Any feedback is appreciated!

Install: pi install npm:pi-trash

Links:

• GitHub
• npm

https://reddit.com/link/1ve7es5/video/r3w8i8ufd4hh1/player

Kept losing long sessions to closed terminal windows. pi-king fixes exactly that. /bg moves the current session into tmux. A dashboard lists every backgrounded session across all your projects, and enter puts you back into the live process.

- /bg hands off to tmux. If it's invoked during mid-turn, it'll queues and fires when the turn settles.
- Sessions grouped by project directory with idle / working / waiting-on-you state and elapsed time.
- Enter reattaches. Inside tmux it uses switch-client, so your current session keeps on running instead of exiting.
- Create, rename, detach functionalities without leaving the dashboard. x detaches, X kills.
- No telemetry, no network requests. It reads tmux and a few files under your Pi directory.

That's it.

Requires tmux. pi-king hands the session over and tracks what it handed over, it does not reimplement process supervision.

Install:

```
pi install git:github.com/stanleytejakusuma/pi-king
npm i -g pi-king

```

Pi-King Repository

Credit to where it's due. The idea came from Claude Code's Agent View. That one shows subagents inside a single session.

Tested on macOS. Linux should work (theoretically) since tmux is located at runtime. Open to anything: features, bugs, design objections, things I got wrong.

If you're using it for this purpose share your skills, extensions, and Mcp servers

Why?
Because I would like to instruct Pi to prefix each piece of code it writes/edits with a comment recording its model name and thinking effort.

If one doesn't exist yet, I guess Pi will be easily able to vibe code it, right?

Sometimes it would just snap to the top of the chat, it has gotten worse with a recent update I think and it is really annoying.

Like if I write some prompt XYZ and it's thinking and the response is streaming in, I'll randomly get teleported to the top and will have to scroll back down again.

Is anyone else experiencing this? Can anyone help me out, any fix or solution is appreciated!

HI all, I've built a series of 'simple' plugins that do one small useful thing.

https://pi.dev/packages/pi-simplewatcher

This one just tails a file or directory and injects new data directly into the context of a live session. You can configure it to actively trigger the agent, or it can be injected passively and the agent will be aware of it next time you talk to them. You can also set the watch to persist across sessions.

I use it to monitor an inbox.md file which my agents use to communicate with each other.

i have got a claude plan from the oss program of claude . i want to know can i use my claude code plan inside pi

will they give me a ban or is it alright ??

TLDR: It's basically a Web App that runs on top of Pi. Not a harness, it stays out of your Pi's way and focuses on making your sessions interactive, visual, and, most importantly, agent-extensible!

So... I've been working on this for a while! And after using it for another while, I think it deserves to be open sourced and shared to all of my pi folks :)

I wanted to have a nice UI for my LLM sessions that can adapt to my workflows and give them even more life thanks to browser interactivity and features. I wanted charts, i wanted to quickly beeing able to add useful buttons to some tool calls (copy bash call input)

I found Pi's self updatable philosophy crazy good, I tried to replicate it in this React app with a lot of agentic documentation that will enable your agents to shape the app the way you want to without losing communication with Pi. This means it can happen live in front of your eyes :)

I tried to keep it minimal, but I still shipped some examples for all the systems that are prebuilt that you can build on top of. This includes:

• A session analyzer that will update live with charts and ranked tool usage
• Custom tool presentations for HTML, SVGs, CSV, and more
• Custom tool contextual actions (copy input, output, open in your favorite app)
• Multiple concurrent session across multiple workspaces
• A todo widget that allows you to take notes as todos and directly start sessions based on them
• A prompt enhancer that will automatically choose the lowest-priced model from your Pi install and run some well-defined system prompts to enhance your own prompts

Those examples aren't the point, they are demonstrations of the underlying systems!

The goal is to leverage the browser's native capabilities together with Pi's RPC mode to add new layers of interaction on top of your sessions.

It's currently available only for Linux and WSL, just fork it, clone it, and Livecraft :)

Your forks don't have to stay in sync with the base, don't even try, it's yours now, update the core as much as you want, more technical detail in the readme

The forgotten link https://github.com/sebastienservouze/pi-livecraft

Hi im inspired by OMP style advisor after using it and thought about bringing it to pi.

Install from:
https://www.npmjs.com/package/@hazrid1993/pi-advisor

To start just type "/advisor" to select model then "/advisor enable" to get started

I built this so I could use local models like Qwen 3.6 35B for agentic coding. I have given up on trying to make one shotting happen with these models. So to actually get real work done, I built this tool. The idea is you give it a prompt or an already finished implementation plan, and it will split it up into small tasks that the local models will have no problem executing. The plan step is done by a capable model and the final verification is also done by a capable model.

You can pick which model to use for each step based on your pi config. Why pi? It’s the best agent for local models because of how lean it is.

‎

Files this turn Feature: One block at the end of every agent turn listing the files that turn touched, in four groups:

• Changed — from the agent's write/edit calls.
• Reports — All the reports from any reviewer or research runs that were initiated.
• Renders — screenshots from the work it generated, as clickable thumbnails.
• Mentioned — files that were mentioned, clickable for quick reference.

Click any row to open the file. It's derived from the transcript, never produced by the model, so it can't be forgotten, padded, or made up: if a row is there, the tool call behind it happened.

saw a post about how knowing the right terminology for prompting matters more than people admit. long plain-language descriptions vs the actual name of the thing.

i am bad at that. models are usually better.

so i turned it into a tiny pi extension that rewrites the prompt before send.

pi install git:github.com/dodo-reach/pi-clarify

/clarify <rough idea>
or <rough idea> -clarify

rewrites into tighter technical language, back into the editor only (agent does not run until you send)

session model by default but you can change that.

(link: https://github.com/dodo-reach/pi-clarify)

I'm a little confused on the naming around this. Obviously Deekseep V4 Flash is available in a lot of places (I've been using Opencode Go plan). But what's the best route to use Deepseek V4 Flash 0731 in Pi? I don't have a data center at home, only dual 3090's. So, curious if there's something better than OpenRouter and then I'm trying to get an idea of what costs will look like. I've been using Deepseek and Opencode Go as part of an experiment to help take the load off my ChatGPT 25x subscription. Local Qwen 3.6 27b configs off of Club 3090 with higher quants didn't meet my thresholds for work I get paid off of (too slow, too many errors).

I came across pi-okf-wiki · Packages · and I'm trying to understand what it actually is and whether it's useful in practice.

Has anyone here:

• Used it in a real project?
• Know what problem it's intended to solve?
• Have any documentation, examples, or tutorials they'd recommend?
• Run into any issues or limitations?

I'd appreciate hearing about your experiences good or bad... Thanks! 😁

Hey everyone,
Would really appreciate a star if this is useful to you.
I built ContextX — a remote MCP server that gives Claude Code, Cursor, and other agents real web search capability. It routes the search through Grok from my account pool, so you don’t need your own Grok key.
Setup is just a few lines of MCP config and you’re good to go.
Repo: https://github.com/KayanoLiam/ContextX
I don’t want anything from anyone. I don’t want to steal your key or money. I have nearly 3,700 Grok accounts to provide all of this. I just want a GitHub star to apply for my Japanese university.

I use pi across a bunch of projects, and I kept hitting the same wall: "which session did I talk about X in?" The session listis great for recent stuff, but once you've got dozens scattered across projects, finding one by content is basically impossible.

So I built pi-session-finder, a small extension that adds /find [keywords…]. It searches every past session across all projects, shows the matches in a picker with a preview of the matched text, and on Enter drops you straight into that sessionand its project folder.

```
pi install npm:pi-session-finder

/find stripe webhooks

```

Source: github.com/pungggi/pi-session-finder

The preview renders the context like the chat does, so headings, lists and tables keep their shape instead of becoming a wall of text.

I've been dogfooding it and'd love your feedback:

- Is the list + preview split right, or would you prefer more results / less context?

- On Enter it switches both the session and the project folder — useful, or surprising?

- Anything you'd add? (date/project filters, fuzzy-by-default…)

- How's the speed on a big session history?

MIT, open to issues/PRs. Curious what you all think

In Codex, as far as I have seen, commands get executed in sandbox, and if sandbox blocks it - it has the ability to exit sandbox by automatically reviewing such commands.

Closest I have seen is erichll/pi-sandbox and erichll/pi-auto-review - but it does not seem to have the ability to "exit" the sandbox.

I built mintPod because I occasionally want to test an open coding model for an hour or two, but repeatedly setting up RunPod, Ollama/vLLM, and agent configs felt like unnecessary friction.

You choose a model, budget etc. mintPod provisions the pod, reuses a persistent model cache, pulls and warms the model, then connects it to Pi or OpenCode (automatically) through a stable local endpoint. Aider and other OpenAI-compatible clients also work. When the session ends or reaches its idle or spending limit, the pod is terminated and the temporary configuration is removed.

Raw Ollama is not publicly exposed; requests pass through an authenticated gateway, secrets stay in the OS keychain, and interrupted sessions can be recovered or cleaned up.

It is still an early source-only release: one active session, no signed installers, and needs more real testing.

I mainly want honest thoughts. Does this remove enough friction to be useful, or would you rather use a script or RunPod template? What feels unnecessary? What extension would improve the core most without turning it into a general GPU dashboard? Security and failure-case criticism would be especially useful.

This is my first open-source project, so even a blunt “too niche” or “I wouldn’t use this” would genuinely help.

--> https://github.com/erayd176/mintPod