Dispatch 100 agents, then let them all wait on a tool call that returns in three days - a build queue, an approval, an overnight PR. Then read the memory bill: as traditional resident processes, community readings put an idle instance at roughly 700MB - the wait holds about 70GB. On AWS's newly open-sourced suspend-first runtime Infinity, the official benchmark puts an idle suspended agent at about 100KB - the same wait costs roughly 10MB. Seventy gigabytes versus ten megabytes, four orders of magnitude [estimated from secondhand inputs; different hardware and workload assumptions, scale comparison only]. That is the pricing of waiting: an agent's cost is not in its thinking, it is in its waiting.
Two heavyweight releases landed in late October 2026: AWS open-sourced the suspend-first runtime Infinity on October 23; Google announced Agent Compute Engine (ACE) at AGNTCon + MCPCon on October 22. Add the resident-process baseline and pay-per-second E2B, and where agents rest while they wait finally has four formed routes. Scope note: one measuring stick only - the economics of waiting: memory held while idle, resume speed, what scale pays off. Isolation strength is a different stick (our August 19 five-way isolation comparison); the Infinity deep dive is in the open-source resource piece; local setup is in the sandbox-runtime SOP. A synthesis of official and secondhand sources, not a hands-on test, not procurement advice.
1. The Suspenders: AWS Infinity Turns Agents Into Pure Data
Release facts [official - AWS blog]: on October 23, 2026, AWS released Infinity, an output of Hydro, an AWS-UC Berkeley collaboration - Apache-2.0, explicitly an early research release, not GA, no SLA. The repository is github.com/hydro-project/infinity; the README calls it "An agent runtime and tool protocol for principled agent concurrency."
Mechanically, an agent is a stackless coroutine and every tool call is an await point. Execution runs in slices: load history, one model completion, persist output, dispatch at most one tool call, end of slice. Between slices the agent is pure data - "Between turns, an agent is pure data, just its conversation history with no task, no stack, and no open connection" - and resident memory stays close to the history's size [official].
The headline number [official - blog benchmark]: about 100KB per idle suspended agent, from a simulated-model benchmark - 80,000 agents x 20 turns, 3.2 million completions, single-threaded AMD EPYC 9R14, in-memory stores, about 1.2KB per completion. AWS extrapolates: 8GB (the Raspberry Pi 5's memory as reference line) then fits about 75,000 suspended agents. That is linear extrapolation, not measurement [official estimate]; real long-context agents suspend at roughly their history's size, significantly more than 100KB.
The serverless reference architecture is copyable [official]: SQS FIFO input queues (one MessageGroupId per thread), a Lambda invocation per slice, Aurora DSQL for history, DynamoDB for deduplication, EventBridge timers, CDK constructs in the repo. On our yardstick: three waiting days cost zero compute - you pay for execution, the wait costs nothing.
Shortcomings: research release, no SLA, and the authors' own open questions (interleaved event reasoning, scheduling policies, agent-tree compaction, event provenance). Most importantly, Infinity makes no isolation claims - suspension is a scheduling-level saving, not a security boundary [no official claim].
2. The Isolators: Google ACE, One microVM per Agent
On October 22, 2026, Google announced ACE at AGNTCon + MCPCon [official]. Every agent session gets a single-tenant, memory-safe, hardware-isolated microVM (Cloud Hypervisor) with its own guest kernel and root privileges. The signature design is zero-secrets: no persistent keys, OAuth tokens, or service account keys in VM memory or disk; each VM gets only a short-lived SPIFFE certificate, and long-lived credentials never leave the host - the Agent Gateway injects them at the exit after verifying mTLS identity and egress policy. Stated goal: "compromised sandboxes hold nothing worth stealing." Trust anchors in the Titanium IPU: block-storage mounts are brokered with instance-bound cryptographic authorization, unreadable across node or tenant boundaries [official - deep dive].
Two economic levers [official]: copy-on-write memory sharing runs multiple agents off one OS template; when an agent thinks or waits on a human, the host marks the microVM idle, checkpoints quickly, and restores from the snapshot when needed.
The attribution trap to flag: the widely quoted "sustained 500 agent activations per second with under 500ms resume latency in a 200,000-agent benchmark test" belongs, in the original announcement, to Agent Substrate - the GKE-native runtime open-sourced alongside it (repository: github.com/agent-substrate/substrate) - not to the ACE managed service [official]. ACE's own startup time, density, and pricing are unpublished; availability is "preview in the coming months," SLA unpublished [official]. Third-party coverage states the figures come from Google and partners, not independently measured [secondhand - aipolix].
Shortcomings: not GA, no pricing, no SLA; the 200,000-agent test's methodology is unpublished; and the design leans on Google's in-house silicon (Titan chips, Titanium IPU) - an open question for multi-cloud buyers.
3. The Residents: Claude Code + Docker, With an Honest Disclaimer
Up front: this camp has no official concurrency benchmark. Everything here is community-reported [secondhand]. The mechanism has an official characterization, ironically from AWS's motivation paragraph: "Most agent harnesses run the agent loop as a sequence of blocking steps... While the agent waits, it holds a process and its memory, and it cannot respond to events." Wait twenty minutes for a build or overnight for an approval, and the process and memory sit there the whole time [official - AWS framing]. Agents are I/O-bound: mostly waiting on API responses, command results, and file operations; memory occupancy is the hard cost [secondhand].
The community readings stack up [secondhand]: roughly 700MB idle RSS per CLI instance (GitHub issue #61425); extreme cases of a session climbing from about 900MB to 12.6GB and another OOM-killed at 29.9GB; and the desktop case of 183 idle session trees plus about 2,600 MCP sidecars totaling roughly 160GB RSS - MCP cost is an N-sessions-times-M-servers multiplication. The official anchors number two, both third-party relays worth re-verifying [official - relayed]: a 4GB RAM minimum, and a critical memory warning when a session's JS heap passes 2.5GB [secondhand - changelog].
When is resident simpler? When agents number in the single digits to a few dozen and MCP servers stay warm: no message queues, no durable stores, no deduplication state - the smallest operational surface. No published crossover analysis exists for resident-versus-suspended costs [secondhand - qualitative]. Mind the isolation ceiling: containers are namespace-level isolation on a shared kernel - good enough for "the code messed up its environment," not for "the code was instructed to escalate" (our August 19 review).
4. The Cloud Reference: E2B Rents You the Wait
E2B calls itself "The AI Agent Cloud," with over one billion sandboxes started per its pricing page; each sandbox is a dedicated Firecracker microVM with its own kernel, never shared with another customer's sandboxes [official]. Its answer to our yardstick is direct: the vendor implements suspension and isolation; you pay by the second the sandbox runs; paused or killed sandboxes are not billed. Waiting is free; running is what costs.
Rates and plans [official - pricing page captured 2026-10-26]: vCPU $0.000014 per second, RAM $0.0000045 per GiB per second, billed on allocation rather than usage; the official FAQ example puts a default-spec sandbox at about $0.109 per hour. Plans: Hobby is free (1-hour sessions, 20 concurrent); Pro is $150/month including 100 concurrent (24-hour sessions); Enterprise starts at $3,000/month for multi-day sessions and tens of thousands of concurrent sandboxes.
One official self-contradiction, reported side by side without adjudication [two official pages]: the pricing page marks 4GiB as the Default memory tier, the docs FAQ's example uses "2 vCPU and 512 MiB" as the default sandbox - cite both. Pause and resume: roughly 4 seconds per GiB, about 1 second back (official docs, relayed secondhand); cold-start figures unpublished. The old cost remains: your code and data leave your perimeter - our August 19 verdict still holds.
5. The Master Table
| Route | Memory held while waiting | Resume latency | Isolation strength | Operational complexity | Fits at scale |
|---|---|---|---|---|---|
| Suspenders: Infinity | ~100KB/agent (simulated-model benchmark) [official; real long-context unpublished] | Unpublished [no public figure] | No isolation claim [official made none] | High: self-run SQS/Lambda/DSQL/DynamoDB [official reference architecture] | Tens of thousands suspended (75k/8GB estimate, unmeasured) |
| Isolators: Google ACE | Idle checkpoints free host memory; per-VM figure unpublished [no public figure] | <500ms and 200k-agent test belong to Agent Substrate [official]; ACE itself unpublished | Strongest: hardware-isolated microVM + zero-secrets + IPU anchoring [official] | Low-medium: managed but not GA, no pricing [official] | 200k-agent test self-reported, methodology unpublished [official self-report] |
| Residents: Claude Code + Docker | ~700MB RSS idle per instance [secondhand]; 4GB RAM official minimum [official relay] | Process already in memory, immediate [estimated] | Container = namespace isolation, shared kernel [site review, Aug 19] | Lowest: no extra infrastructure [secondhand, qualitative] | Single digits to a few dozen [secondhand, qualitative] |
| Cloud: E2B | Rented by the second; pauses not billed [official] | ~1s resume, ~4s/GiB pause [secondhand relaying official]; cold start unpublished | Firecracker microVM, dedicated kernel [official] | Lowest: sign up and go; price is data egress [official] | Tens of thousands concurrent sandboxes (Enterprise) [official] |
6. The Scale Math Behind 70GB vs 10MB
All four routes on one stick allows only order-of-magnitude estimation [estimated from secondhand inputs]: at about 700MB per resident instance, 100 resident sessions hold about 70GB; at Infinity's official ~100KB per suspended agent, 100 suspended agents hold about 10MB - a factor of roughly 7,000. The figures assume different hardware and workloads; scale comparison, not conclusions. On the E2B side a framework can be drawn but no crossover found: renting scales linearly with usage, self-building (Infinity / Agent Substrate) amortizes infrastructure and operations - no public source has measured the TCO crossover, and this article will not invent one [no public crossover figure].
7. What to Pick at What Scale
- Single digits to a few dozen agents: stay resident. Smallest operational surface; do not buy architectural anxiety your numbers do not justify.
- Hundreds to tens of thousands of suspended agents, with an infrastructure team: the Infinity route. Accept the research-release positioning and a self-run serverless stack; turn waiting into a queue message.
- Strong isolation, all-in on Google Cloud: watch ACE's preview. If you cannot wait, study the open-sourced Agent Substrate (GKE) first.
- No appetite for ops, egress acceptable, bursty workloads: rent by the second with E2B. Pauses are not billed; Hobby and Pro suffice to experiment.
- Standing discipline: pick isolation strength with the threat model first (the August 19 stick), then place the waiting with the economics (this article's stick). Never mix the two.
FAQ
Q1: Is every suspended agent really just 100KB? A1: No. The benchmark used a simulated model at roughly 1.2KB per completion over 20 turns, so the histories were short; the post says suspended memory stays "close to the size of their histories," and real long-context agents suspend significantly larger. The defensible claim is "about 100KB per agent under benchmark conditions" [official self-limitation].
Q2: Are the 200,000 agents and the sub-500ms resume ACE's results? A2: No. The announcement attributes them to Agent Substrate, the GKE-native runtime open-sourced alongside ACE; ACE itself has no published startup time, density, or pricing. Third-party summaries crediting the whole platform are garbled relays [original text governs].
Q3: Does the resident camp truly have no official numbers? A3: No. The only citable official anchors are the 4GB RAM minimum and the 2.5GB heap warning threshold, both third-party relays worth re-verifying; everything else is community reporting, with extremes reaching 12.6GB to 29.9GB [secondhand].
Q4: Is E2B's default sandbox 4GiB or 512MiB? A4: The two official pages disagree: the pricing page marks 4GiB as Default, the docs FAQ's example uses 512MiB. Report both; cost estimates can differ several-fold - run a real bill in your own account before committing [two official pages compared].
Q5: Can these four routes be mixed? A5: Yes, and commonly: resident for interactive work, suspension for long waits, cloud sandboxes rented by the second for untrusted code. The hazard is judging all four with one stick - isolation from the August 19 review, waiting economics from this article. Fix isolation first, then placement.
Related reading
- Five-Way Comparison of Agent Isolation Options - the other measuring stick (Aug 19): Firecracker / CubeSandbox / agent-sandbox / E2B / Daytona.
- AWS Infinity Open-Source Resource - companion deep dive: why 8GB fits 75,000 suspended agents.
- Claude Code Sandbox-Runtime SOP - companion hands-on local-sandbox guide.
Sources
- AWS Open Source Blog: "Introducing Infinity: a runtime for extreme agent concurrency" (2026-10-23, Shadaj Laddad): https://aws.amazon.com/blogs/opensource/introducing-infinity-a-runtime-for-extreme-agent-concurrency/
- GitHub hydro-project/infinity README (last commit 2026-10-23): https://github.com/hydro-project/infinity
- Google Cloud Blog: "Introducing Agent Compute Engine and expanding agent governance" (2026-10-22); "Inside Agent Compute Engine" (deep dive)
- GitHub agent-substrate/substrate: https://github.com/agent-substrate/substrate
- E2B pricing page (captured 2026-10-26): https://e2b.dev/pricing ; billing FAQ: https://www.e2b.dev/docs/faq/calculate-sandbox-price
- Community readings: Claude Code memory issue #61425; 183-session ~160GB RSS desktop case (claudeissues.com); jtti VPS article; wpnews.pro memory teardown
- On this site: Five-Way Comparison of Agent Isolation Options (2026-08-19)
Based on public materials and direct captures of official pages (figures as of 2026-10-26). A representative comparison, not a hands-on deployment test; Infinity and ACE benchmarks are vendor-reported and independently unmeasured; not procurement advice.