Koyeb vs smol machines
Both run each sandbox in its own microVM. Koyeb is a serverless cloud with GPUs and regions in the EU, US and Asia, while smol machines is an open-source VM engine that branches running machines with their memory and runs the same VM on your laptop or servers.
The companies and products
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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. “4th cheapest of 345” means 3 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 | Koyeb: 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 A software factory needs a disk that stays; smol machines keeps the filesystem across stops, Koyeb loses local disk on redeploy unless you add a volume, and bochka saves its disk every minute. | 54th of 367, with limits $366 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 An assistant that lives on its machine needs its files and keys safe; on both Koyeb and smol cloud secrets are environment variables the agent can read, while bochka keeps keys in a proxy. | 135th of 366, with limits $923 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: Koyeb scales to zero after 5 idle minutes and wakes on a request, and smol machines bills a one-minute minimum and has a /code endpoint. | 4th cheapest of 345 $66 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 Koyeb and smol machines both fit and sit close together; bochka gives each user a desktop, HTTPS on up to 50 ports and a credentials proxy. | 6th cheapest of 361 $495 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 smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state, while Koyeb snapshots are an experimental SDK feature. | 237th of 360, with limits $1,631 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 | 19th cheapest of 364 $429 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 bills only the CPU and memory a job uses, while Koyeb's cheap eco instances guarantee half of each vCPU; neither exposes /dev/kvm for Android builds, which bochka does. | 142nd of 377, with limits $88 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 | 217th of 368, with limits $37 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 Koyeb nor smol cloud has a desktop in the sandbox; bochka streams a 60fps Linux desktop with Chromium and computer use. | 81st of 369, with limits $123 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 | 172nd of 367, with limits $123 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 | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 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 Koyeb runs GPU instances up to H100 and H200, while smol cloud and bochka have no GPUs. | 3rd cheapest of 98 $628 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 | Koyeb | smol machines | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Biggest machine | Instance types up to 40 vCPU / 128 GB, and larger GPU types | Up to 32 vCPU / 32 GB on Startup, 16 vCPU / 24 GB on Pro | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Files after a stop | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Filesystem survives a stop, but stopped disk keeps billing; cloud snapshot routes return 501 | Disk is kept across stops and saved every minute; a stopped sandbox costs nothing |
| Fork and snapshots | SDK snapshots of the filesystem or running processes, then new sandboxes from them (experimental) | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk |
| Sleep and wake | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | A command or terminal starts a stopped machine; idle apps wake on the next request | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Nested virtualization | Not documented | Not exposed in the cloud API; a local smolvm flag only | Yes, /dev/kvm for Android emulators and VMs |
| Inbound access | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | Up to 16 published ports through a URL or an authenticated connect route | HTTPS URLs for up to 50 ports, raw TCP, and a dedicated IPv4 or IPv6 |
| Outbound rules | Block all outbound traffic, or allow only listed IPs and CIDRs | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and browser | No desktop or browser in the sandbox SDK | No hosted desktop; a guide shows running your own Chromium | 60fps Linux desktop with Chromium and computer use |
| Coding agents | Tutorials that run agents through the command API; an MCP server | Registry images with the Codex CLI and the Harbor eval harness | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables inside the service | Cloud secrets are environment variables the guest can read | Credentials proxy for model providers and any HTTPS API |
| GPUs | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | Not in smol cloud; GPU remoting in self-hosted smolvm | No |
| Regions | EU, US and Asia | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | Edge and on-premise deployments for Enterprise, on request | Open-source smolvm runs on your laptop or your own servers | No |
Every feature Battleships tracks (43)
| Feature | Koyeb | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | 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) | Not published | 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 | 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 | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Koyeb or smol machines: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, and smol machines publishes only a boot 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. Koyeb 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 | Koyeb, 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 | $29 · Pro | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $57 · Pro | $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 | $475 · Pro | $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 | $329 · 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 | $485 · Scale · with limits | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 with $100 included; the rest of the fee is not 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) and Startup ($150) are monthly 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
Koyeb's priced shape is eco-xlarge, with a 20 GiB disk and no published price for more, and eco instances guarantee only half of each vCPU, so at 1,000 short jobs at once it does not fit as priced. 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 the burst needs Startup. bochka's limit that bites is starts: at 1,000 short jobs at once its $2,000 plan queues starts above 90 a minute.
| Scenario | Koyeb | 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 | 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 Koyeb when
your sandboxes need GPUs, must run in the US or Asia, or sleep most of the time and wake on a request next to apps you already host there.
- GPUs in the same platform. Pick Koyeb when an agent or eval needs a GPU: it runs instances from RTX 4000 cards up to H100 and H200.
- Regions in the EU, US and Asia. Koyeb runs in Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more, while smol cloud has no region choice.
- Bigger CPU machines. Koyeb instance types go up to 40 vCPU and 128 GB, for jobs that need more memory than smol cloud offers.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, or you fan out many branches of a running machine with its memory.
- Open source, from laptop to your servers. smolvm is open source, so the same machine runs on your laptop, in smol cloud or on your own servers.
- Branches with memory. For RL and test fan-out, smol machines branches a running machine with its memory and processes, paying the minimum once.
- Pay for what the guest uses. smol cloud bills the CPU and memory a machine actually uses, so a mostly idle machine costs little.
Where bochka fits
Koyeb and smol machines both give you a microVM and an exec API, and you build the rest. If your agents do hours of real work, with Docker, emulators, a browser and preview servers, bochka gives each one a whole machine with agents, a desktop and hosting built in.
Root, Docker and /dev/kvm
Neither Koyeb nor smol cloud exposes nested virtualization, so Android emulators and VMs inside the sandbox cannot start there. bochka runs full VMs with root, systemd, Docker and /dev/kvm.
Keys that never enter the sandbox
On both Koyeb and smol cloud secrets are environment variables the agent can read, so one prompt injection can leak them. bochka's credentials proxy keeps real keys outside for any HTTPS API.
Agents, desktop and ports built in
Neither has a desktop, and Koyeb exposes one port at a time while smol cloud has no SSH. bochka ships seven coding agents you drive from outside, a 60fps desktop with Chromium, and HTTPS on 50 ports.
Use bochka when your agents do real work for hours on a machine that keeps its disk: Docker, emulators, SSH, a desktop browser and preview servers, with agents and keys handled for you. Compare it one to one: bochka vs Koyeb and bochka vs smol machines.
Questions people ask
Is Koyeb cheaper than smol machines?
In three of the five scenarios on this page, yes: $57 against $93 a month for one agent that never stops, and $475 against $1,139 for 50 agents in parallel. smol machines is a little lower for one agent on workdays, and it is the only one of the two that fits 1,000 short jobs at once as priced.
Which is faster, Koyeb or smol machines?
Neither has been measured on the same CPU benchmark, so there is no fair answer. Koyeb guarantees a share of each vCPU and bursts above it, and smol machines publishes a boot time under 200ms for smolvm. bochka did 26.69 runs per second on that benchmark.
Can Koyeb and smol machines run Docker?
Both run Docker inside the sandbox; smol's guide says Docker data must live on the machine's ext4 disk. Neither exposes /dev/kvm on the hosted cloud, so Android emulators and nested VMs need bochka or another host.
Can I self-host Koyeb or smol machines?
smolvm is open source and runs on macOS, Linux and Windows hosts, so you can run the same machines on your own servers. Koyeb offers edge and on-premise deployments for Enterprise, on request.
Which one keeps files when a sandbox stops?
smol machines keeps the filesystem across a stop and bills the disk while stopped. Koyeb loses local disk on redeploy and a deep sleep discards the VM, so lasting files need a volume, which is in preview. bochka keeps its disk across stops at no cost and saves it every minute.
Does Koyeb or smol machines have GPUs?
Koyeb runs GPU instances from an RTX 4000 SFF Ada up to H100 and H200. smol cloud has no GPUs, though self-hosted smolvm supports GPU work through Vulkan and CUDA remoting. bochka is CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview