boat vs AWS Lambda MicroVMs
Lambda MicroVMs is a new AWS service that runs each user or agent session in its own Firecracker microVM for up to 8 hours. boat gives each agent a full Linux machine with Docker that keeps its disk and runs as long as you want, while Lambda MicroVMs fits short sessions that sleep between requests inside your AWS account.
Where boat stands out
A whole machine, for as long as the work takes
A boat sandbox is a full VM with root, Docker, systemd and /dev/kvm, with no session cap on paid plans. A Lambda MicroVM is terminated after 8 hours, counting suspended time, and AWS does not let you raise that limit.
The disk stays, with snapshots and fork
boat saves the whole disk every minute and when a sandbox stops, keeps it until you delete it, and can fork a running sandbox with its disk. A Lambda MicroVM keeps its state only within its 8-hour lifetime, and new MicroVMs can only start from a prebuilt image.
Agents and keys built in
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them from outside through one API. Real API keys stay outside the sandbox in a credentials proxy, and a credential can switch to another account when it runs out of credits.
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
AWS Lambda MicroVMs
AWS Lambda MicroVMs is a serverless AWS compute service, launched in July 2026, that gives each tenant, user session or job its own isolated microVM.
It is part of AWS Lambda, not a dedicated agent sandbox product. You zip a Dockerfile and your app, Lambda builds it into a Firecracker snapshot of memory and disk, and every run-microvm call restores a new MicroVM from that snapshot with its own HTTPS endpoint. A MicroVM can suspend when idle and resume with memory intact, and it lives for at most 8 hours. It is built for AWS teams making code sandboxes, notebooks, dev environments and multi-tenant CI.
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 | AWS Lambda MicroVMs: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent on Lambda MicroVMs is terminated after 8 hours, and Docker inside the MicroVM is not documented; boat gives it a full machine with Docker that keeps running. | 3rd cheapest of 367 $634 a month | 308th of 367, with limits $6,119 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month cannot fit in an 8-hour MicroVM lifetime, so you would rebuild it from an image every day; on boat it simply keeps running. | 5th cheapest of 366 $657 a month | 319th of 366, with limits $7,917 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Lambda MicroVMs is built for this: a code run starts from a ready snapshot, suspends when idle and bills only for snapshot storage while it sleeps. | 186th of 345, with limits $2,000 a month | 149th of 345, with limits $413 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Lambda MicroVMs gives each user a MicroVM with its own endpoint that wakes on the next request, but it ends after 8 hours; boat gives each user a machine that keeps its disk for as long as they come back. | Cheapest of 361 $209 a month | 166th of 361, with limits $2,622 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Fresh environments per rollout from one snapshot suit Lambda MicroVMs well; boat adds fork of a running sandbox to branch from a shared state. | 34th of 360, with limits $2,000 a month | 161st of 360, with limits $12,540 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 | 190th of 364, with limits $2,018 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Android apps or VM images need /dev/kvm, and many need Docker; boat has both, and Lambda MicroVMs documents neither. | 4th cheapest of 377 $86 a month | 327th of 377, with limits $1,220 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that lasts more than a workday; Lambda MicroVMs ends after 8 hours and offers a shell token, not SSH. | 18th cheapest of 368 $26 a month | 332nd of 368, with limits $317 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Lambda MicroVMs is headless; boat streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 6th cheapest of 369 $200 a month | 297th of 369, with limits $1,834 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 | 304th of 367, with limits $926 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 | 293rd of 346, with limits $651 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 | 252nd of 338, with limits $12,736 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 | 292nd of 360, with limits $601 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 | AWS Lambda MicroVMs |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | No |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| 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 | No |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | No |
| 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 | Yes |
| 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 | 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: Lambda MicroVMs was not part of the hpc-sandbox-benchmarks run. boat did 26.69 runs per second on its Node.js build-and-test loop at 4 vCPU / 8 GB. Lambda MicroVMs run on Arm64 Graviton and can burst above their baseline, so a fair test would need to fix the size and note the architecture.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. AWS Lambda MicroVMs 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 | AWS Lambda MicroVMs, 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 | $80 · Pay-as-you-go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $331 · Pay-as-you-go · 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 | $3,995 · 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 | $1,153 · Pay-as-you-go · 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 | $2,508 · Pay-as-you-go · with limits |
boat: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
AWS Lambda MicroVMs: Lambda bills per second for the baseline vCPU and memory while a MicroVM runs, plus any burst above baseline only for the seconds it is used. A suspended MicroVM pays no compute, only snapshot storage, and snapshot reads, snapshot writes and data transfer are billed at AWS rates.
Limits in those scenarios
The 8-hour lifetime is the limit that bites: it counts suspended time and cannot be raised, which is why Lambda MicroVMs does not fit the always-on scenario. The fleet scenarios need Docker, which is not documented inside a MicroVM, and many machines at once, which depends on a per-region memory quota of 400 GB by default (1,024 GB in its biggest regions) that is lower on new accounts. Each MicroVM also caps its endpoint at 16 MB/s and 32 connections at 4 vCPU. boat has no session cap, but its start limits are lower: at 1,000 short jobs at once, the top plan queues starts above 90 per minute.
| Scenario | boat | AWS Lambda MicroVMs |
|---|---|---|
| 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 |
|
| Sandboxes for your users | None that bite |
|
| 1,000 short jobs at once |
|
|
Which one should you use?
Use AWS Lambda MicroVMs when
your sandboxes must stay inside your AWS account and VPC, run outside the EU, or are short sessions that sleep between requests and finish within a workday.
- It lives inside your AWS account. Teams built on AWS keep sandboxes behind their own IAM, VPC, security groups and PrivateLink, in 10 regions.
- Memory suspend and wake on request. For sessions that sit idle between requests, a suspended MicroVM wakes on the next request with its processes still running.
- Pay the baseline, burst when busy. A MicroVM can briefly grow to 4x its baseline size during busy moments, billed only for the seconds it uses the extra room.
Use boat when
your agents do real work for hours or days: installs, builds, tests, Docker, emulators and a browser, on a machine whose disk stays and which you can fork, open and SSH into.
- A whole machine, for as long as the work takes. A long build, a backlog of tickets or an assistant that runs all week gets cut off at 8 hours. On Lambda MicroVMs your code has to save its work elsewhere and start a fresh MicroVM each time.
- The disk stays, with snapshots and fork. When the lifetime ends, everything the agent installed or wrote is gone unless you copied it to S3. Trying three fixes from the same state means building that state three times.
- Agents and keys built in. Lambda MicroVMs is raw compute: you build the harness, the image and the webhook launcher yourself, and the keys your code reads from Secrets Manager sit inside a machine the agent controls.
Questions people ask
Is boat cheaper than AWS Lambda MicroVMs?
In all five scenarios on this page boat costs less per month. Lambda MicroVMs also does not fit four of them, mostly because of its 8-hour lifetime, Docker and how many MicroVMs a new account can run at once. For 1,000 short jobs at once neither fits cleanly, since boat's plans queue starts above 90 per minute.
How long can a Lambda MicroVM run?
Up to 8 hours, and that counts both running and suspended time. The limit is not adjustable, and when it is reached the MicroVM is terminated. boat has no session cap on paid plans.
Can I run Docker inside a Lambda MicroVM?
Lambda uses your Dockerfile to build the image, then runs your app as one container in the MicroVM. Its docs do not say a Docker daemon or /dev/kvm is available inside. boat runs Docker and exposes /dev/kvm for Android emulators and VMs.
Can I SSH into a Lambda MicroVM?
No. You reach it through one HTTPS endpoint with a JWE token on every request, and AWS offers a separate shell access token instead of SSH. boat gives you SSH, raw TCP and HTTPS URLs on up to 50 ports.
Is Lambda MicroVMs an agent sandbox like boat?
Partly. It is a general AWS compute service that AWS documents for AI sandboxes, notebooks, dev environments and CI, and as the tool sandbox for Claude Managed Agents. boat is built around agents, with coding agents, a desktop and a credentials proxy included.
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