Hands Off Development

What Separates a Real Isolated-VM Agent Platform From a Shared Container That Just Returns a Pull Request

Real agent isolation needs four boundaries, and containers alone fall short.

· 8 min read
Cover illustration for “What Separates a Real Isolated-VM Agent Platform From a Shared Container That Just Returns a Pull Request”
Cloud Agent Environments · November 18, 2026 · 8 min read · 1,846 words

Migrating engineering teams from local to cloud coding agents requires evaluating both the execution environment and the pull requests it returns. For teams moving coding agents off developer laptops, real isolation requires four boundaries enforced together, namely per-agent compute sandboxing, default-deny egress, per-tenant network separation, and per-run credential scoping. A pull request is a reviewable output whose execution boundaries still require verification.

Why returning a pull request does not make a platform an isolated-VM agent platform

A clean pull request can conceal an uncontrolled execution environment. Its diff does not reveal which network paths were open, which credentials were available, or whether a prompt-injected instruction could have redirected those privileges. Code review’s scope is limited to the proposed change.

That distinction changes the security question for engineering leaders. An agent that reads repositories, runs shell commands, installs packages, and calls external APIs is an execution environment with a language model attached to it. Engineering leaders must assess what it can touch when it is wrong, manipulated, or overconfident. The dominant failure mode is not necessarily a container escape. An over-scoped credential or an open egress path can let a prompt-injected agent exfiltrate data without ever leaving its sandbox.

Why shared-kernel containers are not a sufficient boundary for agent workloads

Shared-kernel containers provide packaging and resource control, but they are not a sufficient security boundary for agent workloads. Every container on a host shares the same kernel. A kernel exploit, a rogue capability, or a mis-mounted socket can therefore expose the host and other tenants’ data. Hundreds of syscalls are exposed, so the shared attack surface is still there even with namespace separation.

CVE-2024-21626, known as Leaky Vessels, is a runc container escape that gives access to the host filesystem. NVIDIA’s description of CVE-2024-0132 identifies a Time-of-check Time-of-Use vulnerability in its container toolkit that can give a crafted container image access to the host filesystem. CVE-2025-23266, known as NVIDIAScape, is another NVIDIA container toolkit flaw leading to privilege escalation, with CVSS 9.0. These failures occur below the agent’s instructions.

A runc masked path race condition allows arbitrary host procfs path bind-mounting through symlink substitution. CVE-2025-38617 is a Linux kernel packet socket race condition that causes use-after-free, which allows full container escape through user namespaces. Firecracker, written in Rust, makes a fresh microVM per agent session operationally practical through low boot times and memory overhead. A container inside a VM reconciles the two needs, giving developers a container while providing a VM boundary.

The four boundaries that together constitute real isolation

The rubric has four independent criteria, enforced simultaneously. Boundary 1 is per-agent compute sandboxing, with each session in its own microVM or an equivalent sandbox. A Firecracker microVM passes this criterion through hardware isolation. A gVisor user-space kernel also passes, although with a different isolation strength. Plain namespace isolation does not pass this test.

Boundary 2 is default-deny egress, with outbound traffic blocked except to an explicit allowlist of fully qualified domain names, or FQDNs. The cloud metadata endpoint and sibling workloads must remain unreachable. Boundary 3 is per-tenant network and namespace separation, so an environment’s failure stops at its tenant boundary. A namespace alone does not establish that separation. Boundary 4 is per-run credential scoping, using short-lived secrets injected for one run rather than long-lived keys stored inside the sandbox.

These criteria distinguish three terms that are often conflated. A sandbox is the compute boundary around one run, while tenancy describes who shares a namespace, VPC, or account. Isolation is the combined four-boundary property. Passing three criteria cannot make up for failing the fourth, because each missing control leaves another way for things to go wrong. The framework is a diagnostic for assessing a platform through examination of its infrastructure.

Diagram: The Four Boundaries of Real Agent Isolation. Visualizes: Show four named boundaries that must all be enforced simultaneously to constitute real isolation for cloud coding agents.

What breaks when per-agent compute sandboxing is missing or partial

In a shared-kernel container, the agent’s useful capabilities also expose the shared host surface. Writing scripts, installing packages, manipulating file descriptors, and spawning subprocesses all operate through that kernel. Other workloads depend on the same underlying boundary. With shell and network access alone, an agent can also read secrets, run unsafe commands, and attempt exfiltration. Prompt injection can redirect capabilities the agent already possesses.

Thomas Winninger’s 2026 paper, Steerability via constraints: a substrate for scalable oversight of coding agents, argues that prompt-level defenses do not stop indirect prompt injection, secret exfiltration, arbitrary script execution, or malware delivery once an agent has CLI access. Machine-layer controls enforce limits that instructions cannot grant or revoke. Permission dialogs are not an equivalent enforcement layer. When approval rates are very high, those dialogs become ceremony. The sandbox must constrain execution independently of approval habits.

Different sandbox mechanisms still provide different levels of protection. gVisor intercepts every syscall through its user-space kernel, reducing the exposed host surface from the full Linux kernel interface to around 68 syscalls. It reduces rather than eliminates shared-kernel exposure, but materially raises the cost of breakout compared with plain namespaces. A team evaluating a platform should therefore check which mechanism it uses. A guest kernel and a user-space kernel are different answers, while “containers with namespaces” fails the compute criterion.

What breaks when egress is not default-deny

A microVM can prevent host escape while still allowing secret exfiltration. If an agent can send data to an attacker-controlled endpoint over an allowed path, the compute boundary can remain intact throughout the incident. Network access therefore needs its own enforcement.

Coding agents need network access for ordinary work, including dependency installation, documentation retrieval, LLM API calls, and GitHub queries. Without an explicit policy, those useful capabilities also provide an outbound route for stolen data. The cloud metadata endpoint at 169.254.169.254 is a specific target because access can expose cloud credentials broader than the agent’s intended privileges. An FQDN allowlist limits access to required services, while the metadata endpoint must be explicitly blocked.

The evaluation should check whether outbound traffic is blocked from the start and then allowed for each destination. “Open by default, with optional policies” fails this criterion. The control must be a network constraint enforced independently of instructions asking the agent to avoid certain destinations. Open egress and over-scoped credentials form complementary parts of the same failure path, providing a route out and authority worth stealing. Even with that outbound route constrained, however, tenant separation needs separate examination.

What breaks when the network and tenancy boundary does not hold under misbehavior

Default-deny outbound access does not by itself prove that another tenant is unreachable. Kubernetes namespaces partition API objects and can gate RBAC, but they do not stop cross-namespace process traffic unless NetworkPolicies are explicitly applied. Kubernetes multi-tenancy guidance points to sandboxing for tenants that do not trust each other.

The tenancy architecture therefore needs one namespace, VPC, or account per agent environment, backed by default-deny NetworkPolicies and workload identity replacing static keys. This architecture should contain a failure within one tenant’s boundary. Enforcement belongs to the infrastructure. Firewall rules, VPC routing tables, and NetworkPolicy provide concrete mechanisms to examine when evaluating that claim. A policy that depends on the agent choosing to comply does not pass.

Misbehavior is the decisive test of this distinction. An agent may loop, retry aggressively, or follow a prompt-injected instruction, but none of those actions should dissolve its network boundary. Winninger’s paper distinguishes infrastructure constraints from instructions whose effect depends on agent behavior. The same principle applies to identity in the next boundary. Both network separation and credential limits must hold even when the agent misbehaves.

What breaks when credentials are not scoped to a single run

A long-lived credential inside a sandbox can preserve an attacker’s access after the sandbox disappears. Ending compute does not end the credential’s authority. If an attacker compromises the sandbox during a run, or exfiltrates a key before network enforcement activates, the key can remain useful after the session ends. Strong compute and tenancy controls cannot correct its lifetime.

A prompt-injected agent can read a long-lived token from its environment and send it to an attacker-controlled endpoint before an egress policy is evaluated. The attacker then keeps access even though the compute boundary was never breached. Per-run credentials limit that persistence. The correct model uses short-lived, identity-federated or projected tokens, scoped to one run and injected at session start, with expiration at session end.

An engineering leader’s credential audit should check whether those limits on lifetime and scope are in place. It should also establish whether the agent process can enumerate other secrets in the environment. Even a token with a short lifetime must have limits on what it can do. The platform must be able to show which credentials were in scope for each run, and inability to answer these questions fails the credential criterion. Audit logs provide that evidence after the fact, but they do not enforce the boundary themselves.

How do engineering teams evaluate a move from local to cloud coding agents?

A team leaving local assistants should ask vendors for infrastructure evidence that shows how they meet the four criteria. Vendors should specify whether each session receives a Firecracker microVM, a gVisor sandbox, or merely a shared-kernel container. Vendors should explain whether traffic is denied by default, allowed per FQDN, and explicitly blocked from the metadata endpoint. The implementation must explain what prevents the prohibited action.

Vendors should explain whether firewall rules, VPC routing, or NetworkPolicy enforce separation independently of the agent. Vendors should explain whether tokens are injected for one run, expire at session end, and exclude access to other secrets. All four answers must describe the same environment in which the agents run. A strong compute answer cannot stand in for missing identity or network controls. Likewise, a pull-request integration proves only a delivery workflow.

Sandbox runtimes designed for ephemeral code execution can address compute isolation strongly while leaving tenancy and credentials for the adopting team to configure. Long-running agents need the full set of boundaries from startup through tasks spanning minutes to hours. Governance supplies the supporting evidence through audit logs, SCIM provisioning, and reviewable recordings of agent activity. Without that layer, an engineering leader is being asked to trust a boundary that cannot be adequately examined after a run.

What the four-boundary framework means for teams running agents at scale

These controls make parallel, automated agent work operationally viable. Agents can work on schedules, respond to events, and use production credentials without requiring a human at the keyboard for every session only when their authority is bounded independently of their behavior. The pull request remains the unit of review. A human can merge, comment, or send it back, while infrastructure constrains what happened before that review.

Winninger’s paper argues that access control, network policies, and strict coding conventions enforced by tooling work for coding agents just as they do for human engineering teams. The underlying discipline is established, even though the workload is new. Migration therefore need not trade developer autonomy for uncontrolled execution. Verifying all four boundaries gives engineering leaders a basis for more parallelism, more automation, and less dependence on continuous supervision. Isolation is what makes it possible to say yes to more agents.

Sources

  1. Steerability via constraints: a substrate for scalable oversight of coding agents

More in Cloud Agent Environments