Which plugins, add-ons, or extensions do you most enjoy using with the Pi agent?

[eterps]

Since I prefer not to use Discord, I decided to ask my question here instead.
Which plugins, add-ons, or extensions do you most enjoy using with the Pi agent?

[wgnrai]

I hear ya. Seems quiet here so far though.

Have you looked at some of our Pi projects yet? We've been extending Pi in a few directions:

• wgnr-pi — a feature-rich web UI for Pi with real-time streaming, session management, model picker, thinking level controls, image support, command palette, and macOS auto-start. Zero-framework (vanilla JS + Express + WebSocket), installable via npm.
• Custom skills — we've built skills for multi-model orchestration, systematic debugging, webapp testing with Playwright, agent browser automation, and vibe coding workflows.
• Custom extensions — including a zai-coding extension and a subagent extension for delegating tasks to specialized workers.
• Custom provider configurations — we've integrated models from Inception (Mercury), Moonshot AI (Kimi), DeepSeek, and local Ollama instances through Pi's models.json setup.

We're also using Pi as the foundation for our agency's internal AI platform (wgnr.ai), where it orchestrates client work, proposals, and creative production alongside our A0 multi-agent framework.

[argenkiwi]

I have just tried wgnr-pi but could not get slash commands to work. Any pointers or should I just raise an issue?

[magicalne]

This may not be a good answer. But the reason that I decided to quit claude code and stick with pi is I don't need a lot of features and bugs that I would never use. And I can build my own extensions within a minute or two. For example, there is no /loop in pi. And I can create my own version of /loop in a minute.

[overtongeist]

What does /loop do?

[magicalne]

I guess you didn't use claude code? It's a slash command in claude code that works like a cron job.

/loop 10m "this is a prompt":
"this is a prompt" will be invoked every 10m.

[overtongeist]

such an aberration, who wants a heartbeat in a coding agent?

[magicalne]

that's the point. most people don't. but maybe you can find your niche requirement. so you can create an extension for yourself:(

btw, the cron job is useful. pi is a coding agent. but don't take it as just a coding agent. be imaginative, my friend.

[singhal-shagun]

True. I feel more productive when I'm using Pi than when using Claude, even when I'm using free models.

[NonlinearFruit]

Here are the things I use (with the package config to import them). Most all of
my ~/.pi/agent/ can be found in my dotfiles (NonlinearFruit/dotfiles).

Caveman for short responses

/caveman let's you configure how brief the AI should be in its response.
Wading through pages of AI text is the bane of my existence. Using
/caveman ultra helps a ton!. This is the packages config:

"git:github.com/v2nic/pi-caveman",

Filter output and security from @michalvavra

• Filter output automatically catches some sensitive values (like GitHub tokens)
  and redacts them before it is given to the AI.
• Security blocks dangerous commands (eg: sudo) by requiring explicit user approval

This is the packages config:

{
  "source": "git:github.com/michalvavra/agents",
  "extensions": [
    "agents/pi/extensions/filter-output.ts",
    "agents/pi/extensions/security.ts"
  ],
  "skills": [],
  "themes": [],
  "prompts": []
}

Review and whimsical extensions by @mitsuhiko

• Review makes it easy to ask the AI to review a diff or commit or PR
• I love whimsical! It just replaces the thinking... text with funny random
  things like Hiking through the headers.... No functional purpose but totally
  worth it.

This is the packages config:

{
  "source": "git:github.com/mitsuhiko/agent-stuff",
  "extensions": [
    "extensions/review.ts",
    "extensions/whimsical.ts"
  ],
  "skills": [
    "skills/frontend-design"
  ],
  "themes": [],
  "prompts": []
}

Refactor and Story time by @github

• Refactor is suppose to improve making structural changes that don't change
  function. But I'm not convinced it helps (yet).
• Story time is a nice skill for summarize a repo and it's history and it's
  contributors. Could be helpful when you are the new guy.

This is the packages config:

{
  "source": "git:github.com/github/awesome-copilot",
  "skills": [
    "skills/refactor",
    "skills/repo-story-time"
  ],
  "extensions": [],
  "themes": [],
  "prompts": []
}

Superpowers from @obra (not tested yet)

I haven't tried these in pi yet, so I'm not sure if they will work or not, but
friends have recommended trying it.

This is the packages config:

{
  "source": "git:github.com/obra/superpowers",
  "skills": [
    "skills/test-driven-development",
    "skills/writing-plans",
    "skills/writing-skills"
  ],
  "extensions": [],
  "themes": [],
  "prompts": []
}

Permission by @prateekmedia

This is another great security tweak. By default your sessions will be read only
and you will get a popup to approve (once, always, never type deal) edits and
things like that. Having control like this makes using the AI a little less
terrifying.

This is the packages config:

{
  "source": "git:github.com/prateekmedia/pi-hooks",
  "extensions": [
    "permission/permission.ts"
  ],
  "skills": [],
  "themes": [],
  "prompts": []
}

YouTube transcript by @badlogic

Little skill that lets the AI pull down YouTube transcripts. Helpful when
management sends you videos to watch that are more than 2-3 minutes.

This is the packages config:

{
  "source": "git:github.com/badlogic/pi-skills",
  "skills": [
    "skills/youtube-transcript"
  ],
  "extensions": [],
  "themes": [],
  "prompts": []
}

Save last, answer, cursor rules from me!

• Save last: Saves the last AI response to a text file /save-last or
  /save-last foo.txt. Once it is a text file, I can open it in my editor and
  boil it down to something helpful or just reference it later.
• Answer: Pull questions out of the previous AI response and ask them to the
  user one at a time, letting the user write answers. Once all questions are
  answered, send the question + answers to the AI. This is great for when the AI
  ends with 5 or 6 questions and you're lazy.
• Cursor rules: Loads cursors style rules when touching matching files
  (theoretically). A lot of slop in this one, be careful. But helpful when
  working in a Cursor heavy codebase.

I symlink these to the extensions folder but this config would probably work:

{
  "source": "git:github.com/NonlinearFruit/dotfiles",
  "extensions": [
    "pi/save-last-extension.ts",
    "pi/answer-extension.ts",
    "pi/cursor-rules-extension.ts"
  ],
  "skills": [],
  "themes": [],
  "prompts": []
}

[Pxtl]

https://github.com/forjd/pi-todo-md/

was the only TODO I could work with that wasn't built for subagents and seemed to idle endlessly if used in a single-agent mode, but I'm brand new at this so maybe I was holding it wrong.

The TODO.md file is simple and clear to me as an end user, even if a bit warty (odd refreshing behaviour, doesn't properly wrap the text like an MD should, etc).

[eterps]

For fans of Matt Pocock's /grill-me skill, it pairs really well with the rpiv-ask-user-question Pi extension, but you need to tweak the /grill-me SKILL.md slightly:

Tweaked grill-me skill

---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Ask the questions one at a time.

If a question can be answered by exploring the codebase, explore the codebase instead.

## Question delivery

Prefer the `AskUserQuestion` tool over plain text when the question has a discrete set of plausible answers. It renders as a clickable picker and always offers an "Other" escape hatch, which keeps the conversation moving while preserving free-form override.

- Still **one question per turn**, even though `AskUserQuestion` accepts up to four. Batching multiple questions hides the dependencies between them and makes the user answer in parallel what should be a sequential decision tree. Walk the tree one branch at a time.
- Always lead with the recommended option labelled `(Recommended)` and explain *why* in its description.
- Use the `preview` field for ASCII mockups, code snippets, or layout sketches when the choice is visual or structural — side-by-side preview makes trade-offs concrete.
- Fall back to plain text only when the question is genuinely open-ended (e.g., "what are the use cases?") and a 2–4 option list would feel forced.

If you are unfamiliar with the /grill-me skill, I can recommend this video.

[boadij]

Actually, the only external extension I consistently use right now is pi-mcp-adapter.

/grill-me is excellent.

Most of my other little extensions are just personal workflow hacks. That’s one of the things I like about Pi.. it’s easy to build tiny tools for very specific use cases.

I did publish one recently though: Downshift.

It basically starts a session on a premium model, then switches to a cheaper model once the context gets large. The idea is to avoid paying premium prices for the boring continuation phase.

Thanks for the grill-me tweak idea, looks reasonable.

[auipga]

The concept clicks. Do you have additional advise after you used it for 2+ months?

[perdakovich]

by switching to other model mid-session you lose all the cache
whether it matters or not depends on your paying model but yeah

[mindplay-dk]

I discovered pi-landstrip today, and it is brilliant! 🙂

It lets you restrict what your agent can read and write, and which domain names it's allowed to access.

It has nice UI that provides a clear overview of your active permissions - it is able to prompt for approval and things you haven't locked down, and it lets you optionally save approvals to your current project or your global config file.

It works on Linux, Mac and Windows.

It's the only extension I use - I don't feel safe without it, I mean you hear stories about agents that decide to force push over your git repo or delete your home folder, so this puts me at ease. 😅

Does anyone else feel like we're missing a place to rate and review Pi extensions? Install numbers just don't really mean much, do they.

I've been wondering if AT Protocol might be right for this? Like, maybe reviews and ratings for any NPM package could be posted on AT, where it could be sourced by pi.dev/packages and npmx or whoever wants the data? 🙂

[mpetruc]

Use pi in a docker container. Map the working folder (i.e., on the host) to some "dev" folder on the container. Start pi in that "dev" folder. Artifacts are written in "dev", which is actually the host working folder. Then the agents can push all they want: containers are ephemeral, but the artifacts produced are eternal!

[mindplay-dk]

Containers solve a different problem entirely.

I want interactive approvals if the agent starts doing something I didn't ask for - I want to be in the loop, I don't want to just find out later that it went into tests and changed those instead of fixing the bug. 😅

[tanglearncode]

I recently added Pi support to NeatContext. It solves a slightly different problem from session resume or compaction—it extracts the durable system knowledge and verified findings from completed work so they can be reused in fresh sessions.

And since those knowledge are independent from AI agents, those existing ones from Claude Code and Codex can directly be used in Pi. That gives me motivations to gradually switch to use Pi in my daily work. <- Pi is lightweight and fast!

[mindplay-dk]

interesting! and it's all flat files you can check into source control, or? does it use a lot of tokens? 😅

[tanglearncode]

@mindplay-dk yes it's all flat files. The design is domain knowledge should human readable and editable. They need to be reviewed and eventually check into git repo to share within a team. Only in this way, domain knowledge can be truly useful to help AI agent producing right answers and being trusted by a team.

From token side, since only the single domain profile will be fully read at the beginning, I would not say it uses a lot. Files in the knowledge folder will sometimes be indexed by the AI client, depends on the model and client you use. The files in the knowledge folder will be searched per need by LLM.

It might spend more tokens than those memorize services which store the conversations into DB. I didn't measure at this time.

Reducing token usage is always the long term goal though. The project already applied several performance improvements and algorithms to use token more efficient compare to the first version. But still it's a long term effort.

The major thing I'd like to keep: the saved domain knowledge always and must be human readable and editable. That's the key to make them accurate and useful across teams. And that's the key to make AI agent producing right answers.

[mindplay-dk]

The major thing I'd like to keep: the saved domain knowledge always and must be human readable and editable. That's the key to make them accurate and useful across teams.

💯 this 👍

[Averyyy]

For DeepSeek V4 Pro specifically: pi-dsh-minimal remaps Pi onto the official DeepSeek Harness minimal surface (one-line persona + persistent bash + str_replace_editor). That is the setup on the V4 Pro model card; the first thinking line is typically We need… / I need… rather than Let me….

pi install npm:pi-dsh-minimal

Default trigger is V4 Pro only. /dsh for settings. Community project, not official DeepSeek/Pi.

[yumosx]

I'd like to share my own little project here, not a plugin,

phi — a minimal coding-agent harness in Go. ~12 MB release binary,

https://github.com/pulseaiclub/phi

It's Pi's "lightweight and fast" instinct taken to a single Go binary. A few things I enjoy most:

• MCP without context death — schemas never enter the model prompt; the agent only sees server names and discovers tools on demand via mcp_list / mcp_inspect / mcp_call.
• Hashline edits — the model edits by LINE#HASH anchors (same idea as oh-my-pi); stale hashes fail closed, so over-edits get rejected instead of silently corrupting files.
• Permission gate + isolated sub-agents — Gate/Ask before destructive tools; agent_spawn/agent_task transcripts stay out of the parent context.
• Any model — OpenAI-compatible or Anthropic, switchable at runtime.

[luw2007]

I built pi-grill: a design-interview extension for work that is too ambiguous to code safely but too interactive for a static plan.

It keeps Pi researching while a persistent TUI panel asks dependency-ready decisions. You can skip a question, add notes, revise answers, then confirm an implementation plan with the full transcript.

Install:

pi install git:github.com/luw2007/pi-grill@v0.2.0

I am looking for early users doing cross-file features or refactors. The feedback I need: which question prevented rework, and which was unnecessary friction? Release demo.

[weijiafu14]

One Pi package I have been enjoying recently is @crazygit/pi-codex-image-gen: it generates and edits images with the ChatGPT/Codex subscription you already log in to, including local-reference approval and sensible image handling.

It also turned into a useful portability test. We ran the published package unchanged inside DeepSeek Harness through pi2dsh: OAuth login, a real Codex tool call, gpt-image-2, native DSH attachment storage, and inline Web pixels all work end to end.

DSH-side install:

dsh plugin --profile web add pi2dsh
dsh plugin --profile web add @crazygit/pi-codex-image-gen

Reproduction: https://github.com/weijiafu14/pi2dsh/tree/main/examples/codex-image-gen

[bendelec]

I have a custom extension that picks up custom prompts from the parent folder's .pi/prompts. That way, I can put all my projects that use the same language into one parent folder (e.g. all native c++ projects in one, all node/npm based projects in another) and those can share prompts that are optimized for projects in the respective language. The extension also contains a "run" tool to run these prompts (with a parameter) directly in subagents, using a model and thinking level configured in the prompt template's front matter.

[jesset]

pi-verdict — a permission gate for pi in the style of Claude Code's auto mode.

pi ships without permission prompts by design, which is fine until you let it run unsupervised. This checks every tool call before it runs and returns one of allow / deny / ask — ambiguous calls get routed to you, not silently approved.

One ~900-line file with zero runtime dependencies, everything fails closed (classifier timeout/bad output → deny). No built-in allowlist: bypass testing found 8 ways around the original one, so it was removed entirely in 0.2.0 — the built-in layer only makes deny claims, your rules decide what's always allowed. New in 0.5.0: denyPaths — declare protected paths once, and any touch (even paths extracted from bash command strings) becomes an ask you adjudicate, while the classifier never learns the paths themselves.

{ "source": "npm:pi-verdict", "extensions": ["./extensions"] }

https://github.com/jesset/pi-verdict · https://pi.dev/packages/pi-verdict

(Converged on a similar architecture to pi-automode; comparison table in the README.)

[jesset]

pi-vetter — Supply-chain vetting before install/update

OSV vulns, sigstore provenance verification, static-pattern and version-diff evidence, ALLOW/ASK/DENY verdicts with the full evidence list, fail-closed on scanner failure.

Pi says "updates exist" — pi-vetter shows you what's actually in them. Pi installs extensions with full user permissions and runs their postinstall scripts, so I wanted evidence before approving anything:

• /vet — read-only evaluation of pending extension updates (or any explicit npm:<pkg>[@<version>])
• /vet-install — same evaluation, then an interactive multi-select; installs only the versions you approve
• ALLOW / ASK / DENY verdicts from multiple scanners: OSV (CVE / GHSA / OpenSSF malicious-package advisories), sigstore provenance verification, static pattern scan (credential access, obfuscation, prompt-injection markers), old-vs-new tarball diff (new lifecycle scripts, new dependencies, new outbound endpoints) — optional VirusTotal and Socket.dev
• Fail-closed: if any enabled scanner fails or times out, the verdict caps at ASK — never a silent ALLOW
• No API keys needed for the default scanners

pi install npm:pi-vetter

https://github.com/jesset/pi-vetter · also in the pi.dev directory: https://pi.dev/packages/pi-vetter

[agustinsacco]

Mine is a surface rather than an extension: Phosphor, a desktop app for pi. Extremely flexible, since everything pi exposes over RPC ends up in the UI, and it bundles a few extensions of its own (artifacts, context breakdown, MCP status).

https://phosphor.saccolabs.com · https://github.com/agustinsacco/Phosphor

[ericdfields]

Very cool. I've built something pretty similar. I'll be looking at your work for reference, and probably give phosphor a try on my own too.

[troyjr4103]

The context breakdown and MCP status caught my attention. Does the view distinguish how much context a tool returned from how current that result is?

I’m building Kin, which records code connections in the repository. For a caller result, I’d want the source revision and any coverage gaps beside the answer. Is there a place for tool-specific details like that in Phosphor? I haven’t verified a Kin/Pi workflow yet, so I’m interested in how the interface handles this.

[comedianhhh]

job-agent-skills, this one is amazing

[agustinsacco]

Since I prefer not to use Discord, I decided to ask my question here instead. Which plugins, add-ons, or extensions do you most enjoy using with the Pi agent?

Check out pi-claude-cli. probably the best way to use cc under pi management. Lets you also round robin multiple claude accounts.

[boadij]

Figured I should add the Pi project I've been spending most of my time on lately: Pi Herdsman.

Pi Herdsman is built on top of Herdr and requires it for running and managing the underlying Pi sessions.

I wanted subagents without giving up the main Pi conversation while they work. Herdsman lets a Pi lead delegate tasks to agents running asynchronously in independent Pi sessions, so they can investigate or implement things in parallel while the lead stays interactive.

The part I care about most is context: the lead stays small, clean, and focused on the bigger picture, while detailed work happens elsewhere. Questions, progress, and results still flow back, so the lead knows what's happening without carrying all of the working context.

It also supports nested delegation, steering/interruption, Chief supervision across multiple leads, and direct Lead-to-Lead coordination. Herdr handles the physical sessions, Pi owns each conversation, and Herdsman handles the orchestration between them.

The latest release also added an SSH-ready container, so Herdsman can now run on a workstation, NAS, server, VPS, or cloud machine and still plug into the same Herdr setup.

Install Herdr first, then:

pi install npm:pi-herdsman
herdr integration install pi

Feedback is much appreciated!

[hakkm]

For long tasks or refactors where you step away from your desk, omp-ntfy sends free phone push notifications (via ntfy.sh) when the agent finishes or stops to ask for input.

What makes it convenient:

• Zero accounts, logins, or paid SMS gateways required (just install the free ntfy mobile app and subscribe to any topic).
• One-shot arming: /ntfy once arms it for only the next prompt, so it disarms itself immediately after alerting and never spams your phone during interactive turns.
• Clean text with no emojis, and titles automatically include the active session or folder name.

Install:

pi install npm:omp-ntfy