Koyeb vs Islo
Both run each sandbox in a microVM with its own kernel. Koyeb is a serverless cloud whose sandboxes sleep when idle, run on GPUs and live in many regions, while Islo is built for coding agents, with a gateway that filters outbound traffic and keeps credentials out of the sandbox.
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.
Islo
Islo is an agent sandbox from Incredibuild: each coding agent gets its own microVM, with network rules and credentials handled at a gateway.
An Islo sandbox is a Linux microVM with its own kernel, built from a container image, with Claude Code, Cursor CLI and Codex preinstalled. Outbound traffic can pass through a gateway that allows or blocks hosts, injects credentials and logs every request. It is built for teams that run coding agents, evals and RL rollouts in the background, on Islo's cloud or in their own cloud account.
- Launched
- May 4, 2026
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 | Islo: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 54th of 367, with limits $366 a month | 326th of 367, with limits $7,402 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Islo fits an always-on assistant fully, since it can pause with memory and wake on the next request; on Koyeb a deep sleep throws away the VM. | 135th of 366, with limits $923 a month | 30th cheapest of 366 $9,928 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 ranks 4th for short code runs, with small instances that scale to zero after 5 idle minutes; Islo needs a raised concurrency limit for big bursts. | 4th cheapest of 345 $66 a month | 153rd of 345, with limits $503 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 ranks 6th and fits 300 user sandboxes at once on Scale, while Islo's Team plan is reported at 50 running sandboxes; bochka ranks 1st. | 6th cheapest of 361 $495 a month | 171st of 361, with limits $3,160 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 | 237th of 360, with limits $1,631 a month | 167th of 360, with limits $15,265 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 Islo has a Harbor integration and gateway rules that stop trials from looking up answers, while Koyeb runs more sandboxes at once; bochka ranks 10th. | 19th cheapest of 364 $429 a month | 198th of 364, with limits $2,456 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 boots Android emulators or VMs needs /dev/kvm, which neither Koyeb nor Islo documents and bochka exposes on every machine. | 142nd of 377, with limits $88 a month | 119th cheapest of 377 $1,507 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 | 112th cheapest of 368 $402 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 Islo has a desktop or a computer-use API; bochka streams a 60fps Linux desktop with Chromium that agents can see and click. | 81st of 369, with limits $123 a month | 310th of 369, with limits $2,210 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 Islo has a browser inside the sandbox for testing, Koyeb leaves you to install one, and bochka adds a visible desktop and a computer-use API. | 172nd of 367, with limits $123 a month | 113th of 367, with limits $1,105 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 | 66th cheapest of 346 $748 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 | 265th of 338, with limits $14,966 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 | 47th of 360, with limits $746 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 with GPU instances up to H100 and H200; Islo 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 | Islo | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance | MicroVM with its own kernel per sandbox | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and nested virtualization | Starts from any Docker image; nested virtualization not documented | Docker inside and sudo; no /dev/kvm documented | Docker, root, systemd and /dev/kvm on every machine |
| Files that survive | Local disk is lost on redeploy and a deep sleep discards the VM; volumes (preview, 1 to 10 GB) persist | Pause keeps files, processes and memory; snapshots of a running sandbox's files | Disk 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 | Pauses after a set idle time with memory kept; resumes on the next exec, file access or webhook | Stop and start by API; a stopped sandbox costs nothing and keeps its disk, and resume reboots from disk |
| Fork | SDK snapshots of files or running processes, then new sandboxes from them (experimental) | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox with its disk |
| Reaching the sandbox | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | HTTPS share links anyone with the URL can open, expiring after 24 hours by default; SSH through the CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; its own IP |
| Outbound rules | Block all outbound traffic, or allow only listed IPs and CIDRs | Allow or deny by host, path and HTTP method, with default deny, rate limits and content filters | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets are set as environment variables inside the service | Gateway injects stored credentials into outbound requests; they never reach the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | Claude Code, Cursor CLI and Codex preinstalled; factory lines with events, steer and triggers | Seven agents preinstalled, with a prompt, steer and events API |
| Desktop and browser | No desktop or browser in the sandbox SDK | A browser for testing; no desktop or computer-use API | 60fps Linux desktop with Chromium and computer use |
| Request logs | Audit logs on Enterprise; no per-request log of outbound calls documented | Per-request gateway logs of every outbound call, streamed to your SIEM | Usage API and spend limits; no per-request log |
| Sandboxes at once | 100 services on Pro, 1,000 on Scale | Free 5 and Team 50 running sandboxes per launch coverage; more by contract | 100 to 2,000 running sandboxes by plan |
| GPUs | RTX 4000 SFF Ada up to H100 and H200 | No | No |
| Where it runs | EU, US and Asia; edge and on-premise for Enterprise | US West, or your own cloud account with BYOC | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Koyeb | Islo | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Not published | Yes | Yes |
| Memory fork | Yes | No | 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 | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | 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 | Yes | 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 | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | No | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Koyeb or Islo: neither was part of StarSling's hpc-sandbox-benchmarks run. In that run bochka did 26.69 Node.js build-and-test runs per second 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. Koyeb and Islo 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 | Islo, 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 | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $57 · Pro | $420 · Free | $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 | $4,863 · Team | $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 | $1,382 · Team · with limits | $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,053 · Team · with limits | $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 a month with $100 included.
Islo: Islo bills each CPU core and each GB of memory and disk while a sandbox runs, billed per hour, with no plan fee. An idle sandbox keeps billing until its pause-after-idle timer fires, and egress has no published price.
Islo: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Islo's Team plan is reported at 50 running sandboxes at once, so 300 sandboxes for your users and 1,000 short jobs at once do not fit it without a custom contract, while Koyeb's Scale plan fits the 300. Koyeb's priced shape is eco-xlarge, which has a 20 GiB disk with no published price for more and guarantees only half of each vCPU, so it throttles in the 1,000-job burst. Islo publishes no egress price, so every Islo total here leaves egress out.
| Scenario | Koyeb | Islo | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Koyeb when
your sandboxes need GPUs, sleep most of the time and must wake on a request, run in the US or Asia, or number in the hundreds.
- 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.
- Sleep when idle, wake on request. Good for sandboxes that sit idle between requests: Koyeb scales to zero and wakes in about 200 ms with Light Sleep.
- Many regions and more at once. Good if you need the US, EU or Asia, or hundreds of sandboxes: Scale allows 1,000 services.
Use Islo when
your coding agents need per-host egress rules, credentials injected at a gateway with a log of every call, or a US region or your own cloud account.
- Egress rules and request logs. Useful if you must control what agents reach: Islo filters by host, path and method, and logs every call.
- Keys that never enter the sandbox. Islo's gateway adds stored credentials to outbound requests, so the agent never sees the real key.
- Coding agents and memory pause built in. Claude Code, Cursor CLI and Codex come preinstalled, and an idle sandbox pauses with memory and wakes on request.
Where bochka fits
Koyeb and Islo both give an agent a headless microVM. If your agents need a screen, /dev/kvm or ports other people can reach, neither covers it, and bochka does on a full VM that keeps its disk. bochka is also the one to look at if your data must stay in the EU on a platform built for agents.
/dev/kvm, root and systemd
Neither Koyeb nor Islo documents nested virtualization, so Android emulators, Firecracker or QEMU VMs stop at the first boot. bochka exposes /dev/kvm on every machine, next to Docker, root and systemd.
A desktop agents can see
Koyeb sandboxes have no desktop or browser, and Islo has only a browser for tests. On both you build a VNC stack and a control layer into every image; bochka streams a 60fps desktop with Chromium and a computer-use API.
Ports you can host on
Koyeb exposes one HTTPS port at a time, and Islo share links open to anyone with the URL and expire after 24 hours by default. bochka serves up to 50 token-protected HTTPS ports, plus raw TCP.
Use bochka when your agents need more than a headless shell: a desktop for computer use, /dev/kvm for emulators, ports you can host on, and a disk that stays, on a full VM in the EU. Compare it one to one: bochka vs Koyeb and bochka vs Islo.
Questions people ask
Is Koyeb cheaper than Islo?
In every scenario we priced, yes: one agent that never stops comes to $57 a month on Koyeb and $420 on Islo, and 50 agents in parallel come to $475 against $4,863. bochka lands below both, at $26 and $317, and Islo leaves egress out because it publishes no price.
Which is faster, Koyeb or Islo?
There is no comparable measurement: neither was part of the public benchmark run we use. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB.
Can Koyeb and Islo run Docker?
Koyeb starts each sandbox from a Docker image, and Islo runs Docker inside its microVMs with sudo. Neither documents /dev/kvm, which bochka exposes for Android emulators and VMs alongside Docker and systemd.
Which one controls outbound traffic better?
Islo: its gateway allows or denies by host, path and HTTP method, can deny by default and logs each request. Koyeb can block all outbound traffic or allow listed IPs and CIDRs. bochka has open internet, with a credentials proxy that keeps real API keys out of the sandbox.
Do Koyeb and Islo keep files when a sandbox sleeps?
Islo's pause keeps files, processes and memory. Koyeb's local disk is lost on redeploy and a deep sleep discards the VM, so lasting files need a volume, which is in preview. bochka keeps the disk across stops and saves it every minute.
Where do Koyeb and Islo run?
Koyeb runs in Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more. Islo runs in US West or inside your own cloud account with BYOC. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview