Shared Container Runtimes vs Per-Agent Micro-VMs in SaaS Agent Products
Kernel vulnerabilities in one tenant can escape shared containers but not per-agent microVMs.

A SaaS product that ships AI agents which execute generated code is making a guarantee about failure, whether its operators realize it or not. If you pick shared containers or per-agent microVMs, you set the blast radius for every prompt injection, supply-chain compromise, and kernel bug that follows. This is a structural decision, not a configuration preference, and it compounds as fleet size and tenant count grow.
Why the container-vs-microVM choice is a structural decision, not a configuration preference
The boundary between an agent's generated code and the host kernel defines what failure modes are possible at scale. When an agent executes code produced by an LLM, the substrate that stands between that code and the underlying machine decides how far a single bad instruction can propagate. Containers confine processes through namespaces and cgroups, but every container on a host shares one kernel, which means a kernel-level vulnerability in any container is a vulnerability in every workload on that machine.
The DevOps framing of "containers versus VMs" obscures the real tension. Agents require statefulness and strong isolation at the same time. A traditional VM delivers strong isolation but carries heavyweight lifecycle costs. The agent workload needs both at once, and no legacy primitive gives you both in one package.
That tension is precisely why the runtime decision qualifies as architectural rather than operational. A runtime's properties are guarantees about the system, not parameters to be tuned later. Scale does not change the guarantee. It changes how many times it gets tested. If an isolation model collapses under a kernel exploit, it collapses with five agents or five thousand.
What the isolation spectrum actually covers, and where containers and microVMs sit on it

Production isolation mechanisms fall into a graded spectrum, and the container-versus-microVM debate comes down to two positions with a structural gap between them. Level 1 isolation, exemplified by Docker and LXC, uses Linux namespaces and cgroups to partition processes. These processes share the host kernel directly, which is appropriate for trusted, internally written code where the platform controls what runs. It is insufficient for any workload where an LLM generates the code that executes.
Level 2 introduces user-space kernels such as gVisor, where agent code never touches real kernel syscalls directly. This approach is stronger than a plain container and lighter than a full VM, though compatibility gaps with some Linux software persist. Level 3 is the microVM, where the guest kernel is isolated by hardware virtualization, and the boundary between workloads is enforced by the hypervisor rather than by kernel conventions.
The distance between Level 1 and Level 3 is not a marginal difference in hardening effort. The decision an agent platform makes is whether a kernel vulnerability in one tenant's workload can reach another tenant, and the answer is fixed by the level chosen. The rest of the analysis follows from this foundation.
Why the shared kernel is not a theoretical risk in agent workloads
Container escape vulnerabilities shipped repeatedly across 2024 and 2025, and every one of them offered an attacker a path from inside a container to the host. That path terminates at the guest boundary in a microVM model. The CVEs that Andronchik and Lokhmakov documented in 2026 include CVE-2024-21626, the runc "Leaky Vessels" container escape granting host filesystem access, and CVE-2025-38617, a Linux kernel packet socket use-after-free that requires only CAP_NET_RAW, obtainable via user namespaces, to achieve a full container escape.
The production case that makes the pattern concrete is Flowise. CVE-2025-59528, rated CVSS 10.0, arose because Flowise's CustomMCP node parsed user-provided configuration strings without validation and executed arbitrary JavaScript with direct access to Node.js child_process and fs modules. More than 12,000 internet-facing instances were exposed to arbitrary code execution on the host at the time of active exploitation. The vulnerability was not a subtle chain. It was an unvalidated input reaching a code execution primitive, exactly the class of failure an agent platform faces daily.
In a microVM model, none of these container escape CVEs matter. Infrastructure built specifically for agent workloads defaults to per-agent VM isolation for this reason. A shared-kernel architecture does not give you the hardware-enforced wall that stops a container escape from propagating.
What cross-tenant isolation actually requires in a multi-tenant SaaS product
Multi-tenant agent products face a threat class that single-tenant deployments do not. One tenant's agent workload must be provably unable to read another tenant's data, even if the kernel itself is exploited. A sandbox in this context must address five threats: filesystem read and write outside the intended scope, network egress to arbitrary domains, host kernel syscall surface exposure, cross-tenant data leakage, and secret exfiltration via environment variables or /proc.
Container-based solutions share a kernel and rely on namespace isolation. MicroVMs address the kernel surface threat with hardware enforcement, not policy. The guest kernel becomes the boundary, not a software convention that can be circumvented by a sufficiently clever exploit.
The industry is converging on this position. Amazon Bedrock AgentCore entered production with session-isolated microVM-based compute, launching lightweight microVMs per session. Each session carries its own isolated, though by default ephemeral, filesystem, reducing the risk of cross-session data leakage. Maritime's per-agent model approaches this by giving each agent its own kernel, filesystem, and memory that persists independently of other tenants' activity. A shared kernel cannot provide both of those guarantees simultaneously.
The hidden cost structure of idle agents, and why it changes which runtime wins economically
The dominant cost in agent workloads is not active compute but idle time. The pattern repeats thousands of times per session. Any runtime that charges for reserved capacity rather than active concurrency translates that idle time directly into operator spend.
Cortex.io documented the mechanics precisely. With durable snapshots, host count follows active concurrency instead. PandaStack made the same bet on sub-200-ms snapshot restore to eliminate warm pools entirely, hitting end-to-end create at 179 ms p50 by restoring baked Firecracker snapshots on demand. Copy-on-write forks add further branching latency without keeping multiple live instances.
Snapshot-restore scheduling breaks the idle-cost structure. When an agent waits, the harness snapshots full execution state, including memory, call stack, and pending continuations, to durable storage. The process terminates and compute drops to zero. When the signal arrives, the harness restores in milliseconds. The lukewarm performance objection to microVMs, that they are too expensive to retain, dissolves when idle storage replaces idle compute as the billing unit.
What millisecond-level checkpoint and rollback enable that application-level state management cannot
Agents running test-time tree search, whether Monte Carlo Tree Search or Tree of Thoughts, or reinforcement learning must checkpoint and roll back complete sandbox state, including files and process state, at high frequency. Existing mechanisms that duplicate full state create latency that bottlenecks deep search, because copying an entire filesystem and process image for every branch is prohibitively slow. So shared container runtimes cannot provide the isolation boundary, and they also cannot provide the checkpoint capability these workloads demand.
DeltaBox, from Dong et al. in 2026, demonstrates the key insight: consecutive sandbox states between checkpoints differ only slightly, so change-based checkpoint and rollback can replace full duplication. Two co-designed OS mechanisms carry the load. DeltaFS checkpoints file state by freezing the writable layer and inserting a new one, turning updates into copy-on-write and rollback into a layer switch. DeltaCR rolls back process state by forking from a frozen template process backed by a CRIU dump, bypassing traditional full-dump pipelines entirely.
The performance figures are striking. On agentic coding and reinforcement learning micro-benchmarks, DeltaBox hides checkpoint work of approximately 10.83 ms under inference and rolls back in approximately 1.86 ms. The architectural consequence is direct: this class of capability is only available in the microVM model, because shared containers with a shared kernel cannot provide the isolation boundary that makes per-agent rollback safe or correct in a multi-tenant context.

How the security properties of each engine class hold up under formal comparative measurement
Case studies and architectural reasoning carry weight, but systematic evidence matters more when the decision bears compliance and liability risk. Andronchik and Lokhmakov measured six engine-level properties across five AI-sandbox products: host attack surface, information leakage, defense-in-depth stackability, public CVE history, patch cadence, and upstream fuzzing posture. The cross-axis reading is the load-bearing analysis.
Engine classes separate cleanly on every architectural axis. MicroVMs, userspace kernels, and OCI containers each occupy a distinct position across all six dimensions. The paper declines to propose an overall ranking, and any responsible operator should resist the urge to construct one from partial information.
The dominant operator-facing variable is product pin policy. Fuzzing investment divides into three tiers, and the strongest combination, a microVM with a continuous public fuzzer, is unoccupied in the measured product set, leaving a structural gap in assurance. For SaaS operators, the practical implication is to choose a microVM engine for the isolation guarantee, then evaluate the vendor's patch cadence and pin policy as the variable that determines realized security.
Where the MCP authorization layer and per-user agent patterns fit into the isolation architecture
Per-agent microVMs are the right compute primitive for per-user agent products, but isolation at the VM layer is incomplete without isolation at the permission layer. The MCP server is where per-tenant authorization gets enforced at runtime. The VM boundary and the credential boundary reinforce each other.
The July 28, 2026 MCP spec update formalized this direction with authorization hardening aligned to OAuth 2.1 and OIDC. Tokens are audience-bound to specific MCP servers via RFC 8707 Resource Indicators, with scopes used to limit permissions, and each tool re-checks the specific scope its action requires. A production rollback demands break-glass access or an approved proposal regardless of what the transport accepted. Issuer validation, scope step-up accumulation, and credential binding by issuer all tighten the token boundary.
The per-user agent model now has a coherent shape. One persistent, isolated VM per user, with MCP-scoped credentials, makes agent-native SaaS products both safe and economically viable. Maritime's infrastructure is built around this primitive: each agent receives its own Firecracker microVM with persistent disk and MCP-compatible tooling accessible via a single deployment push. That architecture treats the VM as the substrate and the MCP credential as the gate, which is the pattern the entire analysis has been building toward.
What to evaluate when choosing a runtime for an agent fleet that will grow
Make the runtime decision against the fleet's growth trajectory, not its current size. Properties that are acceptable at small scale compound into liabilities at large scale, because a structural weakness gets tested more frequently and by more adversarial workloads as the fleet expands. The questions below are not a generic checklist. Each one derives from a specific claim this article has established.
Isolation model, first. Does the runtime provide a dedicated kernel per tenant workload, enforced by hardware virtualization, or does it rely on namespace and cgroup conventions over a shared kernel? The answer determines which CVE classes are in scope for the blast radius. Second, the idle cost model. Does the runtime bill reserved capacity or active concurrency, and does storage get charged when the agent sleeps? Snapshot-restore scheduling is the mechanism that makes the second model viable, so evaluate whether the platform exposes pause and resume as a first-class API.
Third, state persistence. Does agent state, files, installed packages, working directory, and credentials, survive a sleep-and-wake cycle, or does each invocation start from scratch? Persistence is a hard requirement for agents that operate across multi-step sessions. Fourth, checkpoint and rollback capability. For agents doing tree search or reinforcement learning exploration, can the runtime checkpoint and restore complete OS state, not just application-level variables, in milliseconds? OS-level checkpoint and rollback is the only mechanism that correctly undoes physical side effects.
Fifth, patch cadence and pin policy. What is the vendor's downstream lag on CVE disclosure for their chosen engine? As Andronchik and Lokhmakov establish, engine-class selection is necessary, but product-level patch policy is the operator-facing variable that determines realized security. Sixth, boot and wake latency. Sub-second wake from snapshot is a hard requirement for responsive agent products. Agents that pause on a tool call and resume in milliseconds are invisible to the user. Agents that cold-start in seconds are not.
A runtime that satisfies all six criteria treats each agent as a first-class, persistent, isolated tenant. That is the per-user agent model this article has argued toward, and it is the direction agent-native SaaS is already heading. The choice between shared containers and per-agent microVMs is not a preference about infrastructure. It is a decision about which guarantees the product makes, and which failures it rules out by construction.


