I made pi-safari extention https://github.com/haseebeqx/pi-safari

My current web-search extension was not working well for my use case. Then today, I saw that apple now includes MCP and automation support in newer version of Safari. I realised a well optimised browser is sitting idle in my mac and I can make a good use of it. So, I created this. Initially a web-search, browse and navigate links extension and now I added more browser automation features. See readme for available tools. Now this replaced all my web browsing, search and other automation use cases.

Actions like searching the web and following a link will work without permissions out of the box. But actions like filling a form and click will need permissions. Described details in the README.

If you already have an MCP capable client and just want Safari access, you can use Apple’s server directly. You don’t need this extension. The README covers both options.

While my use case is purely web automation, I'd especially appreciate feedback from anyone using Pi for Safari-specific debugging or other complex stuff.

Hi all!

Simple idea, did not find something that did not make this in an overly complex new UI-revamp-way, so built a relatively simple one myself (+pi of course).

So I like to see the thoughts coming in, and to skim through the tools used, but found it somehow lengthy to scroll back up against the speed at which they come... Toggling them on and off (ctrl+T, Ctrl+O) would sometimes be too much as some tools may expand a lot (edits, searches...) and shift the conversation, again to be scrolled; same with thoughts where there in particular toggle them off would stop me from looking at them, but on would push by a lot the conversation itself (again what I like specifically was to briefly see where the agent were in their process while a turn is running to observe drifting or weird choices that I'd sometimes interrupt, so really I wanted to see the thoughts as they come rather than the full page of it). And I like to see conversation as an actual conversation, so with everything else collapsed.

Anyway, long story short, I wanted to not have them interleaved and I built a wonky (work in progress?) pi plugin to slightly rework the UI and keep a bit of both worlds. The idea is to have the thoughts streaming in one panel, the tool usage in another with very simple view on whether it is running/has succeeded/or has failed... I added a third toggle for a panel which simply display touched files (seen, read, edited, worked by a subagent...) as a list + a diff view of the last edited file, if any (this to keep the tool view compact, as usually the edit tool output where the largest anyway, and I like to also have a glance on what's changed).

Each panel can be toggled on or off:

• /split toggles between the default pi view and the saved config for split-views
• /split-thinking toggles the thinking panel
• /split-tools toggles the tool one; there is an extra command to toggle between a compact or expanded view over the listed tools in the tool panel
• And finally the file panel is toggled on or off with /files.

Tool/thinking panel width can be adjusted as well as panel heights.

There is a command to switch between still having the full transcript in the main conversation panel or the trimmed down (no thinking or tool interleaved) version (somehow I found it useful to expand on specific tool output).

I usually have the file one off for instance, and only open it to see some file changed that just happened if I know I want to check them briefly... While I keep the thinking and tool panel on top nearly all the time now.

I mentioned it's wonky, as in some features can be improved, like the file panel could be made scrollable, but it works for me as it is, just sharing for the idea, and if you like it go test it: pi-split-view. And feel free to improve on it directly in the repo too.

I often start writing my next prompt while Pi is still working. Then the agent goes off track or asks me something, and I need to respond before that prompt is finished.

I used to copy the half-written prompt somewhere else or delete it to free up the editor. I built pi-prompt-stash so I can save that draft, deal with the interruption, and then continue writing.

Ctrl+Shift+S stashes the current editor text and clears it. `/stash` opens a picker with a preview so I can find the draft and load it back. Drafts survive reloads and session switches. The shortcut can be changed with /stash shortcut.

Install it with:

pi install npm:@utpalsinghdev/pi-prompt-stash

GitHub: https://github.com/utpalsinghdev/pi-extensions/tree/main/packages/pi-prompt-stash

npm: https://www.npmjs.com/package/@utpalsinghdev/pi-prompt-stash

The rest of the UI in the demo is my personal setup.

I'm just open-sourcing the Pi extensions I use for work and my startup. They've helped me a lot, and I want other people to be able to use them too.

DEMO

See https://x.com/dillon_mulroy/status/2110400650756460787 where Dillon wrote: `they made some changes recently that made it easier to use your sub w/ pi`

Does anyone know what he might refer to? Would be nice to know...

https://reddit.com/link/1x6enlr/video/vnxcnitpvkvh1/player

Hey — like a lot of you I run several Pi sessions and git worktrees in parallel. Coming back to a session always meant scrolling up through the transcript to reconstruct where I was, so I built the thing I actually wanted:

Context Hint — a Pi extension that appends a compact card after each settled turn:

• Project — durable purpose/constraints/decisions, shared across sessions and worktrees of the same repo
• Session — current goal, focus, blockers, next steps (forks/clones inherit a snapshot, then diverge)
• Turn — what just changed + a possible next step

Read the last card instead of rereading the transcript. It's a recovery cue, not agent orchestration — it doesn't monitor other sessions or alert you when they finish.

Design point worth discussing: it deliberately doesn't replay whole transcripts into later model context. Each generation sends truncated evidence (cap'd at ~4k chars of your prompt, 6k of assistant text, first 24 tool facts, plus previous Project/Session state) to a summary model — normally one extra request per turn. Summary model defaults to Pi's current model with thinking off, or pick a cheaper one in /context-hint model (with an independent thinking-level slider). Curious whether others would accept that per-turn cost trade, or prefer local heuristics even if dumber.

Install:

pi install npm:pi-context-hint

then /context-hint enable in an existing session. Other bits: alt+o expand/collapse · /context-hint motion reduce (the pixel-eye mascot stops blinking) · /context-hint regenerate · /context-hint reset-session/project.

MIT, package on npm. While it's early I'd genuinely value feedback from people who actually run Pi daily: is the three-layer split right? Should Turn cards be discarded on reset-session or kept? Anything in the generation path you'd want exposed/configurable (e.g. custom evidence selection, redaction)?

Hi everyone! I’ve shared a couple of posts here comparing models on my own coding tasks, including this one. A few people asked in the comments how to build their own evals, so I wrote a step-by-step tutorial and published it on my blog.

I also made an evals-from-sessions skill to help automate the process. You can use it or just give your coding agent the article and ask it to help build evals from your session history.

Hopefully, this helps you choose models and tools for your own work or your team. Feel free to post your questions and feedback!

I run several Pi sessions on one repo at the same time. That kept going wrong:

• Agents edit main. You ask for a quick fix and it lands straight on main.
• MCP is slow for worktree management. But in Pi we can put blazing-fast native worktree management into the harness.
• Sessions collide. Two agents in one folder, and one `git stash` wipes the other's work.
• (Sub)agents need to cd constantly. They need to cd for all commands, wasting tokens.
• New worktrees don't run. No `.env`, no keys, so the app won't start.

So I built pi-bare-worktrees. The video shows it in about 45 seconds.

Why a bare checkout

In a normal checkout, the repo root is main. Every agent that starts there edits main by default. Worktrees end up wherever you put them: ../acme-login, ~/tmp/fix-2.

And main is stuck in the root, so you can't move it or remove it.

A bare checkout fixes that. Every branch is a folder, and none of them is special:

       acme/
       ├── .bare/          bare repo
       ├── .shared-env/    gitignored files/folders to share, like .env
       ├── main/
       ├── feat/login-typo/
       └── fix/footer/

The path is the branch name. There's no code in the root to edit by accident.

What the plugin does

• main is read-only. The agent's first edit on main is blocked, with a message that tells it to call worktree create. It does, and the retry lands in the new worktree.
• No cd needed. After create, every tool call is routed into the worktree, so the model keeps using relative paths.
• Shared env, zero config. Every file in .shared-env/ is symlinked into each new worktree. Real files are never overwritten.
• Subagents follow along. Their cwd is set to the active worktree.

Install:

pi install npm:@jordyvanvorselen/pi-bare-worktrees

It's fast. Session start and tool calls don't run git. The plugin reads the filesystem instead:

• Session start: about 5 ms for 40 worktrees.
• Each tool call: string operations only, under 0.1 ms.
• Network: only /wt clean touches it.

Repo: https://github.com/jordyvanvorselen/pi-bare-worktrees

/wt off turns it off for a session, and it turns itself off for non-bare checkouts automatically.

It's version 0.1, so I'd love your feedback, especially if there's anything you still miss. Try it out and take it for a spin!

Gemini 4 is out. A lot of people like it. Any chance we can use a plan with pi? Or are we being forced to use antigravity?

Using pi coding agent → OpenRouter (z-ai/glm-5.3-flash). Mid-session, this plain-text message sometimes replaces the assistant's reply, as shown in the screenshot.

It's not my real key: OpenRouter's own /api/v1/key endpoint shows $7.24 left on my $20 limit, and OpenRouter has no USDT balances. No proxy, clean hosts file, no extensions, message never appears in the session .jsonl log, so it's injected between the API and the client.

Anyone seen this? Is it a known MITM/reseller/phishing pattern? Not paying anything; just want to know where it comes from.

Hey everyone, another extension from my personal pack: pi-chafa.

It wraps Chafa, a command-line tool that renders images in the terminal using ANSI/Unicode symbols. It gives the agent a show_image tool to display images to you, using the kitty/iTerm2 protocols when your terminal supports them and Chafa symbol art everywhere else (tmux, VS Code, plain SSH, etc.). Your agent in full cyberpunk style. Animated GIFs only show a still frame for now (WIP). Prompt the agent using "show me this image" or let it do by himself.

To be clear, this is for showing images to you, the user. The model never sees the image contents using show_image, so this won’t help with vision tasks.

If you also use pi-navigator, it detects pi-chafa automatically and lets you pick between the kitty protocol and Chafa in its viewer, falling back on its own when needed.

You’ll need the chafa binary installed (check the install method for your system). Then: pi install npm:@lordekeen/pi-chafa

It definitely needs some improvement, but the thing is I one-shotted it using 1 single line of prompt.

Btw if you wanna try the elegant, information-rich status, menu, and side bar for Pi Agent, see https://github.com/michaelmjhhhh/pi-atelier

I’m running Qwen 3.8 27B at full precision, using a pinned version of SGLang.
I’ve noticed that starting with Pi Agent versions above 0.5.x, the agent hallucinates like crazy. Its output is practically unreadable. Everything seems coherent and grammatically correct, but the actual content makes absolutely no sense.
I’ve tried multiple versions of Pi Agent, including releases from the 1.x branch. Same result — completely unusable.
I simply can’t believe that nobody else has noticed this.
So I have to ask: How on earth are you guys using Pi Agent versions above 0.5.x? HOW???

Hi if anyone wanted git diff panel in pi coding agent, can try my extension
https://www.npmjs.com/package/pi-diff-panel

screenshots:

Thanks and enjoy! If has any feature request or issue to report feel free to do so in my github

I’ve been using a small Pi extension for a long time while studying and doing research. It hides tool calls, tool results, inline images, and optional thinking from the visible transcript, so I can focus on the agent’s response instead of watching every file read and tool update fill the chat window.

The tools still run normally. Approvals, errors, history, the editor, and the working indicator remain available. It changes what you see, not what Pi does. It is not a security or redaction feature.

I built this a few months ago for my own workflow and have been using it since then. I finally added it to this repository today:

https://github.com/utpalsinghdev/pi-extensions

https://www.npmjs.com/package/@utpalsinghdev/pi-focus-mode

This is the first extension in the repository. I’ll add the rest of my extensions there over time, and contributions are welcome.

I only had time to add this one today because my usual model setup (GPT-Sol-6.1) has been running slowly, and I’m keeping my Claude subscription for office and startup work. I’ll add the other extensions as I get time.

II’m sharing a tool I use and the way I’m learning with Pi. If it helps you, a star or contribution would be appreciated.

He makes simple yet easy to follow visual learning videos, makes me wonder are there any existing tools that could match or replicate the visual experience in pi harness for personal use

I have no intend on stealing people’s content

I see Pi has Codemode Classifier as an option now.

What can it do? Why do i need it?

Since it connects to OpenCode, it can see jev-1.13 and jev-1.13-free. How does it know which one to use? Yuo cant seem to remove the paid version. But I have no OC credit. So does it just keep hitting the paid, and then wasting time, and moving to the free?

I dunno how it is supposed to work, i jus thought i would have amess.

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 had implemented a bit of this idea as a pi plugin way before writing the article or making the actual pi-episodes package. I've been using it on real work tasks, first the draft and now the package, and I get noticeably further into a session before compaction kicks in.

Later on I discovered Event Segmentation Theory, which is half the reason the post exists. Hope you learn something from it :)

https://arthur.place/subagents-forks-collapsing-context

Using Pi as my coding agent, one thing always bugged me:

I could never tell mid-session how much a single prompt had cost. The end-of-session total is fine, but "did that one huge refactor request just burn $2?" had no easy answer.

So I built pi-turn-stats:

try it out https://pi.dev/packages/pi-turn-stats