Computer-Use Agent Sandboxing Requirements

Four hardware-enforced isolation layers keep injected agents from causing harm.

· 10 min read · Updated
Cover illustration for “Computer-Use Agent Sandboxing Requirements”
Browser Agent Architecture · October 2, 2026 · 10 min read · 2,266 words

A computer-use agent is dangerous because its mistakes don't stay on screen, not because it reasons better than a chatbot. This piece lays out why that distinction demands a different security architecture, built on four isolation layers enforced at a level the agent itself can never reach.

Computer-use agents face a more severe threat model than ordinary LLM apps

An ordinary LLM app produces text. If it gets something wrong, the user reads a bad answer, maybe winces, and moves on. Nothing in the world changes because of it. A computer-use agent produces actions. It clicks Confirm Purchase. It sends the email. It deletes the folder. It submits the form. These are changes to the world, and a meaningful share of them cannot be undone once they happen. That gap between a wrong sentence and a wrong action is the entire reason this category of system needs a different security posture than a chatbot does.

The danger deepens once you account for where the agent gets its instructions. It reads whatever is on the screen in front of it and treats that content as guidance for what to do next. A web page, an email, a pop-up window: any of these can carry hidden instructions the agent will follow as if they came from its actual user. This is prompt injection, and aimed at a system that can only talk, it's a nuisance. Aimed at a system that can push buttons, it's a vector for real-world harm. A screen that looks clean to a person checking it over can still carry an active instruction set for the agent reading the same pixels. Visual confirmation by a human doesn't catch what the model is actually parsing.

The clearest illustration of what this looks like in practice comes from a security researcher's documented work, first discussed at a security conference. Claude was given a normal browsing task and navigated to a page an attacker had set up. The browser-based approach did, and the full chain completed on a machine with no sandbox around it. That sequence, prompt to download to execution to outbound connection to a server built for exactly this purpose, is what "irreversible action triggered by adversary-controlled input" looks like when it's no longer theoretical.

Why the attack surface is active rather than passive, and what that means for the security boundary

Enterprise security perimeters were built around two kinds of actors: human users and the applications they run<sup>3</sup><sup>4</sup><sup>1</sup><sup>2</sup>. An agent is neither. None of the assumptions the old perimeter was built on apply to a system that behaves this way.

That difference is what makes the attack surface active instead of passive. A passive attack surface requires the adversary to break into the model itself, to compromise weights or steal access. An active attack surface requires nothing of the sort. The adversary just needs to influence what the agent sees or reads, since the agent will treat that content as something to act on. A poisoned web page or a manipulated email accomplishes what an actual intrusion into the model would otherwise require.

Standard containers don't close this gap on their own. A control that lives at the same layer as the thing it's supposed to constrain can be talked around by the same adversarial instructions the agent is already following. A microVM takes a different approach: its isolation is enforced by hardware, at a layer the agent's reasoning cannot reach, so no instruction the agent receives, however cleverly worded, can touch it.

The practical choices form a hierarchy, from weakest to strongest: an OS process sandbox, a container, a gVisor user-space kernel, and a Firecracker microVM. gVisor runs a kernel implemented in user space, stronger than a bare container but still short of full hardware virtualization. Each step up this ladder costs more in performance overhead and buys a security boundary that sits at a lower, harder-to-reach layer. Amazon's Bedrock AgentCore Runtime is one concrete deployment of this idea: it runs each AI agent session inside its own Firecracker microVM, on the principle that one session gets one microVM, isolated in CPU, memory, and filesystem from every other session and from the host itself.

The fair objection here is that containers handle most workloads just fine, and microVMs add operational complexity that most teams don't need. That's a reasonable position for a trusted internal service running code your own team wrote. It stops being reasonable once the workload is a computer-use agent executing instructions that may have been shaped by an adversary somewhere in its input, on a machine with real credentials and real data on it. Sandboxing, in this context, is a stack of four separate isolation boundaries, each closing off a different path an injected agent could take, and the rest of this piece works through each one.

Network egress controls that limit where an injected agent can reach

The first and most externally visible of the four layers is network egress. An agent with no restriction on outbound traffic can call any endpoint its host machine can reach, and that's the default condition unless someone has deliberately locked it down. Data exfiltration attacks built on prompt injection succeed for exactly this reason: the injected instruction doesn't need to do anything sophisticated. It just needs to tell the agent to make an HTTP request to a server the attacker controls, and an agent with unrestricted egress will do it.

A browsing agent operating without a sandbox is especially exposed here, since it spends its working life on adversarial content by definition, pages built by people other than its user. The instruction driving it is the problem, regardless of the credential it's using.

The fix isn't telling the agent not to call bad endpoints. An instruction like that lives in the same reasoning layer the attacker is already manipulating, so it offers no real guarantee. With a real allowlist in place, an attacker's command-and-control endpoint is simply unreachable, regardless of how convincing the injected instruction is. A sandbox that still has open network access remains exploitable for exfiltration no matter how locked down everything else is, so the enforcement has to sit at the network layer itself, inside an egress proxy or a network namespace, not inside a policy the agent is merely asked to follow. A microVM's network namespace isolation delivers a stronger version of this same guarantee than a container's network policy does, because it operates below where the agent's reasoning can interfere with it.

Filesystem boundaries that prevent an agent from modifying what executes at startup

The second layer concerns what an agent can write, not just what it can read. Reading sensitive files is a real risk on its own:.env files, SSH keys, any secret sitting unprotected on the machine are all fair game for an agent with filesystem access. But the deeper danger is write access to files that have consequences down the line, files that get executed automatically the next time something starts up.

A sandbox escape found in Google's Antigravity tool shows how this plays out. An agent with write access to the filesystem could stage a malicious script inside its own workspace. The security check existed. It simply ran too late to matter.

NVIDIA's own guidance on this subject calls out configuration files directly, naming hooks, skills, and local MCP configurations as zones that need write protection, precisely because these files get executed at startup or by developer tools before any runtime security check even runs. Anthropic has acknowledged a related limitation in its own sandbox isolation approach: any sandbox that mounts a writable project directory leaves the code inside that directory open to modification, whatever other restrictions are layered on top.

The enforcement options here fall into a clear hierarchy. MicroVM-level enforcement is the strongest of the three: it gives the agent a filesystem that is physically separate from the host, so writes made inside the microVM have no path to the host's dotfiles, hooks, or configuration directories. For agents that persist across multiple sessions, the microVM's snapshot-restore mechanism keeps the agent's disk state persisting across sessions inside the VM boundary, never touching the host.

Secrets scoping that ensures an agent only ever holds the credentials its current task requires

Even a system with airtight network egress controls and airtight filesystem boundaries leaves one gap open if it hands the agent the same credential environment the host itself runs with. An agent that inherits the full set of host credentials can reach every API key, every cloud role, every database connection string available to its process, regardless of how locked down its network and filesystem otherwise are.

The mechanism most developers underestimate here is the child process. Environment variable leakage is a documented gap even in agents that are otherwise sandboxed: a secret passed as an environment variable to a parent process is available to be exfiltrated by any child process that process spawns, whether or not that child process needed it for its actual job.

The right fix is the same principle of least privilege applied specifically to credentials. NVIDIA's model for solving this is to inject credentials at runtime, scoped to the specific task at hand, so the secret arrives only when the task starts and disappears when it ends, rather than sitting in the process environment at rest the whole time. A credential rendered visibly in a UI element is just as accessible to it as one sitting in an environment variable would be. The enforcement for this has to live at the orchestration layer, in the system that schedules and launches each agent task, and that system is responsible for injecting only the credentials that particular task's tool catalog actually requires, never a general-purpose credential set handed out by default. The complexity here is infrastructure built once.

Configuration file protection that closes the gap between runtime controls and startup execution

The fourth layer is the hardest one to reason about, because it concerns files that execute before any runtime security check has a chance to run. Dotfiles, hooks, and tool configuration directories fall into this category, and an agent with the filesystem write access described two sections back can plant a modified version of one of these files that executes in some future session, carrying the developer's full privileges, entirely outside whatever sandbox had been active when the original write happened<sup>3</sup><sup>4</sup><sup>1</sup><sup>2</sup>.

This is the exact reasoning behind NVIDIA's guidance naming dotfiles, hooks, and MCP configuration directories as write-protected zones. They're code that runs on the developer's behalf before any security control has engaged. The Antigravity vulnerability is the concrete case that makes this tangible: find_by_name was classified as a native tool rather than a shell command, so it invoked the fd binary underneath it before Secure Mode's command-level restrictions were ever evaluated. A restriction that only engages after startup offers no protection if the file it should have caught was already modified in a prior session. Application-level security policies generally have no visibility into subprocesses spawned by native tool calls. Kernel-level isolation is what actually stops a subprocess like that from escaping to the host.

MCP configuration directories deserve particular attention as a growing target. The fix mirrors the filesystem protections already described, but it has to be applied specifically to these startup-adjacent paths: read-only mounts on dotfile directories, hooks directories, and MCP configuration paths, enforced at the microVM or OS layer rather than left to agent policy. Multiple vendors have converged independently on naming this same set of paths as the ones that need protecting, a sign that this isn't one team's house opinion but an emerging consensus among the organizations building and securing these systems.

Hardware-enforced isolation below the agent's reasoning layer is the architectural requirement all four layers point toward

Diagram: Four Isolation Layers, From Weakest to Strongest. Visualizes: Visualize a hierarchy of four security isolation layers for computer-use agents, showing how each layer addresses a distinct attack path and where enforcement must sit.

The pattern repeats without exception across where each of these four layers lands. Network egress enforcement only holds if it happens outside a proxy or network namespace the agent cannot influence through anything it's told to do. Filesystem protection only holds if the write boundary is a property of the virtual machine itself, not a policy the agent is asked to respect. Secrets scoping only holds if credentials are injected by an orchestration layer the agent has no access to, rather than inherited wholesale from the environment it runs in. Configuration file protection only holds if the read-only mount is enforced at the microVM or OS layer, because anything enforced later than that arrives after the file has already been rewritten.

Every one of these mechanisms resolves to the same requirement: the control has to sit below the layer where the agent reasons. A policy, a denylist, an instruction telling the agent what not to do, all of these live in the same space the agent's reasoning lives in, and an adversary who can influence that reasoning through an injected prompt can influence anything built at that same layer. A boundary enforced by hardware, through a microVM's isolated CPU, memory, and filesystem, doesn't share that space. Firecracker's microVMs, gVisor's user-space kernel, and the broader hierarchy running from OS process sandboxes up through containers were all built around the same idea: the strength of an isolation boundary is a function of how far it sits from the agent, not how cleverly it's written. That's the architectural requirement every one of the four layers, network, filesystem, secrets, and configuration, converges on. A computer-use agent capable of taking irreversible action in the world needs a security boundary it cannot reason its way around, because reasoning around boundaries is the one thing these systems are already demonstrably capable of doing.

Sources

  1. Firecracker
  2. Practical Security Guidance for Sandboxing Agentic Workflows and Managing Execution Risk
  3. CaMeLs Can Use Computers Too: System-level Security for Computer Use Agents
  4. Sandlock: Confining AI Agent Code with Unprivileged Linux Primitives
  5. Treat Your Agent Like an Insider Threat: Why AI Sandboxing Can't Wait - Coalition for Secure AI
  6. AI Code Sandboxes: A Comparative Security Study. Part 1 of 2 -- Engine-Level Properties (Attack Surface, Leakage, Stackability, CVE History, Patch Cadence, Fuzzing)
  7. Sandboxing AI Agents: 3 Essential Production Controls for Engineers

More in Browser Agent Architecture