Runloop vs Islo
Both give each coding agent its own VM. Runloop adds a desktop for computer use, arm64 and Dockerfile builds, while Islo adds a gateway that checks and logs every outbound request and pauses idle sandboxes with their memory kept.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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. “20th cheapest of 367” means 19 of the other 366 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 | Runloop: 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 Runloop fits fully, while Islo is a compromise with no desktop or /dev/kvm documented; boat adds /dev/kvm for Android emulators on top of a desktop. | 20th cheapest of 367 $8,152 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: Islo pauses an idle assistant with its memory on any plan, Runloop needs the Pro plan to suspend, and boat keeps the disk across free stops. | 32nd cheapest of 366 $10,194 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 | 44th cheapest of 345 $525 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 300 sandboxes for your users at once is more than the 50 running sandboxes reported for Islo's Team plan, while Runloop publishes no cap and boat fits on its plans. | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts because it starts large waves without published start limits; Islo's 50-sandbox Team limit makes it a compromise. | 4th cheapest of 360 $15,922 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, but its Team limit caps how many run at once; boat ranks higher than both. | 81st cheapest of 364 $2,562 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 Runloop and Islo are close here and both run Docker inside; boat's faster CPUs finish builds and test runs sooner. | 121st cheapest of 377 $1,554 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 | 113th cheapest of 368 $410 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 Runloop ships a desktop and browser an agent can control, while Islo sandboxes are headless; boat streams its desktop at 60fps and you can embed it in your app. | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 Both can lock a sandbox to listed hosts; Islo goes further with path and method rules and a log of each call, and boat adds a full kernel with nested virtualization. | 10th cheapest of 360 $770 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 | Runloop | Islo | boat |
|---|---|---|---|
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | Every sandbox is a microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and nested virtualization | Docker on the dnd blueprints, as root; no nested virtualization documented | Docker inside and sudo; no /dev/kvm or nested virtualization documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | Desktop and browser an agent can control | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Images and CPU architecture | Blueprints built from Dockerfiles; x86_64 and arm64 | Built from a container image; x86_64 | Templates from named snapshots, no Dockerfile builds; x86_64 only |
| Idle pause and wake | Suspend after idle, wake on an HTTP request to the tunnel (Pro plan) | Pause keeps files, processes and memory; resume on the next exec, file access or webhook, on any plan | No idle timer; disk snapshot every minute and on stop, a stopped sandbox costs nothing, resume reboots from disk |
| Keeping files | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox | Kept through pause; snapshots of a running sandbox's files | Snapshot every minute and on stop, on every plan; resume with the same disk |
| Long runs | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it | No published cap; runs until you stop it | No session cap on paid plans; default TTL 1 hour, changeable |
| Reaching the sandbox | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy; no public IP | HTTPS share links anyone with the URL can open, 24-hour TTL by default; SSH and port-forward through the CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; its own IP |
| Outbound internet rules | Hostname allowlist with wildcards, or block all | Gateway rules by host, path and HTTP method, default deny, rate limits and content filters | Open internet on every plan; no provider-side allowlist |
| Request logs | Not documented | Per-request gateway logs of each call and each block, streamed to your SIEM | Usage API and spend limits; no per-request log of outbound calls |
| Keeping keys out of the sandbox | Agent gateways for any API endpoint with bearer, header or basic auth | Gateway injects stored credentials into outbound requests for any host | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Claude Code, Cursor CLI and Codex preinstalled; factory lines run agent steps on a schedule, webhook or GitHub, Slack and Linear events | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Sandboxes at once | No cap published for Basic or Pro; 3 on the trial | Free 5 and Team 50 running sandboxes per launch coverage; more by contract | 100 to 2,000 running sandboxes by plan, raised by adding seats |
| Where it runs | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | US West, or inside your own cloud account with BYOC | EU only: Germany, Finland, France; EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | Islo | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | 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) | 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 | 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 | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | 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) | No | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Not published | Not published | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On StarSling's Node.js build-and-test benchmark at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), Runloop scored 8.29 runs a second and boat 26.69, about 3.2 times faster. Islo was not part of that run or the other public results we use, so there is no comparable score for it. The test measures CPU work only, not start time or network speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. 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 | Runloop, 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 | $113 · Basic | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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,184 · Basic | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate, including start, suspend and resume, and bills disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend.
Islo: Islo bills each CPU core and GB of memory and disk while a sandbox runs, billed per hour, with no plan fee. An idle sandbox keeps billing until a pause-after-idle timer fires, and that timer is set only at creation.
Islo: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. 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 without a custom contract; Runloop publishes no cap there and fits both. Runloop's lifetime setting tops out at 48 hours unless an idle policy replaces it, and suspend needs Pro. Neither publishes an egress price, so their totals leave egress out. boat fits every scenario except the 1,000-job burst, where its start limits queue the jobs.
| Scenario | Runloop | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Runloop when
your agents need a desktop to click, arm64 or Dockerfile builds, very large waves of short jobs, or devboxes inside your own AWS, GCP or Azure account.
- A desktop for computer use. Useful if your agent must see and click a screen: Runloop ships a desktop and browser it can control, while Islo is headless.
- arm64 and Dockerfile builds. Useful for arm64 builds and teams with Dockerfiles: Runloop builds blueprints from Dockerfiles and offers arm64 machines.
- Large waves of sandboxes. Useful for RL rollouts and big bursts: Runloop publishes no concurrency cap on paid plans, while Islo's Team plan is reported at 50.
Use Islo when
you need rules and a log for every outbound request, sandboxes that pause with memory and wake on request without a plan fee, or a US region or your own cloud.
- Rules and logs for every request. Useful if you must control what agents reach: Islo allows or blocks each host, path and method, and logs every call.
- Pause with memory on any plan. Useful for agents that sit idle: Islo pauses with memory kept and wakes on the next request, with no plan fee.
- Sessions with no lifetime setting. Useful for long unattended jobs: an Islo sandbox runs until you stop it, with no keep-alive timer to replace.
Where boat fits
Runloop and Islo both put agents in microVMs and focus on control: tunnels, gateways and egress rules. If your agents do heavy work for hours, such as builds, tests, Docker, emulators or servers others connect to, boat gives each one a full VM on faster CPUs with ports you can host on. Pick Runloop or Islo instead if a provider-side egress allowlist or a US region is a must.
Nested virtualization
Neither Runloop nor Islo documents /dev/kvm, so an Android emulator or a VM inside the sandbox does not start. boat exposes /dev/kvm with root and systemd on every machine.
Ports you can host on
Runloop reaches devboxes through one HTTPS tunnel and Islo through share links that expire after 24 hours by default, and neither offers raw TCP. boat serves up to 50 HTTPS ports, raw TCP and its own IP.
Faster CPUs, files kept for free
boat ran 26.69 build-and-test runs a second to Runloop's 8.29, and Islo has no public score. Keeping a disk on Runloop needs the $250 Pro plan or your own snapshot code; boat saves it every minute and stops cost nothing.
Use boat when your agents do real work for hours: builds, tests, Docker and emulators on faster CPUs, with a 60fps desktop, ports you can host on and files kept on every plan. Compare it one to one: boat vs Runloop and boat vs Islo.
Questions people ask
Is Runloop cheaper than Islo?
Islo comes out a little lower in our scenarios: one coding agent on workdays is $101 a month on Islo and $113 on Runloop, and 50 agents in parallel are $4,863 versus $5,268. boat comes to $20 and $317 for the same work. Islo's 50-sandbox Team limit means it does not fit 300 user sandboxes at once.
Which is faster, Runloop or Islo?
We cannot say: Runloop scored 8.29 runs a second on StarSling's Node.js benchmark at 4 vCPU / 8 GB, and Islo has no public score. boat scored 26.69 on the same test.
Can Runloop and Islo run Docker?
Yes. Runloop runs Docker on its Docker-in-Docker blueprints, and Islo runs Docker inside its microVMs. Neither documents /dev/kvm, so Android emulators and VMs need boat, which exposes it.
Does Runloop or Islo have a desktop for computer use?
Runloop ships a desktop and browser an agent can control. Islo sandboxes are headless, with a browser for testing and no computer-use API. boat streams a 60fps desktop with Chromium that you can embed in your app.
Can I limit what an agent reaches on the internet?
On both. Runloop allows listed hostnames with wildcards or blocks all traffic, and Islo checks host, path and HTTP method and logs every request. boat has open internet with no provider-side allowlist, and its credentials proxy keeps real API keys out of the sandbox.
Where do Runloop and Islo run?
Runloop does not document its regions, and its Enterprise plan deploys into your own AWS, GCP or Azure account. Islo runs in US West or in your own cloud account with BYOC. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial