Orchestration Primitives That Make Per-User Computer-Use Agent Fleets Production-Ready

Four orchestration primitives make AI agent fleets production-ready and cost-effective.

· 9 min read
Cover illustration for “Orchestration Primitives That Make Per-User Computer-Use Agent Fleets Production-Ready”
Agent Patterns · November 3, 2026 · 9 min read · 2,095 words

Per-user persistent AI agent deployment at scale requires four orchestration primitives working together, namely VM-level isolation, persistent state, snapshot-restore scheduling, and multi-tenant session governance. A capable agent alone cannot provide these guarantees. Production readiness depends on an orchestration layer that preserves each user’s environment, stops charging for idle compute, and controls every action under the correct tenant policy.

Why per-user computer-use agent fleets fail at the orchestration layer, not at the agent level

An agent designed for one developer’s machine has no built-in answer to the boundaries a customer fleet requires. On that machine, identity, credentials, disk ownership, and resource allocation can remain implicit. In a fleet, they cannot remain implicit. Teams then discover that multi-tenancy, persistence, sandboxing, and billing need to be rebuilt together, even when the agent performs its task correctly.

Computer-use agents make this mismatch especially sharp because they operate an environment. They install packages, open authenticated browser sessions, run code, and leave artifacts on disk. Those actions extend both the state that must survive and the damage that must be contained. A shared-container or stateless serverless approach suitable for a chatbot does not provide the same guarantees.

A single-agent prototype can initially use fewer mechanisms than a fleet, a valid exception limited to that stage. Once a team assigns persistent agents to separate customers, the problem becomes architectural, and improvements to model quality cannot substitute for tenant boundaries.

The four orchestration primitives that must all be present simultaneously

The four requirements must all be met together. Without VM-level isolation, persistent tenant state can be exposed through a shared environment or kernel. Without persistence, agents lose their credentials, browser state, and unfinished work between sessions. Without snapshot-restore scheduling, isolated environments consume compute budgets while idle. Without tenant-level session governance, the fleet lacks a principled way to route, authorize, pause, and audit actions on each user’s behalf.

These requirements constrain one another in practice. Persistence needs an isolation boundary that keeps state with its owner, and scheduling must keep that state when it takes an environment off active compute. Governance must select the correct environment and policy before an agent acts. The supervisor/worker pattern gives these responsibilities a common control plane rather than leaving each agent to enforce them independently. The following sections address isolation, persistence, scheduling, and governance in that order.

Diagram: The Four Orchestration Primitives and Their Dependencies. Visualizes: Visualize four orchestration primitives that must all be present simultaneously for per-user persistent AI agent fleets: (1) VM-level isolation, (2) persistent state…

VM-level isolation as the minimum acceptable boundary for computer-use agents

A Docker container shares its host’s Linux kernel, while a Firecracker microVM has a dedicated kernel. That distinction defines the containment boundary. A vulnerability that gives a container kernel-level access threatens the other tenants on that host. For multi-tenant agents executing AI-generated code or acting on user-supplied prompts, a dedicated kernel per agent is the minimum boundary this architecture requires.

Microsoft disclosed CVE-2026-25592 in February 2026, showing how prompt injection in agent frameworks led to host-level remote code execution. The finding connects untrusted agent input to an infrastructure-level consequence. It makes isolation a security requirement. A microVM gives an agent room to install packages, run browsers, and rebuild its environment without sharing a neighboring tenant’s kernel state.

This boundary need not impose impractical startup latency. Firecracker microVMs can start in approximately 125ms with under 5 MiB of memory overhead. Docker Sandboxes reached general availability in September 2026 with custom microVM isolation for AI coding agents and 180ms cold starts. These figures establish that kernel separation can coexist with fast environment creation, although startup speed alone does not solve idle cost.

A local sidecar proxy provides a complementary boundary for delegated authority. The agent reaches external services only through the proxy, which injects authentication and strips authentication metadata from responses. This keeps service credentials outside the agent’s direct control. Network policy adds to the VM boundary, which is still needed.

Persistent state as the primitive that makes an agent the same agent across sessions

Once an agent has an isolated environment, continuity depends on what survives inside it. A conversation transcript is not enough for computer use. The state surface includes files, configurations, downloaded assets, installed packages, authenticated browser cookies, local storage, session tokens, and task memory. If any required part is lost, the agent may be unable to keep working even if it remembers what the user asked.

Persistence must therefore survive process restart, sleep, and redeploy. An isolated persistent disk puts a boundary around a tenant’s artifacts, so their separation does not depend on conventions inside a shared environment. Durable execution addresses the workflow side of continuity. LangGraph provides checkpointing for crash recovery, human-in-the-loop pause and resume, and structured multi-agent state passing. Teams with long-running computer-use workflows should choose a stateful execution model and make persistence part of how work runs, beyond an optional transcript store.

Memory also needs boundaries within the application. Global knowledge may be shared across agents, while strategy-level patterns belong to an agent type. Conversational history belongs within a tenant scope, and each user’s context needs its own partition. Conflating these levels can expose tenant data even when compute isolation is correct.

Credential continuity must also respect delegated authority. Browser authentication state may need to survive, while the proxy keeps the service credentials it injects out of the agent’s hands. Keeping the whole environment lets the agent pick up work across sessions, but keeping every such environment running all the time adds cost.

Snapshot-restore scheduling as the primitive that makes per-user isolation economically viable

Most agents are idle most of the time. An always-on VM-per-user design nevertheless reserves compute for each environment, making inactivity expensive. Snapshot-restore scheduling changes the chargeable resource during that period from compute to storage. It is the economic mechanism behind persistent per-user isolation.

With copy-on-write memory management, the host can keep a base image plus each agent’s divergent pages in place of a full RAM allocation for every environment. Those pages represent what differs from the shared base. Many sessions can stay snapshotted and idle while active agents use vCPU and RAM. The host’s session capacity is therefore distinct from the number of agents it can execute simultaneously at peak allocation.

Interactive computer-use workloads need a sub-second wake target because delays measured in seconds make resumption feel unresponsive. Preparing a template incurs the initial cold-boot cost, while subsequent sessions can restore its prepared state. That distinction amortizes environment preparation across the fleet.

AWS operationalized this pattern in AgentCore Runtime V2, shipped September 18, 2026. New sessions restore a prepared environment snapshot taken after the first healthy ping, keeping P75 cold-start times consistently low regardless of container image size. The runtime also reclaims memory an agent stops using, so billing tracks actual usage. This supports costs based on active compute time, but it leaves a separate question unresolved, namely who may activate which agent under which policy.

Multi-tenant session governance as the primitive that makes a fleet safe to operate

VM isolation controls where an agent can execute. Session governance controls whose authority it exercises and which resources that authority permits it to reach. An isolated agent can still call the wrong tenant’s tool endpoint if policy selection is incorrect. Tool-invocation authorization must therefore be enforced separately from the VM boundary.

A silo places each tenant’s complete workflow in isolated agent skills, while a pool uses shared skills. A hybrid combines tenant customization with resource efficiency for SaaS-style deployments. None of these arrangements removes the need for deterministic, configuration-driven session routing. The control plane should behave predictably, with rules that assign tenants and keep that choice out of model reasoning.

MCP server access requires per-tenant policies at invocation time. A proxy can enforce per-agent rate limits and request quotas so runaway activity does not cascade to neighboring tenants. Governance also needs approval before agents reach servers, identity-bound access to individual tools, blocking of non-compliant calls in the request path, and audit records against policy. Each control closes a different gap.

Human intervention completes this operational boundary. Pause and resume, approval queues, and audit trails let a team inspect and authorize consequential browser or code actions. These controls must operate on the same tenant identity used for routing and state access. That shared identity is what allows the four primitives to compose into one architecture.

How the four primitives compose into a fleet architecture with a concrete orchestration pattern

The supervisor receives the user’s task and decomposes it into work for specialist agents. A capable model can perform decomposition and synthesis, while cheaper, task-specific models handle execution. Dispatch follows deterministic configuration, which keeps the choice of tenant ownership out of model reasoning. This separates judgment about the task from authority over resources.

Each worker runs in its own microVM with persistent disk and browser state. The scheduler decides whether to restore a snapshot or start an environment cold. That decision stays below the supervisor’s task logic. Every task includes a tenant tag, which the governance layer uses to select the memory partition, MCP policy, and tool authorization set before the worker accesses a resource.

As an operational rule, workers send structured summary packets to each other through the orchestrator. A defined schema makes inter-agent state auditable and allows malformed output to be rejected before forwarding. Schema validation constrains the handoff, though it does not establish that every model-generated claim is true.

The architecture should begin with supervisor/worker and gain additional hierarchy only when the single supervisor becomes a bottleneck. Adding layers earlier makes work harder to coordinate without solving a known constraint. To build this pattern, teams still need to choose how to handle durable execution, tool access, and infrastructure. Those choices have different responsibilities and tradeoffs.

What platforms and tools support a dedicated persistent agent for every user?

No single framework supplies the complete primitive stack. Teams need durable execution, a tool-access protocol, and infrastructure for VM isolation, persistent disks, and snapshot scheduling. For most developer teams and startups, the infrastructure layer is best handled by choosing a platform.

LangGraph fits Python workflows that need checkpointing, crash recovery, pause and resume, and structured multi-agent state management. The OpenAI Agents SDK handles handoffs and threading for teams committed to OpenAI, with tighter coupling to one provider’s abstractions as the tradeoff. Neither choice removes the infrastructure requirement. Durable workflow state and a persistent computer environment are related but distinct responsibilities.

MCP supplies the connector layer for tools. The protocol moved from an Anthropic experiment in late 2024 to an industry standard by 2026, backed by OpenAI, Google, Microsoft, and AWS and donated to the Linux Foundation’s Agentic AI Foundation. Its July 28, 2026 specification update removed protocol-level sessions, so servers could run behind load balancers without session affinity. That improves tool-server scalability without making the agents themselves stateless.

Infrastructure evaluation must therefore look below the SDK. Firecracker supplies the microVM foundation, while AgentCore Runtime V2 provides a concrete example of prepared-environment snapshot restoration and usage-based memory reclamation. Those capabilities are not, by themselves, evidence that every persistence and governance requirement is satisfied. The platform must demonstrate the complete set of boundaries the application needs.

The deployment checklist: when the four primitives are actually in place

Deployment verification should exercise each boundary independently under adversarial conditions. Confirm that each user’s agent has a microVM with a dedicated kernel. Test that another tenant’s disk or kernel state stays out of reach if an environment fails or is exploited while agents install packages, run code, and drive browsers. A running orchestration framework is not sufficient evidence.

Next, put an agent through a sleep-wake cycle. Confirm that browser authentication, packages, artifacts, and memory remain available without re-authentication or environment setup, while proxy-managed service credentials remain outside the agent. Check process-restart and redeploy continuity as well. Test the global, strategy, tenant, and user memory partitions one at a time to check that their access boundaries hold.

Then examine scheduling under realistic fleet conditions. Keep most agents idle and wake a cohort simultaneously. Restore latency should stay within the sub-second target in normal use, with charges for storage when environments are idle and compute billing based on active use. Confirm that restores reuse the work of template preparation and that the host can store more sessions than it can run at the same time at peak allocation.

Finally, test governance and composition together. Verify configuration-driven routing, per-tenant MCP access, invocation-time authorization, and accessible pause, approval, and audit controls for consequential actions. Give an agent a task that would reach another tenant’s data or session if isolation were wrong, and establish that governance and VM boundaries each prevent that access independently. A fleet that passes these tests has closed the orchestration gap between a capable individual agent and a production per-user service.

Filed underAgent Patterns

More in Agent Patterns