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.

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 workloadboat: price rankAWS 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 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
IsolationFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are sharedFirecracker microVM per function environment or MicroVM
How long one machine livesNo cap once you turn auto-stop off (default 1 hour), on paid plans15 minutes per function call (90 minutes for async calls on Managed Instances; durable functions can checkpoint across calls for up to a year); MicroVMs up to 8 hours, running and suspended time together
Biggest machineUp to 16 vCPU / 32 GB with 251 GB of disk, on the $100 plan and aboveFunctions up to 10,240 MB with CPU in proportion; MicroVMs up to 8 GB / 4 vCPU baseline with 32 GB of disk, bursting to 32 GB / 16 vCPU
CPU architecturex86_64 onlyx86_64 or Arm64 (Graviton) for functions and MicroVMs
Root, Docker and systemdRoot, Docker and systemd inside every sandbox, ready at startFunctions run as a least-privileged user on a read-only file system. MicroVMs can be granted all Linux capabilities; AWS does not document Docker inside, but users report running it that way
Nested virtualizationYes, /dev/kvm for Android emulators and VMsNot documented for functions or MicroVMs; functions run unprivileged
DiskSaved every minute while running and at each stop; a stopped sandbox keeps its disk for at least 14 days, longer with a saved snapshot. Writes after the last snapshot can be lost if a machine failsFunctions get a temporary /tmp; you set up lasting files: attach the function to a VPC and mount EFS or S3 Files. A MicroVM image bakes in your installs, and a MicroVM keeps its disk while suspended, until its lifespan ends
Pause and resumeDisk is saved every minute and on stop; resume boots the machine again, like a reboot, with a new IPMicroVMs suspend with memory and disk, so processes keep running after resume
Wake on requestNo; a stopped sandbox is started by APIYes; functions start on each request, and a suspended MicroVM resumes when traffic reaches its endpoint
ForkFork a running sandbox with its disk, from the last 1-minute snapshotNo fork of a running machine; many MicroVMs can start from one image snapshot
Inbound accessHTTPS URLs for up to 50 ports, token-gated by default; SSH; raw ports (IPv6 only on sandboxes with no IPv4 of their own)Function URLs or API Gateway for functions; one token-protected HTTPS endpoint per MicroVM, any port by header, plus a shell token; no raw TCP
Network controlsOpen internet, no provider-side allowlistRoute traffic through your VPC with security groups and network ACLs
Coding agentsSeven harnesses installed (Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe), with a prompt, steer and events APINone built in; you package your own agent in the image
Keeping API keys out of the sandboxOptional AI credentials proxy ($1 a day plus $1 per 1,000 requests): real keys of supported AI providers stay out; other secrets and environment variables still enterSecrets read into the function from Secrets Manager, Parameter Store or environment variables
ComplianceSOC 2 in progress; no HIPAA BAA documentedIn scope of AWS SOC reports and HIPAA eligible
RegionsGermany, Finland and France; no US or Asia region, and you cannot pick oneMost commercial AWS regions across the Americas, Europe, Asia Pacific, the Middle East and Africa; MicroVMs in 10 regions across the US, Europe and Asia Pacific
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
Full VM (own kernel)YesYes
Docker insideYesNo documented way
Nested virtualizationYesNo documented way
RootYesNo documented way
SystemdYesNo documented way
Desktop GUIYesNo documented way
BrowserYesNo documented way
Computer-use APIYesNo documented way
SSHYesNo documented way
Persistent diskYesYes
Pause/resumeYesNo documented way
Automatic snapshotsYesNo documented way
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 wayYes
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 wayYes
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 LambdaNot measured

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.

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

ScenarioboatAWS Lambda
One coding agent, workdaysNone for this scenario
  • Pay-as-you-go: sessions capped at 0.25 h
  • files survive a stop only in an EFS or S3 Files mount (VPC-attached function): packages installed elsewhere reset
One agent that never stopsNone for this scenario
  • Pay-as-you-go: sessions capped at 0.25 h
  • files survive a stop only in an EFS or S3 Files mount (VPC-attached function): packages installed elsewhere reset
50 agents in parallelNone for this scenario
  • Pay-as-you-go: sessions capped at 0.25 h
  • missing Docker inside
  • files survive a stop only in an EFS or S3 Files mount (VPC-attached function): packages installed elsewhere reset
Sandboxes for your usersNone for this scenarioNone for this scenario
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
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

More comparisons