Modal vs Koyeb
Modal runs sandboxes as gVisor containers next to its GPU platform, built for huge bursts of short jobs that end within 24 hours. Koyeb runs each sandbox as a microVM service that can sleep when idle, wake on the next request, and keep running with no documented time cap.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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.
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. “19th cheapest of 345” means 18 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 | Modal: price rank | Koyeb: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 54th of 367, with limits $366 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent hits Modal's 24-hour sandbox limit, and on Koyeb a deep sleep throws away the VM; a bochka sandbox runs with no session cap on paid plans and keeps its disk. | 196th of 366, with limits $1,924 a month | 135th of 366, with limits $923 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, and Koyeb ranks 4th here against Modal at 19th thanks to small instances that scale to zero. | 19th cheapest of 345 $181 a month | 4th cheapest of 345 $66 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 All three fit sandboxes for your users; Koyeb wakes a sleeping sandbox on request, Modal starts fresh ones fast, and bochka ranks 1st with stopped sandboxes that keep their disk for free. | 11th cheapest of 361 $811 a month | 6th cheapest of 361 $495 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 RL rollouts launch many short sandboxes at once, which is what Modal is built for, so Modal ranks 5th while Koyeb is a compromise at 237th. | 5th cheapest of 360 $19,038 a month | 237th of 360, with limits $1,631 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 | 59th cheapest of 364 $1,244 a month | 19th cheapest of 364 $429 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 CI that builds Docker images needs the VM runtime on Modal, while Koyeb sandboxes start from Docker images; bochka runs Docker and /dev/kvm in every sandbox. | 126th cheapest of 377 $1,793 a month | 142nd of 377, with limits $88 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 138th of 368, with limits $23 a month | 217th of 368, with limits $37 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 Modal nor Koyeb ships a desktop, so computer-use agents need VNC set up by hand; bochka streams a 60fps desktop with Chromium built in. | 98th of 369, with limits $183 a month | 81st of 369, with limits $123 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 | 177th of 367, with limits $136 a month | 172nd of 367, with limits $123 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 | 267th of 346, with limits $394 a month | 172nd of 346, with limits $89 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 For mass scraping Koyeb ranks 65th, close to bochka at 71st, while Modal is far behind at 223rd. | 223rd of 338, with limits $8,795 a month | 65th of 338, with limits $1,683 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 | Can't run it | 233rd of 360, with limits $299 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 Both rent GPUs, Modal from T4 to B300 and Koyeb from RTX 4000 cards to H100 and H200, and bochka has none. | 19th cheapest of 98 $1,187 a month | 3rd cheapest of 98 $628 a month | 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 | Modal | Koyeb | bochka |
|---|---|---|---|
| Isolation | gVisor containers by default; a VM runtime with its own kernel is available | MicroVM per instance | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Starts from any Docker image; fits the Docker-inside fleet scenario | Yes, in every sandbox, with root and systemd |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Longest session | 24 hours (default 5 minutes) | No forced cap; optional auto-delete timers | No cap on paid plans (default TTL 1 h, changeable) |
| Stop, sleep and wake | No paused state; an idle sandbox pays until it is terminated | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Disk that survives | Root disk is gone when the sandbox ends; only Volumes keep files | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Whole disk kept across stops and saved every minute |
| Snapshots and fork | Filesystem snapshots to boot new sandboxes; memory snapshots in alpha end the sandbox | SDK snapshots of the filesystem or running processes, then new sandboxes from them (experimental) | Fork a running sandbox without stopping it |
| Desktop and browser | Not offered; an example shows how to set up VNC yourself | No desktop or browser in the sandbox SDK | 60fps Linux desktop with Chromium and a computer-use API |
| Coding agents and API keys | Examples only; secrets are environment variables or your own sidecar proxy | Tutorials over the command API; secrets are environment variables | Claude Code, Codex and others preinstalled with a prompt API; a credentials proxy keeps real keys out |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Block all, or allow only listed IPs and CIDRs | Open internet, no provider-side allowlist |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | RTX 4000 SFF Ada up to H100 and H200 | None |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo | EU only: Germany, Finland, France |
| CPU speed (4 vCPU / 8 GB) | 12.79 runs/s on the default sandbox | Not benchmarked; at least 0.25 dedicated vCPU per GB, bursting | 26.69 runs/s |
Every feature Battleships tracks (43)
| Feature | Modal | Koyeb | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Not published | 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 | No | Yes | 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 | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Not published | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the same hpc-sandbox-benchmarks run at 4 vCPU / 8 GB, bochka finished 26.69 Node.js build-and-test runs per second and Modal's default gVisor sandbox 12.79, so bochka did about twice the work. Koyeb has no comparable measurement: it was not in that run. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Koyeb, 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 | $15 · Starter · with limits | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $57 · Pro | $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 | $2,229 · Starter · with limits | $475 · 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 | $792 · Team | $329 · Scale | $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 | $3,193 · Team · with limits | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of what you request and what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.
Koyeb: Koyeb bills each instance per second 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 a month with $100 included; the rest of the fee is not credit.
Koyeb: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and only Volumes keep files, so the workday, always-on and fleet scenarios do not fit, and the fleet also needs Docker, which the default sandbox lacks. Koyeb fits those scenarios, but its priced eco-xlarge shape has a 20 GiB disk with no published price for more. At 1,000 short jobs at once nothing fits as priced: Modal's tier shares vCPUs, Koyeb's eco CPU guarantees only half of each vCPU, and bochka queues starts above 90 a minute.
| Scenario | Modal | Koyeb | 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 Modal when
your sandboxes need GPUs, or are huge bursts of short jobs like RL rollouts that finish in minutes, with fine outbound rules.
- GPUs from T4 to B300. Useful when your agent trains or runs models: Modal rents GPUs up to B300 on the same platform as its sandboxes.
- Huge bursts of short jobs. Built for RL rollouts and big fan-outs, with up to 5,000 containers on Team and fast starts.
- Finer outbound rules. Modal can block a sandbox's traffic or allow only chosen IP ranges or domains, where Koyeb filters by IP only.
Use Koyeb when
your sandboxes sit idle and must wake on a request, run for longer than a day, or live in a microVM in the EU, US or Asia.
- Sleep when idle, wake on request. Good for sandboxes that sit idle between requests: Koyeb scales to zero and wakes on the next call.
- No 24-hour cap. A Koyeb sandbox keeps running until you delete it, so long agent sessions are not cut off at a day.
- A microVM per sandbox. Each Koyeb sandbox gets its own microVM rather than a gVisor container, and starts from any Docker image.
Where bochka fits
If your sandboxes run coding agents that work for hours, look at bochka. Modal and Koyeb both shine at sandboxes that come and go, but both lose an agent's disk unless you add volumes, and neither ships a desktop or agent tooling. bochka gives each agent a full VM that keeps its work, on a faster CPU.
The machine keeps its work
On Modal a sandbox ends within 24 hours and its root disk goes with it; on Koyeb a redeploy or deep sleep wipes local files. Both need volumes for lasting files. bochka saves the whole disk every minute and stops for free.
A real VM with Docker and /dev/kvm
Modal needs its VM runtime for Docker, and nested virtualization only on request for Team plans. Koyeb does not document /dev/kvm, so Android emulators and VM builds run elsewhere. Every bochka sandbox has root, systemd, Docker and /dev/kvm.
Desktop, agents and ports built in
Neither ships a desktop, so you wire up VNC yourself, build the agent harness on exec, and keep keys in readable environment variables. Koyeb exposes one port at a time. bochka has a 60fps desktop, preinstalled agents, a credentials proxy and 50 HTTPS ports.
Use bochka when your agents work for hours or days: builds, Docker, emulators, a desktop browser and preview servers, on a fast machine that keeps its disk. Compare it one to one: bochka vs Modal and bochka vs Koyeb.
Questions people ask
Is Modal cheaper than Koyeb?
For long-running work, no: one agent that never stops costs $178 a month on Modal against $57 on Koyeb, and 50 parallel agents $2,229 against $475, though Modal does not fit either as priced. For one agent on workdays Modal is $15 against $29 on Koyeb, but its files reset between days. bochka is $26 and $317 for those first two.
Which is faster, Modal or Koyeb?
Only Modal was measured: its default sandbox did 12.79 runs per second at 4 vCPU / 8 GB. Koyeb was not part of the benchmark. bochka did 26.69 in the same run, about twice Modal's default sandbox.
Can Modal and Koyeb run Docker?
Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. Koyeb sandboxes start from Docker images and fit our Docker-inside fleet scenario. Every bochka sandbox runs Docker with root and systemd.
How long can a sandbox run on Modal and Koyeb?
Modal caps a sandbox at 24 hours, with a default of 5 minutes. Koyeb has no forced cap, only optional auto-delete timers you set. bochka has no session cap on paid plans.
Do Modal and Koyeb have GPUs?
Yes, both do. Modal rents T4 up to B300, and Koyeb runs RTX 4000 SFF Ada up to H100 and H200. bochka is CPU only.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview