ZeroLang: When Vercel Built a Systems Programming Language for AI Agents

TL;DR: Vercel Labs has launched Zero (file extension .0), an experimental systems programming language positioned as “the programming language for AI agents.” It’s built around “everything is explicit” — no hidden allocators, no implicit async, no magic global variables — with a built-in agent-first toolchain: structured JSON diagnostics, binary size reports, typed repair metadata. If you care about the evolution of programming languages in the AI era, or are looking for a language that lets agents and humans “read, repair, check, and ship” small native programs together, Zero is worth your attention.

Chapter 1: Context — AI Agents Are Reshaping Programming Language Requirements

From 2025 to 2026, AI coding assistants have evolved from “code completion tools” into autonomous agents capable of independently writing, debugging, and shipping code. Anthropic’s 2026 Agentic Coding Trends Report notes that roughly 27% of AI-assisted work consists of tasks that simply wouldn’t have been done before — building interactive dashboards, exploratory experiments, fixing papercuts long ignored because they “weren’t worth human effort.” The engineer’s role is shifting from “building yourself” to “orchestrating agents,” and this places entirely new demands on programming languages.

Traditional systems languages — C, C++, Rust, Zig — were all designed for human developers. Their error messages, compiler output, and documentation formats are essentially “human-readable.” But when agents start reading and modifying code at scale, these outputs are often too free-text for machines. Agents need structured diagnostic information, predictable memory models, explicit function contracts — they don’t need pretty error hints, they need directly parseable JSON.

This is exactly the problem ZeroLang aims to solve. Its tagline is direct: “The programming language for agents” — a systems language that humans and AI agents can read, repair, check, and ship small native programs together.

Chapter 2: ZeroLang’s Design Philosophy — Everything Explicit, Start from Zero

ZeroLang’s core philosophy can be summed up in a single phrase: “Everything is explicit.” This sounds like a common pursuit among systems languages, but Zero pushes it to an extreme — specifically tailored for agent scenarios.

2.1 No Hidden Allocators

In most modern languages, memory allocation carries some degree of “magic.” Go has a garbage collector working silently in the background; Rust requires explicit management but many standard library operations still allocate implicitly; even Zig, known for explicitness, uses a global allocator behind std.debug.print. ZeroLang’s stance: if a function performs allocation, the signature must say so. You explicitly pass in an Alloc capability, use owned<T> to manage resource lifetimes, and helpers like std.mem.span, std.mem.len are zero-alloc.

pub fun main(world: World) -> Void raises {
    let bytes: Span<u8> = std.mem.span("zero")
    let view = BufferView { bytes: bytes }
    if std.mem.len(view.bytes) == 4 && view.bytes[0] == 122 {
        check world.out.write("span ok\n")
    }
}

2.2 No Implicit Async

JavaScript’s async/await transformed frontend development but brought the “color problem” — sync and async code can’t be freely mixed. Rust’s async ecosystem is powerful but .await’s infectiousness forces the entire codebase to be async-colored. ZeroLang completely rejects implicit async. If your function doesn’t block, it’s synchronous; if concurrency is needed, you express it explicitly. For agents, this is a blessing: no need to reason about complex async state machines — the execution flow is literally what’s written.

2.3 No Magic Globals

This is ZeroLang’s most distinctive design. Traditional languages’ printf, console.log, even Rust’s println! rely on some global or thread-local output handle. ZeroLang’s main function signature looks like this:

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

Note the world: World parameter. In Zero, a program doesn’t start from an implicit global environment; the runtime explicitly passes in a World capability object, and all interaction with the outside world — writing output, reading files, accessing networks — must go through this capability object. If a function wants to write output, it must request World in its signature; if it might fail, it must mark raises. This design lets an agent statically and completely understand a function’s side-effect boundary without analyzing the function body.

Chapter 3: Language Features Deep Dive — A Systems Language Designed for Agents

ZeroLang’s syntax is broadly a Rust/Zig-like statically typed systems language, but with extensive simplification and specialization for agent scenarios. The file extension is .0 — perhaps one of the shortest in programming language history.

3.1 Basic Syntax: Explicit and Concise

Zero function signatures follow a clear pattern:

fun function_name(params: Type) -> ReturnType { ... }

pub for export, fun declares a function, return type with ->. Basic types include i8/i16/i32/i64, u8/u16/u32/u64, usize/isize, f32/f64, bool, char, and Void. No implicit conversion between integers and floats — explicit as required:

let count: u32 = 0x12c_u32
let byte: u8 = count as u8

This “no implicit conversion” attitude runs through the entire language design. For agents, this means fewer surprises and clearer type boundaries.

3.2 Effects System: Capability-based I/O

ZeroLang’s effects system is its most technically distinctive feature. A function signature isn’t just a type signature — it’s a capability contract. The full main signature pub fun main(world: World) -> Void raises tells us three things:

• It receives a World capability — it may interact with the outside world
• It returns Void — no meaningful return value
• It’s marked raises — it may fail

The check keyword handles fallible operations. world.out.write(...) might fail, so calling it requires check, and any function using check must declare raises in its signature. This explicit error propagation chain lets an agent statically trace failure paths.

3.3 Data Modeling: shape, enum, and choice

Zero provides three data construction forms:

shape for named records (like struct):

shape Point {
    x: i32,
    y: i32,
}

Shape supports field defaults: shape Counter { value: i32 = 0, }. Field names must be explicit on construction: Point { x: 40, y: 2 }.

enum for fixed name sets:

enum Status {
    ready,
    failed,
}

choice is Zero’s algebraic data type (ADT) for “tagged unions with payload”:

choice Result {
    ok: i32,
    err: String,
}

choice pairs with match, and matching must be exhaustive — if a choice has both ok and err branches, you must handle both. This eliminates an entire class of runtime errors.

match result {
    .ok => value {
        if value == 42 {
            check world.out.write("choice ok\n")
        }
    }
    .err => message {
        check world.out.write("choice err\n")
    }
}

3.4 Memory Management: Predictable and Explicit

ZeroLang has no garbage collector and no Rust-style ownership/borrow checker. Its memory model is closer to Zig’s explicit management, with agent-oriented simplifications.

Core memory types include:

• Span<T>: read-only view, zero-cost abstraction
• MutSpan<T>: explicitly writable view
• [N]T: fixed-length array
• Maybe<T>: value that may not exist
• ref<T> / mutref<T>: explicit reference mutability
• owned<T>: owned value, auto-cleaned at scope end (if drop is defined)
• Alloc: allocator capability

defer for scope-exit cleanup:

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

defer executes on scope exit via return, break, or continue. It borrows from Zig and Go’s excellent design, but Zero adds: users cannot directly call value.drop(), ensuring cleanup determinism.

3.5 C Interop and Web Support

ZeroLang natively supports C interop:

extern c "config.h" as config
extern shape CConfig {
    enabled: bool,
    limit: i32,
}

On the web side, Zero compiles to wasm32-web targets and exports HTTP handlers via routes:

pub fun GET(req: Request) -> Response {
    return Response.text("hello from zero web\n")
}

zero routes --json outputs route manifests and Web bundle audit metadata including browser security capability restrictions, request/response surfaces, and bundle import information — all structured data agents can consume directly.

Chapter 4: Agent-First Toolchain — Not Just a Compiler, But an Agent’s IDE

If ZeroLang’s language design solves “how agents understand code,” its toolchain solves “how agents interact with code.” The official docs capture this intent precisely:

“Humans read the message. Agents read the JSON. The same CLI surfaces diagnostics, repair metadata, graph facts, and size reports.”

4.1 Structured JSON Diagnostics

Traditional compiler error messages are designed for human reading — pretty colors, suggested fixes, context hints. Zero’s CLI provides human-readable errors too, but simultaneously outputs structured JSON:

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

Each diagnostic includes a stable error code (e.g., NAM003), position info, expected/actual type comparison, help text, repair safety assessment, and typed repair metadata. Agents don’t need to parse free-text error messages — they can act directly on repair.id, like auto-generating missing symbol declarations.

4.2 Binary Size Reports

For systems languages, binary size is critical, especially in edge and serverless scenarios. Zero has built-in size analysis:

$ zero size --json examples/point.0

Size reports output as JSON, letting agents track how code changes affect binary size and auto-warn when exceeding thresholds. This aligns with Zero’s “small native binary” positioning — static distribution, explicit capabilities, no forced GC, no hidden runtime overhead.

4.3 Dependency Graph Analysis

$ zero graph --json examples/systems-package

zero graph outputs structured graph data of module dependencies. For agents, this means rapid understanding of codebase topology, identifying circular dependencies, or evaluating change ripple effects during refactoring. This capability normally requires an IDE or specialized tools — in Zero, it’s compiler-native.

4.4 Web Route Analysis and Skills System

$ zero routes --json examples/web/hello
$ zero skills get zero --full

zero routes analyzes web route surfaces and bundle imports; zero skills outputs Zero’s capability descriptions following Vercel’s Agent Skills spec, consumable by Claude Code, Cursor, Codex, and 17+ AI coding assistants. Vercel’s January 2026 skills.sh ecosystem rapidly accumulated 200+ skills, with the official React Best Practices skill reaching 26,000+ installations. Zero’s skills command bakes this ecosystem directly into the language toolchain.

4.5 Environment Diagnostics

$ zero doctor --json

zero doctor checks PATH health, workspace write permissions, bundle target support, target SDK/sysroot readiness, and interop tool readiness. The --json flag outputs targetToolchains — a readiness matrix per target. For agents, this means knowing whether the environment is ready before attempting a build.

Chapter 5: Comparison with Rust and Zig — Whose Shoulders Does ZeroLang Stand On?

5.1 Rust Comparison

Rust has been one of the most successful systems languages of the past decade, voted “most admired language” on Stack Overflow for 8 consecutive years. Rust’s core selling point is memory safety — eliminating an entire class of runtime errors at compile time through ownership and borrow checking. But Rust’s learning curve is notoriously steep, and compile times are often criticized.

ZeroLang’s fundamental difference from Rust is target audience. Rust is designed for human systems programmers — its error messages are exquisitely detailed (some say verbose), and while lifetime annotations are powerful, they add cognitive load. ZeroLang is designed for humans and agents together — it retains static typing and basic memory safety guarantees, but simplifies the ownership model (no lifetime annotations) while adding the structured output agents need.

5.2 Zig Comparison

Zig is probably ZeroLang’s closest “cousin.” Both emphasize explicitness, reject hidden control flow, use defer for scope cleanup, and have no garbage collector. Zig’s philosophy — “focus on debugging your application rather than debugging your knowledge of the programming language” — echoes Zero’s “everything is explicit.”

But ZeroLang extends Zig in two critical agent-oriented directions. First, the effects system — Zig’s function signature won’t tell you whether it can fail, allocate memory, or access the filesystem; Zero’s raises and World capability make all of this explicit. Second, the structured toolchain — Zig’s compiler output is human-designed, while Zero’s --json mode is agent-designed.

Zig’s creator Andrew Kelley positions Zig as “a better C,” while ZeroLang positions itself as “a systems language for agents.” This isn’t competition — it’s complementary design for different eras.

5.3 Why Not Just Extend an Existing Language?

A natural question: why not just add --json output to Rust or Zig, instead of building a new language? The answer is language design determinism. Rust’s ownership system is powerful, but its complexity (lifetime annotations, unsafe blocks, async runtime ecosystem) is a huge cognitive burden for agents. Zig’s explicitness is good, but its compiler architecture and language design weren’t built with agent needs from day one. ZeroLang’s design philosophy — “if a function touches the outside world, the signature must say so” — requires syntactic-level support for effects annotations, which isn’t something you can add post-hoc with a CLI flag.

Chapter 6: Getting Started — From Installation to First Executable

ZeroLang’s onboarding flow is designed to be extremely simple. Installation is a one-line curl:

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

6.1 First Program

Create a hello.0 file:

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

Then run type checking:

$ zero check hello.0

6.2 Compile to Native Executable

$ zero build --emit exe --target linux-musl-x64 hello.0 --out .zero/out/hello

Zero uses direct emitters, so no external C compiler is needed.

6.3 Project Management

Real projects use zero.json manifests and src/ directory structure:

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

6.4 VS Code Support

ZeroLang provides an official VS Code syntax highlighting extension at extensions/vscode/.

Chapter 7: Project Status — Experimental but Ambitious

ZeroLang is currently in experimental status. The official docs state up front: “The compiler, standard library, docs, and examples are useful for trying the language and giving feedback, but the language is not stable yet.”

7.1 Repository Structure

7.2 The Self-Hosting Path

native/zero-c/ is the current C-based compiler; compiler-zero/ is the Zero self-written compiler source — the ultimate test of language maturity. Self-hosting means a language is powerful enough to write its own compiler. Historically, Zig took years to self-host, and Zeta caused a stir in January 2026 by achieving self-hosting — compiling itself in just 14 milliseconds. Whether ZeroLang follows a similar path is worth watching.

7.3 Vercel’s Agent Ecosystem

ZeroLang isn’t Vercel’s only play in the agent space. In January 2026, Vercel launched skills.sh — an “npm for AI agents” — letting developers install best-practice skill packs for Claude Code, Cursor, etc. It reached 20,000+ installations within hours, with the React Best Practices skill reaching 26,000+ installs. Stripe, Expo, and Remotion published their own skills on launch day.

Chapter 8: Future Outlook — The Vanguard of Agent-Native Programming

ZeroLang’s emergence marks the beginning of a larger trend: programming languages are evolving from “human-only” to “human-machine shared.” This doesn’t mean humans no longer need to understand code — it means code and toolchain output must serve two consumers simultaneously: intuitive, creative humans and fast, tireless agents.

8.1 For AI Agent Developers

• Predictable semantics: no implicit async, hidden allocation, or magic globals
• Structured interaction: compiler output is JSON, directly consumable
• Small binary size: suitable for edge and serverless
• C interop: reuse existing C library ecosystems

8.2 For Systems Programming Enthusiasts

ZeroLang offers a window into “post-Rust/Zig” language design. It finds an interesting balance between Zig’s explicitness and Rust’s type safety, while adding agent-oriented innovations (effects system, structured toolchain).

8.3 Risks and Uncertainty

As an experimental project, ZeroLang faces many uncertainties. The language spec isn’t stable, the ecosystem is near-zero, the self-hosted compiler is still in development, and the community is nowhere near Rust or Zig’s scale. Whether ZeroLang transitions from experiment to production depends on breakthroughs in language stability, ecosystem growth, and community adoption.

Closing: Start from Zero, Face the Future

ZeroLang’s name embodies a philosophy — “Start with zero.” Start from zero, no historical baggage; start from zero, everything explicit; start from zero, humans and agents on the same starting line.

In 2026, where AI is rapidly transforming software development, programming language design paradigms are undergoing deep change. We no longer ask only “is this language human-friendly?” but also “is this language agent-friendly?” ZeroLang is among the first to systematically answer this question. Its effects system, capability-based I/O, and structured toolchain all work toward making code a “universal language” between humans and agents.

Whether ZeroLang ultimately becomes mainstream or not, it represents an important direction: the programming language of the future must be both human-native and agent-native. From this perspective, ZeroLang’s experimental value already far exceeds its current line count.

If you’re curious, spend ten minutes installing it, run a hello.0, and look at the zero check --json output. You might find that the future of programming languages arrives faster than expected.

ZeroLang official site: zerolang.ai | GitHub: github.com/vercel-labs/zero | Install: curl -fsSL https://zerolang.ai/install.sh | bash