Sprites vs AWS AgentCore
Sprites gives each agent a persistent Linux VM with a 100 GB disk that sleeps when idle and wakes on the next request. AWS AgentCore hosts agent sessions inside your AWS account, with managed Code Interpreter and Browser tools, but a microVM session tops out at 2 vCPU and 8 hours and keeps only a small storage mount.
The companies and products
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: 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 Sprites keeps a 100 GB disk between runs, while AgentCore keeps only its storage mount and stops after 8 hours; bochka adds systemd, /dev/kvm and up to 50 public ports. | 66th of 367, with limits $546 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 always-on assistant needs a task hold renewed every hour on Sprites and the Instances type on EC2 on AgentCore; on bochka it just keeps running. | 157th of 366, with limits $1,166 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 AgentCore Code Interpreter is built for short code runs and bills only CPU actually used; Sprites also fits, since it sleeps about 30 seconds after the last command. | 93rd of 345, with limits $140 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 Sprites gives each user a persistent VM with an HTTPS URL that wakes it, while AgentCore sessions have no open ports; bochka gives each user SSH, raw TCP and up to 50 HTTPS ports. | 56th of 361, with limits $428 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 | 105th of 360, with limits $6,540 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 | 125th of 364, with limits $545 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 that builds Android apps or VM images needs /dev/kvm, which bochka exposes and neither the Sprites nor the AgentCore docs mention. | 63rd cheapest of 377 $476 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 wants SSH and a disk that keeps installed packages: Sprites keeps the disk but tunnels SSH through its CLI, AgentCore has neither, and bochka has both. | 213th of 368, with limits $27 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 Sprites nor AgentCore gives an agent a full desktop; bochka streams one at 60fps with computer use built in. | 85th of 369, with limits $136 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 replay, Sprites is headless, and bochka runs Chromium on a 60fps desktop you can watch. | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 141st of 338, with limits $4,113 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 | 210th of 360, with limits $223 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 | Sprites | AWS AgentCore | bochka |
|---|---|---|---|
| What it is | Persistent Linux computers for agents, created by API or CLI | 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 | Firecracker microVM with its 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 |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | Up to 2 vCPU / 8 GB per microVM session, not adjustable; bigger EC2 types only on Instances | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No time cap; pauses about 30 seconds after activity stops unless a task holds it awake | Up to 8 hours per microVM lifecycle, 15 idle minutes by default; up to 14 days on Instances | No cap on paid plans; runs until you stop it or its time to live ends |
| What survives a stop | The whole 100 GB disk, synced to object storage | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances | The whole disk, saved every minute and on stop |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | No user snapshots or fork of a session | Named snapshots to start new sandboxes from; fork a running sandbox with its disk |
| Docker, systemd and /dev/kvm | Root and Docker (with rough edges users report); no systemd; /dev/kvm not in the docs | Root in the microVM with arm64 container images; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Inbound access | One HTTPS URL to one HTTP port that wakes the Sprite; other ports and SSH only through the sprite proxy CLI | No open ports or SSH; reached only through AgentCore APIs with IAM or JWT | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Network controls | Optional DNS-based domain allowlist; private IPs always blocked | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet, no provider-side allowlist |
| Browser and desktop | Headless; no desktop or browser product | Managed Chromium with live view, session recording and replay, profiles and proxies; no full desktop | Full Linux desktop streamed at 60fps, with Chromium and computer use |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | AWS's own managed harness built on Strands Agents, or your own agent code | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping keys out of the sandbox | Connectors gateway holds the token for any HTTP API, with path allow and block lists | 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 a credential to another account when credits run out |
| GPUs | No | NVIDIA G-series and Inferentia2 on the Instances type | No |
| Regions | Not selectable | 17 commercial AWS regions plus GovCloud | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | AWS AgentCore | bochka |
|---|---|---|---|
| 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 | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | 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 | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | 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 | No | 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 | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Sprites or AWS AgentCore: neither is in the hpc-sandbox-benchmarks results we use. bochka did 26.69 runs per second on the Node.js build-and-test test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. A Sprite always has 8 vCPU and an AgentCore microVM stops at 2 vCPU, so a fair test would need matching shapes.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites 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 | Sprites, 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 | $23 · Pay-as-you-go | $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 | $92 · Pay-as-you-go | $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 | $1,120 · Pay-as-you-go | $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 | $314 · 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 | $1,134 · Pay-as-you-go · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time actually used at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans include fixed CPU-hour, memory-hour and storage allowances that are not credit.
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 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 microVM sessions stop at 2 vCPU and 8 hours, so the 4 vCPU scenarios use the Instances type, which caps sessions at 14 days and keeps files only in the storage mount or an EBS volume. Sprites has no session cap but does not publish how many Sprites can run at once without a plan, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed. bochka has no session cap on paid plans, but at 1,000 short jobs at once even the $2,000 plan queues starts above 90 a minute, while AgentCore fits that burst.
| Scenario | Sprites | AWS AgentCore | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops | None that bite |
| 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 Sprites when
your agents or apps sit idle most of the day, should wake on a request, and need a persistent disk and more than 2 vCPU.
- A persistent machine that sleeps when idle. For agents that sit idle most of the day: a Sprite keeps its whole disk, stops billing compute and wakes on the next request.
- Bigger than an AgentCore session. Each Sprite has 8 vCPU and a 100 GB disk, while an AgentCore microVM session stops at 2 vCPU and 8 hours.
- Agents preinstalled and a URL that wakes it. Claude Code, Codex, Gemini CLI and Cursor come preinstalled, and each Sprite gets an HTTPS URL, which AgentCore sessions lack.
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 17 commercial regions.
- Managed Code Interpreter and Browser. For short code runs and browser tasks, ready-made tools bill only CPU actually used, and Browser adds 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 account.
Where bochka fits
If your agents do real work on a machine for hours, installing, building, testing and serving apps, both Sprites and AgentCore make you work around their shape. bochka gives each agent a full VM you size yourself, with systemd, Docker and /dev/kvm, a disk saved every minute, a 60fps desktop, and many ports you can open.
A full machine that keeps running
A Sprite pauses when work stops and drops open connections unless a task hold, renewed every hour, keeps it awake. An AgentCore microVM stops after 8 hours at 2 vCPU, and the way around it is running EC2 in your account.
Services, emulators, forks and ports
Sprites has no systemd and one public HTTP port, and AgentCore has no open ports at all, so a dev server needs your own proxy. Neither documents /dev/kvm or lets you fork a running machine to try two fixes from one state.
A desktop and agents you drive from outside
Sprites is headless and AgentCore Browser shows only a browser, so other apps need a display server you set up yourself. bochka streams a 60fps desktop and lets your code prompt, steer and follow seven preinstalled agents.
Use bochka when your agents need a full machine for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Sprites and bochka vs AWS AgentCore.
Questions people ask
Is Sprites cheaper than AWS AgentCore?
In the five scenarios we priced, Sprites comes out lower each time: one agent that never stops is $92 a month on Sprites against $107 on AgentCore, and 50 agents in parallel are $1,120 against $1,286. bochka comes to $26 and $317 for those two. For 1,000 short jobs at once, AgentCore costs $1,615 and is the only one of the three that fits.
Which is faster, Sprites or AWS AgentCore?
Neither has a comparable CPU measurement in the benchmark we use. A Sprite always has 8 vCPU, while an AgentCore microVM session tops out at 2 vCPU, so a heavy build has more cores on Sprites. bochka did 26.69 runs per second at 4 vCPU / 8 GB.
Can Sprites and AgentCore run Docker?
Users run Docker on Sprites, though some images fail on docker exec because of restricted capabilities, and Sprites has no systemd. AgentCore's docs do not say Docker works inside a session. bochka runs Docker, systemd and /dev/kvm in every sandbox.
How long can a session run on each?
A Sprite has no time cap, but it pauses about 30 seconds after activity stops unless a task holds it awake for up to an hour at a time. An AgentCore microVM session lasts up to 8 hours, or 14 days on the Instances type. bochka has no session cap on paid plans.
Do files survive a stop?
On Sprites, yes: the whole 100 GB disk stays. On AgentCore, only a storage mount under /mnt of up to 1 GB, or EBS volumes on Instances, survives; the rest resets. bochka keeps the whole disk and saves it every minute.
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