boat vs AWS Lambda
Lambda runs your code in short bursts. A function call stops after 15 minutes, and a Lambda MicroVM ends after 8 hours at most. Durable functions can checkpoint a workflow across many calls. boat gives each agent a whole Linux machine with Docker and a disk saved every minute, with no session cap once you turn auto-stop off.
Where boat stands out
A whole machine with no clock running out
Once you turn auto-stop off (default 1 hour) on a paid plan, a boat sandbox has no session cap, so an agent can work for days on one machine. A Lambda function stops after 15 minutes, and a Lambda MicroVM ends after 8 hours at most, counting the time it spends suspended.
Root, Docker, systemd and /dev/kvm
Every boat sandbox is a full VM with root, Docker, systemd, SSH and /dev/kvm. Lambda functions run as a least-privileged user on a read-only file system. MicroVMs run your app as one container that can be granted all Linux capabilities, with no /dev/kvm documented for either.
A disk that stays, plus agents and an optional key proxy
boat saves the disk every minute while the sandbox runs and once more at each stop. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; a saved snapshot keeps it longer. You can fork a running sandbox. Seven coding-agent harnesses come installed with a prompt, steer and events API. The optional AI credentials proxy keeps real model-provider keys outside the sandbox.
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
AWS Lambda is Amazon's serverless compute service: you hand it code or an image, and AWS runs it on demand without servers for you to manage.
Lambda started as a function service, not a sandbox. Each call runs in a Firecracker microVM for up to 15 minutes as an unprivileged user. Lambda Managed Instances allow 90 minutes for async calls, and durable functions checkpoint a multi-step workflow for up to a year. AWS has also added Lambda MicroVMs, a separate API for sandboxes, dev environments and multi-tenant CI/CD. You build an image from a Dockerfile, run one MicroVM per user or job on Arm64 or x86_64, and reach it through an HTTPS endpoint. A MicroVM can suspend with its memory and resume, for up to 8 hours in total. Lambda suits teams that run event-driven code inside AWS. It overlaps with boat where each agent or user needs its own isolated machine.
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: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent works for hours and runs docker build. A Lambda function stops at 15 minutes. A MicroVM runs for up to 8 hours and can get all Linux capabilities; AWS does not document Docker inside, but users report it works. boat runs Docker in every sandbox, with no session cap once auto-stop is off. | 5th cheapest of 365 $634 a month | 235th of 365, with limits $2,621 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 a MicroVM's 8-hour lifespan. Durable functions can keep a workflow for up to a year, but each step is a 15-minute call with no lasting disk unless you mount EFS. boat keeps one machine running with no cap once auto-stop is off. | 6th cheapest of 361 $657 a month | 301st of 361, with limits $5,527 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs are what Lambda does best: functions start on each request and bill by the millisecond, and MicroVMs suspend with their memory between calls. | 189th of 336, with limits $2,000 a month | 143rd of 336, with limits $309 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Lambda MicroVMs give each user an HTTPS endpoint that wakes a suspended machine on the next request, and end it after 8 hours at most. boat sandboxes keep their disk across stops, but you start a stopped sandbox by API. | 3rd cheapest of 349 $209 a month | 169th of 349, with limits $2,708 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Lambda can create up to 1,000 function environments every 10 seconds, which suits huge batches of short, stateless rollouts. | 39th of 349, with limits $2,000 a month | 139th of 349, with limits $8,340 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 | 138th of 359, with limits $669 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build container images need Docker, which Lambda functions do not allow. MicroVMs can run it with elevated capabilities for up to 8 hours, but no /dev/kvm is documented for Android emulators. boat has both with no time cap once auto-stop is off. | 2nd cheapest of 374 $86 a month | 293rd of 374, with limits $569 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box stays up for weeks with SSH and a disk that keeps packages. A Lambda MicroVM ends after 8 hours at most, and its shell is a token API, not sshd. boat keeps the disk across stops and gives SSH. | 19th cheapest of 371 $26 a month | 145th of 371, with limits $315 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Lambda has no managed desktop or browser; on a MicroVM you install and stream one yourself, for up to 8 hours. boat streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 7th cheapest of 367 $200 a month | 115th of 367, with limits $1,889 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 | 199th of 356, with limits $1,012 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 | 157th of 343, with limits $649 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 | 232nd of 327, with limits $9,843 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 | 74th of 351, with limits $610 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
Every feature Battleships tracks (43)
| Feature | boat | AWS Lambda |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No documented way |
| Nested virtualization | Yes | No documented way |
| Root | Yes | No documented way |
| Systemd | Yes | No documented way |
| Desktop GUI | Yes | No documented way |
| Browser | Yes | No documented way |
| Computer-use API | Yes | No documented way |
| SSH | Yes | No documented way |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | No documented way |
| Automatic snapshots | Yes | No documented way |
| 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 | Yes |
| 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 | Yes |
| 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
AWS Lambda is not in the public benchmarks we use, so we cannot say which is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in that run. 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 gives CPU in proportion to memory and does not let you pick the processor model.
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 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, 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 | $35 · Pay-as-you-go · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $118 · 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 | $1,614 · 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 | $767 · Pay-as-you-go |
| 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 | $1,662 · Pay-as-you-go |
boat: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, and unused included time does not carry over. A card is required, also for the 7-day free trial. You pay per second from the moment the machine is provisioned: a 4 vCPU / 8 GB sandbox costs $0.036 an hour, $26 for 730 hours. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. Above the included starts (12 a minute and 200 a day on the $20 plan), each extra start costs $0.03 to $0.07, and starts above 3 times the included rate per minute fail with 429.
AWS Lambda: Functions bill per millisecond for the memory you set, plus $0.20 per million requests, with a monthly free tier of 400,000 GB-seconds and 1 million requests. Lambda Managed Instances, which the scenario table uses for 4 vCPU / 8 GiB on c7g.xlarge, bill the EC2 instance price plus a 15% management fee, and an active function keeps 3 instances by default. MicroVMs, which the table does not model for these scenarios, bill per second for baseline vCPU and memory while running ($0.504 an hour for 8 GB / 4 vCPU on Arm64 in us-east-1), extra for bursts above baseline, snapshot storage while suspended, and a small fee to save or load state on each suspend, resume and launch.
Limits in those scenarios
The workday agent, the always-on agent and the agent fleet do not fit Lambda functions: a call stops after 15 minutes, and files last only on an EFS or S3 Files mount that you set up in a VPC. The fleet also needs Docker, which functions do not allow. A Lambda MicroVM lifts the cap to 8 hours, enough for one workday session but not for an agent that stays up all month. New AWS accounts start with reduced Lambda concurrency and memory quotas that grow with use. boat has its own limits. Auto-stop defaults to 1 hour, and the free trial caps it at 2 hours. A stopped sandbox keeps its disk for at least 14 days unless you save a snapshot. boat runs only in Germany, Finland and France, on x86_64, with no GPU, and you cannot boot your own image. boat's start limits are lower for bursts: at 1,000 short jobs at once, the $2,000 plan charges for starts above 90 a minute and refuses them above 270. boat never queues a refused start, so you send it again. Lambda starts them all.
| Scenario | boat | AWS Lambda |
|---|---|---|
| One coding agent, workdays | 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 | None for this scenario |
| 1,000 short jobs at once |
| None for this scenario |
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 when
your work is event-driven code or large bursts of short, stateless jobs that must stay inside your AWS account, when you need US or Asia regions, Arm64 or HIPAA, or for interactive sessions under 8 hours that should sleep with their memory between requests.
- Suspend with memory and wake on request. Interactive sessions that sit idle can suspend with memory and disk and resume when the next request arrives.
- It lives inside your AWS account. Teams already on AWS keep IAM roles, VPC egress rules and the rest of their stack in one account, in most regions worldwide.
- Huge bursts of short work. Event-driven code and large batches of short, stateless jobs scale fast and bill by the millisecond.
Use boat when
your agents do real work on one machine for hours or days: Docker, builds, tests, emulators and a browser, with a disk saved every minute, URLs you can open and agents you drive from outside.
- A whole machine with no clock running out. Agent tasks often take longer than an hour and need their state at the end. Lambda durable functions can checkpoint a multi-step workflow for up to a year, but each step still runs in a 15-minute function with no lasting disk. On a MicroVM you rebuild the state in a fresh MicroVM every 8 hours.
- Root, Docker, systemd and /dev/kvm. Coding agents reach for docker build, docker compose, apt and Android emulators all the time. On a Lambda function those fail. A MicroVM can be granted all Linux capabilities, and users report running Docker that way, but AWS documents no /dev/kvm, so Android emulators and nested VMs need another machine.
- A disk that stays, plus agents and an optional key proxy. On Lambda the disk does not outlive the machine. A MicroVM image bakes in your installs, but what an agent changes on a MicroVM is lost when it terminates, after 8 hours at most, unless you copy it out first. A function's /tmp is temporary, and functions can mount EFS or S3 Files for lasting files. Secrets are read into the machine the agent controls, where one prompt injection can leak them.
Questions people ask
Is boat cheaper than AWS Lambda?
For agents that run all month, yes in our scenario table. One 4 vCPU / 8 GB agent running 24/7 costs $26 a month on boat and $118 on Lambda Managed Instances (c7g.xlarge, EC2 price plus 15%). A Lambda function does not fit that agent because of the 15-minute cap. For 1,000 short jobs at once, Lambda costs $1,662 a month and starts them all. boat's $2,000 plan refuses starts above 270 a minute, so Lambda fits that one better.
Can an AI agent run for hours on AWS Lambda?
Not in one function call: a call stops after 15 minutes, or 90 minutes for async calls on Managed Instances. Durable functions can checkpoint a workflow across calls for up to a year. Lambda MicroVMs can run for up to 8 hours in total, including time spent suspended, and then Lambda terminates them. boat has no session cap once you turn auto-stop off (default 1 hour) on a paid plan.
What are Lambda MicroVMs?
A newer part of Lambda for sandboxes and dev environments. You build an image from a Dockerfile, run one MicroVM per user or job on ARM64 or x86_64, reach it through a token-protected HTTPS endpoint, and it can suspend with its memory and resume on the next request, for up to 8 hours.
Can I run Docker inside AWS Lambda?
Not in a function: code runs as a least-privileged user on a read-only file system, and a container image is only how you package it. A MicroVM runs your app as a container and can be granted all Linux capabilities. Users report running Docker inside it that way, within its 8-hour lifespan. boat runs Docker inside every sandbox, along with systemd and /dev/kvm.
Do files survive on AWS Lambda?
A function's /tmp is temporary and tied to one execution environment. For lasting files you attach the function to a VPC and mount EFS or S3 Files. A MicroVM starts from an image with your installs baked in, and keeps its disk across suspends until its lifespan ends, 8 hours at most. boat saves the disk every minute while the sandbox runs and at each stop, and keeps a stopped sandbox's disk for at least 14 days; a saved snapshot keeps it longer. If a boat machine fails, writes after the last snapshot are lost.
Is boat SOC 2 compliant?
SOC 2 is in progress. No HIPAA BAA and no SAML SSO are 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