Modal vs AWS AgentCore
Modal is a serverless AI cloud whose sandboxes run next to its GPUs, for up to 24 hours. AWS AgentCore is an agent platform inside your AWS account, with 2 vCPU microVM sessions of up to 8 hours and managed code and browser tools.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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 that you reach through AgentCore APIs. Around it sit managed tools (Code Interpreter, Browser) and services for memory, identity, gateways and evaluations, and 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.
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | AWS AgentCore: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 100th of 367, with limits $888 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent outlasts Modal's 24-hour sandboxes and AgentCore's 8-hour microVM sessions, while a bochka sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 64th of 366, with limits $1,300 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit short code runs well: AgentCore Code Interpreter bills only for CPU actually used, and Modal starts many sandboxes fast. | 19th cheapest of 345 $181 a month | 7th cheapest of 345 $114 a month | 186th of 345, 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 Modal fits sandboxes for your users fully, while AgentCore Code Interpreter is a different kind of product; bochka gives each user a sandbox that keeps its disk and costs nothing when stopped. | 11th cheapest of 361 $811 a month | 210th of 361, with limits $506 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month RL rollouts launch huge bursts of short sandboxes, which Modal is built for, while AgentCore's 2 vCPU sessions are only a compromise here. | 5th cheapest of 360 $19,038 a month | 125th of 360, with limits $8,075 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 59th cheapest of 364 $1,244 a month | 33rd cheapest of 364 $650 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Docker images need Modal's VM runtime and are not documented on AgentCore; every bochka sandbox runs Docker and exposes /dev/kvm. | 126th cheapest of 377 $1,793 a month | 52nd cheapest of 377 $399 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 138th of 368, with limits $23 a month | 228th of 368, with limits $52 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither ships a full desktop: Modal shows how to set up VNC yourself and AgentCore drives a browser only, while bochka streams a Linux desktop at 60fps. | 98th of 369, with limits $183 a month | 104th of 369, with limits $202 a month | 6th cheapest of 369 $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, which Modal does not offer; bochka runs Chromium on a full machine you control. | 177th of 367, with limits $136 a month | 4th cheapest of 367 $144 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 267th of 346, with limits $394 a month | 27th cheapest of 346 $287 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 223rd of 338, with limits $8,795 a month | 165th of 338, with limits $5,458 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | Can't run it | 62nd of 360, with limits $294 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Modal has GPUs from T4 to B300 right in its sandboxes; AgentCore offers GPUs only on the Instances type and bochka has none. | 19th cheapest of 98 $1,187 a month | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Modal | AWS AgentCore | bochka |
|---|---|---|---|
| What it is | A serverless AI cloud: inference, training, batch jobs and sandboxes driven from code | An AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser tools | A sandbox platform: each agent gets its own full Linux machine |
| Isolation | gVisor by default; VM runtime with its own kernel available | Firecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environment | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Set CPU and memory per sandbox; Modal does not publish the maximum | 2 vCPU / 8 GB per microVM session, not adjustable; bigger EC2 types only on Instances | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Longest session | 24 hours (default 5 minutes) | 8 hours per lifecycle on microVMs, 15 idle minutes by default; up to 14 days on Instances | No cap on paid plans; you set the time to live |
| What survives a stop | No paused state; only files in Volumes are kept | One storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Snapshots and fork | Filesystem snapshots to boot new sandboxes; memory snapshots in alpha | No user snapshots or fork of a session | Automatic snapshots every minute; fork a running sandbox with its disk |
| Docker and /dev/kvm | Docker only with the VM runtime; nested virtualization on Team and Enterprise, on request | Root in the microVM; Docker and /dev/kvm not documented | Docker, systemd and /dev/kvm in every sandbox |
| Custom images | Build images in code or pull any linux/amd64 registry image | Your own container image: arm64 on microVMs, x86_64 or arm64 on Instances | Named snapshots used as templates; no Dockerfile builds |
| Browser and desktop | Not offered; an example shows how to set up VNC yourself | Managed Chromium with live view, session recording and replay; no full desktop | Full Linux desktop streamed at 60fps, with Chromium and a computer-use API |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | No open ports or SSH; reached only through AgentCore APIs with IAM or JWT | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; SSH |
| Network controls | Block all outbound, IP-range allowlist, domain allowlist (beta) | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet, no provider-side allowlist |
| Coding agents and API keys | Examples only; secrets are environment variables or your own proxy in a sidecar | AWS's managed harness built on Strands Agents; AgentCore Identity hands keys to your agent code | Claude Code, Codex and others preinstalled, driven from outside by API; a credentials proxy keeps real keys out |
| GPUs | T4 to B300 in the sandbox; 10 at once on Starter, 50 on Team | NVIDIA G-series and Inferentia2 on the Instances type only | None |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | 17 commercial AWS regions plus GovCloud | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | AWS AgentCore | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Not published | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the same hpc-sandbox-benchmarks run on 29 September 2026, at 4 vCPU / 8 GB, bochka finished 26.69 Node.js build-and-test runs per second and Modal's default sandbox 12.79, so bochka did about twice the work. AgentCore has no comparable measurement: it was not in that run, and its microVM sessions stop at 2 vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. AWS AgentCore has no published run in this suite yet, so there is no like-for-like number to compare.
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.
| Scenario | Modal, a month | AWS AgentCore, a month | bochka, 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 | $15 · Starter · with limits | $26 · Pay-as-you-go (Instances) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $107 · Pay-as-you-go (Instances) · 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 | $2,229 · Starter · with limits | $1,286 · Pay-as-you-go (Instances) · with limits | $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 | $792 · Team | $423 · Pay-as-you-go · with limits | $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 | $3,193 · Team · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of the CPU and memory you request or what you use, and an idle sandbox pays until it ends. Starter is free with $30 of monthly credit; Team is $250 a month with $100 of credit.
AWS AgentCore: AgentCore 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% fee, with storage and data transfer on top.
AWS AgentCore: bochka charges one hourly rate per machine size, by the second, only while a sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit.
Limits in those scenarios
On Modal a sandbox lives at most 24 hours on Starter and only Volumes keep files, and the 50-agent fleet needs Docker, which the default sandbox lacks. On AgentCore a 4 vCPU agent needs the Instances type, which caps sessions at 14 days, and files outside the storage mount or an EBS volume reset when a session stops, so installed packages have to be set up again. Sandboxes for your users do not fit AgentCore because Code Interpreter is a different kind of product, while 1,000 short jobs at once fit AgentCore but are slowed on Modal's Team tier by shared vCPUs.
| Scenario | Modal | AWS AgentCore | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, run as huge bursts of short jobs, or should sit next to models you already run on Modal.
- GPUs in the sandbox. If your agent trains or runs models, Modal rents GPUs from T4 to B300 on the same platform as its sandboxes.
- Huge bursts of short sandboxes. For RL rollouts and big batches, Modal runs up to 5,000 containers at once on its Team plan.
- Images and 24-hour sessions. Teams that want any amd64 image built in code get sandboxes that last up to 24 hours, three times AgentCore's microVM limit.
Use AWS AgentCore when
your agents must stay inside your AWS account and VPC, or are short code and browser tasks that fit its managed tools.
- It stays inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC, security groups and PrivateLink, in 17 commercial regions.
- Managed browser and code tools. For short code runs and browser tasks, Code Interpreter and Browser bill only for CPU used, with live view and replay.
- Two-week sessions on Instances. Agents that need a session of up to 14 days or a GPU can run on EC2 in your account, with Savings Plans applying.
Where bochka fits
Modal and AgentCore both treat a sandbox as something short that ends and forgets. If your agents work for hours or days, installing packages, running Docker, building and testing, look at bochka: each one gets a full VM that keeps its disk, has no session cap on paid plans and serves a URL you can open.
The work is still there tomorrow
Modal sandboxes end within 24 hours and keep only Volume files; AgentCore microVMs stop after 8 hours and keep 1 GB under /mnt. Either way the agent reinstalls its setup, unless you run EC2 Instances in your AWS account.
Docker, /dev/kvm and room to build
Modal's default sandbox has no Docker, so you switch to the VM runtime and ask for nested virtualization. AgentCore does not document Docker or /dev/kvm and caps microVMs at 2 vCPU. bochka has all three, up to 16 vCPU.
See what the agent built
AgentCore sessions have no open ports, so you proxy a dev server through your own code. Modal has tunnels but no desktop. bochka gives HTTPS URLs on 50 ports and a 60fps desktop with computer use.
Use bochka when your agents work on a machine for hours or days, with Docker, a desktop, a disk that keeps everything and a URL you can open. Compare it one to one: bochka vs Modal and bochka vs AWS AgentCore.
Questions people ask
Is Modal cheaper than AWS AgentCore?
In most of our scenarios AgentCore costs less: one always-on agent is $107 against $178 on Modal, and 50 parallel agents $1,286 against $2,229. Modal is cheaper for one agent on workdays ($15 against $26). On bochka those three cost $26, $317 and $20.
Which is faster, Modal or AWS AgentCore?
We can't say: AgentCore was not in the hpc-sandbox-benchmarks run. Modal's default sandbox scored 12.79 runs per second at 4 vCPU / 8 GB, and bochka 26.69 in the same run.
Can Modal or AWS AgentCore run Docker?
Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. AgentCore runs your container image as root in a microVM, but its docs do not say Docker works inside a session. Every bochka sandbox runs Docker and exposes /dev/kvm.
How long can a session run on Modal and AWS AgentCore?
A Modal sandbox runs up to 24 hours, with a 5-minute default. 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. bochka has no session cap on paid plans.
Which one has GPUs?
Modal has GPUs from T4 to B300 inside its sandboxes. AgentCore offers NVIDIA G-series and Inferentia2 only on the Instances type, running EC2 in your account. bochka has no GPUs.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview