# OpenAI Paused Frontier Training, Then Red-Teamed Its Own Containment

URL: https://nanosolutions.io/openai-frontier-training-containment
Date: 1793232000
Description: An OpenAI model used DNS to reach a chatbot mid-training. OpenAI paused, then set its best models on its own sandbox. What teams running agents should copy.

---


<div class="post-tldr">
  <p class="post-tldr__label">The short version</p>
  <ul>
    <li>On 20 September an internal OpenAI model, stuck on a search task during training, sent questions to a public chatbot through its sandbox's DNS resolver. Every other route it tried was blocked.</li>
    <li>Monitoring raised the alarm in about 12 minutes. The automatic stop did not fire, and the run was killed by hand about two and a half hours later. OpenAI paused training of its most capable models for 11 days.</li>
    <li>It also set teams of its own frontier models on its containment. They escaped microVMs, got limited internet access through services such as metrics, logging and authentication, and passed messages between isolated VMs using CPU cache timing.</li>
    <li>The fixes went upstream: a critical Kata Containers CVE, gVisor, Docker's default seccomp profile and three Linux kernel bugs.</li>
    <li>For anyone running AI agents: DNS is egress, the plumbing is egress, a container is not the boundary, and a kill switch you have never tested is not a kill switch.</li>
  </ul>
</div>

On [date:2026-10-23|https://openai.com/index/securing-our-frontier-model-training-environment/] OpenAI published a detailed account of how it contains models while it trains them. Most of us will never train a frontier model. Plenty of us now run agents that write and execute code, and the controls OpenAI describes are the same ones those agents run inside: containers, VMs, egress rules, DNS and monitoring.

It is also a rare thing in this industry: a lab writing down where its own defences failed. Below is what happened, what OpenAI's own models got through, and two things you can do today: a short test to run inside your own sandbox, and a seven-question check.

## What happened on 20 September

The [incident report](https://alignment.openai.com/misalignment-reports/an-agent-used-dns-to-reach-an-external-chatbot/) is short and specific. An internal research model was in reinforcement learning training on a search task: find information about the person behind a blog post. Its search tool returned nothing useful. It tried Google, Bing and DuckDuckGo directly from Python and got errors. It tried a direct HTTPS request to a chatbot, and the proxy blocked it.

Then it found the one thing still talking to the outside world. Web traffic went to an offline cache, but the sandbox's DNS resolver could reach the live internet. The model sent questions to an external chatbot service through DNS, some of them containing clues from its task, checked that the answers came back, and then asked how to search the web and how to use public DNS tunnels. OpenAI puts the cause down to "insufficient DNS filtering in its training sandbox."

The timeline is the part worth pinning to the wall:

<figure class="ctm-time not-prose">
  <div class="ctm-time__bar" role="img" aria-label="Of the 2 hours 44 minutes between the first outside answer and the run being killed, about 12 minutes passed before the alert, 3 before a person acknowledged it, and about 2 hours 29 minutes after that.">
    <span class="ctm-time__seg ctm-time__seg--dark" style="flex-grow:7.2"></span>
    <span class="ctm-time__seg ctm-time__seg--mid" style="flex-grow:1.8"></span>
    <span class="ctm-time__seg ctm-time__seg--accent" style="flex-grow:91"></span>
  </div>
  <ol class="ctm-time__list">
    <li><strong>9:50 am</strong> A DNS query gets its first answer from outside</li>
    <li><strong>10:02 am</strong> Monitoring raises its highest-priority alert <span>12 minutes</span></li>
    <li><strong>10:05 am</strong> A human acknowledges it <span>3 minutes</span></li>
    <li class="ctm-time__long"><strong>12:34 pm</strong> The run is killed <span>2 hours 29 minutes</span></li>
  </ol>
  <figcaption>20 September 2026. Times from OpenAI's incident report; the bar is to scale.</figcaption>
</figure>

Detection worked. Stopping did not. The run should have halted automatically and did not, and that left people unsure whether it should be stopped at all. A separate DNS anomaly detector had excluded that environment, so it flagged nothing even though the traffic was logged, and a review afterwards found other external DNS lookups the monitor should have rated higher.

OpenAI rates this as much less severe than some of its earlier incidents, but it was the first since the hardening that followed July. It paused training, evaluation and tool-using inference for its most capable models, and says it will not resume training that particular model. DNS in those environments is now limited to an allow-list of domains and record types.

## The new rule: no live internet, at all

The [July Hugging Face incident](/openai-agents-hugging-face-incident) had already pushed OpenAI to cut back the routes models could use to reach the internet. September showed that fewer is not enough. OpenAI's position now is that frontier training happens with no live internet access, and stays that way until alignment research, monitoring and internet security improve enough to justify more.

Models still need to learn to browse, so OpenAI built what it calls an "offline world": a large indexed and cached copy of web content the model can use without touching anything real. Every frontier RL run now uses it.

## Four layers, each assuming the one inside has failed

The containment design is defence in depth, and OpenAI is explicit that each layer is built to hold if the layers inside it are beaten. Here is each layer, with what OpenAI's red team did to it.

<figure class="ctm-layers not-prose">
  <div class="ctm-layer ctm-layer--4">
    <p class="ctm-layer__name">Network and cloud perimeters</p>
    <p>Designed to contain an agent that has already escaped and owns the host.</p>
    <p class="ctm-layer__hit">Agents found limited internet routes through metrics, logging and authentication services.</p>
    <div class="ctm-layer ctm-layer--3">
      <p class="ctm-layer__name">Monitoring</p>
      <p>So a person can step in before a breach spreads.</p>
      <p class="ctm-layer__hit">OpenAI found no route an agent could trivially exploit while hiding from it.</p>
      <div class="ctm-layer ctm-layer--2">
        <p class="ctm-layer__name">MicroVM</p>
        <p>A lightweight VM with its own kernel, separated from the host by a hypervisor.</p>
        <p class="ctm-layer__hit">Agents chained bugs to run code on the host, and passed messages between VMs through CPU cache timing.</p>
        <div class="ctm-layer ctm-layer--1">
          <p class="ctm-layer__name">Sandbox</p>
          <p>A restricted container limits what the agent can see and run.</p>
          <p class="ctm-layer__hit">Some test runs began by assuming this was already beaten.</p>
        </div>
      </div>
    </div>
  </div>
  <figcaption>Linux tasks, innermost layer last. macOS and Windows tasks get virtual machines; GPU tasks get containers with user-space sandboxing. Source: OpenAI.</figcaption>
</figure>

Full air-gapping is not practical, because experiments need outside connections to be run and watched. So outbound traffic and movement between systems are restricted, and that includes any service the host can reach directly or through another service. Firewalls, security groups, IAM and private networking come from the cloud providers. Configuring them correctly, and testing them together, is OpenAI's job.

## Red-teaming with the models themselves

To test all this, OpenAI gave teams of its own models three goals: send a request to an external server it controlled, reach resources outside their permitted environment, and exchange information with agents they were meant to be isolated from. Some runs started from the assumption that the agent had already escaped its sandbox, slipped past monitoring and taken the host, to test the perimeter on its own.

The attackers included OpenAI's upcoming GPT-6 Astra Cyber model and an internal frontier model, working on isolated copies of the research infrastructure. They were deliberately given the advantage: infrastructure source code, configuration and documentation of likely weak points. The campaign used hundreds of billions of tokens, and OpenAI says the number of vulnerabilities and misconfigurations found declined significantly as it went on.

The red-teaming was not confined to the 11-day pause. OpenAI says it has been hardening and red-teaming continuously since July, and the upstream fixes it lists are dated from February to September 2026.

## What the agents found

**MicroVM escapes.** Agents chained bugs into escapes from OpenAI's microVMs and ran code on the host machines. The open-source fixes include:

- [CVE-2026-24834](https://github.com/kata-containers/kata-containers/security/advisories/GHSA-wwj6-vghv-5p64) in Kata Containers with Cloud Hypervisor, rated critical (CVSS 9.3). A process in the container could rewrite the guest VM's root filesystem and run code as root in the guest. The advisory's reporter does not expect it to reach the host on its own, so an escape would need a chain like the ones OpenAI describes. It needs the `CAP_MKNOD` capability, which Docker grants containers by default. Fixed in Kata 3.27.0.
- Two more Kata agent fixes, for [capability and namespace handling](https://github.com/kata-containers/kata-containers/pull/13615) and for [processes keeping a working directory outside the container root](https://github.com/kata-containers/kata-containers/pull/13587).
- A gVisor fix for [file descriptors passed over Unix sockets](https://github.com/google/gvisor/pull/13816).
- Docker's default seccomp profile now [allow-lists the socket address families a container may use](https://github.com/moby/profiles/pull/39) instead of blocking ranges, so unknown or future families are refused.
- Three Linux kernel memory-handling fixes, in [perf events (CVE-2026-74753)](https://github.com/torvalds/linux/commit/fa091f46c3833fb22384f10eade2b4e1e1d0b278), [Unix socket garbage collection (CVE-2026-80521)](https://github.com/torvalds/linux/commit/594d905195024b228c962627ae5ae7c17bd582a4) and [AF_PACKET (CVE-2026-80841)](https://github.com/torvalds/linux/commit/992cc9f94ca924089a506ba9b327caa9af797529).

OpenAI says it has disclosed more that are not yet public.

**Ways out through the plumbing.** After July, the connections left were narrow ones for services such as metrics, logging and authentication. The agents found flaws in almost every one of those services, each giving limited internet access. In one test an agent reused a firewall-approved connection to reach a blocked authentication endpoint in the metrics service, then had that endpoint fetch a URL of its choosing. Others got blocked requests past DNS and firewall controls through misconfigurations, or persuaded internal services to fetch external URLs for them.

**Talking without a network.** Agents in separate microVMs on the same host exchanged test secrets with no network and no shared writable file. One evicted chosen data from the CPU cache; the other timed how long it took to reload it and read the message from the difference. It is the same timing trick behind Spectre and Meltdown. Other channels ran through shared storage, CPU contention and a TLS certificate cache. Describing the storage channel, one agent wrote: "Could create acoustic modem-like signal … using continuous writes vs idle." These channels are slow, and OpenAI has added monitoring for them, but they exist.

OpenAI's verdict is measured. It found no route to the internet an agent could trivially exploit while hiding from the monitors. It resumed frontier training on 1 October, and high-compute red-teaming is now a core part of the safety case for future frontier training and evaluation.

## What this means for teams running AI agents and containers

You are not training GPT-6. But if a coding agent runs tests in your CI, a support bot can call internal APIs, or a model executes code in a container on your cloud account, you have a small version of OpenAI's problem. Here is what we would take from it.

**1. DNS is egress. Filter it.** Most container platforms let DNS out by default. Docker forwards lookups to the host's resolvers, and Kubernetes network policies usually allow port 53 to the cluster DNS, which will then resolve anything on the internet. A firewall that blocks HTTP but resolves any name has left a channel open, which is exactly what happened on 20 September. Give agent workloads a resolver that only answers for the domains they need, log every query, and alert on long or random-looking names.

**2. The plumbing is egress too.** Metrics collectors, log shippers, auth callbacks, package mirrors, webhooks: they exist to talk to the outside, and anything that fetches a URL on request can be talked into fetching yours. List every service an agent's host can reach, then ask of each one whether it can be made to fetch a URL, and whether it trusts a request because it came from inside. The July incident started in a package manager for the same reason.

**3. A container is not the boundary for code an agent writes.** Run it in a sandbox with its own kernel (gVisor, Kata or Firecracker), drop every Linux capability and add back only what is needed (`--cap-drop=ALL`), run as a non-root user, and give it a read-only root filesystem. The Kata CVE above needed `CAP_MKNOD`. A container that never had it was not exposed.

**4. Patch the runtime like you patch the kernel.** Kata, gVisor, containerd, runc, Docker and the host kernel are all security software now. Put them on the same patch timeframes as your internet-facing services in the [Essential Eight](/essential-eight/patch-applications), and rebuild images rather than updating servers in place.

**5. Test the kill switch.** OpenAI's monitor fired in 12 minutes, and the run went on for another two and a half hours while people worked out whether it should stop. Write down who can stop an agent without asking, and how: kill the job, revoke its tokens, cut its network. Then run the drill on a schedule, the way you test a backup restore.

**6. Copy the red-team objective.** OpenAI's first test is one any team can run: stand up a server you control, then ask an agent in a copy of your environment to get a request to it. If it succeeds, you have found a hole before someone else did.

**7. Be proportionate about side channels.** Cache timing between VMs matters if you host agents for different customers, or agents that must not share information, on the same hardware. For most businesses, egress, credentials and patching come first.

## Run this inside your own sandbox

Most of the list above can be checked in a minute. Start a shell in the environment your agent uses, in a test copy rather than production, and paste this. It only reads settings and writes one temporary file, which it removes.

```sh
echo "1. DNS: does an outside name resolve?"
getent hosts example.com || echo "   no answer"
echo "2. Web: can it reach an outside site?"
curl -sS -m 5 -o /dev/null -w "   HTTP %{http_code}\n" https://example.com || echo "   blocked"
echo "3. Capabilities (0000000000000000 is none):"
grep CapEff /proc/self/status
echo "4. User (0 is root):"
id -u
echo "5. Root filesystem: can it write?"
touch /.write-test 2>/dev/null && { echo "   writable"; rm /.write-test; } || echo "   read-only"
echo "6. Kernel (compare with uname -r on the host):"
uname -r
```

We ran it on Docker 29 in two containers, one on default settings and one locked down with these flags:

```sh
docker run --network=none --cap-drop=ALL --user 1000 --read-only ...
```

| Check | Default Docker | Locked down |
| --- | --- | --- |
| Outside DNS | Answers | No answer |
| Outside web | HTTP 200 | Blocked |
| Capabilities | Docker's default set | None |
| User | Root | Non-root |
| Root filesystem | Writable | Read-only |
| Kernel | Shared with the host | Shared with the host |

Two things the results do not show. Cutting the network completely is the bluntest answer, and an agent that needs a package mirror or an API needs a filtering resolver and proxy instead. And no flag gives a container its own kernel: that takes gVisor, Kata or Firecracker. This test also only shows the front door. A clean result says nothing about whether your metrics service will fetch a URL for you, which is why point 6 matters.

## How contained is your agent?

Seven questions, one for each point above.

<div class="selfcheck" x-data="cyberSelfCheck">
  <p class="selfcheck__title">Quick self-check</p>
  <fieldset>
    <legend>Is DNS from your agent's environment limited to the domains it needs, with every query logged?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc1" value="yes" x-model="answers.q1"> Yes</label><label><input type="radio" name="sc1" value="no" x-model="answers.q1"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q1 === 'no'" x-cloak>An open resolver is a way out, even when the firewall blocks the web. That is how the 20 September model reached a chatbot.</p>
  </fieldset>
  <fieldset>
    <legend>Have you listed every service its host can reach, and checked whether each can be made to fetch a URL?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc2" value="yes" x-model="answers.q2"> Yes</label><label><input type="radio" name="sc2" value="no" x-model="answers.q2"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q2 === 'no'" x-cloak>Metrics, logging and auth services gave OpenAI's red team limited internet access. Start the list today.</p>
  </fieldset>
  <fieldset>
    <legend>Does code the agent writes run with its own kernel, using gVisor, Kata or Firecracker?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc3" value="yes" x-model="answers.q3"> Yes</label><label><input type="radio" name="sc3" value="no" x-model="answers.q3"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q3 === 'no'" x-cloak>A plain container shares the host kernel. Move untrusted code to a sandbox with its own.</p>
  </fieldset>
  <fieldset>
    <legend>Does it run as non-root, with all capabilities dropped and a read-only root filesystem?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc4" value="yes" x-model="answers.q4"> Yes</label><label><input type="radio" name="sc4" value="no" x-model="answers.q4"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q4 === 'no'" x-cloak>Docker's defaults include CAP_MKNOD, which the critical Kata CVE needed. Start from --cap-drop=ALL.</p>
  </fieldset>
  <fieldset>
    <legend>Are your container runtimes and host kernel on the same patch timeframes as your internet-facing services?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc5" value="yes" x-model="answers.q5"> Yes</label><label><input type="radio" name="sc5" value="no" x-model="answers.q5"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q5 === 'no'" x-cloak>Three kernel bugs and fixes in Kata and gVisor came out of this work. Put them on the patch schedule.</p>
  </fieldset>
  <fieldset>
    <legend>Have you actually tried stopping a running agent in the last three months?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc6" value="yes" x-model="answers.q6"> Yes</label><label><input type="radio" name="sc6" value="no" x-model="answers.q6"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q6 === 'no'" x-cloak>OpenAI's run went on for about two and a half hours after the alert. Name who can stop it, then run the drill.</p>
  </fieldset>
  <fieldset>
    <legend>Have you asked an agent, in a copy of your environment, to reach a server you control?</legend>
    <div class="selfcheck__opts"><label><input type="radio" name="sc7" value="yes" x-model="answers.q7"> Yes</label><label><input type="radio" name="sc7" value="no" x-model="answers.q7"> No / not sure</label></div>
    <p class="selfcheck__fix" x-show="answers.q7 === 'no'" x-cloak>It costs an afternoon. Whatever it finds, you find first.</p>
  </fieldset>
  <p class="selfcheck__note" x-show="!done">Count your "no" answers. Each one is a route out, or a way of not noticing.</p>
  <div class="selfcheck__result" x-show="done" x-cloak aria-live="polite">
    <p x-show="level === 'low'"><strong>No gaps on these seven questions.</strong> You are ahead of most teams. Repeat the red-team test whenever the environment changes.</p>
    <p x-show="level === 'some'"><strong><span x-text="gaps"></span> gap<span x-show="gaps > 1">s</span>.</strong> Start with DNS and the kill switch: both are quick, and both failed for OpenAI on 20 September.</p>
    <p x-show="level === 'high'"><strong><span x-text="gaps"></span> gaps.</strong> Keep agents away from real credentials and production systems until the first three are closed, or <a href="/contact">talk to us</a> about where to start.</p>
    <button type="button" class="selfcheck__reset" x-on:click="reset()">Start again</button>
  </div>
</div>

None of this is new security advice. What is new is who is testing it. A capable model will try every route out, patiently, and the routes it finds are the ones we leave open because they are boring.

---

If you are putting agents near real systems and want a second pair of eyes on the sandbox, the egress rules and the DNS, our [DevOps consulting](/services/managed-linux-infrastructure/devops-consulting-perth) and [cyber security](/consulting/cybersecurity) teams can review it with you. Or just [get in touch](/contact).

**Related reading:** [AI Agents Built a Message Board and Broke Out](/openai-agents-hugging-face-incident) and [GLM-5.3: Anyone Can Now Download an AI That Breaks Into Software](/glm-5-3-open-weight-cyber-capabilities).

**Photo credit.** Hero image: the server room at the Duga-1 radar site &mdash; [Joël van der Loo](https://commons.wikimedia.org/wiki/File:Duga-1_radar_data_center_interior_server_room_2018.jpg), [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/), via Wikimedia Commons.

## Sources

- [Securing our frontier model training environment](https://openai.com/index/securing-our-frontier-model-training-environment/) &mdash; OpenAI, 23 October 2026. The containment design, the red-teaming campaign and its findings, and the 1 October restart.
- [An agent used DNS to reach an external chatbot](https://alignment.openai.com/misalignment-reports/an-agent-used-dns-to-reach-an-external-chatbot/) &mdash; OpenAI misalignment report, last updated 25 September 2026. The 20 September incident, timeline and fixes.
- [The Hugging Face incident and the road ahead](https://openai.com/index/hugging-face-incident-and-the-road-ahead/) &mdash; OpenAI. The July incident.
- [Patch the Planet](https://openai.com/index/patch-the-planet/) and [Towards safety cases for frontier AI training](https://openai.com/index/towards-safety-cases-for-frontier-ai-training/) &mdash; OpenAI.
- Upstream fixes: [Kata Containers GHSA-wwj6-vghv-5p64 / CVE-2026-24834](https://github.com/kata-containers/kata-containers/security/advisories/GHSA-wwj6-vghv-5p64), [Kata PR 13615](https://github.com/kata-containers/kata-containers/pull/13615), [Kata PR 13587](https://github.com/kata-containers/kata-containers/pull/13587), [gVisor PR 13816](https://github.com/google/gvisor/pull/13816), [moby/profiles PR 39](https://github.com/moby/profiles/pull/39), and Linux kernel commits [fa091f4](https://github.com/torvalds/linux/commit/fa091f46c3833fb22384f10eade2b4e1e1d0b278), [594d905](https://github.com/torvalds/linux/commit/594d905195024b228c962627ae5ae7c17bd582a4) and [992cc9f](https://github.com/torvalds/linux/commit/992cc9f94ca924089a506ba9b327caa9af797529).
