A runtime for developers and their agents
James Snell
Cloudflare
AI is changing how software is created, but generating more code does not automatically help teams ship better products. Developers still need fast feedback loops, reliable infrastructure, and tools they can understand and trust. Drawing on his experience creating Vue.js and Vite and building VoidZero, Evan You will explore how developer tooling, in particular for web developers, must evolve for an AI-native future. Learn about the move toward unified, high-performance toolchains, the continued importance of open source, and what it takes to build tools used by developers around the world.
0:02Okay, welcome everyone to this talk. So I'm Evan Yeo, creator of Vue .js and Vite and founder of the company called VoidZero. We got acquired by Cloudflare a few months ago. And so now we continue to work on the open source projects that we maintain, especially developer tooling, you know, surrounding the Vite ecosystem. So if you're here, I assume you're some familiar with Vite, right? So we continue to do a lot of work and along the the existing work that we've been doing but this talk is more forward-looking. It's about the some of the thinking that about where JavaScript tooling need to go, developer tooling and specifically JavaScript tooling need to go in the age of coding agents, right?
0:48So I've spent years making open source tools for developers, and we focused a lot on developer experience, but something fundamental is changing, and that is with the rise of AI and coding agents, obviously. So the shift has some pretty significant implications for how we should approach the design of the next generation of developer tools.
1:19So a bit of background first, I started Vite in 2020 because I felt JavaScript development experience was unnecessarily slow. Starting a development server with Webpack, for example, could take minutes, and waiting for a rebuild, seeing a change reflected in the browser, these were the things that would interrupt your flow and just make the development process painful. So Veed demonstrated that with the right architecture, we could dramatically improve the feedback loop. Since then, the ecosystem around Veed has grown tremendously within the vo- with the VoidZero team. So we're pushing performance across a connected stack. OXC as the compiler toolchain foundation. And on top of it, we had a bundler rowdown. On top of rowdown, we have Vite.
2:04Vite was originally written in JavaScript, but we essentially swapped its core with all the Rust toolchain that we've created since then. And on top of Vite, we have the test runner, ViteTest. And we also put everything together into one coherent package called VitePlus. We're now part of Cloudflare and continuing our work. So historically, a lot of our motivation has been about making developers happier and more productive. But the assumptions behind the work are changing. Interestingly, many of the things we are optimizing for humans don't necessarily carry over to agents. So there are some differences. Think about how quickly coding agents have progressed, right? not that long ago uh i probably i still remember like when copilots first shipped in vs code it's just like tab and you get something and i thought it was pretty dumb to be honest i never used it um and a bit later we started seeing people actually writing accepting code with uh written by ai right and uh we we moved on to cli coding agents that can actually understand your repository uh and then start large you know mass refactors actually writing large chunk of new code that you'd actually look at and say hey this is actually pretty good and now we are seeing people doing parallel agent sessions right if you are using cloud code today you probably run you would run multiple sessions on a single
3:36machine and then someone is running like hundreds of parallel sessions in cloud boxes okay so the amount of work doing agents and the the pace the acceleration that we're experiencing is is definitely um unprecedented right so um i don't think we've reached the limits of what agents can do really um so my expectation is that eventually it'll obviously write majority of the new code and if that's true agents are on the way to becoming the primary consumer of developer tooling as well so when we are dealing with something that turns out code at a different pace. We need to rethink how tooling deals with that.
4:22So the fundamental issue here is every development tool that we use today was originally designed for humans, right? So including all the things that we currently work on. So we care about, so as humans, what we care about is like, we need readable error messages. We like pretty... distributed error traces, right? You need like code frames, convenient APIs, familiar command interfaces, ergonomic APIs, you know, aliases to like verbose APIs, etc. None of these things are bad, right? We will continue to supervise our agents, but you know, agents kind of work a bit differently. Agents prefer predictability.
5:08efficiency right for agents it's actually more annoying to have more than one way of doing things it would have to basically say it has to guess your intention like guess your preferences when there are multiple different ways of doing things and it would have to ask you which kind of interrupts the flow
5:27so really agents don't really care if the API is elegant or not as long as it is consistent and it works right it doesn't really need beautifully formatted error messages, it prefers structured output, concise and to the point. It can read compressed JSON just fine. We cannot, right? So what it needs really is very different. So the question becomes, if we were designing a JavaScript tool chain from the ground up, from first principle, just for agents, what would we do differently?
5:59So to answer that question, we need to first kind of look at how agents really work, right? uh it's it's a loop we all know agents working a loop and it receives a task explored the code base identify what needs to change and then perform some edits but writing code is just one part of the question right llms are good at just chunking out tokens but uh it needs to verify the work that's really the the tricky and important part um so the first step is the change needs to be reflected. So when you are doing web development with Vite, right, hot module replacement during development really helps shortening that feedback loop. Once you edit, you can see the browser updates. That matters for an agent trying to expect the browser as much as it matters for a person.
6:49If something fails, the agent needs to understand why, make another change, and repeat. So unlike a human developer, agents can go through this loop pretty much endlessly, continuously, without need-and-break losing concentration. It can also launch multiple independent tasks at the same time. So instead of optimizing just for the time it takes to build the application once, we also need to think about the cumulative cost of all the operations within those loops. So the performance of the toolchain directly affects how quickly an agent can converge on a correct solution. That's much more important optimization target. it might initially appear. So here we try to visualize why a tighter feedback loop with faster verification performance really matters, right?
7:36When human developers saving a few hundred milliseconds per linked run or per test run, it's rather negligible because we spend so much time thinking, staring our screen thinking about a problem before type code and when we type code we also type rather slowly compared to an mlm just it just spits out the code immediately so but agents can execute the same operations hundreds of thousand times faster than us so every extra second it stops to wait for something to run to verify whether it has done correctly it gets magnified it gets much more significant when we think about how it loops faster than humans.
8:29So, and when you are running multiple agents concurrently, this compounds, right? So there's like two level of compounding. There's the loop of a single agent instance running, and then it compounds even more when you have multiple parallel agents. There's also a more subtle benefit. When verification is cheap, an agent can afford to verify more frequently. right i don't know if you've run into cases where you start a new project the agents is like working very efficiently initially because the test test case size is small right agents love to write tests and the test suite grows and grows and at a certain stage you realize a lot of the time it's just like i'm waiting for this whole test suite to pass and then one test fails it just like runs try to fix it and runs the whole thing again and just keeps doing that So, faster tooling allows agents also to be more willing to do these verifications.
9:30Sometimes you'd have to tell it, like, hey, don't run the whole test suite. Like, only run a focus test suite or only run the test of the failed test. Like, you have to intervene to force it to do less verification, right? But if the verification is fast enough, then you don't have to do that. You can let agents do as much verification as it wants. to ensure correctness.
9:53So that brings us to the next major point, right? So agents are already good at producing code. The harder problem is knowing whether the code actually works. And so in this verification loop, this ties into the actual tools that we are working on. So in the OXC stack, we have a formatter called OX4Mac. Formatters basically just makes your code look more... consistent across the place this is again a process of removing opinion if you've done JavaScript in the past you probably remember the days when we argue about whether you should use semicolons or not or whether you should have a space before your function calls parents etc things from prettier came along everybody agreed like let's just use a formatter and stop arguing about it and similarly it's very similar to how agents because agents really don't care about how the code looks as long as can understand it.
10:50So, but making it consistent is important because it affects how agents are able to search for certain code patterns, right? And then there's OX links. It's a linkter static analysis to catch errors before you actually run the code and it's much cheaper. So when you have a link rules, why do we have a need a linkter when the agent can just read the code because it's much cheaper and faster right a lot of common errors can be caught with with the linter in milliseconds compared to sending all the tokens to into the lm and then let it read the code and then figure out oh i made a mistake here um vtest is the test runner and has ability to only run the tests that's affected by the the files that you changed and then v10 rolldown is the the layer that actually builds your application actually makes it runnable inside the browser so the agent can look at what is actually being rendered in the browser and verify that, okay, like this button is actually working.
11:59Another aspect in the verification loop is flaky tests. I think this deserves a lot more attention than we do right now. So... For a human developer, a flaky test is annoying at best, right? You might run the test and you recognize the pattern, you rerun it and you'd be like, okay, fine, it passes along. I don't know how many times you see your agent do the same. At least I've experienced so many times, it annoys me to no end. My agent is like, the whole test suite passed, but there's like these three tests that failed, I ran them again, they passed. So I guess they are good. But I'm like, are you sure? So having these flakiness inside your tests Every time basically your your agent has to run it multiple times for it to actually confirm It's just flakiness. It's not the test actually failing, right?
12:51So Like I said slower verification loops just like compounds and slower things down significantly so So for agents flaky tests are very very damaging. So our work on VTES gives us some direct place to address this. Fast tests are valuable, and the test harness also needs to make the result trustworthy, right? So we think that test harnesses need to be designed much more aggressively around determinism. That includes better isolation, control over clocks and randomness. Most of a lot of the flakiness in tests comes from, you know, timers. You're guessing like okay, if we wait 100 milliseconds, this probably has finished.
13:38Well, in most cases, especially when you have multiple agents running, when you have CPU contention, you know, things can take longer than expected and your test starts to get flaky. So there are practices in testing that would allow you to actually control the timer and basically sort of control the time slices so that timers become deterministic. So We want to provide primitives so that you can use that to write tests in a way that, you know, kind of get rid of these undeterminism from a test so that your test becomes less flaky. In an agentic workflow, the reliability of verification is just as important as speed.
14:23So beyond verification, we should also consider the interfaces our tools expose. Historically, developer experience... being major design priority uh experience right when we talk about experiences like how you feel as humans we will feel annoyed when the error message is cryptic and you cannot understand it or uh it's maybe it's exactly the same message just like formatted very ugly and you'll be like well you should put more care into this but agents don't care as long as understands where the problem is um so a lot of that flexibility that we or you know variants or options preferences that we put into tooling design were specifically products of human preference so agents don't really have preferences right it's trained on all the things that we already know um and they don't have subjective uh choices um so if you give the agent something it will just follow the rules so um when we design options from like essentially when we are designed if we were to design a new tool from the ground up I would remove all the subjective preference options from it the only options left should be about facts should about expected behavior right so the configuration the tool requires should describe facts about the project like let's say should I put this file here or not it's not about like
15:54do I, you know, do I add semicolons to the formatter? That's just one extreme example.
16:03But there's also the case where we can extend this idea even into the frameworks that we use because sometimes developers would argue about which styling CSS styling option you should use, which framework you should use. In a lot of cases, I think with agents, you should prefer... Consistency across your stack rather than I like this or versus I don't like it The same principle applies to language and API design, right? We should so People have been exploring like languages designed for agentic work and the common theme is Make the sound make the types type system sound Make invalid states difficult or even impossible to express So you remove a whole category of problems that could arise from the agent just, you know, being loose with assumptions.
17:00Of course, humans still need to understand understandable interfaces. Ultimately, sometimes you still need to look at the code, although maybe not as often as we used to. But when designing an agent -facing API, predictability should take priority over subjective preference. Okay. So another example is CodeSearch. Right now a lot of agent tool calls, when you ask it to explore a code base, sometimes it just casts a file, or it uses grep, it all uses the bash tool, CLI tools that is available in the system, and read whole chunks of files. It's kind of like brute force reasoning, essentially. Right?
17:45But if you have a tool- chain that's dedicated to a language and that like we say when we um when we build all these tools like bundlers or test runners they all involve especially with the typescript there's typescript itself right it already builds an sort of a module graph of your project it understands every ast node that exists in a module imports exports relations where the function is called other things that is exposed to us humans through IDEs and LSPs, right? They already exist in the toolchain, but right now, I don't think there's a anything that exposed these understandings or refactoring capabilities to agents in a interface that makes sense.
18:31So when agents interface with our today's tools, right, it has a bundler, but you know, all the information is locked inside it like a black box. The only way the agent can leverage the tool is Like, say, build a thing and let me see if it works, right? But if the toolchain, for example, exposed either an NCP or a code mode NCP that tells the agent, hey, I have all these, you know, APIs that you can call. And if you want to understand, for example, where is this function used across their code base and how is it being used? What parameters are being passed into it, right? A dedicated toolchain can give you that answer. extremely efficiently, but if you don't have that capability, your agents actually have to explore the code base, read tons of files, consume tons of tokens just to figure out that answer, right?
19:20So this is about token efficiency, both the efficiency of the speed of execution and also the amount of tokens it needs to consume to complete a certain task. So we think future of toolchains should expose if structural and semantic search directly for agents so things you to do in an IDE like search for function tell me like how how it is being used across the code base should be a question that your tool chain can answer to your agents directly the goal is to make interaction for the code base more accurate more efficient and less token intensive okay so we should also try to improve runtime observability for agents so this has to be about like what is specifically for web applications right right now you may have seen your agent try to drive a playwright or chromium instance and try to click around simulate a human just to understand how your application works a toolchain could embed a client inside the inside the browser and expose the same kind of capabilities directly through the same interface it talks to the tool like I said in the last step, we could expose all of these things together through the toolchain.
20:40So the agent has just one interface, it knows it can do all these things to verify the state of your application.
20:50I think I'm going over time, so I have to go a bit faster. So another important aspect, right now a lot of the work we're doing in toolchains are exposed to CLIs. So you run build first, then you run length, then... run tests every step is actually repeating a lot of work you're repeatedly trying to reading files parsing them resolving and then building module graph over and over again for different tasks so an ideal architecture should put all of these things in a persistent in -memory module graph where each task is actually querying from the same source of truth and being able to reuse as much work as possible uh extending this idea and further into for parallel agents, right? A lot of time parallel agents are working off the same base commits.
21:37They're branching into different states with minor differences where the large chunk of the code base is actually shared across work trees. It is possible to build the daemon, the module graph that I set earlier in a persistent, immutable data structure way so that it structurally shares the same bits that is shared across work. trees. This would drastically reduce the amount of memory usage when you have multiple parallel agents from the same system. It also makes creating new work trees much cheaper and much faster. So then there's how do we evaluate whether all of these designs is actually working, right? So there are different criterias that we need to look at. So this is important when we are, as tooling authors, we need to design eval.
22:27We need to design a system that allows us to quantify whether a certain change or certain design actually improves the token efficiency of your tools So I don't have time to dig too deep into here but this is about you know the methodology that we need to use in order to design a better tools and some concrete examples the CFCLI It's um, it is designed with agency in mind and it Exposes structural interfaces for agents to explore the whole API surface itself because the API surface is so big Right, so it actually gives the agents a command to list all the possible commands that can use and then for a specific command It gives you structured data back a schema about that command So the agents can instantly understand how to use it and then finally when you actually run that command it gives you structured results back That's also designed for agent understanding And then we also have Void, which is a deployment platform built on top of it.
23:30It's essentially, the aim is to connect the pieces of the full-stack application, server code, data, platform resources, and deployment all together. So there is a session from Michael that actually demos how you use Void to deploy things to the cloud, and we've open-sourced Void a while ago. Unfortunately, I don't have enough time to like talk into details of how void works But it's another it's it it's kind of the the combination We put together a lot of things we learned about agentic development into this solution so that your agents can deploy apps extremely fast So we've started optimizing the human development loop the rise of agents makes the speed and reliability of that loop even more important We think the future toolchain should provide predictable interfaces shared project understanding and evidence about code that and its runtime behavior we're working on improving our existing tools with these ideas in mind and we're also exploring a new experiment that is sort of designed from first principle with all of these ideas considered so now at cloudflare our team can extend their work all the way from a code change to a running verified application so please stay tuned for the thing that i'm working on it takes a lot of these ideas i talked about into that and hopefully it'll you know uh turn into a thing that you can use and actually be much more efficient at agentic coding with job script thank you
James Snell
Cloudflare
Matt Kane
Cloudflare
Ryan Dahl
Cloudflare
Be the first to know when registration opens and the agenda goes live.
--- title: "Developer tooling in the agentic era" url: "https://www.cloudflare.com/connect/2026/session/developer-tooling-in-the-agentic-era" year: 2026 --- # Developer tooling in the agentic era [Watch session](https://www.cloudflare.com/connect/2026/session/developer-tooling-in-the-agentic-era) ## Session details - **Track:** Web Performance & Frameworks - **Topics:** AI transformation, Agentic AI & MCP, App modernization - **Solution areas:** Developer Platform ## About this session AI is changing how software is created, but generating more code does not automatically help teams ship better products. Developers still need fast feedback loops, reliable infrastructure, and tools they can understand and trust. Drawing on his experience creating Vue.js and Vite and building VoidZero, Evan You will explore how developer tooling, in particular for web developers, must evolve for an AI-native future. Learn about the move toward unified, high-performance toolchains, the continued importance of open source, and what it takes to build tools used by developers around the world. ## Speakers - [Evan You](https://www.cloudflare.com/connect/speakers/2447012) — Creator of Vue.js and Vite, Cloudflare ## Transcript [0:02] Okay, welcome everyone to this talk. So I'm Evan Yeo, creator of Vue .js and Vite and founder of the company called VoidZero. We got acquired by Cloudflare a few months ago. And so now we continue to work on the open source projects that we maintain, especially developer tooling, you know, surrounding the Vite ecosystem. So if you're here, I assume you're some familiar with Vite, right? So we continue to do a lot of work and along the the existing work that we've been doing but this talk is more forward-looking. It's about the some of the thinking that about where JavaScript tooling need to go, developer tooling and specifically JavaScript tooling need to go in the age of coding agents, right? [0:48] So I've spent years making open source tools for developers, and we focused a lot on developer experience, but something fundamental is changing, and that is with the rise of AI and coding agents, obviously. So the shift has some pretty significant implications for how we should approach the design of the next generation of developer tools. [1:19] So a bit of background first, I started Vite in 2020 because I felt JavaScript development experience was unnecessarily slow. Starting a development server with Webpack, for example, could take minutes, and waiting for a rebuild, seeing a change reflected in the browser, these were the things that would interrupt your flow and just make the development process painful. So Veed demonstrated that with the right architecture, we could dramatically improve the feedback loop. Since then, the ecosystem around Veed has grown tremendously within the vo- with the VoidZero team. So we're pushing performance across a connected stack. OXC as the compiler toolchain foundation. And on top of it, we had a bundler rowdown. On top of rowdown, we have Vite. [2:04] Vite was originally written in JavaScript, but we essentially swapped its core with all the Rust toolchain that we've created since then. And on top of Vite, we have the test runner, ViteTest. And we also put everything together into one coherent package called VitePlus. We're now part of Cloudflare and continuing our work. So historically, a lot of our motivation has been about making developers happier and more productive. But the assumptions behind the work are changing. Interestingly, many of the things we are optimizing for humans don't necessarily carry over to agents. So there are some differences. Think about how quickly coding agents have progressed, right? not that long ago uh i probably i still remember like when copilots first shipped in vs code it's just like tab and you get something and i thought it was pretty dumb to be honest i never used it um and a bit later we started seeing people actually writing accepting code with uh written by ai right and uh we we moved on to cli coding agents that can actually understand your repository uh and then start large you know mass refactors actually writing large chunk of new code that you'd actually look at and say hey this is actually pretty good and now we are seeing people doing parallel agent sessions right if you are using cloud code today you probably run you would run multiple sessions on a single [3:36] machine and then someone is running like hundreds of parallel sessions in cloud boxes okay so the amount of work doing agents and the the pace the acceleration that we're experiencing is is definitely um unprecedented right so um i don't think we've reached the limits of what agents can do really um so my expectation is that eventually it'll obviously write majority of the new code and if that's true agents are on the way to becoming the primary consumer of developer tooling as well so when we are dealing with something that turns out code at a different pace. We need to rethink how tooling deals with that. [4:22] So the fundamental issue here is every development tool that we use today was originally designed for humans, right? So including all the things that we currently work on. So we care about, so as humans, what we care about is like, we need readable error messages. We like pretty... distributed error traces, right? You need like code frames, convenient APIs, familiar command interfaces, ergonomic APIs, you know, aliases to like verbose APIs, etc. None of these things are bad, right? We will continue to supervise our agents, but you know, agents kind of work a bit differently. Agents prefer predictability. [5:08] efficiency right for agents it's actually more annoying to have more than one way of doing things it would have to basically say it has to guess your intention like guess your preferences when there are multiple different ways of doing things and it would have to ask you which kind of interrupts the flow [5:27] so really agents don't really care if the API is elegant or not as long as it is consistent and it works right it doesn't really need beautifully formatted error messages, it prefers structured output, concise and to the point. It can read compressed JSON just fine. We cannot, right? So what it needs really is very different. So the question becomes, if we were designing a JavaScript tool chain from the ground up, from first principle, just for agents, what would we do differently? [5:59] So to answer that question, we need to first kind of look at how agents really work, right? uh it's it's a loop we all know agents working a loop and it receives a task explored the code base identify what needs to change and then perform some edits but writing code is just one part of the question right llms are good at just chunking out tokens but uh it needs to verify the work that's really the the tricky and important part um so the first step is the change needs to be reflected. So when you are doing web development with Vite, right, hot module replacement during development really helps shortening that feedback loop. Once you edit, you can see the browser updates. That matters for an agent trying to expect the browser as much as it matters for a person. [6:49] If something fails, the agent needs to understand why, make another change, and repeat. So unlike a human developer, agents can go through this loop pretty much endlessly, continuously, without need-and-break losing concentration. It can also launch multiple independent tasks at the same time. So instead of optimizing just for the time it takes to build the application once, we also need to think about the cumulative cost of all the operations within those loops. So the performance of the toolchain directly affects how quickly an agent can converge on a correct solution. That's much more important optimization target. it might initially appear. So here we try to visualize why a tighter feedback loop with faster verification performance really matters, right? [7:36] When human developers saving a few hundred milliseconds per linked run or per test run, it's rather negligible because we spend so much time thinking, staring our screen thinking about a problem before type code and when we type code we also type rather slowly compared to an mlm just it just spits out the code immediately so but agents can execute the same operations hundreds of thousand times faster than us so every extra second it stops to wait for something to run to verify whether it has done correctly it gets magnified it gets much more significant when we think about how it loops faster than humans. [8:29] So, and when you are running multiple agents concurrently, this compounds, right? So there's like two level of compounding. There's the loop of a single agent instance running, and then it compounds even more when you have multiple parallel agents. There's also a more subtle benefit. When verification is cheap, an agent can afford to verify more frequently. right i don't know if you've run into cases where you start a new project the agents is like working very efficiently initially because the test test case size is small right agents love to write tests and the test suite grows and grows and at a certain stage you realize a lot of the time it's just like i'm waiting for this whole test suite to pass and then one test fails it just like runs try to fix it and runs the whole thing again and just keeps doing that So, faster tooling allows agents also to be more willing to do these verifications. [9:30] Sometimes you'd have to tell it, like, hey, don't run the whole test suite. Like, only run a focus test suite or only run the test of the failed test. Like, you have to intervene to force it to do less verification, right? But if the verification is fast enough, then you don't have to do that. You can let agents do as much verification as it wants. to ensure correctness. [9:53] So that brings us to the next major point, right? So agents are already good at producing code. The harder problem is knowing whether the code actually works. And so in this verification loop, this ties into the actual tools that we are working on. So in the OXC stack, we have a formatter called OX4Mac. Formatters basically just makes your code look more... consistent across the place this is again a process of removing opinion if you've done JavaScript in the past you probably remember the days when we argue about whether you should use semicolons or not or whether you should have a space before your function calls parents etc things from prettier came along everybody agreed like let's just use a formatter and stop arguing about it and similarly it's very similar to how agents because agents really don't care about how the code looks as long as can understand it. [10:50] So, but making it consistent is important because it affects how agents are able to search for certain code patterns, right? And then there's OX links. It's a linkter static analysis to catch errors before you actually run the code and it's much cheaper. So when you have a link rules, why do we have a need a linkter when the agent can just read the code because it's much cheaper and faster right a lot of common errors can be caught with with the linter in milliseconds compared to sending all the tokens to into the lm and then let it read the code and then figure out oh i made a mistake here um vtest is the test runner and has ability to only run the tests that's affected by the the files that you changed and then v10 rolldown is the the layer that actually builds your application actually makes it runnable inside the browser so the agent can look at what is actually being rendered in the browser and verify that, okay, like this button is actually working. [11:59] Another aspect in the verification loop is flaky tests. I think this deserves a lot more attention than we do right now. So... For a human developer, a flaky test is annoying at best, right? You might run the test and you recognize the pattern, you rerun it and you'd be like, okay, fine, it passes along. I don't know how many times you see your agent do the same. At least I've experienced so many times, it annoys me to no end. My agent is like, the whole test suite passed, but there's like these three tests that failed, I ran them again, they passed. So I guess they are good. But I'm like, are you sure? So having these flakiness inside your tests Every time basically your your agent has to run it multiple times for it to actually confirm It's just flakiness. It's not the test actually failing, right? [12:51] So Like I said slower verification loops just like compounds and slower things down significantly so So for agents flaky tests are very very damaging. So our work on VTES gives us some direct place to address this. Fast tests are valuable, and the test harness also needs to make the result trustworthy, right? So we think that test harnesses need to be designed much more aggressively around determinism. That includes better isolation, control over clocks and randomness. Most of a lot of the flakiness in tests comes from, you know, timers. You're guessing like okay, if we wait 100 milliseconds, this probably has finished. [13:38] Well, in most cases, especially when you have multiple agents running, when you have CPU contention, you know, things can take longer than expected and your test starts to get flaky. So there are practices in testing that would allow you to actually control the timer and basically sort of control the time slices so that timers become deterministic. So We want to provide primitives so that you can use that to write tests in a way that, you know, kind of get rid of these undeterminism from a test so that your test becomes less flaky. In an agentic workflow, the reliability of verification is just as important as speed. [14:23] So beyond verification, we should also consider the interfaces our tools expose. Historically, developer experience... being major design priority uh experience right when we talk about experiences like how you feel as humans we will feel annoyed when the error message is cryptic and you cannot understand it or uh it's maybe it's exactly the same message just like formatted very ugly and you'll be like well you should put more care into this but agents don't care as long as understands where the problem is um so a lot of that flexibility that we or you know variants or options preferences that we put into tooling design were specifically products of human preference so agents don't really have preferences right it's trained on all the things that we already know um and they don't have subjective uh choices um so if you give the agent something it will just follow the rules so um when we design options from like essentially when we are designed if we were to design a new tool from the ground up I would remove all the subjective preference options from it the only options left should be about facts should about expected behavior right so the configuration the tool requires should describe facts about the project like let's say should I put this file here or not it's not about like [15:54] do I, you know, do I add semicolons to the formatter? That's just one extreme example. [16:03] But there's also the case where we can extend this idea even into the frameworks that we use because sometimes developers would argue about which styling CSS styling option you should use, which framework you should use. In a lot of cases, I think with agents, you should prefer... Consistency across your stack rather than I like this or versus I don't like it The same principle applies to language and API design, right? We should so People have been exploring like languages designed for agentic work and the common theme is Make the sound make the types type system sound Make invalid states difficult or even impossible to express So you remove a whole category of problems that could arise from the agent just, you know, being loose with assumptions. [17:00] Of course, humans still need to understand understandable interfaces. Ultimately, sometimes you still need to look at the code, although maybe not as often as we used to. But when designing an agent -facing API, predictability should take priority over subjective preference. Okay. So another example is CodeSearch. Right now a lot of agent tool calls, when you ask it to explore a code base, sometimes it just casts a file, or it uses grep, it all uses the bash tool, CLI tools that is available in the system, and read whole chunks of files. It's kind of like brute force reasoning, essentially. Right? [17:45] But if you have a tool- chain that's dedicated to a language and that like we say when we um when we build all these tools like bundlers or test runners they all involve especially with the typescript there's typescript itself right it already builds an sort of a module graph of your project it understands every ast node that exists in a module imports exports relations where the function is called other things that is exposed to us humans through IDEs and LSPs, right? They already exist in the toolchain, but right now, I don't think there's a anything that exposed these understandings or refactoring capabilities to agents in a interface that makes sense. [18:31] So when agents interface with our today's tools, right, it has a bundler, but you know, all the information is locked inside it like a black box. The only way the agent can leverage the tool is Like, say, build a thing and let me see if it works, right? But if the toolchain, for example, exposed either an NCP or a code mode NCP that tells the agent, hey, I have all these, you know, APIs that you can call. And if you want to understand, for example, where is this function used across their code base and how is it being used? What parameters are being passed into it, right? A dedicated toolchain can give you that answer. extremely efficiently, but if you don't have that capability, your agents actually have to explore the code base, read tons of files, consume tons of tokens just to figure out that answer, right? [19:20] So this is about token efficiency, both the efficiency of the speed of execution and also the amount of tokens it needs to consume to complete a certain task. So we think future of toolchains should expose if structural and semantic search directly for agents so things you to do in an IDE like search for function tell me like how how it is being used across the code base should be a question that your tool chain can answer to your agents directly the goal is to make interaction for the code base more accurate more efficient and less token intensive okay so we should also try to improve runtime observability for agents so this has to be about like what is specifically for web applications right right now you may have seen your agent try to drive a playwright or chromium instance and try to click around simulate a human just to understand how your application works a toolchain could embed a client inside the inside the browser and expose the same kind of capabilities directly through the same interface it talks to the tool like I said in the last step, we could expose all of these things together through the toolchain. [20:40] So the agent has just one interface, it knows it can do all these things to verify the state of your application. [20:50] I think I'm going over time, so I have to go a bit faster. So another important aspect, right now a lot of the work we're doing in toolchains are exposed to CLIs. So you run build first, then you run length, then... run tests every step is actually repeating a lot of work you're repeatedly trying to reading files parsing them resolving and then building module graph over and over again for different tasks so an ideal architecture should put all of these things in a persistent in -memory module graph where each task is actually querying from the same source of truth and being able to reuse as much work as possible uh extending this idea and further into for parallel agents, right? A lot of time parallel agents are working off the same base commits. [21:37] They're branching into different states with minor differences where the large chunk of the code base is actually shared across work trees. It is possible to build the daemon, the module graph that I set earlier in a persistent, immutable data structure way so that it structurally shares the same bits that is shared across work. trees. This would drastically reduce the amount of memory usage when you have multiple parallel agents from the same system. It also makes creating new work trees much cheaper and much faster. So then there's how do we evaluate whether all of these designs is actually working, right? So there are different criterias that we need to look at. So this is important when we are, as tooling authors, we need to design eval. [22:27] We need to design a system that allows us to quantify whether a certain change or certain design actually improves the token efficiency of your tools So I don't have time to dig too deep into here but this is about you know the methodology that we need to use in order to design a better tools and some concrete examples the CFCLI It's um, it is designed with agency in mind and it Exposes structural interfaces for agents to explore the whole API surface itself because the API surface is so big Right, so it actually gives the agents a command to list all the possible commands that can use and then for a specific command It gives you structured data back a schema about that command So the agents can instantly understand how to use it and then finally when you actually run that command it gives you structured results back That's also designed for agent understanding And then we also have Void, which is a deployment platform built on top of it. [23:30] It's essentially, the aim is to connect the pieces of the full-stack application, server code, data, platform resources, and deployment all together. So there is a session from Michael that actually demos how you use Void to deploy things to the cloud, and we've open-sourced Void a while ago. Unfortunately, I don't have enough time to like talk into details of how void works But it's another it's it it's kind of the the combination We put together a lot of things we learned about agentic development into this solution so that your agents can deploy apps extremely fast So we've started optimizing the human development loop the rise of agents makes the speed and reliability of that loop even more important We think the future toolchain should provide predictable interfaces shared project understanding and evidence about code that and its runtime behavior we're working on improving our existing tools with these ideas in mind and we're also exploring a new experiment that is sort of designed from first principle with all of these ideas considered so now at cloudflare our team can extend their work all the way from a code change to a running verified application so please stay tuned for the thing that i'm working on it takes a lot of these ideas i talked about into that and hopefully it'll you know uh turn into a thing that you can use and actually be much more efficient at agentic coding with job script thank you ## Related sessions - [A runtime for developers and their agents](https://www.cloudflare.com/connect/2026/session/a-runtime-for-developers-and-their-agents) - [EmDash: The secure WordPress successor for humans and agents](https://www.cloudflare.com/connect/2026/session/emdash-the-secure-wordpress-successor-for-humans-and-agents) - [Self-hosting Durable Objects](https://www.cloudflare.com/connect/2026/session/self-hosting-durable-objects) ## More from Connect - [All sessions](https://www.cloudflare.com/connect/) - [Get notified for Connect 2027](https://www.cloudflare.com/connect#2027)