# AX Is the Only Experience That Matters

Ivan Burazin, Daytona | AI Engineer World's Fair 2025 | 15:25

Source: https://www.youtube.com/watch?v=e9sLVMN76qU
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/ax-is-the-only-experience-that-matters
Published: 2025-07-24
Tags: agent-skills, agents, computer-use, deployment, developer-experience

## TL;DR
- AI agents are becoming the main users of developer tools, so tools designed only for humans are built for an earlier era.
- Agent experience means agents can access, understand, and operate digital environments autonomously, without repeatedly handing work back to a person.
- 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?

## Key ideas
### AI agents are becoming the main users of development tools
[00:01](https://www.youtube.com/watch?v=e9sLVMN76qU&t=1s)
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
[01:55](https://www.youtube.com/watch?v=e9sLVMN76qU&t=115s)
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
[02:58](https://www.youtube.com/watch?v=e9sLVMN76qU&t=178s)
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
[08:03](https://www.youtube.com/watch?v=e9sLVMN76qU&t=483s)
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
[09:38](https://www.youtube.com/watch?v=e9sLVMN76qU&t=578s)
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
[10:37](https://www.youtube.com/watch?v=e9sLVMN76qU&t=637s)
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
[11:49](https://www.youtube.com/watch?v=e9sLVMN76qU&t=709s)
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
[12:48](https://www.youtube.com/watch?v=e9sLVMN76qU&t=768s)
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.

## Notable quotes
- "If you're building dev tools for humans, you're basically building for the past." (01:32)
- "The best way for an agent to interact with any tool is through a machine native interface." (04:50)
- "Daytona is basically what a laptop is to a human. That is what a Daytona runtime is for an agent." (08:43)
- "If your agent can't use your product in the future absolutely no one will." (14:49)

## Tools & references mentioned
- Daytona
- Codeanywhere
- Infobip
- Twilio
- Netlify
- Arcade
- Stripe
- Neon
- Superbase
- MCP
- Docker
- GitHub
- Y Combinator
- Matt, co-founder of Netlify
- Sean from Netlify
- Swix

## 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.

## Related talks

- [Developer Experience in the Age of AI Coding Agents](https://aietalks.com/talks/developer-experience-in-the-age-of-ai-coding-agents) (Max Kanat-Alexander, Capital One, 18:20)
- [Your Attention Is the Bottleneck, Not Your Agents](https://aietalks.com/talks/your-attention-is-the-bottleneck-not-your-agents) (Zack Proser, WorkOS, 25:17)
- [Software Fundamentals Matter More Than Ever](https://aietalks.com/talks/software-fundamentals-matter-more-than-ever) (Matt Pocock, 18:26)
- [Everything We Knew About Software Has Changed](https://aietalks.com/talks/everything-we-knew-about-software-has-changed) (Theo Browne, @t3dotgg, 16:02)
- [AI Leadership](https://aietalks.com/talks/ai-leadership) (Alex Lieberman, Morning Brew and 10X & Kath Korevec, Google Labs & Katelyn Lesse, Anthropic & Michele Catasta, Replit & Lisa Orr, Zapier & Steve Yegge, Sourcegraph and AMP & Gene Kim, IT Revolution & Bill Chen & Brian Fioca, OpenAI & Martin Harrysson & Natasha Maniar, McKinsey & Yegor Denisov-Blanch, Stanford & Itamar Friedman, Qodo & Olive Song, MiniMax & Asaf Bord, Northwestern Mutual & Lei Zhang, Bloomberg & Samir Mody, The Browser Company & Max Kanat-Alexander, Capital One & Arman Hezarkhani, 10X & Justin Reock, DX & Dan Shipper, Every & Mel Lutzky, Graphite, 8:16:05)