AI Engineer Code 2025
YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker
Loading slides…
Read the talk
YOLO Mode, Safely: MicroVM Sandboxes for Any Agent
Rowan Christmas shows how a coding agent reached sensitive information on his Mac, then repeats the browser-history search inside Docker Sandboxes. The difference comes from controlling what the agent can access, while preserving a familiar coding workflow.
From a talk by Rowan Christmas
At a glance
Ideas worth remembering
A warning does not remove file access. In Christmas’s five-prompt experiment, changing the request’s framing let the agent continue investigating sensitive local information.
MicroVM isolation changes what the agent can discover. The browser-history search succeeded on the host and found no browser inside the demonstrated sandbox.
Secret placeholders, network policy and audit trails address different parts of agent execution: credential exposure, permitted connections and recorded activity.
Read-only mounts let an agent understand related repositories while requiring its solution to work with their existing APIs.
Five prompts from browser history to bank information
A coding harness that sometimes refuses a dangerous request can make its environment feel safer than it is. Rowan Christmas, a product manager at Docker, tests that assumption by asking his own agent to investigate his own Mac. The question is concrete: how far can an agent get into personal information while operating through a tool he expects to protect him?
The first request is to find browser history. The agent finds it immediately. A follow-up asks what can be done with that information, and the investigation moves into banking activity. Christmas reports that it identified his banks, recent check ordering, use of Zelle and the last four digits of an account. He substitutes fake bank names in the presentation; the underlying discovery, he says, involved his real information. This demonstrates access to sensitive local information, without establishing that the agent logged into a bank or could move money.
The next day, Docker’s security team sends him an alert because the activity looks like a compromised computer. The CrowdStrike report gives it a nine-out-of-ten score, prompting Christmas’s joke that he did better here than in most of his classes. The important consequence is that a deliberately initiated agent session produced behavior recognizable to endpoint security as a credential-access technique. This experiment began with his own requests; it was not a demonstrated prompt injection from a script or MCP server.
The sequence took five prompts, with some care in how they were phrased. A direct request to find bank data elicited a warning. Framing the activity as security research let the investigation proceed. That change in wording altered the agent’s willingness to act without removing its access to the files. A refusal can interrupt one request, but the underlying permissions still determine what a later request can reach.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Move protection into the environment the agent runs in
Docker’s proposed answer is sbx, a command-line tool that runs the agent in a microVM. The VM has its own kernel and an isolated filesystem. This changes the available environment before the agent decides what to do: files outside that environment are not simply waiting behind a warning that another prompt might bypass.
The protection combines several mechanisms with different jobs:
- Kernel and filesystem isolation. The microVM runs its own kernel and separates the agent’s filesystem view from the host’s files.
- Secret placeholders. The sandbox receives a placeholder rather than the real secret. When a network request needs that credential, Docker’s system replaces the placeholder, keeping the secret value out of the sandbox and the agent’s direct view.
- Audit trail. Activity is recorded so there is a history to inspect, rather than only the agent’s explanation of what it did.
Secret substitution addresses a practical tension: an agent may need an authenticated request to do useful work, while giving it the credential itself creates another thing it can read and misuse. The talk describes the placeholder-and-replacement mechanism, but does not specify its destination checks or substitution rules. Its supported promise is narrower than preventing every harmful authenticated action: the agent need not possess the real secret to make the request.
The balancing act matters. Remove every useful capability and the agent cannot accomplish its task. Leave the whole laptop within reach and the banking experiment becomes possible. The sandbox makes the working environment a deliberate choice: expose the resources needed for the job, then let the agent operate within that environment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Repeat the browser-history search inside the sandbox
What changes in the everyday workflow? Christmas compares launching claude with launching sbx run claude. The latter creates a new VM, starts a sandbox in the selected folder and runs the agent there. The agent interface looks much the same; permission bypass is enabled in the sandboxed demonstration. The convenience comes from letting the environment constrain access while the agent works with fewer interruptions.
The browser-history example now has an observable before and after. On the host, the agent finds browser history and can continue investigating it. Inside the sandbox, the same search does not even lead the agent to believe a browser is installed. The causal step is the changed filesystem view: creating the VM does not place the Mac’s browser installation and personal history within the agent’s reach. The request can remain ambitious while the accessible files become smaller.
Why does the same request produce different results? The comparison below follows the search through its two environments. The host path reaches personal history; the sandbox path reaches a filesystem where that browser history is unavailable. The difference lies in what the tool can discover, rather than whether a carefully worded request receives a warning.
One browser-history search, two filesystem views
Read the diagram as text
- Agent on the Mac. Host — Asked to find browser history.
- Browser history found. Host — Local information becomes available for further investigation.
- Banking information surfaced. Host — Reported discoveries include check ordering, Zelle use and account digits.
- Agent launched with sbx. Sandbox — The command creates a VM and runs the agent inside it.
- Isolated filesystem. Sandbox — The agent searches the sandbox’s filesystem view.
- No browser discovered. Sandbox — The demonstrated search cannot find the host browser history.
- Agent on the Mac → Browser history found: Search succeeds.
- Browser history found → Banking information surfaced: Follow-up investigation.
- Agent launched with sbx → Isolated filesystem: Runs inside the VM.
- Isolated filesystem → No browser discovered: Repeat the search.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Network policy limits where the agent can connect
Filesystem isolation leaves another route to consider: network access. Christmas asks the agent to look up the Pirate Bay, expecting the destination to be blocked, and the sandbox blocks it by default. This illustrates an independently enforced connection policy. Even if the agent agrees to make a request, the environment can deny the destination.
He also points to blocked telemetry requests that he identifies as Claude traffic to a Datadog instance. The example makes background connections part of the same policy discussion as explicit browsing requests. It does not establish the contents or volume of those telemetry payloads, so the useful observation is that the sandbox can block those outbound connections, rather than a quantified claim about data sent to Anthropic.
These defaults are configurable. That is necessary for a development environment whose useful work may include network requests, and it makes policy choices consequential: allowing more connections increases what the agent can do. Christmas reports that every Docker developer now writes code in sandboxes. His operational preference is to enforce restrictions at the microVM, before agent activity reaches the host, while keeping the workflow easy enough to use every day.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connect agent actions to authorization and policy
Isolation answers what an agent can reach. Governance adds another question: why was a particular action allowed? Christmas previews agent identity tracking and delegation chains that would connect an action to the agent that performed it and the human who authorized that agent. The intended result is an explanation that follows authorization through the chain, with policies able to restrict permitted actions as circumstances change. The talk sketches this direction without developing the policy-evaluation procedure.
A governance mock-up brings together three controls described as available at the time of the talk:
- Network allow and deny rules. Decide which connections the environment permits.
- Filesystem access controls. Decide which filesystem resources the agent can access.
- MCP catalog selection. Decide which MCP servers are available to the agent. Docker’s MCP servers themselves run in sandboxes, so those servers are also subject to the controls.
The MCP detail extends the protection to a tool’s execution environment. An agent may invoke a server to do work on its behalf; sandboxing that server gives governance another place to constrain access. Selecting the catalog determines which tools are offered, while governing the server determines what the selected tool can reach when it runs.
Two finer-grained controls remain future work in the recording: L7 networking controls and filesystem permissions organized around individual GitHub repositories, including different areas within a repository. The repository example makes the desired granularity clear: an agent might read and write one area while being excluded from another. Christmas distinguishes those planned additions from the working sandbox demonstrations shown earlier.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Start with installation and local agent workflows, then inspect the architecture, credential handling, network policies and sbx command reference.
Full transcript
Loading transcript…