Zero

What is Zero?

Zero is Vercel's experimental programming language built specifically for a world where AI agents write the code. Instead of editing source text, agents query and patch a semantic program graph while the compiler checks every change. Humans simply ask for outcomes, then review readable code projections when needed. The language is designed from the ground up for agentic coding, with token efficiency, fast builds, low memory, and zero dependencies.

Who it's for

• AI agent developers — building tools and workflows that need a compiler-native, graph-based program representation instead of text patching.
• Engineering teams exploring agentic coding — who want a language where the compiler validates every edit before it touches the program store.
• Early adopters of experimental infrastructure — comfortable with breaking changes and willing to run Zero in safe environments, not against production systems.

Key features

Graph-as-program architecture

The program is a semantic graph, not source text. Symbols, calls, types, effects, node IDs, and graph hashes form the program database that agents query and patch. Readable .0 projections remain available for human review and rare manual edits.

Checked patches by default

Graph patches target semantic nodes and fields, guarded by graph hashes and expected values. Stale or invalid edits fail before they touch the store, so the compiler catches shape, type, and stale-state issues automatically.

Tighter agent loop

A traditional loop writes text, then runs tools to learn what the edit meant. Zero puts the compiler in the loop, so an edit is a checked change to the graph — reducing guessing and iteration cycles for agents.

Runtime constraints built in

Zero aims to stay small, fast, explicit, and dependency-free. The design prioritizes token efficiency, low memory, fast startup, fast builds, and low latency — without relaxing runtime goals.

What stands out

Zero flips the paradigm: the graph is the program, and the compiler is the agent's safety net.

This is a fundamental shift from text-based coding to graph-based programming. Instead of agents generating code that must be parsed and understood, Zero gives them a structured, queryable program database with built-in validation. The compiler checks every patch against graph hashes and expected values, making stale or invalid edits impossible before they land. For teams building agentic coding workflows, this means fewer silent failures and more trustworthy autonomous edits.

Worth checking out if…

You're building AI-agent coding tools and want a language designed for machine-native editing, or you're curious about how compiler-owned program graphs can replace text-based source control. Zero is also worth exploring if you value runtime efficiency — token economy, fast builds, and zero dependencies — and are comfortable with an experimental, breaking-change-prone early release. Start with the getting started guide, then dive into the graph architecture and compile-path pages to understand why the program database matters.