boat vs AWS Lambda MicroVMs
Lambda MicroVMs is an 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 with no session cap once you turn auto-stop off. 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. It has no session cap once you turn auto-stop off on a paid plan (auto-stop defaults to 1 hour). A Lambda MicroVM ends 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 disk every minute while the sandbox runs and once more at each stop. It keeps a stopped disk for at least 14 days, or longer as a saved snapshot, and can fork a running sandbox from its last 1-minute snapshot. Memory and running programs are not saved, and writes from the last minute can be missing after a machine failure. A Lambda MicroVM keeps its state only within its 8-hour lifetime, and new MicroVMs 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. With the optional paid credentials proxy on, the real keys of supported providers stay outside the sandbox, 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 June 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, and Lambda builds it into a Firecracker snapshot of memory and disk. 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 that make 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. “5th cheapest of 365” means 4 of the other 364 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 ends after 8 hours, and the docs do not document Docker inside the MicroVM. You can keep its files on a mounted S3 Files file system. boat gives the agent a full machine with Docker that keeps running once auto-stop is off. | 5th cheapest of 365 $634 a month | 319th of 365, 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 does not fit in an 8-hour MicroVM lifetime. You set it up: start a new MicroVM from the image at least every 8 hours and keep its files on a mounted S3 Files file system. On boat it keeps running once auto-stop is off. | 6th cheapest of 361 $657 a month | 93rd of 361, 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 pays only snapshot storage while it sleeps. | 189th of 336, with limits $2,000 a month | 151st of 336, 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, and it ends after 8 hours. boat gives each user a machine that keeps its disk while it runs and for at least 14 days after each stop. | 3rd cheapest of 349 $209 a month | 166th of 349, 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, from its last 1-minute snapshot, to branch from a shared state. | 39th of 349, with limits $2,000 a month | 167th of 349, 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 359 $200 a month | 193rd of 359, 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 the Lambda MicroVMs docs document neither. On boat, each job start counts toward the plan's start limits (the $20 plan: 200 a day included). | 2nd cheapest of 374 $86 a month | 330th of 374, 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 gives shell access through a shell token, not SSH. | 19th cheapest of 371 $26 a month | 338th of 371, 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 ships no desktop or browser; you add them to your image and build the stream yourself. boat streams a full Linux desktop and Chrome at 60 fps for computer-use agents. | 7th cheapest of 367 $200 a month | 61st cheapest of 367 $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 356 $200 a month | 137th of 356, 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 343 $90 a month | 116th cheapest of 343 $651 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 73rd of 327, with limits $1,800 a month | 252nd of 327, with limits $12,736 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 3rd cheapest of 351 $200 a month | 73rd of 351, with limits $601 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | boat | AWS Lambda MicroVMs |
|---|---|---|
| What it is | A sandbox platform: each agent gets its own full Linux machine | A serverless AWS compute service: microVMs restored from a snapshot of your Dockerfile build |
| Isolation | Full VM with its own kernel (x86_64), on hosts dedicated to boat; vCPUs are shared | Firecracker microVM with its own kernel, Amazon Linux 2023 |
| Machine size | Up to 16 vCPU / 32 GB on the $100 plan and above; x86_64 only | Baseline up to 4 vCPU / 8 GB, with automatic burst up to 4x (16 vCPU / 32 GB); x86_64 or Arm64 |
| Disk | 51 GB on the default size, 51 to 251 GB by size; more disk means a bigger size | 8 GB at the default baseline, 32 GB at the largest; you can mount S3 Files for more |
| Session length | No cap once you turn auto-stop off on a paid plan; auto-stop defaults to 1 hour | 8 hours at most, running and suspended time together, not adjustable |
| Pause and resume | Disk saved every minute and at each stop, kept at least 14 days after a stop or longer as a saved snapshot; memory is not saved, so a resume is like a reboot | Suspend checkpoints memory and disk; resume keeps processes running and can happen on the next request; state ends with the 8-hour lifetime |
| Snapshots and fork | Automatic disk snapshots every minute; fork a running sandbox from its last 1-minute snapshot | Suspend checkpoints the same MicroVM; no fork operation; a new MicroVM starts from an image built from a Dockerfile |
| Docker, systemd and /dev/kvm | Root, Docker, systemd and nested virtualization for Android emulators and VMs | Your app runs as one container in the MicroVM; extra capabilities allow mounts, network namespaces and eBPF; Docker and /dev/kvm are not documented |
| Inbound access | HTTPS URLs for up to 50 ports, token-gated by default; SSH; raw ports (IPv6 only on sandboxes without their own IPv4) | One HTTPS endpoint per MicroVM, a JWE token on every request, port chosen by header; HTTP, gRPC and WebSockets only; shell access through a shell token, not SSH |
| Network controls | Open internet; no provider-side egress allowlist | VPC egress connector with security groups and network ACLs; PrivateLink for private access |
| Desktop and browser | Built-in Linux desktop and Chrome streamed at 1920x1080, 60 fps, with computer-use tools | No desktop or browser included; you install and stream them yourself from your Dockerfile (for example Chromium plus a web VNC over the WebSocket endpoint) |
| Coding agents | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API | None preinstalled; you add an agent to your image. AWS documents MicroVMs as the tool sandbox for Claude Managed Agents, where Anthropic runs the agent loop |
| Keeping API keys out of the sandbox | Optional paid credentials proxy ($1 a day on, plus $1 per 1,000 requests) for model providers and any HTTPS API; with it on, real keys of supported providers stay outside the sandbox | Code in the MicroVM reads keys from Secrets Manager through its IAM role |
| Regions | Germany, Finland and France; you cannot pick a region; no US or Asia region | 10 AWS regions across the US, EU and Asia Pacific |
| Compliance | SOC 2 in progress; no HIPAA BAA documented | AWS Lambda is listed as HIPAA eligible, inside AWS's compliance program |
| 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 | AWS Lambda MicroVMs |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No documented way |
| Nested virtualization | Yes | No documented way |
| Root | Yes | Yes |
| Systemd | Yes | No documented way |
| Desktop GUI | Yes | With your own setup |
| Browser | Yes | With your own setup |
| Computer-use API | Yes | No documented way |
| SSH | Yes | No documented way |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | No documented way |
| Live fork (no pause) | Yes | No documented way |
| Memory fork | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | No documented way |
| Idle auto-stop | No documented way | Yes |
| Wake on request | No documented way | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No documented way |
| Public IPv4 | No documented way | No documented way |
| Egress allowlist | No documented way | Yes |
| Secret proxy | Yes | No documented way |
| Secret proxy for any API | Yes | No documented way |
| Preinstalled agents | Yes | No documented way |
| Agent harness API | Yes | No documented way |
| MCP server | No documented way | No documented way |
| GPU | No documented way | No documented way |
| Windows | No documented way | No documented way |
| Arm64 | No documented way | Yes |
| Self-hosting | No documented way | No documented way |
| BYOC | No documented way | No documented way |
| Open source | No documented way | No documented way |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No documented way | Not published |
| SSO | No documented way | Yes |
| SOC 2 | No documented way | Yes |
| HIPAA | No documented way | Yes |
| EU data residency | No documented way | Yes |
| Zero data retention | Yes | Not published |
Performance
Lambda MicroVMs is not in the public benchmarks we use, so we cannot say which is faster. boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Lambda MicroVMs default to Arm64 Graviton and can burst above their baseline, so a fair test must fix the size and name the architecture.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. AWS Lambda MicroVMs is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| 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 | $8,800 · $2000/mo · with limits | $2,508 · Pay-as-you-go · with limits |
boat: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Included VM time expires at the end of the billing period. You pay per second while a sandbox runs: $0.036 an hour for 4 vCPU / 8 GB. A stopped sandbox has no compute charge; saved snapshots above the included count and the AI credentials proxy still charge. Each plan includes a number of starts (the $20 plan: 12 a minute, 60 an hour, 200 a day; create, fork and resume each count), and extra starts cost $0.03 to $0.07 each.
AWS Lambda MicroVMs: Lambda has no monthly fee. It bills per second for the baseline vCPU and memory while a MicroVM runs: $0.0997 per vCPU-hour and $0.0132 per GB-hour on Arm64 in us-east-1, and about 18% more on x86_64. Burst above baseline bills only for the seconds it is used. A suspended MicroVM pays no compute, only snapshot storage ($0.0811 per GB-month in us-east-1). Snapshot reads, snapshot writes and data transfer bill at AWS rates.
Limits in those scenarios
The 8-hour lifetime is the Lambda limit that bites most: it counts suspended time and cannot be raised, so Lambda MicroVMs does not fit the always-on scenario. The fleet scenario needs Docker, which the docs do not document inside a MicroVM. Many machines at once depends on a per-region memory quota of 400 GB by default (1,024 GB in four regions), burstable to 4x and adjustable on request, that starts lower on new accounts. Launches are limited to 5 run-microvm calls per second per region by default (adjustable). Each MicroVM endpoint also has throughput caps that grow with size: at 4 vCPU they are 8 MB/s sustained (40 MB/s for 5 s), 300 connections and 40 requests per second; at 16 vCPU they reach 600 connections and 160 requests per second. boat has its own limits. Auto-stop defaults to 1 hour, and a sandbox runs with no cap only once you turn it off. Starts are capped per plan: the $20 plan includes 12 a minute, 60 an hour and 200 a day, and the $2,000 plan charges for starts above 90 a minute and refuses them above 270. boat never queues a refused start. A stopped disk is kept at least 14 days unless you save a snapshot, and a machine failure loses writes made after the last 1-minute snapshot. boat runs only in Germany, Finland and France.
| Scenario | boat | AWS Lambda MicroVMs |
|---|---|---|
| One coding agent, workdays | None for this scenario | None for this scenario |
| One agent that never stops | None for this scenario |
|
| 50 agents in parallel | None for this scenario |
|
| Sandboxes for your users | None for this scenario |
|
| 1,000 short jobs at once |
|
|
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Which one should you use?
Use AWS Lambda MicroVMs when
your sandboxes must stay inside your AWS account and VPC, run outside the EU, need HIPAA eligibility, or are short sessions that sleep between requests and finish within 8 hours.
- 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 stops at 8 hours. On Lambda MicroVMs your code saves its work elsewhere and starts a fresh MicroVM each time.
- The disk stays, with snapshots and fork. When the lifetime ends, files that are not on a mounted file system end with the MicroVM. You can mount S3 Files from the MicroVM to keep files, but the machine itself still ends at 8 hours. 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 launcher yourself. 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 four of the five scenarios on this page boat costs less per month. For one coding agent on workdays, boat costs $20 and Lambda MicroVMs $80. For 1,000 short jobs at once, Lambda MicroVMs costs less ($2,508 against $8,800), but neither fits cleanly: boat's top plan charges for starts above 90 a minute and refuses them above 270, and Lambda's memory quota for 1,000 MicroVMs at once is not confirmed. Lambda MicroVMs fits only the workday scenario; its 8-hour lifetime, Docker and account quotas rule out the other four. A session that sits suspended most of the time can cost less on Lambda MicroVMs, because a suspended MicroVM pays no compute.
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. You can keep files past that on a mounted S3 Files file system. boat has no session cap once you turn auto-stop off on a paid plan; auto-stop defaults to 1 hour.
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?
Not with SSH. You reach a MicroVM through one HTTPS endpoint with a JWE token on every request. For a shell, AWS gives a shell access connector and a separate shell auth token. boat gives you SSH, HTTPS URLs on up to 50 ports and raw ports (over IPv6 on sandboxes without their own IPv4).
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 seven coding agents and a desktop included, and an optional paid credentials proxy.
Is boat SOC 2 compliant?
SOC 2 is in progress, and no HIPAA BAA is documented. 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