Zero (zerolang): The Programming Language for AI Agents

aiprogramming-languagesagent-firstvercelresearch

Bottom line

Zero is an experimental systems programming language from Vercel Labs, created by engineer Chris Tate and released on May 15, 2026. It's the first language designed from the ground up so that AI agents - not just humans - are the primary consumers of compiler output. The compiler emits structured JSON diagnostics with stable error codes and typed repair metadata, uses capability-based I/O to make all side effects explicit in function signatures. Compiles to sub-10 KiB native binaries without LLVM. It's currently at v0.1.3 (as of May 19, 2026), Apache-2.0 licensed, explicitly unstable, and not production-ready - but architecturally significant as a concrete experiment in "agent-first" language design.

Key findings

  • Structured compiler output is the core innovation. Every diagnostic includes a stable code (e.G., NAM003), a human-readable message. A repair object with a typed repair ID. The code is the contract; the prose is supplementary. This is unlike any existing systems language.
  • The repair loop is built into the toolchain. zero explain <code> returns structured explanations; zero fix --plan --json emits machine-readable fix plans with byte-range edits. An agent can check → look up → get a fix plan → apply → re-check without ever parsing prose.
  • Capability-based I/O makes effects auditable at the signature level. Every function that touches the outside world must receive a World capability parameter. Functions without World can't perform I/O - enforced at compile time. Combined with raises and check, this makes a function's side effects and failure modes fully visible without reading the body.
  • It sits in the Rust/Zig design space but targets a different consumer. No garbage collector, no hidden allocator, no implicit async, no magic globals. Memory types include Span<T>, MutSpan<T>, owned<T>, Alloc capability. File extension is .0. The compiler is written in C, with a self-hosted compiler (compiler-zero/) as a future goal.
  • The skeptical case has real merit. Developer Mehul Mohan described the borrow checker as "basic, not Rust-grade." The broader critique is that modern LLMs already handle Rust/Go/Python errors reasonably well - agents fail more often from context limits, poor planning. Bad tool use than from unstructured error messages. A new language may shift the bottleneck without moving the needle on overall agent reliability.

Background

What: Zero (also called zerolang) is an experimental systems programming language. Its tagline is "The programming language for agents."

Who: Created by Chris Tate (@ctatedev on X), a Vercel Labs engineer, with Matt Van Horn as a contributor. Published under vercel-labs/zero on GitHub (initially as vercel-labs/zerolang).

When: First public release v0.1.0 on May 16, 2026 (UTC); rapidly iterated to v0.1.1 (May 16), v0.1.2 (May 17), and v0.1.3 (May 19). Chris Tate stated on X that he built Zero in 3 days (unverified beyond his tweet). The launch was the morning before Google I/O 2026.

Where: Vercel Labs - Vercel's experimental arm, separate from the production platform team. This is part of a broader Vercel push into AI-native tooling that includes skills.Sh (launched January 2026 as "npm for AI agents") and Open Agents (April 2026).

Why: The core problem Zero addresses is the fragile agent repair loop. In today's agentic coding workflows, an agent writes code → the compiler emits unstructured text → the agent must parse that prose to determine what went wrong. Error formats change between versions. There's no built-in concept of a "repair action." Zero redesigns the language and toolchain so the compiler speaks JSON to agents as clearly as it speaks text to humans.

Current state

  • Version: v0.1.3 (May 19, 2026), actively iterating
  • License: Apache-2.0
  • GitHub stars: ~900 in first 24 hours; ~1.5K+ within days; growing
  • Contributors: Chris Tate (primary), Matt Van Horn, plus community contributors
  • Community: Vercel ran a "Zero to Agent" hackathon (with Google DeepMind) in multiple cities; a zero-to-agent.community resource hub exists
  • Notable claim: Vercel CTO Malte Ubl shared on X that a "bun rewrite to Zero" achieved 98.7% test pass rate in 22 hours with 96.2% compile time reduction and a "stronger borrow-checker than Rust." This is unverified and should be treated as promotional.
  • What's missing: No package registry, no stable spec, limited cross-compilation targets, VS Code extension only does syntax highlighting

Technical or implementation details

Language design

  • Syntax: Rust/Zig-like statically typed systems language; .0 file extension
  • Entry point: pub fun main(world: World) -> Void raises { ... }
  • Data types: shape (struct), enum (fixed names), choice (ADT/tagged unions with exhaustive match)
  • Memory types: Span<T>, MutSpan<T>, [N]T, Maybe<T>, ref<T>, mutref<T>, owned<T>, Alloc capability
  • Cleanup: defer for scope-exit (borrowed from Zig/Go)
  • Integers: Arbitrary-width from 1 to 64 bits (i5, u5, etc.)
  • C interop: extern c "config.h" as config
  • Web targets: wasm32-web; HTTP handlers via pub fun GET(req: Request) -> Response
  • No LLVM: Uses "direct emitters" - trades optimization ceiling for build speed and tiny binaries

Agent-first toolchain (single zero binary)

Command Purpose JSON output
zero check --json Type checking + diagnostics ✅
zero explain <code> Structured explanation of diagnostic code ✅
zero fix --plan --json Machine-readable fix plan (byte-range edits) ✅
zero run Build + execute -
zero build --emit exe Cross-compile to native binary -
zero graph --json Module dependency graph ✅
zero size --json Artifact size report ✅
zero routes --json Web route manifests ✅
zero skills get zero --full Version-matched agent guidance ✅
zero doctor --json Environment health check ✅

Structured diagnostic example

{
  "ok": false,
  "diagnostics": [{
    "code": "NAM003",
    "message": "unknown identifier",
    "line": 3,
    "repair": { "id": "declare-missing-symbol" }
  }]
}

Fix plan example

{
  "diagnostic": { "code": "NAM003", "line": 3 },
  "plan": {
    "id": "declare-missing-symbol",
    "edits": [
      { "kind": "insert", "line": 1, "text": "fun answer() -> i32 { return 42 }\n" }
    ]
  }
}

Evidence, comparisons, and related context

Comparison with Rust and Zig

Dimension Zero Rust Zig
Compiler output Structured JSON by default Human-readable text Human-readable text
Stable diagnostic codes Yes (NAM003, etc.) Partial (added later) No
Typed repair metadata Yes (repair.id) No No
Built-in agent guidance CLI Yes (zero skills) No No
Capability-based I/O Yes (compile-time enforced) No (ownership model) No
Unified single-binary toolchain Yes No (rustc + cargo + clippy) Partial
Hello World binary size Target: ~7–16 KiB ~280 KiB Small but larger
Mandatory GC No No No
Memory safety model Explicit allocation + basic borrow checking Ownership + borrow checker (mature) Explicit allocation
Async No implicit async Explicit (complex) No implicit async

Related: NERD-lang

NERD-lang (nerd-lang.org) is a parallel experiment in "LLM-native, agent-first" language design. Where Zero is a systems language focused on compiler output, NERD is focused on agent orchestration - its core primitives are LLM calls, MCP tool calls, and JSON handling. Both share the philosophy that future languages should be designed for machine authorship, but they target different layers of the stack.

Related: Vercel's broader agent strategy

Zero isn't an isolated project. Vercel Labs has been building an agent tooling stack:

  • skills.Sh (January 2026): An "npm for AI agents" - a CLI and registry for agent skill packages. Reached 20K+ installs in hours. Stripe, Expo, and Remission published skills on launch day.
  • Open Agents (April 2026): Background coding workflows
  • Zero (May 2026): Language-layer bet - the compiler as part of the agent runtime
  • "Zero to Agent" hackathon: Co-hosted with Google DeepMind in multiple cities

Limitations and critiques

  1. Basic borrow checker. Mehul Mohan tested Zero and described it as "Rust with a basic borrow checker - not Rust-grade." The memory safety guarantees are present in design but immature in implementation.
  2. Unverified performance claims. Malte Ubl's "98.7% bun rewrite, 96.2% compile time reduction, stronger borrow checker than Rust" claim on X has no independent verification and should be treated as promotional.
  3. Does structured output actually help agents? The skeptic's case: modern LLMs already handle Rust/Go/Python errors reasonably well. Agents fail more from context window limits, flawed multi-step planning, and poor tool use than from unstructured error messages. A new language may shift the bottleneck without improving overall reliability.
  4. No ecosystem. No package registry, no stable spec, minimal standard library, limited cross-compilation targets.
  5. Pre-1 by design. The README explicitly warns: "Breaking changes are expected... Treat today's syntax and APIs as something to explore, not something to memorize." Not suitable for production systems.
  6. "Built in 3 days" raises questions. If true, it speaks to the compiler's simplicity and Tate's skill, but also suggests the language hasn't had the years of design iteration that mature systems languages require.

Open questions

  • Does agent-first compiler output measurably improve agent performance? No published benchmarks compare agent repair success rates between Zero and existing languages.
  • Will Zero's ideas migrate to existing languages? The more likely outcome may be that Rust/Zig/Go adopt structured JSON diagnostics and repair metadata rather than developers migrating to a new language.
  • What happens at scale? Zero targets small native tools. Can the design handle large codebases, complex dependency graphs, and real-world systems programming?
  • Will the self-hosted compiler materialize? compiler-zero/ exists but the C compiler is primary. Self-hosting is a key maturity milestone.

Practical takeaways

  • Zero isn't production-ready. It's a research artifact and design experiment.
  • The design ideas are transferable. Stable error codes, typed repair metadata, version-matched CLI guidance, and capability-based effects are sound engineering principles that any language ecosystem could adopt.
  • If you build agent tooling, study zero skills and zero fix --plan --json. These CLI patterns are novel and worth replicating.
  • The question Zero raises is more important than Zero itself. As AI agents become primary code authors, should the entire toolchain be redesigned around agent consumption? Zero says yes, and makes a concrete argument for what that looks like.

Sources