{"id":90987,"date":"2026-05-17T16:34:52","date_gmt":"2026-05-17T16:34:52","guid":{"rendered":"https:\/\/youzum.net\/vercel-labs-introduces-zero-a-systems-programming-language-designed-so-ai-agents-can-read-repair-and-ship-native-programs\/"},"modified":"2026-05-17T16:34:52","modified_gmt":"2026-05-17T16:34:52","slug":"vercel-labs-introduces-zero-a-systems-programming-language-designed-so-ai-agents-can-read-repair-and-ship-native-programs","status":"publish","type":"post","link":"https:\/\/youzum.net\/ja\/vercel-labs-introduces-zero-a-systems-programming-language-designed-so-ai-agents-can-read-repair-and-ship-native-programs\/","title":{"rendered":"Vercel Labs Introduces Zero, a Systems Programming Language Designed So AI Agents Can Read, Repair, and Ship Native Programs"},"content":{"rendered":"

Most programming languages were designed for humans who read error messages, interpret warnings, and manually trace through stack output to fix bugs. AI agents do none of those things well. They work better with structured data: predictable tokens, stable codes, and machine-parseable repair hints. That gap is what Vercel Labs<\/strong> is trying to close by releasing Zero<\/strong>, an experimental systems language that is faster, smaller, and easier for agents to use and repair. <\/p>\n

What is Zero Language<\/strong><\/h2>\n

Zero<\/strong> is a systems programming language that sits in the same design space as C or Rust. It compiles to native executables, gives you explicit memory control, and targets low-level environments. <\/p>\n

What separates Zero<\/strong> from existing systems languages is that its compiler output and toolchain were designed from day one to be consumed by AI agents, not just human engineers. <\/p>\n

The Agent-First Toolchain<\/strong><\/h2>\n

The core problem Zero<\/strong> addresses is how agents interact with compiler feedback. In a typical development loop involving a coding agent, the agent writes code, the compiler emits an error as unstructured text, and the agent has to parse that text to determine what went wrong and how to fix it. This is fragile \u2014 error message formats change, messages are written for human readers, and there\u2019s no built-in concept of a \u2018repair action.\u2019<\/p>\n

Zero\u2019s <\/strong>CLI emits structured JSON diagnostics by default. When you run zero check --json<\/code>, the output looks like:<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
{\n  \"ok\": false,\n  \"diagnostics\": [{\n    \"code\": \"NAM003\",\n    \"message\": \"unknown identifier\",\n    \"line\": 3,\n    \"repair\": { \"id\": \"declare-missing-symbol\" }\n  }]\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
Each diagnostic carries a stable code<\/code> (e.g., NAM003<\/code>), a human-readable \u30e1\u30c3\u30bb\u30fc\u30b8<\/code>, a line reference, and a repair<\/code> object with a typed repair ID. Humans read the \u30e1\u30c3\u30bb\u30fc\u30b8<\/code>. Agents read the code<\/code> and repair<\/code>. The same CLI command surfaces both \u2014 there is no separate mode or secondary tool to run.<\/p>\n
The toolchain is unified into one binary: zero check<\/code>, zero run<\/code>, zero build<\/code>, zero graph<\/code>, zero size<\/code>, zero routes<\/code>, zero skills<\/code>, zero explain<\/code>, zero fix<\/code>, and zero doctor<\/code> are all subcommands of the same CLI. This matters for agentic workflows because agents don\u2019t need to reason about which tool to invoke for which task.<\/p>\n
Two subcommands are particularly relevant to the repair loop. zero explain <diagnostic-code><\/code> returns a detailed explanation of a given diagnostic code, so an agent can look up NAM003<\/code> without parsing prose documentation. zero fix --plan --json <file-or-package><\/code> emits a structured fix plan \u2014 a machine-readable description of what changes to make to resolve a diagnostic \u2014 rather than requiring the agent to infer the fix from the error message alone.<\/p>\n
zero skills<\/code> serves a different purpose: it provides version-matched agent guidance directly through the CLI. Running zero skills get zero --full<\/code> returns focused workflows covering Zero syntax, diagnostics, builds, packages, standard library use, testing, and agent edit loops \u2014 all matched to the installed compiler version. This is notable because it means agents working with Zero don\u2019t need to scrape external documentation that may be out of sync with the compiler they\u2019re actually running.<\/p>\n
Explicit Effects and Capability-Based I\/O<\/strong><\/h2>\n
One of Zero\u2019s<\/strong> core design decisions is that effects are explicit in function signatures<\/strong>. If a function writes to standard output, accesses the filesystem, or makes a network call, it must declare that through a capability object.<\/p>\n
The canonical entry point in Zero<\/strong> looks like this:<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
pub fun main(world: World) -> Void raises {\n  check world.out.write(\"hello from zeron\")\n}<\/code><\/pre>\n<\/div>\n<\/div>\n
The world: World<\/code> parameter is the capability object that grants access to the outside world. A function that doesn\u2019t receive World<\/code> (or a capability derived from it) cannot perform I\/O \u2014 the compiler enforces this at compile time, not at runtime. There is no hidden global process object.<\/p>\n
The check<\/code> keyword handles fallible operations. If world.out.write(...)<\/code> can fail, check<\/code> surfaces that failure along the call stack. The raises<\/code> annotation on main<\/code> signals that the function can propagate errors \u2014 making error paths visible in signatures rather than buried in runtime exceptions.<\/p>\n
Getting Started<\/strong><\/h2>\n
Installation requires one command:<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
curl -fsSL https:\/\/zerolang.ai\/install.sh | bash\nexport PATH=\"$HOME\/.zero\/bin:$PATH\"\nzero --version<\/code><\/pre>\n<\/div>\n<\/div>\n
The installer downloads the latest binary from the GitHub release and places it in $HOME\/.zero\/bin\/zero<\/code>. Packages are defined with a zero.json<\/code> manifest and source files under src\/<\/code>, initialized with zero new cli <name><\/code>.<\/p>\n
A VS Code extension for .0<\/code> file syntax highlighting ships in the repository under extensions\/vscode\/<\/code>.<\/p>\n
Marktechpost\u2019s Visual Explainer<\/strong><\/h2>\n

\n<\/p>\n
\n
  <\/p>\n
\n
<\/div>\n<\/div>\n
  <\/p>\n
\n
\n
      <\/p>\n
\n
\n          Vercel Labs<\/span>
\n          01 \/ 09 \u00a0\u00b7\u00a0 Overview<\/span>\n        <\/div>\n
\n          Zero<\/span>
\n          The Programming Language
for Agents\n        <\/div>\n
\n          An experimental systems language that gives AI agents structured diagnostics,
\n          typed repair metadata, and machine-readable docs \u2014 alongside sub-10 KiB native binaries.\n        <\/div>\n
\n          Systems Language<\/span>
\n          Agent-Native<\/span>
\n          v0.1.1<\/span>
\n          Apache-2.0<\/span>
\n          Experimental<\/span>\n        <\/div>\n
\n
\n            Released<\/span>
\n            May 15, 2026<\/span>\n          <\/div>\n
\n            Author<\/span>
\n            Chris Tate \u00b7 Vercel Labs<\/span>\n          <\/div>\n
\n            Repo<\/span>
\n            vercel-labs\/zero<\/span>\n          <\/div>\n
\n            File Extension<\/span>
\n            .0<\/span>\n          <\/div>\n<\/div>\n<\/div>\n
      <\/p>\n
\n
\n          Context<\/span>
\n          02 \/ 09 \u00a0\u00b7\u00a0 Why Zero Exists<\/span>\n        <\/div>\n
The Agent Repair Loop Problem<\/div>\n
\n          Most programming languages produce compiler output written for human readers \u2014 unstructured text that AI agents must parse to determine what failed and how to fix it. This creates a fragile loop.\n        <\/div>\n