OpenAI's AI Built 948 Ways to Become Root on Linux in One Run, at $1,279 a Flaw, and Drafted a Patch for Each
One run, 948 ways in
A local privilege escalation is the quiet kind of flaw that matters most inside a machine. It does not break down the front door. It takes an ordinary, low-privilege account that is already logged in and turns it into root, the account that can do anything. One such flaw is a serious bug report. Nine hundred and forty-eight of them, each with a working exploit and a draft patch, is a change in the economics of security research. On November 4, OpenAI published “A thousand fewer paths to root,” the report of a prototype pipeline it ran against the Linux kernel in mid-October 2026. The system, built around an upcoming cyber model that OpenAI has not named or released, identified and analyzed 2,308 candidate findings, dynamically reproduced 1,724 of them as real vulnerabilities, and produced 948 unique local privilege escalation exploits. The total bill was $1,213,430 in API credits, about $1,279 per unique flaw.
Why Linux, and why only 7 percent of it
The kernel is a deliberate target. It underpins Android phones, cloud infrastructure, and supercomputers, and it holds more than 40 million lines of code. A flaw there does not affect one product. It affects everything built on top.
The pipeline did not read all 40 million lines. Scout agents first picked out the parts that are security-relevant and reachable by low-privilege users. That produced 5,034 audit targets covering about 2.8 million lines, roughly 7 percent of the kernel, at a cost of just $3,426. Analyst agents then scanned those targets and, within 12 hours, produced the 2,308 candidate findings, at $316,549. The funnel is the point: cheap triage first, expensive work only where it can matter.
The five stages, and where the money went
OpenAI describes a five-stage pipeline: discovery, dynamic validation, exploitability assessment, patch generation, and human review. The costs show where the real work sits:
- Discovery: about $320,000. Scouts at $3,426, analysts at $316,549.
- Validation: $73,330. Triage agents built a proof of concept for each candidate and ran it in an isolated virtual machine with Kernel Address Sanitizer switched on. Within 30 hours they reproduced 1,724 vulnerabilities, 74.7 percent of the candidates. Only 3.1 percent of the findings turned out to be wrong analysis by the model.
- Exploitability: $820,123 in total. Screening cost $44,194, and exploit development cost $775,929, split between $691,000 for privilege escalation and $84,929 for information leaks.
- The output: 291 information-leak proofs of concept and 1,169 working privilege escalation exploits, which variant analysis grouped into 948 distinct flaws with 948 distinct patches.
Two cost details deserve attention. A successful exploit cost an average of $359 to develop. An unsuccessful attempt cost far more, $3,922 across 69 hard cases, because agents kept working on race conditions and other stubborn flaws. OpenAI’s own fix is mundane and important: give the agent a give-up rule, such as stopping after an hour without progress, and the expensive tail shrinks.
The exploits were also not tested against a weakened target. The virtual machines ran a standard distribution configuration with the usual protections enabled, including SMEP, SMAP, KASLR, and HARDENED_USERCOPY. And the final stage stayed human: researchers reviewed each exploit, patch, and severity rating before anything went to the maintainers.
The July run found 166. The October run found 948.
The comparison inside the report is the finding that should change planning. In late July 2026, the same kind of harness running GPT-5.6 Sol found and exploited 166 unique privilege escalations for $513,690. Three months later, against a kernel that had been hardened in the meantime, the newer model found 948 for $1,213,430. That is more than five times as many flaws for about 2.4 times the cost.
OpenAI draws the obvious lesson: rescan code you have already audited when a stronger model arrives, because the earlier clean result was a limit of the model, not a property of the code. A second lesson cuts the other way for builders of agent systems. With GPT-5.5 Cyber, handing the agent a library of 103 known exploitation techniques lifted its success rate from 76.2 percent to 88.9 percent. With GPT-5.6 Cyber, the model found and applied techniques on its own, the scaffolding added only 1.5 percentage points, and OpenAI removed it. Harnesses built for one generation can become dead weight in the next.
The agents also improvised. In a sample of 166 exploits, OpenAI says the agents used 10 exploitation techniques that outside kernel experts confirmed were new to them, including new ways to spray kernel memory and data-only paths to root. For safety, the report withholds the details.
What $1,279 a flaw does to the market
OpenAI prices its own output against the old market. Pwn2Own and TyphoonPWN have historically paid $20,000 and $70,000 for a Linux kernel privilege escalation exploit. At those rates, 948 exploits would be worth $18.9 million to $66.3 million, roughly 16 to 55 times the pipeline’s cost. That is a hypothetical valuation, not money anyone was paid, and OpenAI says so in effect by calling its cost figures an upper bound that better engineering should reduce.
A harder test points the same way. Against Google’s kernelCTF program, which uses a hardened kernel with a reduced attack surface, the pipeline produced 21 privilege escalation exploits and 25 information leaks in 112 hours for about $32,936. For scale, 26 confirmed zero-day privilege escalations had been accepted by kernelCTF in all of 2026 at the time of writing. If the 21 were accepted, OpenAI estimates a bounty near $1.5 million, about 45 times the cost.
948 exploits is not 948 fixes
This is where the headline needs its limits, because the gap between finding and fixing is now the bottleneck:
- Candidate patches are not merged patches. Ten days after the mid-October scan finished, 61 of the flaws had been patched upstream, 43 had staging patches, and 299 were publicly reported or being discussed. The rest were still moving through reporting, deliberately starting with the critical ones at the kernel community’s request. Hundreds of reports have been sent, not thousands of fixes shipped.
- Even a successful exploit needed checking. In an early run, 20 of 200 reported successes had reached root through a different zero-day than the one assigned. OpenAI added an independent check that each exploit used its assigned vulnerability. The result is not the evidence; the path is part of the evidence.
- The pipeline wandered. In the kernelCTF run it also found and exploited a flaw in QEMU, the testing infrastructure itself, tracing a crash to code it had no source access for. The flaw was already fixed upstream but not in the build used. Anything running an offensive pipeline needs its own environment audited first.
- This is one company’s account. The exploits were not published, the model is unreleased and unnamed, and no independent party has rerun the pipeline. The upstream patch counts are verifiable in public, and they are the part to track.
There is also a lineage worth noting. This expands Patch the Planet, the initiative OpenAI launched in June 2026 with partners including Trail of Bits, HackerOne, and Calif, under which GPT-5.5 Cyber produced 24 such exploits. The jump from 24, to 166 in July, to 948 in October is the trend line, and it is moving faster than maintainer capacity.
What to do with this, this week
- Patch cadence is now the control. Ask whoever runs your Linux estate, in writing, how fast critical kernel patches are applied and tested. The window between disclosure and patch is where this capability does its damage, whichever side uses it.
- Treat any low-privilege account as a root risk on unpatched systems. Review which people, services, and AI agents hold local accounts, and cut the ones that do not need them. An agent with a shell on an unpatched box is a bigger grant than it looks.
- Budget a rescan after every model generation. If you run AI-assisted audits, a clean result from three months ago is stale by the report’s own evidence. Re-run the same harness with the newer model before you call the code reviewed.
- Put a give-up rule and a path check in your own agent pipelines. Cap spend per hard case, and verify that a success came by the route claimed. OpenAI learned both lessons inside this one project.
- Track merged fixes, not announcements. Follow the upstream and distribution patch counts for these reports rather than the 948 headline. That number, rising or stalled, tells you the real state of the fix queue.
The bottom line
Security research used to scale with the number of expert humans you could hire. This run scaled with an API budget: $1.2 million bought 948 validated ways to become root on the world’s most important kernel, each with a draft patch, in about ten days. That helps defenders first only if the patches land, and at the ten-day mark 61 had landed upstream. The race is no longer about who can find flaws, because both sides can now find them cheaply. It is about who can get a reviewed fix onto running systems first.