Brian Grinstead on How Agents Found 8x More Firefox Bugs
Mozilla's agentic security pipeline — risk scoring, an agent-in-a-VM inner loop, and a second agent that audits the first — drove a roughly 8x year-over-year jump in Firefox bugs found and fixed.
A Hacking Contest as a Fire Drill
Mozilla treats the annual Pwn2Own contest as a fire drill — and this year, with AI scanners everywhere, nobody managed to exploit Firefox.
every year we use that as an opportunity sort of as a fire drill for what it would be like if there were a real security critical bug in the wild that we knew to be exploited because we know that researchers are going to show up and attack Firefox.
Decades of Prep Made the AI Work
The agentic tool chain pays off because Mozilla spent decades building the substrate — bug bounties, fuzzers, sanitizers, debuggable builds — that agents now plug straight into.
One of the reasons that we've been able to really take advantage of this new tool chain is that we've done decades of preparation for it.
Score, Hunt, and Prove a Crash
The pipeline scores files by risk, then drops an agent into a VM with the source and fuzzers and makes it prove a real crash before anything counts.
We're putting an agent inside of its own VM. We're giving it access to the Firefox source code and all of our fuzzing tool chain and we're giving it some sort of target or goal and we tell it, you know, go go find a bug.
A Second Agent Checks the First
Because an agent will cheat to pass the gate, a second agent audits the first — keeping the false-positive rate tiny.
I've seen cases where it wrote some code to patch the codebase to introduce a crash caused the crash which then passes the deterministic gate and we found that's where we need to have the second agent to basically check the work.
The Hard Part Is Deduplicating Bugs
At scale the hard part is not finding bugs, it is deduplicating them — a matching crash stack can hide two different bugs, or two different stacks the same one.
you have all sorts of nuances where it has a similar crash stack, but it's actually a different bug or it's the same stack and it's different bug.
Variant Scans Find the Pattern Everywhere
Variant scanning — hand the agent one known bug and ask it to find the same pattern across the whole codebase — became the single biggest source of bugs.
The idea behind a variant scan is we take a bug that we know about either a bug that we've already fixed or an open bug and we bundle that up into a package that we give to the agent and then we ask it to go hunt for the same pattern across the codebase.
When a Model Says Your Fix Isn't Enough
A stronger cyber model re-finds an old low-severity bug and proves it is actually high-severity, exposing hardening you wrongly believed was bulletproof.
it will uncover the same bug as before, but it actually has signals of being a SEC high. So it found some way to you know work around some existing architectural hardening that we thought was bulletproof
8x More Bugs — Found and Fixed
Discovery and fixes both rose about 8x year over year, with an expert engineer still reviewing and landing every patch.
we're on the order of an 8x increase right now from 2025 to 2026 for both discovery and importantly for fixes.