boat vs Latitude.sh
Latitude.sh rents whole physical servers and plain VMs that you install, secure and look after yourself. boat gives each agent a full VM that is ready to work, with snapshots every minute, stops that cost nothing, fork of a running machine, HTTPS ports, a desktop and coding agents built in.
Where boat stands out
Free stops, minute snapshots and fork while running
boat saves a sandbox's disk every minute and when it stops, and a stopped sandbox costs nothing. You can fork a running sandbox in one call. On Latitude.sh, a shut-down VM keeps billing until you delete it, and copying a machine means taking a backup and restoring it into a new VM.
Coding agents and a desktop built in
Every boat sandbox has Claude Code, Codex, OpenCode and other agents ready, and you drive them from outside with a prompt, steer and events API. It also streams a 60fps desktop with Chromium for computer use. The credentials proxy keeps real AI keys out of the machine and can switch to another account when one runs out of credits.
HTTPS ports with no setup
Each boat sandbox can serve HTTPS on up to 50 ports, token-protected, plus raw TCP and its own IP. A Latitude.sh machine gets a public IP, and the web server, certificates, domain and access control are yours to run.
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
Latitude.sh
Latitude.sh is an infrastructure provider that rents automated dedicated servers, GPU servers and virtual machines in 26 locations.
Its main product, Metal, gives you a whole physical server with your own operating system, from a 6-core Intel box up to 192-thread AMD EPYC machines, plus GPU servers with Nvidia H100, RTX PRO 6000 and B300 cards. It also sells general-purpose Linux VMs, block, file and object storage, private networks, Kubernetes and managed Postgres, all driven from a dashboard, an API, Terraform or a hosted MCP server. It is general infrastructure, not an agent sandbox, so this page compares the two where they overlap: giving an agent its own Linux machine.
- Stopped machines
- Shutting down a VM does not pause billing; you have to delete it
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 | Latitude.sh: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both give an agent a Linux machine with root and Docker, but a Latitude.sh VM starts empty and bills until deleted, while boat comes with agents, snapshots and free stops. | 3rd cheapest of 367 $634 a month | 243rd of 367, with limits $3,344 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Latitude.sh VM can run an assistant around the clock, but you build the agent setup, the HTTPS endpoint and the backups yourself; boat has them built in. | 5th cheapest of 366 $657 a month | 214th of 366, with limits $2,416 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither fits one-minute runs well: Latitude.sh bills by the hour and deploys VMs 1 to 5 at a time from the dashboard, and boat's start limits queue big bursts. | 186th of 345, with limits $2,000 a month | 193rd of 345, with limits $4,833 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Latitude.sh limits how many VMs a team can run and raises it only after a request with a business justification, so 300 user sandboxes need approval first; boat allows 100 to 2,000 by plan. | Cheapest of 361 $209 a month | 180th of 361, with limits $5,700 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 | 206th of 360, with limits $48,330 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 | 82nd cheapest of 364 $2,850 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both run Docker builds; on Latitude.sh you run the runner software, the images and the clean-up yourself, and you pay for whole hours. | 4th cheapest of 377 $86 a month | 129th cheapest of 377 $2,100 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both fit a 24/7 dev box: a Latitude.sh VM or server is a classic always-on machine, and a boat machine keeps its disk with snapshots every minute. | 18th cheapest of 368 $26 a month | 95th cheapest of 368 $139 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month boat streams a 60fps desktop with Chromium and computer use; on Latitude.sh you install a desktop, a browser and the control loop yourself. | 6th cheapest of 369 $200 a month | 315th of 369, with limits $2,417 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | 342nd of 367, with limits $2,417 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 | 315th of 346, with limits $1,140 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 | 290th of 338, with limits $22,800 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 | 312th of 360, with limits $950 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Latitude.sh fits: it rents H100, RTX PRO 6000 and B300 GPU servers, and boat has no GPUs. | Can't run it | 43rd of 98, with limits $1,685 a month |
| 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 | Latitude.sh |
|---|---|---|
| What you get | A sandbox API for agents, on full VMs | Dedicated servers and general VMs you set up and run yourself |
| Isolation | Every sandbox is a full VM with its own kernel | Metal: a whole physical server per customer; VMs: shared hosts, hypervisor not documented |
| CPU | Dedicated AMD Ryzen 9 9950X (Zen 5) hosts; 26.69 runs/s at 4 vCPU / 8 GB | Intel Xeon and AMD EPYC servers up to 192 threads; no comparable measurement |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine, documented | Full control of a Metal server, KVM included; VMs give sudo, and nested virtualization is not documented |
| Stopping | A stopped sandbox costs nothing and keeps its disk | Shutting down does not pause billing; only deleting stops it |
| Snapshots | Automatic snapshots every minute and on stop | VMs: backups of the disk when you ask for one; Metal servers: none |
| Fork | Fork a running sandbox in one call (disk, no memory) | VMs: take a backup, then restore it into a new VM (disk, no memory) |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP | A public IPv4 that stays with the machine; HTTPS, certificates and domains are yours to set up |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | None built in; you connect over SSH |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | None inside the machine; a hosted MCP server lets an agent manage your Latitude.sh servers from outside |
| Keeping keys out of the machine | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | No credentials proxy; secrets live on the machine |
| Firewall | Open internet on every plan; no provider-side allowlist | Inbound and outbound TCP and UDP rules, enforced by a UFW agent inside each machine |
| GPUs and Windows | No GPUs; no Windows guests (Wine for Windows apps) | H100, RTX PRO 6000 and B300 GPU servers; Windows on Metal servers |
| Regions | EU only: Germany, Finland, France | 26 locations in the Americas, Europe, Asia and Australia |
| 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 | Latitude.sh |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| 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 | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | Yes |
| Egress allowlist | No | No |
| 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 | Yes |
| Windows | No | Yes |
| 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 | Yes |
| 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 Latitude.sh: its servers and VMs were not part of the public StarSling benchmark run where boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Results would depend on the plan you pick, from a shared-host VM to a whole AMD EPYC server.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Latitude.sh 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 | Latitude.sh, 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 | $33 · Usage account |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $48 · Usage account · 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 | $1,672 · Usage account |
| 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 | $5,700 · Usage account |
| 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 | $38,000 · Usage account |
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.
Latitude.sh: Latitude.sh bills hourly, monthly at half the hourly rate, or yearly upfront at 65% less, and a machine bills until you delete it, even when shut down. The prices here use the vm.small VM (4 vCPU, 16 GB); a monthly server deleted early is not refunded, and a yearly one can only be deleted when its term ends.
Limits in those scenarios
Latitude.sh limits how many VMs and servers a team can run, and raises the limit only after a request with a business justification is approved. New accounts also start with a $100 spending limit on hourly plans, rising to $500 with consistent payments and higher only through sales, so 50 agents, 300 user sandboxes or 1,000 short jobs all need a talk with Latitude.sh first. The cheapest always-on price needs a one-year prepaid term. On boat the limit is a sandbox count (100 to 2,000 by plan) plus 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 | Latitude.sh |
|---|---|---|
| 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 | None that bite |
| Sandboxes for your users | None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
Which one should you use?
Use Latitude.sh when
you need whole physical servers, GPUs, Windows, or regions outside the EU for long-lived infrastructure you run yourself.
- Whole physical servers. Useful if one job needs a big machine to itself: Latitude.sh rents dedicated servers up to 192 threads and 1.5 TB of memory.
- GPU servers. Useful if your agents train or serve models: Latitude.sh rents servers with Nvidia H100, RTX PRO 6000 and B300 cards.
- Regions around the world. Useful if your users are outside Europe: Latitude.sh has 26 locations across the Americas, Europe, Asia and Australia.
Use boat when
you want each agent on its own full VM that is ready to work: coding agents, a desktop, HTTPS ports and minute-by-minute snapshots built in, fork while running, and stops that cost nothing.
- Free stops, minute snapshots and fork while running. Agents sit idle between tasks. On Latitude.sh you either pay the full hourly rate for an idle VM or delete it and set it up again, and backups only exist when you remember to take one.
- Coding agents and a desktop built in. A Latitude.sh VM starts as an empty OS image. You install, update and supervise each agent, desktop and key yourself, and the agent can read any key you put on it.
- HTTPS ports with no setup. An agent that starts a preview or a webhook needs a safe HTTPS link right away. On Latitude.sh that link means a reverse proxy, a certificate and a firewall you build and keep patched on every machine.
Questions people ask
Is boat cheaper than Latitude.sh?
In the scenarios we priced, yes: one coding agent on workdays comes to $20 a month on boat and $33 on Latitude.sh, and 50 agents in parallel come to $317 against $1,672. One agent that never stops comes to $26 on boat against $48 on Latitude.sh, but only with a one-year prepaid VM. Latitude.sh's VM also has 16 GB of memory against boat's 8 GB.
Do I pay for a Latitude.sh machine that is shut down?
Yes. Latitude.sh says shutting down a virtual machine does not pause billing, and you have to delete it to stop the charges. On boat, a stopped sandbox costs nothing and keeps its disk.
Does Latitude.sh have an agent sandbox product?
No. It rents dedicated servers, GPU servers and VMs, and you install agents yourself and reach them over SSH. Its hosted MCP server lets an agent manage your Latitude.sh account, not run inside a sandbox. boat is built for agents, with coding agents, a desktop and a credentials proxy in every sandbox.
Can I run Docker and nested VMs on Latitude.sh?
On a Metal server, yes, since you control the whole physical machine. On its VMs you get sudo and can run Docker, but nested virtualization is not documented. On boat, Docker, systemd and /dev/kvm are documented on every machine.
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. Latitude.sh has 26 locations, including Frankfurt, Amsterdam and London in Europe.
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