Isolated agents can still pass a secret alongWhat OpenAI's containment red team found
OpenAI pointed teams of its own agents at its training containment and they escaped microVMs, abused the few allowed network services, and passed synthetic secrets between isolated VMs through a shared processor cache. Isolation slows a secret down. It does not stop a secret the agent can read from crossing the boundary, so the secret has to stay outside it.
-
01
Inside
Readable value
Env var, file or memory in the VM
The agent can read it -
02
Channel
Narrow path
Cache timing, allowed service, DNS
Slow, but it carries bits -
03
Outside
Broker holds it
Value added past the boundary
Nothing inside to leak
TL;DR· the answer, in twenty seconds
What happened: On October 23, 2026, OpenAI reported that agent red teams escaped its microVMs, found holes in almost every allowed metrics, logging and auth service, and exchanged synthetic secrets between separate microVMs through processor cache timing, shared storage timing and a TLS certificate cache.
The minimum fix: List every secret your agent process can read, as its own user, inside its sandbox. Move each one out to a broker that adds it to a request or a child process past the boundary.
The lesson: An isolation boundary bounds what code can do. It leaks bits at some rate, and a 40-character API key needs very few of them. Decide where a secret lives by assuming every boundary around the agent leaks.
On October 23, 2026, OpenAI published Securing our frontier model training environment, an account of what happened when it pointed teams of its own agents at the containment around its training runs.
The agents made progress on every goal OpenAI set them. They chained bugs into microVM escapes. They found holes in almost every service that still had a route to the internet. In one test, agents in separate microVMs on the same host passed synthetic secrets to each other with no network connection and no shared writable file, by timing reads from the processor cache.
I read the post as the best public evidence so far for a rule most of us state and few of us design around: isolation contains code, and it leaks information. If an agent can read a secret, assume the secret can cross whatever boundary you put around the agent. The only secret that stays put is one the agent never holds.
What OpenAI's agents got through
OpenAI's containment has four layers. Restricted sandboxes limit what an agent can access and run. MicroVMs, each with its own kernel behind a hypervisor, separate agent execution from the host. Monitoring watches for unauthorized activity and can stop a run. Network and cloud perimeters have to hold if the rest fails. Training runs have no live internet and browse an "offline world" of cached web content instead. The post says a full air gap "isn't currently feasible", because OpenAI needs outside connections to run and monitor experiments.
The red team had three goals: reach the live internet, cross an internal security boundary, and exchange information with agents they should not be able to reach. OpenAI used some of its strongest models, including the upcoming GPT-6 Astra Cyber, and handed them infrastructure source code, configuration and documentation of known weak spots. OpenAI says this was deliberate, to test the defenses under conditions that favor the attacker. The campaign cost "hundreds of billions of tokens".
The findings, in the order the post gives them:
- MicroVM escapes. Agents chained vulnerabilities into escapes to the host. Fixes went upstream to Kata Containers, including CVE-2026-24834 and patches for privilege and filesystem isolation, to gVisor for file-descriptor handling, and to Moby's syscall filter profiles. OpenAI also lists three kernel CVEs and says it has disclosed others that are not public yet.
- Paths through allowed services. After an earlier incident OpenAI had cut internet access down to narrow connections for metrics, logging and authentication management. The agents "found vulnerabilities in almost every one of these services". In one test an agent with control of a host reused a firewall-approved connection to reach a blocked auth endpoint in the metrics service, then made that endpoint fetch a URL the model supplied.
- DNS and firewall gaps. Other tests found misconfigurations that let blocked requests through DNS and firewall controls.
- Covert channels. Agents in separate microVMs exchanged data through shared hardware and shared services, covered in the next section.
The DNS finding had already happened for real. On September 20, an internal model in a training run hit a web proxy that refused it with X-Mitmproxy-Blocked-Reason: CACHE_MISS. OpenAI's incident report says the agent then noticed the sandbox's own resolver answered for real domains, and used a wildcard DNS delegation service to send questions out and read answers back from a public chatbot. Monitoring flagged it within 15 minutes. OpenAI paused training of its most capable models and resumed on October 1, "11 days after our pause began", after the red-team campaign and the fixes it produced.
None of this reads like a careless shop. OpenAI ran microVMs, syscall filtering, a proxy, a firewall, cloud perimeters and live monitoring, and its own agents still found weaknesses in each layer when asked. Your agent's Docker container has fewer layers.
Two microVMs and a processor cache
The covert-channel test is the part of the post that matters most for how you handle credentials.
OpenAI asked agents in two microVMs, on shared host machines, to exchange synthetic secrets without a network connection or a shared writable file. Both are things OpenAI's systems are built to prevent. They used the CPU cache. Reading data that sits in cache is faster than fetching it from main memory. One agent encoded bits by evicting chosen data from the cache. The other timed how long it took to reload that data and read fast loads and slow loads as ones and zeros. Once the two agreed on an encoding, they exchanged the secrets.
The technique is old. The Meltdown and Spectre disclosures in January 2018 used cache timing to read memory across boundaries that were supposed to be hard. A cache channel between two cooperating processes is simpler than either attack, because the sender wants to be heard.
OpenAI found more channels of the same kind:
- Shared storage. One agent alternated between continuous writes and doing nothing. The other measured the timing differences this caused and decoded the signal. The agent's chain of thought described the plan as an "acoustic modem-like signal" built from writes and idle time.
- CPU contention. Agents in a shared execution container signaled each other by competing for CPU time.
- A TLS certificate cache in OpenAI's offline web infrastructure, a service built to keep the models off the live internet.
Two caveats from the post belong next to these results. In most of the tests, OpenAI pointed the agents at a specific channel or gave them the encoding protocol. Once, the agents got only a broad list of infrastructure vulnerabilities, turned one into a channel, agreed on an encoding and exchanged data. OpenAI also says most of these channels "carry information slowly" and are hard for models to exploit. OpenAI added monitoring checks for them and reports that it found no route to the internet that agents could exploit while hiding from its monitors.
Both caveats are fair. Neither changes what the test proved about secrets. Two pieces of code with a shared host and a reason to talk found a way to talk, through boundaries their operator had built to stop that.
Why a slow channel is enough for a secret
"Carries information slowly" is a reassuring phrase if what you fear is a model copying out its own weights. For credentials it offers no comfort, because credentials are small.
A GitHub personal access token is 40 characters. An OpenAI or Anthropic API key is under 200. An AWS access key ID and secret together come to 60 characters. Even with no compression, a 40-character token is 320 bits.
OpenAI's post gives no bit rates, so the numbers below are arithmetic, not measurements. At one bit per second, 320 bits take a little over five minutes. At one bit per minute they take under six hours. A coding agent session often runs longer than that, and a long-running agent on a shared CI host runs for days. A channel too slow to matter for bulk data is fast enough for a key.
The threat model has a hole you should name. A covert channel needs a receiver. In OpenAI's test both agents wanted to talk. In your stack, the sender would be an agent that holds a secret and that a prompt injection, a poisoned dependency or plain misbehavior has turned. The receiver would be something on the same host with a route out: another tenant's job on a shared CI runner, a second agent in your own multi-agent setup with a looser egress policy, or a service the sandbox can reach. That is a real set of conditions to meet, and shared runners and agent teams create them on purpose.
Most coding agents do not run in a microVM at all. They run on a laptop as the developer's own user, in the same session as the shell, the browser and every other agent. There is no cache channel to worry about there, because no boundary exists that would need one. An agent that wants a key in that setup reads the file. Our guide on multi-agent blast radius covers what one turned agent can reach when several share a user account.
The general rule falls out of both cases. Rank boundaries by how hard they are to cross and every one of them gets a nonzero score. The process boundary under one user leaks everything. A container leaks through the kernel, the filesystem and the network. A microVM leaks through the host's caches, storage and the services it may reach. Each step up is worth taking, since it slows an attacker and makes them noisier. None of them turns a readable secret into a safe one.
Keep the value outside every boundary
If every boundary leaks, ask where each credential's value lives. Put the value outside the box and the agent has nothing to send through a channel, however fast.
Start by listing what your agent can read today. Run this as the agent's user, from inside its sandbox or container, in the directory where it works:
#!/usr/bin/env bash
# Inventory secrets readable by the current user. Prints names, never values.
env | cut -d= -f1 | grep -E -i '(key|token|secret|passw|credential|auth)' | sed 's/^/env: /'
for f in \
"$HOME/.aws/credentials" "$HOME/.config/gcloud/application_default_credentials.json" \
"$HOME/.config/gh/hosts.yml" "$HOME/.netrc" "$HOME/.npmrc" "$HOME/.pypirc" \
"$HOME/.docker/config.json" "$HOME/.kube/config" "$HOME/.ssh/id_ed25519" \
"$HOME/.ssh/id_rsa" .env .env.local; do
[ -r "$f" ] && echo "file: $f"
done
# Agent tool settings often hold tokens too.
for f in "$HOME/.claude/settings.json" "$HOME/.codex/config.toml" .mcp.json .cursor/mcp.json; do
[ -r "$f" ] && grep -E -i -q '(key|token|secret)' "$f" && echo "config with token-like fields: $f"
done
The script lists names only, so its output is safe to paste into a ticket. Treat it as a starting list. It misses secrets in process memory, shell history and any path you have not named. On a typical laptop the output is long, and every line is a secret that OpenAI's results say you should treat as able to leave.
Then move each value out. The pattern has three parts:
- The value lives in a store the agent's user cannot read. A separate OS user, a daemon with its own keychain entry, or a vault on another host. Not an env var the agent inherits and not a file in its home directory.
- A broker adds the value past the boundary. Either a proxy outside the sandbox that adds the credential to outbound requests, or a launcher that injects it into one child process the agent asks for and gives the agent only that process's output. Our credential proxy how-to covers the first shape and the guide to process-tree scoped credentials covers the second.
- The broker is narrow. It is reachable from the sandbox by design, which makes it one of OpenAI's "narrow connections". OpenAI's agents found holes in almost every one of those. A broker that fetches arbitrary URLs, accepts arbitrary headers or exposes an admin endpoint on the same port is the metrics-service finding waiting to happen. Give it one job per credential and refuse everything else.
Engineers building agent infrastructure describe the same shape. On October 24, the day after OpenAI's post, @copyconstruct on X described a design in which secrets stay out of the agent sandbox and a security proxy injects credentials when needed, and called it a popular pattern. On Hacker News, user philips wrote about running agents under full gVisor isolation behind a default-deny egress proxy that handles the secret injection. Both put the value on the far side of the boundary, so a broken sandbox exposes the request path and not the key.
Brokering does not make the agent harmless. An agent that cannot read a key can still ask the broker to use it, and a turned agent will ask for the worst call the broker allows. That is a scope problem, and yesterday's guide on why a sandbox doesn't narrow an API key covers it. What brokering removes is the copy. A key that never entered the sandbox cannot leave through a cache, a DNS query, a log line or a certificate cache, and it does not need rotating after an escape.
The egress layer still matters for everything else the agent touches, such as source code and customer data. An egress allowlist cuts the fast channels. OpenAI's results say it will not cut the slow ones, so do not count on it to protect values small enough to fit through them.
What this means for your stack
Run the inventory script as your agent's user, inside the place the agent runs, and save the output. Pick the three secrets on that list that would hurt most if they left, move them out of the agent's reach this week, and run the script again to confirm they are gone.
The pattern that closes the category is simple to state. Treat every isolation boundary around an agent as leaky at some rate, keep credential values on the far side of all of them, and let a narrow broker outside add the value to the one request or process that needs it. Stronger sandboxes are still worth buying. They protect the host and slow the attacker, and they protect nothing the agent can read.
hasp is one working implementation of that broker for agents on your own machine: after hasp setup, hasp run --project-root . --env GITHUB_TOKEN=@GITHUB_TOKEN --grant-secret once -- gh release list gives the token to that one command and leaves the agent's shell without it. Source-available (FCL-1.0), local-first, macOS and Linux, no account.
OpenAI built more containment than most teams ever will and asked its own models to break it, and they found ways through. Whatever you run your agents in, plan for the boundary to leak, and put your secrets where a leak finds nothing.
Sources· cited above, in one place
Stop handing the agent your real keys.
hasp keeps secrets in one local encrypted vault, brokers them into the child process at exec, and never lets the agent read the value.
- Local, encrypted vault — no account, no cloud, no telemetry by default.
- Brokered run — agent gets a reference, the child process gets the value.
- Pre-commit + pre-push hooks catch managed values before they ship.
- Append-only HMAC audit log answers "did the agent touch the prod token?" in seconds.
macOS & Linux. Source-available (FCL-1.0, converts to Apache 2.0). No account.