Modal vs smol machines
Modal runs short-lived gVisor sandboxes next to its GPUs, in regions around the world, for up to 24 hours each. smol machines runs each agent in its own microVM with no session cap, and can branch a running machine with its memory or run the same VM on your own servers.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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.
- Uptime SLA
- 99.95% on Pro, Startup and 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. “19th cheapest of 345” means 18 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 | Modal: price rank | smol machines: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker and a disk that lasts, which smol machines has and Modal's default sandbox does not; boat ranks 3rd with a desktop and coding agents on top. | Can't run it | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent hits Modal's 24-hour limit and smol machines keeps billing its base fee every running hour, while boat ranks 5th with a desktop, a browser and no session cap. | 196th of 366, with limits $1,924 a month | 148th of 366, with limits $1,038 a month | 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 Both fit short code runs well: smol machines ranks 12th with a one-minute minimum, and Modal ranks 19th with fast starts, while boat's start limits push it far down. | 19th cheapest of 345 $181 a month | 12th cheapest of 345 $140 a month | 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 All three fit; smol machines wakes a stopped machine on the next command, Modal adds GPUs, and boat ranks 1st because a stopped sandbox keeps its disk and costs nothing. | 11th cheapest of 361 $811 a month | 7th cheapest of 361 $531 a month | 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 Modal ranks 5th for RL rollouts because it is built for huge bursts of short sandboxes, while smol machines can branch one prepared machine with its memory into many rollouts. | 5th cheapest of 360 $19,038 a month | 111th of 360, with limits $6,978 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 | 59th cheapest of 364 $1,244 a month | 36th cheapest of 364 $670 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month smol machines runs Docker inside every VM while Modal needs its VM runtime for Docker, and boat ranks 4th with Docker and /dev/kvm in every sandbox. | 126th cheapest of 377 $1,793 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 138th of 368, with limits $23 a month | 216th of 368, with limits $29 a month | 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 Modal nor smol machines hosts a desktop, so you build your own screen stack, while boat ranks 6th with a 60fps desktop and computer use built in. | 98th of 369, with limits $183 a month | 90th of 369, with limits $156 a month | 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 | 177th of 367, with limits $136 a month | 176th of 367, with limits $136 a month | 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 | 267th of 346, with limits $394 a month | 241st of 346, with limits $242 a month | 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 | 223rd of 338, with limits $8,795 a month | 148th of 338, with limits $4,344 a month | 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 | Can't run it | 252nd of 360, with limits $377 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 Modal rents GPUs from T4 to B300 next to its sandboxes, and neither smol cloud nor boat has GPUs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | smol machines | boat |
|---|---|---|---|
| Isolation | gVisor by default; VM runtime with its own kernel since October 2026 | libkrun microVM with its own guest kernel | Full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Yes, with Docker data on the machine's ext4 disk | Yes, in every sandbox |
| Longest session | 24 hours (default 5 minutes) | No provider cap; an optional lifetime you set yourself | No cap on paid plans (default TTL 1 h, changeable) |
| Stop and keep your files | No paused state; a finished sandbox is gone, only Volumes keep files | Filesystem survives a stop; stopped disk keeps billing | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | Snapshot the filesystem into an image; memory snapshots in alpha end the sandbox | Branch a running machine with its memory and processes | Fork a running sandbox with its disk, without stopping it |
| Wake on request | No | A command or terminal starts a stopped machine | No; a stopped sandbox is started by API |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None on the hosted cloud | None |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Not exposed in the cloud create API | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Not offered; an example shows how to set up VNC yourself | No hosted desktop; a guide shows running your own Chromium | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents and API keys | Examples only; secrets are environment variables or a proxy you run in a sidecar | Registry images with the Codex CLI; cloud secrets are environment variables the guest can read | Seven agents preinstalled with a prompt and steer API; a credentials proxy keeps real keys out |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | Up to 16 published ports; no SSH, no dedicated IP | HTTPS URLs for up to 50 ports, raw TCP, SSH and a dedicated IP |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Regions | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | No | Open-source smolvm runs on your laptop or your own servers | No |
Every feature Battleships tracks (43)
| Feature | Modal | smol machines | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | 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 | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | 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 | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB on 29 September 2026, boat finished 26.69 runs per second and Modal's default gVisor sandbox 12.79, so boat did about twice the work. smol machines has not been run on that test, so there is no comparable CPU score for it; it publishes a boot time under 200ms, which measures start time, not speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | smol machines, a month | boat, 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 | $15 · Starter · with limits | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $93 · Standard | $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 | $2,229 · Starter · with limits | $1,139 · Pro | $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 | $792 · Team | $465 · Startup | $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 | $3,193 · Team · with limits | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of the CPU and memory you request or what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region costs 1.15x to 1.75x.
smol machines: smol cloud charges $0.04 for every hour a machine runs plus the CPU and 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.
smol machines: boat charges one hourly rate per machine size, by the second, only while a sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and only Volumes keep files, so the workday, always-on and fleet scenarios do not fit, and the 50-agent fleet also needs Docker, which the default sandbox lacks. Modal's 1,000-job burst runs on shared vCPUs that other tenants can slow. smol machines fits all five scenarios, but caps how many machines you hold by plan (20, 100, 1,000), so 50 agents need Pro and the burst needs Startup. boat's limit is starts: the burst queues above 90 starts a minute and exceeds the daily start limit.
| Scenario | Modal | smol machines | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | 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 |
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, must run in the US or Asia-Pacific, or are huge bursts of short jobs that finish in minutes.
- GPUs on the same platform. If your agent trains or runs models, Modal rents GPUs from T4 to B300 next to its sandboxes; smol cloud has none.
- Regions around the world. Modal runs in the US, EU and Asia-Pacific and can pin a sandbox to a region; smol cloud has no region choice.
- Very large bursts. For huge fan-outs of short jobs, Modal runs up to 5,000 containers on Team, against 1,000 machines on smol's Startup plan.
Use smol machines when
your agents run for days in their own microVM, you branch running machines with their memory, or you want to self-host the same VM.
- A VM that keeps running. smol machines has no provider session cap and Docker in every VM, so long agent work is not cut off at 24 hours.
- Live branches with memory. For RL and test fan-out, smol branches a running machine with its memory and processes and wakes stopped machines on the next command.
- Open source, run it anywhere. Teams that want one VM from laptop to their own servers can run the open-source smolvm engine, which Modal has no equivalent of.
Where boat fits
If your agents work for hours or days, building, testing and clicking through what they made, look at boat. Each sandbox is a full VM with Docker, /dev/kvm, a desktop and coding agents built in, it keeps its disk for free when stopped, and it ran about twice as fast as Modal's default sandbox in the same CPU test. Modal stays the pick for GPUs and huge bursts, and smol machines for self-hosting and memory branches.
A computer that keeps its work for free
Modal sandboxes end within 24 hours and lose anything outside a Volume. smol machines keeps the filesystem but bills the disk while stopped. A boat sandbox saves its disk every minute and costs nothing stopped.
Emulators, a desktop and a browser
Neither hosts a desktop, so you build VNC or Chromium yourself, and nested virtualization is on request on Modal's VM runtime and missing on smol cloud. boat has /dev/kvm, a 60fps desktop and computer use in every sandbox.
Agents you drive, keys they cannot leak
On both, secrets sit in environment variables the guest can read, unless you run your own sidecar proxy on Modal. boat keeps real keys in a credentials proxy for any HTTPS API and lets you drive agents inside from outside.
Use boat when your agents need a whole machine for real work: Docker, emulators, SSH, a desktop and a browser, coding agents driven from outside, keys that never enter the sandbox, and a disk kept free when stopped. Compare it one to one: boat vs Modal and boat vs smol machines.
Questions people ask
Is Modal cheaper than smol machines?
Mostly no. One agent that never stops costs $93 a month on smol machines against $178 on Modal, and 50 parallel agents $1,139 against $2,229. Modal is cheaper for one agent on workdays ($15 against $25), but its files reset between days unless you use a Volume. boat costs $26 and $317 for the first two.
Which is faster, Modal or smol machines?
We cannot say for CPU work: smol machines has not been run on the same benchmark. Modal's default sandbox scored 12.79 runs per second and boat 26.69 at 4 vCPU / 8 GB in the same run.
Can Modal and smol machines run Docker?
smol machines runs Docker inside every VM, with Docker data on the machine's ext4 disk. Modal needs its VM runtime for Docker; the default gVisor sandbox does not document it. boat runs Docker in every sandbox, plus /dev/kvm for emulators.
How long can a sandbox run on Modal and smol machines?
Modal caps a sandbox at 24 hours, with a 5-minute default. smol machines has no provider cap; you can set your own lifetime or leave a machine running. boat has no session cap on paid plans.
Do Modal or smol machines have GPUs?
Modal does, from T4 to B300, on its gVisor runtime. smol cloud has none; self-hosted smolvm can remote GPU work through Vulkan and CUDA. boat has no GPUs.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial