Vercel Labs Launches Zero: A Systems Language That Emits JSON Errors So AI Agents Can Fix Code Without Human Help

Vercel Labs shipped Zero on May 15, and the premise is a sharp left turn from how programming languages have historically been designed: instead of writing compiler errors for humans to read, Zero writes them for AI agents to parse and act on.

The language — files use a .0 extension — is a systems-level language that compiles to native binaries under 10 KiB. It introduces a capability-based I/O model where functions must explicitly declare any side effects before the compiler will accept them. No implicit file access, no hidden network calls.

The error format is the product

The defining design decision is the error output format. Where Rust emits a paragraph explaining that a borrow checker rule was violated, Zero emits a structured JSON object with a stable error code (e.g., NAM003), a typed repairId field, and the exact source location. There’s no English prose — not because English is wrong but because JSON is what a coding agent’s tool-use loop can reliably parse, route, and act on.

The practical effect: an agent running a Zero compile step can read the error output directly without a text parsing layer, look up the repairId in a lookup table, apply the corresponding repair pattern, and recompile — all without making an LLM inference call to interpret what went wrong. The repair loop becomes deterministic instead of probabilistic.

For human developers, the JSON-only errors are initially disorienting. The team ships a human-readable mode (zero fmt --errors=human) but it’s opt-in, and the documentation is explicit that human readability is a secondary concern.

Sub-10 KiB native binaries

The binary size constraint isn’t arbitrary. Zero is targeting deployment in environments where an agent is shipping self-modifying tools to edge nodes, embedded systems, or container layers where size and cold-start time matter. The current compiler produces binaries that fit in that category reliably.

The capability-based I/O system enforces auditability: a binary can be read by a toolchain that parses the declared capability header and knows exactly what system resources it was allowed to access. That’s useful when agents are generating and deploying code autonomously and a human needs to audit what ran.

900 stars in 24 hours

The GitHub repo crossed 900 stars in the first 24 hours. That’s a notable signal for an experimental language that explicitly says the API isn’t stable, there’s no production use case yet, and the target user is primarily developers building agentic coding tools.

The interest isn’t surprising. As coding agents mature, the friction between LLM-generated code and the compiler error → human interpretation → LLM retry loop is one of the practical bottlenecks that slows autonomous coding pipelines. Zero is a bet that fixing the problem at the language level is cleaner than building better parsers for existing compiler output.

Whether that bet pays off at v0.1.2 is an open question. But the design direction is coherent, the team has Vercel’s resources behind it, and the problem it’s solving is real.