Zero — Vercel's new agent-first programming language that will change everything

After all, agents don't need curly braces. They don't care about the elegance of if, while, for, match, Result, try, await, naming conventions, and all that other stuff built for us meatbags.

That's why Zero from Vercel Labs looks like an interesting experiment at first glance. The official site calls it a language for agents, the README describes it as an "agent-first programming language", and the author's post on X promises it's a systems language that is faster, smaller, and simpler for agents to use and debug.

It sounds almost convincing. That is, until you take a look at the code.

What is Zero

Zero is an experimental systems language from Vercel Labs. The vercel-labs/zero repository had already racked up thousands of stars by the time this was written, alongside releases and the standard Vercel product packaging: a website, documentation, examples, a CLI, benchmarks, and so on and so forth.

The official pitch is as follows:

• Minimalist, simple syntax so an agent can "learn it on the fly";

• A standard library instead of hunting for dependencies;

• Structured tooling: diagnostics, graph facts, size reports, repair plans in machine-readable format;

• Explicit effects: access to the outside world must be visible in the function signature;

• Predictable memory, small native binaries, less magic.

If you strip away the marketing, the idea is solid. Even good.

The problem is that almost every one of these points already exists somewhere out there: in Rust, Zig, TypeScript, the Language Server Protocol, compilers with JSON output, static analyzers, linters, package managers, and just standard engineering discipline. Zero, meanwhile, is trying to sell all of this as brand-new language design approaches, seasoned with syntax like ret + 40 2 to make it seem more "agent-first".

Agent-first learnability

The official stated premise is that the language should be small, regular, with only a small number of special cases, so an agent can quickly learn it from examples, documentation, and compiler feedback.

In theory, this is excellent. LLMs do indeed perform better with regular patterns. The fewer syntactic exceptions there are, the lower the chance the model will start hallucinating JavaScript inside Rust inside YAML.

But there's a critical point that is somehow constantly overlooked in discussions about languages built for AI: agents do not appear out of thin air. They are trained on datasets.

TypeScript, Rust, Zig, Python, Go, C, and C++ appear in training data at industrial scale. There are millions of repositories, issues, pull requests, Stack Overflow posts, blogs, compiler errors, CI logs, Cargo outputs, GitHub Actions workflows, linters, and Tekkix guides on how to set up a create-react-app. There is, pun intended, zero data on Zero.

In other words, the claim that "agents can learn the language on the fly" in practice means feeding the agent documentation, examples, and skill files every single time, and hoping it doesn't mix up Zero's syntax with any similar language present in its training dataset. This isn't learnability. This is a context tax.

And while I was writing this article about Zero's syntax, its similarity to other languages, and that very learnability, the following happened:

On May 21, 2026, a commit appears in the repository 229331fe93119e481cd24fd75b3d67a9e2c1db84:

Raw stats: 711 files changed, 6854 insertions, 8904 deletions. We migrated examples, fixtures, docs, skills, and command contracts.

Before:

fun answer() -> i32 {
    return 40 + 2
}

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

After:

// No more brackets, yay, the future
fn answer i32
    ret + 40 2

pub fn main Void world World !
    let value answer()
    if == value 42
        check world.out.write "math works\n"
    else
        check world.out.write "math broke\n"

On the one hand, yes, the syntax has become "more regular". On the other hand, it now looks like... Lisp? My apologies to Lisp fans just in case.

And the funniest part: agents don't "not need if/while/for". The Zero documentation still retains if, else, while, range for, match, enum, choice, type, defer, owned, ref, mutref, Alloc, Maybe, and the rest of human civilization. It's just that now if value == 42 has turned into if == value 42.

Yep, it really looks "agents-first" now.

Standard library first

Zero says: "agents don't need to pick a dependency stack every single time. Frequent tasks should be part of the standard library, with documented APIs and predictable behavior. This is, without irony, the right goal."

Agents really are bad at picking dependencies. They grab a package with 80 stars, last released in 2019, with an API from a README that no longer exists, and then confidently explain that "the error is probably related to the environment. Share your .env file, I'll figure it out".

But standard-library-first is not a unique idea. Go has been built on this for decades. Python, with its "batteries included" philosophy, also tried this approach. Rust went a different direction, but made up for it with its ecosystem + cargo + docs.rs. TypeScript, for its part, leeches off the massive JS ecosystem.

Zero currently has a set of modules: std.mem, std.codec, std.parse, std.fs, std.io, std.json, std.env, std.time, std.rand, std.proc, std.crypto, std.net, std.http. It looks decent on paper. But the problem is that an agent doesn't just need std.parse.isAsciiDigit — it needs surrounding context: libraries, bugs, patterns, Stack Overflow, CI failures, weird edge cases, and other people's production experience.

Without this, the agent isn't "writing code". It's solving a syntax puzzle with hints from the compiler.

Deterministic tooling

Despite the odd phrasing, Zero really highlights a good idea here.

Idea: a human reads a message, an agent reads JSON. The compiler doesn't just throw errors, but provides a structured description of the problem and a potential fix plan.
This is a strong feature of Zero, but the issue is that a new language isn't needed for this. This functionality already exists in Rust! Cargo, rust-analyzer, clippy, rustfix, compiler suggestions — all this infrastructure has been built over years specifically around machine-readable signals. Even TypeScript has a compiler API and language service. ESLint has been outputting machine-readable reports and autofixes for a long time.

Zero does the right thing, but it does so in the most expensive place possible: at the level of a new language, a new ecosystem, new syntax, and a new habit for everyone.

Comparison with TypeScript, Zig, Rust

Let's take the most straightforward example: a function returns 42, the program prints math works.

Zero (new row syntax)

fn answer i32
  ret + 40 2

pub fn main Void world World !
  let value answer()
  if == value 42
    check world.out.write "math works\n"
  else
    check world.out.write "math broke\n"

TypeScript

function answer(): number {
  return 40 + 2;
}

function main(): void {
  const value = answer();

  if (value === 42) {
    process.stdout.write("math works\n");
  } else {
    process.stdout.write("math broke\n");
  }
}

main();

TypeScript is not a systems language, and it is clearly not agents-first, but it has something that is currently more important for an agent than syntactic "regularity": a massive training dataset. The model has seen this code millions of times. It knows what if looks like, what process.stdout.write looks like, what types look like, tsc errors, ESLint autofixes, Vitest, package.json, and Stack Overflow answers from 2007 that no longer work but are still present in the dataset as a cultural layer.

What's most interesting is that Zero, as a language built specifically for agents, isn't even all that much more compact. That means you're unlikely to save many tokens by migrating to it from TS.

Let's move on to compare it with more similar counterparts.

Zig

const std = @import("std");

fn answer() i32 {
    return 40 + 2;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    if (answer() == 42) {
        try stdout.writeAll("math works\n");
    } else {
        try stdout.writeAll("math broke\n");
    }
}

If Zero were "Zig plus first-class JSON repair metadata for agents", the discussion would be more interesting. But the current row syntax doesn't look like the next step after Zig, but rather like an attempt to prove that prefix operators are definitely necessary for agents.

Rust

use std::io::{self, Write};

fn answer() -> i32 {
    40 + 2
}

fn main() -> io::Result<()> {
    let value = answer();
    let mut out = io::stdout().lock();

    if value == 42 {
        out.write_all(b"math works\n")?;
    } else {
        out.write_all(b"math broke\n")?;
    }

    Ok(())
}

Rust is hard. Let everyone who tried to learn it but never got the hang of it upvote this post. But Rust gives an agent strong guard rails in the form of types, ownership, ?, cargo check, rustc --error-format=json, rust-analyzer, and a huge corpus of real-world code.

Yes, the agent will argue with the borrow checker. But at the very least, this will be an argument with a reliable mechanism that has been validated over years and by thousands of developers.

If we distill the comparison down to what truly matters to the agent, the outcome is not very rosy for Zero:

But the most honest argument against Zero: agents learn from the past

Vercel says: a language should be learnable on demand.

But an LLM does not learn like a human developer who is given a tutorial. An LLM keeps predicting the next token based on its dataset. If a language does not exist in the past, the model has no "intuition" for it. It only has the prompt, docs, and a feedback loop.

Yes, an agent can read Zero's documentation. Yes, you can add AGENTS.md, skill data, and examples to the repository. Yes, you can run zero check --json, zero fix --plan --json, zero explain NAM003.

But this means the best-case scenario for Zero is not "agents finally have their own language". The best scenario is "we built a small closed-loop environment where an agent can make mistakes multiple times, the compiler corrects them, and a human hopes the final diff makes sense".

This isn't a language revolution. This is a REPL with autocomplete, at the cost of your tokens.

What people are saying

The launch on X got notable attention. In Digg's aggregated cluster for Chris Tate's original post, there are 1.2M views, hundreds of comments, and almost perfectly split sentiment: 49.9% positive vs 50.1% negative. It's surprising there are so many positive responses.

On Reddit, in the r/WebAfterAI discussion, the conversation was more engineering-focused. One comment articulates skepticism well: the effects flavor is interesting, but it's not explained what exactly makes this so useful for agents, since similar linter/checker workflows exist in most languages.
But I want to highlight one comment in particular, because it's literally the thought that's been bothering me to this day: why isn't this a middleware/readable layer built on top of existing languages?

In other words, the general public consensus is roughly as follows: the idea is interesting, but everyone is waiting for someone to explain why we need a brand new language for it instead of standard tools for existing ones.

Conclusion

It’s worth mentioning that overall I like Vercel and their products, as long as I don’t have to pay for them. They made deploying side projects extremely simple and free, launched a great initiative with skills.sh, built a fantastic CLI agent-browser, but they also have some very questionable decisions to their name, this being one of them.

Zero is a solid experiment and an unnecessary programming language.

If a language is “for agents” but isn’t present in agent datasets, it starts off at a disadvantage.
If it’s “learnable on demand” but its syntax changes drastically after just a few days, as if the authors don’t have a clear idea of what they want to build.
If it’s “agent-first” but humans still need to review it at some point, then human readability can’t be discarded as an optional luxury.

Maybe in a year, Zero will turn into a very smart compiler/tooling layer that everyone will cite as an early example of an agent-readable development environment. Maybe Vercel will find a killer use case for it. Or maybe Zero will end up as just another repository that people will open in 2030 with the words: “Oh, remember when we thought AI agents needed their own dedicated programming language?”