In 2026, AI agents run the code they write, and every run needs a machine of its own. The sandbox has become one of the fastest-growing lines on an engineering bill, and Daytona raised its Series B to build a cloud for agents on that demand.
Daytona prices that machine by the resource: it charges per second for the vCPU, memory and disk a sandbox reserves, with no monthly fee. Solari bills the same resources for less, and a Solari sandbox is almost 3x cheaper than Daytona per sandbox hour at list price. This guide covers each line on a Daytona bill, what an idle sandbox costs, how the rates compare with Solari and how to keep the bill down.
Why Does Sandbox Pricing Matter Now?
Agents used to borrow a developer's laptop or a shared CI runner. Now each run gets its own isolated virtual machine or container, a team may run thousands of them at once, and many stay alive for hours while the agent waits on a model or a person.
That changes how you read a rate card. A price per vCPU-hour looks small until a fleet of agents holds reserved memory overnight. Three questions decide the bill: what you pay while a sandbox runs, what you pay while it sits idle, and how many sandboxes you can run at once.
What Does Daytona Charge For?
Daytona bills for the resources a sandbox reserves, by the second, from a prepaid wallet with no plan fee. Five lines make up a Daytona bill:
Compute and memory. Daytona says a running sandbox costs $0.0504 per vCPU-hour and $0.0162 per GiB-hour of memory, with $200 in free compute to start. Daytona bills reserved resources, not used ones, so a sandbox sized for its peak pays the peak rate for every second it runs.
Disk. Daytona bills storage by the GiB-hour beyond a small free allowance. Disk is the line that keeps billing after a sandbox stops, so a finished sandbox you forget about still costs money until you archive or delete it.
Idle sandboxes. Daytona bills a stopped or paused sandbox for reserved disk only, and archiving a container stops billing altogether. Pause and resume, which keep memory, work only on VM sandboxes; the default class is a container, which you stop and start instead.
Windows and GPUs. Daytona prices Windows sandboxes with a per-vCPU surcharge and GPU sandboxes by the GPU-hour. Free credits do not cover GPU sandboxes, so GPU work draws on paid balance.
Credits and tiers. Organizations move up usage tiers as they verify and top up their wallet. Each tier unlocks a larger shared pool of vCPU, memory and storage for all running sandboxes, so the tier you reach sets how many sandboxes run at once.
For a team running agents in production, the tier decides how many sandboxes run at once, and the rate decides what each one costs.
How Does Daytona Pricing Compare to Solari?
Solari charges less than Daytona for every vCPU-hour and every GB-hour of memory, on its self-serve Professional plan and again on Team.
Solari's Professional plan is $200 a month, and the whole fee comes back as usage at Solari's per-second rates. Team cuts those rates further on a custom contract, and memory follows the same pattern as compute.
On the 4 vCPU, 8 GB size most vendors compare, Solari Team runs a sandbox for $0.114 an hour, the rate behind the multiple above. A fleet that holds its sandboxes all day feels that gap on every invoice.
Smaller teams start lower. Solari's Free plan includes $3 of monthly credits, and Starter costs $20 a month, all of it usable as credit. Credits refill each month and don't roll over, and Solari never bills past your balance, so there is no end-of-month overage charge.
Isolation differs too. Every Solari sandbox is a microVM of your own by default, while Daytona runs containers by default and offers a full virtual machine with its own kernel as a separate class.
What Can You Do to Lower Your Sandbox Bill?
Size, idle time and setup time drive most of the bill on either platform. Four habits cut it:
Right-size every sandbox. Both vendors bill the size you reserve, so start small and grow only the jobs that need it. On Solari you choose 1 to 8 vCPU at create time, and the size sticks across pause and resume, so a sandbox never comes back larger than you asked.
Pause what waits. Pause a Solari sandbox and its memory and processes are saved; resume it and your agent picks up exactly where it stopped. Set an idle timeout so an agent waiting on a model or a reviewer pauses on its own instead of running all night.
Shut down what is done. A stopped Solari sandbox keeps its files, not its running state, and a one-shot job can be set to shut down on idle instead of pausing. On Daytona, delete or archive finished sandboxes so their disk stops billing.
Snapshot once, fork many. Take a snapshot of a sandbox after setup and fork it for each attempt, so every agent starts from a ready machine instead of reinstalling packages on the clock. Solari bills snapshot storage at $0.05 per GB-month, with the first 10 GB free.
What Role Does Solari Play?
Solari is the infrastructure an agent runs on: cloud browsers, sandboxes and desktops from one API. Your agent brings the logic; Solari gives it a machine to work in at a lower rate.
A machine of its own for every agent. Each Solari sandbox is a dedicated microVM by default, and the hardened tier blocks all outbound network for code you don't trust. You never share a VM with another organization, on any tier.
Ready when the agent is. A Solari VM is ready usually in about a second, and a paused VM doesn't count against your plan's limit on running VMs. You can give every task a fresh machine and pause the ones that wait.
From one agent to a fleet. Solari supports up to 100,000 sandboxes or desktops at once on Enterprise. You can run a whole eval or test suite in parallel instead of queueing it.
One balance for every surface. Browsers, sandboxes and desktops draw on one credit balance and one bill. A coding agent that checks its work in a browser pays $0.07 per browser hour on Professional, with no second vendor to set up.
Desktops follow the same model for computer-use agents: a full Linux computer with a screen your agent can see and operate, billed by size plus $0.02 an hour for the live screen.
Where Is Agent Compute Pricing Heading?
Agent compute is still priced like general cloud compute. Over the next year that changes in four ways:
Prices that follow the agent's state. Running, paused and stopped machines already bill differently on both platforms. Agents will be built to spend most of their life in the cheapest state that still resumes fast.
Fleets as the unit. Teams will buy capacity for thousands of concurrent machines, and the concurrency limit will weigh as much as the hourly rate.
CPU as the scarce resource. Daytona's chief executive told Fortune he expects a CPU crunch as agent fleets grow, which puts pressure on every vendor's rate card.
One account for code, web and screen. Agents that write code, browse and operate desktop apps through computer use will run on one bill rather than three.
What stays human is the budget call: which jobs deserve a large machine, how long an agent may wait, and when a run is worth what it costs.
Solari or Daytona: Which Should You Choose?
Choose Solari when your agents run sandboxes and browsers together and you want a lower rate on every vCPU-hour, a microVM per sandbox by default and one bill for every surface. Daytona is the more established vendor with the larger ecosystem; Solari is the younger company and moves faster on speed and price.
Get Started With Solari
Start with one job, such as the test runs your coding agent already does: move it to a Solari sandbox and compare a week of bills. Solari is the fastest and cheapest way to run cloud browsers and VMs for coding agents. Get started with a free account and start running your agents today.
