How Mozilla uses GPT-6 Cyber to find and fix Firefox vulnerabilities

Mozilla partnered with OpenAI to build an agentic security pipeline that uses AI agents to discover, verify, deduplicate, prioritize, and help fix Firefox vu

By Sean Weldon

How Mozilla Uses GPT-6 Cyber to Find and Fix Firefox Vulnerabilities

Abstract

This synthesis examines a collaboration between Mozilla and OpenAI that applied autonomous AI agents to the discovery, verification, deduplication, prioritization, and remediation of security vulnerabilities in Firefox. The reported architecture couples an outer targeting layer - driven by Large Language Model (LLM) risk scoring over source files - with an inner agentic harness that forms, tests, and deterministically verifies bug hypotheses inside isolated virtual machines. A secondary judge agent audits findings for gaming behavior and assigns severity, yielding a low reported false-positive rate. Variant and commit scanning extend discovery beyond initial findings, with variant scans accounting for the majority of monthly bugs by September 2026. The program reports an approximately 8x year-over-year increase in both bug discovery and fixes from 2025 to 2026, and no successful Firefox compromise at Pwn2Own 2026. Findings indicate that organizational readiness, not model capability alone, governs the throughput of agentic security programs, and that triage and remediation - not discovery - become the binding constraints at scale.

1. Introduction

Browser security occupies an unusual position in software assurance: the attack surface is continuously exposed to adversarial web content, the codebase is large and long-lived, and exploitation consequences are immediate. Pwn2Own, the annual competition in which researchers demonstrate working exploits against production software, has long served as a proxy signal for the state of browser exploitability. Mozilla reportedly treats the event as a fire drill for real-world, actively exploited security-critical bugs rather than as a reputational contest.

In the 2026 edition, competitors increasingly relied on agentic scanning tools of their own, producing a surge of registered attacks against Firefox ahead of the event. OpenAI's cyber team, working with Mozilla's red team, filed several bugs shortly before the competition that were fixed and uplifted quickly. A notable number of competitor submissions were later found to rely on exactly the bugs OpenAI had already discovered and Mozilla had already patched. The result was that nobody was able to pwn Firefox at Pwn2Own 2026 - a direct, falsifiable outcome attributable to the pipeline described in this synthesis.

The central question addressed here is whether autonomous agents can shift vulnerability discovery from a human-rate-limited process to an infrastructure-rate-limited one, and what new bottlenecks emerge when that shift occurs. The evidence suggests that discovery scales readily, while triage and remediation become the binding constraints. This synthesis proceeds as follows: Section 2 establishes the organizational and tooling preconditions; Section 3 analyzes the pipeline architecture, triage mechanics, and scanning strategies; Section 4 consolidates actionable technical findings; Section 5 discusses implications and open problems; Section 6 concludes.

2. Background and Related Work

The program did not emerge from a standing start. Decades of accumulated practice functioned as latent infrastructure that agents could reuse: an external bug bounty program, which normalized the intake of findings from untrusted third parties; early internal adoption of address sanitizers and fuzzers within the red team, producing instrumented, debuggable builds; engineering processes tuned for triaging high volumes of external reports and shipping fixes rapidly through release tracking and uplift mechanisms; and internal technical documentation and a formalized threat model developed over years.

Consequently, the agentic system inherited tooling designed for human and external researchers. This is a material point: the fuzzing toolchains, sanitizer builds, and release-tracking workflows that made external submissions tractable also made agent submissions tractable. Organizations lacking deterministic crash reproduction or fast uplift paths would face the same discovery volume without a corresponding ability to absorb it - a theme that recurs throughout the analysis of scaling fixes in Section 3.

3. Core Analysis

3.1 Pipeline Architecture

The pipeline decomposes into two nested layers. The outer targeting layer selects what to scan: an LLM scores source files for risk using features such as exposure to web content and memory safety characteristics, combined with scan history, to choose the next batch of targets. An initially simple scoring model proved adequate for low-hanging fruit but required refinement as that surface was exhausted. Scoring prompts incorporate Mozilla's internal documentation and threat model, grounding target selection in institutional knowledge rather than generic heuristics.

The inner agentic security harness performs discovery itself. An agent runs inside its own VM with access to Firefox source code and the fuzzing toolchain, given a target and a goal to find a bug. It forms bug theories through static analysis, tests them dynamically - sometimes writing mini fuzzers of its own - and iterates until it reaches deterministic verification, such as producing an HTML test case that reliably causes a crash. A second judge agent then reviews the finding, checking for gaming behavior (for example, an agent patching code to artificially induce a crash rather than discovering a genuine bug) and assigning a severity grade. This two-agent check-and-verify structure is reported to produce a very low false-positive rate, which Mozilla treats as essential to avoiding wasted engineer time on invalid reports. Once verified, an agent drafts a fix patch and a test, with results written to storage buckets and pulled into a local workbench for human review.

3.2 Deduplication and Prioritization

Scaling discovery surfaced an unanticipated bottleneck: deduplication proved harder than expected. Similar crash stacks can represent genuinely different underlying bugs, while structurally different stacks can represent the same bug. Mozilla's approach ingests findings into a local database and gives an agent access to perform deduplication, tuned by a human feedback loop that balances leniency. Filing too liberally spams engineers with near-duplicates; filing too conservatively risks dropping real bugs from the tracker. As a mitigation, when a bug lands and other reports were marked as duplicates of it, the team re-verifies that those duplicates still fail to reproduce, catching deduplication errors after the fact rather than before.

A further complication is that more capable cyber models, including GPT-6 Cyber, have re-discovered previously low- or moderate-severity bugs and shown them to actually be security-high by bypassing architectural hardening that had been assumed to contain them. This severity re-evaluation function helps Mozilla redirect engineering attention and identify areas requiring improved defense-in-depth, independent of whether the underlying bug itself is newly discovered.

3.3 Variant and Commit Scanning

Two scanning modes extend discovery beyond first-pass hunting. Variant scanning bundles a known bug - fixed or still open - and tasks an agent with hunting for the same pattern elsewhere in the codebase, whether nearby or structurally distant from the original location. Commit scanning is narrower in scope, examining each new commit for vulnerabilities as it lands. By September 2026, variant scans had become the majority of bugs found per month, and this mode tends to produce fewer duplicate bugs than other discovery methods, likely because the search is anchored to a specific, well-characterized pattern rather than open-ended. Patterns extracted from bugs fixed in 2025 were specifically reused to locate long-lived instances of the same pattern elsewhere in the codebase, illustrating a compounding-returns effect: each fixed bug becomes a search template for others.

3.4 Scaling Fixes and the Workbench

Agent-generated patches function as a helpful starting asset but are often not directly landable. Patches tend to be too narrowly scoped to the specific crash or test case, or lack broader codebase context that a human engineer would bring to a fix. No single technique was identified that makes generated patches automatically landable; instead, Mozilla relies on a human workflow in which an expert browser engineer reviews the bug report and the agent-generated patch, writes or refines the actual fix, obtains peer review, and lands it. This human-in-the-loop remediation step, rather than discovery, is the apparent rate-limiter on overall throughput, even as discovery and fixes both increased approximately 8x from 2025 to 2026.

Supporting this entire process is an agentic vulnerability workbench: all signals - scan runs, bugs, engineer comments - are ingested into a single SQLite file on the red team engineer's local machine. Engineers query this database through a coding agent rather than relying on hardcoded rules; for instance, a coding agent can replace a static rule such as "scan if not scanned in N days with high risk score" by reasoning over the database directly and responding to ad hoc hints, including those raised in Slack. Agents can also pull raw traces and logs to diagnose harness failures. When agents encounter environment issues, such as a missing system dependency, they are instructed to write a blockers.yaml file rather than attempt risky workarounds, preserving a clean feedback loop for updating VM images.

4. Technical Insights

Several implementation patterns generalize beyond this specific case. First, deterministic verification gates - requiring reproducible proof such as a crash-inducing test case - are a necessary complement to LLM-based discovery, since unverified agent claims are not trustworthy at scale. Second, a second judge agent checking for reward-hacking behavior (e.g., an agent patching code to fabricate a crash) is a practical mitigation for a known failure mode of autonomous verification loops. Third, deduplication across semantically similar but syntactically different findings remains an open engineering problem better solved with a tunable, human-supervised agent than with fixed matching rules. Fourth, storing all pipeline state in a single queryable database (here, SQLite) and exposing it to a coding agent allows ad hoc policy changes without rewriting scanning logic. Fifth, structured failure reporting (blockers.yaml) over autonomous workaround behavior reduces the risk of agents silently corrupting their own execution environment. Finally, variant scanning - reusing fixed bugs as search templates - appears to offer a favorable precision/recall trade-off relative to open-ended scanning, at the cost of being bounded by the diversity of previously known bug patterns.

5. Discussion

The central finding - that discovery scales but remediation does not scale correspondingly - has broader implications for how organizations should sequence investment in agentic security. Enterprises considering similar pipelines should recognize that the binding constraint is not model capability but organizational absorption capacity: fast release/uplift tracks, existing fuzzing infrastructure, and engineer bandwidth for reviewing and landing fixes. Mozilla's decades of bug-bounty and fuzzing practice functioned as prerequisite infrastructure rather than incidental history.

A further implication concerns model diversity. The observation that different models find different bugs even after the code has been scanned multiple times suggests that bug discovery coverage is not a property of a single model's capability ceiling but of ensemble diversity across models and scanning strategies. This raises an open question for future investigation: whether coverage gains from adding additional distinct models eventually saturate, and how organizations should allocate compute between breadth (more models/strategies) and depth (more iterations per model).

Finally, the re-discovery of previously low/moderate-severity bugs as actually security-high by more capable models (GPT-6 Cyber) indicates that severity assessments are themselves time-varying artifacts of model capability, not fixed properties of a bug. This has implications for how organizations should treat historical severity ratings as cyber models continue to improve.

6. Conclusion

This synthesis documents an agentic security pipeline in which LLM-driven targeting, VM-isolated bug-hunting agents, deterministic verification, and judge-agent auditing combine to produce an approximately 8x year-over-year increase in both vulnerability discovery and fixes, alongside a successfully defended Pwn2Own 2026. The practical takeaway is that agentic discovery tooling is only as valuable as the triage, deduplication, and remediation infrastructure built to absorb its output; organizations adopting similar approaches should prioritize release velocity and database-backed triage tooling alongside discovery capability. Mozilla's stated long-term goal of zero bugs in Firefox, combined with expanding commit scanning to catch regressions before they land, suggests the next phase of this work will shift emphasis from discovery volume toward prevention at the point of code introduction.


Sources


About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub

Sean Weldon builds apps and custom software at 22Atlas.

Start your build

More about Sean