boat vs Cube Computer
Cube Computer gives one developer an always-on Linux computer for their coding agents, run from a Mac app and a phone. boat gives you as many VMs as you need from an API, each with Docker, a desktop, public URLs and coding agents you drive from outside.
Where boat stands out
Machines from code, as many as you need
On boat you create, fork, stop and resume VMs from a CLI, SDKs or an HTTP API, up to your plan's concurrency limit. Cube gives you one machine that you set up in its Mac app, and its site documents no public API. Its answer to parallel work is a Git worktree per task on that one machine.
Coding agents you drive from outside
boat ships Claude Code, Codex, OpenCode and other agents inside each sandbox, and you drive the agents inside from outside with a prompt, steer and events API. The credentials proxy keeps real AI keys out of the sandbox and can switch to another account when credits run out. On Cube, agents use your own accounts and their tokens live on the machine.
A full machine you can show to the world
Every boat sandbox has Docker, root, systemd and /dev/kvm, a 60fps desktop with Chromium, and HTTPS URLs for up to 50 ports, raw TCP and its own IP. Its disk is snapshotted every minute and on stop, and a stopped sandbox costs nothing. Cube documents a terminal and SSH machine with no desktop, no public URLs and no snapshots.
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
Cube Computer
Cube Computer is an always-on Linux cloud computer for running coding agents like Claude Code and Codex, set up and driven from a Mac app.
You sign in with GitHub in the Cube Mac app, pick how much CPU, memory and disk your machine gets, and install agents from a list. Each task gets its own Git worktree on that one machine, you reach it over SSH from your editor, and you can check in on sessions from your phone. It is a personal dev box for one developer and their agents, not a sandbox API: the site documents no public API or SDK for creating machines from code.
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 | Cube Computer: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs many machines started from code, and Cube documents no API, so its agents share one machine through Git worktrees. | 3rd cheapest of 367 $634 a month | 76th of 367, with limits $639 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Cube keeps one machine on for you; boat gives each assistant its own VM that you can create, fork and stop from code. | 5th cheapest of 366 $657 a month | 120th of 366, with limits $725 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code interpreter bursts need fast starts from an API; neither fits fully, and Cube has no API to start machines from. | 186th of 345, with limits $2,000 a month | 214th of 345, with limits $66 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Giving each of your users a sandbox needs an API and a known concurrency limit; Cube publishes neither, so it is only a compromise here. | Cheapest of 361 $209 a month | 197th of 361, with limits $231 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 | 226th of 360, with limits $993 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 | 232nd of 364, with limits $182 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI runners are started by code on every push, and Cube's machines are started from its Mac app. | 4th cheapest of 377 $86 a month | 223rd of 377, with limits $85 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB This is Cube's home ground: one always-on machine for one developer, with a Mac app and phone check-ins; boat fits too, with snapshots and free stops. | 18th cheapest of 368 $26 a month | 19th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Cube is a terminal and SSH machine with no desktop, while boat streams a 60fps desktop with Chromium for computer use. | 6th cheapest of 369 $200 a month | 97th of 369, with limits $182 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month boat ships Chromium and browser control in every sandbox; Cube documents no browser on the machine. | 7th cheapest of 367 $200 a month | 164th of 367, with limits $99 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 | 182nd of 346, with limits $99 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 | 78th of 338, with limits $1,986 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 | 113th of 360, with limits $50 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 | Cube Computer |
|---|---|---|
| What you get | As many VMs as your plan allows, created from a CLI, SDKs or an HTTP API | One always-on cloud computer per developer, set up in a Mac app |
| Control from code | CLI, SDKs and HTTP API for create, fork, stop, resume and exec | Mac app, phone check-ins and SSH; no public API or SDK documented |
| Isolation | Every sandbox is a full VM with its own kernel | A virtual machine on Fly.io; all your agents share it |
| Parallel attempts | Fork a running sandbox into a new VM per attempt | A Git worktree per task, on one machine |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Install agents from a list (Claude Code, Codex, Gemini CLI, OpenCode and more) and run them from the app, SSH or your phone |
| Keeping keys out of the machine | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Agents use your own accounts; credentials and tokens live on the machine |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Debian machine over SSH; Docker and /dev/kvm are not documented |
| Desktop and browser | 60fps desktop and Chromium, computer use and browser control, embeddable stream | Terminal and SSH only; no desktop or browser on the machine |
| Files after a stop | Snapshots every minute and on stop; a stopped sandbox costs nothing | Pause keeps the disk and keeps billing it; backup is a manual file download |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | SSH set up by the app; no public URLs or ports documented |
| Machine sizes | Fixed sizes from small to 16 vCPU / 32 GB | Pick CPU, memory up to 128 GB and disk up to 500 GB, and change them later |
| Personal app | CLI, SDKs and SSH from any editor | Mac app with a sidebar of every repo, worktree and session, plus phone check-ins |
| Where it runs | EU only: Germany, Finland, France | Region not published; data may leave the UK and EEA under standard contractual clauses |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | No SOC 2 report published |
Every feature Battleships tracks (43)
| Feature | boat | Cube Computer |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| 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 | Not published |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | No |
| 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 | No |
| Audit logs | No | Not published |
| SSO | No | No |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Cube Computer is not in the public StarSling benchmark, so we have no CPU number for it. In that benchmark boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts. Cube calls its CPUs dedicated, but has published no benchmark we can compare.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Cube Computer 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 | Cube Computer, 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 | $6 · Prepaid usage |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $26 · Prepaid usage |
| 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 | $319 · Prepaid usage |
| 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 | $99 · Prepaid usage · with limits |
| 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 | $199 · Prepaid usage · with limits |
boat: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Cube Computer: Cube bills from prepaid credit: CPU and memory while the machine runs, and storage for as long as you keep it, paused included. Its calculator charges $3 per CPU a month, $1.50 per GB of memory and $0.05 per GB of disk, and egress pricing is not published.
Limits in those scenarios
Cube does not publish how many machines can run at once, and it has no API to start them. 50 agents in parallel is probably fine, but the 300 user sandboxes and the 1,000-job burst are priced without being confirmed to fit. It is built for one developer's machine, and those scenarios need many. On boat the limits are a sandbox count (100 to 2,000 by plan) and starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | boat | Cube Computer |
|---|---|---|
| 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 Cube Computer when
you are one developer on a Mac who wants a single always-on machine for your agents, with a polished app and phone check-ins and no code to write.
- A finished personal workflow. Useful for one developer who wants a Mac app with every repo and session in one sidebar, and check-ins from a phone.
- Sizes you choose yourself. Useful if your agents need an unusual shape, like lots of memory or a big disk on a modest CPU.
Use boat when
your agents need machines started from code: one VM per task or per user, forks of running work, Docker and emulators, a desktop and browser, public URLs, and agents you drive from outside.
- Machines from code, as many as you need. Agents in worktrees on one machine share its CPU, memory and kernel, so one runaway test slows or breaks the rest. Without an API, a pipeline cannot start a fresh machine per task or per user.
- Coding agents you drive from outside. Cube's agents are driven from its app or your phone, so your own code cannot prompt or watch them. A token stored on the machine can be read by any code an agent runs there.
- A full machine you can show to the world. An agent building a web app needs to open it in a browser and share a preview link. On Cube you would set up your own tunnel, and a backup means downloading files by hand.
Questions people ask
Is boat cheaper than Cube Computer?
For one machine, Cube is often lower: one coding agent on workdays comes to $6 on Cube against boat's $20 plan, and one agent running all month is $26 on both. For 50 agents in parallel it is $317 on boat against $319 on Cube. For sandboxes for your users Cube comes to $99 against boat's $200, but Cube does not say it can run the 300 machines at once that this needs.
Does Cube Computer have an API?
Cube documents no public API or SDK. You set up and drive the machine from its Mac app, over SSH, or from your phone. boat has a CLI, SDKs and an HTTP API to create, fork, stop and resume VMs and to drive the agents inside them.
Can I run several agents at once on Cube?
Yes, on one machine: Cube gives each task its own Git worktree, so agents don't overwrite each other's files. They still share the machine's CPU and memory. On boat you can also fork a running sandbox, so each attempt gets its own VM.
Do I need a Mac to use Cube or boat?
Cube's app runs on macOS only, and it is how you set up and drive your cloud computer. boat works from any system through its CLI, SDKs, API and SSH.
Where does my data run?
boat runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Cube's machines run on Fly.io; its privacy policy says its providers operate in the United States and elsewhere and relies on standard contractual clauses when data leaves the UK or EEA.
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