Runloop vs Docker Cloud Sandboxes
Both put each coding agent in its own small VM. Runloop is a platform for running agents at scale, with no published concurrency cap and devboxes that can run past a day, while Docker Cloud Sandboxes is the sbx microVM from your laptop moved to the cloud, capped at 24 hours and 10 at once by default.
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.
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Runloop fits a software factory fully; Docker is a compromise because each sandbox ends 24 hours after creation and only 10 run at once by default, and boat fits with nested virtualization and files kept on every plan. | 20th cheapest of 367 $8,152 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month can run on Runloop with an idle policy, but not in one Docker session, which ends at 24 hours. | 32nd cheapest of 366 $10,194 a month | 276th of 366, with limits $5,110 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 Docker fits short code runs better than it fits anything else here, with small sandboxes billed by the second; Runloop fits fully, and boat's start limits queue very large bursts. | 44th cheapest of 345 $525 a month | 119th of 345, with limits $233 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 Serving your own users needs more than Docker's default of 10 sandboxes at once; Runloop publishes no cap for paid plans, and boat's $20 plan runs 100. | 26th cheapest of 361 $3,301 a month | 136th of 361, with limits $1,628 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: it starts large waves without published start limits and sells RL fine-tuning on Enterprise, while Docker's 10-at-once default rules it out. | 4th cheapest of 360 $15,922 a month | 114th of 360, with limits $7,000 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 | 81st cheapest of 364 $2,562 a month | 167th of 364, with limits $1,400 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 | 121st cheapest of 377 $1,554 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays on all month needs no session cap; Runloop gets there with an idle policy, Docker's sandboxes end after 24 hours, and boat has no cap on paid plans. | 113th cheapest of 368 $410 a month | 127th of 368, with limits $204 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 a browser your agent can control, while Docker's cloud sandboxes are terminal only; boat streams its desktop at 60fps. | 39th cheapest of 369 $2,306 a month | 268th of 369, with limits $1,400 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 | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 limit where a sandbox connects, Runloop by hostname allowlist and Docker by allow and deny rules at its proxy, but Docker's 10-at-once default limits parallel runs. | 10th cheapest of 360 $770 a month | 248th of 360, with limits $350 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 | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | MicroVM with its own Linux kernel and Docker Engine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it with no documented cap | 1 hour by default, at most 24 hours from creation; resuming starts a new timer | No cap on paid plans; you set the time to live |
| Sandboxes at once | No cap published for paid plans; 3 on the trial | 10 by default, 50 stored; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Stop and resume | Suspend keeps the disk and wakes on an HTTP request (Pro plan); shutdown ends the devbox | Stop keeps memory and files; resume picks up where it left off | Disk saved every minute and on stop, on every plan; resume boots the machine again |
| Fork | Disk snapshots of a devbox, restored as new devboxes | Snapshot a running sandbox with disk or disk and memory, then restore it as a new one | Fork a running sandbox with its disk |
| Docker inside | Yes, on the Docker-in-Docker blueprints, as root | Yes, its own Docker Engine; agent runs as a non-root user with sudo | Yes, with root and systemd |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Desktop and browser your agent can control | Terminal sessions only | 60fps Linux desktop with Chromium and computer use |
| Images | Blueprints built from Dockerfiles, plus disk snapshots | Same sbx images as on your laptop | Templates from named snapshots, no Dockerfile builds |
| Inbound access | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy; no public IP | Public HTTPS URL per published port, not behind Docker sign-in; not a TCP tunnel; SSH with Docker-issued certificates | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Hostname allowlist with wildcards, or block all | Allow and deny rules by host at a proxy, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Claude Code, Codex, Copilot, OpenCode and more, attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping API keys out | Agent gateways for any API endpoint with bearer, header or basic auth | Cloud proxy sets the auth header for built-in AI services and custom hosts | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Where it runs | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | Regions not published; the same sandbox also runs on your laptop | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | Docker Cloud Sandboxes | 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 | No | 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 | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | 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 | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | Yes | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | 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 | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Not published | No | 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, Runloop scored 8.29 runs a second and boat 26.69, about 3.2 times apart. Docker Cloud Sandboxes has no comparable measurement yet: it launched in September 2026, is not in those runs, and Docker does not say what hardware it uses.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, 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 | $49 · Docker Agentic Platform (pay-as-you-go) | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $429 · Basic | $204 · Docker Agentic Platform (pay-as-you-go) · with limits | $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 | $2,464 · Docker Agentic Platform (pay-as-you-go) · with limits | $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 | $700 · Docker Agentic Platform (pay-as-you-go) · 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 | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate while a devbox starts, runs, suspends or resumes, 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.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: 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
Docker's limits bite first: its 24-hour session cap rules out one agent that never stops, and its default of 10 sandboxes at once rules out 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once. Runloop fits all five scenarios, since it publishes no concurrency cap for paid plans and an idle policy lifts its 48-hour lifetime, but it publishes no egress price. boat fits every scenario except the 1,000-job burst, where its start limits queue the starts even on the $2,000 plan.
| Scenario | Runloop | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | 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 run large fleets or bursts of agents, need a desktop for computer use, Dockerfile blueprints, hostname allowlists, or devboxes inside your own AWS, GCP or Azure account.
- Many agents, past a day. For fleets and long jobs: Runloop publishes no concurrency cap on paid plans, and an idle policy lets a devbox run past 48 hours.
- A screen for the agent. For computer-use and browser agents: Runloop ships a desktop and a browser the agent can control, which Docker's terminal sandboxes lack.
- Run it in your own cloud. On the Enterprise plan, Runloop can run devboxes inside your own AWS, GCP or Azure account.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, with memory kept across stops.
- Stop and fork with memory. For agents that pause between steps: a stopped Docker sandbox comes back with its memory and running processes.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move work between them.
- No plan fee, cheap small runs. For a few agents at a time: per-second billing with no monthly fee, and stopped sandboxes, volumes and egress are free.
Where boat fits
If your agents run for days, by the dozen, and do heavy work like builds, Docker and emulators, look at boat. It gives each agent a full VM on fast CPUs with no session cap on paid plans, files kept on every plan, and a desktop and API built in.
No session cap, many at once
Docker ends a sandbox 24 hours after creation and runs 10 at a time by default. Runloop's fixed lifetime stops at 48 hours unless you set an idle policy, and keeping the disk through a pause needs the paid Pro plan.
A fuller machine with a fast CPU
Neither documents /dev/kvm, so Android emulators and VMs do not start. On the same build-and-test benchmark boat ran 26.69 loops a second and Runloop 8.29, so every install and test waits about three times longer there.
Reach in from outside
Runloop has one HTTPS tunnel and no public IP, and Docker's ports are open HTTPS URLs, not TCP tunnels. boat gives 50 token-protected HTTPS ports, raw TCP, and an API that prompts and steers the agent inside.
Use boat when your agents run for days or by the dozen, need Docker, Android emulators, a desktop or raw TCP, and have to be driven from your own app, on CPUs about three times faster than Runloop's. Compare it one to one: boat vs Runloop and boat vs Docker Cloud Sandboxes.
Questions people ask
Is Runloop cheaper than Docker Cloud Sandboxes?
For one coding agent on workdays, Docker is cheaper: $49 a month against $113 on Runloop for 4 vCPU / 8 GiB. In the other four scenarios Docker does not fit, because of its 24-hour session cap or its default of 10 sandboxes at once. boat costs $20 a month for the workday agent.
Which is faster, Runloop or Docker Cloud Sandboxes?
There is no comparable CPU measurement for Docker Cloud Sandboxes yet. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, Runloop scored 8.29 runs a second and boat 26.69.
Can Runloop and Docker Cloud Sandboxes run Docker inside?
Yes. Runloop runs Docker on its Docker-in-Docker blueprints as root, and each Docker cloud sandbox has its own Docker Engine. Neither documents nested virtualization, while boat exposes /dev/kvm for Android emulators and VMs.
How long can a sandbox run on each?
A Docker cloud sandbox ends at most 24 hours after creation. A Runloop devbox has a fixed lifetime of up to 48 hours, or no documented cap when you set an idle policy instead. boat has no session cap on paid plans.
Can I keep memory when a sandbox stops?
On Docker, yes: a stopped sandbox comes back with its memory and running processes, and you can fork one with its memory. Runloop's suspend keeps the disk and needs the Pro plan. boat saves the disk every minute and on stop, and resuming boots the machine again.
Can I limit which hosts a sandbox can reach?
Both can. Runloop allows only the hostnames you list, with wildcards, or blocks everything, and Docker applies allow and deny rules by host at its proxy. boat has no provider-side egress allowlist, so you filter inside the VM.
Try boat
Install the CLI, then run boat new.
7-day free trial