Vercel Labs Unveils Zero: A Systems Language Built for AI-Driven Code

Vercel Labs
01 / 09  ·  Overview

Zero
A Language Built
for AI Agents

An experimental systems-level language offering AI agents structured error reports,
typed fix metadata, and documentation that machines can read — plus native binaries under 10 KiB.

Systems Language
Agent-Native
v0.1.1
Apache-2.0
Experimental

Context
02 / 09  ·  Why Zero Exists

The Agent Repair Loop Problem

Traditional programming languages generate compiler messages meant for people — raw text that AI agents need to interpret to figure out what went wrong and how to correct it. This leads to a brittle cycle.

• Agent writes code — the compiler spits out an error as plain text
• Agent interprets text — error formats may shift across compiler versions
• No fix guidance — there’s no native notion of a “repair action”
• Human gets involved — the cycle demands manual help to sort out errors

Zero was built from the ground up so agents can read the source, make sense of the diagnostics, and patch the program — all without a human in the middle.

Core Feature
03 / 09  ·  JSON Diagnostics

Structured Compiler Output

When you run zero check ——json, you get machine-friendly diagnostics rather than freeform text. Each error carries a consistent code, a readable message, a line reference, and a typed repair identifier.

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

• code — a stable identifier agents can reliably match (NAM003)
• message — a clear, human-readable error description
• repair — a typed repair ID agents can use directly, no text parsing needed

Core Feature
04 / 09  ·  Repair Commands

zero explain & zero fix

Two CLI subcommands round out the agent repair cycle — no need for agents to sift through prose documentation.

zero explain NAM003

zero fix --plan --json add.0

Combined, zero explain and zero fix --plan --json enable agents to grasp errors and take action without a human translating compiler output.

Core Feature
05 / 09  ·  Agent Guidance

zero skills: Version-Matched Agent Guidance

Most tools force agents to pull from external docs that might not match the installed compiler version. Zero tackles this with zero skills — guidance delivered straight from the CLI, aligned with the version you have installed.

zero skills get zero --full

Provides focused workflows covering:

• Zero syntax — core language concepts for the installed version
• Diagnostics — how to read and respond to compiler messages
• Builds & packages — manifest layout, targets, and output
• Testing & agent edit loops — patterns for validation and repair cycles

Language Design
06 / 09  ·  Capability-Based I/O

Explicit Effects & Capability-Based I/O

In Zero, if a function interacts with the outside world, its signature makes that clear. There’s no hidden global process object, no implicit async behavior, and no magic globals.

pub fun main(world: World) -> Void raises {
  check world.out.write("hello from zeron")
}

• world: World — a capability object that unlocks access to I/O, filesystem, and network
• check — manages operations that can fail; pushes errors up the call chain
• raises — signals that the function may propagate errors — right there in the signature
• Compile-time enforcement — capabilities you don’t have are caught at compile time, not at runtime

Language Design
07 / 09  ·  Memory & Size

Predictable Memory & Tiny Binaries

Zero is aimed at environments where binary footprint and memory behavior need to be predictable. There’s no hidden runtime overhead.

zero build --emit exe 
  --target linux-musl-x64 
  add.0 --out .zero/out/add

• zero size --json — displays artifact size information prior to code generation when available
• No hidden allocator — memory allocation is fully explicit and visible within the source code
• C ABI exports — platform-specific interoperability metadata for C interface boundaries

Quick Start
08 / 09  ·  Getting Started

Install & Run Zero

Set up the compiler using a single curl command:

curl -fsSL  | bash
export PATH="$HOME/.zero/bin:$PATH"
zero --version

Verify, execute, and compile your first program:

zero check examples/hello.0
zero run   examples/add.0
zero build --emit exe --target linux-musl-x64 
  examples/add.0 --out .zero/out/add

Scaffold a new package:

zero new cli hello
cd hello
zero check .  &&  zero test .  &&  zero run .

Status
09 / 09  ·  Current State

What’s Available & What’s Not

• v0.1.1 (Experimental) — the compiler, standard library, and language specification are still under active development
• No package registry — the ecosystem is in its early stages
• Cross-compilation — currently supports only the documented set of targets
• VS Code extension — syntax highlighting for .0 files is included in the repository
• Contributors — Chris Tate & Matt Van Horn (Vercel Labs)

Zero is an active experiment worth following for AI engineers curious about agent-native toolchain design — but it is not yet ready for production use.