Freestyle vs Islo
Both give each agent its own VM with its own kernel that can pause with its memory and wake on the next request. Freestyle is a full KVM machine with nested virtualization and bigger sizes, while Islo puts every outbound call through a gateway that checks rules by host, path and method and logs it.
The companies and products
Freestyle
Freestyle sells full Linux virtual machines for AI agents, built for long running, complex tasks.
Each Freestyle VM is a KVM virtual machine with its own kernel, booted from an Ubuntu base snapshot with systemd, Docker and coding agent CLIs preinstalled. VMs can be paused with their memory, snapshotted while running, forked and woken by the next request, and every VM starts behind a default-deny firewall. It is built for teams that give each agent or each user its own machine, driven from a TypeScript SDK, a CLI or an API.
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. “40th cheapest of 345” means 39 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 | Freestyle: 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 Freestyle gives agents systemd, Docker and nested virtualization for emulators, while Islo runs Docker but documents no /dev/kvm; bochka adds faster CPUs and a desktop on top. | 241st of 367, with limits $3,311 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 assistant that lives on its machine all month, pausing it with memory when idle and waking it on a request; bochka ranks 5th here. | 263rd of 366, with limits $4,195 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 Freestyle suits short code runs well: a paused VM wakes on the next request and resumes the same processes, and it ranks well ahead of Islo and bochka here. | 40th cheapest of 345 $482 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 Freestyle fits 300 user sandboxes at once on Pro, which allows 400, while Islo's Team plan is reported at 50 running sandboxes; bochka ranks 1st here. | 16th cheapest of 361 $1,358 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 | 107th of 360, with limits $6,600 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, while Freestyle ranks higher on fit and bochka ranks 10th. | 53rd cheapest of 364 $1,046 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 Islo fits CI runners better than Freestyle here, and Freestyle's own docs say CPU-heavy jobs like kernel builds are better served elsewhere. | 168th of 377, with limits $625 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 | 98th cheapest of 368 $151 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 ships a desktop: Freestyle has guides to install GNOME, VNC and Chromium yourself, and Islo sandboxes are headless; bochka streams a 60fps desktop with computer use. | 234th of 369, with limits $940 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 | 257th of 367, with limits $482 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 and bots where Freestyle is only a compromise; bochka ranks 6th here. | 278th of 346, with limits $482 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 | 183rd of 338, with limits $6,560 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 | 272nd of 360, with limits $482 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 | Freestyle | Islo | bochka |
|---|---|---|---|
| Isolation | Full KVM VM with its own kernel on bare metal servers | A microVM with its own kernel, built from a container image | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 9.64 runs/s | No public measurement | 26.69 runs/s |
| Docker, systemd and nested virtualization | Yes; systemd is pid 1, Docker runs from boot, full KVM support | Docker inside and sudo; no /dev/kvm or nested virtualization documented | Root, systemd, Docker and /dev/kvm on every machine |
| Biggest machine | Up to 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits | Not listed in the sources we checked | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Pause and wake | Pause keeps memory and processes; a VM paused by idle timeout wakes on the next traffic | Pause keeps files, processes and memory; resumes on the next exec, file access or webhook | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Clone a running VM without pausing it; snapshots capture memory and disk | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox with its disk |
| Desktop, browser and computer use | Guides to install GNOME or Xvfb, VNC and Chromium yourself | A browser inside the sandbox for testing; no desktop or computer-use API | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | Claude Code, Cursor CLI and Codex preinstalled; factory lines with events, steer and follow-ups, on a schedule or webhook | Seven agents preinstalled, with a prompt, steer and events API |
| Outbound rules | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Gateway rules by host, path and HTTP method, default deny, rate limits and content filters | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Credentials injected at the edge for HTTPS headers, Postgres and S3 | 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 |
| Request logs | Audit logs on Enterprise | 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 |
| Reaching the sandbox | HTTPS on free style.dev names or your own domain, forward auth, other public protocols | HTTPS share links that expire after a TTL (24 hours by default); SSH and port-forward through the CLI | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Sandboxes at once | 10 on Free, 40 on Hobby, 400 on Pro | 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 | Not listed; the docs name a San Jose, US data center | US West, or inside your own cloud account with BYOC | EU only (Germany, Finland, France), zero data retention |
Every feature Battleships tracks (43)
| Feature | Freestyle | 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 | No | 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 | Yes | 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 | 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 | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Not published | 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 the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Freestyle did 9.64, so bochka did about 2.8 times the CPU work in the same time. Islo has no comparable measurement: it was not part of the public benchmark runs we use. This measures CPU speed only, not start time.
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 | Freestyle, 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 | $27 · Free | $101 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $159 · Free | $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,139 · Pro | $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 | $581 · Pro | $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,305 · Pro · with limits | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances that are hard stops on Free. Hobby and Pro set a $50 or $500 monthly minimum that counts as usage, and a paused VM bills only for storage.
Islo: Islo bills each CPU core and each 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, set only 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 while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Freestyle Pro allows 400 VMs at once, so it fits 300 sandboxes for your users, while Islo's Team plan is reported at 50 running sandboxes and needs a custom contract. For 1,000 short jobs at once neither fits: Freestyle hits its 400 cap and Islo its 50. bochka queues starts above 90 a minute on its $2,000 plan, so that burst does not fit bochka either. Islo publishes no egress price, so its totals leave egress out.
| Scenario | Freestyle | Islo | bochka |
|---|---|---|---|
| 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 |
| 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 Freestyle when
you need nested virtualization, machines bigger than 16 vCPU, live forks with memory, or hundreds of user VMs at once.
- Nested virtualization and big machines. Useful for emulators and heavy jobs: Freestyle VMs have full KVM support and go up to 32 vCPU / 64 GiB on Pro.
- Live fork with memory. Useful for rollouts that branch from one state: Freestyle clones a running VM and snapshots its memory and disk.
- More sandboxes at once. Useful for products that give each user a machine: Freestyle Pro allows 400 concurrent VMs, against 50 reported for Islo Team.
Use Islo when
you must control and log every outbound call, want agent runs started by schedules and webhooks, or need sandboxes in your own cloud account.
- Egress rules and request logs. Useful if you must control what agents reach: Islo checks each host, path and method, and logs every call to your SIEM.
- Agent runs on triggers. Useful for background agents: Islo factory lines run agent steps on a schedule, a webhook or GitHub, Slack and Linear events.
- Your own cloud account. Useful if sandboxes must live in your cloud: Islo can run its control plane and sandboxes there under BYOC.
Where bochka fits
Freestyle and Islo are both built around pausing VMs with their memory, and Islo around gating their network. If your agents do hours of real work, building, testing and using a screen, bochka gives each one a full VM on faster CPUs with a desktop built in.
A desktop agents can see and use
Neither ships a screen. On Freestyle you install GNOME or Xvfb, VNC and Chromium in your own snapshot, and Islo sandboxes are headless, so on both you build the screenshot and click layer before an agent can use a web app.
Faster CPUs for builds and tests
On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Freestyle did 9.64, so each install and test waits almost three times as long there. Islo has no public measurement.
Agents that keep going when credits run out
Freestyle and Islo inject a stored key, so an agent that runs out of credits stops until your code swaps it. bochka's credentials proxy switches the credential to another account of the same type and the agent carries on.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, on fast CPUs, with an API to drive the agents inside from outside. Compare it one to one: bochka vs Freestyle and bochka vs Islo.
Questions people ask
Is Freestyle cheaper than Islo?
In every scenario we priced, yes. One agent running all month comes to $159 on Freestyle and $420 on Islo, and 50 agents in parallel come to $2,139 against $4,863. bochka comes to $26 and $317 for the same two.
Which is faster, Freestyle or Islo?
Only Freestyle has a public CPU measurement: 9.64 runs per second at 4 vCPU / 8 GB, against 26.69 for bochka. Islo was not part of the benchmark runs we use, so there is no fair speed comparison between the two.
Can Freestyle and Islo run Docker and Android emulators?
Both run Docker. Freestyle also has systemd and full KVM support, so Android emulators and VMs inside the sandbox work, while Islo's docs do not mention /dev/kvm. bochka has Docker, systemd and /dev/kvm on every machine.
Do Freestyle or Islo have a desktop for computer use?
No. Freestyle has guides to install a desktop, VNC and Chromium yourself, and Islo sandboxes are headless with a browser for testing. bochka streams a 60fps desktop with Chromium and computer use in every sandbox.
Which controls outbound traffic better?
Both can block everything by default. Freestyle allows traffic by IP, VM, VPC or exact domain, while Islo's gateway checks host, path and HTTP method, rate-limits, and logs every request to your SIEM. bochka has open internet with no provider-side allowlist.
Can both pause a sandbox with its memory?
Yes. Freestyle pauses a VM with its memory and wakes it on the next traffic, and Islo pauses after idle time and resumes on the next exec, file access or webhook. bochka saves the disk and boots the machine again on resume.
Try bochka
Install the CLI, then run bochka new.
Product preview