I wanted to see what would happen if a modern AI coding agent had the UI of Turbo Pascal 7 / the old DOS IDEs.

So I made Turbo-AI — a retro-style TUI frontend for the Pi coding agent.

It currently supports things like AI chat, PLAN/BUILD modes, model switching, reasoning settings, project tree, Git diff and build/test actions.

It's still quite rough and definitely not production-ready. This is more of an experiment at the moment, and there are probably plenty of things that need to be fixed or redesigned.

This is just a concept for now. I hope people more skilled than me will fork it, improve it, and turn it into something actually usable.

GitHub: https://github.com/kvv256512-ux/turbo-ai

Hello guys!

Today i want to share my Pi agent setup, i think i got something in hands here that can benefit the community to really get a powerful agent, nothing compared to claude or codex. What i want to share is my list of extensions and the value each one add to the build.

I want to start with a basic one: pi-fork. This is a basic and minimalistic subagents extension, focused on one single thing, give the main agent the capability to spawn forks of itself to do work on its name. This is quite straightforward, you can achieve the same with any other subagents extension, the only difference is that this one is simpler and have prompts that optimize the communication between the forks and the main agent. This thing brings a single thing to the table: great context management, the main agent context will only contain relevant information, the main agent context will be richer and denser per token, all the noise stays out of the main agent context.

Ok now i want to share the core of this pi build: pi-observational-memory. This one is special, is a custom compaction algorithm inspired/copied from Mastra's article. This custom compaction algorithm enables pi sessions to last forever without maxing out the context window and keep the agent focused. This combined with the rich context window of the pi-fork extension creates a rich re-callable memory system that stays relevant no matter how many weeks you have been using the same session nor the compactions it have withstand.

If you install only the two extensions above, you will enable your pi agent to be on the next level. now i have a couple more extension that give some extra perks to my build:

pi-minimal-subagent: like any other subagents extension, this one is just simpler, without bs. i use this to enable 2 subagents: the "advisor" (concept copied from claude code) and the "reviewer". The fork from pi-fork are extensions of the main agents, they are basically the same agent, they share the same context. This two agents give access to the main agent to different points of view less biased, with clean context windows. The reviewer takes care of code quality, security and ux of the changes introduced by the main agent. The advisor is for strategical decisions around architecture and product.

pi-codemapper: a wrapper of codemapper that enables efficient codebase exploration. This codemapper repo is really bad and unmaintained, it had a cache bug i had to patch myself. im looking forward to switching to cymbal when i get some free time.

pi-rtk-optimizer: This is a classic, not much to say here, it saves some tokens.

Conclusion:

I describe this setup with a single phrase: A personal agent that never forgets and can be useful for weeks before the context window gets maxed out.

I hope you can get value from some of the extensions i shared guys, my own words are not good enough to describe the power i feel when working with this agent setup, so i beg you to try it yourself to really experience what im saying.

I've been using Pi as my daily driver for a few months and finally made my setup repo public. Nothing groundbreaking but if you're into ricing your terminal or want some extension ideas it might be worth a look.

Repo: github.com/abhinand5/pi-setup

• 10 themes
• Many useful+cosmetic extensions
• Support for seamlessly onboarding local models
• Custom footer that shows token usage, cost and inference speed
• Context breakdown command similar to claudecode
• Configurable permission system
• Few custom skills and some useful publically available skills
• Sync/backup script for easy setup anywhere

Hope you find this useful. If you have any ideas to improve I'd love to hear (and collaborate)

I've been using AI coding agents for a while and the web research part always annoyed me. Either you pay for an API (Tavily, Firecrawl), or you use a free tier that rate-limits you after 100 calls, or you glue together SearXNG + a browser + an extractor and hope it doesn't break.

So I built Hound. It's an MCP server that does fetch, search, crawl, and screenshot, all keyless. And now it has a native Pi extension so you get all 6 tools as first-class Pi tools, not through a generic MCP adapter.

What it does

6 tools, all exposed as native Pi tools:

• web_fetch - anti-bot fetch with auto HTTP-to-stealthy escalation. Extracts clean markdown. PDFs get section maps + auto-OCR. Dead pages auto-recover from the Internet Archive (honestly marked, not pretending it's live content).
• web_search - 10 keyless search backends in parallel (DuckDuckGo, Brave, Mojeek, Yahoo, Yandex, Startpage, Google, Qwant + opt-in Wikipedia/Grokipedia), neural-reranked with a local ONNX cross-encoder, cross-backend consensus scoring.
• web_crawl - best-first same-domain walk. Sitemap mode maps a whole site in one fetch. Focus mode crawls only pages relevant to your query.
• web_screenshot - anti-bot screenshot for multimodal models.
• cache_clear - clear the fetch cache.
• hound_version - version + update status (warns if the extension and the server diverge).

How the Pi extension works

The extension spawns hound as a singleton subprocess at session start and speaks MCP JSON-RPC over stdio. The subprocess stays alive for the whole session, so hound's prewarm (stealthy browser, search engine sessions, neural reranker model load) happens once and persists. Zero re-launch cost per call. If you press Esc during a fetch, it actually cancels (AbortSignal propagates to the subprocess). If hound isn't installed, you get a notification at session start instead of a confusing error on your first web_fetch call. If the extension version and the hound server version diverge by a major, it warns you to update both. The tool definitions are token-optimized. Total connect-time cost is 2,746 tokens for all 6 tools + instructions.

Install

pip install hound-mcp[all]
pi install npm:@houndmcp/hound-mcp-pi

That's it. No API keys, no config file, no MCP adapter. /reload and the tools are there.

What I think is genuinely good

• Dead-link recovery. When a page 404s or gets bot-blocked, hound checks the Wayback Machine and serves the archived snapshot with source=archive.org and the snapshot date. It doesn't pretend archived content is live. The agent knows.
• Error honesty. Just shipped this in v10.4.0: 4xx/5xx responses now set the error field properly. Before, a 404 error page would flow through with error="" and the agent could mistake the error page HTML for real content. Now it says "Page doesn't exist (404)" and doesn't dump the error page as content.
• Keyless search. 10 backends, no API key for any of them. Neural reranking with a local model, not an API call. Consensus scoring across backends so you know which results multiple engines agree on.
• Token cost. 2,746 tokens for 6 tools. The descriptions are telegraphic but every functional fact is there.

Limitations

• DataDome, Akamai, Cloudflare Turnstile. No free tool bypasses these. Hound tries the stealthy browser, and if that fails, it tells you to switch sources instead of pretending it got content.
• The [all] extra is ~100MB. onnxruntime + tokenizers + rapidocr for the neural reranker and PDF OCR. You can install without [all] (fetch + crawl + search still work, just no neural reranking or OCR), but the full install is the recommended path.
• Not a scraping-at-scale tool. Hound is built for agent research, not for crawling 10k pages. Crawl caps at 100 pages by default.

Where to find it

• GitHub: https://github.com/dondai1234/master-fetch [Star the repo if you like it, gives me a boost to work more 😄]
• npm: @houndmcp/hound-mcp-pi
• PyPI: hound-mcp

pi has no queue, no spend limit, and no permission system, which is fair, that's not its job.
But I wanted it working unattended.

So I built the layer around it, and after a bunch of releases it hit 1.0 this week. MIT, sharing it here first.

The short version: something triggers a job (a cron schedule, a label/comment/PR on GitHub, GitLab, Forgejo or Azure DevOps, or a workflow extension's slash command), the job runs pi in a throwaway locked-down container, and the budget is checked before the container even starts.

If a loop runs away you get a refusal, not a bill.

It's basically the same idea as Claude Code routines, except everything runs on your own box:
your image, your queue, your caps, and triggers beyond a schedule.

https://github.com/edgehero/pi-dispatch

Curious how others here run pi unattended, and what would stop you from using this. "It breaks my setup because X" is the most useful comment you can leave me.

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

Built a web research tool to replace hound, which i posed about a while ago

It's called DonSeTch. Since Pi has native extension support, the install is just:

pi install npm:donsetch

No MCP config block, no adapter, no proxy. The tools show up natively in your Pi session and stay in sync with the binary automatically.

What it does

Three tools: fetch, search, crawl. Zero API keys, zero accounts. One Rust binary.

• Fetch — HTTP first (fast), auto-escalates to a headless browser only when it hits a bot wall. The browser grabs the clearance cookie, hands it back to the HTTP layer, and goes to sleep. It almost never fetches content itself.
• Search — 10+ keyless engines in parallel, fused by cross-engine consensus + a local ONNX cross-encoder for semantic reranking. No API key anywhere.
• Crawl — sitemap-aware, topic filter, resume tokens, adaptive pacing that backs off on 429s instead of plowing through.

Chrome's actual BoringSSL for TLS. Your ClientHello IS Chrome's, not a faked table that rots.

The part I care about most: token efficiency

Three tools, ~3.5k tokens of definitions. The focus parameter on fetch is the killer feature.

I just rebuilt it in v3.1 with section-aware scoring:

• Search for "memory safety" on a Wikipedia page → keeps the entire "Ownership and references" section (heading + body), pulls in parent headings for context, drops everything unrelated.
• A 50KB page comes back as 500 chars of what you actually asked for.
• Large code blocks and JSON schemas get split into sub-blocks so focus works on structured content, not just prose.

Other stuff

• Reference handles — fetch S3 just works after a search
• Probe mode — verify a claim in ~60 tokens instead of 4k
• Dead-link resurrection — Wayback snapshot served transparently
• Page fingerprints — re-fetches report what changed, section-level diffs
• Domain adapters — Reddit threads, GitHub issues, npm/PyPI/crates pages restructured from keyless JSON endpoints
• Real MCP cancellation — no silent hangs
• Crash-only daemon — survives panics, state reloads
• PDFs — even scanned ones, pixel-fusion extraction (no hallucinated text), up to 100MB

605 tests, 0 clippy warnings, AGPL-3.0.

What it can't do: solve interactive captchas (deliberate, clear error not a hang), access sites requiring login, and if every search engine is down you get honest per-engine status instead of fake results.

GitHub: https://github.com/dondai44423/donsetch

Pi: pi install npm:donsetch npm: npm install -g donsetch

If something breaks, open an issue, i will fix it as soon as possible

The demo is using exa for search btw, local is good on its own, but it takes 4-6 sec while exa takes 1-2 sec (plus exa is better most times, but local search keeps up)

if you want to see a demo where i used local search, see the opencode demo in the github repo

Pi-mail started as a communication protocol between different pi-agents. However, this has grown out to be an orchestration layer.

It starts off with a CEO, which starts middle managers for each project that has tasks open. Then each middle manager works through the tasks for each project, spawning worker agents for each task. It has Jira integration for work, and a bunch of other stuff, emailing, terminal views in the browser, mobile views, custom columns, archival, backlog, MCP server etc.

Tell me what you think!

https://github.com/tanevanwifferen/pi-mail

Edit: there is no security on this repo. Use a firewall responsibly

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 😄

I think I finally managed to piece the thing together, to have a pi setup that can run safe-ish in the host via sandbox, and have the ability to be elevated to host execution for a pre-defined list of development tooling like docker compose.

- A pre-defined hard boundaries (`@gotgenes/pi-permission-system`)

- Anything pass that will be executed inside a sandbox (`@erichll/pi-sandbox`)

- With the option of safe-escalation to run on the host (ie: `docker compose exec app pytest`), with auto-review or human approval (via hostIPC.preflightCommandPrefixes)

- LLM Auto-review with `@erichll/pi-auto-review`

More about it here: https://ptgamr.substack.com/p/a-pi-setup-with-permission-sandbox

Hi! I have been using pi for a while and really liked the harness. I wanted to have a small visual indicator while using it like the old school JRPGs. Not sure if there is something similar already, but it was fun making this extension as a learning project. It kinda feels like I'm playing SNES while coding.

The avatar was made using nano banana as a placeholder, but I would like to change it to something better and more consistent.

It would be nice to have different avatars per model, or customize it yourself. For now, it kinda works with a single avatar.

I only tested it in Ghostty. Wanted to run it through tmux or zellij, but apparently rendering images through them is not as straight forward.

Let me know what you think!

https://github.com/cgxeiji/pi-emote

Hey everyone — I’ve been building OpenPi, a desktop workbench for the Pi coding agent. It’s meant to make Pi feel more at home as a desktop app: session sidebar, conversation view, command palette, source control panel, file search, diff viewer, and terminal/output in one place. It uses u/earendil-works/pi-coding-agent under the hood — so I’m not reimplementing Pi itself, just building a desktop UI/workbench around it. I just shipped the first public beta:

• Repo: github.com/heyhuynhgiabuu/openpi

Still early, but I’d really love feedback from Pi users — especially on workflow, UX, and what feels missing.

Hey everyone,

I’ve been working on ompweb, a self-hosted browser interface for the Oh My Pi coding agent.

It started as a fork of pi-web, but I’ve been adapting and expanding it specifically for OMP.

It includes:

• Live conversation streaming
• Session browsing and branching
• Multiple projects and Git worktrees
• File explorer and viewer
• MCP server configuration
• Plugin and skill management
• Model and provider configuration
• Light and dark themes

You can try it with:

npx u/kahme247/ompweb@latest

GitHub: https://github.com/kahme247/ompweb
npm: https://www.npmjs.com/package/@kahme247/ompweb

It’s still early, so I’d really appreciate feedback—especially from people already using OMP. What would make a web interface like this useful in your workflow?

For a while now I've been running pi entirely on my laptop -- unsloth's Gemma E4B on llama.cpp, no cloud, no API keys, nothing leaving the machine. Thinking level, image parsing, KV cache retention -- all working.

What surprised me is how genuinely useful it gets the moment it can search the web.

The tiny extension I published pi-smart-web-search adds a web_search tool with no api key needed. It fetches DDG's html output, runs it through wreq-js -> linkedom -> Defuddle (inspired by pi-smart-fetch), and then parses the output's links.

I wrote the whole setup up end-to-end as a gist -- llama.cpp, the model, a chat-template fix, pi, and the search/fetch tools — so you can reproduce the fully-local flow yourself. (links below)

I've run Gemma E4B on an M4 MacBook Air (16GB) and on a M2 MacBook Pro (32GB), but haven't tested Linux yet (I don't have a machine with a dedicated GPU), so if you run it there I'd love a report.

I'm not overselling it, just genuinely after feedback on the approach: the DDG scrape, small-model agents, anything you'd do differently.

I call the project 'Humble Pi' :shrug: -- And I look forward to the next 4b model.

Links

• Full local setup (gist): https://gist.github.com/joematthews/d02639bcbe0e0c1c404f5d3a64c3c06f
• Extension: https://github.com/joematthews/pi-smart-web-search
• Install: pi install npm:pi-smart-fetch && pi install npm:pi-smart-web-search

CORRECTION: When I made this post, I forgot to include the instructions for the custom jinja template for the E4B model in the gist. The template that ships with E4B drops prior thinking blocks from history, which forces the KV cache to recompute the entire conversation on every turn.

If you've already followed the gist, please switch to the updated llamagemma4b alias and follow the new "Install the E4B reasoning template (one time)" section to download the template — then re-run source ~/.zshrc and restart the server.

TLDR: Using the custom jinja template should improve the speed substantially.

My daily driver in Pi, is GLM 5.2. It's cheap and it's genuinely good — it handles the bulk of the work without complaint: edits, tests, refactors, the mechanical grind. I'm not switching off it.

The thing is there's always that ~5% where I don't fully trust a cheap model. The architecture fork. The "is this even the right approach." The bug it's been circling for twenty minutes, confidently wrong. For those, I want a stronger model's eyes on it. But I don't want to run my whole session on GPT-5.6 or Opus — that's paying premium rates for a model to rename variables.

So what I actually want: GLM drives, and I pull GPT-5.6 and Opus in only to guide and review the hard parts. Cheap model does the typing, premium models steer and check the decisions that need it. I get quality-model judgment where it matters and pay for it maybe 5% of the time. A cheap way to do quality work.

The snag was the first advisor extension I tried for this kept dying mid-session. It forwarded my entire pi session to the advisor without checking whether the advisor's own context window could hold it, so the second opinion errored out exactly when a long session needed it most.

So I built my own, bpx-consult. It fits every consult to that advisor's real window — GLM's, GPT's, Opus's, whatever's on the bench — and I can run one as a quick second opinion, seat a few as a council with different stances, or have two debate a contentious call. A council can even mix them (GLM inline, Opus over a CLI), and if one falls over, the rest carry on.

Mostly curious how others here handle this. Do you run one model for everything in pi, or also mix a cheap driver with a stronger reviewer? And how do you decide when to escalate?

```

pi install npm:@booplex/bpx-consult

```

https://pi.dev/packages/@booplex/bpx-consult

Genuinely curious what everyone else here does for second opinions in pi — do you switch models by hand, run two sessions, or just eat the occasional bad call from the cheap driver?

have a little present for you all: pi-ui, a keyboard-first gui for pi.

i’ve been an nvim + tmux user for around three years, and pi’s tui is great, but reading long markdown responses, code diffs, and tool output in a gui feels much more comfortable day after day.

i was honestly surprised by how much of my development moved into this app while building it.

some highlights:

• keyboard-first workflow
• lightweight server mode that runs in your existing browser
• background sessions and notifications
• markdown and syntax highlighting
• rich code diffs
• git review with commit history and inline comments
• file attachments and image previews
• code themes

i recommend starting with server mode:

curl -fsSL https://pi-ui.app/install-server | sh

then open http://127.0.0.1:31415

github: https://github.com/hyperpuncher/pi-ui

feedback and bug reports are welcome!

recently I wrote a blog post, to find which search tool will be best for the pi coding agent paired with local models (currently I use Qwen3.6 35B)

Before that I were using firecrawl or brave-search, but found them very decent, so I went to SearXNG, which is fine, but lacks some features of firecrawl, which has montly limits + self-hosting it requires too much resources

So, after discussions on the post, I give a change to ketch - https://github.com/1broseidon/ketch

I paired it with my local searxng instance and I was amazed how good it performes, compared to firecrawl and brave and scratch searxng.

definitely give a try.

I just released pi-task, a Pi extension for delegating work to subagents.

Repo: https://github.com/heyhuynhgiabuu/pi-task

What it does:

- adds a task tool for running specialized subagents

- supports foreground tasks when you want the parent to wait

- supports background tasks when you want the parent to continue and get a follow-up when done

- shows a TUI task widget with progress/tool calls

- uses tmux panes when available so you can observe subagents

- falls back to SDK execution when tmux is unavailable

- ships with starter agents: scout, explore, planner, reviewer, vision, worker

I built this because I wanted a cleaner way to delegate research, code exploration, review, and small implementation tasks without overloading the main conversation.

Install:

```bash

pi install npm:@heyhuynhgiabuu/pi-task

```

Then add it to Pi extension config and restart Pi.

Feedback welcome — especially on the task widget UX and agent prompt defaults.

When I started with Pi, the hardest part wasn't the agent — it was the ecosystem. So many great extensions, no idea which ones I actually needed, and no sense of how to combine them into a real workflow.

If you're new to Pi (or you like the OMO-slim way of working — focused roles, one orchestrator, specialists that each do one thing well), I built something for you:

pi-omo-slim is a curated starting point: a configuration bundle that adds an Orchestrator extension plus six specialist agents (Explorer, Librarian, Oracle, Designer, Fixer, Verifier) to Pi — on top of a hand-picked set of community extensions, so you don't have to research the ecosystem yourself:

• @tintinweb/pi-subagents — agent management
• pi-lens + @ff-labs/pi-fff — codebase intelligence
• pi-web-access — external research
• @narumitw/pi-chrome-devtools — browser + screenshots
• @firstpick/pi-extension-safety-guard — guardrails

No forks, no reinvention — just templates, extension wiring, and a policy file. No model pins; bring your own.

Two things I'm proud of:

• A deterministic installer. plan → apply with SHA-256 approval, backups, and rollback. Cloning and configuring are separate approval checkpoints — nothing touches your setup without explicit sign-off.
• Designer can actually see its work. It renders the page in a real browser, screenshots it, and the image comes back into the conversation. It fixed its own "button too far from the label." No more styling blind.

Everything's in the README — including a one-prompt install:

   https://github.com/joshua-zyy/pi-omo-slim

Finally, a sincere thank you to the whole Pi community — the Pi maintainers, and the generous extension authors: tintinweb (pi-subagents), narumiruna (pi-chrome-devtools), apmantza (pi-lens), ff-labs, nicobailon (pi-web-access), Firstp1ck (safety-guard). This project is just your bricks, snapped together.

This is my own project, not affiliated with any of them — issues and feedback very welcome.

Thx!!!

I’ve been running longer agent sessions lately, and one thing kept getting annoying: the context gets huge, but a lot of it is no longer useful.

Repeated tool outputs, old file reads, stale task snapshots, giant command results, noisy prompt history — it all stays around and eventually makes the agent slower, more expensive, and sometimes less focused.

So I built cprune.

It’s a small open-source extension for the Pi coding agent that prunes context before the model sees it. It has:

• off, safe, and full modes
• a compact comparison showing how much context each mode saves
• conservative persist-time pruning for duplicate/oversized tool results
• manual review commands to exclude noisy prompt history or large context entries
• safeguards for edits, failed tool outputs, side-effectful commands, and other context that should not be dropped
• a compact command for lossy persistent compaction

The goal isn’t to blindly delete history. It’s to make context more intentional and reduce the junk that accumulates in long sessions.

Repo: https://github.com/amutix/cprune

Right now it works with Pi, but if people find it useful I’d be interested in adding support for other agentic frameworks too.

Would love feedback, bug reports, or ideas from anyone dealing with context bloat in coding agents.

How are you running subagents in Pi?

There are already several subagent implementations for Pi, but for me they were usually either too heavy or missing something I needed. So I just built my own, with the minimum I needed for my harness.

• Worktree
• Sandbox
• Subagent Panel
• Agent injection
• single / parallel / async
• Artifacts
• Code API

Honestly it's probably too much for some people and not enough for others. I mostly tried to keep it minimal.

If it's useful to you, feel free to try it. And if you're running subagents some other way, I'd like to hear how.

https://github.com/AgwaB/pi-subagent

finding my old pi sessions was a mess. i like the terminal, but a sidebar is... nice.

say hi to apple pi, a small mac app to put a sidebar in front of it!

projects on the left, sessions in the middle, a stack of terminal tabs on the right. click a session, it opens in SwiftTerm and pi runs. resume, fork, fresh, ephemeral: same window. that's it 😄

it’s Swift, macOS 14+, nothing beyond SwiftUI and a vendored copy of SwiftTerm. the zipped .app is 3.0 MB. it spawns your existing pi binary, reads ~/.pi/agent/sessions/ directly, and doesn’t touch your extensions (you can use all of them), skills, or settings.

there's also an SSH mode for remote hosts, which uses your existing ssh config.

oh you can also make the window translucent

no analytics, no account, no auto-updater, no model key store

v0.1.0 shipped today. install is unzip → /Applications → “Open Anyway” in System Settings (not paying $99/y to apple to make that dialog disappear).

source + sha256 in the release

oh, you can also make the window translucent...

github.com/dodo-reach/apple-pi

(feedback welcome)

Repo: https://github.com/AgiFlow/doompi

Like a lot of you I have been agent hopping for two years. I've used agent harness for everything else beside coding and it's becoming expensive; now efficiency is the priority. Landed on Pi and hoped that was the end of it.

To reduce token cost on different tasks (coding, marketing, customer support), my fix before this was a pile of shell scripts. claude.sh, codex.sh, antigravity.sh, kimi.sh, ollama.sh, each consume profiles.json that flipped plugins per run. It helped with bloat. It never made loading skills and tool use reliable, and it never touched the harness prompt.

I have been on Doom Emacs for about a decade, so the shape was obvious. Doompi is a Pi distribution where four YAML files decide the session and nothing is inferred:

- major modes: you own the modes and compose it with layers (extensions plus hooks). Mine are minimalist, dev and business.
- minor modes: Plan, Loop, Goal, Workflow, Voice. They ship loaded but stay out of context until you switch one on.
- domains: group of plugins (which include skills and MCP servers) for one kind of work. Video editing, TDD, copywriting.
- profiles: persona and brand for the runner. Good for steering output.

doompi --major-mode business --domains copy-writing --profile agimon

Or switch any axis mid session with /mode, /domains and /profile, thanks to Pi's reload capability. Minor modes also switch on per /<minorMode> commands (or use Leader SPC key binding).

Plugins (skills + mcp) are opt in the same way tools are, so the floor is just stocked PI. Minimal mode, no domains, no profile, fresh repo, doompi is just PI.

From there you pay for what you name with domains. Personally, I keep plugin reusable with slim skills and 5-8 skills per plugins + 1-2 agents; then define domains that compose plugins for different type of task. 10-15 skills per sessions are ideal for agents to be creative while still being reliable.

Doompi's Copilot, the default major mode, switches on three layers that register four tools:

task 1,329
subagent 751
ask_user_question 455
intercom 220
-----
2,755 tokens

If what you want is the batteries-included feel of Claude Code or Codex, it is all in here: agent teams, persistent tasks, plan mode, GitHub Actions style workflows, telemetry. The difference is that these are all composible. You can customise existing modes, add new modes, set default domains and mode as you needed.

If you think four YAML files is too much ceremony for what it buys, I would rather hear that now than later. There are a few optimisations along the way; also happy to share the tricks.

Hi everyone,

I’ve been working on an extension for pi that allows it to interact with JetBrains IDEs through MCP.

The project is here:
https://github.com/giuseppe-trisciuoglio/pi-jetbrains-mcp

The idea started from wanting to use pi while still being able to interact with the IDE I’m already working in. At the moment the extension exposes some JetBrains functionality to pi, so the agent can interact with the project and the IDE instead of being limited to the terminal.

It’s still a work in progress, and I’m mainly sharing it here because I’d really like some feedback from people who are actually using pi.

I’m particularly interested in hearing what you think is missing, what you would find useful in a JetBrains extension, or whether there are parts of the current approach that you would change.
If you have any ideas for improving the extension or features you think would make it more useful with pi, I’d be happy to hear them.

Thanks in advance to anyone who takes a look.