Agents have moved from calling APIs to running whole computers. OpenAI's ChatGPT agent completes tasks on its own virtual computer, and Anthropic's computer use tool lets Claude operate a desktop through screenshots, mouse and keyboard.
That puts the agent's machine on the cloud bill, and the line grows with every hour the agent waits. A VM for an AI agent costs its size multiplied by the hours it runs, plus a small charge for the live screen. Solari bills Computer Desktops and their screen-free sibling, AI Sandboxes, per vCPU-hour and per GB-hour, so your bill comes down to the plan, the machine size and how quickly an idle machine pauses. This guide covers what each choice costs, how to keep the bill down, and where agent VM pricing goes next.
Why Does VM Cost Matter More for Agents Now?
Agent VMs now run for hours, and most of those hours are spent waiting. The length of task a frontier agent can finish on its own keeps doubling, so a job that once took a few minutes now runs through an afternoon.
The old pattern was short: a script started a virtual machine, did its work and shut it down. Today an agent stops between steps for a model response, a slow tool call or a person reading the screen, and a machine left running through those gaps bills for every one of them.
That moves cost control from the hourly rate to the machine's lifecycle. The cheapest VM is the one that pauses when it goes quiet and comes back the moment the agent needs it.
How Much Does a VM for an AI Agent Cost on Solari?
Solari bills every vCPU and every GB of memory by the hour, and your plan sets both rates and how many machines run at once. The figure sets out both by plan.
A Solari VM adds $0.02 per hour for its live screen, the VNC view you can watch and take over, or $0.002 on Enterprise. A sandbox has no screen, so it bills compute and memory only. Every plan and rate sits in the Solari plan table.
For a well-equipped machine, a 4 vCPU, 16 GB sandbox costs $0.221 per hour on Professional, before a VM's screen charge. Both rates scale in a straight line, so halving the CPUs and memory halves the price.
How Can You Keep the Bill Down?
You keep the bill down by sizing each machine once and telling it what to do when it goes quiet. These are the moves that save the most, in the order a team makes them:
Pick the smallest size that runs the job. A Solari VM takes 1 to 8 CPUs and up to 16 GB of memory, and starts at 2 CPUs and 2 GB when the create call sets neither. A request above those limits is rejected with a 400 rather than quietly reduced. A paused VM resumes at the size it was created with, so a machine sized once stays sized.
Pause on idle instead of leaving it running. Every action and every open connection resets a VM's idle timeout, and when it runs out the default policy pauses the machine and saves its state. Without timeoutMs set, that happens after 30 minutes, and a paused VM frees its slot on your running limit until it resumes.
Park only for short waits. With parkAfterMs set, a VM's CPUs freeze while its slot, network connection and live stream stay held, so a parked VM still counts against your limit. Pair it with hibernateAfterParkedMs and a long park escalates to a full pause, which keeps quick waits instant and hands long ones back.
Never power off from inside. A VM that runs poweroff or shutdown is deleted along with its disk, so the next run pays again to rebuild its setup. To keep state, pause from your code instead.
Start from a snapshot. Setup time is billed time, so prepare one machine, take a snapshot and start later machines from it with fromSnapshot. Stored snapshots bill at $0.05 per GB-month with the first 10 GB across your organization free, and deleting a snapshot stops its charge the same day.
Let credits cap the month. Every Solari product draws from one credit balance: the Free plan includes $3 a month, and the Starter and Professional fees of $20 and $200 return as the same amount in credits, which refill monthly and do not roll over. At a zero balance new sandboxes and desktops stop launching, and there is no end-of-month overage charge.
What Role Does Solari Play?
Solari runs the machines an agent works on: cloud browsers, AI Sandboxes and Computer Desktops from one account and one API. Your agent brings the model and the logic; Solari prices its machine by size and pauses it when it goes idle.
Rates that follow size. Solari bills sandboxes and VMs by vCPU and memory, so a small machine costs a fraction of a large one. You pay for the machine your agent needs, not a fixed instance tier.
Fast starts that make pausing cheap. A Solari VM starts usually in about a second, and a same-host resume took about 1.3 seconds on staging, five trials, once the pause had finished saving. Pausing an idle machine costs your agent a short wait, not a rebuild.
The cost policy on the create call. Solari takes the idle action, park, hibernation and checkpoint interval as fields when you create a desktop or sandbox, so the policy travels with the job instead of living in a cleanup script. Sandboxes share the same lifecycle as desktops, so one policy covers both.
A screen you can watch. Every Solari desktop comes with a live view you can watch and take over, so you can check an overnight run without stopping it. Work that needs no screen goes to a sandbox and skips the screen charge.
One balance with a hard stop. Browsers, sandboxes, VMs, proxies and captcha solves all draw from one balance. A runaway loop ends at the balance rather than on the invoice.
Sandboxes cost less again: Solari sandboxes are about 1.3x faster than E2B over a full lifecycle and almost 3x cheaper per sandbox hour. For a machine that runs overnight, the long-jobs guide walks through each lifecycle setting, and the Solari launch overview shows how desktops, sandboxes and browsers share one account.
Where Is VM Pricing for Agents Going Next?
Most agent VMs today still bill like servers: on while running, gone when killed. Over the next year that changes in four ways:
Idle stops costing money. Machines will pause when quiet and wake on the next request by default. Paying for idle compute will look as dated as leaving a server on over a holiday.
Sizes chosen per step. Agents will request a small machine for browsing and a large one only for the step that compiles or renders, then hand the large one back.
Snapshots replace setup. Teams will keep a library of prepared machines, signed in and configured, and start every run from one instead of installing from scratch.
Budgets set in code. Spend caps will sit next to an agent's other limits, so a fleet stops at a balance rather than at the end of the month.
What stays human is the judgement about what a job is worth: which agents earn a large machine, which runs deserve the whole night, and when a result justifies the hours behind it. The teams that spend least will set those rules once and let their machines follow them.
Get Started With Solari
Start with one small desktop on a job your agents already run, with pause as its idle action, and read its hours in the console after a week. Solari is the fastest and cheapest way to run cloud browsers and VMs for computer-use agents. Get started with a free account and start running your agents today.
