Blaxel vs smol machines
Both run each sandbox in a microVM with its own kernel. Blaxel is a hosted service built to sleep in seconds and wake in under 25 ms with its memory, while smol machines is an open-source engine you can run on your laptop, in their cloud or on your own servers, with live branches of a running machine.
The companies and products
Blaxel
Blaxel is a San Francisco company that runs cloud infrastructure for AI agents, and since September 2026 it is part of Baseten.
You get sandboxes, batch jobs, MCP server hosting and a model gateway. Each sandbox is a Firecracker microVM with its own kernel that drops to standby when nothing is connected and resumes in under 25 ms with its memory and running processes. It is built for agent products that start many sandboxes and want them asleep most of the time.
- Headquarters
- San Francisco, founded 2024
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. “10th cheapest of 367” means 9 of the other 366 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 | Blaxel: 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, but neither exposes /dev/kvm on its hosted machines, which bochka does for Android emulators and VMs. | 10th cheapest of 367 $2,373 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 | 12th cheapest of 366 $2,832 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 Blaxel and smol machines are close here: Blaxel sleeps right after a run and wakes in milliseconds, and smol machines bills a one-minute minimum and branches warm machines. | 14th cheapest of 345 $144 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 smol machines fits 300 users at once on its Startup plan, while Blaxel's public tiers stop at 200 at once; bochka fits it on a self-serve plan with a desktop per user. | 101st of 361, with limits $926 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 can branch a running machine with its memory, so rollouts start from one prepared state; on Blaxel that fork is still in private preview. | 77th of 360, with limits $4,378 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 | 136th of 364, with limits $704 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 | 57th cheapest of 377 $431 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 Neither Blaxel nor smol machines offers native SSH, while bochka is a plain machine you SSH into and leave on. | 265th of 368, with limits $114 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 Blaxel runs a desktop, a browser and computer use, smol machines has no hosted desktop, and bochka streams a Linux desktop at 60fps you can embed. | 14th cheapest of 369 $634 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 Blaxel ships a browser for agents, while smol machines documents how to run your own Chromium inside a machine. | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 Blaxel ranks 3rd here with domain rules on the provider side; smol machines has a host and CIDR allowlist, and bochka gives root with raw TCP and nftables. | 3rd cheapest of 360 $217 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 | Blaxel | smol machines | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | A command or terminal starts a stopped machine; idle apps wake on the next request | Stop keeps the disk and costs nothing; resume boots the VM again |
| Fork | Fork with memory and running processes (private preview) | Branch a running machine with its memory and processes; checkpoints save RAM to a file | Fork a running sandbox with its disk |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Filesystem survives a stop, memory paths are emptied; disk keeps billing while stopped | A real disk saved every minute and on stop; a stopped sandbox costs nothing |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Not exposed in the cloud create API; a local smolvm flag only | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Shell access | Root, terminal through the bl connect command, no native SSH | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | Real SSH, root and systemd, plus a command API and terminal |
| Docker inside | Yes, with a Docker-in-sandbox image | Yes, with Docker data on the machine's ext4 disk | Yes |
| Desktop and browser | Desktop, browser and computer use | No hosted desktop; a guide shows running your own Chromium inside a machine | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | 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; own IPv4 or IPv6 |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet; filter inside the VM with nftables |
| Keeping API keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests; sandbox never sees them (public preview) | Cloud secrets are environment variables the guest can read; placeholder 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 |
| Coding agents | Claude Code image you drive from its terminal or your own harness | 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 |
| Regions | US (Oregon, North Virginia), London, Frankfurt | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | Hosted; bring-your-own-metal on a custom plan | Open-source smolvm runs on your laptop or your own servers, with the same .smolmachine artifact | Hosted only |
Every feature Battleships tracks (43)
| Feature | Blaxel | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | No | 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 | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | 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 | Yes | Not published | Yes |
Performance
On the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB, run on September 29, 2026, bochka did 26.69 runs per second and Blaxel 19.48, so bochka got through about 1.4 times the work in the same time. smol machines has no comparable measurement on that test; it publishes a boot time under 200 ms for smolvm, which is about 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. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). 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 | Blaxel, 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 | $33 · Pay-as-you-go Tier 1 | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $120 · Pay-as-you-go Tier 1 | $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,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $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 | $876 · Pay-as-you-go Tier 2 · with limits | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox has an open connection, with CPU included (8 GB comes with 4 cores). In standby you pay only snapshot storage, and the tier you reach depends on how much you top up each 30 days, which goes to your wallet as credit.
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
Blaxel's self-serve tiers allow 10, 50 or 200 sandboxes at once, and sandboxes in standby count, so 300 users at once and 1,000 jobs at once need a sales tier. smol machines caps machines by plan at 20, 100 and 1,000, with stopped machines still holding a slot, so 50 agents needs Pro and the 1,000-job burst needs Startup, which makes smol machines the only one of the three to fit that burst on a public plan. bochka's limit is starts: above 90 a minute they are queued. On Blaxel, the lower tiers also delete sandboxes after 7 or 30 days.
| Scenario | Blaxel | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | None that bite | None that bite |
| 50 agents in parallel | None that bite | 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 Blaxel when
your sandboxes sit idle most of the time and must wake in milliseconds with their memory, need a hosted desktop and a secret proxy, or must run in the US.
- Sleeps in seconds, wakes in milliseconds. For sandboxes that sit idle most of the time: standby seconds after the last connection, back in under 25 ms with memory intact.
- A desktop and a key proxy, hosted. For computer-use agents: Blaxel runs a desktop and a browser, and its proxy fills secrets into requests so the sandbox never sees them.
- US and UK regions. For teams with users in the US: Blaxel runs in Oregon and North Virginia as well as London and Frankfurt.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, need big or arm64 machines, or fan out many branches of a running machine.
- Open source, from laptop to your servers. For teams that want one VM engine locally, in a hosted cloud and on their own servers, smolvm is open source.
- Live branches with memory. For RL and test fan-out: branch a running machine with its memory and processes, paying the one-minute minimum once.
- Bigger machines and arm64. For heavy jobs: up to 32 vCPU and 32 GB on Startup, with images in amd64 and arm64.
Where bochka fits
Blaxel and smol machines are both built around light microVMs that start, sleep and branch fast. If your agents do long, real work like builds, tests, Docker and emulators, look at bochka: a whole Linux machine with a real disk, a measured faster CPU, and coding agents you drive from outside.
A whole Linux machine
Neither Blaxel nor smol cloud gives a hosted machine /dev/kvm, so an Android emulator or a VM will not start. Neither has native SSH: on Blaxel you go through bl connect, on smol through an exec API and a terminal capped at one hour.
A disk that stays, and free stops
Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation, and lower tiers delete sandboxes after 7 or 30 days. smol keeps files but bills the disk while stopped. bochka saves the disk every minute and a stop costs nothing.
Agents you drive from outside
Blaxel gives you a Claude Code image and smol a Codex image, and on both you build the harness yourself on a terminal or exec calls. bochka ships seven agents with one API to prompt, steer and read events.
Use bochka when your agents do real work for hours: Docker, emulators, SSH, a desktop and a browser on a whole Linux machine with a real disk, a faster CPU and agents you drive from outside. Compare it one to one: bochka vs Blaxel and bochka vs smol machines.
Questions people ask
Is Blaxel cheaper than smol machines?
In most of our scenarios smol machines costs less: one coding agent on workdays is $25 against $33, and 50 agents in parallel $1,139 against $1,489. Blaxel is lower for 300 user sandboxes ($396 against $465) and 1,000 short jobs, but its self-serve tiers cannot run that many at once. bochka is $20 and $317 for those first two.
Which is faster, Blaxel or smol machines?
For CPU work we only have a measurement for Blaxel: 19.48 runs per second on a Node.js build-and-test loop, against 26.69 for bochka. smol machines has not run that test. For start time, Blaxel wakes from standby in under 25 ms and smolvm boots in under 200 ms.
Can Blaxel and smol machines run Docker?
Yes, both run Docker inside the VM: Blaxel with its Docker-in-sandbox image, smol machines with Docker data on the machine's ext4 disk. Neither exposes /dev/kvm on hosted machines, so Android emulators do not run, while bochka exposes /dev/kvm in every sandbox.
Can they fork a running machine with its memory?
Both can. smol machines branches a running machine into children that keep its memory and processes, and Blaxel offers the same in private preview. bochka forks a running sandbox with its disk, and the fork boots fresh.
Can I self-host Blaxel or smol machines?
smol machines, yes: smolvm is open source and runs on macOS, Linux and Windows hosts. Blaxel is hosted, with bring-your-own-metal on a custom plan. bochka is a hosted service only.
Where do Blaxel and smol machines run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. smol cloud has no region choice in its API. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview