Zero Makes the Program Graph the Source of Truth
Vercel Labs' experimental language lets agents query and patch semantic program structure, while keeping readable source as a human review surface.
The 60-second version
Zerolang makes a semantic program graph the compiler's source of truth and gives AI agents checked query-and-patch operations over it.
Key points
- Humans can still review readable `.0` projections, but agents normally operate on `zero.graph` through compiler commands.
- Graph hashes, expected values, shape checks, and type checks can reject stale or invalid edits before they reach the program store.
- The implementation is public under Apache 2.0 and currently lists v0.3.4 as its latest release.
- The project is explicitly experimental and should be evaluated only in isolated, non-sensitive workspaces.
Verdict. Zero is not ready for production adoption, but its graph-as-API model is a credible direction for making coding-agent loops less ambiguous.
Zero changes the unit an AI agent edits. Instead of treating source lines as the program, Vercel Labs' experimental Zerolang makes a compiler-owned semantic graph the source of truth. Agents query that graph and submit checked patches; people review a readable `.0` projection.
The core shiftThe graph is the program
Traditional coding agents edit text, run tools, and infer meaning from diagnostics. Zerolang stores symbols, node IDs, calls, types, effects, ownership facts, capabilities, imports, and target facts in `zero.graph`. The `.0` source remains readable, but the project treats it as a projection for human review and occasional manual editing.
| Traditional agent loop | Edit source text, format, compile, inspect failures, then try another text edit. |
|---|---|
| Zerolang loop | Query semantic nodes, submit a checked graph patch, validate the task, then expose a readable projection. |
| Source of truth | The compiler-owned `zero.graph`, rather than the projected source file. |
| Human role | Ask for outcomes, review projections, and approve behavior; the graph model does not remove review. |
Checked editsPatches behave more like transactions
A patch can target a semantic node and field while carrying the expected graph hash and old value. Stale hashes, unexpected values, invalid shapes, and type errors can fail before the program store is changed. That reduces line-number drift and blind search-and-replace errors.
The useful analogy is a checked database transaction: the agent proposes a semantic change, and the compiler accepts or rejects it against the current program state.
This is not a proof that the requested feature is correct. The agent can still misunderstand a requirement, introduce unsafe behavior, or pass inadequate tests. Graph checks improve the editing interface; they do not replace runtime isolation, code review, dependency controls, or security testing.
What existsA public implementation, not just a concept
The official repository documents `zero query`, `zero patch`, `zero check`, `zero test`, and `zero run`, plus explicit import and export commands for moving between the graph and its text projection. Version-matched skills are bundled so an agent can use guidance aligned with the installed compiler.
Why it mattersCompiler semantics could become an agent API
Even if Zerolang never becomes a mainstream systems language, its interface is a useful signal. Coding agents are more reliable when tools expose stable semantic objects, preconditions, and structured failures instead of forcing a model to repeatedly reconstruct meaning from prose and line-oriented diffs.
Practical takeExperiment with the interface, not production adoption
- For agent and compiler builders: test it in a disposable repository and measure stale-patch handling, projection quality, and task success.
- For application teams: keep production code on mature toolchains, but ask whether your compiler, linter, and refactoring stack exposes machine-readable semantic operations.
- For security teams: treat agent permissions, sandboxing, dependency trust, and review as separate controls; a graph-first language does not collapse those risks.
The thing to watch is not whether everyone starts writing `.0` files. It is whether checked semantic edits become a standard interface between compilers and coding agents.