"Google Paused Its Open-Source Bug Bounty. The Real Story Is the Signal-to-Noise Problem AI Just Created"

Earlier this month, Google quietly hit pause on one of the more interesting experiments in open-source security. Its Open Source Software Vulnerability Rewards Program (OSS VRP) — launched in 2022 to pay independent researchers for privately reporting flaws in projects like Go, Angular, and Protocol Buffers — stopped accepting new "product vulnerability" reports as of October 1. The reason, stated plainly by the program's own account, is that its human reviewers are drowning in AI-generated submissions that mostly aren't real vulnerabilities at all.

The immediate reaction is to file this under "AI slop," and that's fair as far as it goes. But the more interesting thing here isn't that large language models can produce bad bug reports — that's been obvious for a while. It's what this pause reveals about how the economics of security research change when the cost of submitting collapses toward zero. And that's a lesson that reaches well beyond Google.

Let's start with what actually happened, because the precise scope matters. This is not a shutdown of the entire program. Supply-chain vulnerability reports remain open, as does the separate Patch Rewards Program, and some issues in Google Cloud repositories can still be routed through the Cloud VRP. Submissions received before October 1 are still being processed. What's paused — until at least the first quarter of 2027, per coverage from Help Net Security — is the "product vulnerability" intake, while Google reworks how the program evaluates reports. The company has framed it as a temporary pause, not an end.

The root problem is a signal-to-noise collapse, and it's worth being precise about why that's different from ordinary spam. Bug bounty programs have always attracted some noise — well-meaning people reporting non-issues, duplicates, misconfigured setups mistaken for bugs. But a human had to actually do the work to produce each of those. They had to understand the code well enough to form a hypothesis, describe it, and justify it. That labor acted as a natural filter: low-quality reports were self-limiting because they were time-consuming to make.

Generative AI removed that filter. A model can now produce a plausible-sounding vulnerability report — a stack trace here, a hand-wavy exploit path there — in seconds, at essentially no cost. The marginal cost of a submission fell through the floor, and the volume rose to meet it. What the OSS VRP experienced isn't a new kind of attack; it's a classic economics problem. When the price of something drops to zero, consumption spikes, and the scarce resource — in this case, skilled human reviewers' attention — becomes the bottleneck. That's the first insight worth carrying away: the constraint in security research was never the number of reports, it was always reviewer attention, and AI has now made that constraint visible and acute.

The second, and I think more consequential, insight is about trust. Bug bounty programs run on a quiet social contract. A researcher finds something, reports it privately, gives the maintainer time to fix it, and gets paid for their effort. That contract works because both sides assume good faith — a report is presumed to be worth reading until proven otherwise. A flood of AI-generated submissions corrodes exactly that presumption. Every hour a reviewer spends chasing a hallucinated bug is an hour not spent on a real one, and over time the default posture shifts from "let me look at this" to "let me figure out if this is worth looking at." Genuine researchers feel that shift most acutely: their legitimate reports now compete for attention against an ocean of synthetic noise, and the slower review cycles that result discourage exactly the people the program exists to reward.

That's why this matters beyond Google. The OSS VRP is hardly the first casualty. Malwarebytes noted that the curl project ended its own HackerOne bounty program earlier in 2026 for essentially the same reason — a small security team overwhelmed by low-quality, often AI-generated submissions. When even a project with curl's visibility and a program with Google's resources both conclude the noise is unmanageable, it's a sign that this is a systemic shift, not an isolated incident. Every open-source project that runs a public bounty, from tiny libraries to major frameworks, is now making the same calculation.

So what does the fix look like? Here's where things get genuinely interesting, because the most likely answer is recursive: the tools best equipped to triage AI-generated reports are themselves AI. A model that can flag a submission as "looks like an LLM wrote this, no PoC, low signal" costs almost nothing to run and can pre-sort the flood before a human ever sees it. That's an arms race in miniature — slop generators versus slop detectors — and it's a dynamic we're going to see play out across open source, not just in security. But it also carries a risk worth naming: if the filter becomes the primary gatekeeper, a determined adversary can study it and generate reports that slip past. Human judgment doesn't disappear from the loop; it just moves to a smaller, more expensive role.

There's a subtler response Google is likely weighing, too, and it points at the same conclusion from a different direction: raising the cost of submission back up. Requiring a proof-of-concept, a minimal reproduction, or some verifiable artifact doesn't stop AI from participating, but it forces the submitter to do real work that a language model can't trivially fake. Bounty programs have always used such requirements to keep noise down; the difference now is that they've gone from a convenience to a necessity. The "cost of entry" that generative AI eliminated will simply be reinstated in a different form.

None of this is an argument against AI-assisted security research. On the contrary — used well, these tools genuinely help researchers understand codebases faster and spot patterns they might have missed. The OSS VRP's own history is full of valuable AI-adjacent findings. The problem is specifically the unsupervised, high-volume end of the spectrum: the part where the tool generates a report that no human has meaningfully verified. The distinction between "AI helping a researcher" and "AI replacing the researcher" turns out to be the whole ballgame, and programs like Google's are now forced to draw that line explicitly.

There's also a mildly ironic symmetry lurking in the timing. Bug bounty programs were created, in part, to catch the errors that humans introduce at scale — the more code we write, the more bugs we ship, so we needed a market mechanism to find them. Now the same scaling logic is being applied to the finding process itself, and it's producing the same failure mode: more output, more noise, more burden on the human beings asked to make sense of it. The OSS VRP pause is, in that sense, a very clean little parable about what happens when you remove the human bottleneck from a process whose entire value depended on humans being careful.

For the broader open-source ecosystem, the practical takeaway is that the vulnerability-reporting pipeline — one of the quiet load-bearing walls of modern software — is going to have to be redesigned, not just patched. Expect to see more programs adopt a mix of reputation systems, proof-of-concept requirements, and AI-assisted pre-screening, and expect some smaller projects to follow curl's lead and drop public bounties entirely. The question is whether the redesign preserves what made bounties work in the first place: a low-friction way for a stranger to tell you, privately and earnestly, that your code is broken.

The optimistic read is that we're watching the system adapt in real time, and that the pause is a sign of a program taking its own signal-to-noise problem seriously rather than pretending it doesn't exist. Google has said it plans to return with a reworked intake process in early 2027, and the fact that it kept the supply-chain and patch tracks open suggests a surgical rather than a panicked response. The honest read is that this is the leading edge of a much larger adjustment, and that how well a project manages the flood of AI-generated noise may soon be as important to its security as how well it manages its dependencies. Either way, the days of assuming every bug report deserves a human's undivided attention are, quietly, over.