boat vs Hopx
Hopx and boat both give each agent its own Linux VM with a desktop. boat's VM also runs Docker and emulators, keeps its disk safe with snapshots every minute, and comes with coding agents you drive from outside.
Where boat stands out
Docker and emulators inside the VM
Every boat sandbox gives the agent root, systemd, Docker and /dev/kvm. It can start a database in a container, run docker compose, or boot an Android emulator. Hopx builds its templates from Docker images, but its docs do not offer Docker or KVM inside a running sandbox.
A disk that is saved every minute
boat snapshots each sandbox's disk every minute and when it stops, and a stopped sandbox costs nothing. You can also fork a running sandbox into a copy with the same files. On Hopx, when the timer runs out the sandbox is deleted with all its data, and there is no fork.
Coding agents and keys built in
Claude Code, Codex and other agents come preinstalled, and you prompt, steer and follow them from outside through one API. Real API keys stay outside the sandbox in a credentials proxy, which can switch a credential to another account when one runs out of credits.
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
Hopx
Hopx sells secure sandboxes for AI agents: small Linux VMs you create and control through an API, SDKs, a CLI and an MCP server.
Each Hopx sandbox is a Firecracker microVM running Ubuntu, built from a template whose CPU, memory and disk are fixed when the template is built. You run code, shell commands and files through its VM agent API, open a WebSocket terminal, reach any port on a public URL, and automate a VNC desktop. It is pay per use with no plan fee, aimed at teams that run agent code, untrusted scripts and desktop automation.
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. “3rd cheapest of 367” means 2 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 | boat: price rank | Hopx: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs Docker, databases and test suites inside each sandbox, which Hopx does not document, so it only fits there as a compromise. | 3rd cheapest of 367 $634 a month | 299th of 367, with limits $5,867 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit; a Hopx sandbox can run for days if you keep extending its timer, and boat keeps the disk safe with snapshots every minute. | 5th cheapest of 366 $657 a month | 25th cheapest of 366 $6,123 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Hopx fits short code runs well: pay per second with no plan fee, while boat's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 28th cheapest of 345 $278 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; boat adds raw TCP, SSH and token-protected URLs for each user's machine, while Hopx exposes every port on a public URL. | Cheapest of 361 $209 a month | 20th cheapest of 361 $1,938 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 354th of 360, with limits $8,334 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 72nd cheapest of 364 $1,667 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit for plain test runs; CI that builds containers or Android apps needs Docker and /dev/kvm, which boat has. | 4th cheapest of 377 $86 a month | 88th cheapest of 377 $805 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box lives for months, and a Hopx sandbox is deleted with its data when its timer runs out, so it is a compromise there. | 18th cheapest of 368 $26 a month | 314th of 368, with limits $246 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a Linux desktop with mouse, keyboard and screenshots; boat streams it at 60fps and you can embed it in your app. | 6th cheapest of 369 $200 a month | 35th cheapest of 369 $1,667 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Hopx has a desktop with a browser, but no Docker for browser tooling stacks, so it fits as a compromise; boat ships Chromium and browser control. | 7th cheapest of 367 $200 a month | 105th of 367, with limits $833 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 43rd cheapest of 346 $417 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 215th of 338, with limits $8,334 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 39th of 360, with limits $419 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 | Hopx |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Firecracker microVM with its own kernel |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Templates are built from Docker images; Docker inside a running sandbox and /dev/kvm are not documented |
| Machine size | Up to 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from the $100 plan | Set per template, typical ranges up to 64 cores and 64 GB depending on plan; you cannot pick a size at create |
| Session length | No cap on paid plans; you set the time to live | No maximum; a timer you can extend deletes the sandbox when it runs out |
| Keeping files | Disk snapshots every minute and on stop; a stopped sandbox costs nothing | Stop keeps the filesystem; when the timer runs out, the sandbox and all its data are deleted |
| Pause and resume | Resume boots the machine again from its saved disk | Pause keeps memory and running processes; resume continues where it left off |
| Fork | Fork a running sandbox with its disk | Not offered; pause and resume only work on the same sandbox |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; SSH; dedicated IPv4 or IPv6 | Every port gets a public HTTPS URL; WebSocket terminal; no SSH, raw TCP or public IP |
| Outbound internet | Open internet, no provider-side allowlist | Open by default, or turned off for a sandbox at create |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | VNC desktop with mouse, keyboard, screenshots, screen recording and window control |
| Coding agents | Claude Code, Codex and more preinstalled, with a prompt, steer and events API | None preinstalled; you install and run an agent through the command API |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Secrets are environment variables inside the sandbox |
| MCP server | No MCP server; REST API, SDKs and CLI | MCP server so AI tools can create and use sandboxes directly |
| Regions | EU only (Germany, Finland, France) | US East and EU West |
| 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 | Hopx |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Hopx: it has no result in the StarSling hpc-sandbox-benchmarks CPU test. boat did 26.69 Node.js build-and-test runs per second there at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Hopx 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 | boat, a month | Hopx, 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 | $59 · Pay-per-use |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $246 · Pay-per-use |
| 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 | $2,934 · Pay-per-use · with limits |
| 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 | $833 · Pay-per-use |
| 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 | $1,667 · Pay-per-use |
boat: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Hopx: Hopx bills per second for the vCPU, RAM and disk fixed in the template, while the sandbox runs, idle time included, until you pause, stop or delete it. There is no plan fee; egress and paused-storage prices are not published.
Limits in those scenarios
Hopx fails the 50-agent scenario because those agents need Docker inside the sandbox, which its docs do not offer. Its other scenarios fit, but none of them can price egress, because Hopx does not publish an egress price. Hopx also starts at most 20 new sandboxes a minute by default (twice that on Pro), so a burst of 30 user sandboxes waits about 2 minutes and a burst of 333 jobs about 17 minutes. On boat, 1,000 short jobs at once do not fit even the $2,000 plan: starts above 90 a minute are queued and the day's starts run out.
| Scenario | boat | Hopx |
|---|---|---|
| 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 Hopx when
you run short jobs that pause and resume with their memory, need a US region, or want sandboxes through an MCP server with no plan fee.
- Pause with memory. Useful for jobs that sleep between steps: a paused Hopx sandbox resumes with its memory and processes where they were.
- US region and an MCP server. Hopx runs in US East as well as EU West, and its MCP server lets AI tools open sandboxes directly.
- No plan fee and an offline switch. Hopx has no subscription, starts you with $200 of credits, and can create a sandbox with no internet at all.
Use boat when
your agents do real work for hours or days: Docker, emulators, builds and a browser, on a VM whose disk is saved every minute, with coding agents built in.
- Docker and emulators inside the VM. Agents that build real software start containers for databases, services and tests. Without Docker inside, each of those must be baked into a Hopx template ahead of time, and emulators cannot start at all.
- A disk that is saved every minute. An agent that runs for days is one missed timer extension away from losing its work on Hopx. Without fork, trying two fixes from the same state means rebuilding that state twice.
- Coding agents and keys built in. On Hopx you install the agent yourself and pass keys as environment variables, so the real keys sit inside a machine the agent controls, where one prompt injection can leak them.
Questions people ask
Is boat cheaper than Hopx?
In four of the five scenarios on this page, yes: one coding agent on workdays comes to $20 a month on boat and $59 on Hopx, and one agent running all month comes to $26 versus $246. For 1,000 short jobs at once, Hopx comes to $1,667 a month and fits, though it starts only 20 sandboxes a minute, while boat's $2,000 plan runs out of starts for the day.
Can I run Docker inside a Hopx sandbox?
Hopx builds its templates from Docker images, but its docs do not describe running Docker inside a sandbox. boat sandboxes run Docker, docker compose and /dev/kvm for emulators out of the box.
What happens to my files when a Hopx sandbox times out?
Hopx deletes the sandbox and all its data when its timer runs out, so you must extend the timer or save files first. On boat the disk is saved every minute and when the sandbox stops, and a stopped sandbox keeps its files.
Is Hopx up right now?
On 2026-10-14 the Hopx status page showed its public API down, with 0% uptime over the last 7 days and no updates posted in 30 days. Check status.hopx.ai before you rely on it. boat's live status is at status.ascii.dev.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial