AWS AgentCore vs Modal VM Sandboxes

AgentCore is the part of AWS that hosts agents and gives them a managed code interpreter and browser, inside your own AWS account. Modal VM Sandboxes are Linux VMs with their own kernel, Docker and systemd that you start from code. Each one runs up to 24 hours, and filesystem snapshots carry its work to the next one.

The companies and products

AWS AgentCore

Amazon Bedrock AgentCore is a set of AWS services to deploy and run AI agents: a Runtime that hosts your agent code, plus built-in Code Interpreter and Browser tools.

AgentCore is not a sandbox product first. It is a hyperscaler's agent platform: you push a container image or code, and each Runtime session gets its own Firecracker microVM. You reach a session through AgentCore APIs, an interactive shell API and authenticated HTTPS session endpoints. Around it sit managed tools (Code Interpreter, Browser) and services for memory, identity, gateways and evaluations. An Instances compute type runs longer sessions on EC2 in your own account. It is built for teams who already build on AWS and want agents to stay inside their account, IAM and VPC.

Modal VM Sandboxes

Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.

You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026. It suits teams that want many agent machines next to Modal's inference and training.

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. “11th cheapest of 336” means 10 of the other 335 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 workloadAWS AgentCore: price rankModal VM Sandboxes: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Modal VM Sandboxes fit this as a full match: Docker in a VM, a filesystem snapshot between sessions, and a desktop from Modal's VNC example. An AgentCore microVM gets 2 vCPU and 8 hours. boat saves the disk every minute with no code.
132nd of 365, with limits
$888 a month
27th cheapest of 365
$633 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An agent that lives on one machine all month outlasts both session caps: AgentCore needs its Instances type on EC2 (up to 14 days), and Modal needs a snapshot and a new sandbox each day. On boat, turn auto-stop off (default 1 hour) on a paid plan.
109th of 361, with limits
$1,300 a month
Not ranked: misses a requirement6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
AgentCore Code Interpreter is built for short code runs and bills only for CPU actually used, which makes it a strong fit here.
11th cheapest of 336
$114 a month
Not ranked: misses a requirement189th of 336, with limits
$2,000 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
205th of 349, with limits
$506 a month
Not ranked: misses a requirement3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
Large bursts of short rollouts suit both platforms better than long sessions. boat's per-plan start limits charge for or refuse starts in big bursts.
129th of 349, with limits
$8,075 a month
163rd of 349, with limits
$11,982 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
46th cheapest of 359
$650 a month
Not ranked: misses a requirement10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
Modal runs Docker builds in a VM; AgentCore does not document Docker inside a session. boat runs Docker and exposes /dev/kvm on every plan.
51st cheapest of 374
$399 a month
170th of 374, with limits
$655 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
242nd of 371, with limits
$52 a month
Not ranked: misses a requirement19th cheapest of 371
$26 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
AgentCore Browser drives a managed Chromium. Modal has no built-in desktop, but its runnable example installs Xvfb, x11vnc, noVNC and Chromium. boat streams a built-in 60fps desktop.
146th of 367, with limits
$202 a month
Not ranked: misses a requirement7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
AgentCore Browser is a managed Chromium with live view and session replay. On Modal you install Chromium in the image, as its VNC example does. boat runs Chromium on a full machine with a desktop.
4th cheapest of 356
$144 a month
Not ranked: misses a requirement7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
32nd cheapest of 343
$287 a month
Not ranked: misses a requirement6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
164th of 327, with limits
$5,458 a month
Not ranked: misses a requirement73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
Modal VM Sandboxes are a full match here, and AgentCore is a compromise. boat ranks higher in the default view at a lower monthly bill.
108th of 351, with limits
$294 a month
27th cheapest of 351
$464 a month
3rd cheapest of 351
$200 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 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 requirementNot ranked: misses a requirement

Key features

FeatureAWS AgentCoreModal VM Sandboxesboat
What it isAn AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser toolsSandboxes inside Modal's serverless AI cloud, run as VMs with runtime="vm"A sandbox platform: each agent gets its own full Linux machine
IsolationFirecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environmentVM with its own Linux kernel on Cloud HypervisorFull VM with its own kernel on a physical host dedicated to boat (AMD Ryzen 7 9700X or Ryzen 9 9950X); vCPUs are shared
Biggest machine2 vCPU / 8 GB per microVM session, not adjustable; on Instances, the EC2 type you pick sets the sizeSized by the CPU and memory you request; fixed 512 GiB root filesystemUp to 16 vCPU / 32 GB on the $100 plan and above; 8 vCPU / 16 GB on the $20 plan
CPU benchmark (V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026)Not in the benchmarkVM runtime 15.48 runs/s, gVisor 12.60, both rank 7 of 15 (shared)28.06 runs/s, rank 2 of 15 (shared), on an AMD Ryzen 9 9950X host
Longest session8 hours per microVM lifecycle, 15 idle minutes by default; up to 14 days on Instances24 hours (default 5 minutes); continue in a new sandbox from a filesystem snapshotAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no cap
What survives a stopMounts under /mnt only: a 1 GB per-session storage mount (preview), your own EFS or S3 Files in a VPC, or EBS volumes on InstancesFilesystem snapshots (kept 30 days by default, or with no expiry) that boot a new sandbox, or files in a Volume; your code takes the snapshotThe disk, saved every minute and at each stop with no code; memory and running programs are not saved; kept at least 14 days
Snapshots and forkNo snapshot or fork of a session; on Instances you can seed new EBS volumes from your own EBS snapshotsFilesystem snapshots boot any number of new sandboxes; memory snapshots in alphaAutomatic snapshot every minute; fork any sandbox from its latest snapshot
Docker, systemd and /dev/kvmRoot in the microVM; Docker and /dev/kvm not documentedDocker and systemd (you start dockerd yourself); nested virtualization on Enterprise only, as an experimental optionRoot, Docker, systemd and /dev/kvm on every plan
Inbound accessAuthenticated HTTPS session endpoints for 1 to 5 ports on microVM sessions (IAM or OAuth on every request); interactive shell API; no SSHEncrypted and raw TCP tunnels, connect tokens, inbound IP allowlistHTTPS URLs on up to 50 ports, token-gated by default; SSH; raw ports (IPv6 only on sandboxes with no IPv4 of their own)
Outbound network rulesVPC mode with security groups, PrivateLink and a NAT gateway for a fixed IPBlock all, IP-range allowlist, domain allowlist (beta)Open internet, no provider-side allowlist
Browser and desktopManaged Chromium with live view, recording and replay; no desktop beyond the browser windowNot built in; Modal's runnable example installs Xvfb, x11vnc, noVNC, Chromium and a Browser Use agentBuilt-in Linux desktop and Chrome streamed at 1920x1080, 60fps, with computer-use tools
Coding agents and API keysManaged harness on Strands Agents; AgentCore Identity hands keys to your agent codeYou install the harness in the image (examples for the Claude Agent SDK and OpenCode); a credential-injecting Sidecar proxy from an official example (experimental)Seven harnesses installed; optional paid credentials proxy keeps real keys of supported model providers out
GPUsNVIDIA G-series and Inferentia2 on the Instances typeNone on the VM runtime; GPU sandboxes use gVisorNo GPU on any size
Regions21 commercial AWS regions plus GovCloud (Instances in 9)US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75xGermany, Finland and France; no US or Asia region, and you cannot pick one
Every feature Battleships tracks (43)
FeatureAWS AgentCoreModal VM Sandboxesboat
Full VM (own kernel)YesYesYes
Docker insideNot publishedYesYes
Nested virtualizationNo documented wayYesYes
RootYesYesYes
SystemdNo documented wayYesYes
Desktop GUINo documented wayWith your own setupYes
BrowserYesWith your own setupYes
Computer-use APIYesWith your own setupYes
SSHNo documented wayWith your own setupYes
Persistent diskYesWith your own setupYes
Pause/resumeNo documented wayNo documented wayYes
Automatic snapshotsNo documented wayNo documented wayYes
Fork/cloneNo documented wayYesYes
Live fork (no pause)No documented wayNot publishedYes
Memory forkNo documented wayYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsNo documented wayYesYes
Idle auto-stopYesYesNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayYesYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyNo documented wayWith your own setupYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsNo documented wayWith your own setupYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesNo documented wayNo documented way
GPUYesNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64YesNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsWith your own setupNot publishedYes
Usage per sandbox (API)No documented wayNot publishedYes
Audit logsYesYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

AWS AgentCoreNot measured
Modal VM Sandboxes15.48 runs/s
boat28.06 runs/s

In StarSling's run of 3 October 2026 (run 37073680030), on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, boat did 28.06 runs/s, second of 15. Modal's VM runtime did 15.48 and its gVisor runtime 12.60, both rank 7 (shared). StarSling ran Modal with cpu=4, and the sandbox saw 4 CPUs (PR #121); sized that way, Modal bills 4 cores, $0.76/h. 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. Providers ran on different hardware in different regions. AgentCore is not in the public benchmarks we use, and its microVM sessions stop at 2 vCPU.

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. Modal VM Sandboxes measured on: VM Sandbox, request = size. 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 AgentCore 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.

ScenarioAWS AgentCore, a monthModal VM Sandboxes, a monthboat, 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
$26 · Pay-as-you-go (Instances) · with limits$0 · Starter$20 · $20/mo
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$107 · Pay-as-you-go (Instances) · with limits$109 · Starter · with limits$26 · $20/mo
50 agents in parallel
50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside
$1,286 · Pay-as-you-go (Instances) · with limits$1,480 · Starter$317 · $20/mo × 3 seats
Sandboxes for your users
2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once
$423 · Pay-as-you-go · with limits$579 · Team$200 · $100/mo × 2 seats
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$1,615 · Pay-as-you-go (Instances)$1,911 · Team · with limits$8,800 · $2000/mo · with limits

AWS AgentCore: No monthly fee. Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and for peak memory. The 4 vCPU shape in these scenarios is the Instances type: the EC2 on-demand price plus a 12% management fee. EBS storage (billed also while a session is stopped) and data transfer are billed on top, and the scenario prices leave EBS out.

Modal VM Sandboxes: Modal prices CPU per physical core, and one core equals two vCPUs. A 4 vCPU / 8 GiB sandbox is 2 cores + 8 GiB: $0.476 an hour when the request equals the size. Modal bills per second for the larger of the request and the use, until the sandbox ends. Starter costs $0 with $30 of credit a month; Team costs $250 a month with $100 of credit. Pinning a region costs 1.15x to 1.75x.

Limits in those scenarios

AgentCore microVM sessions stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU scenarios use the Instances type, and files outside /mnt mounts reset on a stop. A Modal VM runs 24 hours at most; the 24/7 scenario needs a snapshot and a new sandbox each day, so it does not fit Modal as-is. Modal's scenario bills assume a minimal CPU request that bursts above it, and that extra CPU is not guaranteed. boat's limits: plans cost $20, $100, $500 or $2,000 a month, and the plan price comes back as VM time for that month only. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. boat keeps a stopped disk for at least 14 days. If a machine fails, you lose what was written after the last good snapshot. For 1,000 short jobs at once, AgentCore fits; boat's $2,000 plan charges for starts above 90 a minute and refuses them above 270, and Modal's small tier shares its vCPUs.

ScenarioAWS AgentCoreModal VM Sandboxesboat
One coding agent, workdays
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
None for this scenarioNone for this scenario
One agent that never stops
  • Pay-as-you-go (Instances): sessions capped at 336 h
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
  • Starter: sessions capped at 24 h
None for this scenario
50 agents in parallel
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
None for this scenarioNone for this scenario
Sandboxes for your users
  • different kind of product: code interpreter
None for this scenarioNone for this scenario
1,000 short jobs at once
  • disk beyond 0 GiB: price unknown
  • shared vCPUs on this tier (Modal (VM Sandboxes) sells dedicated cores separately as “VM Sandbox, request = size”): heavy, sustained CPU use can be slowed by other tenants
  • 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

Which one should you use?

Use AWS AgentCore when

your agents must stay inside your AWS account and VPC, need a GPU, or are short code and browser tasks that fit the managed tools.

  • It lives inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC, security groups and PrivateLink, in 21 commercial regions.
  • Managed tools that bill only for use. For short code runs and browser tasks, Code Interpreter and Browser charge for CPU actually used and peak memory, with live view and replay.
  • GPUs and two-week sessions on Instances. Agents that need a GPU or a session of up to 14 days can run on EC2 in your own account.

Use Modal VM Sandboxes when

you need Docker in a VM for jobs that finish within a day, run huge bursts of short sandboxes, need memory snapshots or regions outside Europe, or already run your models on Modal.

  • A VM with Docker and snapshots. Each sandbox has its own Linux kernel, so Docker and systemd work, and filesystem snapshots carry work to the next sandbox.
  • Very large bursts of short jobs. Modal runs 5,000 containers at once on Team, and boots many sandboxes from one snapshot.
  • One platform with inference and training. Teams that already serve or train models on Modal can put agent sandboxes on the same account and bill.

Where boat fits

Look at boat if your agents work on one machine for hours or days and come back to the same state. AgentCore keeps only /mnt mounts, and Modal carries state through snapshots that your code takes. boat saves the disk every minute with no code. Auto-stop defaults to 1 hour; turn it off on a paid plan to remove the session cap.

The disk is saved with no code

AgentCore microVMs stop after 8 hours and keep only paths under /mnt. A Modal VM ends within 24 hours, and you call snapshot_filesystem() or use a Volume to keep its files. boat saves the disk every minute and at each stop. A boat resume is like a reboot: memory and running programs are not kept.

Docker and /dev/kvm on every plan

AgentCore does not document Docker or /dev/kvm in a session, and Modal offers nested virtualization only on Enterprise, as an experimental option. In StarSling's run of 3 October 2026, boat did 28.06 runs/s and Modal's VM runtime 15.48 on the V8 Web Tooling Benchmark. Providers ran on different hardware in different regions.

Desktop, ports and agents installed

AgentCore session endpoints need an AWS signature or an OAuth token, and on Modal you build a desktop from its VNC example. boat ships a 60fps desktop, HTTPS on up to 50 ports and seven coding-agent harnesses.

Use boat when your agents work on one machine for hours or days: Docker, /dev/kvm and a built-in desktop, with the disk saved every minute and URLs you can share. Compare it one to one: boat vs AWS AgentCore and boat vs Modal VM Sandboxes.

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

Questions people ask

Is AWS AgentCore cheaper than Modal VM Sandboxes?

It depends on the scenario. For one agent on workdays, Modal costs $0 inside Starter's $30 monthly credit and AgentCore $26. One agent 24/7 is $107 on AgentCore and $109 on Modal, and neither fits as listed. 50 parallel agents cost $1,286 on AgentCore (no fit: files reset outside /mnt) and $1,480 on Modal. On boat these three are $20, $26 and $317. For 1,000 short jobs at once, AgentCore fits at $1,615.

Which is faster, AgentCore or Modal VM Sandboxes?

Only Modal has a measurement. In StarSling's run of 3 October 2026, its VM runtime did 15.48 runs/s and its gVisor runtime 12.60 on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB. AgentCore was not part of that run. boat did 28.06 runs/s in the same run, on an AMD Ryzen 9 9950X host.

Can AgentCore or Modal run Docker?

Modal VM Sandboxes run Docker and systemd in a VM; you start dockerd yourself. AgentCore runs your container image as root in a microVM, but its docs do not say Docker works inside a session. boat runs Docker in every sandbox.

How long can a session run on each?

An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default; the Instances type runs up to 14 days on EC2. A Modal VM Sandbox lasts 5 minutes by default and 24 hours at most, and a filesystem snapshot carries its files to a new one. On boat, auto-stop defaults to 1 hour; turn it off on a paid plan and there is no cap.

Do files survive when a session ends?

On AgentCore, only paths under /mnt: a 1 GB storage mount in preview, your own EFS or S3 Files, or EBS volumes on Instances. On Modal, files you save with a filesystem snapshot (kept 30 days by default, or with no expiry) or in a Volume. boat saves the disk every minute and at each stop with no code; memory and running programs are not saved.

Is boat SOC 2 compliant?

SOC 2 is in progress. Modal has SOC 2 on every plan, and AgentCore is listed as a HIPAA eligible AWS service. Live status for boat is at status.ascii.dev and our data retention policy is at docs.boat.dev/data-retention.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons