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.

[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 👍