fx vs pi: Is Minimal the New Big for Agentic CLIs?

Official Sources#

Every load-bearing claim below traces to these pages. Star counts, versions, and sizes were pulled on August 23, 2026 unless stated otherwise.

Last updated: August 23, 2026

The Wave Has Receipts#

Something odd happened over the last twelve months of agentic CLIs: while every vendor raced to ship more product, the projects that caught fire were the ones refusing to ship anything at all.

The numbers first, all checked August 23, 2026. pi, Mario Zechner's TypeScript agent harness, sits at 95,881 stars under the MIT license, with the latest release tagged v0.84.2 on August 14. Its launch thread hit 608 points on February 24, and a follow-up essay titled "Pi's Minimalism Is Its Advantage" pulled another 551 points on August 4. Even Zechner's design rationale post earned its own 421-point discussion. On April 8, Earendil, the company founded by Armin Ronacher, acquired the project outright, with Zechner keeping technical direction and the core staying MIT (his account).

fx is the newborn: repository created August 11, 2026, first discussed on Hacker News on August 18 where it reached 313 points inside five days, and already at version v0.0.5 as of August 21. It has 2,226 stars, Apache-2.0 licensing, and a Zig codebase. Against those two stands the incumbent pole: Anthropic's claude-code repository at 142,749 stars with no license file at all, which tells you everything about how much of it is product versus open source.

The interesting question is not whether small agents are popular. It is whether "small" means one thing or two, because the two most-cited minimal kits turn out to be minimizing opposite things.

Two Kinds of Minimal#

Read the READMEs closely and pi and fx barely overlap on what they refuse.

pi minimizes features#

The philosophy section of pi's coding-agent README reads like a dare. No MCP, because CLI tools with READMEs cover the ground, and an extension can add MCP if you disagree. No sub-agents: spawn pi instances via tmux, or build your own with extensions. No permission popups: run in a container, or build your own confirmation flow. No plan mode: write plans to files. No built-in to-dos, in the README's own words, because "They confuse models." No background bash: use tmux, which gives full observability and direct interaction. The root README adds a seventh refusal: pi has no built-in permission system for restricting filesystem, process, network, or credential access, and points you at containerization instead.

Out of the box the model gets exactly four tools, read, write, edit, and bash, with three more built-ins (grep, find, ls) one flag away. Everything else is deliberately your job, done through TypeScript extensions, skills, prompt templates, themes, and npm or git packages. The extension docs are candid about the escape hatch: extensions can add sub-agents, plan mode, MCP integration, even, quoting the README, "Make pi look like Claude Code." What pi refuses to do is pick those answers for you.

What it does pick, it picks well. Four run modes ship natively: interactive TUI, print or JSON output, RPC over stdio, and an SDK. Sessions are JSONL trees where /tree, /fork, and /clone navigate and branch history in place. Subscription auth reuse covers Anthropic Pro/Max, ChatGPT Plus/Pro via Codex, and GitHub Copilot.

fx minimizes footprint while embracing features#

fx makes the opposite trade. It wants the feature set, just not the megabytes. The tools table counts 26 built-in tools before any MCP server contributes its own: eleven file operations, lexical semantic search, command execution with background processes, web search and fetch, vision, skills installation, and a subagent tool. Yes, MCP is built in. Yes, subagents are built in, as session-backed children with one-off and persistent modes, a ctrl+x manager UI, durable identities so retries are safe, and an explicit rule that model-created children cannot elevate their own authority.

The compression is the pitch. The README claims a 7.8 MiB binary written in Zig; the documentation index still advertises roughly 6 MB with a 10-microsecond cold start and no unnecessary I/O before accepting input. More convincing than either marketing number: CONTRIBUTING.md documents a benchmark workflow that runs hyperfine on every pull request across six command paths, each with a 2 ms wall-clock budget on Linux, and fails CI if any path exceeds it. Latency is not an aspiration here, it is a merge gate.

The auth story follows the same local-first instinct: three routes, with Vercel AI Gateway as default, plus Codex OAuth and Grok OAuth whose tokens are stored privately at ~/.fx/chatgpt-auth.json and ~/.fx/grok-auth.json and, per the README, never sent to the gateway.

The distinction matters#

So the honest taxonomy is this: pi is philosophically minimal, refusing features to keep the core a neutral substrate for your workflow. fx is physically minimal, embracing features while compressing the runtime to something you can compile into someone else's program. One refuses to decide for you. The other refuses to slow you down. Calling both "minimal agents" flattens a real disagreement about which kind of weight actually hurts.

The Spectrum: From Platform to Shell#

Place every option on one axis, distance from finished product toward raw component, using documented capability only:

Two placements deserve defense. First, fx sits below pi despite shipping more features, because the axis is how much product you adopt versus how much you compose or embed: fx is explicitly built, per its own README, to be embedded "as part of larger systems," while pi expects to be your working environment. Second, Claude Code tops the scale not because it lacks extensibility but because its extensibility is layered onto a finished product: the quickstart assumes a subscription login and a prompt, not a build step.

The Evidence for the Small End#

The strongest argument for minimal kits is arithmetic, and one Hacker News commenter did it better than most marketing copy. Running hierarchical review fleets of, quoting the comment, "50-100 on a regular basis," the difference between a 6 MB and 250 MB harness is, in his words, "can do" versus "cannot" (messh). At fifty concurrent agents, footprint stops being a vanity stat.

The second argument is architectural. rsyring cut through a thread full of "why another agent" fatigue by quoting fx's actual differentiators: a Zig harness optimized for research and embeddability, closer to a Unix shell than an IDE-in-the-terminal. fazxes sharpened it: fx is not primarily another coding agent, it is a tiny embeddable harness and infrastructure component that happens to have a good CLI. That is a category Claude Code does not occupy, and the WASM SDK running interactively in a browser at fx.sh/try demonstrates it rather than promising it.

pi's evidence is different in kind: longevity and stewardship. A year of releases to v0.84.2, a supply-chain hardening section treating npm dependency changes as reviewed code changes, JSONL session trees that treat branching as a first-class operation, and an acquisition whose stated licensing commitment is that the core stays MIT. The community metaphor writes itself; one commenter put it as "Codex, Claude Code are VS Code, Jetbrain. Pi is Neovim" (azuanrb), and others noted pi already has LazyVim-style distributions forming around it. Neovim, it is worth remembering, did not lose that argument.

The Case Against#

Now steelman the other side, because the objections have teeth.

The sharpest critique came from inside the minimal camp's own framing: impulser_ called fx out for shipping 26 tools with a tool for nearly every file operation and concluded "You should have significantly less tools today with how good LLMs have become," ending with "Just use Pi." If tool-count minimalism is the metric, fx loses to pi by design. fx's bet is that per-tool latency budgets and a bounded system prompt matter more than tool count, which is testable but unproven.

Sustainability doubt targets fx specifically. rvz asked whether this becomes another abandoned labs experiment, and the thread had receipts on the other side too: one builder compiled from source and got a 144 MB debug binary, 44 MB stripped, nowhere near the headline number, a reminder that release-build claims deserve audits. Others bounced off the onboarding: no generic OpenAI-compatible endpoint visible in five minutes, a required Vercel account for the default route, a credit card concern, and no Claude subscription sign-in at all. Several of those threads remain unresolved in the docs as of August 23.

And the platform pole has a real answer, straight from official docs: product depth buys things minimal kits cannot. An auto permission mode where a classifier reviews actions instead of you. The same assistant in your terminal, IDE, browser, Slack, and CI. Corporate SSO, cloud-provider routes through Bedrock, Google Cloud, and Microsoft Foundry, and organization-managed settings. None of that is glamour; all of it is what procurement and security reviews ask for first. A median team does not want to assemble a harness, it wants Tuesday's ticket closed, and Claude Code charges assembly time to itself rather than to the user.

There is also convergence pressure eating the debate from both ends. pi's extension API can rebuild every feature it refuses. fx already includes the features purists mock. Claude Code exposes headless modes and SDK hooks of its own. When every pole grows toward the others, "minimal" risks becoming a marketing adjective rather than an architecture.

Falsification Signals: How This Wave Could Die#

An honest thesis names its own kill conditions. Watch for these:

1. The fx stall pattern. Version cadence collapses after the v0.0.x honeymoon, or the repo goes quiet the way abandoned labs projects do. Leading indicator worth tracking monthly: the README's own binary figure, which moved from 6.39 MiB quoted at launch on August 18 to 7.8 MiB by August 23. Feature growth will push it up forever; the question is whether capability grows faster than bytes.
2. The DIY tax exceeds the subscription. pi is free until you price the engineer-hours spent writing extensions for plan mode, permissions, and MCP that Claude Code bundles. If median teams spend more assembling pi than subscribing to the platform, minimalism priced itself out. A proliferation of mandatory oh-my-pi-style distributions would be the tell that the core was not enough.
3. Embeddability finds no buyers. The WASM SDK stays marked experimental through mid-2027, ACP integrations remain niche editor experiments, and no named production products ship fx inside them. Then "infrastructure component" was a vibe, not a market.
4. Enterprise has no minimal answer. Compliance regimes want audit trails, permission policies, and centralized settings. pi refuses permission popups by design; if no container-based pattern becomes standard practice, regulated teams simply cannot buy what minimal sells, and the ceiling of the wave is the prosumer tier.
5. Footprint stops mattering. If model pricing and speed improve to where harness overhead is rounding error even at fleet scale, the 2 ms merge gates and 7.8 MiB binaries stop being moats and become trivia.

Flip side signals would confirm the thesis: enterprises standardizing on pi or fx in CI fleets, production products shipping embedded agents on the fx SDK, and Claude Code's own users gravitating to its most stripped-down invocation patterns.

Verdicts by Profile#

• Building a product with an agent inside (browser demos, sandboxed CI, SaaS features): fx. The WASM SDK, ACP server, and enforced latency budgets have no equivalent anywhere near this size. You are accepting v0.0.x volatility as the entry fee.
• Power user with strong workflow opinions: pi. Every refusal is an invitation; the extension API plus npm distribution means your dream agent is a weekend away, and the v0.84 maturity is real.
• Median developer or team: Claude Code, and the minimal wave does not dispute this yet. Zero-config onboarding, auto permission handling, and presence in every surface you already use beat assembly time.
• Fleet operators running tens of concurrent agents: fx now, pi when it must not break. The concurrency math holds; fx is lighter, pi is proven.
• Scripting and bulk automation: tie. fx ask --json and pi's print, JSON, and RPC modes are both first-class citizens, not afterthoughts.

The overall verdict: minimal is the new big, but it is two movements wearing one label. pi proves that a feature-minimal core can sustain an ecosystem, community distributions, and now corporate stewardship without surrendering its license or its taste. fx bets that a footprint-minimal runtime with a maximal feature set wins the embedder market nobody currently owns, from browser tabs to CI fleets. If forced to a single line: the platform era is not being overthrown, it is being flanked, from above by people who customize and from below by people who embed. The casualty of this debate is neither extreme. It is the middle-weight TUI that is neither deep enough to be a platform nor small enough to be a component.

Frequently Asked Questions#

Are fx and pi competitors?#

Only loosely. They share an aesthetic and a comment-section rivalry, but pi minimizes features while fx minimizes footprint, so they compete mainly for the identity of "the minimal agent" rather than for the same user. Many workflows could legitimately use both: pi as the daily driver, fx embedded in tooling around it.

Why does pi refuse MCP, sub-agents, and the rest?#

The project philosophy argues that baked-in features dictate workflows, while extensions and packages let each user choose their own. The to-do refusal comes with a stated reason, "They confuse models"; the others lean on alternatives like tmux for background work and containers for safety.

Does fx really run in the browser?#

Yes, via the WebAssembly SDK: createFxTerminal() embeds the interactive terminal and createFxAgent() the headless core, with a live demo at fx.sh/try. The SDK carries an experimental label in the README, so treat browser deployment as a preview capability, not a contract.

Can you use fx without a Vercel account?#

The default route signs in with Vercel AI Gateway, but the README documents two subscription alternatives, Codex OAuth and Grok OAuth, whose tokens stay in local files and are never sent to the gateway, and the docs describe support for direct provider APIs and local models. Early users nonetheless reported friction finding non-Vercel paths during onboarding.

What happened to pi after the Earendil acquisition?#

Mario Zechner joined Earendil on April 8, 2026, taking pi with him, retaining technical direction, and committing in RFC 0015 that the core remains MIT while some future components may be Fair Source or proprietary services. Release activity continued, with v0.84.2 shipping August 14, 2026.

Which one is actually smaller?#

Depends on the dimension. fx is a single-digit-MiB machine-code binary with CI-gated 2 ms startup budgets. pi is a TypeScript package on npm needing a Node-compatible runtime, so it weighs more on disk and at startup. But pi's feature surface is smaller by design: four default tools versus fx's 26. Small bytes, fx; small behavior, pi.

Should a team on Claude Code switch to a minimal kit?#

Switching wholesale is usually the wrong frame. Teams needing enterprise controls, multi-surface continuity, and managed settings get real value from platform depth that minimal kits do not offer. A reasonable hybrid: keep the platform for the median workflow, pilot pi or fx where their axes matter, embedded automation, fleet-scale scripting, or deeply customized personal workflows.

What single metric decides this debate?#

Named production deployments. If, a year from now, minimal kits power real products and fleet infrastructures while the platform pole keeps the median seat, both movements won on their own terms. If the embedders stall and extension authoring stays a hobbyist pursuit, minimal was a critic's romance, and the platform era absorbs another challenger.

Minimal is not one bet but two, and both are still live. For the individual tools behind this argument, read the fx deep dive, the practical fx setup guide, the architectural pi deep dive, the hands-on pi run modes and session trees guide, and the broader herdr vs pi vs tmux harness comparison.