mrkeyoor.com_
Tue 11 Aug 13:28 UTC
LLM Toolsevaluationupdated 11 Aug 2026

pi

Pi is a terminal coding agent and a TypeScript toolkit for building agents, connecting to many model providers, rendering terminal interfaces, and embedding agent sessions in other programs. It solves the lock-in and customization problems of single-provider coding assistants by keeping the core small and moving specialized workflows into extensions, skills, prompts, and packages.

earendil-works/pi · ★ 87,343 · TypeScript · v0.84.1 · reviewed by Keyoor

Verdict

Pi is an excellent choice for developers who see a coding agent as a programmable workbench rather than a finished appliance. Its provider coverage, session model, extension API, skills support, and SDK are unusually deep, while the one-command start stays approachable. Choose it only if you agree with its bring-your-own-safety philosophy; otherwise a tool with native approvals and sandboxing is the better default.

Setup4/5One npm install and login, with isolation left to the operator
Docs5/5Extensive guides for users, extension authors, and SDK integrators
Community5/5Large adoption, daily issue work, and an exceptionally fast release pace
Maturity4/5Highly capable, but v0 releases and active interface regressions remain

Who it’s for

Developers who want one terminal agent across Claude, ChatGPT Codex, Gemini, Copilot, API-key services, and local llama.cpp models.
TypeScript teams building custom coding-agent tools, interfaces, provider adapters, or embedded agent workflows.
Power users who prefer a minimal core and are comfortable assembling extensions, skills, themes, and prompts.
Organizations prepared to run the agent inside their own container, VM, micro-VM, or policy-controlled sandbox.

Who it’s NOT for

Anyone who requires built-in command approval or filesystem, network, process, and credential restrictions: the README explicitly says Pi runs with the launching user's permissions and has no built-in permission system.
Users expecting MCP, sub-agents, plan mode, background shell jobs, or built-in task lists out of the box: Pi's philosophy explicitly omits all of them and points to extensions, packages, files, or tmux instead.
Windows teams needing one settled native shell workflow: the maintainers' Windows discussion lists ongoing Git Bash, WSL, PowerShell, path, keybinding, and shell-selection tradeoffs.
Integrators who cannot absorb fast-moving RPC behavior: version 0.84.1 has an open regression where mid-turn usage disappeared from JSON and RPC update events.
Operators who prohibit unapproved startup calls: Pi checks its website for updates and sends an install or update version ping by default unless the documented offline or opt-out settings are applied.

Setup reality

The normal start is genuinely quick: install the scoped npm package globally with lifecycle scripts disabled, run pi, then sign in to a supported subscription or provide an API key. The first useful session needs no extension because read, write, edit, and shell tools are built in. Safe use takes more work than startup: use Git for rollback, decide whether the project is trusted, review any package code, and place untrusted work in an operating-system-level sandbox. Windows users should also test their exact Node, terminal, shell, WSL, and authentication combination because current reports show real platform-specific failures.

A coding agent for people who want to shape the agent

Pi starts as a capable terminal coding assistant. Install one npm package, authenticate with a subscription or API key, and the selected model receives four tools: read, write, edit, and bash. The interface adds file search, image pasting, shell commands, model switching, session resume, branching, context compaction, cost display, and message steering while a task is running. That is enough to use Pi without writing a line of extension code.

The bigger product is the toolkit underneath. The monorepo includes a multi-provider model API, agent runtime, coding-agent CLI, terminal UI library, and telemetry contracts. The coding agent also runs in print, JSON, RPC, and SDK modes. Teams can embed a session in a TypeScript program or control the CLI over line-delimited JSON from another language. Pi is therefore both a usable tool and a box of agent parts.

Its MIT license and provider neutrality are compelling. Built-in authentication covers Claude, ChatGPT Codex, and GitHub Copilot subscriptions, while the documented API-key list spans major labs, gateways, cloud platforms, and regional services. A llama.cpp router path supports local models. Switching providers does not require abandoning the same terminal workflow or session machinery.

Minimal does not mean inflexible

Pi's default feature set is deliberately smaller than many competitors. Reusable Markdown prompts become slash commands. Agent Skills load specialized instructions only when needed and can be shared with Claude Code or Codex skill directories. TypeScript extensions can register tools, commands, keybindings, event handlers, providers, permission gates, user-interface components, and custom compaction. Pi packages bundle extensions, skills, prompts, and themes through npm or Git.

That design is Pi's strongest advantage. A team can add its deploy command, issue tracker, review workflow, or internal model gateway without maintaining a fork. Sessions are stored as JSONL trees, so users can jump to an earlier point, branch in place, fork into another file, export work, or resume later. Automatic compaction is lossy, but the full session history stays on disk for inspection.

The project also pays attention to supply-chain details. Direct dependencies are pinned, the CLI ships a shrinkwrap for transitive packages, normal installation disables lifecycle scripts, and release checks exercise isolated installs. Project trust prevents local settings and executable extensions from loading silently before approval. Those are useful protections around a system designed to execute code.

The missing safety layer is intentional

Project trust is not a command sandbox. Once running, Pi's built-in tools have the permissions of the user account, and extensions execute as ordinary TypeScript with the same access. There are no default permission popups before a shell command, file edit, network request, or credential access. The security guide is unusually direct about this boundary and recommends containers, virtual machines, micro-VMs, or policy-controlled sandboxes for untrusted and unattended work.

That honesty is preferable to a weak safety switch, but it shifts meaningful responsibility to the operator. Use a clean Git worktree, limit mounted directories, pass only required credentials, restrict network access where practical, and review changes before moving them back into a trusted environment. Third-party packages deserve code review because their extensions have full system access and their skills can tell a model to run executables.

The same philosophy explains other omissions. Pi has no built-in MCP client, sub-agent system, plan mode, background bash manager, or task list. Extensions can add MCP or sub-agents, files can hold plans and tasks, and tmux can manage long-running commands. This is liberating if you dislike somebody else's workflow assumptions. It is frustrating if you expected these common features to be installed, supported, and secured by the core team.

Setup is quick, customization has a real cost

The supported npm command includes --ignore-scripts, after which /login can connect an eligible subscription or store an API key. Four useful tools are immediately available, and AGENTS.md or CLAUDE.md can provide repository instructions. The global and project settings split is clear, while project trust defaults to asking in interactive mode.

Going beyond that baseline means learning several concepts: extensions for code, skills for on-demand procedures, prompts for reusable requests, themes for appearance, and packages for distribution. The documentation is excellent, but choice itself creates work. A third-party package may solve a missing feature, yet it also expands the trusted code base. Pin versions and treat package updates like dependency changes.

Platform behavior deserves a trial. An open Windows discussion documents unsettled choices among Git Bash, PowerShell, and WSL, along with path and keybinding problems. A separate report says subscription login can still fail in WSL on version 0.84.1. Another current issue reports startup crashes for some Bun-based installations, with Node version changes suggested as a workaround. Linux and macOS are not trouble-free either: a report tracks high CPU use in a large Mac session.

Fast development, with fast-moving edges

Pi was pushed on August 11, 2026, the same day issues and pull requests were actively opened, discussed, fixed, and closed. Release 0.84.1 arrived on August 7, one day after 0.84.0. The previous month included many releases and patches. The repository showed 111 open issues and pull requests, a substantial but actively worked queue.

That pace delivers provider updates and interface improvements quickly, but integrators should pin versions. Version 0.84.1 still has an open JSON and RPC regression where usage data is missing during streaming updates, and recent release notes include fixes for Bun startup, extension recursion, and session reset behavior. Extension and RPC authors should expect movement even when the interactive experience feels polished.

Pi is easy to recommend to advanced users who want model choice and deep customization. It is harder to recommend as an unmanaged company default. Establish isolation, package review, version pinning, and upgrade tests first. With those boundaries in place, Pi offers one of the most adaptable open coding-agent foundations available.

Alternatives

ProjectWhat it isPick it when
CodexOpenAI's terminal coding agent with a more integrated permissions and sandboxing model.pick this instead when you want a guided, security-bounded agent centered on OpenAI models rather than building your own Pi configuration.
Claude CodeAnthropic's polished terminal agent built around Claude and its native workflows.pick this instead when Claude is your standard model and first-party workflow integration matters more than provider portability.
OpenCodeAn open-source coding agent with terminal and application interfaces and broad model support.pick this instead when you want a more product-shaped multi-provider agent without treating extensions as the primary design surface.
AiderA mature terminal pair programmer centered on editing code and working with Git.pick this instead when focused repository editing and an established Git workflow matter more than an agent framework and custom TUI.

What people are saying

  1. [github-trending] earendil-works/pi
  2. [hackernews] Sonic Pi v5
  3. [github-trending] can1357/oh-my-pi
  4. [hackernews] Pi's Minimalism Is Its Advantage

Sources

  1. Pi repository and project overview
  2. Pi coding agent documentation
  3. Pi security guide
  4. Pi v0.84.1 release notes
  5. Pi Windows support discussion
  6. Pi v0.84.1 JSON and RPC usage regression
  7. Pi WSL subscription login report