Ivan Burazin runs Daytona, the infrastructure company behind 850,000 agent runs per day. His central argument: we're building AI agents wrong. We're giving them Lambda functions and API endpoints when they need actual computers.
The company is growing at 74% month-on-month. That growth rate suggests they're solving a problem developers are actively hitting right now, not building for a future that might arrive.
The Lambda Problem
Most agent frameworks treat compute like a temporary resource. Spin up a function, run the task, tear it down. Stateless, disposable, cheap. That works beautifully for web requests and batch jobs. It falls apart for agents.
An agent isn't a single function call. It's a process that runs over time, maintains state, explores possibilities, backtracks, tries different approaches. It needs a filesystem that persists between steps. It needs installed dependencies. It needs to remember what it tried five minutes ago.
Lambda functions don't do that. They're designed to forget. Every invocation is a fresh start. For agents, that's like trying to solve a puzzle where someone resets the board every time you place a piece.
Burazin's solution is what he calls "stateful, composable computers" - environments that persist, that let agents install tools, that maintain context across tasks. Not VMs in the traditional sense, but something closer to a developer's local machine, accessible via API.
The Economics of Agent Infrastructure
Here's where it gets interesting. Daytona's model isn't just technically different - it's economically different. They're running on bare metal, not cloud VMs. The cost structure changes completely.
Cloud compute pricing is built around human usage patterns - spiky demand, unpredictable workloads, pay-per-use billing. Agents don't follow those patterns. They run continuously or in tight loops. They don't need the flexibility of cloud VMs. They need consistent, cheap compute that doesn't charge per invocation.
Bare metal gives you that. Fixed cost, predictable performance, no cold starts. For workloads that run constantly, it's dramatically cheaper than cloud functions. Burazin didn't share exact numbers, but if you're running 850,000 agent executions daily, the cost difference between Lambda pricing and dedicated hardware is the difference between a sustainable business and a money pit.
What Composable Means Here
The "composable" bit is about modularity. An agent doesn't just need compute - it needs a terminal, a code editor, a package manager, version control, debugging tools. The things developers use to build software.
Daytona's approach is to provide those as composable blocks. Need Git? It's there. Need Python with specific dependencies? Install them once, they persist. Need to run a Docker container inside the agent's environment? That works too.
This is the opposite of serverless philosophy. Serverless says: minimize state, maximize simplicity, pay for what you use. Daytona says: agents need rich, stateful environments, and running them on dedicated infrastructure is cheaper at scale.
Both can be true. It depends on the workload. For one-off tasks, Lambda wins. For agents that run continuously, exploring codebases, debugging issues, iterating on solutions - you need something closer to a real computer.
The Developer Experience Shift
What's interesting about Daytona's growth isn't just the technical architecture - it's that developers are choosing it. 74% month-on-month growth doesn't happen because of marketing. It happens because people try it, it solves their problem better than alternatives, and they tell others.
The shift Burazin is describing is from "AI as API" to "AI as colleague with a workstation". Instead of sending prompts to a model and getting responses, you give an agent access to a full development environment and let it work like a junior developer would - installing tools, running tests, checking results, trying different approaches.
That requires infrastructure that looks more like GitHub Codespaces than AWS Lambda. Persistent, stateful, with a full OS and toolchain. The cost is higher per environment, but the capability is different. It's not about running a single function - it's about running a process that spans hours or days.
What This Means for Builders
If Daytona's growth is representative, we're seeing a split in agent infrastructure. One path optimizes for stateless, disposable compute - great for simple tasks, API calls, quick automations. The other path optimizes for stateful, long-running processes - better for complex workflows, coding tasks, multi-step problem solving.
The economic model matters as much as the technical model. If you're building agents that run frequently, the infrastructure cost becomes the dominant factor. Choosing between cloud functions and bare metal isn't a technical decision - it's a business model decision.
Burazin's argument is that we've been constrained by cloud pricing models designed for human workflows, and agents need something different. The 850,000 daily runs suggest he might be right.
Listen to the full interview for the technical details on how Daytona's sandbox architecture actually works.