# YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker

Rowan Christmas, Docker

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/OE_lLNCNfQo-yolo-mode-safely-microvm-sandboxes-any-agent) · [Video](https://www.youtube.com/watch?v=OE_lLNCNfQo)

## 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.

### Five prompts from browser history to bank information

[0:12](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=12s)

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.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 120 seconds](https://ai.engineer/api/talk-essay-media/8714eb6ecfa522e2a87769d2353f71e0b281b2e6476d4306dc3a526254a9e933)

A presentation slide displays a profile and visits table with a blue callout.

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.

### Move protection into the environment the agent runs in

[3:53](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=233s)

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.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 245 seconds](https://ai.engineer/api/talk-essay-media/f2f5dca839dbf7c31b2c32f25f90af6a5e3393895e765c19a01afbffbb581b15)

The slide contrasts informal safeguards with microVM kernel isolation, PII boundaries, proxy secret injection, policy enforcement and an audit trail.

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.

### Repeat the browser-history search inside the sandbox

[4:47](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=287s)

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.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 362 seconds](https://ai.engineer/api/talk-essay-media/bf692f7fb98265b1da32a13a6f0e0604e0dbc80741d9205bda53fc1366abffd9)

In the sandboxed example, the agent says it does not think a browser is installed.

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
The sandbox changes the resources available to the search before the agent can use them.
- Agent on the Mac — Asked to find browser history.
- Browser history found — Local information becomes available for further investigation.
- Banking information surfaced — Reported discoveries include check ordering, Zelle use and account digits.
- Agent launched with sbx — The command creates a VM and runs the agent inside it.
- Isolated filesystem — The agent searches the sandbox’s filesystem view.
- No browser discovered — 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)

### Network policy limits where the agent can connect

[6:14](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=374s)

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.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 392 seconds](https://ai.engineer/api/talk-essay-media/0d941c33cf48d1a4b94b7ebf82c82b9f69ee3b7b69ab09d3ed6afd3a4ae50787)

The Docker Sandboxes terminal shows allowed and blocked network requests.

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.

### Connect agent actions to authorization and policy

[7:29](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=449s)

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.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 543 seconds](https://ai.engineer/api/talk-essay-media/258a6609562bd5729062f6e5c762f219132ed0a01ad454f7299fdec26a921732)

A governance slide shows network, filesystem and MCP catalog controls beside a policy interface.

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.

### Run other workloads and keep related repositories read-only

[9:46](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=586s)

The sandbox is a full VM, so Claude is only one workload it can host. Christmas lists Codex, a shell, a Python job and a web server as other examples, and describes installation on Mac, Windows and Linux. The intended experience is a familiar agent session with protections supplied by the surrounding environment. The supplied [Docker Sandboxes documentation](https://docs.docker.com/ai/sandboxes/) provides practical entry points for installation, agent configuration, architecture, security and the `sbx` command reference.

![Selected presentation frame from YOLO Mode, Safely: MicroVM Sandboxes for Any Agent — Rowan Christmas, Docker at 634 seconds](https://ai.engineer/api/talk-essay-media/e941d35bc54a25b05dd85f0d9baab507caf3fd0765df028d90f260716636fdc4)

A slide shows terminal commands for installing and running Docker.

The final technical example concerns code spread across related repositories. Christmas mounts the related repositories read-only. That gives the agent enough context to inspect another codebase while preventing it from changing that mounted code just to make the current task succeed.

The restriction changes how a coding problem must be solved. If the current project depends on an API in another repository, the agent can read that implementation to understand the interface. It cannot quietly edit the dependency to fit its proposed fix. The current project must work with the specified API. Read-only access therefore protects both the neighboring repository and the integrity of the solution: useful context remains available, while an unwanted shortcut is removed.

## Key takeaways

- 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.

## Resources

- [Docker Sandboxes documentation](https://docs.docker.com/ai/sandboxes/) — Start with installation and local agent workflows, then inspect the architecture, credential handling, network policies and sbx command reference.

## Slides

### Autonomous agents are future

Rowan contrasts trust in coding harnesses and blame for human mistakes with a warning that agent systems are easily exploited. He sets out to test that protection by hacking himself.

[1:21](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=81s) [Three cards contrast assumptions about coding harnesses and human decisions with the claim that the systems are exploitable.](https://assets.ai.engineer/sites/aiecode2025/sha256/57e88b26179caff925e978fbafb00cd16bca4629528c607e865a1a2c188d9ba2.webp)

Autonomous agents are future
and the future is now

docker

What we think
Coding harnesses do a pretty good job of protecting you.

What we feel
The stories we hear seem to be bad human decisions rather than AI going rogue.

What’s real
These systems are easily exploitable for serious threats.

### How bad can agents really be?

Rowan tests how far an agent can go in a supposedly safe environment, starting by asking Claude on a Mac where browser history is stored.

[1:33](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=93s) [A Claude for Mac window accompanies a prompt asking where browser history is stored.](https://assets.ai.engineer/sites/aiecode2025/sha256/de35c36f79d365accdf88dba665b6410053ed20f0cf36a85a28775f9abfa9a07.webp)

How bad can agents really be?
Let’s find out...

where is my browser history?

Interface text:
docker
Claude for Mac
Version 1.15962.1 (1e236d)
Help
Get support

### Browser history locations

Claude lists history database paths for five Mac browsers and suggests querying them with SQLite. Rowan says it found his browser history right away.

[1:40](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=100s) [A response lists local history database locations for several browsers on a Mac.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e5c74c86160cab52ec3cc92699f05acb0adce4cbc1ff39d40dfc9477d1c3e69.webp)

where is my browser history?

Browser history location depends on which browser you use:

Chrome
~/Library/Application Support/Google/Chrome/Default/History

Safari
~/Library/Safari/History.db

Firefox
~/Library/Application Support/Firefox/Profiles/<profile>/places.sqlite

Arc
~/Library/Application Support/Arc/User Data/Default/History

Edge
~/Library/Application Support/Microsoft Edge/Default/History

These are SQLite databases (except Safari’s which is also SQLite). You can query them with sqlite3 or browse with a tool like DB Browser for SQLite.

Interface text:
4d ago

### Asking about banking history

After Claude Code found his browser history, Rowan asked which banks he had visited from his other accounts. He says it found his real bank data.

[1:45](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=105s) [A prompt asks which banks were visited from other accounts, alongside a callout saying the speaker tried it.](https://assets.ai.engineer/sites/aiecode2025/sha256/7cd20822370d327548ae9a7816a1d9f64bfc94425164a9c64eb1826ea7b505bc.webp)

from my other accounts which banks have I visited?

I really did this...

### Account information found

Claude’s browser-history search surfaced banking details across two profiles, including check orders, Zelle use and an account suffix. The speaker says the displayed data is fake.

[2:05](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=125s) [A Claude screenshot summarizes information found across two browser profiles.](https://assets.ai.engineer/sites/aiecode2025/sha256/1bbc2511dc17fe6f9de3acbaf47947890c96edb69a4f9df25b5d93fdf120f366.webp)

CLAUDE SCREENSHOT

Quite a bit here. Key things:

Profile 1 ([redacted]) — personal WM account:
• Checking account ending in 5555 (business complete checking)
• Ordered physical checks via the WM marketplace (traveller business checks)
• Used Zelle to send money
• Searched for “9 digit PAC number chase” — looks like you were setting up a wire or ACH

Profile 10 ([redacted]) — Mineral Springs DGC club account:
• Same Chase business checking account WM — so both profiles share the same account
• Username my name leaked in a session token in one URL
• Mainly just logging in and doing transfers

Both profiles appear to be the same WM business account, just accessed from different browser profiles (personal vs. club-facing).

Interface text:
4d ago

### Information exposed

The Claude desktop app found two email addresses, a username, a bank name and the last four account digits. The slide uses fake data to illustrate what it found.

[2:19](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=139s) [A diagram labels email addresses, an account-number suffix, a username, and a bank name.](https://assets.ai.engineer/sites/aiecode2025/sha256/e2b44c9f1ee74fd5b445c7057ce5df796aefbb2eaec7f3f8a4ba046752032060.webp)

EMAIL ADDRESS
name@hacked.com

THE LAST 4 ACCOUNT NUMBER DIGITS
5555

BANK NAME
WM
WM
WM
WM

ANOTHER EMAIL ADDRESS
real_name_goes@here.com

THE USERNAME
my name

docker

### Credential harvesting report

The report rated the speaker’s internal credential-harvesting demo 0.90/1.0: Chrome login databases were copied and queried for banking credentials, and CrowdStrike took no blocking action.

[2:48](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=168s) [A security report summarizes the activity, its risk score, and key findings.](https://assets.ai.engineer/sites/aiecode2025/sha256/56402acc4c2c4bcd6a205efea2df0b783dc2304056ea311faad139dabe727791.webp)

Claude AI Chrome Credential Harvest

Summary
On 2026-06-25T05:30:49Z UTC, CrowdStrike detected user john.smith on macOS host ABCDEFG1234 executing a targeted credential harvesting operation — orchestrated by a Claude AI agent (claude-code 2.1.181, --permission-mode auto) as the grandparent process — that copied Chrome browser Login Data from two profiles to /tmp and queried them via sqlite3 specifically targeting banking credentials for Chase, PayPal, and BannerBank, with no blocking action taken by CrowdStrike. This activity is classified as Risky with a Composite Risk Score of 0.90.

Risk Classification
Risky  Score: 0.90  Explain
Benign  Inconclusive  Risky

Risky — Score 0.90/1.0. The evidence is unambiguous: a Claude AI agent with autonomous execution permissions (--permission-mode auto) directly orchestrated Chrome browser credential harvesting targeting financial institutions, the files were successfully written to disk, and CrowdStrike took no blocking action.

Evidence  2 Benign  5 Risky

Key Findings
• Chrome credential harvesting confirmed: Two separate cp processes copied Chrome's Login Data SQLite files from Profile 1 and Profile 10 (/Users/john.smith/Library/Application Support/Google/Chrome/Profile */Login Data) to /private/tmp/chrome_p1_logins.db and /private/tmp/chrome_p10_logins.db. This is a well-documented credential theft technique (T1555.003 – Credentials from Web Browsers).
• Targeted financial credential extraction: The parent zsh command explicitly used sqlite3 to query the copied databases for credentials matching %chase%, %paypal%, %bankerbank%, and %bank% — a deliberate, targeted attack on banking logins, not generic data access.
• Claude AI agent is the grandparent: The GrandParentCommandLine reveals claude-code 2.1.181 running with --permission-mode auto, mcp__computer-use, and multiple plugin directories. The AI agent autonomously issued the credential-harvesting shell script through a zsh subprocess — raising the question of whether this was user-directed or a result of a malicious prompt injection or compromised plugin.

Interface text:
Analysis

### Report finding

The report flags copies of two Chrome login databases as credential harvesting. Rowan says the activity was his own internal test.

[2:54](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=174s) [An enlarged report finding describes copies of browser login databases.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba45b5ddb748bf3e5646cd36a271a8000fa6c09974ebf16615dea73869868b3c.webp)

• Chrome credential harvesting confirmed: Two separate cp processes copied Chrome's Login Data SQLite files from Profile 1 and Profile 10 ( /Users/john.smith/Library/Application Support/Google/Chrome/Profile */Login Data ) to /private/tmp/chrome_p1_logins.db and /private/tmp/chrome_p10_logins.db . This is a well-documented credential theft technique (T1555.003 – Credentials from Web Browsers).

### Five prompts

The speaker’s internal test took five prompts. He says a direct request for bank data would trigger a warning, while framing it as security research would elicit help.

[3:20](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=200s) [Docker slide asks whether the information was enough to steal an identity and says it took five prompts.](https://assets.ai.engineer/sites/aiecode2025/sha256/c4d5c1c39a7af9880f5b7cb842a9e64f3ab68b2048153b3923ac1096e95d1b72.webp)

Enough to steal my identity?
It took 5 prompts.

docker

### Please is not security

Docker contrasts prompt-based restrictions with microVM isolation and governance. Its secret-injection system replaces placeholders in network requests so the sandbox never sees the secrets; it also records an audit trail.

[3:44](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=224s) [A Docker slide contrasts hope-based controls with sandboxes and governance.](https://assets.ai.engineer/sites/aiecode2025/sha256/5cd2e0be7155134d535f703d6a5e0f4aca54292b6840b1d57606f4c8a383e636.webp)

“Please” is not security

HOPE IT WORKS:
• Containers share kernels
• Deny-lists in config files
• Agents can read secrets from env variables
• Context files with "don't do X"
• Manual approval of agent actions

If the agent can see it, it can use it.

SANDBOXES & GOVERNANCE:
• MicroVM kernel isolation
• Hard boundaries for PII
• Secrets injection at the proxy
• Policy-as-code enforcement
• Automated approval, full audit trail

Secure by design, not hope.

docker

### The lethal trifecta

Useful agents may need private data, untrusted content and external actions at once. The slide calls for runtime enforcement; Rowan also cautions against giving agents bank data.

[4:44](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=284s) [A Docker slide lists access to private data, exposure to untrusted content, and the ability to act externally as three agent risks.](https://assets.ai.engineer/sites/aiecode2025/sha256/6431300bdc4dd6e828dd881311c5c5e193b84ea7fe5c56952cefe8b7ce4b4f1f.webp)

Every useful agent is built on the "lethal trifecta."

RISK · 01
Access to private data
▸ INTERNAL · SENSIT[illegible]

Like bank data?

RISK · 02
Exposure to untrusted content
▸ PROMPT INJECTION · POISONED INPUT

RISK · 03
Ability to act externally
▸ EXFIL · UNBOUNDED EGRESS

A useful agent has all three by design. The only fix is an enforcement layer at the runtime.

docker

### Launching Claude in a sandbox

Rowan compares a regular Claude session with a sandboxed one. He says sbx run claude creates a VM in the folder and starts the agent; the sandboxed session shows bypass permissions enabled.

[5:07](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=307s) [Two terminal windows compare a standard Claude launch with a sandbox launch.](https://assets.ai.engineer/sites/aiecode2025/sha256/dafb2182b0c34a9edcdb33449aead1b6422a648dd1bb51914dec1fa0cbd45a3f.webp)

>claude
>sbx run claude

docker

Interface text:
Left window:
Claude Code v2.1.181
Welcome back Rowan!
Sonnet 4.6 · Claude Enterprise · Docker
~/haxxor
Tips for getting started
Ask Claude to create a new ap...
What's new
Added `CLAUDE_CODE_DISABLE_MO...
Fixed hook matchers with hyph...
Fixed voice dictation on macO...
/release-notes for more
2 setup issues: MCP · /doctor
Try "refactor <filepath>"
» auto mode on (shift+tab to cycle) · ← for agents

Right window:
Claude Code v2.1.195
Welcome back Rowan!
Sonnet 4.6 · Claude API · Docker
/Users/xmas/haxxor
Tips for getting started
Ask Claude to create a new app or cl...
What's new
Added `CLAUDE_CODE_DISABLE_MOUSE_CLI...
Fixed hook matchers with hyphenated ...
Fixed voice dictation on macOS captu...
/release-notes for more
Try "edit <filepath> to..."
» bypass permissions on (shift+tab to cycle) · ← for agents

### Browser history locations

In the regular Claude session, a browser-history prompt returns common macOS database paths. The next prompt asks for the last 20 entries from the Docker profile.

[5:44](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=344s) [A terminal lists typical browser history locations on macOS.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d467372e0eeed63703e5738770ac4369f35e69e4e2c263af599a0a80e20b082.webp)

where is my browser history?

• Browser history locations on macOS depend on which browser you use:

Safari
~/Library/Safari/History.db

Chrome
~/Library/Application Support/Google/Chrome/Default/History

Firefox
~/Library/Application Support/Firefox/Profiles/<profile>.default/places.sqlite

Arc
~/Library/Application Support/Arc/User Data/Default/History

Brave
~/Library/Application Support/BraveSoftware/Brave-Browser/Default/History

Show the last 20 from my Docker profile

Interface text:
haxxor — ✳ Find browser history location — claude — 99×32
Sonnet 4.6 · Claude Enterprise · Docker
~/haxxor
Fixed voice dictation on macOS capturing silence…
/release-notes for more
2 setup issues: MCP · /doctor
Jump to bottom (ctrl+End) ↓
Update available! Run: brew upgrade claude-code
» auto mode on (shift+tab to cycle) · ← for agents

### Browser history search in the sandbox

The sandboxed agent searches for browser history but finds none. It reports a headless Linux container without a desktop browser profile, illustrating what the agent can see inside the sandbox.

[5:53](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=353s) [A sandboxed terminal reports finding no browser history and lists locations it checked.](https://assets.ai.engineer/sites/aiecode2025/sha256/b321a0b97c08962c3c93bbebf7685174b68d30ef6fc807b7a43fd9a737173cb3.webp)

echo "==== any sqlite holdi…)
└ /usr/share/nodejs/undici/lib/web/cookies
  ==== any sqlite holding urls table (history signature) ====
  /Users/xmas/.codex/logs_2.sqlite
  … +4 lines (ctrl+o to expand)

I searched the whole filesystem and there's no web browser history on this machine.

What I checked
- Standard browser profile locations and history databases — History (Chrome/Chromium/Edge/Brave/Opera/Vivaldi), places.sqlite (Firefox), Safari's History.db
- Browser profile directories (Chrome, Chromium, Mozilla, Firefox, BraveSoftware, Safari, Microsoft Edge)
- ~/Library/Application Support (macOS-style), /Users/xmas, and any User Data / Cookies /
- ~/Library/Application Support (macOS-style), /Users/xmas, and any User Data / Cookies / chromium profile dirs
- Every .sqlite file on the system

Why there's nothing
This is a headless Linux sandbox container (haxxor, aarch64) — there's no installed d[illegible] Cook
ies / chromium profile dirs
- Every .sqlite file on the system

Why there's nothing
This is a headless Linux sandbox container (haxxor, aarch64) — there's no installed desktop browser keeping a history profile here. The only browser-adjacent things

Interface text:
haxxor — ✳ Find web browser history — sbx run --name haxxor — 93×29

## Full transcript

[0:12](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=12s) Hey, everybody. I hope you had a good lunch. I know it's one of the last talks of the entire conference. I tried to make it somewhat engaging and amusing. So, you know, audience participation is, is, uh, encouraged. We'll see how it goes. So I'm here with Docker. Uh, I'm one of our product managers that works on our new sandbox product. I don't know if you've seen it. It's a new binary for Docker. It's called sbx. Uh, it's a microVM. It's really cool. You should come check it out. But I'm gonna tell you

[0:42](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=42s) why, uh, you might want to use it in context of agents doing governance and j-- being safe in general for your agentic platforming needs.

[0:54](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=54s) So right now, you know, all of you are doing way more AI than you ever thought you would five years ago, at least I am. And we generally think that we're being protected by our coding harnesses, 'cause if we try to do something bad, they will sometimes stop us. And when we see stories, we think, "Oh my gosh, I would never make this mistake to have my AI drop my prod database. You know, I've been doing coding for thirty years. There's no way I would possibly do that." So what I d- decided to find out

[1:23](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=83s) was, well, what happens if I actually try to hack myself, and how far can I get with, you know, our tools and what we've been told is a safe environment? So I opened up my Claude Code on desktop on my Mac, and I had it look for my browser history. Uh, and it found it right away, which I was very impressed about. And I asked it, uh, "What can I, what can I do with this?" And so we started looking at my bank accounts, which I was, uh,

[1:53](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=113s) surprised about. And it found them, uh, which I was very unhappy about. I made fake bank names. This is not my real data, just so you know. But it did find all of my real bank data on there. Uh, and it went even further. It found that I've been ordering checks recently, that I've been using Zelle. It told me the last four digits of the account I was using. Um, I was, I was very impressed. Uh, and here's a kind of a idea of all the PII that it found. Um, this is from,

[2:23](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=143s) again, the Claude desktop app, uh, that we thought was safe. Anyways, maybe, maybe there's a better solution. Who knows? So the next day, I came in, and I got from my security team, uh, a nice little notice that I-- they thought I'd been hacked. And so I had to explain to them that, "No, no, no. I'm just putting together a talk for this conference, and, uh, please, please don't flag me as a, as a, a compromised computer." And then they sent me the CrowdStrike report from this, which I asked them to

[2:53](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=173s) do, and I was quite impressed with it. Apparently, this is a known way to get, uh, credentials from a machine. Didn't realize that. And I had scored very well on this. I got a nine out of ten, which, uh, is better than I did in most of my classes. So that was, that was really good. But fortunately, this was just me internally. It was not some sort of, you know, injection from a script or MCP server or anything that could easily happen. So five, five prompts is what

[3:23](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=203s) it took. Um, I had to be a little clever. I couldn't-- If I just-- If you just ask straight up, like, "Hey, Claude, go find my bank data," it kind of-- it, it will give you a warning. But if you say, "I'm researching how to do security," it'll happily go and help you do that research on your account. It is not, uh, it's not your friend. So if o- if only there was a better way to do this using a sandbox microVM technology

[3:53](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=233s) that Docker and others have released recently. So rather than just saying please, which, you know, if you look in some of these Claude prompts, you'll see, "Please don't do nefarious things," right? Like, that is the level of security we're at. So now we've got microVMs, if you're not aware of them, compared to... I know you're probably all aware of Docker, been using it for years. The new thing now that we and others are doing is with microVMs. They run their own kernel. They isolate your file system. We have a system that will go and make sure that the

[4:23](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=263s) sandbox never actually sees your secrets. When you try to go and do a network request, it takes a placeholder, replaces it so that your sandbox and your agent can't do bad things. We've got a full audit trail for it. Uh, so yeah, we wanna be, you wanna be secure by design, not just, you know, hope and say please and see what's gonna happen.

[4:47](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=287s) We're trying to do this balancing act, right? If we don't act-- If we can't actually do these things, the agent's not useful. So that's why this whole sandbox idea is so exciting for us. We encourage you to use it, um, and maybe, you know, don't let your bank data get into the hands of your agent. That's not, that's not what you want. So this is what it looks like in practice when you're running a sandbox. Uh, on the, uh, left side is when I run Claude, and on the

[5:17](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=317s) right side is when I do sbx run claude. And you can see that there, there's a lot of, uh, differences. That's a joke. Sorry, they're not. It's, uh, just the bypass permissions are on, but it's nothing, nothing else, uh, was hard to do, right? Running that command on the right automatically creates a new VM. It spins it up in that folder, and it makes a new sandbox for you. It, i-- runs your agent. Now you're up and running. It can't see anything. So if we try to do our browser history

[5:46](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=346s) attack on regular Claude, it happily goes and finds your browser history.

[5:54](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=354s) But if I run it on the sandbox version, it does not even think there's a browser installed on your machine. So pretty cool. No difference. I had to type, uh, seven more keystrokes to get here, but I think it's well worth the, uh, the price to pay.

[6:14](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=374s) Same thing is true for network egress and ingress. So right here, I'd, uh, I tried to get it to go and look up, uh, the Pirate Bay because I f-- I knew that would be blocked. And sure enough, blocked by default. The other thing you kind of see, it's hard-- maybe it's hard to see, but like the, uh, Claude likes to really send back a lot of telemetry data to their Datadog instance. So if you're using Claude, uh, you are sending Anthropic a lot of your data, unless you're using sandboxes, in which case you're cleverly being blocked

[6:44](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=404s) by that. The other thing I'll say about sandboxes, they're so easy to use. Every developer at Docker now writes all of their code in sandboxes. So we are using this every day. We're writing all of our code in it. If we don't use it, we get, uh, we get yelled at. So it's worth our time to, to go and do that.

[7:03](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=423s) Little defaults on this. All of this is configurable. Um, and so now that we've talked about like why this matters, right? So doing this at the hardest level doesn't really work. Agents find their way around it. If it gets down to your host machine, it's too late. So you wanna be at that micro VM boundary. We think it's the best way. Other people do too. And it's easy to use.

[7:29](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=449s) If you're working in consulting, if you've got a, you know, chief security officer, if you do client work, whatever it might be, you're probably dealing this-- with this on a day-to-day basis. So not only do you want this to be useful, but also you want to do things and enable your agents to do different things, right? So one of the things we're really excited about is doing like agent-level identity tracking and delegation chains. So when you can start saying, "Hey, how come this thing happened?" And you can go back and say, "Oh,

[7:59](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=479s) that's because an agent did it, and a human actually authorized that agent to do it." It didn't just happen by magic. We didn't know. We don't-- It's not like we don't know how it would happened. Now we're gonna start tracing that, tell you f-- tell you about it, and let you write policy that actually goes and s-- does degradation of, uh, what you can do based on Cedar policies, based on new, new things happening. And you might say to yourself, "Oh my gosh, this is so good. I would like, I would like to buy it now.

[8:30](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=510s) How do I, how do I buy this from you guys?" And so I have my marketing slide that my marketing team is really mad at me that I made this, but I think it's funny and cute for AI governance. So definitely talk about that. Okay. What does AI governance look like? I-- You're doing-- This is what, this is what it looks like in a kind of a mock-up. So right now we've do, we do network. You can set allow, deny. You can do file system, uh, points. And you can also decide what your MCP catalog looks like.

[9:00](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=540s) Also, if you're running our MCP server, our MCP servers themselves run on a sandbox, so they are also governed by all of these different controls. In the future, we're gonna be adding more stuff. One of the things we've heard from a lot of people at this conference is that they wanna do, uh, L7 networking controls. They wanna do, uh, like per GitHub repo file system level controls, right? Like you want your agent to be able to read and write to some

[9:30](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=570s) repos and some areas of some repos, but not others, right? So all of this is gonna be coming down the line, but everything that I've showed you today is working. Um, and you should come by our booth and see that.

[9:46](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=586s) It's easy to install. We run on Mac, Windows, and Linux, uh, based on your, uh, package manager of choice. And you can see at the end, it's just sbx run cla-- It's not just Claude, by the way. The, the sandboxes are a full VM. So you can run a shell, you can run Codex, you can run whatever. You can run a Python job. You can run a web server. Any- anything you wanna do. But we wanna make it easy for you to get in and up and running. So this is kind of our default. So you can just

[10:16](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=616s) get in. You can get that Claude Code or Codex instance going. It feels native. It works just the same way as your one did today, but you've got all these protections in store. Uh, additionally, you can mount other file systems. So what I do is when I'm working on a, you know, a piece of code with related repositories, I'll mount those, uh, read-only. That way, my agent can see what I'm doing. It can see my other code base, but I know it's not gonna make random commits to other

[10:46](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=646s) repos just to make my thing work, right? I want the guarantee that it's actually doing what it says it's doing with the API that I've specified.

[10:55](https://www.youtube.com/watch?v=OE_lLNCNfQo&t=655s) So that's it. Pretty short. We have a booth. We have a few sunglasses left and some power banks to give away. You should come by our booth, and I'll walk over there afterwards and give you the demo, and then you can look as good as, uh, Macho Man Randy Savage with those glasses. So there you go. Thank you.
