Beam vs smol machines
Beam is a serverless GPU platform whose sandboxes are gVisor containers by default, with a separate line of CPU VMs. smol machines gives every machine its own microVM kernel, branches running machines with their memory, and runs the same open-source engine on your laptop or servers.
The companies and products
Beam
Beam is a serverless cloud for GPU inference, sandboxes, VMs and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor by default. It lives until you terminate it or its time to live runs out, and you can save it as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd, a root disk that stays when it stops, and a browser desktop. A VM can pause with its memory, fork and take disk snapshots. CPU work runs on Spot, Shared or Performance tiers at different prices.
smol machines
smol machines makes 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. Each machine has its own guest kernel. smol cloud is the paid hosted service. It runs machines behind a REST API, Node, Python and Rust SDKs, and a managed agents API. It is 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. “7th cheapest of 365” means 6 of the other 364 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 | Beam: 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 | 7th cheapest of 365 $1,200 a month | 105th of 365, with limits $604 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 12th cheapest of 361 $1,495 a month | 41st cheapest of 361 $1,038 a month | 6th cheapest of 361 $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. smol machines ranks 12th here, with a one-minute minimum and a /code endpoint for Python and JavaScript. Beam ranks 17th, with sandboxes that bill per millisecond and end on their own timer. | 21st cheapest of 336 $161 a month | 16th cheapest of 336 $140 a month | 189th of 336, 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. boat ranks 2nd, smol machines 10th and Beam 12th. smol starts a stopped machine on the next command, and boat gives each user up to 50 token-gated URLs, within its start limits. | 14th cheapest of 349 $567 a month | 12th cheapest of 349 $531 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month smol machines can branch a running machine with its memory and processes, and Beam can restore a memory snapshot into new sandboxes, so both can start many rollouts from one prepared state. A boat fork boots fresh from the last 1-minute disk snapshot. | 332nd of 349, with limits $984 a month | 119th of 349, with limits $6,978 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month All three fit eval runs. boat ranks 8th, Beam 10th and smol machines 32nd here. smol's managed agents API runs Claude Code, Codex or OpenCode; boat installs seven agents with a prompt, steer and events API. | 16th cheapest of 359 $258 a month | 49th cheapest of 359 $670 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Android apps or boot VMs need nested virtualization. boat exposes /dev/kvm on every plan, smol cloud on its Startup and Enterprise plans, and Beam does not document it. | 29th cheapest of 374 $300 a month | 69th cheapest of 374 $514 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Beam VM keeps its root disk with no compute charge while stopped. smol machines keeps the filesystem and bills disk at $0.0001 per GB-hour while stopped. boat keeps a stopped disk for at least 14 days with no compute charge. | 44th cheapest of 371 $55 a month | 230th of 371, with limits $29 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Beam VMs have a browser desktop with an SDK for clicks and screenshots. On smol cloud you run Chromium from an OCI image and add a desktop yourself. boat streams a desktop at 60 fps with Chrome. | 12th cheapest of 367 $431 a month | 135th of 367, with limits $156 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 73rd of 356, with limits $272 a month | 58th of 356, with limits $136 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 16th cheapest of 343 $196 a month | 97th cheapest of 343 $242 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 44th of 327, with limits $967 a month | 145th of 327, with limits $4,344 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 6th cheapest of 351 $219 a month | 59th of 351, with limits $377 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Beam has GPU sandboxes, serverless GPUs and GPU machines up to H100, H200 and B200, and ranks 1st here. smol cloud and boat have no GPU. | Cheapest of 102 $547 a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Beam | smol machines | boat |
|---|---|---|---|
| Isolation | gVisor container by default for sandboxes, with an opt-in VM-backed mode; Beam VMs are CPU microVMs with their own kernel | libkrun microVM with its own guest kernel for every machine | Full VM with its own kernel, on physical hosts dedicated to boat; vCPUs are shared |
| GPUs | GPU sandboxes, serverless GPUs and GPU machines, from RTX 4090 up to H100, H200 and B200 | None on smol cloud; GPU remoting in local or self-hosted smolvm | No GPU on any size |
| Docker and systemd | Beam VMs have Docker and systemd; sandboxes run Docker with docker_enabled, without systemd | Docker inside the VM, with its data on the machine's ext4 disk | Docker, systemd and root in every sandbox |
| Nested virtualization | Not documented for sandboxes or VMs | Yes on Startup ($150 a month plus usage) and Enterprise, with nestedVirt; refused on Standard and Pro | Yes on every plan: /dev/kvm for Android emulators and VMs |
| Stop and keep your files | A sandbox keeps files through a saved image, a memory snapshot or a volume; a Beam VM keeps its root disk while stopped | Filesystem in /workspace and the image survives a stop; /tmp is emptied; stopped disk bills at $0.0001/GB-hour; checkpoints save a running machine with its RAM | Disk saved every minute and at stop; no compute charge while stopped; disk kept at least 14 days; memory is not saved |
| Fork and snapshots | Sandbox memory snapshots with running processes; VMs pause with RAM kept, fork and take disk snapshots | Branch a running machine into copy-on-write children with its memory and processes; checkpoints save RAM | Fork a running sandbox from its last 1-minute disk snapshot; the fork boots fresh |
| Wake on request | You start sandboxes from the SDK; Beam VMs can sleep when idle and wake again | A command or terminal starts a stopped machine, and idle apps wake on the next request | No; you start a stopped sandbox by API |
| Inbound access | Sandboxes: a public HTTPS URL per port, no built-in auth. VMs: token-protected URLs and TCP ports on a persistent public IPv6 address | Up to 16 published ports via token URLs or an authenticated connect route, plus a TCP tunnel route | Up to 50 HTTPS URLs per sandbox, token-gated by default; SSH; raw ports on public IPv6, and on IPv4 where the sandbox has its own address |
| Outbound rules | Block all, or allow up to 64 hosts, wildcard domains, IPs or CIDRs, changeable while running | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and browser | Beam VMs have a browser Linux desktop with Chrome and an SDK for screenshots, clicks and typing; documented for VMs, not sandboxes | You run Chromium from an OCI image (official guide); no hosted desktop in the cloud API | Desktop and Chrome in every sandbox at 1920x1080 and 60 fps, with computer tools for agents |
| Coding agents | You install agents and run them through process exec; Beam's MCP server plugs into Claude Code, Codex and Cursor | Managed agents API: Claude Code, Codex, OpenCode or any command as the harness, with turns, event stream, rewind and branch | Seven agents installed, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Brokered secrets: the guest sees a placeholder, and Beam puts the real key into HTTPS headers to approved hosts | Stored credentials bound to a machine: the guest sees a placeholder, and the real value is swapped in on HTTPS to allowed hosts | Optional AI credentials proxy ($1 a day while on, plus $1 per 1,000 requests) for supported model providers; other secrets still enter the sandbox |
| Regions | US by default; another region if you choose one; your own cloud with BYOC | No region choice in the cloud API | Germany, Finland and France; you cannot pick a region; snapshot copies can be stored outside the EU |
| Self-hosting | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | Open-source smolvm runs on macOS, Linux and Windows hosts, with the same .smolmachine artifact as the cloud | No |
Every feature Battleships tracks (43)
| Feature | Beam | smol machines | boat |
|---|---|---|---|
| Full VM (own kernel) | No documented way | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No documented way | Yes | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No documented way | Not published | Yes |
| Desktop GUI | No documented way | No documented way | Yes |
| Browser | No documented way | With your own setup | Yes |
| Computer-use API | No documented way | No documented way | Yes |
| SSH | Yes | No documented way | Yes |
| Persistent disk | With your own setup | Yes | Yes |
| Pause/resume | No documented way | Yes | Yes |
| Automatic snapshots | No documented way | No documented way | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No documented way | Yes | No documented way |
| Wake on request | No documented way | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | No documented way | Yes | Yes |
| Preinstalled agents | No documented way | Yes | Yes |
| Agent harness API | No documented way | Yes | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | Yes | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | Yes | Yes | No documented way |
| BYOC | Yes | Yes | No documented way |
| Open source | Yes | Yes | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No documented way | Yes | Yes |
| Audit logs | Not published | Not published | No documented way |
| SSO | No documented way | Yes | No documented way |
| SOC 2 | Yes | No documented way | No documented way |
| HIPAA | Yes | No documented way | No documented way |
| EU data residency | Not published | No documented way | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Beam nor smol machines is in the public CPU benchmark we use, so we cannot say which is faster at CPU work. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host; boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. For start time, ComputeSDK measured Beam at 534 ms median with 100 at once (2026-11-06), at Beam's default size. smol machines says smolvm boots in under 200 ms; smol and boat are not in ComputeSDK.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Beam and smol machines are not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | Beam, 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 | $20 · Developer | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $58 · Developer | $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 | $836 · Team | $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 | $312 · 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 | $527 · Team · with limits | $1,389 · Startup | $8,800 · $2000/mo · with limits |
Beam: Beam bills sandboxes per millisecond while they run, for each vCPU and GiB, on Spot, Shared or Performance tiers; new accounts default to Performance. For 4 vCPU / 8 GiB that is $0.28 an hour on Performance, $0.088 on Shared and $0.036 on Spot. VMs bill per second while running, and nothing for compute while stopped. Developer is $20 a month with $20 of credit; Team is $89 a month plus usage. There are no egress fees, and storage is not billed yet.
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, with a one-minute minimum. Disk bills at $0.0001 per GB-hour, also while stopped, and egress at $0.05 per GB. Standard is $0. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge and keeps its disk for at least 14 days, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 12 starts a minute and 200 a day; extra starts cost $0.03 to $0.07.
Limits in those scenarios
Beam's Developer plan allows 30 vCPUs at once, so 50 parallel agents or 300 user sandboxes need its Team plan. Beam does not bill storage yet, so no disk cost is counted for it. smol machines caps machines by plan, 20 on Standard, 100 on Pro and 1,000 on Startup, and a stopped machine still holds a slot. For 1,000 short jobs at once, smol machines on Startup fits; Beam Team allows 1,000 vCPUs where the burst needs 2,000; and boat's $2,000 plan charges for starts above 90 a minute and refuses them above 270. boat's auto-stop defaults to 1 hour.
| Scenario | Beam | smol machines | boat |
|---|---|---|---|
| One coding agent, workdays |
| None for this scenario | None for this scenario |
| One agent that never stops |
| None for this scenario | None for this scenario |
| 50 agents in parallel |
| None for this scenario | None for this scenario |
| Sandboxes for your users |
| None for this scenario | None for this scenario |
| 1,000 short jobs at once |
| None for this scenario |
|
Which one should you use?
Use Beam when
your agents or evals need GPUs, when you want quick containers that clean themselves up, CPU VMs with a desktop, or a self-hosted open-source runtime.
- GPUs in the same platform. For agents or evals that need a GPU, Beam offers GPU sandboxes, serverless GPUs and GPU machines from RTX 4090 to H100, H200 and B200.
- Quick sandboxes that clean up. For short jobs, Beam sandboxes bill per millisecond and go away on their own when their time to live ends.
- Persistent CPU VMs alongside. Teams that also want a long-lived machine get Beam VMs, with systemd, a desktop and a root disk kept while stopped.
Use smol machines when
you want a microVM per machine by default, live branches with memory, a managed agents API, or one open-source VM engine from your laptop to your own servers.
- A microVM for every machine. Teams that want a kernel boundary by default get a libkrun microVM with its own guest kernel on every machine.
- Live branches with memory. For RL and test fan-out, branch a running machine with its memory and processes, and wake stopped machines on the next command.
- One engine from laptop to servers. Teams that want the same VM locally, in a hosted cloud and on their own servers can use open-source smolvm, with arm64 images too.
Where boat fits
Beam and smol machines both suit short, code-driven runs. If your agents do long work that needs a whole machine, with emulators, a desktop and a browser, and URLs with access control, look at boat.
/dev/kvm on every plan
Beam documents no /dev/kvm on sandboxes or VMs. smol cloud exposes nested virtualization on its Startup plan ($150 a month plus usage) and Enterprise. Every boat sandbox has /dev/kvm on every plan.
A desktop in every sandbox
Beam has a desktop on its VMs, not its sandboxes. On smol cloud you run Chromium from an OCI image and add the desktop and screen stream yourself. Every boat sandbox streams a 60 fps desktop with Chrome.
SSH and gated URLs
smol cloud reaches machines through a command API, 16 published ports and a TCP tunnel route, with no SSH route documented. A Beam sandbox URL has no built-in auth. boat gives SSH and up to 50 token-gated HTTPS URLs per sandbox.
Use boat when your agents need a whole machine on every plan: Docker, /dev/kvm for emulators, SSH, a built-in desktop and browser, and coding agents you drive from outside. Compare it one to one: boat vs Beam and boat vs smol machines.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Questions people ask
Is Beam cheaper than smol machines?
In four of the five scenarios on this page, yes. One coding agent on workdays costs $20 a month on Beam and $25 on smol, one agent that never stops $58 against $93, 50 agents in parallel $836 against $1,139, and user sandboxes $312 against $465. For 1,000 short jobs at once, smol fits on Startup at $1,389, and Beam Team does not fit. smol bills only the CPU and memory a guest uses, so a mostly idle machine can cost less there. boat costs $20, $26, $317 and $200 in the first four.
Which is faster, Beam or smol machines?
We cannot say: neither is in the public CPU benchmark we use. ComputeSDK measured Beam at 534 ms to start with 100 at once, and smol says smolvm boots in under 200 ms, but those are start times, not CPU speed.
Is a Beam sandbox a VM like smol machines?
Not by default. Beam sandboxes are gVisor containers, with an opt-in VM-backed mode and a separate Beam VM product. Every smol machine is a libkrun microVM with its own kernel, and every boat sandbox is a full VM with /dev/kvm.
Can Beam and smol machines run Docker?
Yes. Beam runs Docker in a sandbox with docker_enabled and in its VMs, and smol machines runs it inside the VM with its data on the ext4 disk. boat runs Docker in a full VM and also has systemd and /dev/kvm.
Can I fork a running machine on Beam or smol machines?
Both can. Beam takes a memory snapshot of a running sandbox and restores it into new sandboxes, and smol machines branches a running machine into children that keep its memory and processes. boat forks a running sandbox from its last 1-minute disk snapshot, and the fork boots fresh.
Which one has GPUs?
Beam does, from RTX 4090 up to H100, H200 and B200. smol cloud has no GPUs, though self-hosted smolvm can remote GPU work. boat has no GPU on any size.
Try boat
Install the CLI, then run boat new.
7-day free trial