Zero: Vercel Labs' agent-readable programming language

Most programming languages assume the reader is human. The compiler can be precise, but the feedback loop is still built around a person reading an error message, opening a file, making a judgment, and trying again.

Zero asks a sharper question: what changes if the primary user is an AI coding agent?

Vercel Labs describes it as an experiment in an “agent-first programming language” and is careful about the caveat. The README says Zero is pre-1, intentionally unstable, and not ready for production systems, sensitive data, or trusted infrastructure. That matters. This is not a Rust replacement, a Zig replacement, or a new general-purpose language you should bet a company on today.

What caught my eye is not the .0 extension or the syntax. It is the edit-check-repair loop. Zero is trying to make that loop less dependent on prose and guesswork. The language surface is deliberately regular. Capabilities are explicit. The standard library is meant to reduce dependency hunting. The CLI exposes structured diagnostics, graph facts, size reports, and repair plans that agents can parse directly.

That is a more concrete thesis than “AI will write code now.”

The agent loop is the product

The smallest Zero program already shows the tradeoff:

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

Output does not come from a hidden global. The program receives world: World, uses world.out, and marks fallibility with raises. The Getting Started guide calls this out directly: a program that writes output asks for a capability instead of reaching into an ambient process object.

Read as human-first scripting, this is slightly clunky. For an agent, the extra shape is useful. The signature carries information that would otherwise have to be inferred from context, imports, convention, or documentation.

The same pattern shows up across the docs. The language reference says command-line programs export main, World is a capability object created by the selected runtime, and targets can reject unavailable capabilities. Zero’s target capability docs currently list hosted capabilities such as args, env, fs, net, proc, rand, stdio, and time, while the smallest target-neutral subset is memory and stdio.

That gives an agent a boundary it can act on. If generated code needs filesystem access and the target does not expose fs, the compiler can say that before a failed deployment or a confusing runtime error.

JSON, not vibes

Zero’s strongest idea is not the syntax. It is the compiler contract.

The diagnostics reference shows a native JSON packet for zero check --json with stable fields for severity, code, message, source span, expected and actual values, help text, fix safety, and repair metadata:

{
  "schemaVersion": 1,
  "ok": false,
  "diagnostics": [
    {
      "severity": "error",
      "code": "NAM003",
      "message": "unknown identifier 'message'",
      "path": "examples/hello.0",
      "line": 2,
      "column": 27,
      "expected": "visible local, parameter, function, or builtin",
      "actual": "no visible symbol named 'message'",
      "help": "declare the name before using it",
      "fixSafety": "behavior-preserving",
      "repair": {
        "id": "manual-review",
        "summary": "Inspect the diagnostic fields and choose a repair manually."
      }
    }
  ]
}

This is the right abstraction level for agentic coding. A human can read the normal terminal output. An agent can consume the JSON without scraping ANSI-coloured prose, guessing where the span starts, or inventing a repair strategy from a vague error.

The fix-safety labels are the small detail that makes the design more serious. Zero distinguishes repairs such as format-only, behavior-preserving, local-edit, api-changing, and requires-human-review. That means a tool can treat “make this binding mutable” differently from “change the public API and update call sites.”

The repo includes a tiny agent repair demo that makes the loop concrete. The broken program passes an immutable destination buffer to std.mem.copy:

use std.mem

pub fun main() -> Void {
    let dst: [4]u8 = [0, 0, 0, 0]
    let src: [4]u8 = [122, 101, 114, 111]
    let _copied = std.mem.copy(dst, src)
}

The repair is intentionally boring:

-    let dst: [4]u8 = [0, 0, 0, 0]
+    let mut dst: [4]u8 = [0, 0, 0, 0]

Exactly. Agents do not need every compiler interaction to be clever. They need many interactions to be narrow, typed, repeatable, and safe enough to automate.

A standard library with metadata

Most AI coding failures are not caused by syntax alone. They happen when the model guesses the wrong library, calls the right library with the wrong ownership rule, or misses a target constraint hidden in docs.

Zero tries a different answer: make standard-library metadata part of the toolchain. The standard library reference says modules document target support, allocation behavior, error behavior, ownership notes, and runnable examples. It also says zero graph --json, zero size --json, and zero mem --json expose required capabilities, imported helpers, retained helper cost, allocator facts, and related metadata.

For an agent, that is more useful than another package ecosystem with ten plausible libraries for the same job.

The current library surface is still small, but it is already aimed at agent-readable systems work: std.mem for spans and fixed-buffer allocation, std.fs for hosted file lifecycle helpers, std.json for explicit-allocator parsing, std.crypto for small hash helpers, and std.http for hosted HTTP metadata and fetch conveniences.

Here is an example from the repo’s HTTP JSON sample:

let net = std.net.host()
let client = std.http.client(net)
let mut response: [512]u8 = [0_u8; 512]
let result = std.http.fetch(client, std.mem.span(maybe_request.value), response, std.time.ms(5000))

There are no hidden allocators in that snippet. The response storage is caller-owned. The network capability is explicit. The timeout is explicit. It is not elegant in the way a high-level TypeScript fetch wrapper is elegant, but it gives the compiler and downstream tools handles to reason about.

That tradeoff runs through the whole project: make the machine-readable shape obvious, even when the human-facing syntax gets a little heavier.

It is a systems language, but not a mature one

Zero is not just a DSL for compiler diagnostics. It is a native systems-language experiment with direct emitters, cross-target checks, C interop, explicit memory views, borrow checking, owned cleanup, static generics, and target capability validation.

The language reference lists executable targets including darwin-arm64, darwin-x64, linux-arm64, linux-musl-arm64, linux-musl-x64, win32-arm64.exe, and win32-x64.exe. The CLI reference includes everyday commands such as zero check, zero run, zero test, zero fmt, zero build, zero ship, zero graph, zero size, zero doc, zero fix --plan --json, and zero doctor.

The project is moving quickly. The first public release, v0.1.0, landed on 16 May 2026. The latest release at the time of writing, v0.1.3, landed on 19 May 2026 and added hosted HTTP client runtime support, more structured backend and target-readiness facts, expanded borrow-trace diagnostics, import graph facts, and native compiler allocation hardening.

That pace is good for exploration and bad for stability. The homepage says the current toolchain is useful for exploration, but that syntax and APIs are not a contract. The README is even more blunt: expect security vulnerabilities and use an isolated, disposable environment.

So the right evaluation is not “should I rewrite a service in Zero?” The answer is no. The right evaluation is “what does Zero teach us about languages designed for agents?”

The obvious objection

The skeptical response is fair: agents already know Python, JavaScript, Go, Rust, and C because there is a huge training corpus. A brand-new language has almost no public code for models to imitate.

That came up quickly in community discussion. One Reddit thread noted the limited training-data problem and questioned whether some of the “agent-friendly” parts are really language features or just checks many ecosystems can bolt on with linters, schemas, and better compiler output.

I think that objection is strongest against Zero as a near-term production language. It is weaker against Zero as a design probe.

Models do not need a giant corpus for every layer of the loop if the tool can explain itself well enough. A language with regular syntax, copyable examples, JSON diagnostics, typed repair plans, version-matched skills, and a standard library with explicit metadata is testing whether the training-data gap can be partly offset by better live feedback.

That makes the experiment useful even if Zero itself stays small.

What other languages should steal

The best parts of Zero do not require everyone to adopt Zero.

Existing compilers and toolchains should steal the JSON contract. Not just “machine-readable errors”, but stable diagnostic codes, source spans, expected and actual facts, repair IDs, fix-safety labels, target-readiness facts, and graph output that agents can consume without scraping terminal text.

Standard libraries should steal the metadata idea. Effects, allocation behavior, ownership notes, target support, and runnable examples should be queryable by tools, not buried in prose.

Agent integrations should steal version-matched guidance. Zero’s CLI reference documents zero skills, which serves bundled skill content from the compiler so an agent can load guidance that matches the installed binary. That is a better model than a stale prompt in a README.

And teams building internal platforms should steal the broader principle: if agents are going to be part of the development loop, design the loop as an API. Do not make the agent reverse-engineer your conventions from logs and wiki pages.

Who should try Zero now

Try Zero if you build coding-agent infrastructure, compiler tooling, or small native utilities and want to see what an agent-readable feedback loop feels like. Install it in a disposable environment, run the examples, inspect zero check --json, and look at zero graph --json and zero fix --plan --json.

Do not try it because you need a stable systems language. Use Rust, Zig, Go, C, or whatever already fits your constraints.

Zero is interesting because it treats agents as first-class users without pretending humans disappear. The human still reviews the diff, chooses the architecture, and decides what is safe. The compiler just stops hiding the facts the agent needs in prose.

That is the part worth paying attention to.