boat vs Aptible
Aptible is a platform for deploying web apps and managed databases as Docker containers on AWS, built for health and other regulated teams. boat is a sandbox for AI agents: each one gets a full VM with root, Docker and /dev/kvm, a disk saved every minute, and coding agents you drive from outside.
Where boat stands out
A full VM with Docker and KVM
Every boat sandbox has its own kernel, with root, systemd, Docker and /dev/kvm ready. An Aptible workload is a Docker container on a shared EC2 host, and its docs describe no Docker inside it, no privileged mode and no nested virtualization.
A disk that keeps the agent's work
A boat sandbox keeps its whole disk, saves it every minute and on stop, and can be forked while it runs. Aptible wipes a container's filesystem on every deploy, restart or scale. Its Persistent Disk keeps one folder for a single-container service, and Aptible does not back it up.
Agents and a desktop built in
boat ships Claude Code, Codex, OpenCode and other agents in each sandbox, which you drive from outside with a prompt, steer and events API, plus a 60fps desktop with Chromium and computer use. Aptible runs the apps you deploy; its AI product, the LLM Gateway, routes model calls and does not run agents.
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
Aptible
Aptible is a platform as a service (PaaS) for deploying web apps, databases and AI on isolated AWS infrastructure, aimed at digital health teams.
You push a Docker image or a git repo, and Aptible runs it as containers on EC2 hosts inside a Stack, with managed databases, load-balanced endpoints, logs and metrics around it. Shared Stacks are for development and staging; Dedicated Stacks belong to one customer and add VPN, VPC peering and a HIPAA BAA. It is an app host, not an agent sandbox, so this page compares the two only where they overlap: running long-lived Linux workloads that agents or users drive.
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 | Aptible: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs agents that install packages, run Docker and keep their work; Aptible containers lose local files on every restart and do not document Docker inside. | 3rd cheapest of 367 $634 a month | 351st of 367, with limits $14,979 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Aptible keeps a container running for as long as you like, but its filesystem is wiped on each recycle, so an assistant's state must live on a Persistent Disk or a database. | 5th cheapest of 366 $657 a month | 349th of 366, with limits $15,299 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs fit neither cleanly: Aptible bills containers from provisioning and has no fast create-run-destroy API, and boat's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 306th of 345, with limits $1,071 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Aptible does not publish how many containers can run at once, and one service scales to 32 containers from the dashboard or 128 from the CLI, so 300 user sandboxes means many services. | Cheapest of 361 $209 a month | 336th of 361, with limits $7,472 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 | 323rd of 360, with limits $32,137 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 | 335th of 364, with limits $6,427 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build images need Docker inside the job, which boat has on every machine and Aptible's container docs do not describe. | 4th cheapest of 377 $86 a month | 359th of 377, with limits $3,098 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB aptible ssh opens a fresh 1 GB container that ends after seven days, not a shell in a machine that keeps your files. | 18th cheapest of 368 $26 a month | 203rd of 368, with limits $944 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Aptible has no desktop, browser or computer-use tooling, so computer-use agents would need you to build all of it into an image. | 6th cheapest of 369 $200 a month | 357th of 369, with limits $6,427 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 | 347th of 367, with limits $3,214 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 | 324th of 346, with limits $1,607 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 | 297th of 338, with limits $24,663 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 | 329th of 360, with limits $1,614 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
Every feature Battleships tracks (43)
| Feature | boat | Aptible |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| 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 | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| 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 | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| 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 | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public benchmark, but Aptible is not in that benchmark, so we cannot say which is faster. Aptible guarantees each container a CPU share in line with its memory and lets it burst above that when the host has room to spare.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Aptible 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 | Aptible, 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 | $650 · Production · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $1,093 · Production · 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 | $7,739 · Production · 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 | $3,214 · Development · 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 | $6,427 · Development · 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.
Aptible: Aptible bills containers per GB of memory per hour with CPU bundled in: $0.08 for general purpose, which comes with 1 vCPU per 4 GB, from the moment a container is provisioned, idle or not. Production adds a $499 monthly base fee that is not usage credit, endpoints cost $0.06 an hour each and Persistent Disks $0.20 per GB-month, and egress has no published price, so our bills leave it out.
Limits in those scenarios
Aptible marks every scenario as not a clean fit because it is an app platform, not a sandbox, and because it does not publish an egress price. It publishes no limit on how many containers run at once, and one service scales to 32 containers from the dashboard or 128 from the CLI, so 300 or 1,000 sandboxes means splitting work across many services. A Persistent Disk forces its service down to one container, and the 50-agent fleet also misses Docker inside. On boat, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | boat | Aptible |
|---|---|---|
| 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 Aptible when
you are hosting a production web app and its databases on AWS, in a region outside the EU or inside your own AWS account, rather than giving agents machines to work in.
- Apps and managed databases together. Useful if you are hosting a production web app: Aptible runs your services and managed databases with daily backups in one Stack.
- AWS regions worldwide. Useful if your users or data sit outside Europe: on the Production plan, Dedicated Stacks run in 14 AWS regions, from Virginia to Tokyo.
- Runs in your own AWS account. Useful if workloads must stay inside your own cloud account: Enterprise can self-host Aptible in your AWS.
Use boat when
agents need a machine of their own: a full VM with Docker and KVM, a disk that keeps their work and can be forked, a desktop, and coding agents you drive from outside.
- A full VM with Docker and KVM. Agents build images, run docker compose for tests and boot emulators. On Aptible those steps have nowhere to run, so you would build and push every image from somewhere else first.
- A disk that keeps the agent's work. An agent that installs packages and edits a repo for hours loses all of it when Aptible recycles the container. The workaround is a Persistent Disk you back up yourself, and no way to fork a run to try two ideas.
- Agents and a desktop built in. On Aptible you would package the agent, a browser and a screen into your own image, write the code that starts and watches each one, and still have no live desktop to see what it did.
Questions people ask
Is boat cheaper than Aptible?
In every scenario we priced, yes, though Aptible is an app platform and fits none of them cleanly. One coding agent on workdays comes to $20 a month on boat and $650 on Aptible, one agent running all month to $26 versus $1,093, and 50 agents in parallel to $317 versus $7,739. Sandboxes for your users come to $200 versus $3,214, and 1,000 short jobs at once to $2,000 versus $6,427.
Can Aptible run AI agent sandboxes?
It can run an agent as a long-lived container, but it was built to host apps. Its containers lose local files on every restart, its docs do not describe Docker inside, and it has no desktop, fork or snapshot. boat is built for that job, with a full VM per agent.
Can I run Docker inside an Aptible container?
Aptible's docs do not describe Docker inside a container or a privileged mode; you deploy a Docker image that Aptible builds or pulls for you. Every boat sandbox runs Docker, systemd and /dev/kvm as root.
Does Aptible keep files when a container restarts?
Not by default: the filesystem is wiped each time containers are recycled on deploy, restart or scale. A Persistent Disk keeps data for a single-container service, but Aptible does not back it up. boat keeps the whole disk and snapshots it every minute and on stop.
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. Aptible runs on AWS, with Shared Stacks in 6 regions on any plan, Dedicated Stacks in 14 from the Production plan, and self-hosting in your own AWS account on Enterprise.
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. Aptible's pricing page lists HIPAA and SOC 2 on its Production plan.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial