Sprites vs Islo
Sprites and Islo both give each agent a microVM with its own kernel and a disk that stays. Sprites is a fixed machine that sleeps when idle and wakes on the next request, while Islo runs your own container image behind a gateway that checks and logs every outbound call.
The companies and products
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: 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 Neither exposes /dev/kvm and Sprites has no systemd, so full-stack builds with emulators or many services fit boat better, which ranks 3rd here. | 66th of 367, with limits $546 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, since a sandbox runs until you stop it; a Sprite pauses about 30 seconds after work stops and drops open connections unless a task holds it awake. | 157th of 366, with limits $1,166 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 Sprites suits short code runs: it sleeps soon after the last command, bills only the CPU and memory it used, and wakes in under a second. | 93rd of 345, with limits $140 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 Sprites does not publish its running cap on pay as you go and Islo's Team plan is reported at 50 running sandboxes, so 300 users at once is not confirmed on either. | 56th of 361, with limits $428 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 | 105th of 360, with limits $6,540 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; Sprites has no eval integration in its docs. | 125th of 364, with limits $545 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 Both run Docker for CI, but builds of Android apps or VM images need /dev/kvm, which boat exposes and neither documents. | 63rd cheapest of 377 $476 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 wants SSH and services: Islo gives SSH through its CLI, while a Sprite has no systemd and tunnels SSH through the sprite proxy. | 213th of 368, with limits $27 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 with no computer-use API, while boat streams a 60fps desktop with Chromium that agents can see and click. | 85th of 369, with limits $136 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 | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 141st of 338, with limits $4,113 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 | 210th of 360, with limits $223 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 | Sprites | Islo | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | MicroVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory set and scaled by the platform | You set the CPU cores, memory and disk each sandbox gets | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Image | One managed Ubuntu 25.10 image; you install on top of it | Built from your own container image | Start new sandboxes from named snapshots of one you set up |
| Inside the machine | Root and Docker, with docker exec failing for some images per users; no systemd, no /dev/kvm in the docs | Docker inside and sudo; no /dev/kvm or nested virtualization documented | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Idle behavior | Pauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 ms with memory | Pauses with files, processes and memory after an idle time you set at creation; resumes on exec, file access or webhook | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing and resumes by booting from disk |
| Fork | No fork; checkpoints restore the disk in place | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox with its disk into new ones |
| Reaching the sandbox | One HTTPS URL to one HTTP port, private by default; other ports and SSH only through the sprite proxy CLI | HTTPS share links anyone with the URL can open, expiring after 24 hours by default; SSH and port-forward through the CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; its own IP; SSH |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Gateway rules 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 | Connectors hold the token for GitHub, Slack or any HTTP API, with path allow and block lists | Gateway injects stored credentials into outbound requests for any host | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Claude Code, Cursor CLI and Codex preinstalled; factory lines with events, steer and follow-ups, started by schedule, webhook, GitHub, Slack or Linear | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Request logs | Not documented | Per-request gateway logs of what each agent called and what was blocked, streamed to your SIEM | Usage API and spend limits; no per-request log of outbound calls |
| Sandboxes at once | Pay-as-you-go cap not published; optional plans list 20 to 2,000 running; 10 creates a minute without a plan | Free 5 and Team 50 running sandboxes per launch coverage; paused ones do not count; more by contract | 100 to 2,000 running sandboxes by plan, raised by adding seats |
| Where it runs | Region not selectable | 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 | Sprites | Islo | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | 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 | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | 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 | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | 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 | 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) | No | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or Islo: neither is in the hpc-sandbox-benchmarks results we use. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on dedicated AMD Ryzen 9 9950X hosts in StarSling's run of 2026-09-29.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites 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 | Sprites, 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 | $23 · Pay-as-you-go | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $92 · Pay-as-you-go | $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,120 · Pay-as-you-go | $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 | $314 · Pay-as-you-go · 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,134 · Pay-as-you-go · with limits | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills measured CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans buy fixed CPU, memory and storage allowances, not credit.
Islo: Islo bills each CPU core and each GB of memory and disk you give a sandbox while it runs, with no plan fee. An idle sandbox keeps billing until a pause timer fires, which can only be set at creation, 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
Sprites does not publish how many Sprites run at once on pay as you go, and Islo's Team plan is reported at 50 running sandboxes, so neither confirms 300 sandboxes for your users or 1,000 short jobs at once. A Sprite also pauses when idle and drops open connections, so an always-on agent needs a task hold renewed at least every hour. boat has no session cap on paid plans, but even its $2,000 plan queues a 1,000-job burst and runs out of daily starts. Islo totals here leave egress out, since it has no published price.
| Scenario | Sprites | Islo | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops | None that bite |
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, billed only for the CPU and memory they use.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day: a Sprite pauses on its own and wakes on the next request in under a second.
- Bills the CPU and memory you use. For bursty work: a Sprite bills measured CPU time and actual memory only while awake, so a mostly idle machine costs little.
- Plugs into agent platforms. For teams on Claude Managed Agents or Cursor Cloud Agents: Sprites has a remote MCP server and documented setups behind both.
Use Islo when
you need per-host egress rules with a log of every outbound call, your own container image, or sandboxes in the US or your own cloud.
- Egress rules and request logs. For teams that must control what agents reach: Islo allows or blocks each host, path and method, and logs every call.
- Your own image. For stacks with set dependencies: an Islo sandbox is built from your container image, while every Sprite starts from one managed Ubuntu image.
- US region or your own cloud. For data that must stay in the US or your own account: Islo runs in US West or deploys inside your cloud with BYOC.
Where boat fits
Sprites and Islo both give an agent a headless microVM with a shell and a few ways in. If your agents need a full machine for hours, with systemd, emulators, a desktop, many open ports and forks of a running sandbox, boat covers that on dedicated hosts in the EU.
A full machine with systemd and /dev/kvm
A Sprite has no systemd, so services must be rewritten for its services API, and neither Sprites nor Islo documents /dev/kvm. Android emulators and nested VMs then stall or fall back to software emulation, which runs many times slower.
A desktop agents can see and use
Both are headless with no computer-use API, so an agent that checks a UI or fills a form in a real app has no screen. The workaround is installing a display server, browser and streaming layer yourself in every image.
Ports you can host on
A Sprite exposes one HTTP port, and Islo share links are public and expire after 24 hours by default. Anything else, like a database client or a second service, needs a CLI tunnel running on your own machine.
Use boat when your agents need a full machine for hours: systemd, Docker, /dev/kvm, a 60fps desktop, 50 HTTPS ports and raw TCP, forks of a running sandbox, and an API to drive the agents inside from outside. Compare it one to one: boat vs Sprites and boat vs Islo.
Questions people ask
Is Sprites cheaper than Islo?
In every scenario we priced, yes: one coding agent on workdays comes to $23 a month on Sprites against $101 on Islo, and one agent running all month is $92 versus $420. 50 agents in parallel come to $1,120 on Sprites against $4,863 on Islo, and boat lands at $317 for the same fleet.
Which is faster, Sprites or Islo?
We cannot say: neither is in the public benchmark results we use. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. A Sprite always has 8 vCPU, so a fair test would need a matching shape.
Can Sprites and Islo run Docker?
Both run Docker inside the VM. On Sprites, users report docker exec failing for images whose main process is not root, and its docs say Sprites do not run systemd. Neither documents /dev/kvm, which boat has on every sandbox.
Can I SSH into a Sprite or an Islo sandbox?
On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. Islo gives SSH and port forwarding through its CLI. boat sandboxes have SSH, raw TCP and their own IP.
Can I limit what an agent reaches on the internet?
Both, at different depths. Sprites can get a DNS-based domain allowlist, while Islo's gateway allows or denies by host, path and HTTP method and logs each request. boat has open internet, and its credentials proxy keeps real API keys out of the sandbox.
Where do Sprites and Islo run?
Sprites does not let you choose a region. Islo runs in US West, or inside your own cloud account with BYOC. boat runs only in the EU, in Germany, Finland and France, with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial