What Is Zero? The Programming Language for AI Agents

A Language Designed Around Its Readers

Most programming languages were designed for humans. Their grammars optimize for the things humans care about: terse syntax, expressive idioms, "elegant" shortcuts. Compilers print error messages in prose because a human is reading them. Standard libraries are organized the way library authors found memorable.

Zero starts from a different premise. Its primary readers are AI agents — language models writing, debugging, and repairing code on someone's behalf. Humans are still in the loop, but the language design treats agents as first-class users from day one. That single shift cascades into almost every visible feature of the language.

Zero is built by Vercel Labs, lives at zerolang.ai, and is open source at github.com/vercel-labs/zero. Source files end in .0.

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

Five things in that snippet — pub, World, raises, check, and the explicit world.out.write — already tell you a lot about how Zero thinks. We'll unpack each of them below.

"Everything Is Explicit"

The unofficial slogan in Zero's docs is everything is explicit. The language deliberately avoids the kind of hidden machinery that makes other systems languages convenient for humans but treacherous for code generators:

• No mandatory garbage collector.
• No hidden allocator.
• No implicit async runtime.
• No magic globals — no ambient stdout, no process.env, no implicit filesystem.

Anything a function does that touches the outside world has to show up in its signature. That's a lot of typing for a human; for an agent that's reasoning about what a function actually does, it's a gift.

Capabilities, Not Globals

The way Zero handles I/O is the clearest example of the philosophy. There is no global print function. Output happens through a World value that the runtime hands to main:

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

If a function deep in your call stack wants to write a log line, it has to be passed a World (or some narrower capability) explicitly. You can read a function's signature and know — without reading its body — whether it might touch the network, the filesystem, or stdout. That's the kind of property a static analyzer (or an agent doing a code review) can rely on.

The World capability goes deeper on this idea.

Explicit Failure with raises and check

Functions that can fail declare it. Callers that invoke fallible functions acknowledge it. There's no silent throwing:

fun validate(ok: Bool) -> i32 raises { InvalidInput } {
    if ok == false {
        raise InvalidInput
    }
    return 42
}

pub fun main(world: World) -> Void raises {
    check validate(true)
    check world.out.write("ok\n")
}

raises { InvalidInput } on validate means "this function can fail with InvalidInput". check at the call site means "if this fails, propagate the error up". You can't accidentally drop an error on the floor — it shows up in your function's signature or the compiler stops you. See Raises and Check for the full story.

A Compiler That Talks to Agents

The most distinctive piece of Zero isn't a syntax feature — it's the compiler's output. Run zero check --json on a broken program and you get back something like this:

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

Three things make this different from a normal compiler error:

1. Stable error codes. NAM003 means "unknown identifier" today and will mean exactly that in the next compiler version. Agents can pattern-match on the code without parsing English.
2. Structured repair metadata. The repair field names a fix kind the compiler thinks would resolve the error. An agent can fetch the plan with zero fix --plan --json and apply it.
3. No prose parsing required. The whole point is that an agent shouldn't have to interpret a human-friendly message to decide what to do next.

JSON Diagnostics walks through the format in detail.

Small Surface Area on Purpose

Zero's grammar is small and regular — closer in spirit to early C than to a kitchen-sink language like Scala or modern C++. The reasoning is practical: an agent should be able to internalize the entire language during a session without misfires on edge cases.

That means you'll find:

• One way to declare a function (fun or pub fun).
• One way to bind a local value (let).
• One way to model product types (shape), one way to model sum types (choice), one way for plain enumerations (enum).
• One pattern-matching construct (match).
• One loop construct in the early language (while).

What you won't find — at least at this stage — are operator overloading, implicit conversions, macros, decorators, or three competing ways to express the same idea. That's not asceticism; it's a deliberate choice to keep the surface small enough that an agent rarely picks a wrong variant.

What Zero Is Not

To set expectations:

• Not a scripting language. Zero compiles to native binaries. Programs are small (the docs mention sub-10KB executables) and don't drag in a runtime.
• Not Rust, not Go, not Zig. The syntax has shared ancestors but the priorities are different — Rust optimizes for memory safety with a sophisticated type system, Zero optimizes for agent learnability with a deliberately tiny one.
• Not stable. Zero is pre-1.0. The team is explicit that breaking changes will land if they advance agent-first goals. Don't depend on it for anything serious yet.
• Not a Vercel deployment platform feature. Despite being from Vercel Labs, Zero isn't tied to Next.js or Vercel hosting. It's a standalone systems language.

When You'd Try Zero Today

You'd try Zero today if you're interested in:

• How a language changes when its design constraints come from agents rather than humans.
• Experimenting with capability-based I/O without adopting a research language.
• Watching what "structured compiler output" looks like as a first-class feature instead of an afterthought.
• Giving Vercel Labs feedback on a project that's actively evolving.

You'd skip it (for now) if you need a stable language for real work, want a mature ecosystem of libraries, or need cross-platform tooling at the level of Rust or Go.

Next: Install Zero

The next doc walks through installing the Zero toolchain and getting your first program to compile. It takes about a minute end-to-end.