Beam vs AWS AgentCore
Beam is a serverless GPU platform with quick gVisor sandboxes and a separate line of CPU VMs, all in the US. AgentCore is the part of AWS that hosts agents in short microVM sessions with a managed code interpreter and browser, inside your own AWS account.
The companies and products
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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. “8th cheapest of 345” means 7 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 | Beam: price rank | AWS AgentCore: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent on AgentCore gets 2 vCPU per microVM session and stops after 8 hours, and a Beam sandbox ends with its time to live; boat gives it a full VM with Docker and /dev/kvm whose whole disk stays. | 69th of 367, with limits $551 a month | 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 assistant that lives on its machine all month fits a Beam VM, which keeps its disk while stopped, while AgentCore needs its Instances type on EC2 in your account; boat keeps it running with no session cap. | 115th of 366, with limits $651 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 well: Beam sandboxes start in a second or two and bill per second, and AgentCore Code Interpreter bills only for CPU actually used. | 8th cheapest of 345 $117 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 AgentCore sessions have no open ports, so your users cannot open the app their sandbox runs; Beam gives each exposed port a public HTTPS URL, and boat gives token-protected URLs on up to 50 ports. | 3rd cheapest of 361 $290 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 | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 | 12th cheapest of 377 $171 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 A Beam VM keeps its 50 GiB root disk and you can SSH in, while AgentCore has no SSH and resets everything outside its storage mount after a stop. | 13th cheapest of 368 $21 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 has a full desktop: AgentCore Browser drives a managed Chromium and Beam has no browser product, while boat streams a Linux desktop at 60fps. | 111th of 369, with limits $237 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; on Beam you would set up a browser yourself. | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 a month | 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 Beam has GPU sandboxes and serverless GPUs from RTX 4090 to H100 and B200; AgentCore offers GPUs only on its Instances type, and boat is CPU only. | Cheapest of 98 $458 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 | Beam | AWS AgentCore | boat |
|---|---|---|---|
| What it is | Serverless GPU and CPU platform with sandboxes, functions, task queues and VMs | AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser tools | Sandbox platform: each agent gets its own full Linux machine |
| Isolation | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | 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 |
| Session size | Max sandbox size is not published | 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 |
| Session length | Default 10 minutes; set -1 to run until you terminate it | Up to 8 hours per lifecycle on microVMs, 15 idle minutes by default; up to 14 days on Instances | No session cap on paid plans; you set the time to live |
| Disk between runs | Save an image or use a volume; a Beam VM keeps a 50 GiB root disk while stopped | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances | Whole disk saved every minute and on stop, kept for free while stopped |
| Snapshots and fork | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | No user snapshots or fork of a session | Automatic snapshots every minute; fork a running sandbox with its disk |
| Docker, systemd and /dev/kvm | Docker in sandboxes with docker_enabled; systemd only in Beam VMs; /dev/kvm not documented | Root in an arm64 microVM; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm for Android emulators and VMs |
| Inbound access | Public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | No open ports or SSH; reached only through AgentCore APIs with IAM or JWT | HTTPS URLs on up to 50 ports, token-protected by default; raw TCP; SSH |
| Network controls | Block all outbound traffic or allow up to 10 CIDR ranges, changeable while running | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet, no provider-side allowlist |
| Browser and desktop | No desktop or browser product | Managed Chromium with live view, recording and replay, profiles and proxies; no full desktop | Linux desktop streamed at 60fps with Chromium and computer use |
| Coding agents | None preinstalled; you install and run them through process exec | AWS's managed harness built on Strands Agents, or your own agent code | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables inside the sandbox | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| GPUs | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | NVIDIA G-series and Inferentia2 on the Instances type | No, CPU only |
| Regions | US only; no other region is listed | 17 commercial AWS regions plus GovCloud | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Beam | AWS AgentCore | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | 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) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | 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 | Yes | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Beam nor AgentCore has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which is faster at CPU work. boat did 26.69 runs per second on that test at 4 vCPU / 8 GB. An AgentCore microVM session stops at 2 vCPU, so a like-for-like test would need its Instances type.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Beam and AWS AgentCore have 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 | Beam, a month | AWS AgentCore, a month | boat, 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 | $5 · Developer | $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 | $22 · Developer | $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 | $410 · Team | $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 | $191 · 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 | $259 · Team | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Beam: Beam sandboxes bill per second for each CPU core (one core is two vCPU) and each GiB of RAM you request, until you terminate them or their time to live ends. Developer has no fee; Team costs $89 a month plus usage, with no usage credit, and there are no egress fees.
AWS AgentCore: 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, with EBS storage and data transfer billed by AWS on top.
AWS AgentCore: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
AgentCore's serverless sessions stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU scenarios use its Instances type, and files outside the storage mount reset when a session stops, so it does not fit the agent scenarios. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need Team, and neither publishes a disk price the scenarios could count. For 1,000 short jobs at once, both Beam and AgentCore fit, while boat's $2000 plan queues starts above 90 per minute.
| Scenario | Beam | AWS AgentCore | boat |
|---|---|---|---|
| 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Beam when
your agents or jobs need GPUs, when you want quick per-second sandboxes and low-cost CPU VMs in the US, or when you must self-host the runtime.
- GPUs in the same platform. For agents or jobs that need a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100 and B200.
- Memory snapshots and long sandboxes. Teams that want to capture a running sandbox with its processes and restore it into new ones can, with no published lifetime cap.
- Open source and your own cloud. Its Beta9 runtime is AGPL-3.0 and free to self-host, and it can also run in your own cloud for a fee.
Use AWS AgentCore when
your agents must stay inside your AWS account and VPC, run in a region Beam does not offer, or are short code and browser tasks that fit its managed tools.
- It lives inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC, security groups and PrivateLink, in 17 commercial regions.
- A managed browser for agents. Browser-use agents get a managed Chromium with live view, session recording and replay, saved profiles and proxies.
- Tools that bill only for CPU used. For short code runs, Code Interpreter charges only for CPU actually used, so waiting on a model costs little.
Where boat fits
If what you are really running is agents that work on a machine for hours, installing packages, building with Docker and serving what they build, look at boat. Beam sandboxes are containers that end with their timer, and AgentCore sessions stop at 2 vCPU and 8 hours. boat gives each agent a full VM that keeps its disk.
A full VM with /dev/kvm, Docker and systemd
A Beam sandbox is a gVisor container without systemd, and AgentCore runs an arm64 image where Docker is not documented. Neither documents /dev/kvm, so Android emulators and nested VMs have nowhere to start; boat exposes it.
The disk stays, with no session cap
AgentCore keeps only a 1 GB mount and stops after 8 hours unless you run EC2 Instances in your account. A Beam sandbox needs a saved image or volume. boat saves the whole disk every minute and has no cap on paid plans.
Open the app, with agents and keys built in
AgentCore has no open ports, and Beam's port URLs are public with no auth. boat serves token-protected HTTPS on 50 ports plus raw TCP, ships seven coding agents and a 60fps desktop, and keeps real API keys outside in a credentials proxy.
Use boat when your agents do real work on a machine for hours: installs, builds, Docker, emulators and a browser on a full VM whose disk is still there next time, with a URL you can open. Compare it one to one: boat vs Beam and boat vs AWS AgentCore.
Questions people ask
Is Beam cheaper than AWS AgentCore?
In every scenario on this page, yes. One agent that never stops costs $22 a month on Beam against $107 on AgentCore, and 50 agents in parallel cost $410 against $1,286. boat comes in at $26 and $317 for those two.
Which is faster, Beam or AgentCore?
We cannot say: neither has a result on the StarSling hpc-sandbox-benchmarks CPU test. Beam's guide says its sandboxes cold-boot in 1 to 3 seconds. boat did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Beam or AgentCore run Docker?
Beam supports Docker inside a sandbox with docker_enabled. AgentCore runs your arm64 container image as root in a microVM, but its docs do not say Docker works inside a session. boat runs Docker, systemd and /dev/kvm in its full VM.
How long can a session run on each?
A Beam sandbox runs 10 minutes by default, or until you terminate it if you set its time to live to -1. An AgentCore microVM session lasts up to 8 hours, or up to 14 days on the Instances type. boat has no session cap on paid plans.
Do files survive when a session stops?
On Beam, a sandbox keeps files only in a saved image, memory snapshot or volume, while a Beam VM keeps its root disk. On AgentCore, only a storage mount of up to 1 GB, still in preview, or an EBS volume on Instances survives. boat keeps the whole disk and saves it every minute.
Which one has GPUs?
Both, in different ways. Beam has GPU sandboxes and serverless GPUs up to H100, H200 and B200, while AgentCore offers NVIDIA G-series and Inferentia2 only on its Instances type. boat is CPU only.
Try boat
Install the CLI, then run boat new.
7-day free trial