Vercel Labs Introduces Zero, a Systems Programming Language Designed So AI Agents Can Read, Repair, and Ship Native Programs

Most programming languages were designed for humans who read error messages, interpret warnings, and manually trace through stack output to fix bugs. AI agents do none of those things well. They work better with structured data: predictable tokens, stable codes, and machine-parseable repair hints. That gap is what Vercel Labs is trying to close by releasing Zero, an experimental systems language that is faster, smaller, and easier for agents to use and repair.

What is Zero Language

Zero is a systems programming language that sits in the same design space as C or Rust. It compiles to native executables, gives you explicit memory control, and targets low-level environments.

What separates Zero from existing systems languages is that its compiler output and toolchain were designed from day one to be consumed by AI agents, not just human engineers.

The Agent-First Toolchain

The core problem Zero addresses is how agents interact with compiler feedback. In a typical development loop involving a coding agent, the agent writes code, the compiler emits an error as unstructured text, and the agent has to parse that text to determine what went wrong and how to fix it. This is fragile — error message formats change, messages are written for human readers, and there’s no built-in concept of a ‘repair action.’

Zero’s CLI emits structured JSON diagnostics by default. When you run zero check --json, the output looks like:

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

Each diagnostic carries a stable code (e.g., NAM003), a human-readable message, a line reference, and a repair object with a typed repair ID. Humans read the message. Agents read the code and repair. The same CLI command surfaces both — there is no separate mode or secondary tool to run.

The toolchain is unified into one binary: zero check, zero run, zero build, zero graph, zero size, zero routes, zero skills, zero explain, zero fix, and zero doctor are all subcommands of the same CLI. This matters for agentic workflows because agents don’t need to reason about which tool to invoke for which task.

Two subcommands are particularly relevant to the repair loop. zero explain <diagnostic-code> returns a detailed explanation of a given diagnostic code, so an agent can look up NAM003 without parsing prose documentation. zero fix --plan --json <file-or-package> emits a structured fix plan — a machine-readable description of what changes to make to resolve a diagnostic — rather than requiring the agent to infer the fix from the error message alone.

zero skills serves a different purpose: it provides version-matched agent guidance directly through the CLI. Running zero skills get zero --full returns focused workflows covering Zero syntax, diagnostics, builds, packages, standard library use, testing, and agent edit loops — all matched to the installed compiler version. This is notable because it means agents working with Zero don’t need to scrape external documentation that may be out of sync with the compiler they’re actually running.

Explicit Effects and Capability-Based I/O

One of Zero’s core design decisions is that effects are explicit in function signatures. If a function writes to standard output, accesses the filesystem, or makes a network call, it must declare that through a capability object.

The canonical entry point in Zero looks like this:

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

The world: World parameter is the capability object that grants access to the outside world. A function that doesn’t receive World (or a capability derived from it) cannot perform I/O — the compiler enforces this at compile time, not at runtime. There is no hidden global process object.

The check keyword handles fallible operations. If world.out.write(...) can fail, check surfaces that failure along the call stack. The raises annotation on main signals that the function can propagate errors — making error paths visible in signatures rather than buried in runtime exceptions.

Getting Started

Installation requires one command:

curl -fsSL https://zerolang.ai/install.sh | bash
export PATH="$HOME/.zero/bin:$PATH"
zero --version

The installer downloads the latest binary from the GitHub release and places it in $HOME/.zero/bin/zero. Packages are defined with a zero.json manifest and source files under src/, initialized with zero new cli <name>.

A VS Code extension for .0 file syntax highlighting ships in the repository under extensions/vscode/.

Marktechpost’s Visual Explainer

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

zero explain NAM003

zero fix --plan --json add.0

zero skills get zero --full

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

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

curl -fsSL https://zerolang.ai/install.sh | bash
export PATH="$HOME/.zero/bin:$PATH"
zero --version

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

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

Originally published at marktechpost.com. Curated by AI Maestro.

Stay ahead of AI. Get the most important stories delivered to your inbox — no spam, no noise.

Please enable JavaScript in your browser to complete this form.

Name *

First

Last

Email Name

Email *

Submit