Pi Extensions & Plugins

$ pi↗

The Pi monorepo: unified LLM API, agent loop, TUI, and the coding agent CLI itself.

$ npm install -g @earendil-works/pi-coding-agent

Skip it when — Using pi is not a reason to clone it — this is the monorepo for people hacking on pi itself; everyone else installs the npm package.

$ @earendil-works/pi-coding-agent↗

The official npm package — install the Pi coding agent CLI with one command.

$ npm install -g --ignore-scripts @earendil-works/pi-coding-agent

Skip it when — Already running pi? Then you already have this — it is the CLI base, not an add-on.

$ pi-skills↗

The official skill collection for Pi, also compatible with Claude Code and Codex CLI.

$ git clone https://github.com/badlogic/pi-skills ~/.pi/agent/skills/pi-skills

Skip it when — Wanting tools and code, not prompt skills? The official pack ships instructions, not executables — pick from the tool groups below instead.

$ Pi Web↗

Local web UI for Pi: browse sessions, chat in real time, and manage skills from your browser.

$ npx @agegr/pi-web@latest

Skip it when — Happy in the terminal? Pi Web is a second local service to keep running — the TUI already covers daily driving.

$ pi-gui↗

Community Electron desktop GUI for Pi with a threaded timeline, git worktree isolation, integrated terminal, and inline diff viewer.

Skip it when — No appetite for another desktop app alongside the TUI? It covers the same ground in a window — skip it and nothing is lost.

$ Pie↗

Native SwiftUI macOS client for pi --mode rpc: Pi-owned sessions, chat-side diffs, and Pi's own commands and skills.

$ Open PiCode.xcodeproj in Xcode, select the PiCode scheme with My Mac as the destination, and build and run; macOS 14 Sonoma or later and Xcode with the macOS 14 SDK are required, and pi must already be installed and on PATH

Skip it when — On Linux/Windows, or never leave the TUI? Pie is a native macOS companion — elsewhere it has nothing to add.

$ Pi for VS Code↗

VS Code extension hosting the real pi TUI in the sidebar over a pseudo-terminal — not a chat-panel reimplementation.

$ Download the VSIX from the GitHub releases page (pi-for-vscode-<version>.vsix), optionally verify it against the SHA256SUMS.txt from the same release, and run code --install-extension pi-for-vscode-*.vsix — there is no Marketplace listing

Skip it when — Not a VS Code user? It only drives pi from inside VS Code — other editors live in their own corner of the map.

$ pi-rewind-hook↗

Pi extension that records file-state rewind points so /tree navigation, fork, and resume can restore exact file snapshots alongside the conversation.

$ pi install npm:pi-rewind-hook

Skip it when — Never rewind? The hook snapshots your tree every turn for machinery you will never invoke.

$ pi-better-rewind-redo↗

Rewind files and conversation together from an earlier message, with multi-level redo and recovery from interrupted restores.

$ pi install npm:pi-better-rewind-redo

Skip it when — Stock /rewind covers your one-off undos — this pays off only when you rewind constantly and want redo back too.

$ pi-relay↗

Slash-command handoffs: the agent writes a sealed handoff, a successor session verifies it on the model you pick.

$ Install a tagged release with pi install git:github.com/jpowersdev/pi-relay@v0.1.0 and restart pi; move to a newer tag by installing it explicitly, or try the current checkout without installing it permanently with pi -e git:github.com/jpowersdev/pi-relay

Skip it when — One machine, one terminal? Relay exists to hand a session elsewhere — skip it until you actually hand off.

$ CCompactor↗

Turns finished coding-agent sessions — Pi, Claude Code, Codex — into compact, verified, provenance-linked handoff artifacts, in TypeScript.

$ npm i -g ccompactor (or standalone binaries from the GitHub releases for macOS, Linux, and Windows)

Skip it when — Sessions stay short and compaction never kicks in? The export/handoff flow is machinery you will never touch.

$ Pi MCP Adapter↗

Use MCP servers with Pi without burning your context window.

$ pi install npm:pi-mcp-adapter

Skip it when — No MCP servers to connect? The adapter is plumbing — with nothing to mount it does nothing.

$ Pi Web Access↗

Web search, content extraction, and video understanding for the Pi agent.

$ pi install npm:pi-web-access

Skip it when — Your work never needs live web facts? The search/extraction calls just add latency and tokens.

$ big-pi↗

Model-driven compression that summarizes completed phases into tiered blocks while Pi's JSONL transcript stays authoritative and untouched.

$ Installs from a local package directory: pi install /opt/big-pi after verifying the release archive (sha256sum -c big-pi-0.1.0.zip.sha256, then node verify-release.js); no third-party runtime dependencies

Skip it when — Sessions rarely near the context limit? Background compaction is idle overhead.

$ pi-rolling-compaction↗

Trigger pi's built-in compaction once context hits a configurable threshold (default 50% of the window) so large-context models get a continuously-maintained rolling summary instead of a near-full cliff-edge.

$ cp rolling-compaction.ts ~/.pi/agent/extensions/

Skip it when — Happy with pi’s built-in compaction? Rolling summary changes what the model "remembers" mid-session — skip if stock behavior works.

$ pi-experience↗

Experience-memory extension: logs raw runs to its own SQLite; the main agent merges audited history into cross-session experiences.

$ npm ci then pi -e ./src/index.ts to load once, or pi install /absolute/path/to/pi-experience as a local pi package; requires Node.js 24+ and pi 0.85.1

Skip it when — Wanting zero-maintenance auto-recall? Experience needs you to tend its sqlite memory to stay useful.

$ motus↗

Redacts exact secret values from pi tool output, blocks the commands and files that print them, and fails closed.

$ pi install npm:@espadat/motus (global, never --local), then move it to the top of packages in ~/.pi/agent/settings.json — pi install appends it last, and handlers run in load order — and create ~/.config/motus/config.toml, because without it every session starts degraded. For Claude Code: npm install --global @espadat/motus and register motus-cc-hook as a PreToolUse hook.

Skip it when — Never touch real keys inside a session (throwaway environments only)? Then there is nothing to redact.

$ pi-heed↗

Turns what you said into runtime constraints and checks every side-effecting tool call against them before it runs.

$ Run pi install git:github.com/Nyarlathoteppppp/pi-heed; rules work immediately and the extension starts in shadow mode — /heed on switches to enforce, and a Jev key via TYPESAFE_API_KEY or OPENROUTER_API_KEY unlocks the semantic layer.

Skip it when — No written rules to enforce? Heed shines when you have constraints to encode; with none it is a no-op layer.

$ pi-jev-sentinel↗

Guards pi tool calls, tool outputs, and replies with Jev-scored risk, injection checks, and secret scrubbing — never auto-allows.

$ Run pi install git:github.com/harshwasan/pi-jev-sentinel, then export TYPESAFE_API_KEY before starting pi; to try it without installing, run pi -e git:github.com/harshwasan/pi-jev-sentinel.

Skip it when — Prompts come only from you and trusted files? Sentinel guards tool-output injections you never consume.

$ pi-edit-guard↗

A repair-and-match pipeline behind the built-in edit name that fixes malformed arguments and locates off-whitespace targets.

$ pi install npm:pi-edit-guard

Skip it when — You read every diff before accepting anyway? Auto-repairing botched edits duplicates your own review loop.

$ pi-workflow↗

Named, repeatable multi-step workflows for Pi: research, code review, spec checks.

$ pi install npm:@agwab/pi-workflow

Skip it when — One agent, one task at a time? Multi-step orchestration is dead weight for solo sessions.

$ pi-tmux-orchestrator↗

Pi extension + dependency-free Python CLI for coordinating implementer, reviewer, and optional probe agents in a monitorable tmux grid with a per-run Unix-socket broker.

$ pi install npm:pi-tmux-orchestrator

Skip it when — Only ever one terminal pane? The orchestrator manages a tmux fleet — overkill for one pane.

$ pi-flows↗

Delegate work to isolated, budgeted pi sub-agents — recon, review, decomposition — with cost caps, OpenInference tracing, and contract validation.

$ pi install npm:pi-flows

Skip it when — Subagent needs are covered by a one-off spawn? Flows targets traced, budgeted fan-out pipelines.

$ pi-duo↗

Two persistent, resumable peer agents — Austin implements up front, Tony verifies behind — sharing each other's live session context.

$ Run pi install git:github.com/atfa/pi-duo, then /reload; pi -e git:github.com/atfa/pi-duo loads the extension for one session without writing the install config. Requires pi 0.85.1 or newer.

Skip it when — No appetite for two models second-guessing each other? The parallel pair adds tokens and noise around solo judgement.

$ pstack↗

A 42-skill pi package of principle skills, playbooks, and routed skills that fan work out to subagents.

$ pi install git:github.com/hieusats/pstack

Skip it when — Rather hand-pick extensions one by one? pstack is a full skills-and-subagents stack — adopting it means adopting its shape.

$ pi-arena↗

Fair, replayable tournaments for pi coding agents: same task, isolated workspaces, objective scoring, and a browser replay console.

$ Clone the repository, then run npm run demo for the deterministic three-contestant local tournament (no API key) and open arena-demo/index.html for the replay console; per SKILL_USAGE.md, pi install <path to your local clone> adds the package to pi, and /skill:arena loads the tournament protocol from skills/arena/SKILL.md inside a session.

Skip it when — Not comparing models or prompts? A benchmark harness with nothing to run is just noise.

$ pi-cache-lens↗

Status-bar chip tracking per-request and session KV cache hit rates, with background forensics attributing every drop.

$ pi install git:github.com/w31r4/pi-cache-lens, then update anytime with pi update. The chip renders through the built-in pi footer automatically; pi-powerline-footer and pi-cc-extensions have documented integration snippets in the README.

Skip it when — Bills look fine and cache hits are not a concern? Cache-lens is a microscope you have no reason to open.

$ pi-ttft↗

Footer HUD that times the first token and names the culprit — network or server — when one clearly dominates.

$ Run pi install git:github.com/quanxinwang18-a11y/pi-ttft@v1.1.0, or try it in a single session with pi -e git:github.com/quanxinwang18-a11y/pi-ttft. Requires pi 0.85.1 or newer.

Skip it when — Not chasing latency numbers? First-token timing only matters when you A/B providers.

$ pi-tool-timeout↗

Timeout overlay for foreground tools: bash and powershell default to 300s, grep and find get a wrapped deadline.

$ Run pi install git:github.com/GhabiX/pi-tool-timeout (local-path and project-local installs are documented too); targets pi 0.85.x and needs Node 22.19.0 or newer, then restart pi or run /reload

Skip it when — Tools always return fast? A timeout guard is set-and-forget you can skip until something actually hangs.