Solari and every other sandbox vendor now sell the same thing: a machine for code an AI agent writes. Model providers ship code execution as a built-in tool, so every agent that parses a file, runs a test or builds a report needs a machine to do it on, and the bill for those machines grows with every run.
Solari and Archil price that machine differently. Solari bills sandbox compute per vCPU-hour and per GB-hour from one credit balance, with rates that fall at every plan step, and the same balance pays for browsers and desktops. Archil bills sandbox compute per vCPU-hour and per GiB-hour, plus storage, tool calls and outbound data, against a monthly minimum. This guide goes line by line through what each charge pays for and what the same work costs on Solari.
Why Does Sandbox Pricing Matter More in 2026?
A sandbox used to be a side cost: a developer opened one, ran a script and closed it. Agents changed the pattern. One task can start a sandbox per step, keep it alive while a model thinks, and run next to hundreds of other tasks at once.
That puts three things in charge of the bill: the rate per hour of compute, how much of the plan fee pays for capacity you never use, and what happens when usage runs past the plan. A rate that looks small per hour adds up across a fleet that runs every day, and a plan that keeps billing past its limit turns a runaway agent into an invoice.
What Does Archil Charge For?
Archil starts from storage. It builds durable disks for AI, with hot data on SSD and cold data in object storage, and runs sandboxes and tool calls beside them. Its pricing has five lines:
Monthly minimum: Archil's Developer and Team plans each carry a monthly minimum, and usage counts toward that minimum rather than adding to it. A quiet month bills the minimum; a busy month bills the usage. Free has hard caps and no overage, so a free account simply stops when it hits them.
Sandbox compute: Archil meters CPU per vCPU-hour and memory per GiB-hour on what a running sandbox is allocated, at one rate across Developer and Team. Stopping or pausing a sandbox stops the compute charge. This is the line that grows fastest when agents run in parallel.
Serverless tool calls: Archil prices tool calls per 1,000, with execution included, where one call runs Bash, Python or Node against a disk and exits. For short, stateless steps this is the cheapest way to run code on Archil, because no sandbox stays up between calls. Model inference stays on your model provider's bill.
Storage: Archil bills active storage per GiB-month on paid plans, and charges archive storage on managed disks unless a disk syncs to your own Amazon S3 bucket. Files outlive the sandbox and mount over POSIX, which is why teams pick Archil, and this line is where that durability is paid for.
Data out: Archil charges per GB for data transferred out of Archil, while transfer within Archil is free. An agent that ships large outputs back to your own servers pays this line on every run.
The plan also sets how many agents work at once: Archil's Developer plan runs 20 concurrent sandboxes and 1,000 file systems, and Team raises both.
What Does the Same Work Cost on Solari?
Solari bills a sandbox for its size while it runs, at $0.0245 per vCPU-hour and $0.0077 per GB-hour on the Professional plan, plus snapshot storage above a free allowance. There is no monthly minimum on top of usage: the plan fee comes back as credits.
Memory follows the same curve in Solari's sandbox rates: $0.0165 per GB-hour on Free, $0.011 on Starter, $0.0055 on Team and $0.00055 on Enterprise. A growing fleet gets cheaper per hour each time it moves up a plan.
Solari's Starter plan is $20 a month with $20 of credits, Professional is $200 with $200 of credits, and the Free plan includes $3 of credits a month. Credits refill monthly and don't roll over; credit you top up yourself doesn't expire.
What Role Does Solari Play?
Solari is the runtime an agent's code works in: sandboxes, cloud browsers and desktops from one API and one bill. Here is what that does for the cost of a fleet:
Spend that stops where you set it: when your balance reaches zero, new sandboxes and desktops stop launching until you top up, so there is no end-of-month overage charge. A runaway agent loop costs what was in the account, never more.
Machines sized to the step: you size each Solari sandbox by vCPUs and memory and pay for that size only. For the lightest steps, the shared isolation tier is cheaper and starts faster, with each sandbox fenced off from its neighbours by namespaces and a cgroup.
State without paying to keep it running: pause saves memory and processes, and resume brings the sandbox back exactly as it was. Snapshots bill at $0.05 per GB-month with the first 10 GB free across your organization, and one snapshot starts as many ready copies as you need.
Durable folders across machines: volumes keep a live folder of data that outlives any single sandbox, for datasets, package caches and build output. Delete the ones you no longer need and their storage stops.
A fleet that grows with you: Solari runs 2 sandboxes at once on Starter, 10 on Professional and 50+ on Team, and up to 100,000 on Enterprise. Moving up a plan raises the limit and lowers the rate at the same time.
The same credit balance pays for Solari desktops and cloud browsers, so an agent that runs code and then operates a website stays on one account. Solari is also about 1.3x faster than E2B on a sandbox's full lifecycle and almost 3x cheaper per sandbox hour.
Where Is Agent Sandbox Pricing Going Next?
Sandbox pricing is moving from machines to work done. Over the next year, four changes look likely:
Per-step prices: more vendors will price a single tool call, as Archil already does, alongside hourly compute for longer tasks.
Storage and compute split: teams will keep files on durable disks or volumes and treat compute as disposable, so storage becomes its own buying decision.
Spend limits as a feature: finance teams will ask for hard stops on agent spend the way they ask for budgets on cloud accounts.
Fleet contracts: companies running agents at scale will buy compute on contract, at rates a fraction of self-serve.
What stays human is the shape of the job: how big each sandbox should be, what to keep and what to delete, and which agent runs are worth paying for at all.
Choosing Between Archil and Solari
Choose Archil when files are the product: shared disks across many machines, data that lives in your own bucket, and short stateless tool calls priced per 1,000. Choose Solari when compute is the main line on the bill, when your agents also need a browser or a desktop, and when you want spend to stop at a balance you set. Archil is the storage specialist, built around a durable shared filesystem; Solari is the broader runtime and moves faster on speed and price.
A companion piece, Solari vs Archil: Speed, Price and Fit, covers the head-to-head beyond pricing, and Introducing Solari covers the whole platform.
Get Started With Solari
Start by pricing one real job: run your agent's busiest task in a Solari sandbox for a week and compare the bill line by line. Solari is the fastest and cheapest way to run cloud browsers and VMs for coding and data agents. Get started with a free account and start running your agents today.
