smol machines vs Modal VM Sandboxes

Both give each agent a Linux VM with its own kernel and Docker inside. smol machines keeps a machine as long as you want and can branch it while it runs, while Modal VM Sandboxes are short-lived machines that end within 24 hours, inside a big serverless AI platform with more regions and bigger bursts.

The companies and products

smol machines

smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.

The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.

Isolation: Hardware-isolated microVM with its own guest kernel (libkrun)
Company: Founded 2026, Y Combinator Spring 2026, San Francisco, team of one listed
Open source: smolvm engine and smol SDK are open source and run on macOS, Linux and Windows hosts
Guests: Linux only; no Windows or macOS guests
Regions: No region field in the cloud create API
Uptime SLA: 99.95% on Pro, Startup and Enterprise

Modal VM Sandboxes

Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.

You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.

Founders: Erik Bernhardsson and Akshat Bubna
Offices: New York, Stockholm and San Francisco
Funding: Over $466M raised
Isolation: Virtual machine per sandbox on Cloud Hypervisor, with its own Linux 7.2 kernel
Generally available: 1 October 2026; early customers launched over 20 million VMs before that
Session length: Default 5 minutes, maximum 24 hours
Compliance: SOC 2 on every plan; HIPAA on Enterprise

Which use cases each one fits

For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “12th cheapest of 345” means 11 of the other 344 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.

Use case and its workload	smol machines: price rank	Modal VM Sandboxes: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker in a VM, but a Modal VM ends within 24 hours and loses files outside a Volume, while smol machines and bochka keep the disk; bochka also adds /dev/kvm, SSH and a desktop.	73rd of 367, with limits $604 a month	84th of 367, with limits $759 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month does not fit Modal's 24-hour cap; smol machines can keep it running, and bochka adds a desktop, a browser and a key proxy.	148th of 366, with limits $1,038 a month	Can't run it	5th cheapest of 366 $657 a month
Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month smol machines fits short code runs well, with a one-minute minimum, a /code endpoint and branches of a warm machine that pay the minimum once.	12th cheapest of 345 $140 a month	Can't run it	186th of 345, with limits $2,000 a month
Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month smol machines starts a stopped machine on the next command, so users can come back to the same one; bochka also keeps a stopped sandbox's disk for free and adds a desktop and hosting on 50 ports.	7th cheapest of 361 $531 a month	Can't run it	Cheapest of 361 $209 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month smol machines branches a running machine with its memory and processes, while Modal's memory snapshots are alpha and end the original sandbox.	111th of 360, with limits $6,978 a month	171st of 360, with limits $16,322 a month	34th of 360, with limits $2,000 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month	36th cheapest of 364 $670 a month	Can't run it	10th cheapest of 364 $200 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Builds that need Android emulators or VMs need /dev/kvm, which smol cloud does not expose, Modal gives only on Team and Enterprise on request, and bochka has on every plan.	66th cheapest of 377 $514 a month	188th of 377, with limits $1,064 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB	216th of 368, with limits $29 a month	Can't run it	18th cheapest of 368 $26 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither smol machines nor Modal VM Sandboxes ship a hosted desktop, so you set up the screen and browser yourself; bochka streams a 60fps desktop with computer use built in.	90th of 369, with limits $156 a month	Can't run it	6th cheapest of 369 $200 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month	176th of 367, with limits $136 a month	Can't run it	7th cheapest of 367 $200 a month
Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month	241st of 346, with limits $242 a month	Can't run it	6th cheapest of 346 $90 a month
Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month	148th of 338, with limits $4,344 a month	Can't run it	71st of 338, with limits $1,800 a month
Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Many attackers in parallel each need a full machine for hours; Modal's 24-hour cap and smol cloud's missing nested virtualization both get in the way, and bochka fits fully.	252nd of 360, with limits $377 a month	294th of 360, with limits $642 a month	2nd cheapest of 360 $200 a month
GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month	Can't run it	Can't run it	Can't run it
macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month	Can't run it	Can't run it	Can't run it

Key features

Feature	smol machines	Modal VM Sandboxes	bochka
Isolation	libkrun microVM with its own guest kernel	VM with its own Linux kernel on Cloud Hypervisor	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Docker inside	Yes; Docker data must live on the machine's ext4 disk	Yes; start dockerd yourself as the entrypoint	Yes, with systemd and root in every sandbox
CPU benchmark (4 vCPU / 8 GB)	Not measured	15.54 runs/s	26.69 runs/s
Longest session	No provider cap; an optional lifetime you set	24 hours (default 5 minutes); continue with a filesystem snapshot	No cap on paid plans; you set the time to live
Stop and keep your files	Filesystem survives a stop and a command wakes it; /tmp is emptied and stopped disk keeps billing	No paused state; a finished sandbox is gone, only Volumes and snapshots keep files	Disk saved every minute and on stop; a stopped sandbox costs nothing
Fork	Branch a running machine with its memory and processes	Snapshot the filesystem into an image; memory snapshots in alpha end the sandbox	Fork a running sandbox with its disk
Nested virtualization	Not exposed in the cloud API; a local smolvm flag only	Team and Enterprise plans only, on request	Yes, /dev/kvm on every plan
Inbound access	Up to 16 published ports through a returned URL; no dedicated IP	Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist	HTTPS URLs for up to 50 ports, token-protected by default, raw TCP, dedicated IP
Outbound rules	Blocked, open, or an allowlist of hosts and CIDR ranges	Block all, IP-range allowlist, domain allowlist (beta)	Open internet, no provider-side allowlist
Desktop and browser	No hosted desktop; a guide shows running your own Chromium	Not offered; an example shows setting up Xvfb and VNC yourself	60fps Linux desktop, Chromium and computer use built in
Coding agents and API keys	Registry images with the Codex CLI; secrets are env variables the guest can read	Examples only; secrets are env variables, or you run your own proxy in a sidecar	Seven agents preinstalled with a prompt, steer and events API; a credentials proxy keeps real keys out
Regions	No region choice in the cloud API	US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x	EU only (Germany, Finland, France), with EU data residency
Machines at once	20 on Standard, 100 on Pro, 1,000 on Startup; stopped machines hold a slot	100 containers on Starter, 5,000 on Team	Starts are paced by plan; the $2,000 plan starts 90 a minute
Self-hosting	Open-source smolvm runs on your laptop or your own servers	No	No

Every feature Battleships tracks (43)

Feature	smol machines	Modal VM Sandboxes	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	Yes	Yes
Root	Not published	Yes	Yes
Systemd	Not published	Yes	Yes
Desktop GUI	No	No	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	No	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	No	Yes
Automatic snapshots	No	No	Yes
Fork/clone	Yes	Yes	Yes
Live fork (no pause)	Yes	Yes	Yes
Memory fork	Yes	Yes	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	Yes	No
Wake on request	Yes	No	No
HTTPS preview URLs	Yes	Yes	Yes
Raw TCP inbound	Not published	Yes	Yes
Public IPv4	No	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	No	No	Yes
Secret proxy for any API	No	No	Yes
Preinstalled agents	Yes	No	Yes
Agent harness API	No	No	Yes
MCP server	Yes	No	No
GPU	No	No	No
Windows	No	No	No
Arm64	Yes	No	No
Self-hosting	Yes	No	No
BYOC	Yes	No	No
Open source	Yes	No	No
Scoped API keys	Not published	Not published	Yes
Spend limits	Yes	Not published	Yes
Usage per sandbox (API)	Yes	Not published	Yes
Audit logs	Not published	Yes	No
SSO	Yes	Yes	No
SOC 2	No	Yes	No
HIPAA	No	Yes	No
EU data residency	No	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

smol machinesNot measured

Modal VM Sandboxes15.54 runs/s

bochka26.69 runs/s

On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, in the same run on 29 September 2026, bochka did 26.69 runs per second and Modal's VM runtime 15.54, so bochka did about 1.7 times the CPU work in the same time. smol cloud has not been run on that test, so there is no comparable number for it; smol machines publishes a boot time under 200ms, which is start time, not CPU speed.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. smol machines has no published run in this suite yet, so there is no like-for-like number to compare.

Pricing in five scenarios

Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.

Scenario	smol machines, a month	Modal VM Sandboxes, a month	bochka, a month
One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days	$25 · Standard	$15 · Starter · with limits	$20 · $20/mo
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$93 · Standard	$178 · Starter · with limits	$26 · $20/mo
50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside	$1,139 · Pro	$2,229 · Starter · with limits	$317 · $20/mo × 3 seats
Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once	$465 · Startup	$792 · Team	$200 · $100/mo × 2 seats
1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month	$1,389 · Startup	$3,193 · Team · with limits	$2,000 · $2000/mo · with limits

smol machines: smol cloud charges $0.04 for every hour a machine runs, plus $0.05 per active vCPU-hour and $0.0162 per active GB-hour of memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.

Modal VM Sandboxes: Modal bills VM Sandboxes by the second for whichever is higher, the CPU and memory you request or what you use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.

Modal VM Sandboxes: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

A Modal VM Sandbox lives at most 24 hours and keeps files only in a Volume or a snapshot, so the workday, always-on and 50-agent scenarios do not fit it, and its 1,000-job burst on Team runs on shared CPU above the request. smol machines caps machines by plan, with stopped ones still holding a slot, so 50 agents need Pro and 1,000 jobs at once need Startup, whose fee comes on top of usage. On bochka the limit that bites is start speed: even the $2,000 plan starts 90 sandboxes a minute, so 1,000 jobs at once queue.

Scenario	smol machines	Modal VM Sandboxes	bochka
One coding agent, workdays	None that bite	files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
One agent that never stops	None that bite	Starter: sessions capped at 24 h files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
50 agents in parallel	None that bite	files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
Sandboxes for your users	None that bite	None that bite	None that bite
1,000 short jobs at once	None that bite	shared vCPUs on this tier (Modal (VM Sandboxes) sells dedicated cores separately as “VM Sandbox, request = size”): heavy, sustained CPU use can be slowed by other tenants	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

Use smol machines when

you want machines that stay as long as you need, live branches of a running machine with its memory, or one open-source VM engine from your laptop to your own servers.

Machines that stay. For agents that keep working past a day: a smol machine has no provider time cap and keeps its files when stopped.
Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, paying the one-minute minimum once.
Open source, laptop to servers. Teams that want the same VM locally, in a hosted cloud and on their own servers can use one open-source engine.

Use Modal VM Sandboxes when

you run huge bursts of short jobs that finish within a day, need regions outside Europe, or already run your models on Modal.

Regions around the world. Teams that need machines in the US, the EU or Asia-Pacific can pin Modal sandboxes to a region.
Very large bursts. Useful for huge waves of short jobs: Modal runs 5,000 containers at once on Team and more on Enterprise.
One platform with your models. Teams that already serve or train models on Modal can keep sandboxes, GPUs and models on one account and one bill.

Where bochka fits

If your agents work for hours or days in a machine they come back to, and need more than a VM boundary, look at bochka. It gives each agent a full VM with /dev/kvm, SSH, a desktop and built-in coding agents, keeps the disk across free stops, and ran faster than Modal's VM runtime on the same CPU test.

A machine that keeps its work

A Modal VM ends within 24 hours and its root disk goes with it unless you write Volume or snapshot code. smol machines keeps files, but stopped disk keeps billing. bochka saves the disk every minute and a stop is free.

Emulators, SSH and real hosting

smol cloud exposes no /dev/kvm and no SSH, with 16 ports and no dedicated IP. Modal gives nested virtualization only on Team and Enterprise after asking support. bochka has /dev/kvm and SSH on every plan, 50 HTTPS ports and raw TCP.

Desktop, agents and keys built in

Neither ships a desktop, so you build the screen stream and browser yourself, and on both real keys sit in env variables a prompt injection can read. bochka has a 60fps desktop, seven agents driven from outside and a credentials proxy.

Use bochka when your agents need a whole machine for days of real work: Docker, emulators, SSH, a desktop and a browser, on a faster VM that keeps its disk, with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: bochka vs smol machines and bochka vs Modal VM Sandboxes.

Questions people ask

Is smol machines cheaper than Modal VM Sandboxes?

In most of our scenarios, yes: one always-on agent costs $93 a month on smol machines against $178 on Modal, and 50 parallel agents cost $1,139 against $2,229. For one agent on workdays Modal is cheaper ($15 against $25), but its files reset between days unless you use a Volume. bochka costs $26 a month for the always-on agent.

Which is faster, smol machines or Modal VM Sandboxes?

There is no comparable CPU number for smol cloud, because it has not been run on the hpc-sandbox-benchmarks test. Modal's VM runtime did 15.54 runs per second at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.

How long can a machine run on each?

A Modal VM Sandbox runs 5 minutes by default and 24 hours at most. smol machines has no provider cap: you can set an optional lifetime or leave a machine running until you stop it. bochka has no session cap on paid plans.

Can I run Docker and Android emulators in each?

Both run Docker inside the VM. For Android emulators you need nested virtualization: smol cloud does not expose it on hosted machines, and Modal offers it on Team and Enterprise after you ask support. bochka exposes /dev/kvm on every plan.

Can smol machines or Modal fork a running machine?

smol machines branches a running machine into children that keep its memory and running processes. Modal can snapshot the filesystem into an image and boot new sandboxes from it, and its memory snapshots are alpha and end the original sandbox. bochka forks a running sandbox with its disk.

Try bochka

Install the CLI, then run bochka new.

Product preview