Morph Cloud vs smol machines
Both give each agent its own VM and can branch a running machine with its memory and wake it on the next request. Morph Cloud is a hosted service with SSH, experimental Windows and macOS guests and managed CI runners, while smol machines is an open-source engine you can also run on your laptop or your own servers.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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. “16th cheapest of 345” means 15 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 | Morph Cloud: price rank | smol machines: 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 inside the VM, but neither ships coding agents you drive by API; bochka ranks 3rd with seven agents preinstalled. | 198th of 367, with limits $2,288 a month | 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 | 235th of 366, with limits $3,014 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: machines pause or stop with little cost and wake on the next request, and smol machines ranks 12th here, just ahead of Morph Cloud at 16th. | 16th cheapest of 345 $154 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 Both fit, with smol machines at 7th and Morph Cloud at 12th; bochka ranks 1st and gives each user HTTPS on up to 50 ports and raw TCP. | 12th cheapest of 361 $905 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 Both branch a running machine with its memory, so rollouts can start from one prepared state; Morph Cloud ranks 86th and smol machines 111th. | 86th of 360, with limits $4,847 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 | 38th cheapest of 364 $675 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 Morph Cloud also sells managed GitHub Actions runners; bochka ranks 4th, with /dev/kvm for jobs that build Android apps or boot VMs. | 39th cheapest of 377 $355 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 Morph Cloud fully fits a 24/7 dev box at 85th, smol machines is a compromise at 216th, and bochka ranks 18th. | 85th cheapest of 368 $116 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 ships a ready desktop with a browser and computer use; bochka streams a Linux desktop at 60fps with Chromium built in. | 182nd of 369, with limits $595 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 | 214th of 367, with limits $250 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 | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 | 214th of 360, with limits $228 a month | 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 | 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 | Morph Cloud | smol machines | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Fork a running machine | Yes, with its memory, as many copies as you ask for, in under 250 ms | Yes, copy-on-write children keep its memory and running processes; checkpoints save RAM to a file | Yes, with its disk; the fork boots fresh |
| Wake on request | A paused VM resumes on the next HTTP request, SSH or exec call | A command or terminal starts a stopped machine; idle apps wake on the next request | No; a stopped sandbox is started by API |
| Stop and keep your files | Saved when you pause or snapshot; a plain stop deletes the instance | Filesystem survives a stop, memory paths like /tmp are emptied; stopped disk keeps billing | Disk saved every minute and on every stop; a stopped sandbox costs nothing |
| Nested virtualization | Experimental | Not exposed on hosted machines; a local smolvm flag only | Yes, /dev/kvm for Android emulators and VMs |
| Shell access | SSH through Morph's gateway, plus exec and a tmux API | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | Named HTTP services with optional API key auth; no raw TCP | Up to 16 published ports through a returned URL or an authenticated connect route; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | No outbound allowlist documented | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and browser | Browser-based remote desktop; you install the browser and any computer use agent | No hosted desktop; a guide shows running your own Chromium inside a machine | 60fps Linux desktop with Chromium and a computer use API |
| Coding agents | You install the agent, then drive it through a tmux API that sends keys and reads the screen | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Responses Proxy for model APIs; other secrets are handed to the machine | Cloud secrets are environment variables the guest can read; credential swapping only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux only, in amd64 and arm64 | Linux |
| Self-hosting | No; SDKs are open source, the platform is hosted only | Open-source smolvm runs on your laptop or your own servers with the same .smolmachine artifact | No |
| Where data lives | Regions not published | No region choice in the cloud API | EU only (Germany, Finland, France), with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | 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 | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | No | No |
| HIPAA | Not published | No | No |
| EU data residency | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or smol machines: neither is in the StarSling hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Morph's under 250 ms snapshot restore and smolvm's under 200ms boot are start times, 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. Morph Cloud and smol machines have 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 | Morph Cloud, a month | smol machines, 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 | $32 · Developer | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $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 | $1,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 each: per hour, a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot.
smol machines: smol cloud charges a base fee 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: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Morph's limits are account-wide resource pools: the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU, disk beyond 16 GiB per MCU raises the price, and egress prices are not published. smol machines caps machines by plan, 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still holding a slot, so 50 agents need Pro and 1,000 short jobs need Startup. Both fit 1,000 short jobs at once, while bochka's $2,000 plan queues starts above 90 a minute.
| Scenario | Morph Cloud | smol machines | bochka |
|---|---|---|---|
| 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 |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use Morph Cloud when
you want a hosted VM with SSH, memory branching and wake on request, need experimental Windows or macOS guests, or want managed GitHub Actions runners from the same account.
- SSH into every machine. Morph Cloud gives SSH through its gateway, so tools that expect SSH work without being rewired to an exec API.
- Windows and macOS guests. Morph Cloud lists experimental Windows and macOS (x86) guests for agents that must test software on those systems.
- Managed CI runners and a shared filesystem. Morph Cloud also sells GitHub Actions runners from the same balance, and a filesystem many machines can mount at once.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, outbound allowlists or arm64 images, and billing on what the guest actually uses.
- Open source, from laptop to your own servers. Teams that want one VM engine locally, in a hosted cloud and on their own servers can run open-source smolvm everywhere.
- Outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
- Billing on what the guest uses. smol cloud charges for the CPU and memory a guest actually uses, so a machine that idles most of the day costs less.
Where bochka fits
Morph Cloud and smol machines both sell a fast VM boundary with memory branching, and leave the rest for you to build. If your agents need to arrive ready, with coding agents you drive from outside, a desktop with a browser, keys kept out of the machine and a whole machine with /dev/kvm and many open ports, look at bochka.
Agents and keys built in
On Morph you drive agents by tmux keystrokes and its proxy covers model APIs only; on smol cloud secrets are plaintext in the guest. bochka ships seven agents behind one API and proxies keys for any HTTPS API.
A desktop and a browser, ready to use
Neither ships a ready browser or computer use API: on Morph you install them on its remote desktop, and on smol cloud you build the whole desktop stack. bochka streams a 60fps desktop with Chromium in every sandbox.
A whole machine that keeps its work
Nested virtualization is experimental on Morph and not exposed on smol cloud; smol has no SSH and 16 ports, Morph no raw TCP. bochka has /dev/kvm, SSH, 50 HTTPS ports and raw TCP, and saves disk every minute.
Use bochka when your agents need a whole machine that arrives ready: coding agents you drive from outside, a 60fps desktop with Chromium, keys kept outside the sandbox, /dev/kvm, and hosting on 50 ports in the EU. Compare it one to one: bochka vs Morph Cloud and bochka vs smol machines.
Questions people ask
Is Morph Cloud cheaper than smol machines?
It depends on the shape. smol machines costs less for one workday agent, one always-on agent and 50 agents in parallel, while Morph costs less for sandboxes for your users ($325 vs $465 a month) and 1,000 short jobs at once ($869 vs $1,389 a month). bochka costs less than both in the first four scenarios.
Which is faster, Morph Cloud or smol machines?
Neither has a CPU score in the StarSling hpc-sandbox-benchmarks run, so there is no fair speed comparison. Both publish start times: under 250 ms for a Morph snapshot restore and under 200ms for a smolvm boot. bochka scored 26.69 runs per second on that benchmark.
Can both branch a running machine with its memory?
Yes. Morph branches a running VM with its memory into many copies in under 250 ms, and smol machines branches a running machine into children that keep its memory and processes. bochka forks a running sandbox with its disk, and the fork boots fresh.
Can Morph Cloud and smol machines run Docker?
Both run Docker inside the VM, and Morph also runs Docker in Docker and local Kubernetes. Nested virtualization is experimental on Morph and not exposed on smol cloud, while bochka exposes /dev/kvm for Android emulators and VMs.
Is smol machines open source and Morph Cloud not?
The smolvm engine and smol SDK are open source and run on your own computer or servers; smol cloud is the paid hosted service. Morph's Python and TypeScript SDKs are open source, but the platform is hosted only, as is bochka.
Can I SSH into each?
Morph gives SSH through its gateway. smol cloud has no SSH: you use its command API, sessions or a WebSocket terminal capped at one hour per connection. bochka gives SSH plus a command API and terminal.
Try bochka
Install the CLI, then run bochka new.
Product preview