Modal vs Islo
Modal gives you fast, short-lived sandboxes inside a big AI compute platform, with GPUs and regions around the world, but each one ends within 24 hours. Islo gives each coding agent its own microVM that can run for days, with a gateway that controls and logs every outbound call.
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.
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. “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 | Islo: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Islo runs Docker inside its microVMs, but documents no desktop or /dev/kvm, so browser testing on a screen and Android emulators need boat. | Can't run it | 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 An always-on agent hits Modal's 24-hour sandbox limit, while Islo keeps a microVM running with no session cap and can pause it with memory when idle. | 196th of 366, with limits $1,924 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 Short code runs at high volume suit Modal's fast starts and large container limits, while Islo's Team plan is reported at 50 running sandboxes. | 19th cheapest of 345 $181 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 Modal can run 300 sandboxes for your users at once on Team, which is more than the 50 reported for Islo's Team plan; boat fits too, with stopped sandboxes that keep their disk. | 11th cheapest of 361 $811 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 RL rollouts launch many short sandboxes at once, which is what Modal is built for; Islo needs a raised concurrency limit for large runs. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 | 126th cheapest of 377 $1,793 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 A dev box that stays up all week fits Islo, which has no published session cap, better than Modal, where every sandbox ends within 24 hours. | 138th of 368, with limits $23 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 Modal nor Islo ships a desktop or computer-use API, while boat streams a 60fps desktop with Chromium that agents can see and click. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Modal rents GPUs from T4 to B300 and neither Islo nor boat has any, so Modal is the pick for GPU jobs. | 19th cheapest of 98 $1,187 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 | Modal | Islo | boat |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel is a separate option | Every sandbox is a microVM with its own kernel | Every sandbox is a full VM with its own kernel |
| Docker inside | Only with the VM runtime | Yes, with sudo | Yes, with root and systemd, in every sandbox |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | No /dev/kvm or nested virtualization documented | Yes, /dev/kvm on every machine (Android emulators, Firecracker) |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop, Chromium and a computer-use API built in |
| Pause and resume | No paused state; a finished sandbox is gone, only Volumes keep files | Pause keeps files, processes and memory; wakes on the next exec, file access or webhook | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume reboots from disk |
| Longest session | 24 hours (default 5 minutes) | No published cap | No cap on paid plans (default TTL 1 h, changeable) |
| Fork | Snapshot the filesystem into an image and boot new sandboxes from it | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox without stopping it |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Outbound internet rules | Block all, IP-range allowlist, domain allowlist (beta) | Gateway rules by host, path and HTTP method, default deny, rate limits, per-request logs | Open internet; no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Gateway injects stored credentials into outbound requests for any host | AI credentials proxy for model providers and any HTTPS API you register |
| Coding agents | Examples only | Claude Code, Cursor CLI and Codex preinstalled, with factory lines that run agent steps | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Reaching the sandbox | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | 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 by default, plus raw TCP |
| Sandboxes at once | 100 containers on Starter, 5,000 on Team, more on Enterprise | 5 on Free and 50 on Team per launch coverage; paused ones do not count | 100 to 2,000 running sandboxes by plan |
| Where it runs | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | US West, or inside your own cloud account with BYOC | EU only: Germany, Finland, France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | Modal | Islo | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | 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 | 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 | No | 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 | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public benchmark run of 29 September 2026 at 4 vCPU / 8 GB, Modal's default gVisor sandbox finished 12.79 Node.js build-and-test runs per second and boat finished 26.69, about twice as much. Islo was not part of that run or the other public results we use, so there is no comparable Islo number.
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. Islo 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 | Islo, a month | boat, 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 | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for whichever is higher, the CPU and memory you request or 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.
Islo: Islo bills each CPU core and each GB of memory and disk you give a sandbox while it runs, per hour, with no plan fee. An idle sandbox keeps billing until a pause-after-idle timer fires, and egress has no published price.
Islo: boat plans start at $20 a month and the whole fee becomes usage credit, spent by the second while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
On Modal a sandbox lives at most 24 hours and its root disk is wiped when it ends, so the workday, always-on and 50-agent scenarios only keep files you put in a Volume, and the fleet also needs the VM runtime for Docker. Islo's Team plan is reported at 50 running sandboxes, so 300 sandboxes for your users and 1,000 short jobs at once do not fit without a custom contract, and Islo totals leave out egress because it has no published price. No one fits 1,000 jobs at once as listed: boat starts at most 90 sandboxes a minute, so that burst queues for several minutes.
| Scenario | Modal | Islo | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| 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 Modal when
your sandboxes need GPUs, must run outside the US or Europe, or are huge bursts of short jobs that finish in minutes.
- GPUs next to your sandboxes. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 on the same platform as its sandboxes.
- Huge bursts of short jobs. Useful for code runs and RL rollouts at scale: Modal runs up to 5,000 containers on Team, against 50 reported for Islo.
- Regions around the world. Useful if users sit far from the US: Modal runs in the US, EU and Asia-Pacific, while Islo's cloud is US West.
Use Islo when
your coding agents run for hours or days in a VM and you need per-host egress rules with a log of every call, pause with memory, or your own cloud account.
- A VM that runs for days. Useful for long agent jobs: Islo's microVMs have their own kernel, run Docker and have no published session cap, unlike Modal's 24 hours.
- 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.
Where boat fits
Look at boat if your agents need a whole computer, not just a shell: a screen, Docker, /dev/kvm and a disk that stays. Modal and Islo each cover part of that, and neither has a desktop. boat gives every sandbox all of it, on a machine that did about twice the CPU work of Modal's default sandbox.
A desktop agents can see and use
Without a screen an agent cannot open the app it built and check it. Modal only has an example for setting up VNC yourself, and Islo is headless with a test browser and no computer-use API.
Docker, systemd and /dev/kvm in every sandbox
Android emulators and tools that start their own VMs stop at boot without /dev/kvm. Modal needs its VM runtime for Docker and gives nested virtualization only on request on Team, and Islo documents no /dev/kvm.
A disk saved every minute, free to stop
On Modal a sandbox ends within 24 hours and anything outside a Volume is lost. On Islo an idle sandbox keeps billing unless a pause-after-idle timer was set when it was created.
Use boat when your agents need a whole computer: a 60fps desktop, Docker and /dev/kvm, ports you can host on, and a disk that stays, on a fast VM in the EU. Compare it one to one: boat vs Modal and boat vs Islo.
Questions people ask
Is Modal cheaper than Islo?
In most of our scenarios Modal costs less: one agent running all month is $178 on Modal against $420 on Islo, and 50 parallel agents are $2,229 on Modal against $4,863 on Islo. But Modal does not fit those as listed, because of its 24-hour limit and no Docker in the default sandbox. boat comes to $26 and $317 for the same two.
Which is faster, Modal or Islo?
Only Modal has a public measurement: its default sandbox finished 12.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Islo was not benchmarked. boat finished 26.69 in the same run, about twice Modal's default sandbox.
Can Modal and Islo run Docker?
Islo runs Docker inside every microVM. Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. boat runs Docker in every sandbox, with systemd and /dev/kvm.
How long can a sandbox run on Modal and Islo?
A Modal sandbox lasts 5 minutes by default and 24 hours at most. Islo publishes no session cap, and a sandbox runs until you stop it or a lifecycle rule pauses or deletes it. boat has no session cap on paid plans.
Do Modal or Islo have GPUs?
Modal does, from T4 up to B300, on its default gVisor runtime. Islo has no GPUs, and neither does boat.
Can I limit what an agent reaches on the internet?
Both can. Modal can block all outbound traffic or allow chosen IP ranges, with a domain allowlist in beta. Islo's gateway allows or denies by host, path and HTTP method and logs each request; boat has open internet with no provider-side allowlist.
Try boat
Install the CLI, then run boat new.
7-day free trial