exe.dev vs Islo
exe.dev and Islo both give each machine its own VM with root and Docker, and neither has a desktop. exe.dev is a flat-priced pool of persistent dev boxes in nine regions; Islo is a metered agent sandbox in US West whose gateway controls and logs every outbound call.
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
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. “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 | Islo: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker, but neither has a desktop or /dev/kvm on standard plans, so UI checks and Android emulators need bochka. | 253rd of 367, with limits $3,701 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 All three fit always-on assistants: exe.dev keeps the VM running in its pool, Islo can pause an idle one with its memory and wake it on the next request, and bochka keeps the disk across stops. | 15th cheapest of 366 $3,833 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 | 235th of 345, with limits $175 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 Neither fits 300 sandboxes for your users at once: exe.dev Personal and Islo Team both stop at 50 running, while bochka fits on its $100 plan with token-protected URLs. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 built-in Harbor integration and gateway rules that stop trials from looking up answers; exe.dev runs evals as plain VMs, and bochka runs more of them at once. | 283rd of 364, with limits $1,050 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 Islo bills only while a runner is up, which suits CI; exe.dev pools bill whether jobs run or not, though its standalone VMs bill per second. | 288th of 377, with limits $504 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 For one box that stays on, exe.dev's flat pool comes to $35 a month against $402 on Islo's hourly meter, and bochka comes to $26 a month. | 25th cheapest of 368 $35 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 Both are headless, so a computer-use agent has no screen on either; bochka streams a 60fps desktop with Chromium that agents can see and click. | 240th of 369, with limits $1,055 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 ships a browser for tests inside the sandbox, on exe.dev you install a headless one yourself, and bochka adds a visible desktop and a computer-use API. | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | Can't run it | 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 | exe.dev | Islo | bochka |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor on rented bare-metal servers; you can't choose the kernel | A microVM with its own kernel for every sandbox | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and nested virtualization | Root, systemd and Docker; nested virtualization on Enterprise only | Docker inside and sudo; no /dev/kvm or nested virtualization documented | Docker, root, systemd and /dev/kvm on every plan |
| Desktop and computer use | Headless; no desktop or screen streaming | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Snapshots | None; the disk persists and is streamed to a second server | Snapshot a running sandbox's files and start new sandboxes from it | Snapshots every minute while running and on stop; named snapshots as templates |
| Pause and wake | A stopped standalone VM pays nothing for CPU and memory and keeps its disk; pools bill either way | Pause keeps files, processes and memory; can pause after idle time and resume on the next exec, file access or webhook | A stopped sandbox costs nothing and keeps its disk; resume reboots from disk |
| Fork | cp copies a VM's disk and config into a new VM | Start new sandboxes from a snapshot of a running one | Fork a running sandbox into new ones |
| Custom images | Boots from your own Docker image in about two seconds | Built from a container image | Templates from named snapshots; no Dockerfile or OCI images |
| Coding agents | Claude Code, Codex, Pi and Shelley; only Shelley takes prompts through the API | Claude Code, Cursor CLI and Codex; factory lines run agent steps with events, steer and follow-ups, on a schedule, webhook or GitHub, Slack and Linear events | Seven harnesses including Claude Code, Codex and OpenCode, with a prompt, steer and events API and TypeScript and Python SDKs |
| MCP server | Yes, at exe.dev/mcp | No | No |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | HTTPS share links anyone with the URL can open, expiring after 24 hours by default; SSH and port-forward through the CLI; no raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; its own IP |
| Outbound rules and logs | Open internet; no allowlist | Gateway allows or denies by host, path and HTTP method, can deny by default, and logs every request to your SIEM | Open internet; no provider-side allowlist; usage API and spend limits |
| Keeping keys out of the sandbox | Integrations inject secrets at the network edge for any HTTP host, S3, GitHub and a large catalog | Gateway injects stored credentials into outbound requests; credentials never reach the sandbox | Credentials proxy for model providers and any HTTPS API you register; switch to another account when credits run out |
| Sandboxes at once | Personal: 50 VMs in one pool plus up to 50 standalone VMs; Work pools above 32 vCPU need approval | Free 5 and Team 50 running sandboxes, per launch coverage; paused ones do not count | 100 to 2,000 running sandboxes by plan |
| Regions | 9 regions in the US, Europe, Asia and Australia | US West, or your own cloud account with BYOC | EU only: Germany, Finland, France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | exe.dev | Islo | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | 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 | Yes | Yes |
| Memory fork | No | No | 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 | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | 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 CPU measurement for exe.dev or Islo: neither was part of StarSling's public sandbox benchmark run. In that run of 2026-09-29, bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. We don't guess how the other two would score.
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 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 | exe.dev, 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 | $35 · Personal | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · with limits | $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 | $1,050 · Personal · with limits | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev sells reserved pools that your VMs share, from $15 a month on Personal, and a pool bills the same whether its VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
Islo: Islo bills each CPU core and each GB of memory and disk while a sandbox runs, by the hour, with no plan fee. An idle sandbox keeps billing until a pause-after-idle timer fires, and egress has no published price.
Islo: bochka's monthly plan fee, from $20, is all usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal and Islo Team both stop at 50 machines running at once, so 300 sandboxes for your users and 1,000 short jobs at once fit neither without a custom deal. exe.dev's flat pool is billed whether used or not, and Islo publishes no egress price, so every Islo total here leaves egress out. bochka allows 100 to 2,000 sandboxes by plan, but its start limits still queue a 1,000-job burst.
| Scenario | exe.dev | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want a flat-priced dev box or VM pool that stays on, in a region near your users, booted from your own Docker image.
- A flat price for a box that stays on. For one machine running all month, exe.dev's flat 4 vCPU pool is $35 a month, where Islo's hourly meter comes to $420.
- Regions around the world. Useful if your users are far from the US West coast: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Your own Docker image and an MCP server. exe.dev boots each VM straight from your own Docker image, and its MCP server lets tools like Claude Code control VMs.
Use Islo when
you need per-host egress rules with a log of every outbound call, or agents that pause with memory and wake on a request or event.
- Egress rules and request logs. Useful if you must control what agents reach: Islo allows or blocks each host, path and method, and logs every call.
- Pause with memory, wake on request. Useful for agents that sit idle between tasks: Islo pauses them with memory kept and resumes on the next request.
- Agent runs started by events. Islo's factory lines start agent steps on a schedule, a webhook, or GitHub, Slack and Linear events.
Where bochka fits
If your agents need more than a shell, look at bochka instead. exe.dev and Islo both give you a headless VM; bochka adds a desktop, /dev/kvm on every plan, ports you can host on, snapshots every minute and up to 2,000 sandboxes at once, all on a full VM in the EU.
A screen agents can see and use
exe.dev VMs and Islo sandboxes are both headless, so an agent that has to check a UI or click through an app has nothing to look at. On either you install a VNC stack and a control layer yourself.
Nested virtualization on every plan
Android emulators and tools that start their own VMs need /dev/kvm. exe.dev only offers nested virtualization on Enterprise, and Islo's docs do not mention it, so these jobs stop at the first emulator boot.
Ports you can host on
exe.dev makes one port public through its HTTPS proxy, and Islo share links are open to anyone with the URL and expire after 24 hours by default. Neither offers raw TCP; bochka serves 50 token-protected ports plus raw TCP.
Use bochka when your agents need a desktop, /dev/kvm, ports you can host on and state saved every minute, on up to 2,000 full VMs at once in the EU. Compare it one to one: bochka vs exe.dev and bochka vs Islo.
Questions people ask
Is exe.dev cheaper than Islo?
In every scenario we priced, yes. One coding agent on workdays comes to $35 vs $101 a month, one agent running all month to $35 vs $420, and 50 agents in parallel to $1,848 vs $4,863. Islo totals leave out egress, which has no published price.
Which is faster, exe.dev or Islo?
We can't say: neither has a CPU score in the public benchmark run we use. bochka scored 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB.
Can exe.dev and Islo run Docker?
Yes. exe.dev VMs have root, systemd and Docker, and Islo runs Docker inside its microVMs with sudo. Neither gives you /dev/kvm on standard plans; bochka has it on every plan.
Do exe.dev or Islo have a desktop for computer use?
No. exe.dev VMs are reached over SSH and an HTTPS proxy, and Islo sandboxes are headless with a browser for testing. bochka streams a 60fps desktop with Chromium and has a computer-use API.
Can I limit what an agent reaches on the internet?
On Islo, yes: its gateway allows or denies traffic by host, path and HTTP method and logs each request. exe.dev and bochka give sandboxes open internet, while both keep real keys out of the sandbox by injecting them at the edge.
Where do exe.dev and Islo run?
exe.dev has nine regions in the US, Europe, Asia and Australia. 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