OpenAI's AI Patched 948 Linux Kernel Bugs in One Run for $1.2M
Quick verdict
OpenAI says an unreleased security model ran one autonomous pipeline that found, exploited, and generated patches for 948 local privilege-escalation bugs in the Linux kernel, at a total API cost of about $1.2M. That works out to roughly $1,000 per vulnerability. The capability is real and the scale is new. The open question is how many of those 948 patches hold up once kernel maintainers review them, because finding a bug and shipping a correct fix are not the same job.
What OpenAI actually reported
OpenAI's security team built a pipeline that chains three steps that used to need separate human effort: discovering a vulnerability, proving it is exploitable, and writing a patch. In a single run against the Linux kernel, using an upcoming cyber model, the pipeline validated and produced patches for 948 local privilege-escalation (LPE) flaws. Those are the bugs that let a logged-in user quietly become root. The run cost about $1.2M in API usage.
OpenAI also claims the agents used at least 10 exploitation techniques that its own researchers and outside experts consider novel, which it reads as the model going past memorized methods rather than pattern-matching known exploits. The company says it is routing the results through Linux maintainers and its Patch the Planet partners instead of dumping them publicly, and framing the whole thing as a pro bono open-source patching effort.
The scale number that got everyone's attention
Eric Wallace, an OpenAI researcher, gave the comparison that made the rounds: human researchers typically find about 20 Linux LPEs in a year, and this model found around 1,000 in a week on roughly $1M of tokens. Greg Brockman put it at about $1,000 per vulnerability. Set those against the old economics and the shift is stark. A single researcher-year of a scarce, specialized skill, compressed into a week of compute you can rent.
There is a cost curve underneath this too. One comparison pegged GPT-5.6 Sol at 166 vulnerabilities for about $500k back in July 2026, against 948 for about $1.2M with the new model. More bugs per dollar in a few months, which is the trend line that matters more than any single run. If that keeps going, large-scale automated auditing stops being a frontier-lab stunt and becomes something any well-funded team can point at a codebase.
Why it matters beyond the headline
The same pipeline that patches 948 bugs for a defender can find 948 bugs for an attacker. OpenAI chose coordinated disclosure through maintainers, but the method is not secret, and the cost is dropping. The economics of finding kernel exploits just moved, and they moved for everyone who can afford frontier compute, not only for the lab that published first.
It also lands in a week where other labs were visibly pulling in the opposite direction. Tencent said it deliberately held its new Hy4 model's offensive-cyber training to defensive patching and filtered out exploit development, and Cognition declined to open the weights of its SWE-2 coding model, citing cyber-misuse risk. The field is splitting on how much of this capability to ship into the open, and OpenAI's run is the loudest argument that the capability is already here.
The catch worth keeping in mind
"948 patches" is a count of generated patches, not a count of fixes that landed in the kernel. Linux maintainers are famously strict, and a patch that compiles and silences a crash can still be wrong in ways that only a careful human review catches. The number tells you how fast the model can produce candidate fixes. It does not yet tell you the acceptance rate, and that is the figure that decides whether this is a breakthrough or a firehose of review work for volunteer maintainers.
One commenter also flagged that the $1.2M is API list price, and that OpenAI's real internal cost is probably far lower, which is an unverified estimate but a reasonable one. If the true cost per vulnerability is a fraction of $1,000, the math gets more aggressive, in both directions.
Video: LLM-driven bug hunting and patching
A conference talk on how LLM agents are being wired up to hunt and patch bugs in open-source software, which is the same loop OpenAI ran at scale.
FAQ
Does this mean AI can secure the Linux kernel on its own now?
No. It means AI can generate a large number of candidate patches quickly. Human maintainers still decide what merges, and the acceptance rate for these 948 patches has not been reported. The bottleneck is shifting from finding bugs to reviewing fixes.
Is this the rumored GPT-6.2 model?
No. OpenAI used an unreleased cyber model for this run, which it describes as separate from the GPT-6.2 Sol and Astra models that have been rumored for an imminent launch.
Should I worry that attackers get the same tool?
The method is public even though OpenAI's specific model is not, and the cost per vulnerability is falling. That is a defender's argument for assuming large-scale automated auditing is now part of the threat model, not a reason to panic about one run.
Sources
- @OpenAI - autonomous pipeline validated and patched 948 Linux kernel LPEs for $1.2M
- @Eric_Wallace_ - researchers find ~20 Linux LPEs a year; the model found ~1,000 in a week
- @gdb - about $1,000 per vulnerability
- @scaling01 - cost trajectory from GPT-5.6 Sol's 166 vulns to 948 with the new model
Further reading
Try all the models mentioned in this article
Admix gives you GPT-5, Claude, Gemini, and 300+ AI models in one app. Compare responses side by side. Try it for 7 days for $1.99.
Try Admix for $1.99