boat vs Depot

Depot is build and CI infrastructure: fast GitHub Actions runners on Linux, Windows and macOS, a new machine for every job. It also runs Depot Sandboxes and Managed Agents, isolated Linux microVMs that live up to 24 hours and carry files forward through snapshots. boat gives each agent a full VM that you keep until you stop it or its auto-stop timer ends, that serves apps on HTTPS URLs and that comes with coding agents you drive from outside.

Where boat stands out

A machine that stays

A boat sandbox is a full VM that runs until you stop it or its auto-stop timer ends (default 1 h, up to 30 days, or off on a paid plan). boat saves its disk every minute while it runs and once more at each stop, and you can fork a running one. A resume is like a reboot: memory and running programs are not saved. Depot's runners are thrown away after each job, and its sandboxes end after at most 24 hours, and a stopped one cannot restart; only files saved by a snapshot carry over to a new sandbox.

Apps your agents can serve

boat gives each sandbox public HTTPS URLs on up to 50 ports, token-gated by default, plus SSH and a public IPv6 address. An agent can start a dev server, a database or an API, and you, your users or a test suite can reach it. boat has no static IP, and the IP changes at each resume. Depot documents SSH for debugging a CI job and private access through Tailscale, but no way to expose a port to public traffic.

Coding agents you drive from outside

boat ships Claude Code, Codex, OpenCode and four other agents inside each sandbox, and you prompt, steer and follow them through one API from your own backend. With the optional paid credentials proxy on, the real keys of supported providers stay outside the sandbox, and a credential can switch to another account when credits run out. Depot's Managed Agents runs five agent providers, started from each provider's own app or the depot claude CLI, and keeps keys out of the sandbox only for Managed Agents host-bound secrets.

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.

Depot

Depot is a build and CI platform: faster Docker builds, drop-in GitHub Actions runners, its own Depot CI, and sandboxes for coding agents.

Depot's main product is GitHub Actions runners: you change one runs-on label and each job runs on a fresh AWS EC2 instance that is thrown away when the job ends, with Linux, Arm, Windows and macOS sizes and a shared fast cache. It also sells Depot Sandboxes with a Node.js SDK: isolated Linux microVMs with Docker that live at most 24 hours, with file snapshots that restore into a new sandbox. Managed Agents runs Amp, Claude Code, Claude Managed Agents, Devin and OpenAI agents in those sandboxes and saves workspace snapshots automatically. It is built for engineering teams that want CI and builds to finish sooner, so this page compares where the two products overlap.

Compliance
SOC 2 Type II

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. “5th cheapest of 365” means 4 of the other 364 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 workloadboat: price rankDepot: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
An agent that builds an app over days needs one machine that keeps its state. boat keeps the disk, Docker and /dev/kvm on one VM until you stop it or auto-stop ends it. On Depot you chain sandboxes: each lives at most 24 hours, and a snapshot carries its files, not its running programs, into the next one.
5th cheapest of 365
$634 a month
338th of 365, with limits
$8,688 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An always-on assistant needs a machine that keeps running. boat runs it all month once you turn auto-stop off (default 1 h). Depot caps a sandbox at 24 hours; Managed Agents continue a session in a new sandbox from the latest snapshot, without running processes or memory.
6th cheapest of 361
$657 a month
152nd of 361, with limits
$13,148 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
189th of 336, with limits
$2,000 a month
305th of 336, with limits
$1,188 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
Your users' sandboxes need a URL to reach them. boat serves up to 50 HTTPS URLs per sandbox. Depot documents no public inbound ports or URLs; its sandboxes reach your private services through Tailscale.
3rd cheapest of 349
$209 a month
311th of 349, with limits
$3,713 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
39th of 349, with limits
$2,000 a month
304th of 349, with limits
$17,908 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
10th cheapest of 359
$200 a month
318th of 359, with limits
$2,888 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
Both fit. Depot is made for this: a one-line change to your GitHub Actions workflow, with a shared fast cache and no concurrency limit. boat gives you a full VM that you register as your own runner, with start limits per plan.
2nd cheapest of 374
$86 a month
128th cheapest of 374
$1,736 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
A dev box that keeps its state all month fits boat: its disk stays until you delete it or for at least 14 days after a stop. Depot runners end with the job, and Depot sandboxes end after at most 24 hours, so you restore files from a snapshot each day.
19th cheapest of 371
$26 a month
213th of 371, with limits
$534 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
boat ships a 1920x1080, 60 fps desktop with Chrome and computer tools. Depot ships no desktop or computer-use tools; you set it up: install a virtual display (Xvfb) and a VNC server in a sandbox and reach it over your Tailscale tailnet.
7th cheapest of 367
$200 a month
330th of 367, with limits
$2,600 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
7th cheapest of 356
$200 a month
204th of 356, with limits
$1,304 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
6th cheapest of 343
$90 a month
211th of 343, with limits
$1,763 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
73rd of 327, with limits
$1,800 a month
308th of 327, with limits
$35,108 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
3rd cheapest of 351
$200 a month
136th of 351, with limits
$863 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Depot fits: it rents macOS runners by the minute. boat runs Linux x64 only; Windows programs run through Wine, and there is no macOS.
Not ranked: misses a requirement28th of 35, with limits
$1,540 a month

Key features

FeatureboatDepot
What it isVMs for AI agents that you keep, stop, fork and host fromCI runners and build machines for GitHub Actions, plus Depot Sandboxes with a Node.js SDK and Managed Agents
IsolationFull VM with its own kernel on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are sharedA fresh EC2 instance per GitHub Actions job; Depot CI, Sandboxes and agents run in isolated Linux microVMs
How long a machine livesUntil you stop it or auto-stop ends it (default 1 h, up to 30 days, or off on a paid plan)Runners end with the job; Sandboxes at most 24 hours; Managed Agents continue a session in a new sandbox from the latest snapshot
Files after a stopThe disk, saved every minute while it runs and once more at stop; memory, running programs and /tmp are not saved. boat keeps a stopped disk for at least 14 days, longer as a saved snapshotRunners are never reused. A stopped sandbox cannot restart. Sandbox SDK snapshots (up to 25 GiB) and Managed Agents' automatic workspace snapshots keep files, not processes, and restore into a new sandbox
ForkFork a running sandbox with its disk, from the last 1-minute snapshot; memory is not copiedNo live fork; snapshot a sandbox's files and create new sandboxes from it
Docker and nested virtualizationDocker, root, systemd and /dev/kvm on every sandboxDocker on Linux runners and in Sandboxes; /dev/kvm on Depot CI sandboxes, not on GitHub Actions runners; no Hyper-V on Windows
Reaching the machineHTTPS URLs for up to 50 ports, token-gated by default; SSH; a public IPv6 address. No static IP, and the IP changes at each resumeSSH into a running Depot CI job; sandboxes join your Tailscale tailnet for private access; no documented public ports or URLs
Coding agentsSeven agents preinstalled (Claude Code, Codex, OpenCode and more), with a prompt, steer and events APIManaged Agents runs Amp, Claude Code, Claude Managed Agents, Devin and OpenAI agents in Depot sandboxes, started from those tools or the depot claude CLI
Keeping keys out of the machineOptional paid credentials proxy ($1 per day on, plus $1 per 1,000 requests): with it on, real keys of supported model providers and your HTTPS APIs stay outside the sandboxCI jobs, runners and run secrets get environment variables; Managed Agents host-bound secrets stay outside the sandbox and Depot's gateway inserts them for listed hosts
Desktop and computer useBuilt-in 1920x1080, 60 fps Linux desktop with Chrome and computer tools; no GPUNo desktop or computer-use tools; you set it up: install Xvfb and a VNC server in a sandbox and reach it over Tailscale
macOS and WindowsUbuntu 24.04 on x64 only; Windows programs through Wine; no macOSmacOS 26, 15 and 14 runners and Windows Server 2025 and 2022 runners
Biggest machineUp to 16 vCPU / 32 GB on the $100 plan and aboveLinux runners up to 64 CPUs / 256 GB; Sandboxes up to 64 vCPUs
Outbound network rulesOpen internet on every plan; no provider-side allowlistEgress filtering on Linux runners by IP, CIDR or hostname, with a default allow or deny
CI integrationA VM you can register as your own runner; no managed CI cache; starts capped per planDrop-in GitHub Actions runners with a shared cache up to 1000 MiB/s, plus fast Docker builds; no concurrency limit
Regions and CPUsGermany, Finland and France; no US or Asia region, and you cannot pick one; x64 onlyUS East and EU Central; x64 and Arm runners and sandboxes; GPU runners only through Depot Managed on the Business plan
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatDepot
Full VM (own kernel)YesYes
Docker insideYesYes
Nested virtualizationYesYes
RootYesYes
SystemdYesNo documented way
Desktop GUIYesNo documented way
BrowserYesYes
Computer-use APIYesNo documented way
SSHYesYes
Persistent diskYesWith your own setup
Pause/resumeYesNo documented way
Automatic snapshotsYesYes
Fork/cloneYesWith your own setup
Live fork (no pause)YesNo documented way
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesYes
≥24 h sessionsYesYes
Idle auto-stopNo documented wayYes
Wake on requestNo documented wayNo documented way
HTTPS preview URLsYesNo documented way
Raw TCP inboundYesNo documented way
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesYes
Secret proxy for any APIYesYes
Preinstalled agentsYesYes
Agent harness APIYesYes
MCP serverNo documented wayNo documented way
GPUNo documented wayYes
WindowsNo documented wayYes
Arm64No documented wayYes
Self-hostingNo documented wayNo documented way
BYOCNo documented wayYes
Open sourceNo documented wayNo documented way
Scoped API keysYesNot published
Spend limitsYesYes
Usage per sandbox (API)YesNo documented way
Audit logsNo documented wayNot published
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayNot published
EU data residencyNo documented wayYes
Zero data retentionYesNot published

Performance

boat28.06 runs/s
DepotNot measured

Depot is not in the public benchmarks we use, so we cannot say which is faster. For reference, boat did 28.06 runs per second on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB in StarSling's run of 3 October 2026 (run 37073680030), second of 15 providers in that run. Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host; boat also places sandboxes on Ryzen 7 9700X hosts and does not promise a CPU model.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Depot is not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

Scenarioboat, a monthDepot, 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$122 · Developer · with limits
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$26 · $20/mo$534 · Developer · with limits
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,710 · Developer · 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$1,628 · Developer · with limits
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$8,800 · $2000/mo · with limits$3,588 · Developer · with limits

boat: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month; unused time does not carry over. A card is required, also for the 7-day trial. You pay per second while a sandbox runs: a 4 vCPU / 8 GB sandbox costs $0.036 an hour. Each plan includes a set number of starts (the $20 plan: 12 a minute, 200 a day, 100 running at once); create, fork and resume each count, and extra starts cost $0.03 to $0.07. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; saved snapshots above the included count and the credentials proxy still charge.

Depot: Depot plans cost $20 (Developer) or $200 (Startup) a month. Developer includes 2,000 GitHub Actions minutes, 2,000 sandbox minutes and 500 container build minutes; Startup includes 10 times as much. Sandbox minutes are shared by Depot CI, Sandboxes and Managed Agents and count at 2 vCPUs, so a 4-vCPU sandbox uses them twice as fast. Included minutes are not a cap: after them, a 2-CPU Linux runner costs $0.006 a minute and a 4-CPU one $0.012, and sandboxes cost $0.00005 per vCPU-second ($0.72 an hour for 4 vCPU). We priced the scenarios on Depot's Linux runners on the Developer plan, with its included runner minutes subtracted: 4 CPU / 16 GB, and 2 CPU / 8 GB for user sandboxes and short jobs. Depot Sandboxes cost the same per vCPU.

Limits in those scenarios

None of these scenarios fit Depot cleanly, because its main product is a CI runner: a machine lives for one GitHub Actions job. Its sandboxes live at most 24 hours, a stopped one cannot restart, and a snapshot carries files, not running programs, into the next sandbox; Managed Agents do this automatically. Depot says its runners have no concurrency limits. boat has its own limits: auto-stop defaults to 1 hour, a fork or resume loses memory and running programs, and starts above the plan's included count cost extra. For the 1,000 short jobs at once, boat's $2,000 plan includes 90 starts a minute and 2,400 a day, charges for starts above that and refuses them above 270 a minute, so boat's estimate ($8,800) is higher than Depot's ($3,588).

ScenarioboatDepot
One coding agent, workdaysNone for this scenario
  • different kind of product: CI runner
  • egress price not published
One agent that never stopsNone for this scenario
  • different kind of product: CI runner
  • sessions end after 24 h: needs restarts to run 24/7
  • egress price not published
50 agents in parallelNone for this scenario
  • different kind of product: CI runner
  • egress price not published
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
Sandboxes for your usersNone for this scenario
  • different kind of product: CI runner
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • egress price not published
1,000 short jobs at once
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429
  • different kind of product: CI runner
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • egress price not published
boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Which one should you use?

Use Depot when

you want faster GitHub Actions and Docker builds, need macOS or Windows runners, or want hosted third-party agents such as Devin or Amp in sandboxes inside your private network.

  • macOS and Windows runners. Useful if you build or test for Apple or Windows: Depot rents macOS and Windows runners by the minute.
  • Drop-in CI with a fast cache. Useful if your goal is faster GitHub Actions: change one runs-on label and jobs use Depot's runners and cache.
  • US region, Arm, private network, egress rules. Useful if jobs must run in the US, on Arm, inside your private network, or with outbound traffic limited to chosen hosts.

Use boat when

your agents need a machine that stays: a full VM that keeps its disk, forks while running, serves apps on public HTTPS URLs and comes with coding agents you drive from outside.

  • A machine that stays. An agent that installs tools, clones repos and builds for days needs one machine. On Depot you snapshot before each sandbox ends and restore into a new one, and changes after the last snapshot are lost. Managed Agents does this for you, but running programs still restart.
  • Apps your agents can serve. Without public inbound access, people outside your tailnet cannot see what an agent built. On Depot you add your own tunnel to each sandbox, and it ends when the sandbox ends.
  • Coding agents you drive from outside. Depot documents no prompt, steer and events API of its own, so to drive agents from your backend you use each provider's API. In Depot CI jobs, runners and Sandbox SDK sandboxes, secrets are environment variables that code in the machine can read.

Questions people ask

Is Depot an agent sandbox?

Partly. Depot is mainly build and CI infrastructure: GitHub Actions runners, Depot CI and Docker builds. It also sells Depot Sandboxes, isolated Linux microVMs with a Node.js SDK, and Managed Agents, which runs Amp, Claude Code, Claude Managed Agents, Devin and OpenAI agents in those sandboxes. Sandbox SDK sandboxes end after at most 24 hours; snapshots carry files (not running processes) into the next sandbox, and there is no documented public inbound access.

Is boat cheaper than Depot?

For four of the five agent scenarios on this page, yes: $20 against $122 a month for one coding agent on workdays, $26 against $534 for one agent running all month, $317 against $5,710 for 50 agents in parallel, and $200 against $1,628 for your users' sandboxes. For 1,000 short jobs at once, Depot's estimate is lower ($3,588 against $8,800), because boat charges for starts above its plan's included count. Depot's totals use its Linux runner prices on the $20 Developer plan with included minutes subtracted; Depot Sandboxes cost the same per vCPU. For plain GitHub Actions CI, Depot is built for it.

Can I run GitHub Actions on boat?

Yes, you set it up: a boat sandbox is a full Linux VM with root, so you register it as a self-hosted runner or run your build scripts in it, with Docker and /dev/kvm ready. Depot does this for you with a one-line runs-on change and a managed cache, which is simpler if CI speed is all you need.

Does boat have macOS or Windows like Depot?

No. boat runs Ubuntu VMs on x64 hosts (AMD Ryzen 7 9700X and Ryzen 9 9950X) and has Wine docs for Windows apps. If you need macOS runners for Xcode or Windows Server runners, Depot has both.

Where does my data run?

boat runs sandboxes on machines in Germany, Finland and France, and you cannot pick a region; snapshot copies can be stored outside the EU. Depot runs in the United States, and in the European Union if a project chooses the EU region.

Is boat SOC 2 compliant?

No SOC 2 report today; SOC 2 is in progress. Depot states SOC 2 Type II. Live status is at status.ascii.dev and our data retention policy is at docs.boat.dev/data-retention.

Start a sandbox

Install the CLI, then run boat new.

7-day free trial

More comparisons