DX Today | No-Hype Podcast & News About AI & DX
The DX Today Podcast: Real Insights About AI and Digital Transformation
Tired of AI hype and transformation snake oil? This isn't another sales pitch disguised as expertise. Join a 30+ year tech veteran and Chief AI Officer who's built $1.2 billion in real solutions—and has the battle scars to prove it.
No vendor agenda. No sponsored content. Just unfiltered insights about what actually works in AI and digital transformation, what spectacularly fails, and why most "expert" advice misses the mark.
If you're looking for honest perspectives from someone who's been in the trenches since before "digital transformation" was a buzzword, you've found your show. Real problems, real solutions, real talk.
For executives, practitioners, and anyone who wants the truth about technology without the sales pitch.
DX Today | No-Hype Podcast & News About AI & DX
Vercel Zero: The First Systems Programming Language Built for AI Agents Lands as Open Source on GitHub - May 18, 2026
Use Left/Right to seek, Home/End to jump to start or end. Hold shift to jump forward or backward.
Welcome to the DX Today Podcast, your daily deep dive into the AI ecosystem. I'm Chris, and joining me as always is Laura.
SPEAKER_00Chris, today's story is one of the nerdiest, most consequential developer announcements we have covered in weeks. And I have honestly been buzzing about it since I first opened the repository last night around midnight.
SPEAKER_01Okay, well now you absolutely have to tell us what it is, because that is a serious buildup, and the audience is going to want the payoff right at the top of the show.
SPEAKER_00Versal Labs just released an open source systems programming language called Zero, and the genuinely wild part is that it was designed from day one, specifically for AI agents to use as their primary consumers.
SPEAKER_01Hold on, when you say a programming language, designed for agents, do you mean optimized for agents to write it? Or designed so agents can actually read, debug, and repair the resulting code themselves at runtime?
SPEAKER_00That second one, exactly, and that distinction matters enormously. Zero treats the AI coding agent as the primary consumer of the compiler output, the tool chain, and the diagnostics. Humans are explicitly a secondary audience here.
SPEAKER_01That is a genuinely radical inversion of how we have thought about programming languages for the last 50 years. And I want to spend most of this episode unpacking what that actually means in real practice.
SPEAKER_00Let me set the scene first so listeners have the timeline. Versel Labs dropped zero on May 15th, 2026, version 0.1.1 under an Apache 2.0 open source license on GitHub.
SPEAKER_01So it is fully open source from day one, which is a noticeably different posture from how a lot of big platform companies have rolled out experimental language tooling over the past few years in the developer space.
SPEAKER_00Right, and it lives in the versal hyphen labs/0 repository on GitHub. The file extension is. Exactly that. And the same compounding cost is precisely why Vercell cared so much about JSON output and structured diagnostics, which is the second major design decision in Xero and arguably the more philosophically interesting one to discuss.
SPEAKER_01Walk me through that part carefully because I keep hearing developers say current language tool chains routinely break agent loops. And I want to know what specifically goes wrong today before we hear how Xero proposes to fix it.
SPEAKER_00Picture a coding agent doing its job today. It writes a function, hits compile, and the compiler returns a paragraph of beautifully written English prose meant for a human engineer to read and carefully reason about over coffee.
SPEAKER_01And now the agent has to parse that English prose, infer the actual error category, figure out the precise line and column, and decide what the appropriate code edit would be, all of it done probabilistically through a language model.
SPEAKER_00That probabilistic interpretation step is exactly where the loops break. The agent guesses wrong, applies a bad fix, breaks the next compile, and you waste tokens, time, money, and trust chasing a misread error message in circles.
SPEAKER_01So how does Xero actually solve this in a substantive way? Please tell me they did not just slap a JSON flag on an existing compiler and call it a day, because that would be incremental at best.
SPEAKER_00No, it is genuinely much more thoughtful than that surface treatment. Every diagnostic emitted by the Xero compiler is a structured object with a stable error code, a human readable message, a line number, and a typed repair object attached.
SPEAKER_01Give me a concrete example. What would something like the code NAM003 actually mean? And how is that different from the kind of squiggly red underline I would see in a regular IDE working with Rust or TypeScript today?
SPEAKER_00NAMO3 might mean an undefined name error in a specific scope. The crucial thing is that code is stable across compiler versions, so an agent can build reliable, repeatable behavior around it without ever needing to read English again.
SPEAKER_01That stability point is enormous. Because right now, if you fine-tune an agent against today's error messages and tomorrow the wording quietly changes, your entire repair logic silently degrades or breaks outright in production without warning.
SPEAKER_00Exactly the failure mode. And then there is the typed repair object, which is honestly the part that made my eyes light up when I first read through the documentation on the repository wiki very late last night.
SPEAKER_01Repair object, all right? Explain that for the audience, because it sounds like the zero compiler is not just telling the agent what is wrong, but also explicitly proposing the appropriate fix in machine readable, immediately actionable form.
SPEAKER_00That is precisely what it does. And it is a substantial conceptual leap. You can run the command zero fix dash dash plan dash dash JSON, and the compiler returns a typed, structured repair plan that an agent can directly apply.
SPEAKER_01So instead of the agent generating a code diff from scratch and just hoping it works, the compiler itself proposes a structured edit. And the agent can audit, accept, or modify that proposal before applying it to the code base.
SPEAKER_00Yes, and this completely changes the underlying failure mode in a healthy direction. Now, when a loop breaks, it breaks loudly with clean structured signals, not silently with bad text interpretation. Agent debugging suddenly becomes tractable and observable.
SPEAKER_01Let's pivot to the third big design choice in zero, which is honestly the part I personally find the most provocative philosophically and intellectually. The capability-based input-output system that governs side effects everywhere in the language.
SPEAKER_00Okay, so in most existing systems languages today, any function can call essentially any side effect at any time. You can print to ST Doubt, write to the file system, hit the network, all without explicitly declaring any of it anywhere visible.
SPEAKER_01Right, in classical C or even modern Rust, side effects are largely ambient, which is part of why statically analyzing what a function actually does to the outside world has been genuinely difficult for compilers and humans alike forever.
SPEAKER_00Zero takes a hard line on this. If your function does anything at all observable to the outside world, it has to accept a parameter called world, which is an explicit capability object granting that specific access right.
SPEAKER_01So a function that writes to stout literally has world in its signature. A function that touches the file system has world. And any function with no world parameter at all is provably pure by construction, completely free of side effects.
SPEAKER_00Yes, and functions that might fail must also explicitly declare raises in their signature. So failure modes become part of the visible type contract, just like effects. Nothing about what a function actually does is hidden from view anymore.
SPEAKER_01This is huge for agents specifically, because it means an agent can scan a function signature and immediately know exactly what that code is allowed to touch in the outside world with zero ambiguity and zero hidden behavior.
SPEAKER_00That is fundamentally a security and auditability story as much as a development productivity story. Imagine running an autonomous agent on production code and being able to mathematically prove which functions could possibly leak data externally over the network.
SPEAKER_01That kind of static compile time guarantee has been the holy grail in capability-based security research for 30 years. The novel part is that Xero is shipping it inside a deliberately agent-first workflow rather than a research paper.
SPEAKER_00Right. And the broader systems point is that every CLI subcommand in Xero ships with a consistent dash-jSON flag, so the entire toolchain surface is uniformly machine consumable from end to end without any inconsistent edge cases.
SPEAKER_01That kind of internal consistency is the sort of thing that sounds boring in a press release announcement, but it is honestly the difference between a usable agent toolchain and one that quietly falls apart on the edge cases.
SPEAKER_00I do want to be fair to Vercell here, though. They themselves are explicitly calling this experimental and version 0.1.1. So this is not a language anyone should ship a production service on tomorrow morning.
SPEAKER_01That framing is actually completely appropriate, because the real value of zero right now is as a serious design statement about what an AI agent native tool chain could look like at the language level rather than as a finished product.
SPEAKER_00I fully agree. The interesting strategic question is whether other established language ecosystems, Rust, Go, even TypeScript through tooling layers, start adopting these same patterns of structured diagnostics, typed repairs, and machine consumable output over the next year or two.
SPEAKER_01My prediction is yes, and surprisingly quickly, because once one player demonstrates that agent loops measurably improve with JSON diagnostics and typed repair plans, the competitive pressure on every other toolchain maintainer to follow suit becomes impossible to ignore.
SPEAKER_00There is also the larger industry pattern this clearly fits into. We are watching software development tools quietly redesign themselves around AI agents as first-class consumers, not just as humans typing alongside an autocomplete suggestion in their editor. And it absolutely raises some legitimate concerns too. If the entire toolchain is optimized for machines, do humans gradually lose visibility into what is happening? Do we end up reviewing pull requests of JSON diffs instead of actual code?
SPEAKER_01That is a real and serious worry, and I think it has to be designed for explicitly from the start. We cannot accidentally hand the only debugging interface over to agents and leave humans to rubber stamp the output blindly.
SPEAKER_00Right. The healthiest version of this future has agents and humans both being treated as first-class consumers, with great prose diagnostics rendered for humans and equally great structured diagnostics emitted for agents from the very same compiler invocation.
SPEAKER_01Another angle worth considering carefully is the open source dynamic. Apache 2.0 means any toolchain maintainer can study Zero's design choices, fork them outright, or quietly borrow the best ideas into Rust, Go, or any other production language without negotiation.
SPEAKER_00Exactly. And that licensing decision is how good ideas spread fastest in our industry. It is doing real strategic work here. Within 12 months, I genuinely would not be surprised to see at least three other compilers shipping some flavor of structured JSON diagnostics with stable error codes.
SPEAKER_01One thing I want to flag for our listeners is that none of this matters if the agent ecosystem does not actually wire up to Xero's structured output. The language is only as useful as the agent toolkits that learn to consume it.
SPEAKER_00That is exactly the next shoe to drop. I would watch closely for the major agent frameworks, cursor, claude code, cognitions Devon, and the open source alternatives to start publishing adapters that natively understand Xero's JSON diagnostics and typed repair plans.
SPEAKER_01Alright, before we wrap, what is the single most important takeaway you want our listeners to leave with today regarding Vercell Zero and what it might actually mean for the broader programming language and developer tools industry going forward?
SPEAKER_00The big idea is that the compiler is no longer just a tool for humans alone. It is becoming a structured interface for AI agents as well. And Xero is the first serious attempt to design specifically for that reality.
SPEAKER_01And from my side, I would add that even if Xero itself never becomes a mainstream production language, the design patterns it pioneers around capability-based effects and JSON diagnostics will almost certainly stick around in some recognizable form.
SPEAKER_00Agreed completely. Watch this space carefully, follow the versal hyphen labs slash zero repository on GitHub. And if you're building agent workflows today, start seriously thinking now about what your tool chain looks like when machines read everything you ship.
SPEAKER_01Great conversation as always, Laura. Listeners, our show notes for today's episode will include direct links to the GitHub repository and to several of the deep dive write-ups we referenced throughout this conversation today for further reading.
SPEAKER_00Thanks, Chris, and thank you to everyone listening. If you enjoyed today's episode, please share it with a developer friend who is wrestling with agent loops and would genuinely appreciate a clear window into what Versel Zero is attempting here.
SPEAKER_01That's all for today's episode of the DX Today podcast. Thanks for listening, and we'll see you next time.