fx Deep Dive: Inside Vercel's Tiny Native Coding Agent

Last updated: August 23, 2026

Official Sources#

All star counts, sizes, and version numbers below were checked on August 23, 2026, unless a source and date are given inline.

What fx Actually Is#

fx is a coding agent harness and CLI written in Zig by Vercel Labs, the repository tagline being "Unix like coding agent". One sentence up front: fx is a compiled-native, model-agnostic agent runtime that ships as a single-digit-megabyte binary, starts in microseconds, and is designed less like an IDE in your terminal and more like a Unix component you can script, embed in CI, or compile into someone else's application.

The homepage frames it as "tiny, open, native", and each word carries weight. Tiny refers to the 6.39 MiB download, a 10 microsecond cold start that does no unnecessary I/O before accepting input, and what the project calls a single-digit-megabyte memory baseline. Open means genuinely open source under Apache-2.0, not source-available: the full Zig source, tests, benchmarks, and SDK all live in the public repo. Native means the harness is a machine-code binary with no JavaScript runtime dependency, plus first-class WebAssembly targets of the same core.

Third-party writeups describe fx as an internal Vercel tool opened to the public (AgentPedia, August 18, 2026). The repository was created August 11, 2026, the first public tags appeared August 17-18, and the Hacker News launch thread hit 313 points within five days. As of August 23, 2026 the repo shows roughly 2,225 stars and 234 forks against 639 commits, with the changelog at version 0.0.5 (changelog). The README carries an unambiguous warning: "Status: Experimental. Use at your own risk."

Four Surfaces, One Core#

What separates fx from most terminal agents is not the chat loop, it is the number of ways the same core can be driven:

1. The CLI. curl -fsSL https://fx.sh/setup.sh | bash installs on macOS and Linux, x86_64 and arm64 (installation). Interactive sessions behave like a shell rather than a full-screen TUI: scrollback is preserved by default, output is minimal, and paints are sparing.
2. One-shot mode. fx ask "explain this repository" runs noninteractively, and --json returns structured fields instead of Markdown, aimed squarely at scripts and CI (fx ask docs).
3. ACP server. fx acp exposes the agent over stdio using the Agent Client Protocol so editors can drive it (ACP docs).
4. WebAssembly and the libfx SDK. The npm package libfx ships both a native Node addon (prebuilt for macOS and Linux) and two Wasm builds: createFxAgent() for a headless embedded agent and createFxTerminal() for an interactive one, with a pluggable network stack (embedding docs). The browser demo at fx.sh/try runs that Wasm build live.

That fourth surface is the one competitors mostly lack. Pi has print, JSON, RPC, and a TypeScript SDK, but it requires a JavaScript runtime and cannot run in a browser. An HN commenter put it directly: you cannot embed pi in a webpage, and Wasm alone makes fx worth watching (thread).

Providers: Gateway First, Subscriptions Catching Up#

Here is where the launch friction concentrated. The documented credential order is: a Vercel OIDC token when running inside Vercel, then AI_GATEWAY_API_KEY, then an fx login OAuth session, then a saved API key (authentication docs). On macOS keys land in Keychain; on Linux in a 0600-permission file. In other words, the default path routes inference through Vercel AI Gateway, which bills usage and records request metadata such as model, token counts, latency, and cost, though it does not retain prompts after a request completes.

Two things changed the picture within days of launch. First, version 0.0.5 added subscription logins: fx login codex uses an eligible ChatGPT subscription through OpenAI Codex OAuth, and fx login grok does the same with xAI, with both OAuth tokens stored locally and never sent through the gateway (README). Second, the privacy docs describe loopback endpoints for fully local inference: block outbound networking and fx stays hermetic (data and privacy). What still lacks documentation as of August 23 is a plain remote OpenAI-compatible base URL, which several commenters asked for; strings like OPENAI_API_KEY exist in the source but no generic-provider setup page does yet.

Model requests themselves speak Vercel's AI SDK Language Model Specification, which tells you exactly how fx relates to the rest of the company's stack: the client is decoupled from providers through the same abstraction as Vercel's AI SDK, and the gateway is the monetization rail. One early tester noted GLM 5.2 was usable free even on a free Vercel account, reading fx plainly as top-of-funnel for Vercel AI (HN).

Guardrails: Permissions Without a Sandbox#

fx starts in an auto permission mode: routine understood actions run directly, and anything unresolved gets one narrow safety review based on the current request and the exact pending action (permissions docs). You can persist exact allow or deny rules with /permissions remember, list stable rule IDs, and revoke them later. Piped or redirected stdin stays noninteractive and fails rather than waiting for approval, which is the right default for automation.

The sharper edge: fx ships no sandbox of its own. Version 0.0.5's breaking changes explicitly retire sandbox configuration entirely, moving approved commands to ordinary host subprocesses (changelog), and independent verification earlier in the week had already noted that an absent sandbox setting meant no sandbox (HashSparks, August 19). Permission rules are policy checks, not isolation. If you run fx against valuable state, the container or microVM is your problem - the same stance our pi deep dive documented over there, minus pi's official containerization recipes.

Everything else in the guardrail layer leans careful rather than flashy: MCP configs write atomically with private permissions and get validated before servers start (MCP docs); skills follow a strict link-trust policy with symlinks only honored from explicitly trusted directories (skills docs); and /trace builds a diagnostic locally, leaving redaction to you.

The Minimalism Ledger, Verified#

Only verifiable numbers belong here, so we counted.

That last row is the interesting one. For context, Simon Willison measured xAI's open-sourced grok-build at 844,530 lines of Rust and OpenAI's Codex at 950,933 (Willison, July 15, 2026). So fx sits well under the giants but is nobody's weekend script, and the thread noticed: one commenter expected a truly tiny native agent at 200-300 KB, another reported building from source at 44 MB stripped before finding the right release flags, and a third got 5.8 MB with -Doptimize=ReleaseSmall on macOS (HN). Version 0.0.5 also lists shrinking the macOS arm64 footprint among its improvements.

The honest read: fx's minimalism is about runtime surface (binary size, cold start, memory, token overhead), not codebase size. Those are different budgets, and fx optimizes the former deliberately while its source grows like any ambitious harness. The CI-enforced latency budget is the tell - very few projects codify "help must respond in 2 ms or the build fails".

Context discipline shows up at the protocol level too. Large tool results are held out of the model response behind byte-range handles read on demand via read_tool_result, bounded by max_tool_result_bytes (tools docs). The memory tool persists facts to ~/.fx/memories.json but never injects them into every request; the model retrieves on demand. semantic_search is explicitly lexical, not an embedding index. And there are currently no interactive browser or CDP tools - a stated non-goal worth knowing.

Where fx Sits in the Minimal-Agent Wave#

fx arrived into a wave: pi's refusal-driven minimalism, opencode 2 rebuilding around internal plugins and event sourcing, DeepSeek shipping its own small-core harness - commenters connected those dots immediately (HN). Calling fx "a pi competitor" flattens real differences, because the two projects barely optimize for the same thing:

• Runtime vs toolkit. Pi is an MIT TypeScript monorepo you compose from libraries - about 95,900 stars and 11,900 forks as of August 23, 2026 (GitHub). fx is a compiled binary you install or embed, no runtime required. Different answers to "what does minimal mean": pi minimizes features, fx minimizes footprint.
• Extension philosophy. Pi famously refuses subagents and MCP. fx embraces all three - skills, MCP servers, and session-backed subagents are built in (subagents docs) - betting that a small core plus Unix-style extension beats a feature-locked core.
• Audience. Pi targets terminal power users shaping a personal harness. fx targets embedders: CI sandboxes, agent fleets, editor integrations, browser hosts. The strongest defense of fx's approach in the thread came from someone running hierarchies of 50-100 concurrent agents, for whom baseline footprint decides feasibility (HN).

If Herdr multiplexes many agents above harnesses like these (our deep dive), fx is positioning to be the cheapest unit you can run many of.

What Hacker News Made of It#

The launch thread split cleanly:

Praise. Embeddability was repeatedly named the actual differentiator rather than the size brag. The Wasm target drew specific interest, the shell-like UX found fans ("UX-wise it's quite minimalistic, that seems one of their differentiators"), and several commenters simply wanted what fx promises: an agent that opens instantly and does not eat half a gigabyte of RAM.

Skepticism. The sharpest critique called the 26-tool set the opposite of minimalist ("a tool for every single file operation"), dismissed binary size and startup time as useless metrics, and concluded "Just use Pi." Others asked why a Zig binary weighs 6 MB at all, flagged the gateway-only onboarding as disqualifying, worried aloud about Vercel Labs abandoning another experimental project, and one commenter claimed upvote rings - which other users pushed back on citing the site guidelines. A recurring terminological debate broke out over whether calling a harness an "agent" means anything; the tidy version came from one reply: "harness + llm = agent".

Author activity. There was no heavy defense tour. The submitter gently flagged one hyperbolic claim, and the loudest complaint - no way past the Vercel login - was answered in code within days when Codex and Grok subscription logins shipped in 0.0.5. That is a better response than any comment war.

Honest Gaps and Open Questions#

• No Windows. Installers and CI artifacts cover macOS and Linux on x86_64 and arm64 only (homepage; HashSparks).
• Experimental in writing. Frequent breaking changes are promised by the README itself; 0.0.5 already removed sandbox configuration that existed days earlier.
• Vendor benchmarks only. The 10 microsecond start and single-digit-MB memory figures come from Vercel's own materials; independent verification found no comparative benchmark or security audit as of August 18 (HashSparks).
• Provider story still settling. Local loopback works; Codex and Grok subscriptions work; a documented generic OpenAI-compatible endpoint does not yet exist despite the "model-agnostic" banner.
• Gateway gravity. Even with alternatives, every documented default flows through Vercel infrastructure, and Pro/Enterprise Zero Data Retention is a gateway-tier feature (ZDR docs). Trust-or-don't is a legitimate fork in the road; some commenters made it explicitly.
• Unanswered sizing questions. Why the README and homepage disagree on binary size, and what the floor really is with release flags, remain open.

None of these are disqualifying for an eight-day-old project. All of them are reasons to pin versions and read diffs if you adopt it now.

FAQ#

What is fx in one sentence?#

A tiny, open-source (Apache-2.0), native coding agent harness written in Zig by Vercel Labs, installable as a roughly 6 MiB binary and embeddable via CLI, ACP, or WebAssembly (fx.sh).

Is fx actually open source?#

Yes - the full Zig source, tests, benchmarks, and SDK are public under Apache-2.0 at github.com/vercel-labs/fx, not merely source-available.

Do I need a Vercel account?#

For the default path, yes: fx login uses Vercel OAuth or an AI Gateway key. Alternatives as of August 23, 2026 are ChatGPT subscriptions via fx login codex, Grok subscriptions via fx login grok, or local loopback inference (privacy docs).

Why do binary size and startup time even matter for an LLM tool?#

Not for one human session - for fleets. When you run dozens of concurrent agents in CI or sandboxes, baseline megabytes and cold-start milliseconds decide what fits on one machine, which is exactly the use case early adopters described (HN).

Is the 10 microsecond cold start real?#

It is the vendor's figure, but the project backs performance claims unusually hard: CI enforces a 2 ms mean wall-clock budget on six core commands via hyperfine (check_budgets.py). Independent benchmarks do not exist yet.

Does fx work on Windows?#

Not currently. Official builds cover macOS and Linux on x86_64 and arm64; there is no Windows artifact (homepage).

How is fx different from pi?#

Pi minimizes features from an MIT TypeScript toolkit you compose yourself; fx minimizes runtime footprint as a compiled binary that embraces skills, MCP, and subagents, and adds browser-grade embedding pi cannot match. Roughly 95,900 stars versus 2,225 as of August 23, 2026 tells you the maturity gap too.

Is fx production-ready?#

No. The README says "Experimental. Use at your own risk," breaking changes are frequent, and there is no independent audit yet. Evaluate in low-stakes repos, pin versions, and treat the permission system as policy - not isolation.

---

This deep dive opens our three-part series on fx. Part two, a hands-on setup and workflows guide, and part three, fx against pi on philosophy and daily driving, land later this week. Until then, go deeper on the neighboring ideas: how pi's architecture earned its minimalism crown, why Herdr exists to multiplex harnesses like these, how the major coding CLIs compare head to head, what xAI's 844k-line grok-build release revealed about harness complexity, and the CLI-over-MCP thesis that projects like fx quietly prove.