A $500K Zero-Day for $25: AI Just Broke the Vulnerability Market's Pricing Model

What happens when the cost of finding a critical vulnerability drops by four orders of magnitude? That question is bouncing around security circles right now, and nobody has a comfortable answer. The trigger: reports that an AI agent found a remote code execution flaw in WordPress for roughly $25 in API spend. Brokers have paid six figures for bugs in that class. This isn’t a story about one bug. It’s a story about a price list that no longer makes sense.

One caveat up front. Individual claims like this are still being picked apart by researchers, and the verification cycle isn’t finished. So the interesting question isn’t whether this specific number holds — it’s what the vulnerability economy looks like once numbers in this range become routine. The structure matters more than the receipt.

Why WordPress Was Always Going to Be First

WordPress runs somewhere around 40% of the web. The core is reasonably well-maintained. The problem is the 60,000-plus plugin ecosystem hanging off it — much of it written by solo developers, plenty of it abandoned years ago with the download button still live.

RCE sits at the top of the severity ladder. It means an attacker runs their code on your server. Not reading your files — owning the box. And if it’s unauthenticated RCE, you can sweep hundreds of thousands of internet-facing servers with a shell script and a target list.

WordPress is also close to an ideal target for machine-driven analysis. Three reasons. The source is open PHP, so there’s nothing to reverse-engineer. Plugin architecture is highly repetitive, so patterns generalize across thousands of codebases. And the installed base is enormous — one hit pays for a lot of misses.

The Number That Actually Matters Is the Exponent

Don’t anchor on $25. Anchor on the order of magnitude.

Finding a bug at this severity used to require a trained researcher. Read the code, trace data flow, build a working exploit, validate it. Days at minimum, weeks more often. Call it several thousand to several tens of thousands of dollars in labor. And that’s the cost when it works. Most hunts end with nothing.

AI-driven vulnerability discovery inverts that math, because the cost of failure approaches zero. You can fire a thousand plugins into a pipeline overnight and read results with coffee. At a few dollars per attempt, failing 100 times to succeed once is still an obscenely good trade.

That’s the actual shift. Vulnerability research moves from a craft to a compute spend. And compute scales with money, which is a very different constraint than scaling with rare human talent.

The Broker Price List Is Load-Bearing

Exploit brokers like Zerodium have published price sheets for years. Millions for an iOS one-click chain. Six figures for Android. Six figures again for server-side RCE in widely deployed software.

Where do those numbers come from? Two kinds of scarcity. The scarcity of the bug and the scarcity of people who can find and weaponize it. The global population of researchers who can reliably produce a working exploit for a hardened target is far smaller than most people assume — a few hundred, arguably.

AI attacks the second scarcity directly. More finders means more supply. More supply means lower prices. That’s chapter one of any economics textbook.

But the counterargument is strong, and it’s worth taking seriously. What AI finds well is patterned vulnerability — unvalidated input flowing into a dangerous sink, the kind of thing static analysis has chased for two decades with better recall now. What brokers pay the most for is something else: exploit chains that defeat modern iOS memory protections, pointer authentication, sandbox escapes. There, discovery isn’t the hard part. Weaponization is. So the market probably doesn’t collapse uniformly. It collapses from the bottom. The low and mid tiers get commoditized; the top tier may actually get more expensive as the contrast sharpens.

Attackers Are Winning This Round

The standard reassurance is that defenders get the same tools, so it evens out. Short term, I don’t buy it. Attackers are ahead.

The asymmetry is structural. An attacker needs one working bug. A defender needs to close all of them. Hand both sides a 10x productivity multiplier and the outcome is not symmetric — it’s 10x more shots against a wall that still has to hold everywhere.

Then there’s the patch bottleneck. Discovery now takes hours. But getting a report to a volunteer plugin maintainer, getting a fix shipped, and getting site owners to actually apply it still takes weeks or months. When discovery accelerates and remediation doesn’t, the gap between them is the exposure window. It’s widening.

Bug bounty platforms are already feeling the second-order effect. Plausible-sounding reports for vulnerabilities that don’t exist — AI slop — are flooding triage queues and burning out the humans who review them. Curl’s maintainers have been loudly public about this. When real reports drown in synthetic noise, that’s a direct tax on the defensive side.

What Has to Change

Prices collapsing doesn’t kill a market. It reshapes it.

First, value migrates. “I found a vulnerability” stops being the scarce thing. What gets priced instead is delivery infrastructure at scale, reliable exploit chains, and — most valuable of all — staying undetected until the patch lands. Persistence and stealth become the moat.

Second, defensive baselines move. If you ship open-source software and have never once run an AI-assisted audit against it, that’s drifting from “not required” toward negligent. Your adversaries are running one. Assume they ran it last week.

Third, the open-source maintenance model goes on trial. Telling a hobbyist who patches a plugin on Sunday afternoons to defend against an automated fleet of scanners isn’t a reasonable ask — it’s not a gap individual effort can close. That points at funding and infrastructure, not exhortation. The Sovereign Tech Fund and OpenSSF are early attempts. They are not remotely at the required scale.

The Takeaway

The headline isn’t that an AI found a bug. It’s that the marginal cost of finding one has fallen close to zero. Markets built on scarcity don’t survive the scarcity disappearing.

But the market may not be the only thing that breaks. The gap between how fast bugs get found and how fast fixes get deployed is going to set the real security baseline of the internet for the next several years, and right now that gap is opening, not closing.

One question to sit with. How many libraries and plugins are you running that haven’t shipped an update in two years? That used to be code nobody would ever bother looking at. Now it costs $25 to look.