exe.dev vs Koyeb
exe.dev gives you Linux VMs that stay up with their disk, root, SSH and coding agents preinstalled, billed as a reserved pool. Koyeb runs each sandbox as a serverless microVM that can sleep when idle, wake on a request and run on a GPU.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: 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 A software factory needs Docker, a lasting disk and room to build; exe.dev keeps the disk, Koyeb needs a volume for that, and bochka adds snapshots every minute and a desktop. | 253rd of 367, with limits $3,701 a month | 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 exe.dev fits always-on assistants fully, since its VMs keep their disk and run until you stop them; on Koyeb a deep sleep discards the VM, and bochka fits fully too. | 15th cheapest of 366 $3,833 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 Koyeb fits short code runs well, with small instances that scale to zero and wake on the next request; exe.dev and bochka are built for longer sessions. | 235th of 345, with limits $175 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 Koyeb fits sandboxes for your users, with wake on request and more concurrency on Scale; exe.dev Personal stops at 50 VMs at once, and bochka fits with up to 50 HTTPS ports per sandbox. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 Koyeb fits agent evals that start and stop many sandboxes; exe.dev pools bill whether VMs are busy or not. | 283rd of 364, with limits $1,050 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 | 288th of 377, with limits $504 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 exe.dev makes a good 24/7 dev box with root, SSH and a lasting disk, while Koyeb sandboxes have no SSH and a local disk that is lost on redeploy. | 25th cheapest of 368 $35 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 exe.dev nor Koyeb gives a sandbox a desktop, so computer-use agents have no screen; bochka streams a 60fps desktop with Chromium. | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 a month | 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 Koyeb runs GPU instances from RTX 4000 cards up to H100 and H200; exe.dev and bochka have no GPUs. | Can't run it | 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 | exe.dev | Koyeb | bochka |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor on rented bare-metal servers; you can't choose the kernel | MicroVM per instance, started from a Docker image | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Disk that survives | Disk persists and is streamed to a second server; no snapshots | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Disk kept across stops and saved every minute, with snapshots |
| Snapshots and fork | cp copies a VM's disk and config into a new VM | SDK snapshots of the filesystem or running processes, then new sandboxes from them (experimental) | Fork a running sandbox; named snapshots as templates |
| Sleep and wake | VMs run until you stop them; a stopped standalone VM pays no CPU or memory | Scales to zero after at least 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 |
| Access | SSH plus an HTTPS proxy for ports 3000 to 9999, one of them public; no raw TCP | One exposed HTTPS port at a time, plus an optional TCP proxy to one port; no SSH | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Open internet | Block all outbound traffic, or allow only listed IPs and CIDRs | Open internet, no provider-side allowlist |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Tutorials that run agents through the command API | Seven agents preinstalled, with one API to prompt, steer and stream events |
| Keeping API keys out of the sandbox | Integrations inject secrets at the network edge for any HTTP host | Secrets are set as environment variables inside the service | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Desktop and browser | Headless; no desktop | No desktop or browser in the sandbox SDK | 60fps Linux desktop with Chromium, computer use and browser control |
| Nested virtualization | Enterprise only | Not documented | Yes, /dev/kvm on every plan |
| GPUs | No | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | No |
| MCP server | Yes, at exe.dev/mcp | Yes, for managing Koyeb from agents | No |
| Regions | 9 regions in the US, Europe, Asia and Australia | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo, San Francisco in preview | EU only: Germany, Finland, France |
| Session length | No cap; VMs run until you stop them | No cap; optional auto-delete timers | No cap on paid plans; you set the TTL |
Every feature Battleships tracks (43)
| Feature | exe.dev | Koyeb | 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 | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Not published | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor Koyeb was part of the hpc-sandbox-benchmarks run, so there is no comparable CPU score for either. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, so its speed depends on how busy the host is.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and Koyeb 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 | exe.dev, 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 | $35 · Personal | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · with limits | $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 | $1,050 · Personal · with limits | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev Personal is a flat monthly pool that your VMs share and that bills whether they are busy or idle; standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour and pay no CPU or memory while stopped.
Koyeb: Koyeb bills each instance per second from the moment it starts, and Deep Sleep costs nothing. Pro is $29 a month with $10 of usage included and Scale is $299 with $100 included; the rest of the fee is not credit.
Koyeb: Plans start at $20 a month and the whole fee is usage credit. Sandboxes bill per second while they run, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal allows one pool of up to 16 vCPU and 50 VMs at once, so 300 user sandboxes or 1,000 short jobs at once don't fit there. 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 it throttles at 1,000 short jobs at once. bochka's $2,000 plan also queues starts above 90 a minute, so none of the three fits that burst as priced.
| Scenario | exe.dev | 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 | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want long-lived VMs you SSH into, with agents preinstalled, in regions outside Europe.
- A dev box you SSH into. Good for developers who want a VM that stays up with its disk, root, systemd and SSH, like a normal server.
- Agents preinstalled. Each VM comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, which you can prompt over its API.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
Use Koyeb when
your sandboxes sleep most of the time and must wake on a request, need GPUs, or need outbound traffic locked down.
- Sleep when idle, wake on request. Good for sandboxes that sit idle between requests: Koyeb scales them to zero and wakes them on the next one.
- GPUs in the same platform. Useful when an agent or eval needs a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Egress rules. Koyeb can cut a sandbox off from the internet or allow only listed IPs, which helps when running untrusted code.
Where bochka fits
If your agents do hours of real work, like builds, tests, Docker and checking a web app, look at bochka. It is a full VM with its own kernel, /dev/kvm on every plan, a disk saved every minute and a desktop, with agents you drive from outside. exe.dev keeps the disk but has no screen or snapshots, and Koyeb is built for sandboxes that sleep, not machines that keep their work.
A screen your agents can use
exe.dev VMs and Koyeb sandboxes are both headless, so an agent that must click through a web app has nothing to look at until you install and stream a desktop yourself. bochka streams a 60fps desktop with Chromium.
State saved every minute
exe.dev has no snapshots to roll back to, and Koyeb loses its local disk on redeploy unless you add a preview volume or experimental snapshots. bochka saves the disk every minute and can fork a running sandbox.
Drive agents inside from outside
On exe.dev only Shelley takes prompts through the API, and on Koyeb you build the harness on top of exec with keys as environment variables. bochka has one API to prompt, steer and stream seven agents.
Use bochka when your agents do real work for hours on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with one API to drive agents inside from outside. Compare it one to one: bochka vs exe.dev and bochka vs Koyeb.
Questions people ask
Is exe.dev cheaper than Koyeb?
It depends on the workload. For one agent that never stops, exe.dev is $35 a month and Koyeb $57, but for 50 agents in parallel Koyeb is $475 against $1,848 on exe.dev. bochka is $26 and $317 a month for those two.
Which is faster, exe.dev or Koyeb?
Neither has a comparable CPU measurement, since neither was in the hpc-sandbox-benchmarks run. Koyeb eco instances guarantee only half of each vCPU and burst above that. bochka scored 26.69 runs per second on that test.
Can exe.dev and Koyeb run Docker?
Yes. exe.dev VMs have root, systemd and Docker and can boot from your own image, and Koyeb starts each sandbox from a Docker image. bochka runs Docker inside a full VM and also exposes /dev/kvm, which exe.dev keeps for Enterprise and Koyeb does not document.
Do exe.dev and Koyeb keep files between sessions?
exe.dev keeps each VM's disk and streams it to a second server, but has no snapshots. Koyeb loses its local disk on redeploy and a deep sleep discards the VM, so lasting files need a preview volume or an SDK snapshot. bochka keeps the disk and saves it every minute.
Does either have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. exe.dev and bochka are CPU only.
Can I SSH into a Koyeb sandbox?
Koyeb sandboxes are driven through its Python and JavaScript SDKs, which run commands, read files and expose a port, rather than SSH. exe.dev and bochka both give you SSH into the machine.
Try bochka
Install the CLI, then run bochka new.
Product preview