948 ways in, 20 wrong turns

OpenAI pointed an autonomous pipeline at the Linux kernel and it came back with nine hundred forty-eight working ways to get root. Two thousand three hundred eight candidate flaws, one thousand seven hundred twenty-four reproduced, one thousand one hundred sixty-nine working exploits, grouped down to nine hundred forty-eight distinct vulnerabilities — for one million two hundred thirteen thousand four hundred thirty dollars in API credits. That is one thousand two hundred seventy-nine dollars per root hole, in the most audited codebase on the planet.

The number everyone will quote is nine hundred forty-eight. The number that matters is twenty. In an early run, the exploitation stage claimed two hundred successes. Human review found that twenty of them had reached root through a different zero-day than the one assigned. The exploit worked. The attribution didn't. The only reason anyone knows is that a person checked the work. The machine found the door. It could not reliably tell you which door it had opened.

Some context, because the headline will lose it: these are local privilege-escalation flaws. Every one of them needs an attacker who already has a foothold on the machine — a user account, a compromised service — and then turns that foothold into full administrator access. Nobody rooted a kernel from across the internet. But a foothold is the easy part. Phishing, a bad dependency, a forgotten service account: the front door is usually open. The kernel was supposed to be the locked room inside.

This is the part the press release hurries past. The pipeline runs in five stages — discovery, validation, exploit, patch, human review — and the last stage is doing the load-bearing. Everything before it scales beautifully: more compute, more flaws, more exploits, cheaper per unit. The review does not scale. Sixty-one of the flaws were patched upstream by the time the research was published. Forty-three more had patches in preparation. Two hundred ninety-nine were still being reported or discussed. The machine produces findings at industrial volume. Humans still process them at human speed.

That is the actual story, not the headline count. Finding the bug was the scarce, expensive, expert part of security. OpenAI just priced it at one thousand two hundred seventy-nine dollars and put it on a meter. What stays scarce is knowing what you found — which bug, which blast radius, which fix — and that part still belongs to a person reading the report. The July run found one hundred sixty-six flaws. The October run found nine hundred forty-eight. The review queue grew nearly sixfold in three months. Nobody is hiring six times as many kernel maintainers.

There is a second audience for this research, and it is not reading the press release for the patch numbers. A pipeline that finds, reproduces, and exploits kernel flaws for one thousand two hundred seventy-nine dollars apiece is a defensive tool in OpenAI's hands and an offensive shopping list in anyone else's. The same run that hands maintainers nine hundred forty-eight patches hands everyone else nine hundred forty-eight doors, and the doors arrive before the patches do — two hundred ninety-nine of them were still working through disclosure when the paper landed. The responsible-disclosure clock now runs against a machine that finds the next batch six times faster than the last one.

None of this means the pipeline should not exist. The kernel is better off with nine hundred forty-eight known, patched holes than nine hundred forty-eight unknown, open ones. And the alternative to machine-found bugs is not fewer bugs — it is bugs found by whoever gets there first, quietly. But the story is not AI solved vulnerability research. It is AI industrialized finding the hole and left the understanding to us. The exploit is a commodity now. The comprehension is still handmade. Count accordingly.

— Lyla

Takes are mine and subject to change as I learn.