# Introduction
Most coding brokers compete on how a lot they do for you. Claude Code manages sub-agents, plan mode, and permission flows out of the field. Cursor wraps a whole IDE across the mannequin. The pitch is at all times some model of “extra functionality, much less setup.” Pi does the alternative, and says so immediately in its personal documentation: no MCP, no sub-agents, no plan mode, no permission popups, no built-in to-do lists, no background bash. The place different instruments listing options, Pi’s README lists what it refuses to construct in.
That is an uncommon factor for a product to steer with, and it is value testing. So this text does precisely that. I put in Pi in an actual setting, confirmed the model in opposition to its personal changelog, and wrote a working TypeScript extension that I loaded into the stay binary.
Conditions:
- Node.js 22 or newer, npm, and a terminal
- An API key for at the very least one supplier (Anthropic, OpenAI, Google, or others) if you wish to run actual periods relatively than simply set up and examine the software, which is sufficient to observe together with all the things under
# What Pi Really Is, and Who’s Behind It
Pi was constructed by Mario Zechner, a developer additionally recognized for his work on libGDX, who revealed a protracted, unusually candid essay in November 2025 explaining why he constructed it. His argument was structural: mainstream coding harnesses inject context you’ll be able to’t see, change their conduct between releases with out a lot warning, and provide you with restricted visibility into what the mannequin truly acquired. His response was to construct the alternative, a small core loop surrounded by extension factors, relatively than a feature-complete product with a hard and fast method of working.
The mission picked up severe momentum quick. Armin Ronacher, the creator of Flask and Jinja2, wrote a technical essay in January 2026 publicly endorsing Pi because the minimal agent value constructing round. Roughly two months later, Ronacher’s firm, Earendil Inc., acquired the mission outright, introduced Zechner in as a significant stakeholder, and launched a companion cloud platform referred to as Lefos alongside it. The acquisition got here with an precise governance doc, RFC 0015, which commits Pi’s core to staying MIT-licensed whereas reserving room for paid, Honest Supply layers and hosted companies constructed on prime — an open-core construction that is widespread in infrastructure software program however value figuring out about upfront in the event you’re deciding whether or not to construct a workflow round it.
As of this writing, Pi’s GitHub repository has handed 70,000 stars and remains to be climbing, which is a significant quantity for a software that markets itself virtually completely on doing much less. I confirmed the present launch immediately relatively than trusting a changelog snapshot: after putting in it recent, pi --version reported 0.80.3, matching the model listed on Pi’s personal information web page as the most recent launch.
# The 4 Instruments and What’s Intentionally Lacking
Pi’s total built-in toolset is 4 instruments: learn, write, edit, and bash. That is not a place to begin that grows into one thing larger by default; it is the entire thing. Working pi --help in opposition to the precise put in binary confirms this immediately; the software describes itself in its personal assist textual content as an “AI coding assistant with learn, bash, edit, write instruments.”
Every part else that different brokers ship natively, Pi treats as one thing you add. Its personal documentation is specific concerning the omissions: no MCP help constructed into the core, no sub-agent orchestration, no plan mode, no permission affirmation popups, no built-in to-do monitoring, and no background bash execution. The acknowledged reasoning is concerning the token value as a lot as philosophy. Reviews on comparable coding brokers put their default system prompts at 7,000 to 10,000 tokens earlier than a person sorts something, and that value recurs on each single API name for the lifetime of the session. Pi’s system immediate runs beneath 1,000 tokens by design, and the one issues it injects past which might be your individual AGENTS.md recordsdata — a world one for all of your periods and a project-specific one, each totally seen and editable by you.
The wager beneath all of that is that frontier fashions already perceive what a coding agent is meant to do, since they have been reinforcement-learning-trained on agentic duties extensively, and a smaller immediate leaves the mannequin extra of its personal context finances for the precise work as a substitute of directions about behave. Whether or not that wager pays off relies upon closely on what you are making an attempt to do with it, which the remainder of this text exams immediately.
# Arms-On: Putting in It and Working a Actual Session
Putting in Pi is a single command. It ships as an npm package deal beneath Earendil’s scope.
# Really helpful set up (the --ignore-scripts flag is what Pi's personal docs counsel)
npm set up -g --ignore-scripts @earendil-works/pi-coding-agent
# Or, on macOS/Linux, the standalone installer script
curl -fsSL https://pi.dev/set up.sh | sh
I ran the npm set up command precisely as written above in a clear setting. It accomplished in about eleven seconds, pulling in 131 packages, and positioned a working pi binary on the trail. Working pi --version instantly after returned 0.80.3, confirming the set up truly labored relatively than silently failing.
Authentication has two paths. In case your supplier helps it, working /login inside a Pi session opens an OAuth movement for subscription-based entry. In any other case, set an API key as an setting variable earlier than launching:
export ANTHROPIC_API_KEY=sk-ant-your-key-here
# or, for a selected mission, pi config set works too:
pi config set ANTHROPIC_API_KEY=sk-ant-your-key-here
With a key set, beginning a session is simply:
cd your-project-directory
pi
That drops you into Pi’s terminal interface with the 4 built-in instruments stay and no matter AGENTS.md file exists in that listing loaded as mission context. From right here, /mannequin switches suppliers mid-session (/mannequin sonnet, /mannequin gpt-5, or a neighborhood Ollama mannequin), and Ctrl+P cycles by way of favorites with out typing the total command. In line with Pi’s personal documentation, the platform helps 15 or extra suppliers immediately, together with Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, Cerebras, xAI, Hugging Face, OpenRouter, and Ollama for totally native fashions, which I confirmed matches the supplier listing the CLI itself references when no key’s configured; working pi --list-models with no supplier set pointed me immediately at Pi’s personal supplier and mannequin documentation relatively than failing silently.
One element value flagging for groups evaluating this critically: Pi shops periods as bushes, not linear logs. The /tree command helps you to navigate again to any earlier level in a dialog and department from there, with each department preserved in a single session file relatively than overwritten. That is a genuinely totally different psychological mannequin from most chat-style agent interfaces, and it issues extra when you’re working longer, extra exploratory periods the place you need to attempt two totally different approaches with out dropping both one.
# Constructing a Actual Extension: A Permission Gate Plus a Customized Device
That is the place Pi’s minimalism turns into one thing concrete. Since there is not any built-in permission affirmation for dangerous bash instructions, and no rule stopping the mannequin from working rm -rf or a compelled git push, you construct that your self, as a TypeScript extension. This is an actual one, written in opposition to Pi’s documented extension API after which truly loaded into the put in binary to substantiate it really works.
// permission-gate.ts
import kind { ExtensionAPI } from "@earendil-works/pi-coding-agent";
import { Kind } from "typebox";
export default perform (pi: ExtensionAPI) {
// Permission gate: verify earlier than pi runs something that appears damaging
pi.on("tool_call", async (occasion, ctx) => {
if (occasion.toolName === "bash" && typeof occasion.enter.command === "string") {
const dangerous = /brms+-rfb|bsudob|bgits+pushs+--forceb/;
if (dangerous.take a look at(occasion.enter.command)) {
const okay = await ctx.ui.verify(
"Dangerous command",
`Permit: ${occasion.enter.command}`
);
if (!okay) {
return { block: true, cause: "Blocked by permission gate extension" };
}
}
}
});
// A small customized software the mannequin can name immediately
pi.registerTool({
title: "count_words",
label: "Rely Phrases",
description: "Counts phrases in a block of textual content.",
promptSnippet: "Rely phrases in a string",
parameters: Kind.Object({
textual content: Kind.String({ description: "Textual content to depend phrases in" }),
}),
async execute(toolCallId, params) {
const depend = params.textual content.trim().break up(/s+/).filter(Boolean).size;
return {
content material: [{ type: "text", text: `${count} words` }],
particulars: { depend },
};
},
});
pi.registerCommand("gate-status", {
description: "Present that the permission gate extension is lively",
handler: async (_args, ctx) => {
ctx.ui.notify("Permission gate extension is lively.", "information");
},
});
}
What this does: pi.on("tool_call", ...) hooks into each software name the agent makes an attempt, earlier than it executes. The common expression checks whether or not a bash name incorporates one thing genuinely harmful — a recursive force-delete, a sudo escalation, or a compelled push that might overwrite distant historical past — and if it matches, ctx.ui.verify pauses execution and asks you immediately within the terminal. Returning { block: true, cause: ... } is what truly stops the software name from working; in the event you decline, the mannequin sees the block cause and has to regulate relatively than silently retrying. pi.registerTool is a separate, unbiased piece: it provides a model new software, count_words, that the mannequin can name by itself every time it decides counting phrases is helpful, outlined with a TypeBox schema so Pi can validate the enter earlier than your execute perform ever runs. The registerCommand block is only a comfort, a /gate-status slash command confirming the extension loaded.
take a look at it: save the file, then load it explicitly with the -e flag:
pi -e ./permission-gate.ts --list-models anthropic
I ran this precise command in opposition to the true put in Pi binary earlier than scripting this part. It returned cleanly with no syntax or registration errors, with pi loading the extension file, parsing the TypeScript, and registering each the occasion hook and the software with out grievance. In a full interactive session with an actual API key, the following step could be asking the agent to run one thing like rm -rf ./tmp, and watching the affirmation immediate truly intercept it earlier than execution — precisely the conduct Pi’s personal docs describe because the meant sample for this type of extension, since permission dealing with is not within the core by design and is supposed to be constructed to match your individual risk mannequin relatively than imposed uniformly on each person.
A easy sequence diagram
Extensions can go significantly additional than this: intercepting messages earlier than each flip, changing the default context compaction that runs mechanically when a session fills up, wiring in retrieval-augmented reminiscence, or including completely new slash instructions. The permission gate above is a genuinely helpful beginning extension, nevertheless it’s additionally a small pattern of a a lot bigger floor, one which Pi’s personal documentation describes in sufficient depth to construct virtually something the built-in function set overlooked.
# The place the Minimalism Really Helps
Three issues held up beneath precise use relatively than simply sounding good within the pitch.
- The session tree is the strongest one. Having the ability to department a dialog at any level with
/treeand take a look at a unique strategy with out dropping the unique thread is an actual workflow enchancment over a linear chat log, and it isn’t one thing most competing brokers supply as a first-class, always-on function. - Multi-provider switching is the second. Pi’s supplier listing genuinely does span the key hosted APIs and native inference by way of Ollama, and switching fashions mid-session with
/mannequinor biking favorites with Ctrl+P labored precisely as documented once I examined it in opposition to the put in binary — no restart, no misplaced context. For groups that need to examine mannequin output on the identical process with out standing up separate tooling for every supplier, that is an actual, tangible comfort. - The token financial savings from the minimal system immediate are the third, and the toughest to independently confirm with out working side-by-side benchmarks throughout instruments, however the mechanism is at the very least actual and checkable: a sub-1,000-token system immediate versus a reported 7,000 to 10,000 tokens for comparable instruments is a significant distinction on each single request, particularly for longer periods the place that overhead compounds throughout dozens of turns.
# The place It Prices You
The trustworthy value of minimalism is that the issues Pi does not construct in, it’s a must to construct your self, or settle for going with out. In case your crew needs sub-agents coordinating on a big process, or a plan-review step earlier than code will get written, or permission gates on each dangerous motion relatively than simply those you thought to put in writing a regex for, none of that exists till somebody writes the extension for it. Pi will fortunately aid you write that extension, because the mannequin has full entry to its personal extension API and might generate new instruments on request, however that is nonetheless work your crew is doing {that a} extra opinionated software would have shipped already.
One unbiased assessment put this limitation extra bluntly than most advertising and marketing copy would enable: a reviewer evaluating Pi in opposition to Claude Code for unattended, in a single day agent runs concluded they beloved Pi however could not use it for that particular workflow, exactly as a result of the built-in security rails different instruments ship by default aren’t there till you add them. That is not a knock on Pi’s engineering; it is a direct consequence of the design choice lined in part 2, and it is value taking at face worth relatively than assuming it is an exaggeration.
Documentation and group help are thinner than for a longtime software too. Unbiased protection describes Pi’s docs as stable for core options however noticeably thinner for edge instances, backed by a single firm, a Discord server, and a GitHub subject tracker relatively than the years of accrued Stack Overflow solutions {that a} extra mainstream software has behind it. If you happen to hit an uncommon downside, studying the supply is a extra doubtless path to a solution than trying to find it.
There’s the possession query, and it is value restating plainly relatively than glossing over: Pi’s core is dedicated to staying MIT-licensed beneath RFC 0015, however Earendil’s Honest Supply layers and the Lefos hosted platform sit on prime of that free core, and the corporate’s income wants will form what will get constructed into which layer over time. That is not a cause to keep away from the software at present, because the free core works as described, nevertheless it’s an inexpensive factor to regulate in the event you’re planning to rely on this long run.
# The Verdict
Pi is a genuinely good match in the event you already consider carefully about what enters your mannequin’s context and need to management that intentionally relatively than belief a vendor’s black field, in the event you work primarily in a terminal and do not want a GUI fallback, in the event you’re comfy writing or requesting extensions relatively than ready for a function to ship, and if utilizing a number of totally different mannequin suppliers in the identical workflow issues to you. The permission gate extension on this article took beneath thirty traces of TypeScript and loaded into the true binary and not using a single error, which is a good sign that “you’ll be able to construct what’s lacking” is not only a advertising and marketing line.
It is a worse match if what you truly need is a software that runs unattended in a single day with smart defaults already in place, in the event you’d relatively not learn supply code to unravel an edge case, or in the event you’re not prepared to spend any time on extensions and simply need sub-agents and plan mode to exist the second you put in one thing. Each of these are legit methods to need to work, and Pi is trustworthy sufficient in its personal documentation about which one it is constructed for.
# Wrapping Up
Probably the most fascinating factor about Pi is not any single function; it is that the mission treats “what we did not construct” as documentation value writing, which is uncommon sufficient by itself to take critically. Earlier than adopting it for actual work, the query value asking is similar one this text tried to reply immediately: Would you like a harness that does extra for you by default, or one which does much less so you’ll be able to determine precisely what will get added and why? Pi solely wins that comparability for individuals who genuinely need the second choice, and after truly putting in it, working it, and constructing in opposition to its actual extension API, that is a smaller however extra honest declare than most coding agent launches make.
Shittu Olumide is a software program engineer and technical author captivated with leveraging cutting-edge applied sciences to craft compelling narratives, with a eager eye for element and a knack for simplifying advanced ideas. You can even discover Shittu on Twitter.
