OpenAI Builds Defense Factory to Find and Fix Vulnerabilities Continuously

The company’s internal system moves from finding potential bugs to testing patches and checking deployed fixes. Its harder challenge is building enough isolation, evidence and human oversight to make that automation safe at scale.

By 3 min read
OpenAI Builds Defense Factory to Find and Fix Vulnerabilities Continuously
OpenAI Builds Defense Factory to Find and Fix Vulnerabilities Continuously

Listen to this story

The audio brief

About 1:39
0:001:39
Read transcript
OpenAI is turning its internal vulnerability response into what it calls the Defense Factory: an automated loop that investigates suspected flaws, prepares tested patches, and checks whether those fixes actually reach production. The system combines OpenAI’s Codex model with isolated development environments, so agents can work on temporary copies of code, dependencies, and services without directly touching live systems. The effort grew out of a security sprint involving more than 250 people across over 100 service areas. OpenAI says 90.6 percent of routed findings received accepted ownership assignments, while 37 percent were identified as duplicates. After runtime validation, its reported false-positive rate was 0.81 percent. Fixes generated during the sprint were entirely Codex-based, and the rollback rate was 0.53 percent. But the numbers also show where automation still breaks down. Only 19.5 percent of findings were reproduced at runtime, largely because environments were difficult to set up consistently. OpenAI also discovered that a merged patch was not necessarily deployed, so it expanded independent post-deployment checks. That is why the factory starts with small, reviewed batches. Human oversight remains in place for consequential changes, while autonomy expands only when results earn trust. OpenAI says Cloudflare, Ramp, and Google are exploring similar approaches. The key constraint is whether isolated testing, ownership, and deployment evidence can remain reliable as more of the security loop becomes automated.

Story brief

3 key points

OpenAI has formalized its internal cyber-response work into the “Defense Factory,” an agent-based system that uses Codex and isolated environments to investigate findings, propose tested patches, and verify deployment. In a security sprint spanning more than 250 staff and 100 service areas, it reports 90.6% accepted ownership routing, 37% duplicate findings, a 0.81% post-runtime false-positive rate, and a 0.53%...

  1. 01

    Only 19.5% of findings were reproduced at runtime, reflecting environment-setup limits that constrained which services could be tested.

  2. 02

    OpenAI found merged patches were not always deployed, so it expanded independent post-deployment verification.

  3. 03

    The workflow starts with small reviewed batches; autonomy increases only after results earn trust.

OpenAI is trying to turn internal vulnerability response from a series of handoffs into an automated loop that can investigate suspected flaws, prepare tested fixes and check whether repairs reach production. The company has now described that effort as the Defense Factory, a continuous, agent-first security operation built around Codex, existing engineering tools and isolated development environments.

The announcement follows an internal security sprint in which OpenAI says it mobilized more than 250 people across more than 100 service areas. The company says its latest cyber models were used to find, validate and fix vulnerabilities across OpenAI, framing the sprint as the starting point for an ongoing defensive system rather than a one-time cleanup.

A loop, not a scanner

The proposed workflow begins with an inventory of systems and their owners, then moves through discovery, runtime testing, ownership assignment and verified remediation. The goal is to shorten the path from a security finding to an evidence-backed fix, while preserving information from earlier runs so agents can focus on changed systems and unresolved risks.

Its technical premise is that agents need reproducible environments: temporary, isolated copies of code, dependencies and services where they can try to reproduce a reported vulnerability and test a proposed patch. OpenAI’s architecture adds a control plane for orchestration, policy enforcement and credential proxying, alongside those isolated environments.

The sprint’s reported checkpoints
90.6%Accepted ownership after routing

OpenAI says 90.6% of routed findings received accepted ownership assignments.

37%Findings identified as duplicates

OpenAI says it identified 37% of findings as duplicate issues during triage.

0.81%False-positive rate after runtime validation

OpenAI reports a 0.81% false-positive rate after dynamic validation; it says 19.5% of findings were reproduced at runtime.

The bottlenecks appeared before the patches

OpenAI’s results show why a system that simply finds more bugs is not enough. Early ownership lookup depended on people locating the right team. Its severity labels varied with agent instructions. And environment setup limited which findings could be tested at runtime, forcing the company to start with selected services it could run repeatedly.

What the factory is meant to add

  • Automatic investigation when a finding arrives, instead of waiting for a person to pick it up.
  • Testing for exploitability and duplicate reports before a finding is prioritized and routed.
  • Tested patch proposals for reviewers, followed by independent checks of deployed fixes.

OpenAI says remediation during the sprint was entirely Codex-based, with agents generating patches and testing them in the isolated environments. It reports a 0.53% rolled-back fix rate. But the company also found that a merged patch was not necessarily deployed across its systems, prompting an expanded verification effort after an initial trial.

Autonomy has a boundary

OpenAI says it began with small, reviewed batches and removed manual steps only as the results earned trust. People review consequential changes and independently verify deployed fixes. That makes the Defense Factory an effort to automate routine investigation and repair preparation, not a claim that agents should make final security decisions alone.

OpenAI says Cloudflare, Ramp and Google are also exploring continuous agent-based cyber defense approaches. The immediate unresolved test is whether this model can maintain reliable validation and deployment checks as more of the workflow becomes automated.

Editorial analysis

Our Read

The notable step is not merely that OpenAI used Codex to generate patches. It is the attempt to turn security work into a repeatable operational loop: maintain an inventory, test whether a reported flaw is real, route it to an owner, prepare a fix and check the deployed result. The company’s own account also shows why that is difficult. Duplicate reports, incomplete runtime environments and the gap between merged and deployed code can each break the chain. The evidence to watch next is whether OpenAI publishes results from the continuous operation beyond its initial sprint, especially on deployed-fix verification and human-review boundaries.

Sources

  1. openai.comDefense Factory | OpenAI

Loading discussion...