# 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 complete IDE across the mannequin. The pitch is all the time some model of “extra functionality, much less setup.” Pi does the alternative, and says so straight 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 guide with, and it is value testing. So this text does precisely that. I put in Pi in an actual setting, confirmed the model towards its personal changelog, and wrote a working TypeScript extension that I loaded into the reside binary.
Conditions:
- Node.js 22 or newer, npm, and a terminal
- An API key for no less than one supplier (Anthropic, OpenAI, Google, or others) if you wish to run actual periods slightly than simply set up and examine the instrument, which is sufficient to observe together with all the things beneath
# What Pi Really Is, and Who’s Behind It
Pi was constructed by Mario Zechner, a developer additionally identified for his work on libGDX, who revealed an extended, unusually candid essay in November 2025 explaining why he constructed it. His argument was structural: mainstream coding harnesses inject context you possibly can’t see, change their habits between releases with out a lot warning, and offer you restricted visibility into what the mannequin really acquired. His response was to construct the alternative, a small core loop surrounded by extension factors, slightly than a feature-complete product with a hard and fast approach of working.
The venture 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 venture outright, introduced Zechner in as a significant stakeholder, and launched a companion cloud platform known 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 high — an open-core construction that is frequent in infrastructure software program however value understanding about upfront if you happen to’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 instrument that markets itself virtually totally on doing much less. I confirmed the present launch straight slightly 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 newest launch.
# The 4 Instruments and What’s Intentionally Lacking
Pi’s complete built-in toolset is 4 instruments: learn, write, edit, and bash. That is not a place to begin that grows into one thing greater by default; it is the entire thing. Operating pi --help towards the precise put in binary confirms this straight; the instrument describes itself in its personal assist textual content as an “AI coding assistant with learn, bash, edit, write instruments.”
The whole lot else that different brokers ship natively, Pi treats as one thing you add. Its personal documentation is specific in regards to the omissions: no MCP assist 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 said reasoning is in regards to 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 below 1,000 tokens by design, and the one issues it injects past which can be your personal AGENTS.md recordsdata — a worldwide one for all of your periods and a project-specific one, each absolutely seen and editable by you.
The guess 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 funds for the precise work as a substitute of directions about find out how to behave. Whether or not that guess pays off relies upon closely on what you are making an attempt to do with it, which the remainder of this text exams straight.
# Fingers-On: Putting in It and Operating a Actual Session
Putting in Pi is a single command. It ships as an npm bundle below Earendil’s scope.
# Really useful 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. Operating pi --version instantly after returned 0.80.3, confirming the set up really labored slightly than silently failing.
Authentication has two paths. In case your supplier helps it, working /login inside a Pi session opens an OAuth stream 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 particular venture, 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 reside and no matter AGENTS.md file exists in that listing loaded as venture context. From right here, /mannequin switches suppliers mid-session (/mannequin sonnet, /mannequin gpt-5, or a neighborhood Ollama mannequin), and Ctrl+P cycles by favorites with out typing the total command. In accordance with Pi’s personal documentation, the platform helps 15 or extra suppliers straight, together with Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, Cerebras, xAI, Hugging Face, OpenRouter, and Ollama for absolutely native fashions, which I confirmed matches the supplier listing the CLI itself references when no secret is configured; working pi --list-models with no supplier set pointed me straight at Pi’s personal supplier and mannequin documentation slightly than failing silently.
One element value flagging for groups evaluating this significantly: Pi shops periods as timber, not linear logs. The /tree command allows you to navigate again to any earlier level in a dialog and department from there, with each department preserved in a single session file slightly than overwritten. That is a genuinely completely different psychological mannequin from most chat-style agent interfaces, and it issues extra when you’re working longer, extra exploratory periods the place you wish to strive two completely different approaches with out shedding 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 no 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 towards Pi’s documented extension API after which really loaded into the put in binary to substantiate it really works.
// permission-gate.ts
import sort { ExtensionAPI } from "@earendil-works/pi-coding-agent";
import { Kind } from "typebox";
export default operate (pi: ExtensionAPI) {
// Permission gate: affirm earlier than pi runs something that appears harmful
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.check(occasion.enter.command)) {
const okay = await ctx.ui.affirm(
"Dangerous command",
`Permit: ${occasion.enter.command}`
);
if (!okay) {
return { block: true, purpose: "Blocked by permission gate extension" };
}
}
}
});
// A small customized instrument the mannequin can name straight
pi.registerTool({
identify: "count_words",
label: "Depend Phrases",
description: "Counts phrases in a block of textual content.",
promptSnippet: "Depend phrases in a string",
parameters: Kind.Object({
textual content: Kind.String({ description: "Textual content to rely phrases in" }),
}),
async execute(toolCallId, params) {
const rely = params.textual content.trim().cut up(/s+/).filter(Boolean).size;
return {
content material: [{ type: "text", text: `${count} words` }],
particulars: { rely },
};
},
});
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.", "data");
},
});
}
What this does: pi.on("tool_call", ...) hooks into each instrument name the agent makes an attempt, earlier than it executes. The common expression checks whether or not a bash name comprises one thing genuinely harmful — a recursive force-delete, a sudo escalation, or a compelled push that would overwrite distant historical past — and if it matches, ctx.ui.affirm pauses execution and asks you straight within the terminal. Returning { block: true, purpose: ... } is what really stops the instrument name from working; if you happen to decline, the mannequin sees the block purpose and has to regulate slightly than silently retrying. pi.registerTool is a separate, unbiased piece: it provides a model new instrument, count_words, that the mannequin can name by itself each time it decides counting phrases is helpful, outlined with a TypeBox schema so Pi can validate the enter earlier than your execute operate ever runs. The registerCommand block is only a comfort, a /gate-status slash command confirming the extension loaded.
Methods to check 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 towards the actual put in Pi binary earlier than penning 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 instrument with out grievance. In a full interactive session with an actual API key, the subsequent step could be asking the agent to run one thing like rm -rf ./tmp, and watching the affirmation immediate really intercept it earlier than execution — precisely the habits 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 personal risk mannequin slightly 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 totally 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 unnoticed.
# The place the Minimalism Really Helps
Three issues held up below precise use slightly 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 shedding 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 Ollama, and switching fashions mid-session with
/mannequinor biking favorites with Ctrl+P labored precisely as documented after I examined it towards the put in binary — no restart, no misplaced context. For groups that wish to evaluate mannequin output on the identical job 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 no less than 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 would not construct in, it’s important to construct your self, or settle for going with out. In case your staff needs sub-agents coordinating on a big job, or a plan-review step earlier than code will get written, or permission gates on each dangerous motion slightly than simply those you thought to jot down a regex for, none of that exists till somebody writes the extension for it. Pi will fortunately allow you to write that extension, for the reason that mannequin has full entry to its personal extension API and may generate new instruments on request, however that is nonetheless work your staff is doing {that a} extra opinionated instrument would have shipped already.
One unbiased evaluate put this limitation extra bluntly than most advertising copy would enable: a reviewer evaluating Pi towards Claude Code for unattended, in a single day agent runs concluded they cherished 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 resolution coated in part 2, and it is value taking at face worth slightly than assuming it is an exaggeration.
Documentation and neighborhood assist are thinner than for a longtime instrument 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 situation tracker slightly than the years of accrued Stack Overflow solutions {that a} extra mainstream instrument has behind it. Should you hit an uncommon downside, studying the supply is a extra probably path to a solution than looking for it.
There’s the possession query, and it is value restating plainly slightly than glossing over: Pi’s core is dedicated to staying MIT-licensed below RFC 0015, however Earendil’s Honest Supply layers and the Lefos hosted platform sit on high 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 purpose to keep away from the instrument at present, for the reason that free core works as described, nevertheless it’s an inexpensive factor to regulate if you happen to’re planning to rely upon this long run.
# The Verdict
Pi is a genuinely good match if you happen to already think twice about what enters your mannequin’s context and wish to management that intentionally slightly than belief a vendor’s black field, if you happen to work primarily in a terminal and do not want a GUI fallback, if you happen to’re snug writing or requesting extensions slightly than ready for a function to ship, and if utilizing a number of completely different mannequin suppliers in the identical workflow issues to you. The permission gate extension on this article took below thirty traces of TypeScript and loaded into the actual binary with out a single error, which is a good sign that “you possibly can construct what’s lacking” is not only a advertising line.
It is a worse match if what you really need is a instrument that runs unattended in a single day with wise defaults already in place, if you happen to’d slightly not learn supply code to resolve an edge case, or if you happen to’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 wish to work, and Pi is trustworthy sufficient in its personal documentation about which one it is constructed for.
# Wrapping Up
Essentially the most fascinating factor about Pi is not any single function; it is that the venture treats “what we did not construct” as documentation value writing, which is uncommon sufficient by itself to take significantly. Earlier than adopting it for actual work, the query value asking is identical one this text tried to reply straight: Would you like a harness that does extra for you by default, or one which does much less so you possibly can determine precisely what will get added and why? Pi solely wins that comparability for individuals who genuinely need the second choice, and after really putting in it, working it, and constructing towards 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 keen about 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.
