Zero: The Programming Language Built for AI Agents

AIDeveloper44 Team

What Is Zero?

Zero is a new systems programming language created by Chris Tate at Vercel Labs, designed specifically for the era of AI agents. It's not trying to replace Python or TypeScript — it's carved out a very specific niche: small, native, agent-friendly tools where effects are explicit, memory is predictable, and compiler output is structured enough for machines to read and act on.

The project launched publicly on GitHub as vercel-labs/zero and already has over 1,200 stars. The official website is zerolang.ai.

Why Build a New Language for Agents?

As AI agents increasingly write and execute code, most existing languages were never designed with that workflow in mind. They produce verbose, human-readable error messages that are hard to parse programmatically, hide effects behind abstractions, and rely on hidden runtimes or garbage collectors that make size and behavior unpredictable.

Zero flips that model. According to the team, it was built around four core principles:

• Explicit capabilities — Function signatures declare what they touch (I/O, network, filesystem). The compiler rejects unavailable capabilities at compile time, not runtime.
• JSON-native diagnostics — Run zero check --json and you get structured output with error codes, messages, line numbers, and repair metadata — machine-readable fix plans agents can act on directly.
• No hidden GC or event loop — Allocation and cleanup are visible in code. No surprise pauses, no magic globals, no implicit async.
• Small native artifacts — Built for tiny tools. Size reports make binary costs visible before code generation.

What Does Zero Code Look Like?

Zero programs use .0 file extensions. Here's the canonical example from the repo:

pub fun main(world: World) -> Void raises {
  if answer() == 42 {
    check world.out.write("math works\n")
  }
}

Notice how world: World is passed explicitly as a capability — there's no global I/O. The raises annotation makes fallibility visible in the function signature itself. The check keyword surfaces errors for the caller to handle. Nothing is hidden.

Agent-First CLI Tooling

The Zero CLI is designed so both humans and agents can use the same toolchain. Humans read the error messages; agents read the JSON. The same CLI serves both:

• zero check --json — Validates a program and emits structured diagnostics with repair hints
• zero run examples/add.0 — Compiles and runs a Zero program
• zero build --emit exe --target linux-musl-x64 — Produces a native binary for a specific target
• zero size --json — Reports binary size costs before generation
• zero graph --json — Emits dependency graphs as machine-readable JSON
• zero doctor --json — Health check output as structured JSON

When an agent runs zero check --json and gets back a structured error with a repair field pointing to a fix plan, it can act on that directly — no parsing, no guessing. That's a fundamentally different developer experience than any existing language toolchain offers.

Getting Started

Zero is available now as v0.1.1 (experimental). Visit zerolang.ai to download the installer and follow the quick-start guide. Installation takes under a minute — once set up, running your first Zero program is as simple as:

zero check examples/hello.0
zero run examples/add.0

The compiler, standard library, docs, and examples are all available for exploration. The team is explicit that the language is not yet stable — but it's already useful for feedback and experimentation.

Who Built It?

Zero was created by Chris Tate, a software engineer at Vercel who also built agent-browser.dev, json-render.dev, and portless.sh. The project has four contributors on GitHub and is licensed under Apache 2.0.

Why It Matters

Zero represents a broader shift happening in developer tooling: as AI agents become first-class users of software infrastructure, languages and tools need to be designed with both humans and machines in mind. Zero's structured-output-first philosophy — where diagnostics, graphs, and size reports are all machine-readable JSON by default — is a concrete preview of what agent-native development infrastructure could look like.

If the trend continues, we may see more tools follow Zero's lead: making implicit things explicit, standardizing machine-readable output formats, and treating AI agents as a first-class target audience alongside human developers.

Follow the project at github.com/vercel-labs/zero and try it at zerolang.ai.

Enjoyed this?

Get more posts like this delivered to your inbox.

Subscribe