boat vs tama
tama rents Linux machines with GPUs by the second, and only its /workspace folder survives a stop. boat gives every agent a faster VM whose whole disk persists, with root, systemd, /dev/kvm, a desktop and coding agents built in.
Where boat stands out
The whole machine survives a stop
On boat the whole disk persists, with snapshots every minute and on stop, so packages, services and config are all there when the sandbox comes back. On tama only the 50 GiB /workspace disk survives a stop. Anything installed with apt, global npm packages or files in your home folder must be put back after each cold start.
A faster CPU in the same test
In the same public benchmark run at 4 vCPU / 8 GB, boat did 26.69 runs per second and tama did 16.77, about 1.6 times faster. boat runs on dedicated AMD Ryzen 9 9950X (Zen 5) hosts, and gives root, systemd, Docker and /dev/kvm on every machine.
Real keys never enter the sandbox
boat's AI credentials proxy adds your keys to requests on the way out, for model providers and any HTTPS API you register, so the agent never sees them. tama keeps secrets out of snapshots, but injects the real value as an environment variable into the agent process. boat also lets you drive Claude Code, Codex and more with a prompt, steer and events API.
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
tama
tama sells Linux machines with optional GPUs, driven from a CLI and Python and TypeScript SDKs, billed per running second.
A tama machine is an Ubuntu machine you can SSH into, run Claude or Codex inside, snapshot, fork and stop. Stopping takes a snapshot, with memory for normal machines, and a stopped machine costs nothing. It is built for coding agents, kernel work and GPU experiments such as fine-tuning and inference tuning.
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 | tama: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat keeps the whole disk, root, systemd and /dev/kvm on every VM; on tama, tools installed outside /workspace are gone after a stop. | 3rd cheapest of 367 $634 a month | 119th of 367, with limits $1,095 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs for months needs its whole machine to persist, and on tama only /workspace does. | 5th cheapest of 366 $657 a month | 184th of 366, with limits $1,658 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month tama fits short runs better: no plan fee and machines from 1 vCPU, while boat's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 67th of 345, with limits $74 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month tama publishes no limit on how many machines can run at once, so 300 sandboxes for your users is not confirmed there. | Cheapest of 361 $209 a month | 60th of 361, with limits $467 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 | 37th of 360, with limits $2,258 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 | 107th of 364, with limits $363 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit: tama's docs show a whole CI job in four lines, and boat runs it on a faster CPU with Docker and /dev/kvm. | 4th cheapest of 377 $86 a month | 15th cheapest of 377 $218 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 152nd of 368, with limits $66 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month tama's desktop is a KasmVNC tab with no computer-use API; boat streams a 60fps desktop with Chromium and computer use built in. | 6th cheapest of 369 $200 a month | 138th of 369, with limits $327 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month boat has Chromium and browser control in every sandbox; tama documents no managed browser. | 7th cheapest of 367 $200 a month | 192nd of 367, with limits $163 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 | 191st of 346, with limits $111 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 | 91st of 338, with limits $2,214 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 | 148th of 360, with limits $108 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only tama fits: it rents Nvidia GPUs by the second, and boat has no GPUs. | Can't run it | 27th cheapest of 98 $1,971 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 | tama |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | Described as a Linux VM per machine |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 26.69 runs/s | 16.77 runs/s |
| Root, systemd and nested virtualization | Root, systemd, Docker and /dev/kvm on every machine | Docker in the base image; you log in as the tama user; root, systemd and /dev/kvm are not documented |
| Files after a stop | The whole disk persists; snapshots every minute and on stop; a stopped sandbox costs nothing | Only the 50 GiB /workspace disk survives a stop; a stopped machine costs nothing |
| Memory after a stop | Resume reboots from disk (no memory snapshots) | Warm restore in about a second with processes still running, GPU memory included; desktop machines resume cold |
| Fork | Fork a running sandbox | Fork from a snapshot or a machine's latest snapshot; the fork boots cold from a copy of the disk |
| Custom images | Named snapshots (templates), shareable by code; no Dockerfile builds | Build from a Dockerfile, run any image, and save private or public templates |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | KasmVNC desktop in a browser tab on machines made with --desktop; no computer-use or browser API |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | Public HTTPS URL per exposed port where the URL is the credential; SSH and port-forward over a tunnel; no raw TCP or public IP documented |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Workspace secrets are injected as environment variables into the machine or agent process; kept out of snapshots and forks |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Claude and Codex preinstalled; tama prompt starts a run and streams its stdout and stderr as a transcript |
| GPUs | None | Nvidia cards from RTX 4090 to H100, one per machine, billed by the second |
| Machines at once | Published per plan: 100 to 2,000 sandboxes | No limit published |
| Regions | EU only: Germany, Finland, France, with EU data residency | No region choice documented |
| 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 | tama |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Not published |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| 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 | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| 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 | Yes |
| MCP server | No | No |
| GPU | No | Yes |
| 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
In StarSling's public run of 2026-09-29, at 4 vCPU / 8 GB, boat did 26.69 Node.js build-and-test runs per second and tama's CPU machine did 16.77. That makes boat about 1.6 times faster on the same work. tama's GPU machines were not part of this test.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. tama measured on: CPU on-demand.
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 | tama, 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 | $14 · Pay per running second · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $66 · Pay per running second · 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 | $719 · Pay per running second · 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 | $204 · Pay per running second · 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 | $452 · Pay per running second · 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 whole disk.
tama: tama has no plan fee: you buy credit and pay per running second, $0.0117 per vCPU-hour plus $0.0055 per GiB-hour of memory, or a fixed hourly rate per GPU machine. Snapshots and stopped machines are free; egress prices are not published.
Limits in those scenarios
On tama the limit that bites first is persistence: only /workspace survives a stop, so in every scenario with stops, anything installed elsewhere resets. tama publishes no limit on how many machines run at once, so 50 agents may be fine but 300 sandboxes for your users or 1,000 short jobs are not confirmed. 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 | tama |
|---|---|---|
| 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 tama when
your agents need a GPU, a warm restore that keeps running processes, or a machine built from a Dockerfile.
- GPUs by the second. Useful if your agents train or tune models: tama rents Nvidia cards from RTX 4090 to H100 by the second.
- Warm restore with memory. Useful if a stopped job should come back in about a second with its processes, GPU memory and CUDA context still running.
- Dockerfile builds. Useful if your setup lives in a Dockerfile: tama builds it and boots the result, and can publish public templates.
Use boat when
your agents do real CPU work for hours or months: installs, builds, tests, Docker and emulators on a faster VM whose whole disk persists, with a desktop, coding agents and a credentials proxy built in.
- The whole machine survives a stop. An agent that installed tools outside /workspace finds them gone after a cold start or fork on tama. The workaround is a template or Dockerfile you rebuild each time the setup changes.
- A faster CPU in the same test. At 16.77 runs per second against 26.69, every install, build and test takes about 60 percent longer on tama, and per-second billing means you pay for that waiting.
- Real keys never enter the sandbox. Code an agent runs on tama can read its own ANTHROPIC_API_KEY and send it anywhere. On boat the sandbox only holds a placeholder, and a credential can switch accounts when credits run out.
Questions people ask
Is boat cheaper than tama?
It depends on the shape. One agent running all month comes to $26 on boat and $66 on tama, and 50 agents in parallel come to $317 versus $719. One coding agent on workdays is $14 on tama against boat's $20 plan, and for 1,000 short jobs at once tama comes to $452 against $2,000, though neither fits without higher limits.
What survives when a tama machine stops?
Only the 50 GiB /workspace disk. A normal machine also comes back warm with its memory, but a cold start, a fork or a desktop machine boots the rest of the disk fresh. On boat the whole disk persists, with snapshots every minute and on stop.
Does boat have GPUs like tama?
No. boat runs Linux VMs on dedicated AMD Ryzen 9 9950X (Zen 5) hosts and has no GPUs. If your agents fine-tune or serve models, tama rents Nvidia cards by the second.
Can I run Claude Code or Codex on both?
Yes. tama has Claude and Codex in its base image and starts them with tama prompt, streaming their output to a transcript. boat preinstalls Claude Code, Codex, OpenCode and more, adds a steer and events API, and keeps the real API keys outside the sandbox.
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. tama does not document a region choice.
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