Koyeb vs Modal VM Sandboxes
Koyeb runs each sandbox as a microVM service that can sleep when idle, wake on the next request and run on GPUs. Modal VM Sandboxes give each job a real Linux kernel for Docker and systemd, built for huge bursts of short runs that end within 24 hours.
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.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on 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 | Modal VM Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Koyeb ranks 54th and Modal VM Sandboxes ranks 84th for a software factory, because Koyeb loses local disk on redeploy and Modal ends each VM within 24 hours; bochka ranks 3rd with a disk it keeps. | 54th of 367, with limits $366 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month rules out Modal VM Sandboxes and their 24-hour cap; Koyeb can stay up but a deep sleep discards the VM, and bochka ranks 5th. | 135th of 366, with limits $923 a month | Can't run it | 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 Short code runs suit Koyeb well: Koyeb ranks 4th, with small instances that scale to zero and wake on the next request. | 4th cheapest of 345 $66 a month | Can't run it | 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 ranks 6th for sandboxes you hand to your users, thanks to wake on request and many regions; bochka ranks 1st, with a stopped sandbox that keeps its disk for free. | 6th cheapest of 361 $495 a month | Can't run it | 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 Huge bursts of short rollouts are what Modal is built for, with 5,000 containers at once on Team, but both providers only fit as a compromise here. | 237th of 360, with limits $1,631 a month | 171st of 360, with limits $16,322 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 | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both can run builds, but only bochka gives every plan /dev/kvm for Android emulators; Modal offers it on Team and Enterprise on request, and Koyeb does not document it. | 142nd of 377, with limits $88 a month | 188th of 377, with limits $1,064 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 | Can't run it | 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 Modal VM Sandboxes ships a desktop or browser, so computer-use agents need Xvfb and VNC set up by hand; bochka streams a 60fps desktop with Chromium. | 81st of 369, with limits $123 a month | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | 294th of 360, with limits $642 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 ranks 3rd for GPU eval jobs, with instances up to H100 and H200, while Modal VM Sandboxes have no GPUs (only Modal's gVisor sandboxes do) and bochka has none. | 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 | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance, started from any Docker image | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | Not benchmarked; at least 0.25 dedicated vCPU per GB of memory, bursting to all cores | 15.54 runs/s | 26.69 runs/s |
| Longest session | No forced cap; optional auto-delete timer you set, up to 24 hours | 24 hours (default 5 minutes); continue with a filesystem snapshot | No cap on paid plans; you set the time to live |
| Disk that survives | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Root disk is gone when the sandbox ends; only Volumes and snapshots keep files | Disk is kept across stops and saved every minute, with snapshots |
| Sleep and wake | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | No paused state; a finished sandbox is gone | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Snapshots and fork | SDK snapshots of the filesystem, or with running processes, then new sandboxes from them (experimental) | Filesystem snapshots boot any number of new sandboxes; memory snapshots in alpha | Fork a running sandbox with its disk |
| Nested virtualization | Not documented | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan |
| Inbound access | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound rules | Block all outbound traffic, or allow only listed IPs and CIDRs | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Desktop and browser | No desktop or browser in the sandbox SDK | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps Linux desktop with Chromium and a computer-use API |
| Coding agents | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | Examples only | Claude Code, Codex and five other agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables inside the service | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | None on the VM runtime; GPU sandboxes need gVisor | None |
| Regions | EU, US and Asia: Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Koyeb | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | 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 | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | 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 | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | No | Not published | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Koyeb has no comparable measurement: it was not part of the hpc-sandbox-benchmarks run. In that run at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 Node.js build-and-test runs per second and bochka did 26.69, about 1.7 times the CPU work in the same time. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. Koyeb 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 | Koyeb, a month | Modal VM Sandboxes, 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 | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $57 · Pro | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second from the moment it starts, at a fixed price per instance type, and Deep Sleep costs nothing. Pro is $29 a month with $10 of usage included and Scale $299 with $100 included; the rest of the fee is not credit.
Modal VM Sandboxes: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, until the sandbox ends. Starter is free with $30 of monthly credit and Team is $250 a month with $100 of credit; pinning a region multiplies the price by 1.15x to 1.75x.
Modal VM Sandboxes: 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, which has a 20 GiB disk with no published price for more, and eco instances guarantee only half of each vCPU, so the 1,000-job burst gets throttled. A Modal VM Sandbox lives at most 24 hours and loses everything outside a Volume or snapshot, so the workday, always-on and fleet scenarios do not fit, and its burst tier runs on shared vCPUs. bochka does not fit the burst either: even the $2,000 plan starts 90 sandboxes a minute, so 1,000 jobs at once queue.
| Scenario | Koyeb | Modal VM Sandboxes | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| 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 |
|
|
|
Which one should you use?
Use Koyeb when
your sandboxes need GPUs, sleep most of the time and should wake on a request, or must keep running past a day next to apps you already host there.
- GPUs on the same platform. For agents or evals that need a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Sleep when idle, wake on request. For sandboxes that sit idle between requests: Koyeb scales to zero and wakes on the next one, in about 200 ms with Light Sleep.
- No forced 24-hour end. For services that must stay up for days: a Koyeb sandbox runs until you delete it, unless you set an auto-delete timer.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that need a real kernel for Docker or systemd, finish within a day, and sit next to models you already run on Modal.
- A real kernel for Docker and systemd. For jobs that need Docker, FUSE or systemd inside: each Modal VM Sandbox boots its own Linux kernel.
- Very large bursts. For huge waves of short jobs: Modal runs 5,000 containers at once on Team, and more on Enterprise.
- Tighter outbound rules. For agents that must reach only chosen hosts: Modal can allowlist outbound traffic by IP range or by domain.
Where bochka fits
If your agents work for hours or days on a machine they come back to, both Koyeb and Modal VM Sandboxes make you rebuild that machine around volumes or snapshots. bochka gives each agent a full VM that keeps its disk, exposes /dev/kvm and comes with a desktop, coding agents and a key proxy built in.
A disk that stays, with no session cap
On Koyeb the local disk is lost on redeploy and a deep sleep discards the VM, and volumes are a 1 to 10 GB preview. A Modal VM ends within 24 hours and its root disk goes with it, unless you write snapshot code.
/dev/kvm and a faster CPU
Android emulators and nested VMs need /dev/kvm, which Koyeb does not document and Modal gives only on Team or Enterprise on request. bochka measured 26.69 runs/s against Modal's 15.54, so every build waits less.
Desktop, agents and keys handled
Neither ships a desktop or an agent API, so you set up Xvfb, VNC and a harness yourself. Keys sit in environment variables an injected prompt can read, unless you run your own sidecar proxy on Modal.
Use bochka when your agents do real work for hours or days on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with agents and keys handled for you. Compare it one to one: bochka vs Koyeb and bochka vs Modal VM Sandboxes.
Questions people ask
Is Koyeb cheaper than Modal VM Sandboxes?
In most of our scenarios, yes: one always-on agent costs $57 a month on Koyeb against $178 on Modal, and 50 parallel agents $475 against $2,229. For one agent on workdays Modal is cheaper ($15 against $29), but its files reset between days unless you use a Volume. bochka costs $26 and $317 a month for those first two.
Which is faster, Koyeb or Modal VM Sandboxes?
Only Modal was measured: its VM runtime did 15.54 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB. Koyeb was not in that run and promises at least 0.25 dedicated vCPU per GB of memory. bochka did 26.69 runs per second in the same run.
Can Koyeb and Modal VM Sandboxes run Docker?
Koyeb sandboxes start from any Docker image in a microVM. A Modal VM Sandbox has its own Linux kernel, so you can start dockerd inside it, along with FUSE and systemd. bochka runs Docker, systemd and /dev/kvm in every sandbox.
How long can a sandbox run on each?
A Modal VM Sandbox defaults to 5 minutes and stops at 24 hours at most. Koyeb has no forced cap: a sandbox runs until you delete it, unless you set an auto-delete timer. bochka has no session cap on paid plans.
Do Koyeb or Modal VM Sandboxes have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Modal VM Sandboxes do not; on Modal only the gVisor sandboxes can use GPUs. bochka is CPU only.
Which one keeps my files?
Neither does by default. Koyeb loses local disk on redeploy and needs a volume, in preview, to keep files, and a Modal VM loses its root disk when it ends unless files sit in a Volume or a snapshot. A bochka sandbox keeps its disk across stops and saves it every minute.
Try bochka
Install the CLI, then run bochka new.
Product preview