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.

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 workloadboat: price rankAWS 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 requirementNot 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 requirementNot ranked: misses a requirement

Key features

FeatureboatAWS Lambda MicroVMs
What it isA sandbox platform: each agent gets its own full Linux machineA serverless AWS compute service: microVMs restored from a snapshot of your Dockerfile build
IsolationFull VM with its own kernel (x86_64), on hosts dedicated to boat; vCPUs are sharedFirecracker microVM with its own kernel, Amazon Linux 2023
Machine sizeUp to 16 vCPU / 32 GB on the $100 plan and above; x86_64 onlyBaseline up to 4 vCPU / 8 GB, with automatic burst up to 4x (16 vCPU / 32 GB); x86_64 or Arm64
Disk51 GB on the default size, 51 to 251 GB by size; more disk means a bigger size8 GB at the default baseline, 32 GB at the largest; you can mount S3 Files for more
Session lengthNo cap once you turn auto-stop off on a paid plan; auto-stop defaults to 1 hour8 hours at most, running and suspended time together, not adjustable
Pause and resumeDisk 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 rebootSuspend checkpoints memory and disk; resume keeps processes running and can happen on the next request; state ends with the 8-hour lifetime
Snapshots and forkAutomatic disk snapshots every minute; fork a running sandbox from its last 1-minute snapshotSuspend checkpoints the same MicroVM; no fork operation; a new MicroVM starts from an image built from a Dockerfile
Docker, systemd and /dev/kvmRoot, Docker, systemd and nested virtualization for Android emulators and VMsYour app runs as one container in the MicroVM; extra capabilities allow mounts, network namespaces and eBPF; Docker and /dev/kvm are not documented
Inbound accessHTTPS 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 controlsOpen internet; no provider-side egress allowlistVPC egress connector with security groups and network ACLs; PrivateLink for private access
Desktop and browserBuilt-in Linux desktop and Chrome streamed at 1920x1080, 60 fps, with computer-use toolsNo 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 agentsClaude Code, Codex and five more preinstalled, with a prompt, steer and events APINone 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 sandboxOptional 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 sandboxCode in the MicroVM reads keys from Secrets Manager through its IAM role
RegionsGermany, Finland and France; you cannot pick a region; no US or Asia region10 AWS regions across the US, EU and Asia Pacific
ComplianceSOC 2 in progress; no HIPAA BAA documentedAWS Lambda is listed as HIPAA eligible, inside AWS's compliance program
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatAWS Lambda MicroVMs
Full VM (own kernel)YesYes
Docker insideYesNo documented way
Nested virtualizationYesNo documented way
RootYesYes
SystemdYesNo documented way
Desktop GUIYesWith your own setup
BrowserYesWith your own setup
Computer-use APIYesNo documented way
SSHYesNo documented way
Persistent diskYesYes
Pause/resumeYesYes
Automatic snapshotsYesYes
Fork/cloneYesNo documented way
Live fork (no pause)YesNo documented way
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesYes
≥24 h sessionsYesNo documented way
Idle auto-stopNo documented wayYes
Wake on requestNo documented wayYes
HTTPS preview URLsYesYes
Raw TCP inboundYesNo documented way
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesNo documented way
Secret proxy for any APIYesNo documented way
Preinstalled agentsYesNo documented way
Agent harness APIYesNo documented way
MCP serverNo documented wayNo documented way
GPUNo documented wayNo documented way
WindowsNo documented wayNo documented way
Arm64No documented wayYes
Self-hostingNo documented wayNo documented way
BYOCNo documented wayNo documented way
Open sourceNo documented wayNo documented way
Scoped API keysYesNot published
Spend limitsYesNot published
Usage per sandbox (API)YesYes
Audit logsNo documented wayNot published
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayYes
EU data residencyNo documented wayYes
Zero data retentionYesNot published

Performance

boat28.06 runs/s
AWS Lambda MicroVMsNot measured

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.

Scenarioboat, a monthAWS 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.

ScenarioboatAWS Lambda MicroVMs
One coding agent, workdaysNone for this scenarioNone for this scenario
One agent that never stopsNone for this scenario
  • Pay-as-you-go: sessions capped at 8 h
50 agents in parallelNone for this scenario
  • missing Docker inside
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
Sandboxes for your usersNone for this scenario
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
1,000 short jobs at once
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
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

More comparisons