AI agents are becoming the main users of developer tools, so tools designed only for humans are built for an earlier era.
2
Agent experience means agents can access, understand, and operate digital environments autonomously, without repeatedly handing work back to a person.
3
Daytona built fast, API-first runtimes with headless tools, declarative image building, shared volumes, and parallel execution for AI-generated code.
Summary
Ivan Burazin argues that developer tools need to be designed for AI agents because agents are becoming the main users of software development infrastructure. He defines agent experience as how easily an agent can access, understand, and operate within a digital environment to complete a user's goal. Readable documentation and APIs help, but Burazin says they are insufficient when an agent still needs a human to authenticate, click a button, debug an error, or interpret terminal output. He explains how Daytona built an agent-native runtime, comparing it to the laptop an agent would use. The system starts quickly, exposes its functions through an API, and includes headless tools such as a file explorer, Git client, LSP, and terminal. He also describes declarative image building, shared volumes for large datasets, and parallel machine execution. His practical test is simple: can the agent complete the task from start to finish?
AI agents are becoming the main users of development tools
Burazin says agents will eventually outnumber humans by a very large margin. He points to two figures from the latest Y Combinator batch: 25% of startups said AI writes 95% of their code, and 37% were building agents as their products. These companies were building agents rather than copilots or autocomplete features. Burazin uses this to argue that tools built for human developers are aimed at the past. Tool builders need to ask what their products look like when agents become the primary users.
Agent experience measures autonomous access, understanding, and operation
Burazin introduces agent experience as the continuation of user experience, customer experience, and developer experience. He uses a definition from Sean at Netlify: how easily agents can access, understand, and operate within digital environments to achieve a user-defined goal. Burazin adds the word "autonomously" to each part of that definition. An agent that can do most of a task but must repeatedly fall back to a person has not been fully supported. The test is what happens when there is nobody available to click a button or debug an error.
Authentication, documentation, and APIs remove common barriers for agents
Burazin gives three examples of agent-friendly product design. Arcade lets an agent hand authentication back to the user, so the user can log in without giving the agent a password. Stripe makes documentation available as clean Markdown by appending md to a documentation URL, and Burazin recommends the llms.txt standard for making docs easier to consume. He also calls API-first design the most important of these practices. If an agent cannot see a tool's functionality through a machine-native interface, it will have difficulty using that tool.
Daytona treats an agent's runtime like a human's laptop
Daytona provides secure, elastic environments for running AI-generated code. Burazin compares a Daytona runtime to the laptop a human uses. An agent can run code, analyze data, perform reinforcement learning, use a computer, and even play games inside these environments. Daytona designed the runtime around speed and programmatic control. An interactive agent can start one in about 27 milliseconds, then use an API to turn machines on or off, clone them, or delete them.
Headless development tools keep agents from parsing terminal output
Burazin says Daytona found that agents should not have to interpret terminal output for every operation. Its runtimes come preloaded with headless tools, including a file explorer, Git client, LSP, and terminal. This gives the agent direct ways to work with files, source code, and environments. The design came from customer use cases where an agent could start a runtime and work inside it, but still had to involve a human for some part of the task.
Declarative image building lets an agent create its own environment
A standard Docker image can provide a starting template, and an agent can install a dependency through an API or terminal. Repeating that process for many dependencies wastes time and resources. Burazin says having a human create and publish a new image is slow, while asking an agent to build and push a Docker image can be brittle. Daytona's declarative image builder lets an agent specify a base image, the items to install, and the commands to run. Daytona builds the image and opens a sandbox without requiring a human.
Shared volumes avoid copying large datasets into every isolated environment
Human developers often share data across containers on a local machine. Agents do not have that local context because each runtime is isolated. Burazin describes users who need datasets of about 100 gigabytes in every machine. Downloading or uploading that data through S3 for each environment is inefficient. Daytona volumes let an agent upload data once, then mount it as a network drive across machines. The agent can request a volume of the size it needs and reuse the data across its environments.
Parallel execution lets agents test many approaches at once
A human usually works on one machine, or perhaps two. An agent can fork a machine many times and try different approaches in parallel. Instead of testing one change, deciding it failed, and starting over, the agent can run five, ten, or even many more environments at once before selecting an output. Burazin presents this as a capability that became visible through Daytona's work with users. Agent-native infrastructure needs to support the ways agents actually work, rather than copying human workflows.
"Daytona is basically what a laptop is to a human. That is what a Daytona runtime is for an agent."08:43
Who should watch
You are building an API, SaaS product, or developer tool that AI agents need to operate without constant human help.
Your product has readable documentation and an API, but agents still get stuck on authentication, terminal output, environment setup, or data access.
You are designing runtimes or sandboxes for agents and need examples of capabilities that differ from human developer workflows.
