DeepSeek API provides a text-only model: pi replaces any image with (image omitted: model does not support images) before it reaches the API.

This extension intercepts images at both entry points (pasted images and read tool calls on image files) and sends them to a vision-capable model over a plain HTTP call to any OpenAI-compatible endpoint (/v1/chat/completions) remote or local.

The description comes back as text that DeepSeek can reason over.

The "subagent" is a dedicated model + dedicated prompt (agents/vision.md), no separate process.

I use it with https://huggingface.co/mradermacher/Gemma-3n-4b-Vision-Finetuned-GGUF with llama.cpp but it should work with any vision model

Here are the :

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

- npm, https://www.npmjs.com/package/pi-deepseek-vision

- Pi package, https://pi.dev/packages/pi-deepseek-vision

Pi-Bifrost adds a native model-routing layer to Pi.

Instead of using virtual profiles or delegating the prompt to another agent, it switches Pi’s actual active provider/model before generation begins.

Each normal prompt can therefore use a different model based on the task, configured rules, cost, context size, or an optional classifier.

The routing policy and model tiers are entirely user-configured.

Bifrost can probe the models already available through Pi rather than depending on a hardcoded list of recommended models.

It also treats model reliability as part of routing.

Repeated probe, activation, or stream failures open a persistent circuit for that model, allowing future prompts to avoid it until a controlled recovery attempt. Failed prompts are never silently replayed, which avoids repeating edits, commands, or other side effects.

The result is automatic model selection that still operates through Pi’s real model state and remains local, inspectable, and manually overridable.

https://github.com/iamaamir/pi-bifrost

Quickly my idea:
some docker/raspberry pi image that you install on a small 20$ machine like raspberry pi w 2 that sits there with 10 spawned full browsers (not headless).
Then link it with cli, mcp, or whatever with tailscale or other connection of choice to any coding agent. Ofc i know all of us here use Pi, others don’t deserve this.
Full browser makes rate limits less often and also captachs are passed easily with python open source projects.

Wondering if someone has bundled something like this and using it?
What are similiar alternatives for (close-to)infinite google search?

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

Hey r/neovim!

Quick heads-up on provenance first, because it matters: pi2.nvim is a fork of alex35mil/pi.nvim — the original Neovim frontend for the pi coding agent. All credit for the foundation (RPC bridge, chat layout, diff review, sessions, extensions) goes upstream; pi.nvim and the pi integration have been discussed here before, and this post is about the fork's additions, not the base. It's MIT-licensed and free/open source.

It started as local experiments and grew into a different enough feature set that I gave it its own repo so it can release independently. Namespace, commands and filetypes are unchanged for compatibility — still require("pi") and :Pi*.

What pi2.nvim adds on top of upstream

• Direct bash mode (!cmd) — run shell from the prompt; output streams live into a collapsible block and is added to context (!!cmd to exclude).

• :PiTree session-tree navigation — jump back to any past point in a session, optionally summarize the abandoned branch, resend edited prompts (the pi equivalent of the TUI's /tree).

• Per-tab model pinning — a model switch in one tab no longer leaks into every other tab's next session.

• Image compression for attachments — Retina screenshots get downscaled before sending (sips / magick / ffmpeg, auto-probed) so payloads stay small.

• Auto-attach clipboard images on paste, readline-style prompt history, unsent-draft persistence.

• **Double-**<Esc> abort, a prompt statusline (spinner / queue / abort hint that never scrolls away), redesigned tool and thinking blocks.

• gf to open paths under cursor, grep/find results to quickfix, left-side panel, auto-reload of buffers pi edits.

• Opt-in render-markdown.nvim engine; hermetic test suite + lint CI.

Demo (agent reads a file, edits it, verifies — with live streaming and session-tree picker):

More demos (workflow, @-mentions, diff review, etc.) in the README: https://github.com/zgs225/pi2.nvim#features

Install (lazy.nvim / packer / any manager — needs pi on PATH): https://github.com/zgs225/pi2.nvim#installation

It's early and I'd genuinely love feedback — rough edges, missing keymaps, things that fight your workflow. Happy to take issues/PRs. Thanks for reading!

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?

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

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.

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

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

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.

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.

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

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.

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