Pi vs HagiCode: Features and Comparison

HagiCode is a proposal-driven AI coding workbench that turns a request into a reviewable proposal, runs it through agent CLIs such as Claude Code, Codex and GitHub Copilot, and keeps the outcome as team knowledge.

Pi is a minimal, MIT-licensed terminal coding agent that you shape with extensions, skills and packages. HagiCode is a workbench that runs Pi as its executor and adds sessions, proposals and commit tooling around it.

Install HagiCode Desktop

English2026-10-16

Short answer

Pi is a minimal, extensible coding agent harness that runs in your terminal. It deliberately ships without sub-agents, plan mode or permission popups, and expects you to add what you need through extensions, skills and packages. HagiCode is a desktop and web workbench that launches agent CLIs such as Pi and supplies the workflow around them: parallel sessions, spec proposals, commits and history. It does not replace Pi.

If you like a small, hackable agent and prefer to build your own workflow on top of it, stay with Pi alone. Add HagiCode if you would rather have sessions, proposals and review handled by a ready-made workbench while Pi keeps doing the agent work.

Pi vs HagiCode at a glance

AspectPiHagiCode
What it is

Minimal terminal agent harness, extended through extensions, skills, prompt templates and themes

AI programming workbench that runs agent CLIs, including Pi, as executors

Interface and platforms

Interactive terminal UI, print/JSON mode, RPC, TypeScript SDK; macOS, Linux, Windows installers

Desktop app (Windows, macOS, Linux), Docker Compose container, Microsoft Store edition

Pricing and licensing

MIT-licensed and free; you pay only for the models you connect

Desktop and Container editions free; Store edition free base, optional one-time TurboEngine purchase

Model and provider access

15+ providers by API key or OAuth login; custom providers via models.json or extensions

Hosts no models; uses Pi's own sign-in, or OmniRoute routing if you configure it

Parallel work

No built-in sub-agents; add them as an extension or package

Several sessions side by side, managed as named Agents

Spec and planning workflow

No plan mode by default; add one through extensions

OpenSpec proposals: propose, validate, apply, archive

Git and commit handling

You or an extension handle commits; sessions export to HTML or a gist

AI-written commit messages with repository locking; Git management in the UI

Asking you questions

Extensions can open dialogs over RPC

Shows Pi's questions in the conversation, then continues the same run

Setup effort

One install script or npm install, then /login

Install Pi first, then HagiCode, then pick Pi as the Agent CLI

Best for

Developers who want a small agent core they can bend to their own workflow

Running several Pi tasks across repos with specs, review and history in one place

What Pi does well

A small core you can reshape

Pi's own description is "a minimal, extensible agent harness that you can make your own." Sub-agents, plan mode and permission popups are left out on purpose, so what you run is what you chose to add.

Extensions, skills, prompt templates and themes can be bundled as Pi packages and shared through npm or git.

Sessions stored as trees

A session is a tree kept in a single file. You can return to an earlier point with /tree and branch from there without losing the other branch.

Older messages are summarised automatically as the context limit approaches, and compaction can be customised through extensions. /export writes a session to HTML and /share posts it as a GitHub gist.

Four ways to drive it

Use the interactive terminal UI, print/JSON mode for scripts and event streams, an RPC protocol over stdin/stdout, or the TypeScript SDK to embed Pi in your own app.

That makes Pi easy to wrap, which is exactly how tools such as HagiCode can run it.

Broad provider support with your own accounts

Pi lists more than 15 providers, including Anthropic, OpenAI, Google, Azure, Bedrock and Ollama. Sign in with /login using a subscription or an API key, and add custom providers through models.json.

Pi has no built-in permission system and runs with your user's permissions, so its docs suggest a container when you need stronger isolation.

When to choose Pi, and when to choose HagiCode

Stay with Pi when

  • Choose Pi alone if you want a small agent core and enjoy writing extensions or skills to fit your own workflow.
  • Choose Pi alone if you work in a terminal and your tasks run one at a time.
  • Choose Pi alone if you embed an agent in your own tooling through the RPC protocol or the SDK.
  • Choose Pi alone if you already have your own spec, review and commit habits and do not want a second system.

Reach for HagiCode when

  • Choose HagiCode if you want parallel sessions without writing or installing a sub-agent extension.
  • Choose HagiCode if you want a proposal and archive step around each change that Pi does not include by default.
  • Choose HagiCode if a Pi task spans several repositories and you would rather declare them once than re-explain them each session.
  • Choose HagiCode if you prefer a graphical view of sessions and tool calls to terminal output.
  • Choose HagiCode if you move between agents and want one interface for Pi, Claude Code, Codex and others.

Using Pi together with HagiCode

HagiCode does not bundle or replace Pi. It finds the pi executable on your machine, checks its version, and starts it for each run, so your install, login and models.json stay as they are.

From its settings HagiCode can pass Pi's provider, thinking level, session directory, no-session mode and tool restrictions.

  • Install Pi (for example curl -fsSL https://pi.dev/install.sh | sh, or npm install -g --ignore-scripts @earendil-works/pi-coding-agent) and run /login.
  • Install HagiCode Desktop for Windows, macOS or Linux.
  • In HagiCode, choose Pi as the Agent CLI and pick a provider and model.
  • Open a repository and start a session or a proposal.
  • Expect Pi's output to stream into the conversation, with tool calls in the shared tool-call view.
  • To go back, run pi in your terminal as before. Your Pi packages and sessions are not locked to HagiCode.

What HagiCode adds on top of any agent

Parallel sessions and Agents management

Pi leaves sub-agents to extensions. In HagiCode every Pi run is its own session, so one can refactor while another writes tests, and Agents management shows each one's status.

OpenSpec proposals

Pi ships without plan mode, so HagiCode's propose, validate, apply, archive flow gives each Pi task a written plan and a record. Free editions allow 3 concurrent proposals.

AI commit and Code Server

HagiCode writes the commit message from your diff and locks the repository while it commits. The embedded Code Server opens files Pi changed in a browser editor.

Monospecs and Vault

Monospecs lists your repositories in one file so Pi starts a proposal knowing the whole change surface. Vault keeps reference projects and notes that new proposals can use as context.

OmniRoute, tool-call view and TokenMonitor

If you configure OmniRoute, Pi's model requests can be routed through it. Pi's tool calls use the same format as other agents. A TokenMonitor status-bar item shows today's tokens and cost; it is off by default.

Interactive questions

When Pi asks a structured question, HagiCode shows it in the conversation, the session waits for a reply, and your answer continues the same run. If the run already ended, the answer goes in as a normal message in the same session.

  • Questions asked at the same time can be answered in one submission;
  • A question unanswered after 30 minutes expires and can still be answered by a follow-up message;
  • Enabled per CLI by the interactive-control setting.

The bottom line

  • Pi is a free, MIT-licensed, deliberately minimal agent; HagiCode is a workbench that runs it and does not replace it.
  • Stay with Pi alone if you want to shape the agent yourself or use it in scripts and your own tools.
  • Add HagiCode when you want parallel sessions, proposals and commit help without building them as Pi extensions.
  • Your Pi install and login are untouched, so trying HagiCode does not commit you to anything.

Frequently asked questions

Is Pi free?

Pi is MIT-licensed and free to install. You pay only for the models you connect, through an API key or a provider subscription you sign in to with /login. See pi.dev for current details.

How do I install Pi?

On macOS or Linux run curl -fsSL https://pi.dev/install.sh | sh. On Windows run powershell -c "irm https://pi.dev/install.ps1 | iex". You can also run npm install -g --ignore-scripts @earendil-works/pi-coding-agent, which needs Node.js 22.19 or newer.

Does Pi have sub-agents or a plan mode?

Not by default. Pi skips them on purpose and lets you add them through extensions, skills or packages.

Can I use Pi with HagiCode?

Yes. HagiCode lists Pi as an Agent CLI. Install Pi and run /login, then select it in HagiCode; HagiCode starts Pi for you and leaves your Pi setup unchanged.

Does HagiCode replace Pi?

No. HagiCode is the workbench around Pi, adding sessions, proposals, commits and history. It needs Pi installed and signed in to run.

Pi vs HagiCode: which should I pick?

Pick Pi alone if you want a minimal agent you extend yourself. Add HagiCode if you want ready-made parallel sessions, proposals and history around Pi.

Desktop

Localized AI code assistant, privacy protection, enhanced efficiency