Koyeb vs AWS AgentCore
Koyeb runs each sandbox as a service in its own microVM that can sleep when idle and wake on the next request, on CPU or GPU. AgentCore is the part of AWS that hosts agents in 2 vCPU microVM sessions of up to 8 hours, with managed Code Interpreter and Browser tools, and fits best when your agents must stay inside your AWS account.
The companies and products
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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. “4th cheapest of 345” means 3 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 | Koyeb: 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 A software factory needs a big machine and a disk that keeps its work; Koyeb offers bigger instances than AgentCore's 2 vCPU sessions, and bochka ranks 3rd with a full VM that keeps its whole disk. | 54th of 367, with limits $366 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 loses files when a Koyeb sandbox deep sleeps; on bochka it keeps running with its disk. | 135th of 366, with limits $923 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: Koyeb ranks 4th with small instances that scale to zero, and AWS AgentCore ranks 7th with a Code Interpreter billed only for CPU actually used. | 4th cheapest of 345 $66 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 Koyeb ranks 6th because each user's sandbox can expose an HTTPS port and wake on request; AgentCore sessions have no open ports, so users cannot open what their sandbox runs, and bochka ranks 1st with up to 50 HTTPS ports each. | 6th cheapest of 361 $495 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 | 237th of 360, with limits $1,631 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 | 19th cheapest of 364 $429 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 neither Koyeb nor AgentCore documents and bochka exposes. | 142nd of 377, with limits $88 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 | 217th of 368, with limits $37 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 Computer-use agents need a whole desktop: Koyeb has none, AgentCore Browser drives only a browser, and bochka streams a 60fps Linux desktop. | 81st of 369, with limits $123 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 with a managed Chromium that has live view and replay, while Koyeb sandboxes have no browser, and bochka runs Chromium on a full desktop. | 172nd of 367, with limits $123 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 | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 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 Koyeb ranks 3rd here with GPU instances up to H100 and H200; AgentCore has GPUs only on the Instances type in your account, and bochka has no GPUs. | 3rd cheapest of 98 $628 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 | Koyeb | AWS AgentCore | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance, started from any Docker image | 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 |
| Biggest machine | Instance types up to 40 vCPU / 128 GB, and GPU types far larger | 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 | No forced cap documented; optional auto-delete timers up to 24 hours | Up to 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 | Local disk is lost on redeploy and a deep sleep discards the VM; volumes (preview, 1 to 10 GB, two regions) persist | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances; the rest resets | The whole disk, saved every minute and on stop |
| Snapshots and fork | SDK snapshots of the filesystem, or with running processes, then new sandboxes from them (experimental) | No user snapshots or fork of a session | Automatic snapshots every minute; fork a running sandbox with its disk |
| Sleep and wake | Scales to zero after 5 idle minutes or more and wakes on the next request; Light Sleep wakes in about 200 ms | Session stops after 15 idle minutes by default; the next call starts a fresh microVM | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Docker, systemd and /dev/kvm | Runs Docker images in a microVM; nested virtualization not documented | Root inside the microVM; arm64 container images; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm for Android emulators and VMs |
| Inbound access | One exposed HTTPS port at a time, plus an optional TCP proxy to one port; no dedicated IP | No open ports or SSH; sessions are reached only through AgentCore APIs | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; SSH |
| Network controls | Block all outbound traffic, or allow only listed IPs and CIDRs | 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 in the sandbox SDK | Managed Chromium with live view, session recording and replay; no full desktop | Full Linux desktop streamed at 60fps, with Chromium and computer use |
| Coding agents | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | AWS's own 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 set as environment variables inside the service | 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 | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | NVIDIA G-series and Inferentia2 on the Instances type only | No |
| Regions | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo, San Francisco in preview | 17 commercial AWS regions plus GovCloud | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Koyeb | AWS AgentCore | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | 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 | Yes | No | Yes |
| Live fork (no pause) | Not published | 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 | Yes | 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 | Yes | 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 | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Koyeb nor AWS AgentCore has a comparable measurement: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory, and an AgentCore microVM session stops at 2 vCPU, so a like-for-like test there 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. Koyeb 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 | Koyeb, 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 | $29 · Pro | $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 | $57 · Pro | $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 | $475 · Pro | $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 | $329 · Scale | $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 | $485 · Scale · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 a month with $100 included; the rest of the fee is not credit.
AWS AgentCore: Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and for peak memory, with no plan fee. The 4 vCPU shape here 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. 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 / 8 GB, so the 4 vCPU scenarios are priced on Instances, where files survive a stop only in the storage mount and an always-on agent hits the 14-day session cap. Koyeb's priced eco-xlarge shape has a 20 GiB disk with no published price for more, and eco instances guarantee only half of each vCPU, so 1,000 short jobs at once get throttled. That burst is the one scenario AgentCore fits and Koyeb does not; bochka does not fit it either, since its plans queue starts above 90 a minute.
| Scenario | Koyeb | 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 |
| 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 Koyeb when
your sandboxes sleep most of the time and must wake on a request, need a GPU or a big instance, or should expose a port to your users.
- Bigger machines and GPUs without your own cloud account. Koyeb sells instances up to 40 vCPU / 128 GB and GPUs up to H100 and H200, billed per second.
- Sleep when idle, wake on the next request. For sandboxes idle between requests: Koyeb scales to zero after 5 minutes and wakes in about 200 ms with Light Sleep.
- A port your users can open. A Koyeb sandbox can expose an HTTPS port and a TCP proxy, so a user can open the app it runs.
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 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, both tools bill only for CPU used, and Browser adds live view and replay.
- Two-week sessions on Instances. Agents that need a GPU or up to 14 days can run on EC2 in your account, with Savings Plans applying.
Where bochka fits
Koyeb and AgentCore both run short, isolated work well, but both treat a sandbox as something that resets. If your agents work for hours on one machine, installing packages, running Docker and serving what they build, bochka gives each one a full VM that keeps its disk, with agents, a desktop and ports built in.
A disk that stays
On Koyeb the local disk is lost on redeploy and a deep sleep discards the VM; on AgentCore only a 1 GB /mnt mount survives. Every resume repeats the setup. bochka saves the whole disk every minute and can fork a running sandbox.
A full machine with no session cap
AgentCore sessions stop at 2 vCPU and 8 hours unless you run EC2 Instances in your own account, and neither documents /dev/kvm. bochka gives root, Docker, systemd and /dev/kvm, up to 16 vCPU, with no cap on paid plans.
Agents, desktop and ports built in
Koyeb exposes one port at a time and has no desktop; AgentCore has no open ports and only a browser. bochka ships seven coding agents you drive from outside, a 60fps desktop, HTTPS on 50 ports and a credentials proxy.
Use bochka when your agents do real work on one machine for hours: installs, builds, Docker, emulators and a desktop browser, with a disk that keeps everything and URLs you can open. Compare it one to one: bochka vs Koyeb and bochka vs AWS AgentCore.
Questions people ask
Is Koyeb cheaper than AWS AgentCore?
In four of the five scenarios here, yes: $57 against $107 a month for one agent that never stops, and $475 against $1,286 for 50 agents in parallel, where AgentCore does not fit as priced. For 1,000 short jobs at once AgentCore fits at $1,615 a month, while Koyeb's burstable CPU throttles.
Which is faster, Koyeb or AgentCore?
Neither was measured in the hpc-sandbox-benchmarks run, so there is no fair answer. A single AgentCore microVM session stops at 2 vCPU, while Koyeb sells larger instances. bochka did 26.69 runs per second on that benchmark at 4 vCPU / 8 GB.
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 allows up to 14 days. Koyeb documents no forced cap, only optional auto-delete timers. bochka has no session cap on paid plans.
Do files survive a stop on Koyeb or AgentCore?
Not by default. Koyeb loses its local disk on redeploy and a deep sleep discards the VM, so lasting files need a volume or an SDK snapshot. AgentCore keeps only a storage mount under /mnt of up to 1 GB, or EBS volumes on Instances. bochka keeps the whole disk.
Can Koyeb or AgentCore run Docker and Android emulators?
Koyeb starts each sandbox from a Docker image, and AgentCore runs arm64 container images, but neither documents /dev/kvm, which Android emulators and VMs need. bochka runs Docker with root and systemd and exposes /dev/kvm.
Do Koyeb and AgentCore have GPUs?
Koyeb runs GPU instances from an RTX 4000 SFF Ada up to H100 and H200, billed per second. AgentCore offers NVIDIA G-series and Inferentia2 only on the Instances type in your AWS account. bochka is CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview