OpenAI
As automated exploit costs approach zero, organizations must deploy frontier models to find and patch code flaws before matching offensive capabilities proliferate to attackers.
AI-assisted summary of Codex Security: From Vulnerability to Verified Fix | DevDay 2026 — original source. Check the original for full context.
Source published:
Key ideas
- OpenAI announced Codex Security as an open-source Apache 2.0 CLI and SDK alongside a managed turnkey cloud platform powered by the specialized Daybreak Blue security model. (2:12)
- During an internal security sprint allocating 25% of product engineers, automated validation and deduplication reduced false positive vulnerability alerts to 0.81% and patch rollbacks to under 1%. (2:12)
- Frontier models currently maintain a temporary advantage over open-weight models in cyber exploitation, creating an urgent 'defender's window' to scan and remediate codebases before automated offensive capabilities proliferate. (0:22)
- On the PatchBench evaluation suite, 6 Astra operating at medium reasoning outperformed 5.6 Sol at extra-high reasoning while cutting compute costs by more than half. (16:00)
Detailed notes
## Background Published by OpenAI on YouTube on November 11, 2026, this DevDay presentation demonstrates how to identify and remediate code vulnerabilities using OpenAI's cyber models and open-source tooling. The session draws directly from OpenAI's own internal infrastructure security sprint to explain how teams can scan large codebases, catch bugs in pull requests, and deploy verified automated patches.
## TL;DR OpenAI cyber product engineers Ian and Kyle present the concept of the 'defender's window,' arguing that organizations must proactively leverage frontier AI capabilities to fix vulnerabilities before offensive exploitation costs drop to zero. Drawing on an internal sprint where 25% of OpenAI's product engineering workforce mobilized to build an automated continuous security pipeline, they walk through the architecture of the open-source Codex Security CLI. The talk demonstrates how multi-tiered context, parallelized deep scans, agentic deduplication, and adversarial patch verification enable automated fixes with sub-1% rollback rates, concluding with benchmarks for the Astra model and the introduction of Codex Security Cloud powered by Daybreak Blue.
## Atmosphere & style The presentation strikes an urgent yet pragmatic and technically grounded tone, balancing the existential stakes of shifting cyber economics with candid developer realities. Ian and Kyle maintain a collaborative, fluid rhythm on stage, interspersing serious discussions of vulnerability triage and model efficiency with relatable live-demo moments, such as Kyle joking about his nervous habit of making vocal sound effects while operating the presentation clicker. The session follows an encouraging arc, moving from the overwhelming initial dread of alert fatigue and massive issue backlogs to the reassuring calm of an automated steady-state defense pipeline.
## Bulletin - [02:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=132s) OpenAI announced Codex Security as an open-source Apache 2.0 CLI and SDK alongside a managed turnkey cloud platform powered by the specialized Daybreak Blue security model. - [02:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=132s) During an internal security sprint allocating 25% of product engineers, automated validation and deduplication reduced false positive vulnerability alerts to 0.81% and patch rollbacks to under 1%. - [00:22](https://www.youtube.com/watch?v=gUQN7juxvVI&t=22s) Frontier models currently maintain a temporary advantage over open-weight models in cyber exploitation, creating an urgent 'defender's window' to scan and remediate codebases before automated offensive capabilities proliferate. - [16:00](https://www.youtube.com/watch?v=gUQN7juxvVI&t=960s) On the PatchBench evaluation suite, 6 Astra operating at medium reasoning outperformed 5.6 Sol at extra-high reasoning while cutting compute costs by more than half.
## Key takeaways - [00:22](https://www.youtube.com/watch?v=gUQN7juxvVI&t=22s) The marginal cost of software exploitation is approaching zero as frontier AI models uncover dormant vulnerabilities across widely used codebases. - [00:22](https://www.youtube.com/watch?v=gUQN7juxvVI&t=22s) A temporary 'defender's window' exists because frontier models currently lead open-weight models in cyber capability, giving defenders an asymmetric advantage to remediate flaws first. - [02:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=132s) OpenAI mobilized a company-wide security sprint reallocating a quarter of product engineering to build an automated, continuous 'defense factory.' - [04:21](https://www.youtube.com/watch?v=gUQN7juxvVI&t=261s) Unconstrained agent scanning failed to generate high-fidelity alerts; actionable results required targeted scan scopes combined with shared knowledge bases. - [04:21](https://www.youtube.com/watch?v=gUQN7juxvVI&t=261s) OpenAI decentralized threat modeling by establishing repository-level security.md files to define architectural constraints and threat boundaries. - [07:54](https://www.youtube.com/watch?v=gUQN7juxvVI&t=474s) The codex-security CLI runs parallelized deep scans that iteratively explore code paths and reachability until issue discoveries plateau. - [09:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=552s) Deduplication became the primary scaling bottleneck, with OpenAI discovering that 36% of all raw scan findings across monorepos were redundant duplicates. - [11:43](https://www.youtube.com/watch?v=gUQN7juxvVI&t=703s) Enrichment pipelines automate triage by scoring issues against organizational criticality rubrics and routing them through codified service ownership rules. - [12:42](https://www.youtube.com/watch?v=gUQN7juxvVI&t=762s) Automating patches should be approached as a gradual dial rather than a switch, relying on validation prompts and ephemeral test environments to build confidence. - [12:42](https://www.youtube.com/watch?v=gUQN7juxvVI&t=762s) An adversarial 'verify fix' agent subjects proposed patches to hostile regression tests prior to entering standard software development lifecycle pipelines. - [16:00](https://www.youtube.com/watch?v=gUQN7juxvVI&t=960s) Benchmark results on PatchBench show model patching speeds and pass rates surpassing OpenAI's internal baseline human engineering average of approximately 50%. - [17:03](https://www.youtube.com/watch?v=gUQN7juxvVI&t=1023s) Organizations adopt a predictable adoption curve that begins with heavy backlog triage and transitions into continuous, automated pull requests catching vulnerabilities on push. - [17:03](https://www.youtube.com/watch?v=gUQN7juxvVI&t=1023s) Codex Security Cloud provides a managed continuous monitoring loop via a Codex plugin, using the Daybreak Blue model to auto-generate pull requests directly to GitHub.
## Detailed walkthrough ### [00:22](https://www.youtube.com/watch?v=gUQN7juxvVI&t=22s) The Defender's Window and the Changing Cyber Landscape
Ian and Kyle introduce their work on the cyber product engineering team at OpenAI. While Kyle’s day-to-day focus centers on developing the open-source Codex Security CLI, Ian frames the broader existential shift currently underway across the software industry. The economics of offensive software exploitation are fundamentally destabilizing: the cost to discover and exploit software vulnerabilities is rapidly approaching zero. Over recent months, frontier AI models have demonstrated the capability to uncover thousands of previously dormant security vulnerabilities buried deep inside critical software systems relied upon daily.
Crucially, frontier models currently maintain a technical lead over open-weight models in cyber capabilities. Ian explains that this asymmetry creates a temporary strategic advantage known as the "defender's window." This brief period provides organizations and open-source maintainers an opportunity to proactively uncover and remediate flaws before those same offensive capabilities proliferate into widespread, unregulated tooling.
Ian makes the team's urgency unmistakable when discussing this temporary operational advantage: “This is a window of opportunity to find and fix weaknesses before the same capabilities become widely available and fall into the hands of attackers.”
- Frontier AI models currently outperform open-weight models in complex cybersecurity identification and remediation tasks. - The shrinking economic cost of vulnerability exploitation necessitates offensive-style automated discovery for defenders before exploit tooling democratizes. - Defensive AI scanning is positioned as essential not only for enterprise infrastructure, but equally for open-source repositories and personal software projects.
[02:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=132s) Building the Defense Factory: OpenAI's Internal Security Sprint
To validate these security capabilities in a production environment, OpenAI made internal infrastructure security a top company priority. Several months prior, the company mobilized a major internal security sprint, assigning a full quarter of its product engineering workforce exclusively to identifying, verifying, and patching vulnerabilities across their entire internal codebase.
This company-wide push laid the operational groundwork for what OpenAI calls its internal "defense factory." Rather than treating security as an intermittent checklist, the defense factory operates as an automated, continuous loop: scanning repositories, validating theoretical bugs into confirmed issues, routing findings to domain owners, and verifying generated fixes. The system achieved a 0.81% false positive rate through automated deduplication and agentic validation, while patches generated by Codex achieved a production rollback rate of less than 1%. OpenAI translated the lessons, pipelines, and tooling learned from this sprint into the Codex Security product suite, spanning an Apache 2.0 open-source CLI, an SDK, plugins, and the newly announced turnkey Codex Security Cloud.
Ian explains the dedication required to run this operation at scale: “That meant committing the people, the time, the resources to find and fix vulnerabilities as a top priority.”
- 25% of OpenAI's product engineers were reallocated during the dedicated internal security sprint. - Automated validation and deduplication reduced false positive vulnerability alerts down to 0.81%. - Automated code fixes authored with Codex assistance yielded a rollback rate of under 1%. - Codex Security is structured as an open-source CLI, SDK, and IDE/CI plugin, alongside the managed turnkey Codex Security Cloud.
[04:21](https://www.youtube.com/watch?v=gUQN7juxvVI&t=261s) Context is Key: Structuring Scan Instructions and Knowledge Bases
Kyle outlines the five core stages derived from OpenAI's internal sprint: establishing agent context, running targeted scans, enriching findings, generating patches, and embedding automation into the software development lifecycle (SDLC). The CLI is entirely open source under the Apache 2.0 license. In early iterations, pointing an autonomous agent at OpenAI's massive repositories with a blanket instruction to locate all bugs failed to generate actionable results. To produce precise security findings, scans had to be fanned out across distinct subcomponents, with each agent equipped with system context that code alone cannot convey.
To solve this, OpenAI split agent context into two tiers: 1. **Narrow Scan Instructions:** A specific instruction file (`prompt.md`) detailing the exact scope, specific target directories, and precise vulnerability classes for that run. 2. **Shared Knowledge Bases:** Reusable documentation shared across scanners and validators containing architectural diagrams, network boundary rules, and cloud firewall configurations.
To decentralize security governance, OpenAI engineering teams also adopted `security.md` files committed directly alongside code components—analogous to `agents.md` files—empowering individual product owners to define their own threat boundaries and security constraints.
Reflecting on their initial, unconstrained scanning attempts, Kyle remarks: “Pointing an agent scanner at our repositories and saying, find all vulnerabilities, make no mistakes, didn't really cut it.”
```mermaid flowchart TD accTitle: Codex Security Context and Scan Pipeline accDescr: Diagram illustrating how targeted prompts and shared knowledge feed into parallel agent scans and deduplication. subgraph Context["1. Context Layer"] A["Scan Scope & Vulnerability Targets (prompt.md)"] B["Knowledge Base (Architecture & Firewalls)"] C["Component Threat Models (security.md)"] end subgraph Execution["2. Parallel Deep Scan"] D["Multi-Agent Scan Fleet"] E["Iterative Validation Passes"] end subgraph Triage["3. Enrichment & Triage"] F["AI Deduplication Engine"] G["Criticality Rubric & Owner Assignment"] end
A --> D B --> D C --> D D --> E E --> F F --> G ```
[07:54](https://www.youtube.com/watch?v=gUQN7juxvVI&t=474s) Executing Deep Scans in Parallel
Demonstrating the Codex Security CLI on an example repository, Kyle illustrates how context files translate into command-line execution. After inspecting `prompt.md` (which isolates targeted vulnerability classes) and reviewing the architecture documentation in the knowledge base file, the scanner is launched using `codex-security scan deep`.
A deep scan fans out multiple agent processes in parallel. Agents run iterative discovery loops: probing code paths, attempting to validate reachability, checking configurations against the knowledge base, aggregating outputs, and initiating follow-up passes until no additional novel issues are detected or the preconfigured scan limit is reached. A comprehensive codebase scan takes significant compute time, prompting Kyle to fast-forward through the live output while joking with the audience about his nervous habit of making vocal sound effects while operating the presentation clicker.
Describing the underlying mechanics of the command, Kyle states: “The deep scan runs multiple security scans in parallel with agents investigating and validating potential vulnerabilities.”
- Custom CLI arguments pass both ephemeral prompt instructions and persistent knowledge bases into the scanner engine. - Parallelized deep scans re-scan dynamically until findings saturate or hit user-defined execution boundaries.
[09:12](https://www.youtube.com/watch?v=gUQN7juxvVI&t=552s) Tackling the Deduplication Bottleneck and Enriching Findings
Running fleets of hundreds of agent workers across distinct hosts and monorepo components introduced OpenAI's first major scaling bottleneck: finding deduplication. Tens of thousands of raw alerts flowed into the pipeline, many referencing the identical root cause from different entry points. Because assigning dozens of repetitive tickets to engineering teams risks severe fatigue and friction, OpenAI built an agentic deduplication workflow into the CLI to consolidate overlapping issues prior to human triage.
During OpenAI's internal security sprint, deduplication revealed that more than a third of all generated alerts were redundant. Once deduped, the remaining findings entered an enrichment phase tasked with answering two questions: how critical the issue is to OpenAI, and which engineering team owns the code. Criticality was initially defined as any vulnerability granting unauthorized external actors access, though refining this rubric required repeated iteration as unique system edge cases emerged.
Kyle highlights the developer friction that motivated his work on deduplication: “In our internal sprint, we found that across all of the scans, 36% of our findings were duplicates.”
- Hundreds of scanner instances distributed across multiple hosts produced tens of thousands of initial findings. - 36% of all raw scan findings across OpenAI's codebases were identified as duplicates. - Automated deduplication avoids developer alert fatigue, such as engineers receiving dozens of redundant tickets at 1:00 AM for a single bug. - Triage enrichment maps findings against custom criticality rubrics and automatically pinpoints product owners.
[11:43](https://www.youtube.com/watch?v=gUQN7juxvVI&t=703s) Prioritizing Findings and Solving Ownership Bottlenecks
Kyle explains that once scanners generate output, the findings must fit into an organization's internal rubric. Running issues through the Codex Security CLI against that rubric produces a prioritized queue aligned with company priorities—or an indie developer's personal concerns. However, prioritizing is only half the battle; routing the issue to the correct team turned out to be unexpectedly painful. As Kyle emphasizes: “Knowing who owns what in a company that's moving so fast and growing so quickly took actually a large amount of human effort.”
Once OpenAI codified service and code ownership into a formal ruleset, they eliminated friction, enabling automated, accurate assignment of findings with minimal ticket churn.
```mermaid flowchart LR accTitle: Vulnerability Triage and Assignment Workflow accDescr: Pipeline showing raw findings filtered by a custom rubric into a prioritized backlog and routed by ownership rules. subgraph Triage["Triage Stage"] A["Raw Scanner Findings"] --> B["CLI + Custom Rubric"] B --> C["Prioritized Backlog"] end subgraph Routing["Assignment Stage"] C --> D["Codified Ownership Rules"] D --> E["Assigned Engineering Teams"] end ```
[12:42](https://www.youtube.com/watch?v=gUQN7juxvVI&t=762s) From Human-in-the-Loop to Auto-Generated Patches and Adversarial Verification
Addressing findings initially required engineers to manually review assigned tickets, prompt Codex to write a solution, shepherd the pull request through reviews, and deploy it to production. Over time, the team moved toward generating patches automatically. Kyle acknowledges the natural developer hesitation toward automated code modifications, remarking: “Which, that thought process is why we found this process is more of a dial that you turn up, not a switch that you flip on.”
Confidence grew as contextual safeguards matured. Using the CLI's `patch` command, developers can supply a `--validation-prompt-file` flag that guides the agent on spinning up test environments, assessing behavior, and drafting a pull request. Because of rigorous pre-merge validation, the internal deployment achieved an exceptionally low rollback rate of 0.81% across tens of thousands of findings. To guarantee correctness, OpenAI built a `verify fix` command acting as an adversarial agent against the generated patch, subjecting it to hostile tests to confirm the vulnerability is eliminated before it enters the standard software development lifecycle (SDLC).
- **`patch` CLI command**: Consumes vulnerability data and a validation prompt to set up ephemeral dev environments and generate pull requests. - **Rollback reliability**: Achieved a sub-1% rollback rate (specifically 0.81%) on auto-generated remediation patches inside OpenAI. - **Adversarial verification**: The `verify fix` utility pits an adversarial evaluation agent against the proposed fix to prevent incomplete or regressive patches. - **SDLC integration**: The output is designed to seamlessly slot into existing code reviews, QA stages, and release pipelines.
[16:00](https://www.youtube.com/watch?v=gUQN7juxvVI&t=960s) Model Benchmarks: PatchBench and Astra Efficiency
Ian takes over to detail the performance leaps observed in patch quality and compute costs, demonstrating results from PatchBench—an external evaluation benchmark comparing model capabilities using Codex Security's patch skill. In these evaluations, 6 Astra operating at medium reasoning comfortably outstripped 5.6 Sol at extra-high ("X-high") reasoning, while requiring less than half the financial cost per test case.
Human performance at OpenAI hovers around the 50% mark on the benchmark, placing Astra's automated patching abilities well ahead of standard baseline human speeds. Ian notes that engineering continues to work in lockstep with the research team to translate underlying model breakthroughs directly into defender capabilities.
| Model / Baseline | Reasoning Tier | Benchmark Performance | Relative Cost | |:--- |:--- |:--- |:--- | | **5.6 Sol** | Extra-High (X-High) | Lower than Astra Medium | >2x cost per case | | **6 Astra** | Medium | Outperforms 5.6 Sol X-High | <0.5x cost per case | | **Human Engineers (OpenAI)** | N/A | ~50% baseline | High human effort |
[17:03](https://www.youtube.com/watch?v=gUQN7juxvVI&t=1023s) The Defender's Curve, Codex Security Cloud, and Availability
Reflecting on OpenAI's internal rollout curve, Ian outlines the shift from drowning in security alerts to reaching an operational steady state. Early adoption is dominated by an intimidating backlog of deduplication, validation, and remediation. However, as the backlog is eliminated, organizations hit a thin tail where continuous background scans and automated pull requests catch defects before they ever merge to production.
To help teams that do not want to hand-wire the open-source CLI and SDK into custom GitHub Actions or CI/CD pipelines, Ian highlights Codex Security Cloud (first introduced by Sam Altman in the keynote). Codex Security Cloud provides a turnkey, continuous orchestration loop powered out of the box by the security-specialized Daybreak Blue model without complex approval gates. Demonstrating the workflow, Ian installs the Codex Security Cloud plugin inside Codex, connects a GitHub repository, configures scans to trigger on every push, inspects org-wide issue trends, and auto-generates a direct pull request to GitHub.
- **Codex Security CLI / SDK**: Fully open-source and downloadable via NPM for custom CI/CD setups. - **Codex Security Cloud**: Managed turnkey platform available through the Codex plugin marketplace. - **Daybreak Blue**: Dedicated cyber/security-focused model architecture running under the hood to power automated detection and remediation loops.
## Notable quotes > [00:22](https://www.youtube.com/watch?v=gUQN7juxvVI&t=22s) This is a window of opportunity to find and fix weaknesses before the same capabilities become widely available and fall into the hands of attackers. — Ian
> [04:21](https://www.youtube.com/watch?v=gUQN7juxvVI&t=261s) Pointing an agent scanner at our repositories and saying, find all vulnerabilities, make no mistakes, didn't really cut it. — Kyle
## Mentioned Ian, Kyle, OpenAI, Codex Security CLI, Codex Security SDK, Codex Security Cloud, Codex, Sam Altman, Daybreak Blue, PatchBench, 5.6 Sol, 6 Astra, Apache 2.0, GitHub, GitHub Actions, NPM
## Video description Find and fix vulnerabilities with OpenAI’s cyber models and open-source CLI and SDK. Learn to scan large codebases, catch issues in pull requests, and verify fixes, drawing on OpenAI’s own security work.
[Source](https://www.youtube.com/watch?v=gUQN7juxvVI)