Finding 948 ways to get root on Linux is the easy part now. Somebody still has to review 948 patches.

That’s the question OpenAI’s November 4 research post, “A thousand fewer paths to root,” leaves on the table. The company built a pipeline where agents handle vulnerability discovery, dynamic validation, exploit development and patch generation, with security researchers reviewing the output at the end. One mid-October run with an unreleased cyber model produced 948 working local privilege escalation (LPE) exploits for $1,213,430 in API credits, or $1,279 per exploit.

The price per bug is falling fast

The headline number matters less than how quickly it’s dropping. According to the post, a run in late July with GPT-5.6 Sol found 166 unique LPE bugs for $513,690. That’s about $3,094 per bug by our math. Three months later it was $1,279, roughly 41% of the July figure. OpenAI also says the newer model found more than five times as many new LPEs even though the kernel had three months of extra hardening in between. Back in June, GPT-5.5 Cyber had produced 24 exploits.

OpenAI calls its reported costs close to an upper bound, since a better harness could cut every stage. So the volume goes up while the price keeps going down.

The stage-by-stage numbers show where the money went: $3,426 to pick audit targets, $316,549 for analysis, $73,330 for dynamic validation, $44,194 for initial triage and $775,929 for exploitation. Those add up to almost exactly the total, and exploitation alone is about 64% of it (our calculation). Proving a bug is actually exploitable cost more than finding it.

The post also compares the run to bug bounties. Pwn2Own and TyphoonPWN have historically paid $20,000 and $70,000 for a Linux kernel LPE. Multiply those by 948 and you get $18.9M to $66.3M, about 16x to 55x the pipeline’s cost. OpenAI itself frames this as a hypothetical valuation, and it’s best read as a ceiling. Contest prizes are paid per entry, so applying them to hundreds of bugs pulled out of one kernel at once is a stretch.

The kernelCTF result needs the same care. On Google’s hardened kernel bounty environment, the pipeline spent 112 hours and about $32,936 to get 21 LPE exploits and 25 information leak proofs of concept. kernelCTF had accepted 26 confirmed zero-day LPEs in 2026 at the time of writing, so 21 in under five days is a lot. But the newest kernel isn’t compatible with kernelCTF’s SLAB_VIRTUAL mitigation, so that setting was left out, and the roughly $1.5 million payout (about 45x the cost) only applies if all 21 get accepted.

Five stages, and patching is the last automated one

Scout agents first picked code an unprivileged local user can actually reach, narrowing the 40-million-plus-line kernel to 5,034 audit targets, about 2.8 million lines or 7% of the codebase. Analyst agents then spent 12 hours producing 2,308 deduplicated candidate findings.

Static review alone throws off plenty of false positives. So triage agents wrote a proof of concept for each candidate and ran it in an isolated VM with Kernel Address Sanitizer (KASAN) enabled. In 30 hours they reproduced 1,724 bugs, about 74.7% of the candidates. Only 3.1% turned out to be flat-out wrong analysis by the model. Most of the rest needed higher privileges or hit tricky race conditions that couldn’t be reproduced in time.

ExploitDev agents then worked against a default desktop OS with SMEP, SMAP, KASLR and HARDENED_USERCOPY on. They produced 291 information leak PoCs and 1,169 working LPE exploits. After variant analysis, those mapped to 948 distinct patches, which is where the “948 unique LPEs” count comes from. In a sample of 166 exploits, OpenAI says the agents used 10 exploitation techniques that were, as far as it knows, new, and outside kernel exploitation experts hadn’t seen them either.

Patch generation is stage four. Stage five is a human: security researchers review the exploits, patches and proposed severity before anything goes to maintainers.

Two reasons not to trust the output blindly

The post has two stories that make the case for keeping humans in the loop.

The first is about the wrong zero-day. The pipeline counted a run as a success if it got a root shell. In an early run, 200 exploits were reported as successful, but human review found that 20 of them got root through a different zero-day than the one assigned. OpenAI tightened the task constraints and added an independent check that each final exploit used its assigned bug. If you’re building autonomous agents, checking the outcome isn’t enough. You have to check the path too.

The second is patch quality. When the model was first asked for patches directly, they fixed the bug the PoC showed but sometimes created new problems: too much code, possible performance regressions, or patches that didn’t follow coding conventions. Some missed variants of the same bug in related code. More guidance and iteration improved things. It also went the other way: the prototype caught problems in an expert-written patch, which got fixed before merge.

If you build agent frameworks, the orchestration experiment is the part to steal. Giving GPT-5.5 Cyber 103 documented kernel exploitation techniques raised its success rate on 63 exploit candidates from 76.2% to 88.9%. GPT-5.6 Cyber hit 92.1% without any of that, and adding the technique layer back only got it to 93.6%, a 1.5-point gain. OpenAI decided that wasn’t worth the maintenance cost and dropped the heavy orchestration. When the model changes, your harness needs a fresh look.

948 patches, one maintainer queue

Back to the opening question. According to the post, when the autonomous scan and manual analysis finished 10 days after starting in mid-October, 61 LPEs had already been patched upstream, 43 had patches waiting to land, and 299 were being reported and discussed in public. Some of those pending patches came from other contributors, so OpenAI wasn’t the only one looking at these bugs.

OpenAI also isn’t dumping all 948 at once. It says it followed the kernel community’s advice and started with the most severe bugs, has already sent hundreds of reports and patches, and is sending the rest in batches through its Patch the Planet partners. It also recommends revalidating findings against the latest code, including anything merged after the first scan, so maintainers don’t get reports for bugs that are already fixed. What the post doesn’t say is how many of the 948 patches are merged in mainline or how many CVEs have been assigned.

The Hacker News thread, with more than 330 comments, split over exactly this. One commenter wrote that at this rate OpenAI is “probably bottlenecked on people to review these,” and that kernel maintainers are short on time too. Another pointed to a talk by Greg Kroah-Hartman about an earlier wave of AI-generated reports and summed it up as AIs “can’t reliably deduplicate or count vulnerabilities.” That’s the commenter’s summary of an older talk, not Kroah-Hartman’s take on this research. Still, it’s worth keeping in mind with a number like 948, since OpenAI counted unique bugs by the patches it wrote itself.

So, who reviews the patches? From what’s public, OpenAI is aware of the load and is pacing its submissions. But the cost per bug fell by more than half in three months, and the post itself says every new generation of frontier models should rescan the same code. The number of reports will keep growing. How fast humans can review and merge patches is going to be the real limit.

If you run Linux, the practical advice in the post is blunt. On an operating system without the latest patches, OpenAI says, a well-resourced attacker who gets a low-privilege account should be treated as having root. If you’ve been putting off kernel updates, do those first. And if user separation is your only boundary, add real isolation like sandboxes, Firecracker or gVisor.