boat vs Tangle Sandbox
Tangle Sandbox runs each agent in a dev container or microVM, with GPU leases, egress rules and a hosted MCP endpoint. boat gives every agent a full VM with Docker, a desktop and private hosting built in, and it costs less in four of the five scenarios below.
Where boat stands out
A full VM for every sandbox
On boat every sandbox has its own kernel, with root, systemd, Docker and /dev/kvm ready. Tangle's docs say a sandbox is a dev container or microVM, without saying which one you get, and they do not document Docker inside a sandbox, root or /dev/kvm.
A desktop for computer use
Every boat machine has a 60fps desktop and Chromium, with computer use and browser control, and you can embed the stream in your own app. Tangle exposes computer tools over MCP when a sandbox is created with computer_use, and its docs say support depends on the image and deployment.
Private hosting from the sandbox
boat gives a sandbox HTTPS URLs for up to 50 ports, protected by a token, plus raw TCP. Tangle's preview URLs are public, and other traffic reaches the sandbox only as SSH through its API proxy.
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
Tangle Sandbox
Tangle Sandbox is the flagship product of Tangle, a set of services for AI agents: you create isolated Linux sandboxes from an SDK, a CLI or plain HTTPS.
Each Tangle sandbox is a dev container or microVM with a shell, files, ports, snapshots and a coding harness such as OpenCode, Claude Code or Codex. On top it adds durable prompt sessions, fleets of sandboxes, GPU leases for single commands, egress rules and a hosted MCP endpoint. It sits next to Tangle's Router (one API for many models) and Intelligence (traces of agent runs), and it is built for teams that run coding agents, batches and evals from code.
- Regions
- Not published
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 | Tangle Sandbox: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat gives each agent a full VM with Docker, root and /dev/kvm; Tangle's docs do not say Docker runs inside a sandbox, so container-heavy builds are a compromise there. | 3rd cheapest of 367 $634 a month | 35th of 367, with limits $1,361 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB boat keeps each assistant on its own VM with a disk snapshotted every minute; Tangle keeps the workspace after a stop but does not publish what a stopped sandbox costs. | 5th cheapest of 366 $657 a month | 40th of 366, with limits $2,328 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Tangle fits short code runs better: it bills per second with no plan fee and returns typed results like images and dataframes, while boat's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 90th of 345, with limits $131 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month boat can put each user's app behind a token-protected HTTPS URL; Tangle's preview URLs are public, so you add your own access check. | Cheapest of 361 $209 a month | 68th of 361, with limits $581 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 | 47th of 360, with limits $2,806 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 | 116th of 364, with limits $452 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 153rd of 377, with limits $306 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 73rd cheapest of 368 $98 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 for computer use; Tangle exposes computer tools over MCP, and its docs say support depends on the image and deployment. | 6th cheapest of 369 $200 a month | 47th of 369, with limits $406 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both can run Chromium; on Tangle it ships in the node-typescript template, on boat it is on every machine with browser control. | 7th cheapest of 367 $200 a month | 61st of 367, with limits $203 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 | 89th of 346, with limits $195 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 | 32nd of 338, with limits $4,068 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 | 54th of 360, with limits $151 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Tangle can lease a GPU such as an H100 for one command but publishes no GPU prices, so this table cannot price it; boat has no GPUs. | 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 | Tangle Sandbox |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | A dev container or microVM; which one a hosted sandbox gets is not published |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Dockerfile image builds; Docker inside a sandbox, root and /dev/kvm are not documented |
| Desktop, browser and computer use | 60fps desktop and Chromium on every machine, computer use and browser control, embeddable stream | Computer tools over MCP when created with computer_use, depending on image and deployment; Playwright Chromium in a template |
| Files after a stop | Whole disk kept, snapshots every minute and on stop; a stopped sandbox costs nothing | stop() keeps the workspace; workspace snapshots on demand, 3 to 25 per sandbox by plan |
| Fork | Fork a running sandbox into a new one | Start a new sandbox from another sandbox's snapshot, or clone a workspace |
| Custom images | Named snapshots (templates), shareable by code; no Dockerfile builds | Container images, Dockerfile builds and public templates |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH | Public HTTPS preview URLs per port; SSH through the API proxy |
| Outbound internet | Open internet on every plan; no provider-side allowlist | Open, domain allowlist or blocked, changeable on a running sandbox, with logs of refused hosts |
| 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 | Encrypted secrets injected as environment variables at boot; short-lived scoped tokens for clients |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | OpenCode by default, plus Claude Code, Codex and others; durable prompt sessions and agent fleets |
| GPUs | None | GPU leases (such as H100) attached for one command, with a spend cap |
| MCP server | No hosted MCP endpoint | Hosted MCP endpoint and a local MCP bridge |
| Regions | EU only: Germany, Finland, France, with EU data residency | Not published |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | boat | Tangle Sandbox |
|---|---|---|
| Full VM (own kernel) | Yes | Not published |
| Docker inside | Yes | Not published |
| Nested virtualization | Yes | Not published |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Not published |
| Browser | Yes | Yes |
| Computer-use API | Yes | Not published |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Not published |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Not published |
| Memory fork | No | Not published |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Not published |
| Idle auto-stop | No | Yes |
| Wake on request | No | Not published |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | Not published |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Not published |
| Secret proxy for any API | Yes | Not published |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | Yes |
| Windows | No | Not published |
| Arm64 | No | Not published |
| Self-hosting | No | Not published |
| BYOC | No | Not published |
| Open source | No | Not published |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | Not published |
| Audit logs | No | Not published |
| SSO | No | Not published |
| SOC 2 | No | Not published |
| HIPAA | No | Not published |
| EU data residency | Yes | Not published |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Tangle Sandbox: it has no result in StarSling's public benchmark, and Tangle does not publish its CPU type. In that benchmark's run of 2026-09-29, 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.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tangle Sandbox 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 | Tangle Sandbox, 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 | $21 · Pay as you go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $98 · Pay as you go |
| 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 | $894 · Pay as you go · 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 | $254 · Pro · 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 | $561 · Pay as you go · 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.
Tangle Sandbox: Tangle bills per second for the vCPU, memory and disk you ask for, from prepaid credit, and never less than $0.04 an hour per running sandbox. Pay as you go has no fee but no free credit either; Pro ($29.99) and Team ($99) turn their fee into the same amount of monthly credit and bill egress beyond 2 TB per sandbox.
Limits in those scenarios
On Tangle's Pay as you go plan only 1 sandbox runs at a time, which is why 50 agents in parallel and 1,000 short jobs at once do not fit there. Pro and Team list "Unlimited sandboxes" and Tangle's plan data marks their concurrency as unlimited, but the table cannot yet count an unlimited cap, so it assumes 1 on those plans too, including the Pro plan priced for one sandbox per user. On a paid plan, running many sandboxes at once should not be the blocker. Tangle publishes no size limit per sandbox and no account start rate; your ceiling shows only after sign-in. 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 top plan allows.
| Scenario | boat | Tangle Sandbox |
|---|---|---|
| One coding agent, workdays | None that bite | None that bite |
| One agent that never stops | None that bite | 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 Tangle Sandbox when
you need a GPU for single steps, strict per-domain egress rules, or quick code-interpreter runs with typed results and no monthly fee.
- GPU for one step. Useful if one step of a job needs a GPU: Tangle leases one, such as an H100, just for that command, with a spend cap.
- Egress rules with logs. Useful if a sandbox must reach only a few domains: Tangle sets open, allowlist or blocked per sandbox and logs refused hosts.
- Code runs and MCP for agent products. Useful for code-interpreter tools: Tangle returns images, dataframes and JSON from a persistent kernel and offers a hosted MCP endpoint.
Use boat when
your agents do long, real work: builds with Docker and emulators on a full VM, a desktop for computer use, and apps hosted behind private URLs.
- A full VM for every sandbox. Agents that run docker compose, test containers or start an Android emulator need Docker and /dev/kvm. On Tangle you would have to find out first whether your sandbox has them, since the docs do not say.
- A desktop for computer use. A computer-use agent needs a screen to look at and click. On Tangle you build or pick an image that supports it, and no desktop stream for a person to watch is documented.
- Private hosting from the sandbox. An agent's half-built app, admin panel or database UI on a public URL can be found by anyone with the link. On Tangle you put your own login in front of each preview; databases and game servers need raw TCP.
Questions people ask
Is boat cheaper than Tangle Sandbox?
In four of the five scenarios we priced, yes: one coding agent on workdays is $20 a month on boat and $21 on Tangle, one agent running all month is $26 versus $98, and 50 agents in parallel are $317 versus $894. For 1,000 short jobs at once Tangle comes to $561 against $2,000 on boat, though neither fits without higher limits.
Are Tangle sandboxes containers or VMs?
Tangle's docs say each sandbox is a dev container or microVM, and that the same SDK works across both, but they do not say which one a hosted sandbox gets. On boat, every sandbox is a full VM with its own kernel.
Does Tangle Sandbox have GPUs?
Yes, as leases: you attach a GPU worker such as an H100 to a sandbox for the command that needs it, with a spend cap, then release it. boat has no GPUs.
Can I limit what a sandbox reaches on the internet?
On Tangle, yes: each sandbox can be open, limited to a list of domains, or cut off, and you can change it while it runs. boat sandboxes have open internet, and boat's credentials proxy keeps real API keys out of the sandbox instead.
Is there a free tier?
Tangle has none: its setup guide says there is no free tier or free credit, so you add prepaid credit before the first sandbox. boat has a free Trial plan with 2 sandboxes at a time for up to 2 hours each.
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