Beam vs Islo
Beam is a serverless GPU platform whose sandboxes are fast gVisor containers, with separate CPU VMs on the side. Islo is built only for coding agents: each one gets a microVM with its own kernel, and a gateway controls and logs what it reaches.
The companies and products
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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. “8th cheapest of 345” means 7 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 | Beam: 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 | 69th of 367, with limits $551 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 well, since it can pause with its memory and wake on the next request; Beam sandboxes end with their time to live unless you set it to run forever. | 115th of 366, with limits $651 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 Beam fits short code runs well: sandboxes start in a second or two, bill per second and end on their own when the timer runs out, while Islo bills more for the same work. | 8th cheapest of 345 $117 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 Beam's Team plan allows 1,000 containers at once, so 300 sandboxes for your users fit, while Islo's Team plan is reported at 50 running sandboxes; bochka fits too, with a full VM per user. | 3rd cheapest of 361 $290 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 | 341st of 360, with limits $939 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; Beam and bochka both run many more eval sandboxes at once. | 13th cheapest of 364 $251 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 jobs, but neither documents /dev/kvm, so Android builds and VM image builds need bochka. | 12th cheapest of 377 $171 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 | 13th cheapest of 368 $21 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 Beam nor Islo has a desktop or a computer-use API; bochka streams a 60fps desktop with Chromium that agents can see and click. | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 Islo's per-host egress rules and request logs help keep red-team agents contained; bochka runs many more of them at once on full VMs. | 175th of 360, with limits $155 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 Only Beam has GPUs here, from RTX 4090 to H100 and B200; Islo and bochka are CPU only. | Cheapest of 98 $458 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 | Beam | Islo | bochka |
|---|---|---|---|
| Isolation | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | Every sandbox is a microVM with its own kernel | Every sandbox is a full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Docker and systemd | Docker inside sandboxes with docker_enabled; systemd only in Beam VMs | Docker inside and sudo; systemd not documented | Docker, systemd and root, like a normal Ubuntu server |
| Nested virtualization | Not documented | No /dev/kvm or nested virtualization documented | Yes, /dev/kvm for Android emulators and VMs |
| GPUs | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | No, CPU only | No, CPU only |
| Desktop and computer use | No desktop or browser product | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | None preinstalled; you install and run them through process exec | 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 and five other agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables inside the sandbox | 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 |
| Outbound rules | Block all outbound traffic, or allow up to 10 CIDR ranges, changeable while running | Gateway rules by host, path and HTTP method, default deny, rate limits, and a log of every request | Open internet, no provider-side allowlist |
| Pause and snapshots | Memory snapshot of a running sandbox, restored into new sandboxes | Pause keeps files, processes and memory; can pause after idle time and wake on the next exec, file access or webhook | Disk saved every minute and on stop; a stopped sandbox costs nothing; fork a running sandbox |
| Disk between runs | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk | Files kept while paused; snapshots of a sandbox's files start new ones | Disk is saved every minute and on stop, and a stopped sandbox keeps it for free |
| Reaching the sandbox | A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | 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 by default; raw TCP; dedicated IPv4 or IPv6 |
| Sandboxes at once | Developer 30 CPU containers, Team 1,000, Growth by contact | Free 5 and Team 50 running sandboxes per launch coverage; paused ones do not count | 100 to 2,000 running sandboxes by plan, raised by adding seats |
| Where it runs | US only; open-source Beta9 to self-host, or bring your own cloud for a fee | 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 | Beam | Islo | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | 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 | 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) | Yes | Yes | Yes |
| Memory fork | Yes | 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 | 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 | 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 | Yes | 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 | No | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Beam nor Islo has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which is faster at CPU work. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Beam 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 | Beam, 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 | $5 · Developer | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $22 · Developer | $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 | $410 · Team | $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 | $191 · 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 | $259 · Team | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Beam: Beam sandboxes bill per second for each CPU core (one core is two vCPU) and each GiB of RAM, until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team costs $89 a month plus usage, with no usage credit and no egress fees.
Islo: Islo bills each CPU core and each GB of memory and disk while a sandbox runs, billed per hour, with no plan fee and signup credits with no card. An idle sandbox keeps billing until a 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 Beam's Team plan allows 1,000 containers and fits both. Beam's Developer plan allows 30 CPU containers, so 50 parallel agents need Team. Beam publishes no price for disk beyond what a VM includes and Islo publishes no egress price, so those are left out of the totals. bochka's start limits queue the 1,000-job burst on its $2,000 plan.
| Scenario | Beam | Islo | bochka |
|---|---|---|---|
| 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 Beam when
your agents or evals need GPUs, when you run large bursts of short jobs, or when you want to self-host the open-source runtime.
- GPUs in the same platform. For agents or evals that need a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100 and B200.
- Large bursts of short jobs. For many short runs at once, Beam's Team plan allows 1,000 containers that start in a second or two and bill per second.
- Open source and self-hosting. For teams that must run it themselves, the Beta9 runtime is AGPL-3.0 and free to self-host.
Use Islo when
you want each coding agent in its own microVM with per-host egress rules, a log of every outbound call, keys injected at a gateway, and pause with memory.
- A microVM for every agent. For agents running untrusted code, every Islo sandbox is a microVM with its own kernel, not a shared-kernel container.
- 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.
- Keys and agents built in. For coding agents, Islo preinstalls Claude Code, Cursor CLI and Codex and injects credentials at a gateway, so keys never enter the sandbox.
Where bochka fits
If what you are really running is coding or computer-use agents that work for hours, look at bochka. Each sandbox is a full VM with /dev/kvm, systemd, a 60fps desktop and ports you can host on, things neither Beam nor Islo documents. bochka also runs up to 2,000 sandboxes at once, with real keys kept outside in a credentials proxy.
A desktop agents can see and use
Neither Beam nor Islo has a screen or a computer-use API, so an agent that must check a UI or fill a form in a real app needs a VNC stack you build into each image. bochka streams a 60fps desktop with Chromium.
Nested virtualization and systemd
Android emulators and tools that start their own VMs stop at boot without /dev/kvm, which neither Beam nor Islo documents. Beam sandboxes also have no systemd. Every bochka sandbox has root, systemd, Docker and /dev/kvm.
Ports you can host on
Beam gives each port a public URL with no auth, and Islo share links are public and expire after 24 hours by default; neither offers raw TCP. bochka serves 50 token-protected HTTPS ports, raw TCP and a dedicated IP.
Use bochka when your agents do real work over hours: Docker, emulators with /dev/kvm, a desktop for computer use and ports you can host on, on a full VM in the EU. Compare it one to one: bochka vs Beam and bochka vs Islo.
Questions people ask
Is Beam cheaper than Islo?
Yes, in every scenario we priced. One agent running all month comes to $22 on Beam and $420 on Islo, and 50 agents in parallel come to $410 versus $4,863. bochka lands at $26 and $317 for the same two.
Which is faster, Beam or Islo?
We cannot say for CPU work, since neither has a result on the StarSling CPU benchmark we use. Beam's guide says its sandboxes cold-boot in 1 to 3 seconds. bochka did 26.69 runs per second on that benchmark at 4 vCPU / 8 GB.
Are Beam and Islo sandboxes VMs or containers?
Beam sandboxes are gVisor containers by default, and Beam sells separate CPU microVMs with their own kernel. Every Islo sandbox is a microVM with its own kernel. Every bochka sandbox is a full VM with its own kernel and /dev/kvm.
Can Beam and Islo run Docker?
Yes. Beam supports Docker inside a sandbox with docker_enabled, and Islo runs Docker inside its microVMs. Neither documents /dev/kvm, which bochka has for emulators and nested VMs.
Do Beam or Islo have a desktop for computer use?
No. Beam has no desktop or browser product, and Islo has a browser for testing but no screen or computer-use API. bochka streams a 60fps desktop with Chromium and has a computer-use API on every sandbox.
Can I limit what an agent reaches on the internet?
On both. Beam can block all outbound traffic or allow up to 10 CIDR ranges, and Islo's gateway allows or denies by host, path and HTTP method and logs each request. bochka has open internet with no provider-side allowlist.
Try bochka
Install the CLI, then run bochka new.
Product preview