Fly.io Machines vs AWS AgentCore
Fly.io Machines are microVMs for hosting your own apps in 17 regions: you build the image, and they run until you stop them. AWS AgentCore is an agent platform inside your AWS account, with short microVM sessions you reach only through AWS APIs and ready-made Code Interpreter and Browser tools.
The companies and products
Fly.io Machines
Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.
A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.
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. “92nd cheapest of 367” means 91 of the other 366 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 | Fly.io Machines: 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, while Fly's shared vCPUs throttle long builds; boat ranks 3rd with a full machine and Docker. | 92nd of 367, with limits $836 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 runs all month outlasts AgentCore's 8-hour microVM sessions and keeps only what sits on a Fly Volume; on boat it keeps its whole disk and keeps running. | 125th of 366, with limits $816 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 AWS AgentCore ranks 7th here: Code Interpreter is built for short code runs and bills only for CPU actually used. | 75th of 345, with limits $94 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 users cannot open the app their sandbox runs; Fly can host it, and boat ranks 1st with HTTPS URLs on up to 50 ports. | 69th of 361, with limits $600 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 Fly.io Machines ranks 48th against 125th for AgentCore, since Fly bills per second with no plan fee; boat ranks 34th. | 48th of 360, with limits $2,838 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 | 117th of 364, with limits $457 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 | 152nd of 377, with limits $288 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 dev box needs SSH and a disk that keeps installed packages; AgentCore has no SSH, and a Fly Machine keeps only what is on its Volume. | 118th of 368, with limits $53 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 | 95th of 369, with limits $173 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 AWS AgentCore ranks 4th: its Browser tool is a managed Chromium with live view and replay, while on Fly you package a browser into your own image. | 160th of 367, with limits $90 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 | 161st of 346, with limits $67 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 Fly.io Machines ranks 44th here, since it can spread scrapers across 17 regions and pay only for the seconds they run. | 44th of 338, with limits $1,232 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 | 118th of 360, with limits $63 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 | Can't run it | 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 | Fly.io Machines | AWS AgentCore | boat |
|---|---|---|---|
| Kind of product | App hosting platform; Machines are Firecracker microVMs that boot your own image, started through a REST API | AWS agent platform: a Firecracker microVM per Runtime session, plus managed Code Interpreter and Browser tools in containers | Agent sandbox: a full VM with its own kernel per agent, on dedicated AMD Ryzen 9 9950X hosts |
| CPU and size | Shared vCPUs guarantee 6.25% of each core plus bursts; performance vCPUs get the full core at a higher rate | 2 vCPU / 8 GB per microVM session, not adjustable; bigger EC2 types only on Instances | One CPU class with no baseline quota or burst balance, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No documented maximum; a Machine runs until you or autostop stop it | Up to 8 hours per microVM lifecycle, stopped after 15 idle minutes by default; up to 14 days on Instances | No cap on paid plans; you set the time to live |
| Files after a stop | Root file system is ephemeral; one Volume of up to 500GB per Machine, billed for its full size around the clock | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances; the rest resets | The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Pause with memory | Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move | No pause or memory snapshot for sessions | Resume reboots from disk (no memory snapshots) |
| Fork | Clone copies a Machine's config; a cloned Volume starts empty | No user snapshots or fork of a session | Fork a running sandbox, disk included |
| Docker, systemd and /dev/kvm | Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered | Root inside the microVM; arm64 container images; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every machine |
| Reaching the sandbox | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, SSH and a private network | No open ports or SSH; sessions are reached only through AgentCore APIs with IAM or JWT | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH |
| Network controls | Network policies allow chosen ports and protocols and deny the rest | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet on every plan; no provider-side allowlist |
| Browser and desktop | None built in; you add a desktop and browser to your own image | Managed Chromium with live view, session recording and replay, profiles and proxies; no full desktop | Full Linux desktop streamed at 60fps, with Chromium, computer use and browser control |
| Coding agents | None built in; you install and run agents yourself | AWS's own managed harness built on Strands Agents, or your own agent code | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs | No; Fly GPU Machines were discontinued in 2026 | NVIDIA G-series and Inferentia2 on the Instances type | No |
| Regions | 17 regions on six continents, on Fly's own servers | 17 commercial AWS regions plus GovCloud | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Fly.io Machines | AWS AgentCore | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | 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 | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | 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 | Yes | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | Yes | 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 | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | 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 | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either one: neither Fly.io Machines nor AWS AgentCore was part of the public StarSling run where boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly results would depend on whether you pick shared or performance vCPUs, and an AgentCore microVM session stops at 2 vCPU, so a like-for-like test would need the Instances type.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Fly.io Machines 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 | Fly.io Machines, 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 | $15 · Pay As You Go · 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 | $36 · Pay As You Go · 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 | $487 · Pay As You Go · 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 | $110 · Pay As You Go · with limits | $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 | $232 · Pay As You Go · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee; Volumes are billed for their full size all month. The figures here use Fly's lowest rate: shared vCPUs in 1-year reservation blocks for 40% off.
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 storage and data transfer on top.
AWS AgentCore: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Fly is a compromise in every scenario: its lowest figures need a 1-year reservation, and shared vCPUs guarantee only 6.25% of each core, so long builds get throttled. AgentCore's microVM sessions stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU scenarios use the Instances type, and files outside the storage mount reset after a stop. AgentCore is the only one of the three that fits 1,000 short jobs at once; boat queues starts above 90 per minute even on the $2000 plan.
| Scenario | Fly.io Machines | 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 Fly.io Machines when
you want cheap, long-running microVMs you build yourself, reachable on public ports in regions worldwide, and can wake on traffic.
- Host it and reach it. For agents that serve something: Fly gives each Machine public HTTPS and TCP, SSH, custom domains and a private network.
- Wake on request and memory suspend. For work that sleeps between requests: Fly Proxy wakes a Machine on traffic, and small Machines resume with memory kept.
- Runs as long as you want. For long jobs: a Fly Machine has no documented time limit, while an AgentCore microVM session stops after 8 hours.
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. For teams built on AWS: agents stay behind your own IAM, VPC, security groups and PrivateLink.
- Managed tools that bill for use. For short code runs and browser tasks: Code Interpreter and Browser charge only for CPU actually used, with live view and replay.
- GPUs and two-week sessions. For agents that need a GPU or up to 14 days: the Instances type runs them on EC2 in your account.
Where boat fits
Fly.io Machines give you a VM you must fill yourself, and AgentCore gives you short sessions you reach only through AWS APIs. If your agents install tools, build, test and run Docker for hours, boat gives each one a full machine that keeps its disk, with a desktop, coding agents and a keys proxy ready.
The whole disk stays after a stop
On Fly the root file system is ephemeral, so lasting files need a Volume billed for its full size all month. On AgentCore only a 1 GB mount in preview survives, so packages installed with apt are gone. boat keeps the whole disk.
A full machine with no session cap
Fly offers no systemd or /dev/kvm, and its shared vCPUs throttle after 6.25% of a core. AgentCore stops at 2 vCPU and 8 hours unless you run EC2 in your own account. boat has Docker, systemd and /dev/kvm, up to 16 vCPU, with no cap.
Desktop and coding agents built in
Fly has no desktop, browser or agents, so you build and maintain that image. AgentCore drives a browser, not a desktop. boat ships a 60fps desktop with computer use and coding agents you drive from outside.
Use boat when your agents do real work for hours: installs, builds, tests, Docker and emulators on a full VM whose disk survives every stop, with a desktop, coding agents and a keys proxy built in. Compare it one to one: boat vs Fly.io Machines and boat vs AWS AgentCore.
Questions people ask
Is Fly.io Machines cheaper than AWS AgentCore?
In this page's scenarios, yes: one agent all month is $36 on Fly against $107 on AgentCore, and 50 agents in parallel are $487 versus $1,286. Fly's figures assume a 1-year reservation and work that stays within a shared vCPU's 6.25% baseline. For 1,000 short jobs at once, AgentCore costs more but is the one that fits.
Which is faster, Fly.io Machines or AWS AgentCore?
Neither has a comparable measurement. On Fly it depends on whether you pick shared vCPUs, which throttle under long load, or performance vCPUs. An AgentCore microVM session stops at 2 vCPU, so bigger jobs need the Instances type on EC2.
Can Fly.io Machines or AgentCore run Docker?
On Fly you can install and run Docker inside a Machine yourself, but there is no systemd or /dev/kvm. AgentCore runs your arm64 container image as root, but its docs do not say Docker or /dev/kvm work inside a session. boat has Docker, systemd and /dev/kvm on every machine.
How long can a session run?
A Fly Machine has no documented time limit and runs until it is stopped. An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default; the Instances type allows up to 14 days. boat has no session cap on paid plans.
Do files survive a stop?
On Fly, only what is on the Machine's one Volume; the root file system is ephemeral. On AgentCore, only a storage mount under /mnt of up to 1 GB, still in preview, or EBS volumes on Instances. boat keeps the whole disk and saves it every minute.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Fly.io Machines
- boat vs AWS AgentCore
- E2B vs Fly.io Machines
- Daytona vs Fly.io Machines
- Modal vs Fly.io Machines
- Vercel Sandbox vs Fly.io Machines
- Cloudflare Sandbox vs Fly.io Machines
- Blaxel vs Fly.io Machines
- Runloop vs Fly.io Machines
- Tensorlake vs Fly.io Machines
- Morph Cloud vs Fly.io Machines
- CodeSandbox SDK vs Fly.io Machines