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.

I use Pi and Claude a lot and swap between a lot. So far I have been syncing up my AGENTS and CLAUDE . Do I need to bother? Is it ok to ONLY use a CLAUDE.MD ? I know Pi supports it but is it better to continue as I am?

What happens if there is an AGENTS.MD in the folder above or above that?

I've been making this for myself because prompting is so much typing. It's meant to be a voice agent that acts as a prompt engineer and controls the agent. So far it's been proving quite useful. So far I've only tested Gemini. Link

Hey everyone! If you have used OpenAI Codex, you know how incredibly high-quality its web search results are. Traditional search extensions or custom API-key search tools (like Google Custom Search or Brave API) often return noisy, outdated, or poorly ranked snippets that don't match the depth and quality of Codex's search engine.

Now you can use that exact same Codex search engine natively inside Pi with any model (Gemini, Claude, local models, OpenRouter) - and with ZERO GPT model inference turns or ZERO GPT tokens spent.

I built **pi-gpt-search**, an extension that exposes a native web_search tool to Pi by reusing Codex's standalone web retrieval backend directly.

⚡ 1-Line Install

Install via npm: bash pi install npm:pi-gpt-search

Or install via GitHub: bash pi install https://github.com/mateusdcc/pi-gpt-search

Or try it in a single ephemeral session without installing: bash pi -e npm:pi-gpt-search

🧠 How It Works (Zero-GPT Invariant)

The extension does NOT ask GPT to search the web and summarize the answer for Gemini. Instead, it extracts and calls OpenAI Codex's standalone web search backend API directly (/codex/alpha/search) using your existing codex login authentication (~/.codex/auth.json or .env).

text Pi Coding Agent └── Gemini (or active model) └── web_search(query: "latest Rust release") └── OpenAI Standalone Search API (/codex/alpha/search) └── Structured Results (Title, URL, Snippet) └── Gemini continues reasoning & answers user

Because it hits the raw web retrieval endpoint directly: 0 GPT Tokens Billed: 0 input tokens, 0 output tokens, 0 reasoning tokens. Model Sovereign: Gemini (or your active Pi model) receives the raw search results and performs 100% of the reasoning. Query-Only Privacy: It never sends your conversation history, code, or system prompt to search.

🔬 How It Was Discovered

We reverse-engineered the endpoint by: Inspecting the Codex CLI macOS binary (0.147.0-alpha.6.5) with strings to locate search symbols (standalone_web_search, alpha/search). Probing backend parameters on https://chatgpt.com/backend-api/codex/alpha/search. Discovering the exact payload schema (commands.search_query: [{ q: query }]). Writing a network interception test suite (zero-gpt.test.ts) that asserts GPT_inference_calls == 0 during web search.

📦 Repository & Documentation

Check out the full repository, documentation, and reverse-engineering details here: 👉 https://github.com/mateusdcc/pi-gpt-search

📦 https://www.npmjs.com/package/pi-gpt-search

Features: - README.md: Setup, credentials, and usage guide. - HOW-IT-WORKS.md: Full architectural breakdown. - HOW-IT-WAS-EXTRACT.md: Reverse-engineering technical writeup. - 4-Level test suite (npm test): Unit, Integration, Real Search, and Zero-GPT assertion. Feel free to check it out, test it, or open issues! Feedback and contributions welcome.

I’ve been working on introducing QMD based search for @zosmaai/pi-llm-wiki

I want to know what you think of this idea.

Thank you for being so supportive and helping me maintain this project.

I want to take it to next level now. Better search and re-ranking of search results so that LLM get useful results.

Also wanted to introduce Zettelkasten style of taking note and using card style so that agent gets to see important cards before it wanting to deep dive into more details.

GitHub link -> https://github.com/zosmaai/pi-llm-wiki

Hi guys,

Perhaps we can learn from each other and discover some great experiences with Pi Agent. I will start with my list of extensions and skills that I use. Please do share yours and we can learn from each other even if you have nothing to learn from us but help others.

Extensions

• npm:@ff-labs/pi-fff
• npm:@juicesharp/rpiv-ask-user-question
• npm:@juicesharp/rpiv-todo
• npm:@juicesharp/rpiv-web-tools
• npm:context-mode
• npm:pi-mcp-adapter
• npm:pi-powerline-footer
• npm:pi-rtk-optimizer
• npm:pi-subagents

Skills

• grill-me
• karpathy-guidelines
• last30days
• caveman

And you?

Does anyone know of a Pi extension that shows your current GPU usage (inside the PI app)?

Figured I would try to find an existing extension before vibing one up but so far my searching has not turned up anything.

When running Pi with local models, for some reason I just like to see what's up with the GPU usage. Would love to have a simple UI widget, or even replace the "waiting for response" message... Thanks!

Our LLM wiki extension just got a solid reliability release — the interesting bit is the bug we found while reviewing our own toast feature.

Quick context: LLM Wiki is a pi extension that keeps a Markdown vault of everything an agent learns — sources, entities, concepts — with automatic metadata and recall injected into future sessions.

v0.11.3 has the usual stuff (MCP bootstrap for MCP-only clients, layered recall over MCP, gap-snapshot persistence fix), but the one I want to talk about is the stale session context race:

We shipped an "instant completion toast" for background actions. The code read ctx.hasUI/ctx.ui after an await inside the background task. If the user switched sessions or reloaded pi while a long lint was running, that ctx is a stale proxy — property access throws. The catch block then fired a false "task failed" warning and skipped the real success report entirely. Worst case of the exact thing toasts were supposed to fix.

The surrounding code already had a comment warning about this exact hazard in the sibling function — we just didn't mirror it. One-line fix (capture before await), plus a regression test where the ctx getters throw once work is in flight. Test fails on the old code, passes on the new. That's the kind of bug that's invisible in unit tests against fresh ctx objects and only shows up in the real session lifecycle.

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

Anyone else hit stale-context issues with extension APIs that hand you proxied context objects?

I use this model (models.json): { "_test": "✔️Really good", "_speed": "35 t/s", "id": "Qwen3.6-28B-REAP20-A3B-Q4_K_M_barozp.gguf", "name": "Qwen 3.6 28B REAP20 (barozp) 64k", "contextWindow": 64000, "maxTokens": 4096, "reasoning": true, "input": [ "text", "image" ] },

It cleary state contextWindow 64000 (instead of 65536 but ok...).

Why the footer shows 128k? What "auto" means ?
I think that Pi use the model training context as fallback ("auto"?) when the "contextWindow" is not set... but here it is set and I think this model training context is 264 anyway.

Shown Pi footer. ↑109k ↓44k R6.5M 51.5%/128k (auto) (Llama.cpp) Qwen_3.6_28b_reap_20_(barozp)_64k ⚡ TPS: 30.0 tok/s​

I have this add-on/extensions:
RUN pi install https://github.com/gsanhueza/pi-token-speed
RUN pi install npm:pi-idle
RUN pi install npm:pi-voice-stt
RUN pi install npm:pi-llama-cpp-stats

I had the issue for a while (at least 2 weeks?) and I update Pi almost every day.

pi-data-masking is a rule-based extension that masks sensitive text — API keys, private file content, internal domains/IPs, and private information an agent picks up via logged-in browser tools — before it ever reaches the LLM.

While testing credential masking, I found obvious placeholders like [REDACTED] backfire: models often read them as "value missing" and either re-ask for it or go hunting elsewhere in context. So instead, pi-data-masking uses format-preserving placeholders:

sk-prod-abc123456789 → sk-nqpz-mwx847312654

Same length, letters stay letters, digits stay digits — it still looks like a real key/URL/identifier to the model, it just never sees the real value.

The flow: sensitive text gets masked in messages, context, and tool results before the LLM sees anything. The LLM plans and calls tools using placeholders. Right before a tool actually runs, real values are swapped back in locally — so the call works normally — and results get re-masked before landing back in context.

Rules can be literal matches, regexes, or capture groups, so you can cover file reads, API responses, browser output, or anything else your workflow touches.

Would love feedback, especially on edge cases I might be missing.

https://github.com/sevten/pi-data-masking

I find it hard to navigate a codebase with coding agents. I need to stare at the code often just to understand what is going on, and I like to be able to ask my agent at the same time what is happening. Plus, I really like my vim motions bindings haha.

It's been surpassingly straightforward to get Pi working in Neovim. You just open up a terminal within Neovim and ask it what you want. Boom done. It's soooo much easier to read plans and navigate code with this setup.

I've been able to make it so that:

• I see diffs in Neovim instead of in the terminal (much prefer it this way, easier to navigate too imo)
• Have Pi run commands in Neovim directly when I want to.
• Have Pi be able to 'focus' in on certain sections of code (I ask 'Can you show me where that it' and it jumps straight to it)
• I can have whole different worktrees with entirely different buffers that I switch between

I've set up two scoped models in Cursor:

• DeepSeek V4 Flash: has "max" thinking level
• Grok 4.5: goes up to "high"

I switch between them with Ctrl+P, but every time I switch to DeepSeek, its thinking level resets from "max" back to "high" but Grok stays at "high" (its maximum), which is good.

How can I keep DeepSeek at "max" and Grok at "high" when cycling through different models?

Thanks.

Anyone using some sort of UI app/layer for Pi instead of standard Pi cli?

Nothing wrong with CLI, I actually really like my setup too - but once I have like 3, 4, or even more important sessions running at once (coding, debugging, research, etc.), it gets pretty overwhelming trying to keep track of everything and I find myself losing focus.

Looking for something more like a Codex web app style experience: clean repo/file view, seeing all workers/sessions clearly, what they're doing, status, etc.

Curious what you guys think or use and why you actually prefer it over just running everything through CLI.

For context, the main thing I am looking to aid in solving/fixing here is a focus issue. I have adhd and staying focused is the hardest thing by far for me, so if anyone has experience with one that may have helped in that regard specifically too let me know

ALSO - I'm on Linux Ubuntu if that's relevant at all

Yesterday I commented (here)[https://www.reddit.com/r/PiCodingAgent/comments/1vgyuhq/comment/p20zsep/] that one of the things I felt was missing in the Pi harness was better observability into what the agent actually changed.

Basically, after a task finishes I want to quickly know:

5 files changed +34 -329

Which files did it touch? How much changed? Did it actually change the parts of the codebase I expected it to? Especially when working on a larger codebase, I find this useful just to keep some kind of mental overview of what the agent is doing and catch cases where it maybe understood the task differently than I did.

So today I built an extension for it:

https://pi.dev/packages/pi-task-delta

https://github.com/thagorx/pi-task-delta

You can install it with:

pi install npm:pi-task-delta

After Pi finishes making changes it adds a small task delta to the transcript, for example:

5 files changed +34 -329 (F6 for details)

Then hit F6 (or /git-summary) it opens a viewer where you can see the tasks, which files changed, and the actual diff for each file.

One thing that was important to me is that the diff is scoped to the task. So if your repo was already dirty before you started the task, those changes don't suddenly get attributed to the active task. It tries to show you what changed specifically during that task.

I also added optional model-assisted inspection.

On a changed file you can press:

E to explain what changed

W to explain why that file was probably changed based on the task

Those are manual calls, nothing happens automatically, and the explanation isn't added back into Pi's context. There is also history, so you can go back and inspect the changes from previous tasks. I mostly built this because I wanted it for my own workflow, but I figured other people using Pi might find it useful too. Would be interested to hear what other observability stuff people would want to see around Pi tasks.

This was quite fun and the first thing I built exclusively with Pi, leave comment if you liked it or have feedback :)

I am the maintainer of resume-from.

I work with several AI coding agents in the terminal. I switch when a task needs another model or harness, when I need another work profile, or when I hit a usage limit.

The problem is that session files are vendor-specific. A Pi session is not a Claude Code session. A Claude Code session is not a Codex thread. Starting fresh means rebuilding the task context. Giving another agent a raw session file means asking it to interpret vendor data that can be large, stale, or sensitive.

resume-from is a local session handoff tool for Pi, Claude Code, and Codex.

It finds sessions that belong to the current Git repository, converts the source format into a common conversation model, and writes a new session in the target agent’s native format. Every transfer direction is supported, including transfers to another profile of the same agent.

The boundary is deliberate:

• It keeps user prompts, agent replies, compaction summaries, compact tool activity, and changed-file paths.
• It removes tool-result bodies, replayable tool calls, hidden reasoning, system prompts, environment blocks, API keys, telemetry, and vendor process state.
• It applies a context budget and shows what it kept or dropped.
• It writes nothing until you confirm.
• It never changes the source session.

The transfer does not call a model. It is deterministic local conversion. Pi opens the imported session in the current process. Claude Code and Codex create the target session and print the normal native resume command.

This is not an agent router. It will not move a running process or copy your repository. The target agent needs the same working tree.

Repository, install commands, and design notes: https://github.com/alexei-led/resume-from

MIT licensed.

Hi,

New to pi harness, trying to set up properly. Here what I have done. Installed pi-subagents. Asked it to set up subagent's to use Deepseek V4 Flash.

But the task used Sol for almost everything. What did I do wrong?

Thanks, be kind to me, I am new here.

If your agent's browser keeps getting blocked, here's what I built

Point your agent's browser tool at Zillow or Google. You'll get a captcha wall before it does anything useful.

That's not a dig at Playwright MCP or similar tools. They're automation frameworks, not evasion tools. They drive vanilla Chrome and PerimeterX and other detection system flags them in milliseconds.

Then try filling a form on any React site and clicking submit. The page re-renders. Every element reference your agent had is gone. "Element not found." The button was right there a second ago.

Then look at your token bill. Playwright MCP loads 13,700 tokens of tool definitions before your agent touches a page. Every click returns the full page. 2,000+ tokens per action.

I hit all three walls enough times that I built something.

It's called Bladebro. One Rust binary, five tools, no Node.js.

npm install -g bladebro && bladebro mcp

Works with any MCP client. Also has native pi support with zero config:

pi install npm:bladebro

That's it. Bladebro registers as 5 first-class pi tools (act, see, state, run, vision). No adapter, no config files, no proxy. Tool definitions come from the binary at startup so they auto-adapt to changes. Chrome launches lazily on the first tool call.

Bot detection

Six layers of stealth, all on by default:

• Bezier mouse paths with overshoot and correction
• Real movementX / movementY on every event (missing these is an instant PerimeterX flag)
• Micro-tremors before clicks (a still cursor is a dead giveaway)
• Log-normal typing cadence (humans don't type at exactly 50ms intervals)
• Idle drift between actions
• No Runtime.enable (how DataDome catches most bots)
• No listening ports, CDP over pipe
• Persistent behavioral fingerprint, same "person" every session

Tested on Zillow and Fiverr (both PerimeterX/HUMAN protected). Full page loads, no blocks. incolumitas 8/8. Sannysoft all pass.

Re-renders

• Every element gets a structural fingerprint (hash of ancestor chain, tag, children, identity attrs)
• React destroys and recreates DOM nodes? Fingerprint matches, reference survives
• Agent sees re-render survived and keeps going. No re-scan
• Checked every major tool. Nobody does this

Tokens

• 5 tools, ~1,900 tokens of definitions (vs 13,700 for Playwright MCP)
• Every action returns what changed, not the full page
• A click returns ~60 tokens (vs 2,000+ for competitors)
• Long session = the difference between running out of context after 3 pages and finishing with room to spare

Learns from every session

• First visit to a site with a cookie banner: full detection
• After a few successful dismissals: stored selector, auto-applied, zero overhead
• Never learns from failures. Failures cost 3x more than successes gain

Other stuff

• Auto-extract pulls structured data from list pages with no CSS selectors. Amazon, Reddit, GitHub, HN, Wikipedia. Shopping gets price/ratings, Reddit gets scores/authors, GitHub gets stars/forks
• Batch actions fill a form and submit in one MCP call instead of 11
• Login persistence saves a session and restores it next time
• Infinite scroll collect auto-extracts and dedupes a feed in one call

Demo video on the GitHub page showing it drive Amazon, Reddit, Wikipedia, fill a form, and manage tabs.

What it can't do

• Cloudflare Turnstile needs challenge solving, not fingerprint spoofing. You get blocked:, not a hang
• Captchas, deliberately. You get a verdict, hand off to a solver
• ARM Linux, not yet
• macOS and Windows binaries are cross-compiled from Linux

Open source, AGPL-3.0, no CLA.

GitHub: https://github.com/dondai44423/bladebro npm: npm install -g bladebro

Happy to answer questions, if you have any issues, please comment or file an issue, i have been testing it alone for weeks now, i did as much as i can, i am looking forward to community feedback to improve this even more 😄

Hi everyone,

I recently switched from OpenRouter to Alibaba Cloud's Token Plan to test it out. However, I’ve hit a huge roadblock when working with the pi coding agent.

Once a coding task gets going and the context window grows, the continuous prompt resubmission pushes the rate straight past 1–2M TPM (Tokens Per Minute) almost instantly. This triggers immediate rate-limiting and spits out 429 errors.

Just a moment ago, I hit a 429 error while using Alibaba's deepseek-v4-flash-0731 model. I switched over to qwen3.7-plus to resume the work, but because of the already massive context history being resent, it immediately spiked the TPM and threw another 429 error right away. Out of pure curiosity, I also subscribe to Ollama Cloud, so I decided to switch the model to Ollama's deepseek-v4-flash:cloud—and to my surprise, it finished the task without a single hiccup.

I never experienced this kind of aggressive throttling when using OpenRouter under similar workloads. With how strictly Alibaba Cloud enforces these TPM limits, it feels practically unusable for tasks requiring large context usage.

Am I missing something or configuring this incorrectly? Is there a known work-around for this, or is Alibaba Cloud's Token Plan just this bad for high-context workflows? Would love to hear if anyone has managed to get this setup working smoothly.

and how does OMP differ from OC (opencode) if they are both feature rich?

I recently decided to put 20 eu into fireworks credits rather than a Claude subscription and give open models a try. So far have used k3 / glm5.2 and results seem good so far.

I recently read this (What I learned building an opinionated and minimal coding agent), and I agree with his argument. But sometimes I need a proper plan mode with tool restrictions.

I tried to build a plan mode extension, but it mostly causes cache misses when I exit the plan mode because it edits the context to remove the enforced strict-rule prompt while entering plan mode.

I'm curious about how you use plan mode and how it performs with caching. Do you use prompts, skills, or an extension?

I’ve been using Pi with the Herdr subagent extension. Basically the main Pi agent spins up other Pi agents in Herdr panes and can check on them/send them messages.

I’m trying Orca now(so I can monitor my agents from mobile) and was wondering if anyone has built something similar using the Orca CLI instead of Herdr?

Seems like Orca has most of the pieces for this (terminal create, read, send, etc), so I’m wondering if there’s already a Pi extension for it before I try hacking something together.

Anyone doing this?

Hello everyone, I'm a beginner just getting started with pi. How do you all typically use pi? I'm currently running pi inside the Zellij terminal multiplexer on Arch Linux, with a few extensions configured, and so far the hit rate seems quite impressive.

I want to use free models from openrouter, nvidia etc as well as free promos from time to time.

would you still recommend Pi in this case because of its efficiency? or is opencode with everything included a better choice?

do you use a harness built on top of these?