If you've run a coding agent for a while, you know the failure mode: it edits the wrong line, the syntax checks out but the logic is off, and three files are broken before you notice. 

The reason is that every language your agent touches was designed for humans to read, so the agent ends up diffing text and guessing, same as we do.

Vercel Labs just shipped an experiment that flips this. 

It's a language called Zero, and it stores your program as a graph database instead of text files. Let’s dive into it.

Before We Begin

Zero: Vercel Labs' experimental language where the semantic graph is the program itself. Agents patch nodes instead of editing text. Currently on v0.2.1, Apache 2.0.

Fylla: Autofills job applications on LinkedIn, Naukri, Workday and Greenhouse, writes AI cover letters tailored to each job, and prepares ATS-ready resumes.

zero: It gives your AI access to thousands of tools, APIs, and services, letting you go from prompt to project with no configuration.

Zero sits in the same space as C or Rust. There's no garbage collector / hidden allocator and nothing implicitly async, so what you write is what runs. 

It compiles down to native binaries under 10 KiB, which makes it feel like a lighter Rust where the borrow checker is present but runs less strict.

The real difference is where the program lives. 

In Zero, the program is stored in zero.graph, which is a structured fact database rather than text a parser has to read. 

Declarations, types, calls, edges, imports all live there as nodes with IDs.

Agents work with that graph through zero query and zero patch. 

The compiler validates every patch the moment it's submitted, and any edit that's invalid or stale gets rejected before it touches the store.

Here's the traditional agent loop:
agent writes text → check → format → build → inspect failures → repeat

And here's Zero's:
agent queries graph → submits checked patch → compiler accepts or rejects → agent runs validation → human reviews projection if needed

The compiler catches a bad edit before it lands rather than after.

Every Zero program keeps zero.graph as the actual source of truth. Query it:

and you get structured node output:

The agent targets #expr_653eeb6e by its ID. 

Every patch carries the expected current value as a guard, so if the graph changed since the agent last queried it, the patch gets rejected instead of landing silently on top of stale state.

You don't read graph dumps in the normal workflow. Zero generates .0 projection files that look like readable source:

That file is src/main.0, and it's a projection of zero.graph rather than the source.

When you want to review what an agent built:

If you edit the projection by hand:

The rule is simple. Agents author through zero query and zero patch, humans review through projections. You can edit a projection directly, though that isn't the usual path.

Install:

zero doctor confirms your environment is ready, and zero targets shows what you can compile to.

Load agent skills matched to your exact compiler version:

Worth doing before every session. 

The skills ship bundled with the binary rather than fetched from a web guide that may have gone stale, so when your version changes the skills change with it.

Init a new package and build the minimal program:

You just told an agent two things through patch ops: add the main function, and add a write call inside it. 

The compiler validated both before they landed, and the result is the hello from zero binary.

Review what got built:

You'll see the readable projection, which is what you hand to a human reviewer or paste into a PR.

Now build a real example, the CRM API:

The examples directory covers the full progression from hello.graph to add.graph to json-api-router.graph and then the full crm-api/ package. 

Run them in order, since each one exercises a different part of the graph.

When the compiler hits an error:

The output is structured JSON with stable error codes rather than human-readable prose. 

An agent can read NAM003, know it's an unknown identifier, and pick up the repair plan attached to it. 

No LLM inference goes into interpreting the error, because the compiler tells the agent what to fix.

zero fix --plan --json extends this by emitting the repair plan directly, and the agent just executes it.

Build for production:

zero size reports what was retained, the section sizes, and why, which helps when an agent needs to explain binary size back to you.

Zero is early. 

The borrow checker isn't Rust-grade, no package registry exists yet, and cross-compilation works on a documented subset of targets rather than all of them. 

Open issues on GitHub are climbing, dozens of them as of this week.

This isn't a production dependency, and Vercel Labs says so directly. Run it in isolated workspace, as the practical ceiling today is greenfield. 

Migrating an existing TypeScript or Rust codebase over isn't really on the table yet, so the point right now is to build something small from scratch and get a feel for what the agent-native model actually does in a live edit loop.

I don't much care whether Zero wins as a language, as most experiments like this don't. 

The point it proves is what interests me.

Rust's borrow errors are long and detailed because a human has to understand them. 

Your agent doesn't read them that way, it skims prose it was never meant to read and guesses at the fix. Zero hands the agent a stable error code, the exact node that broke, and a repair plan instead. 

It's the first compiler I've seen ship that as a real output. 

The zero skills command does the same thing for guidance, pinning it to the exact compiler version installed so the agent reads the current spec rather than an outdated blog post.

Zero itself might go nowhere, but the JSON diagnostic loop is good engineering regardless, and it reads like a spec sheet for what TypeScript, Rust, and Go should already be building for agents. 

None of them do yet.

Try it: in an isolated folder, run curl -fsSL https://zerolang.ai/install.sh | bash, then walk the examples from hello.graph up to crm-api/ and watch the agent patch the graph instead of the text. 

Hit reply and tell me whether the loop feels different, because I'm still deciding.

Until next time,
Vaibhav 🤝🏻

If you read till here, you might find this interesting

#Partner 1

Home furniture brand Blu Dot blew up on CTV with help from Roku Ads Manager. Here’s how:

After a test campaign reached 211,000 households and achieved 1,010% ROAS, the brand went all in to promote its annual sales event. It removed age and income constraints to expand reach and shifted budget to custom audiences and retargeting, where intent was strongest.

The results speak for themselves. As Blu Dot increased their investment by 10x, ROAS jumped to 2,308% and more page-view conversions surpassed 50,000.

“For CTV campaigns, Roku has been a top performer,” said Claire Folkestad, Paid Media Strategist, Blu Dot. “Comping to our other platforms, we have seen really strong ROAS… and highly efficient CPMs, lower than any other CTV partner we've worked with.”

Using Roku Ads Manager, the campaign moved from a pilot to a permanent performance engine for the brand.

Learn More

#Partner 2

Join the Fin and AWS team on July 9 to see how you can scale customer support with AI. Save your spot.