# 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 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 towards its personal changelog, and wrote a working TypeScript extension that I loaded into the stay binary.

Stipulations:

• 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 classes moderately 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 recognized for his work on libGDX, who printed a protracted, 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 provide you with restricted visibility into what the mannequin truly obtained. His response was to construct the alternative, a small core loop surrounded by extension factors, moderately than a feature-complete product with a hard and fast means of working.

The mission picked up critical 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 serious 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 high — an open-core construction that is frequent in infrastructure software program however value figuring out 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 nearly solely on doing much less. I confirmed the present launch immediately moderately 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 whole 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 towards the precise put in binary confirms this immediately; the instrument 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 consumer 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 individual AGENTS.md recordsdata — a world one for all of your classes and a project-specific one, each totally 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 price range for the precise work as an alternative of directions about tips on 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 immediately.

# Arms-On: Putting in It and Working 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. Working pi --version instantly after returned 0.80.3, confirming the set up truly labored moderately than silently failing.

Authentication has two paths. In case your supplier helps it, operating /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 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 via favorites with out typing the complete command. In keeping 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 secret is configured; operating pi --list-models with no supplier set pointed me immediately at Pi’s personal supplier and mannequin documentation moderately than failing silently.

One element value flagging for groups evaluating this significantly: Pi shops classes as timber, 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 moderately than overwritten. That is a genuinely completely different psychological mannequin from most chat-style agent interfaces, and it issues extra when you’re operating longer, extra exploratory classes the place you need to strive two completely different approaches with out dropping both one.

# Constructing a Actual Extension: A Permission Gate Plus a Customized Instrument

 
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 operating rm -rf or a pressured git push, you construct that your self, as a TypeScript extension. Here is an actual one, written towards Pi’s documented extension API after which truly 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: verify 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.verify(
          "Dangerous command",
          `Permit: ${occasion.enter.command}`
        );
        if (!okay) {
          return { block: true, motive: "Blocked by permission gate extension" };
        }
      }
    }
  });

  // A small customized instrument the mannequin can name immediately
  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().break 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 energetic",
    handler: async (_args, ctx) => {
      ctx.ui.notify("Permission gate extension is energetic.", "information");
    },
  });
}

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 accommodates one thing genuinely harmful — a recursive force-delete, a sudo escalation, or a pressured 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, motive: ... } is what truly stops the instrument name from operating; if you happen to decline, the mannequin sees the block motive and has to regulate moderately 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 every 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.

Find out how 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 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 instrument with out grievance. In a full interactive session with an actual API key, the subsequent step can 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 habits Pi’s personal docs describe because the meant sample for this sort of extension, since permission dealing with is not within the core by design and is supposed to be constructed to match your individual menace mannequin moderately than imposed uniformly on each consumer.

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 solely new slash instructions. The permission gate above is a genuinely helpful beginning extension, however it’s additionally a small pattern of a a lot bigger floor, one which Pi’s personal documentation describes in sufficient depth to construct nearly something the built-in characteristic set overlooked.

# The place the Minimalism Really Helps

 
Three issues held up below precise use moderately than simply sounding good within the pitch.

1. The session tree is the strongest one. With the ability to department a dialog at any level with /tree and check out a unique method 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 characteristic.
2. Multi-provider switching is the second. Pi’s supplier listing genuinely does span the key hosted APIs and native inference via Ollama, and switching fashions mid-session with /mannequin or 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 need to evaluate mannequin output on the identical activity with out standing up separate tooling for every supplier, that is an actual, tangible comfort.
3. The token financial savings from the minimal system immediate are the third, and the toughest to independently confirm with out operating 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 classes the place that overhead compounds throughout dozens of turns.

# The place It Prices You

 
The sincere value of minimalism is that the issues Pi does not construct in, it’s important to construct your self, or settle for going with out. In case your staff desires sub-agents coordinating on a big activity, or a plan-review step earlier than code will get written, or permission gates on each dangerous motion moderately 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 show you how to 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 staff is doing {that a} extra opinionated instrument would have shipped already.

One unbiased overview put this limitation extra bluntly than most advertising and marketing copy would permit: 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 determination lined in part 2, and it is value taking at face worth moderately than assuming it is an exaggeration.

Documentation and neighborhood help are thinner than for a longtime instrument too. Impartial protection describes Pi’s docs as strong for core options however noticeably thinner for edge instances, backed by a single firm, a Discord server, and a GitHub subject tracker moderately than the years of amassed Stack Overflow solutions {that a} extra mainstream instrument 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 moderately 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 motive to keep away from the instrument at the moment, because the free core works as described, however it’s an affordable factor to control if you happen to’re planning to rely on this long run.

# The Verdict

 
Pi is a genuinely good match if you happen to already consider carefully about what enters your mannequin’s context and need to management that intentionally moderately 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 moderately than ready for a characteristic 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 strains of TypeScript and loaded into the actual binary with no single error, which is a good sign that “you possibly can construct what’s lacking” is not only a advertising and marketing line.

It is a worse match if what you truly need is a instrument that runs unattended in a single day with smart defaults already in place, if you happen to’d moderately not learn supply code to unravel 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 authentic methods to need to work, and Pi is sincere sufficient in its personal documentation about which one it is constructed for.

# Wrapping Up

 
Essentially the most attention-grabbing factor about Pi is not any single characteristic; it is that the mission 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 immediately: 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 truly putting in it, operating 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 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 may as well discover Shittu on Twitter.