The Infrastructure Inflection Point Between Hundreds and Millions of Personal AI Agents
Snapshot-based microVMs let each agent keep its own state while idle costs only storage.

Per-user persistent AI agent deployment at scale requires a dedicated, resumable computing environment for each agent. The leap from hundreds to millions exposes a mismatch between short-lived, shared web infrastructure and agents that must remember context, preserve work, and act across sessions. Snapshot-based microVMs address that mismatch by letting each agent keep its own machine state while paying for storage, rather than running compute, when idle.
Why Zuckerberg's prediction is an infrastructure claim, not just an AI claim
Mark Zuckerberg said on Meta's Q2 2026 earnings call that it was “extremely unlikely” that five years later, billions of people would not rely on personal AI agents working around the clock. He named finance, health, relationships, running a home, and careers as examples. Those jobs take more than a single conversation. They need computing environments that keep personal context and stay available between tasks.
The same week, Meta said it had a multi-billion-dollar data center partnership with BlackRock in El Paso, Texas. Its free cash flow fell sharply that quarter, largely because it spent money on AI infrastructure. But data center capacity alone does not explain how individual agents will preserve their work, remain isolated, and stay affordable between uses.
How far agent deployments actually are from that prediction today
McKinsey's April 2026 analysis found that a large majority of organizations were experimenting with or piloting AI agents. Yet in any given business function, no more than ten percent of respondents said their organizations were scaling them. The distinction is between trying agents and operating them. A pilot can demonstrate a useful task without establishing that its supporting systems can handle a much larger population of agents.
The same analysis projected IT infrastructure costs increasing two to three times by 2030 while budgets remain flat. The agent is only the visible layer above APIs, identity systems, access controls, data pipelines, workflow logic, orchestration, monitoring, logging, cost controls, and governance. Model capability does not remove those dependencies. As agent populations grow, the infrastructure has to support both their work and the controls around it without making every additional user an unaffordable running allocation.
What actually distinguishes an agent from a chatbot at the infrastructure level
A chatbot interaction can look complete when an answer appears. A personal agent may still have work to do after that exchange. It must keep context, remember a user's goals, and chain actions together without being told what to do at every step. Persistence means the next interaction starts with the agent's accumulated work, rather than treating every request as a fresh beginning.
That requirement has a substantial resource footprint. An active agent may need multiple virtual CPU cores, significant RAM, tens to hundreds of gigabytes of persistent storage, a browser, an operating environment, network access, and remote AI inference. Even one apparent exchange can involve many LLM calls for understanding, planning, tool execution, verification, and output formatting. The user sees a conversation, but the system supports an ongoing process. Infrastructure is beginning to provision computers for digital workers.
Why the web's stateless, shared infrastructure is the wrong shape for persistent agents
McKinsey framed the shift as infrastructure becoming the platform that orchestrates and governs how enterprise work gets done. Its proposed organizing principles were modularity, composability, and orchestration. Those principles depart from optimizing only for request-response efficiency. Much web infrastructure is built around a short cycle in which a request arrives, a function executes, a result returns, and the process ends. Shared compute works well when the process itself need not survive.
Containers and Kubernetes help workloads share hardware by packing them onto the same machines. That optimization is a poor fit when applied to agents whose live context spans dozens of tool calls and cannot simply be discarded mid-task. More capacity does not fix that mismatch. A shared container pool for persistent agents is like running a city's taxi fleet as one giant shared vehicle, with every passenger expecting to leave belongings inside between trips. The useful measure of allocation shifts from how many agents fit on one machine to how efficiently a machine can serve an agent across its lifetime.
What infrastructure lets every user have a persistent AI agent
The appropriate unit is a per-agent computer with its own kernel, memory state, filesystem, and network identity. Firecracker micro-VMs provide that boundary without relying on containers. An idle machine can become a snapshot rather than remain a running allocation of RAM and vCPU. The snapshot preserves full memory contents, CPU register state, and device state, allowing execution to resume where it stopped.
The latency differences make this operationally useful. Firecracker cold boots take 125–200ms, while snapshot restores complete in 5–30ms. Pausing takes under a millisecond, with waking at roughly a millisecond and a half at p50 on bare metal. These figures measure distinct operations and require separate interpretation. These latencies allow preserving and resuming work to fit into an interactive workflow.
Google's Agent Compute Engine pattern, described in October 2026, gives each agent session a microVM, checkpoints it while the model thinks, and clones it copy-on-write from warm snapshots. It also gives the machine no network card. AWS Lambda MicroVMs, generally available in June 2026, give each user or agent session a Firecracker microVM that starts from a snapshot, suspends when idle, and resumes with memory and disk intact. The economic consequence is straightforward because a sleeping agent costs only storage across a population whose members are not all active simultaneously.

Why sandboxing becomes non-negotiable when agents execute code at scale
Security practitioners' consensus in early 2026 was that Docker/runc isolation was insufficient for executing untrusted AI agent code. LLM-generated and user-supplied code must be treated as hostile. The March 2026 paper SANDBOXESCAPEBENCH measured agents' ability to exploit seeded vulnerabilities and escape OCI containers nested inside virtual machines. The threat belongs in the infrastructure design.
For code from models a team does not control, the lesson is to use a microVM or VM boundary. Accepting a container or user-space kernel means accepting a weaker boundary. Snapshot cloning introduces another requirement that is easy to miss. Clone-safe resume must reseed randomness and identity on wakeup before each copied machine state is ready to run on its own.
Isolation also has a limit of responsibility. A kernel boundary addresses whether code can escape its sandbox, while whether an agent should be allowed to make an HTTP request is a separate question. That second question requires action gating, input sanitization, and runtime monitoring around the model. Per-agent machines provide a foundation for security, but they do not replace decisions about permitted behavior.
How the per-agent model changes when agents must operate real software interfaces
Many enterprise workflows are reachable only through screens. Citrix environments, electronic health records, document management systems, and loan origination systems can remain dependent on visual interfaces and inaccessible through APIs. An agent working there needs an operating environment it can see, click, and type on. A browser alone is not always enough.
OSWorld 2.0, released in June 2026, covered 108 real long-horizon workflows with roughly 318 tool calls each. Its best result achieved just over twenty percent binary success. The infrastructure harness needs retries, preserved state, and human takeover because agents still struggle to do complex tasks reliably.
Microsoft UFO³ shows how work must be coordinated by breaking workflows into dynamic task graphs across Windows, Linux, and Android. It runs independent steps in parallel and adapts the plan as results arrive. OpenAdapt illustrates a different requirement by turning a user demonstration into an inspectable workflow across browsers, desktop operating systems, RDP, and Citrix/VDI. Human takeover is part of that workflow because a person must be able to enter the same desktop when the agent reaches a decision it cannot handle.
What running agents at swarm scale exposes about cost and coordination
The SCALECUA paper used 600 parallel VM environments to collect multiple rollouts per task. That is a concrete example of swarm-scale infrastructure in a reinforcement-learning pipeline. It requires hundreds of isolated environments to be provisioned and managed together. Training and evaluation work therefore has the same need for persistence as customer-facing agents, with many attempts that may branch from the same starting point.
Snapshot forks make that branching practical without repeating all prior work. A fork consists of multiple restores of the same snapshot. A checkpoint at step 37 of a trajectory can preserve interpreter state, open files, and a half-built project while different next actions run in parallel. Coordination now includes deciding when those environments run and how their work is grouped. Major vendors' batch discounts can improve the economics, but capturing them requires queuing, batching, and scheduling.
Dashboards can show what has been spent without stopping the next call. The practical rule is that infrastructure-level spending limits must stop calls before they are sent, rather than leaving the constraint in an agent's prompt.
Why regulated industries face the infrastructure mismatch most acutely
Healthcare, lending, and insurance involve sensitive work and software that is hard to access. Healthcare agents face HIPAA requirements, lending agents encounter loan origination systems without APIs, and insurance agents work in legacy desktop environments. These are not simply additional model challenges. They require persistent desktops whose actions can be isolated, logged, and audited. The environment is part of whether the workflow is usable at all.
Per-session isolation keeps one patient's data out of the environment used by another session. Auditability requires a record of what the agent did on screen, while dedicated infrastructure provides an alternative to multi-tenant shared compute. These requirements shape the deployment from the start. A useful demonstration on a shared desktop does not establish that the same arrangement can support sensitive production work.
The Agent Compute Engine pattern's choice to omit a network card illustrates how isolation can extend beyond processes and files. That restriction is relevant to network segmentation, though it does not by itself establish data residency or compliance. Regulated deployment must account for those requirements together. In this setting, each agent needs its own dedicated environment that can be audited.
What the path from hundreds to millions of agents actually requires
Running more containers or adding Kubernetes nodes does not, by itself, supply persistent per-user computing. Each agent needs a VM boundary, snapshot-based persistence while it is idle, and clone-safe resume. Agents that use real software also need full desktops and human takeover. Infrastructure-level spending controls must govern execution, while scheduling must account for batch and parallel work.
Teams that want thousands of individual agents without rebuilding the infrastructure themselves need a platform that meets these requirements. The platform must give each agent its own computer, keep state between sessions, put idle machines to sleep, and wake them in under a second. Per-second billing and support for customers' own models and keys complete the operating model described here.
The purchasing decision is therefore more specific than choosing an agent framework or a stronger model. It is whether the underlying platform can preserve a customer's agent as an isolated, resumable working environment at an acceptable cost. Teams building for millions must decide whether to adopt that compute model or retrofit infrastructure designed to forget the process after each request.


