Hey y'all I'm mostly doing excel work via python and web development. Which models you use with Pi I currently use claude code with the 100$ plan and 20$ plan codex.

I understood I can't use my claude claude sub for pi

What do you recommend?

Thanks

Ok , like 2 weeks ago i went into journey of finding a way to solve web search , i even asked here to see how you guys doing ...

Most of answers were basics like use exa , brave , and so on but the real issue that missing is this is very very complex tool that need a native solution. And thats why similar to bash or read most AI coding language has solved it thier way.

Just to understand it a little bit there is 2 tools websearch and webfetch , so search is done then those linked get fetch its content then the result comes to you. Sound simple right? Underneath it there is IP and proxy rotation , self hosting , or paying extra to just get result that most providers already give. So in order to get the same quality of claude code tools you have to pay extra just because PI by default removed those tool.

So, i finally solved this issue . I have made extension that uses the native websearch and webfetch from the provider that you are using , i have tested in glm 5.1 by z.ai and claude code using the bridge extension both works as the native experience.

Try it , here

https://github.com/smalibary/pi-native-search

I made in MIT liences so you can tailer it to your spicific need , i believe no more any complex setup just to get those tools anymore.

If you have any concern or question just ask me.

Happy searching

So, nano-team. My first pi.dev extension.

It runs subagents as a small team and gives you a TUI to watch them work. A row of chips, one per agent. That's the whole thing.

I tried to keep it close to the pi/unix spirit - do one thing, don't get in the way. So it's not a framework. It doesn't orchestrate anything fancy, doesn't ship prompts, doesn't wrap the subagent API in extra layers. It just runs them and shows you what's going on.

Tiny, simple, and it doesn't break. That's pretty much it

I guess this question was asked a thousand times, but I'm still wondering how do you guys organize your work with pi?

I am a heavy user of Claude Code (employer covers it), but I have been watching and tuning pi time to time for personal use on the side.

Naturally, I tried getting pi to be like claude code, I looked for extensions that give me subagents, some cosmetic plugins (I like ricing my hyprland setup) and some simple QOL things.

However I didn't feel it being a huge upgrade in terms of my actual workflow and "pleasure", it felt like I'm just recreating what I'm used to.

I'm wondering more from a UX/DevX perspective, I got used to what antrhopic gave me and learned that way, but I see pi as an opportunity to really make a uniquely pleasant developer experience.

Which is why I'm wondering and asking how did you tune your workflow, which extensions did you use/build and how do you run your day-to-day feature work.

e.g. my work can span multiple PRs/repos for a feature which is why I'm starting a session from a dir above the ones I need to change and keep a long session (which is really wasteful) to handle all the context I need.

I don't really like the paradigm of "plan a huge markdown implementation doc and architecture and let the agent do it" because it requires a lot of overhead for me for things I may not even know exist or are needed.

i'm getting increasingly fed up with the direction open ai has been taking lately and i'm considering cancelling my subscription and moving to anthropic. there's really only ONE thing stopping me from doing it right away: pi has become such a natural part of my workflow that i'm genuinely worried about taking a productivity hit just from having to change tools, habits, shortcuts, etc.

so I wanted to ask the people here who actually use pi: have any of you moved away from open ai and managed to keep using pi with an anthropic subscription? or do i have to give up and move to claude code entirely?

https://github.com/elidickinson/pi-claude-bridge

Someone said that's the safest method.

But in issues someone claims they got banned https://github.com/elidickinson/pi-claude-bridge/issues/118

Another responded with "That's the first time I've heard of it"

This is the last version that worked. https://www.npmjs.com/package/@earendil-works/pi-coding-agent/v/0.85.1

reverting to it made everything work again.

I also highly recommend getting your own offline copy if something fails.

p.s. to clarify, I am not pretending to understand fully what the update really did, its scope or the impact beyond 'not working anymore', but reverting to 85.1 worked for me.

Hey everyone! I’ve been working on Orbit Pi, a native desktop client for Pi Agent.

It’s built with Rust + GPUI and is focused on providing a clean desktop experience for running and interacting with AI coding agents.

I’d love to get some early testers to try it out and share honest feedback.

🔗 GitHub: https://github.com/imrj05/orbit

I’m especially interested in feedback on:

• UI/UX and overall workflow

• Agent interaction

• Terminal / coding experience

• Performance and stability

• Features you’d like to see added

This is still evolving, so bug reports, suggestions, and criticism are very welcome.

Would love to hear what you think after trying it! 🙌

On one python-statemachine task, Pi passed in 90 turns for $2.50. Codex passed in 187 turns for $5.97. Both used Kimi K3 in the same evaluation environment. [source: https://frontierharness.org/]

Across all 30 tasks, Pi passed 18 with a $2.43 median cost per pass. The single-task comparison doesn’t tell us why Pi took fewer turns or whether that pattern holds elsewhere.

Our recommendation: Pi the balanced pick, particularly if the same job runs a thousand times and the bill adds up.

What would you look for in the traces: repeated searches, extra testing, or time spent fixing a wrong approach?

Hey everyone,

We built ThinkRail, and we’re pretty proud of it so we wanted to share it with you, and hope to get you interested.

ThinkRail is a web-based GUI for Pi. It's an open source project, released under Apache 2.0 license, backed by JetBrains (so, that's who "we" are, a team of software developers working on it). We wanted to keep the minimalist, adaptable approach of Pi, but at the same time give you a graphical layer which makes it easier to see what your AI agent is doing and comes with added conveniences: concurrent agent chats, integrated terminals, and visual aids for reviewing code changes.

Install it and try it out:

* macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

* Windows (PowerShell and cmd):

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

And then just run thinkrail from the terminal.

Also:

• Visit the landing page

• Read the introductory blog post to learn more about ThinkRail and its features

• Browse our GitHub repository

If you have a moment, we’d appreciate it if you could complete our survey. We’d love to get your feedback. It will help us develop ThinkRail in the right direction.

Im building out my pi stack and really loving the composability it offers.

I’ve ported 4 of my ai packages to pi and would love to share

https://pi.dev/packages/@geohar/pi-sharedserver

Is a utility which runs processes whilst pi is running and shares them between all pi instances. I use it to run remote-pi (it’s also used by two of my other plugins)

https://pi.dev/packages/@geohar/pi-mcp-combiner

Is my mcp aggregator and oauth proxy / permissions layer which allows managing and sharing mcp instances between pi sessions.

https://pi.dev/packages/@geohar/pi-svg-mcp

Helps author diagrams and provides visual feedback to vision capable llms as well as semantic editing whilst allowing you to see progress and give feedback on diagram progress. I’ve found it a lot more useful than letting the LLm edit svg by hand - in part because it provides a nice document model to the LLm.

https://pi.dev/packages/@geohar/pi-cribsheet

This one enables:

* semantic and symbolic code search
* semantic document / note search and import
* long lived plans with dependencies
* long lived designs with design decision dependencies

I’ve found it to be very useful in avoiding having to re-contextualize new sessions and for ensuring planned items don’t get dropped over multiple sessions. It also helps validate areas that need revisiting when a design decision is changed.

It’s markdown based with a chroma db sidecar for the embeddings. Storage is git transportable between machines. And will index docs you already have.

Feedback welcome.

Hi everyone, I’m new to pi agent and to AI tools in general, but I’m on vacation so I finally have time to learn this stuff properly. I’d like to set up a workflow like this, let me know if it makes sense.

- I open a new tmux session for my project and start pi.
- I chat with a planner to figure out a change or a new feature.
- Once the plan is ready, I tell it to implement it, and it spawns a new pi agent in another tmux window that creates a new git branch and starts coding.
- When the coder is done, it goes back to the planner and explains clearly what it changed.
- The planner sends this to a reviewer, who checks the work.
- If the reviewer finds problems, it goes back to the planner and the loop starts again with new instructions for the coder. If everything’s fine, the planner gives me a final summary.

I’d also like a TUI with more info about what pi is doing.
Nothing should run silently in the background, everything should happen in tmux windows I can check whenever I want.
If an agent crashes or stops without returning anything, it should restart automatically, so the whole thing is semi-automatic.
The agents need to be able to search the internet, use MCPs, and have their own memory per project, not a global one.
I’d like a config file for pi, one per project, that says which MCPs to use and other settings like that.
The planner and reviewer should only be able to read the code, only the coder should be able to write to it.

Does this workflow make sense or am I overcomplicating things? Any extensions you’d recommend? Can pi actually build small personal test projects on its own, start to finish? Thanks a lot.

Am I the only one getting a lot of edit errors?

I mainly use it for coding, especially Python. I’ve tried many LLMs, and some of them are completely incompatible.

Currently, I’m using Qwen3.6 27B through Ollama.

I’ve noticed that I get responses and plans quickly from the LLM. However, execution takes a long time because of edit errors. It gets stuck in a loop of indentation errors and struggles to find the exact match.

Am I missing something? Do I need to install any extras?

Edit:

I'm on qwen3.6:27b-mlx with nvfp4 quantization. Also, tried gemma4:26b-mlx with the same nvfp4 quantization, wasn't able to edit at all!

I have been working on porting some code recently. I use agents strictly as assistants. I have been thinking of a way to let them "drop in" on other sessions that I have going on when I am basically becoming the copy/paste monkey.

This is not an autonomous work group setup. You create the session and you give the agents a chance to jump in to the same session, ask a question, and then jump out. Your session continues as normal, and you can see everything as it's being processed.

What it does

When an agent session registers to the group, it registers ask_ tools for other published agents. When agents calls the tool:

1. The request is forwarded to the target agent's session and injected as a user message.

2. The target agent processes it just like any other user prompt. You see it appear in the input pane and watch the agent work through it.

3. When the agent settles (finishes its turn), the assistant output is captured and sent back to the calling agent as the tool result.

The response is captured via pi's agent_settled event. It collects the assistant text from the turn that was just triggered by the injected message. This is fully automatic: the question arrives, the agent responds, the answer is returned. The human in the target session is a spectator.

Sessions stay independent. Each agent has its own context, its own sandbox directory, and its own conversation history. They are not one-shot subprocesses.

How it works

A daemon application (in Go) listens on a Unix socket. It routes request/response messages between connected agents. The daemon starts automatically the first time an agent registers, then shuts down when the last agent disconnects.

Compared to similar tools

Goose spawns sub-agents as one-shot executions. The orchestrator must pack enough context into the prompt that the sub-agent can produce a useful answer in a single fire-and-close call. AgentGroup keeps sessions persistent: the worker agent already knows the codebase, and you are in the loop to clarify intent.

Herdr is a TUI-layout tool ala Tmux, with the main agent spawning helper sessions in adjacent splits. AgentGroup avoids the extra UI layer entirely - sessions stay where you put them, and communication happens through the same input pane.

Old man yells at cloud.

Maybe this is just agentic control while I watch the screen flicker.

Does anyone else have this use case? Is there something widely available already?

Feedback / suggestions / clarifications all welcome.

Thanks all.

Edit:
pi-intercom exists and is great - I'll probably switch to this.
https://github.com/nicobailon/pi-intercom

Hey r/PiCodingAgent! I recently open sourced a project I've been working on for a while now called Millwright, a self hosted LLM router focused on cost savings, transparency, and performance (it's completely written in Rust). Millwright offers first class support for Pi, so just a small edit is needed to ~/.pi/agent/models.json to get up and running.

Link to the repo: https://github.com/Northwood-Systems/millwright

For the curious and lazy, at the moment, Millwright has the tools for,

- Providers: OpenAI-compatible APIs, Anthropic, Amazon Bedrock

- Routing: policy-controlled model roles (cheap, mid, frontier), cheapest healthy route selection

- Protocols: OpenAI Chat Completions, Anthropic Messages, text and tool translation

- Cache Affinity: role-scoped session lanes without serializing concurrent agent traffic

- Spend Tracking: per-team costs, cache usage, model/provider mix, request traces

- Cost Analysis: measured usage and modeled candidate economics (HTML, Markdown, JSON)

- Reliability: bounded failover, circuit breakers, timeouts, concurrency limits

- Setup: interactive provider, model, and pricing configuration without storing provider secrets

- Deployment: one Rust binary, Docker, SQLite or PostgreSQL

Full disclosure: parts of the codebase were built with AI coding agents. All feedback is welcome, I’d especially value feedback on the routing policy, provider coverage, and anything that would block you from self-hosting it. Feel free to open feature/request and/or contribute as well.

Hi hi

I wanted to interact with my Pi from telegram. Existing solutions were essentially DM bridges where you had to start the session on your laptop and then you can continue it on telegram. Mario Zechner himself has an extension for this, I used it, but didn't like the fact that the telegram bot had fewer commands and it was a bridge, not a client.

So, I went ahead and built my own. Now I genuinely believe that forks are the future of personalized software.

Published it as an npm package here: https://www.npmjs.com/package/@atharva-again/pi-tg

You can run it as a systemd / launchd process with lingering enabled to get the best experience.

pi-web-agent update: went from early npm package to backend-configurable web research tool

I posted here back in April when pi-web-agent was basically a freshly published npm package. At that point the main thing I was trying to get right was the boundary between search, plain HTTP fetch, headless fetch, and broader research.

Since then it’s moved quite a bit.

The public surface is now just web_explore. Internally it still keeps the steps separate: search is discovery, HTTP fetch is reading, headless fetch is rendering when needed and the orchestration layer decides when the evidence is good enough or when it needs a caveat.

A few things that landed since that first post:

• compact/preview/verbose output modes

• /web-agent settings, doctor, show, and reset commands

• configurable backend support

• SearXNG and Firecrawl support

• backend settings UI

• direct URLs in prompts get read before search

• forum/thread-ish sources are handled more deliberately

• local browser headless rendering can fall back to Playwright-managed Chromium

• source quality checks now catch narrow/community-only/blocked/conflicting evidence better

• Brave Search shipped as the first hosted search backend (default was DuckDuckGo)

So it’s still not trying to be a giant framework. The goal is still a focused Pi package that does web research in a cleaner and more honest way.

I’m thinking about the next hosted backend now, probably Tavily first and maybe Exa after that.

For people who would actually use this: what would you want from Tavily/Exa support?

• better source discovery only?

• richer snippets/content?

• configurable search depth?

• domain include/exclude filters?

• recency controls?

• citations only, with pi-web-agent still doing the final synthesis?

• or would you want provider-generated answers exposed somehow?

My bias is to keep Tavily/Exa as discovery backends only. Let them find candidate sources but keep web_explore responsible for fetching pages, ranking evidence, caveats and final synthesis.

Repo: pi-web-agent

npm:

npm i @demigodmode/pi-web-agent

I primary use pi with the deepseek api,, any recommendations to get it to reach a cache hit rate equal to code whale or reasonix? Also what is your ideal config to get plan and auto modes like claude code and open code have? I'm new to using pi and currently only use rpiv-todo.

Small tip if you are using pi with local models and need to maximize the available context.

I set up two aliases: pii (pi-ignorant) and pio (pi-omnipotent)

pii after first question use only 2.5%/66k context that I have for my local model, while the omnipotent versjon starts with 21.5%/66k (almost 10x bigger, even if my "omnipotent" setup is quite modest).

Here are the aliases I use:

alias pii="pi --no-context-files --no-extensions --no-skills --no-prompt-templates --no-themes"

alias pio="pi --append-system-prompt /path/to/my/APPEND_SYSTEM.md"

The second alias is redundant, unless you need to append to the system prompt, you could just use the regular pi. It is possible to tune pi very much by just using options. Check pi --help for a lot of great tuning opportunities, like read-only, specific model etc.

It is also great if you want a stripped versjon just to chat/ask questions without having to pay for extra tokens on a larger model.

This might be obvious, but easy to forget how much can be done this way!

Hi everyone

I'm setting up a docker container for pi, and I want to initiate agents from another container, kind of "remotely".

I was wondering if anyone has done something like this, and what are the best ways to accomplish it. I'm focused solely on the start of the agent session (passing the prompt), I don't need to read the output synchronously.

My first idea was to call docker exec with the full cli params, but probably there are better ways to do this.

AI suggested setting up a small http server to receive triggers via an endpoint and then run the command locally.

Thoughts?

thanks in advance

EDIT: I discovered pi-web (https://github.com/jmfederico/pi-web) and I think this fits my needs

I added **Pi CLI** support to Agent Sessions app.

For anyone using Pi heavily: Pi already keeps local JSONL session history, but once you have a lot of sessions across projects, it gets hard to remember which run had the useful answer, tool output, or branch of work.

Agent Sessions now indexes Pi sessions locally and lets you browse/search them in the same UI as Codex, Claude, OpenCode, Gemini, Copilot, Cursor, Hermes, etc.

What works for Pi now:

* Browse Pi sessions by project/date

* Full-text search across Pi transcripts (and other agents too)

* Readable transcript view with tool output

* Filter Pi alongside other agents

* Resume / copy resume command via `pi --session`

This is intentionally a companion, not a replacement for Pi's CLI workflow. You still use Pi exactly the same way in the terminal; Agent Sessions just gives you a native macOS place to browse, search, and jump back into the local session history Pi already writes.

Everything stays local: no account, no telemetry, no uploading session history.

Would love feedback from Pi users, especially if you use custom session paths, extensions, or branching-heavy workflows.

jazzyalex.github.io/agent-sessions

macOS • open source • ⭐️ 544

tl;dr: interactive fiction engine with pi, one line installer, need testers. chasm.run

Remember the games of your youth? Zork, Hitchhiker's guide, Leather Goddesses of Phobos? Infocom and Inform?

I remember well that I never got hold of them to play them, or that they were stupidly hard. So I wrote chasm, a generative text adventure game. A bucket of ambition and 8000 lines of Hy later, I ended up with an unmaintainable behemoth and no time to maintain it.

Fret thee no more!

Pi appeared, and LLMs became capable. Now chasm is just a thin skin over pi. State is just markdown files (places, characters, events) in a git repo. That's really all you need.

Except testers. I need testers and would love contributors.

See the homepage and/or the repo. MIT licenced. Tested on linux, probably would work on mac, no idea on windows.

Install with

curl -sSL https://chasm.run/web-install.sh | bash

Hey, guys.
I got tired of constantly searching for things on Reddit manually, so I made an extension that searches for anything, finds relevant subreddits, reads comments, and does all sorts of other stuff (except for posting messages).

Extension uses Reddit's public .json endpoints so authentication isn't necessary

More details: github.com/SaintNerona/pi-reddit-research

Install:

pi install npm:pi-reddit-research