OpenAI agents found 948 ways to get root on Linux, at $1279 each

Picture a server where an attacker has only a modest user account: say, they got into one of your containers or gained access to a test environment. A vulnerability of the LPE (local privilege escalation) class turns that account into root, meaning full control of the machine. These are exactly the holes OpenAI went looking for in the Linux kernel using autonomous agents. Of 1724 confirmed vulnerabilities, 948 reached working privilege-escalation exploits, and the entire run cost $1 213 430 in API credits, or roughly $1279 per exploit. If Linux runs in your production environment, and for most teams it does, this news concerns you directly.

OpenAI published a write-up titled "A thousand fewer paths to root." The work was done by a cyber model that has not been released yet. The post calls it upcoming, so we may not have long to wait to meet it.

How the pipeline works

The researchers did not simply ask the model to "take a look at the code." They built an autonomous multi-stage pipeline around it, something like a crew in which everyone has a specific job but there are no humans:

• some agents pick a section of code worth checking;
• others scan it for vulnerabilities;
• others reproduce the findings in isolated environments to confirm the hole is real and not a model hallucination;
• the next stage checks whether the hole can actually be exploited;
• the last stage generates patches.

The reproduction step matters most here. The main problem with automated scanners and LLM reviewers is that they produce mountains of false positives, and people drown in sorting through the junk. When every finding is backed by a working exploit, the noise disappears: the bug either triggers or it doesn't.

The numbers and the price

According to the post, the pipeline was run over the Linux kernel, apparently only in part. The result: 1724 vulnerabilities confirmed and reproduced, of which 948 became working privilege-escalation exploits.

The sum of $1 213 430 looks substantial, but the author of the post offers a comparison with the market. At the Pwn2Own hacking contest, an exploit like this has historically earned about $20 thousand, and at TyphoonPWN about $70 thousand. Multiply by 948 and you get between $18.9 million and $66.3 million. In other words, what the agents found would have been worth roughly 15–55 times more at those contests than the agent run cost.

A caveat: this is the post author's estimate, not a price list. Contest prizes and the real market value of an exploit are different things, and the 948 findings themselves may vary widely in severity and in the conditions required to use them. The details are worth checking in the original source.

What to do in practice

First, the economics of vulnerability research are changing. Not long ago, a serious kernel exploit took weeks of work by a rare specialist. Now it is an API line item, and it scales with money. That cuts both ways: defenders can find and close holes faster, but the barrier to entry for attackers also drops if they get access to comparable models.

Second, the window between a vulnerability appearing and its mass exploitation will most likely shrink. Delaying kernel updates on servers and container hosts is becoming more expensive, so it is worth revisiting your patching policy.

Third, the approach carries over to your own code. The scheme of "find, reproduce in a sandbox, confirm exploitability, propose a patch" applies well beyond the kernel. For anyone building agents for code and security, the key point is that the value comes not from one strong model but from the verification stages around it, which filter out false findings.

The post leaves several things unclear: how many of the discovered holes have already been fixed upstream, which part of the kernel was actually scanned, and when and on what terms the model itself will be released. For now this is a strong demonstration of capability, not a finished product. But the direction is clear: automated vulnerability discovery is ceasing to be a toy and becoming an industrial process.