Dissecting the Isolation Stack Each Agent Cloud Platform Actually Gives You
A dedicated kernel isn't enough; four boundaries must all hold.

Firecracker micro-VM isolation for AI agents gives each workload its own kernel behind KVM hardware virtualization, while containers share the host kernel. This article dissects what that boundary protects and what it does not. Strong agent isolation also needs limits on network access, tenant separation, and task-scoped credentials, because even a dedicated kernel cannot stop an agent from misusing permissions it already has.
Why the isolation boundary is not a feature checkbox but a threat model question
The word “isolation” does real work, but vendors use it loosely. It can mean a process jail or a hardware-virtualized machine with a dedicated kernel. Those boundaries stop different threats. Without naming the boundary, isolation is a posture.
Agent workloads make that ambiguity hard to ignore because they execute shell commands, write files, spawn subprocesses, hold credentials, and make outbound calls in one loop. A human need not approve each step. Evaluating the threats therefore requires examining both what an attacker can send to the model and what the model can do to infrastructure after receiving unexpected instructions. Prompt injection turns the agent’s own privileges into the attack surface, so containment belongs in the execution environment.
The four boundaries that must all hold simultaneously, and why three out of four is not isolation
Four independent boundaries define the test, namely compute, network, tenancy, and credentials. Each earns a pass, partial, or fail. A pass means the required control is in place and enforced, while partial means it covers only some cases or depends on how it is configured. A fail means the workload does not have the boundary it needs. Even with three passes, one exposed path is enough to fail the test.
The compute boundary separates untrusted execution from the host. A shared-kernel container fails that test, while gVisor and a Firecracker microVM each pass in a different way and with different strengths. Network isolation, even inside a microVM, requires default-deny egress with explicit FQDN allowlists, no lateral reach to sibling workloads, and no route to the cloud metadata endpoint at 169.254.169.254. Access to it can expose credentials that turn a contained agent into an actor with instance-level access.
Tenancy and credentials close different gaps again. The Kubernetes project’s multi-tenancy guidance treats namespaces as control-plane segmentation and points to sandboxed containers for tenants that do not trust each other. A namespace, VPC, or account per agent or environment therefore addresses tenancy. Credentials must be short-lived, scoped to the task, provisioned at runtime, and revoked at completion. An over-scoped token or open egress path is more likely to cause a failure than an exotic escape, because the agent can misuse access it already has without breaking its compute sandbox.
What runtime isolation options exist for untrusted AI agents in production?

Tier 1 is an OS process sandbox, including Seatbelt on macOS and bubblewrap on Linux/WSL2. It restricts system calls and filesystem paths without separating kernels. Its protection is narrower than it can sound. Anthropic’s documentation states that Claude Code’s Sandboxed Bash tool covers shell commands, but not file tools, MCP servers, or hooks. Anthropic also says that most of the machine, including credential files, can still be read unless those reads are explicitly blocked. Native Windows runs unsandboxed under this tier.
Tier 2 is a dev container or Docker container, which separates filesystems and process namespaces but shares the host kernel. That shared kernel remains the escape route. A kernel vulnerability can expose the host, so this tier is good enough for low-risk development but falls short for adversarial code or compliance-sensitive multi-tenancy. Tier 3, gVisor, instead uses a user-space implementation of the Linux kernel API. It offers meaningfully stronger containment than a standard container, but less protection than Firecracker against a determined kernel-level escape attempt, making it a cost-performance choice.
Tier 4 is the Firecracker microVM, an AWS open-source project written in Rust. It uses KVM hardware virtualization through Intel VT-x or AMD-V to give each workload a dedicated guest kernel. Escape requires breaking through both the guest kernel and the hypervisor, making this tier the 2026 baseline for untrusted code, regulated data, and adversarial agent workloads. Kata Containers microVMs belong in the same isolation class because they also provide a dedicated guest kernel and hardware virtualization.
Tier 5 is a full VM or dedicated hardware, with the strongest isolation and the highest per-session cost and startup time. It fits persistent workloads needing a full graphical desktop. V8 Isolates sit outside this ladder. They suit latency-sensitive JavaScript/WebAssembly tasks, while general-purpose agent execution requiring a filesystem or subprocesses needs another runtime. Stronger boundaries generally cost more or take longer to start, so the choice depends on the workload, and builders must specify which tier the production path actually uses.
How the Antigravity escape and similar CVEs map to specific tier failures
CVE-2025-59528, with CVSS 10.0, shows how application-level controls fail when the execution environment is not isolated. Microsoft’s disclosure of CVE-2026-25592 describes how prompt injection in an agent framework led to host-level remote code execution. The relevant surface is the subprocess or system call. These cases expose the gap in relying on application checks above execution that remains insufficiently contained.
That pattern explains why Tier 1 and Tier 2 are insufficient for adversarial code. A narrow process sandbox cannot protect execution surfaces outside its scope, while a container cannot provide a separate kernel. The attack need not break the advertised sandbox. It can route around it through an uncovered subprocess, filesystem path, or credential environment before the intended runtime check evaluates the action. Stronger compute isolation closes part of that gap, but credential misuse and unrestricted outbound access still require their own controls.
Applying the four-boundary rubric to the platforms builders actually use in 2026
Amazon EKS with gVisor, VPC, and IAM offers control at the cost of assembly work. Its compute boundary passes at Tier 3, below Tier 4. VPC and workload identity provide controls for tenancy and credentials, but their presence alone does not establish default-deny egress or task-scoped token revocation. Those boundaries stay partial until the settings in use enforce them. This fits teams that have the engineers to connect and take care of every layer.
Google Cloud GKE Sandbox also passes the compute test at Tier 3 because its pods run under gVisor. VPC and Workload Identity Federation provide the surrounding network and identity controls. Against the rubric, network, tenancy, and credentials remain partial until their actual settings meet the workload’s requirements. A managed sandbox does not remove the need to inspect those settings.
Qovery operates at the cluster and cloud-account layer, deploying workloads into the customer’s AWS, GCP, Azure, or Scaleway account, or an existing Kubernetes cluster. Per-environment namespaces and RBAC support a tenancy pass at the environment level. Compute depends on how the underlying nodes are configured. Environment-scoped secrets provide partial credential separation, while short-lived per-run tokens require verification and egress needs independent evaluation. Destroying ephemeral environments when a task ends limits how long they live, but leaves the other boundaries to be enforced.
Persistent computer-use agents need resumable machines that sleep when idle and keep their state, with charges based on actual usage. Ephemeral sandboxes serve a different workload shape. For code-execution architectures, a microVM for code the model writes can complement a platform in the customer’s account for code the team writes. Neither layer replaces the other’s responsibilities.
What the snapshot-and-fork pattern adds to isolation — and the new attack surface it opens
Snapshot-and-fork is now standard for parallel evals and RL rollouts. A known-good environment, with dependencies installed and the project built, becomes the starting point for separate runs. Each copy starts from the same state. The pattern works for eval shards, CI parallelism, and best-of-N agent runs, but how safe it is depends on who can change that starting state. When a template is compromised, every fork inherits that compromise.
Amazon’s Rufus-Air RL training stack documents one Firecracker microVM per sandbox, with each task baked into a snapshotted template before training. Creation resumes that template rather than cold-booting it, and the control plane runs on separate machines from untrusted workloads. The Kimi K3 technical report documents AgentENV achieving snapshot timings of a minimum 49ms resume and 133ms incremental checkpoint.
Firecracker trusts snapshot files completely, so they must be signed, checked before they are loaded, and kept where a guest cannot write to them. An arXiv 2026 paper describes a related attack class involving checkpoint and rollback mechanisms documented by CrewAI, Gemini CLI, and Hermes Agent. Manipulating execution continuity can let adversarial input persist across what appears to be a fresh environment. Snapshot provenance therefore extends the isolation model beyond the running machine.
Computer-use agents on Windows, Linux, and Android — where the isolation stack changes shape
Computer-use agents work through a graphical desktop. Desktop infrastructure supplies Linux, Windows, occasionally macOS or Android, streamed through VNC or a browser, with screenshot, mouse, and keyboard APIs. The platform supplies the machine and its boundary. The builder configures the agent that operates it, while the desktop session also needs protection. If that session persists so an agent can stay logged in, it also needs protection from lateral access by other agents or users.
Microsoft Build 2026 introduced two relevant structures. Windows 365 for Agents is generally available within Agent 365 and gives agents Cloud PCs for software workflows that take more than one step. Project Solara targets consistent agent operation across Windows, Linux, macOS, mobile devices, and the web. It uses Microsoft’s Device Ecosystem Platform, an enterprise-grade OS built on AOSP, with an agent shell, Intune management, Entra ID, and Hello for Business biometric authentication. These structures change the execution environment, but do not collapse the four boundaries into one.
Microsoft’s UFO³ framework coordinates GUI agents across Windows, Linux, and Android through dynamic task graphs and parallel steps. It is orchestration, not an isolation layer. Its relevance is that it determines which device-level boundaries a task crosses. For healthcare computer-use agents navigating electronic health record systems or payer portals, screenshots containing protected health information must stay under an endpoint and log store covered by a healthcare data protection agreement. The desktop’s VM perimeter is therefore only part of the protection needed around the session and its data.
Matching isolation tier to workload — a decision framework for agent builders
The practical choice starts with three questions. Does the workload execute untrusted or model-generated code? Does it hold state across sessions? Does it operate software through a GUI?
For single-task, throwaway execution of untrusted code, the choice is a Firecracker microVM or equivalent, deleted with its disk when the task ends. gVisor is acceptable for cost-sensitive multi-tenant workloads where compliance and the threat model do not demand full kernel separation. Parallel evals and RL rollouts fit snapshot-and-fork on microVMs with verified, pre-built templates. Snapshot custody belongs in that decision from the start. Long-running agents instead need machines that keep their state and have sleep-and-wake, while Windows legacy apps, Citrix environments, and phone-only apps need a desktop VM that each agent or end user can resume.
Builders should establish whether compute shares a kernel, whether egress is default-deny, whether tenancy is per agent or environment, and whether credentials expire and are revoked with the task. Snapshot users must also establish signing, provenance, and storage isolation. A microVM fails this test if it has open egress and a long-lived root token. Isolation is an engineering decision, and an honest platform evaluation starts with naming the threats the workload must survive.


