boat vs Runloop
Both give each agent its own VM. boat ran about three times faster on the same CPU benchmark and gives you a fuller machine, while Runloop adds hostname egress rules, arm64 and deploys into your own cloud.
Where boat stands out
About three times the CPU speed
On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, boat ran 26.69 loops a second and Runloop 8.29. Each boat sandbox runs on dedicated AMD Ryzen 9 9950X hosts. Builds, tests and agent tool calls finish sooner.
A fuller Linux machine
Each boat sandbox is a full VM with its own kernel, root, systemd and /dev/kvm, so you can run Android emulators or VMs inside. You can open raw TCP ports and get a dedicated IPv6 or IPv4 address. Runloop documents Docker-in-Docker but not nested virtualization, and reaches devboxes through HTTPS tunnels only.
Files kept on every plan, no session cap
boat snapshots the disk every minute and on stop, and a stopped sandbox resumes with the same files on any plan. Paid plans have no session cap, so an agent can run for days. On Runloop, keeping a devbox's disk between runs means the Pro plan's suspend or taking disk snapshots yourself.
The companies and products
boat
boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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.
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. “2nd cheapest of 366” means 1 of the other 365 providers runs 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 | boat: price rank | Runloop: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit fully; boat adds nested virtualization for Android emulators and keeps the disk on every plan. | 2nd cheapest of 366 $634 a month | 12th cheapest of 366 $8,152 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Runloop can suspend an idle devbox and wake it on an HTTP request, but suspend needs the Pro plan and the disk is kept only while suspended or in a snapshot. | 4th cheapest of 362 $657 a month | 27th cheapest of 362 $10,194 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Runloop ranks higher for many short code runs, because boat's per-plan start limits queue very large bursts. | 183rd of 342, with limits $2,000 a month | 34th cheapest of 342 $525 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 20th cheapest of 361 $3,301 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Runloop ranks higher for RL rollouts: it starts large waves without published start limits and sells RL fine-tuning on Enterprise. | 33rd of 358, with limits $2,000 a month | 4th cheapest of 358 $15,922 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 9th cheapest of 363 $200 a month | 70th cheapest of 363 $2,562 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month boat's faster CPUs finish builds and test runs sooner, and Docker works inside both. | 4th cheapest of 377 $86 a month | 115th cheapest of 377 $1,554 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Runloop is a compromise here: no public IP or raw TCP, and running all month needs an idle policy in place of the 48-hour lifetime setting. | 17th cheapest of 369 $26 a month | 109th cheapest of 369 $410 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both ship a desktop and a browser your agent can control; boat streams the desktop at 60fps and you can embed it in your app. | 5th cheapest of 367 $200 a month | 39th cheapest of 367 $2,306 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 5th cheapest of 363 $200 a month | 37th cheapest of 363 $1,153 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 4th cheapest of 341 $90 a month | 63rd cheapest of 341 $781 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 65th of 337, with limits $1,800 a month | 262nd of 337, with limits $15,611 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Both fit; Runloop can lock each devbox to a hostname allowlist, boat gives each one a full kernel with nested virtualization. | 3rd cheapest of 357 $200 a month | 8th cheapest of 357 $770 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 |
| 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 |
Key features
| Feature | boat | Runloop |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Micro-VM on a custom bare-metal hypervisor, plus a container layer |
| Nested virtualization | Yes: /dev/kvm, Android emulator, VMs inside | Not documented; Docker-in-Docker blueprints only |
| Docker inside | Yes, with root and systemd | Yes, on the dnd blueprints, as root |
| Images | Templates from named snapshots, no Dockerfile builds | Blueprints built from Dockerfiles, plus disk snapshots |
| CPU architecture | x86_64 only | x86_64 and arm64 |
| Keeping files | Snapshot every minute and on stop, on every plan; resume with the same disk | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox |
| Long runs | No session cap on paid plans; default TTL 1 hour, changeable | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it |
| Idle sleep and wake | No idle timer; TTL based | Suspend after idle, wake on an HTTP request to the tunnel (Pro) |
| Inbound networking | HTTPS URLs for up to 50 ports, token-protected by default, raw TCP, dedicated IPv6 or IPv4 | One HTTPS tunnel per devbox covering its ports, open or bearer token; SSH through a TLS proxy; no public IP |
| Egress rules | Open internet, no provider-side allowlist | Hostname allowlist with wildcards, or block all |
| Hidden API keys | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when one runs out | Agent gateways for any API endpoint with bearer, header or basic auth |
| Built-in agents | Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe, with a prompt, steer and events API | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker |
| Where it runs | EU only (Germany, Finland, France), EU data residency | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) |
| Usage per sandbox | Per-sandbox usage API and spend limits | Usage shown on the dashboard; no per-devbox usage endpoint documented |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | boat | Runloop |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Yes |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | Yes |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Not published |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
Both were measured on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29). boat scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. 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.
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 | boat, a month | Runloop, 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 | $20 · $20/mo | $113 · Basic |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $429 · Basic |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $5,268 · Basic |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $1,441 · Basic |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $3,184 · Basic |
boat: 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.
Runloop: Runloop bills per second for the CPU and memory you allocate, while a devbox is starting, running, suspending or resuming, and bills its 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 and resume.
Limits in those scenarios
Runloop's fixed lifetime setting defaults to 1 hour and tops out at 48 hours, but an idle policy replaces that cap, so a devbox can run 24/7; suspending on idle needs Pro. Runloop publishes no concurrency cap for paid plans and no egress price, and its disk tops out at 64 GiB. boat's limit that bites is start rate: even the $2,000 plan queues bursts above 90 starts a minute, so 1,000 jobs at once does not fit there.
| Scenario | boat | Runloop |
|---|---|---|
| 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
you launch very large bursts of short jobs, or need hostname allowlists, arm64 or devboxes inside your own AWS, GCP or Azure account.
- Lock down the network. Useful if a sandbox must only reach a fixed list of hosts: Runloop allows listed hostnames, with wildcards, or blocks everything.
- Run it in your own cloud. On the Enterprise plan, Runloop can run devboxes inside your own AWS, GCP or Azure account.
- Sleep when idle, arm64 and Dockerfiles. Useful for idle devboxes and arm64 builds: Runloop can suspend and wake on a request (Pro), and builds images from Dockerfiles.
Use boat when
your agents do real work for hours: installs, builds, tests, Docker and emulators, on CPUs about three times faster, with files kept on every plan.
- About three times the CPU speed. Agents spend most of their time waiting on installs, builds and tests. At about a third of the speed, each of those waits takes three times as long on Runloop, and you pay for the waiting.
- A fuller Linux machine. Without /dev/kvm an Android emulator or a VM does not start at all, and with HTTPS tunnels only, a database or server that speaks raw TCP has no way in.
- Files kept on every plan, no session cap. On Runloop a devbox is gone once it shuts down, so keeping an agent's work means the $250-a-month Pro plan for suspend, or snapshot code you write and maintain yourself.
Questions people ask
Is boat cheaper than Runloop?
In most of our scenarios, yes. One coding agent on workdays costs $20 a month on boat and $113 on Runloop, and 50 agents in parallel cost $317 versus $5,268. For 1,000 short jobs at once, Runloop fits and boat's start limits do not.
Is Runloop faster than boat?
Not on CPU. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, boat ran 26.69 loops a second and Runloop 8.29.
Can I run Android emulators or VMs inside Runloop?
Runloop documents Docker-in-Docker but not nested virtualization or /dev/kvm. boat exposes /dev/kvm, so Android emulators and VMs run inside a sandbox.
Can I limit which websites a sandbox can reach?
On Runloop, yes: network policies allow only the hostnames you list, or block all traffic. boat has no provider-side egress allowlist, so you filter inside the VM.
Is Runloop SOC 2 compliant? What about boat?
Runloop's trust center lists SOC 2 Type 2. For boat, SOC 2 is in progress. We're open about where we stand: live status at https://status.ascii.dev and our data retention policy at https://docs.boat.dev/data-retention.
Does boat support Dockerfiles or arm64 like Runloop?
No. boat builds templates from named snapshots of a running sandbox instead of Dockerfiles, and runs x86_64 only. Runloop builds blueprints from Dockerfiles and offers arm64.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial