Morph Cloud vs Islo
Both give each agent a VM with its own kernel that can pause with its memory and wake on request. Morph Cloud is built around branching a running machine into many copies, while Islo comes with coding agents preinstalled and a gateway that controls and logs what they reach.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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. “16th cheapest of 345” means 15 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 | Morph Cloud: 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 | 198th of 367, with limits $2,288 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 better than Morph, with preinstalled agents and scheduled or webhook-started runs; bochka adds a desktop and a credentials proxy for any HTTPS API. | 235th of 366, with limits $3,014 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 Morph fits short code runs better: a paused machine bills only its snapshot and wakes on the next request, while Islo's Team plan stops at 50 running sandboxes. | 16th cheapest of 345 $154 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 Morph's Scale plan holds 300 user sandboxes at once, which Islo's reported Team limit of 50 does not; bochka also fits and gives each user HTTPS on up to 50 ports. | 12th cheapest of 361 $905 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 Morph's memory branching suits rollouts that all start from the same running state; Islo's snapshots copy files, so each new sandbox boots fresh. | 86th of 360, with limits $4,847 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; Morph and bochka both fit evals at more sandboxes at once. | 38th cheapest of 364 $675 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 Morph also sells managed GitHub Actions runners; Islo and bochka run builds inside their own sandboxes. | 39th cheapest of 377 $355 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 | 85th cheapest of 368 $116 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 has a computer use API: Morph offers a remote desktop you fill yourself and Islo sandboxes are headless, while bochka ships a 60fps desktop with Chromium. | 182nd of 369, with limits $595 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 | 214th of 367, with limits $250 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 Islo fits startup-scale scraping with a browser inside the sandbox; on Morph you install the browser yourself, and bochka has Chromium ready on its desktop. | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 | 214th of 360, with limits $228 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 | Morph Cloud | Islo | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | MicroVM with its own kernel, built from a container image | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker | Yes, including Docker in Docker and local Kubernetes | Docker inside and sudo | Root, Docker and systemd on every machine |
| Nested virtualization | Experimental | No /dev/kvm or nested virtualization documented | Yes, /dev/kvm for Android emulators and VMs |
| Pause with memory | Yes; a paused VM keeps its processes and memory and bills only its snapshot | Yes; pause keeps files, processes and memory, and can fire after an idle timer set at creation | No; disk is saved every minute and on stop, and resume boots from disk |
| Fork a running machine | Branch with its memory into many copies in under 250 ms | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox with its disk |
| Wake on request | On the next HTTP request, SSH or exec call | On the next exec, file access or webhook | No; a stopped sandbox is started by API |
| Coding agents | You install the agent and drive it through a tmux API that sends keys and reads the screen | Claude Code, Cursor CLI and Codex preinstalled; factory lines run agent steps on a schedule, webhook or GitHub, Slack and Linear events | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Responses Proxy for model APIs; other secrets are handed to the machine | Gateway injects stored credentials into requests to any host | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Outbound internet rules | Open internet; no egress allowlist | Allow or deny by host, path and HTTP method, with default deny and a log of every request | Open internet; no provider-side allowlist |
| Desktop and computer use | Browser-based remote desktop; you install the browser and any computer use agent | Headless, with a browser for testing; no desktop or computer use API | 60fps desktop with Chromium, a computer use API and an embeddable stream |
| Inbound access | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | HTTPS share links anyone with the URL can open, expiring after 24 hours by default; SSH through the CLI; no raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Machines at once | Account-wide pools: 64 vCPU on Developer (16 machines at 4 vCPU), 256 on Team, 1,024 on Scale | 5 running sandboxes on Free and 50 on Team, as reported at launch; paused ones do not count | 100 to 2,000 running sandboxes by plan, raised by adding seats |
| Where it runs | Regions not published | US West, or inside your own cloud account with BYOC | EU only (Germany, Finland, France), with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | 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 | Yes | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | 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 | 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 | Yes | 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 | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No | No | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | 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 | Yes | Yes | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | Not published | No |
| HIPAA | Not published | Not published | No |
| EU data residency | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or Islo: neither is in StarSling's hpc-sandbox-benchmarks run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run, on dedicated AMD Ryzen 9 9950X hosts. Morph's under-250 ms figure measures snapshot restore time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Morph Cloud 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 | Morph Cloud, 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 | $32 · Developer | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $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,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 an hour, where a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, Developer starts with no credit, and a paused VM bills only its snapshot.
Islo: Islo bills each CPU core and each GB of memory and disk while a sandbox runs, with no plan fee and signup credits that need no card. An idle sandbox keeps billing until its pause-after-idle timer fires, and that timer can only be set when the sandbox is created.
Islo: Plans start at $20 a month, and the whole fee is usage credit spent 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, so 300 sandboxes for your users and 1,000 short jobs at once do not fit without a custom contract, while Morph's Scale plan fits both. Morph's limits are vCPU pools instead, and disk beyond 16 GiB per MCU raises its price by an amount these totals leave out. Neither publishes an egress price. bochka has no session cap, but its start limits queue the 1,000-job burst even on the $2,000 plan.
| Scenario | Morph Cloud | 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 Morph Cloud when
your agents branch from one running state with its memory, need many machines at once for short jobs, or must try Windows and macOS guests.
- Branch a running VM with its memory. For agents that fan out from one running state: Morph copies a live VM with its memory into many branches in under 250 ms.
- Windows and macOS guests. For agents that must test software on other systems: Morph lists experimental Windows and macOS (x86) guests next to Linux.
- Managed CI runners and a shared filesystem. For teams that want one bill: Morph also sells GitHub Actions runners and a filesystem many machines mount at once.
Use Islo when
you need per-host egress rules with a log of every call, coding agents that start on schedules and events, or a US region or your own cloud account.
- 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.
- Coding agents that start on events. For background agent work: Claude Code, Cursor CLI and Codex come preinstalled, and runs start on schedules, webhooks or GitHub events.
- 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 bochka fits
Look at bochka when your agents need more than a shell: a screen to see and click, a kernel that can run emulators, and ports other people and tools can reach. Morph and Islo are both strong at pausing idle machines with their memory, but neither ships a desktop or /dev/kvm you can count on, and both stop at HTTP for inbound traffic.
A desktop agents can see and use
Islo sandboxes are headless, and Morph's remote desktop comes empty, so a computer use agent on either starts with you building the desktop image, the browser and the click loop. bochka ships a 60fps desktop with Chromium and a computer use API.
Nested virtualization that is not experimental
Islo documents no /dev/kvm and Morph lists nested virtualization as experimental, so Android emulators and tools that start their own VMs may not boot. bochka gives every machine /dev/kvm, root, Docker and systemd.
Ports you can host on, in the EU
Islo share links are public and expire after 24 hours by default, Morph exposes named HTTP services, and neither offers raw TCP. bochka serves up to 50 token-protected HTTPS ports plus raw TCP, with data kept in the EU.
Use bochka when your agents need a desktop for computer use, /dev/kvm for emulators, coding agents you steer by API, and HTTPS on many ports plus raw TCP in the EU. Compare it one to one: bochka vs Morph Cloud and bochka vs Islo.
Questions people ask
Is Morph Cloud cheaper than Islo?
In every scenario we priced, yes. One coding agent on workdays comes to $32 a month on Morph and $101 on Islo, one agent running all month to $121 versus $420, and 50 agents in parallel to $1,459 versus $4,863. bochka comes to $20, $26 and $317 for the same three.
Which is faster, Morph Cloud or Islo?
There is no comparable CPU measurement for either one. Morph says it restores a snapshot in under 250 ms, which is start time, not CPU speed. bochka did 26.69 runs per second on StarSling's Node.js benchmark at 4 vCPU / 8 GB.
Can Morph Cloud and Islo run Docker?
Yes. Morph runs Docker in Docker and local Kubernetes inside its VMs, and Islo runs Docker inside its microVMs. For nested VMs, Morph lists support as experimental and Islo documents none, while bochka exposes /dev/kvm.
Do they come with Claude Code or Codex?
Islo preinstalls Claude Code, Cursor CLI and Codex. On Morph you install the agent yourself and drive it through a tmux API that sends keys and reads the screen. bochka preinstalls seven agents with a prompt, steer and events API.
Can I control 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. Morph and bochka have open internet with no provider-side allowlist, and both keep model API keys outside the sandbox through a proxy.
Can either one do computer use?
Not out of the box. Islo sandboxes are headless, and Morph offers a browser-based remote desktop where you install the browser and agent yourself. bochka streams a 60fps desktop with Chromium and a computer use API in every sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview