A thousand fewer paths to root: Verify the Path, Not Only the Result
OpenAI's agents audited part of the Linux kernel and built 1,169 working root exploits. In an early run, 20 of 200 successes reached root through a different vulnerability than the one assigned, and every one passed the result check. Any team accepting work from an agent has the same gap.
What OpenAI ran
On November 4, 2026, OpenAI published A thousand fewer paths to root, a report on a pipeline of AI agents that searched the Linux kernel for local privilege escalation (LPE) bugs: flaws that let an ordinary user on a machine become root. Agents chose what to audit, analyzed the code, reproduced each finding, wrote working exploits and drafted patches. Human researchers reviewed the output before anything was reported.
The funnel is large:
- Scope. 5,034 audit targets, about 2.8 million lines, which OpenAI puts at roughly 7% of the kernel. Agents acting as scouts picked the targets for security relevance and reachability by an unprivileged user. The scan ran for 10 days.
- Findings. 2,308 candidate findings after deduplication, of which 1,724 were reproduced, about 74.7%.
- Exploits. Screening left 1,238 LPE candidates, and the exploit agents produced 1,169 working exploits.
- Unique bugs. The agents wrote 948 distinct patches, and OpenAI uses that number to count unique LPE vulnerabilities.
- Cost. $1,213,430 in API credits, which OpenAI reports as $1,279 per LPE, the total divided by the 948 unique vulnerabilities. OpenAI calls the cost closer to an upper bound, because the run aimed at capability, not efficiency.
Read as a security result, the report shows agents carrying a whole investigation from a hunch to a working exploit, across thousands of targets. One section of it matters to every team that accepts work from an agent, security or not.
Twenty of two hundred took the wrong path
In an early run, the exploitation stage reported 200 successful exploits. Success meant the exploit ended with a root shell: a command prompt with full administrator rights. Human review then found that 20 of the 200 had reached root through a different 0-day, a previously unknown vulnerability, than the one the agent was assigned.
Every one of those 20 passed the check. The agent was asked to exploit bug A, it produced root, and the scorer counted a success. The root shell was real. It did not prove anything about bug A. One success in ten that looked like a confirmed vulnerability was a confirmation of something else.
OpenAI's fix had two parts. It tightened the task constraints, and it added an independent check that confirmed each final exploit used its assigned vulnerability. Its lesson, in its own words: "verify the path to a result in addition to verifying the result itself."
A result check asks whether the agent got there. A path check asks whether it got there the way it was supposed to.
The same failure in everyday agent work
You will probably never run an exploit pipeline. If your team uses coding agents, you already run a result check: the build passes, the tests pass, the feature works. The OpenAI finding says that check can be right about the outcome and silent about the route.
Here is the coding version. A team's services read customer data only through a shared data-access layer, a decision it made after two services drifted onto different database schemas. An agent is asked to add a report endpoint. It writes a direct database query in the handler, because that is the shortest path to a passing test. The endpoint returns the right numbers, the tests pass and the pull request looks small. The agent produced the requested result through a route the team had ruled out.
| Result check | Path check | |
|---|---|---|
| OpenAI's exploit pipeline | Did the exploit produce a root shell? | Did it use the assigned vulnerability? |
| A coding agent's change | Does the build pass and the feature work? | Did the change respect the team's decisions about how the code may reach that result? |
| Who writes it | Usually already exists: tests, CI, review | Has to be written on purpose, from the decisions the team made |
The coding case is harder than OpenAI's in one respect. OpenAI knew which vulnerability each task targeted, so the path check had a clear reference. A coding team's reference is its set of engineering decisions, and those are often written nowhere a check can read them.
What the report does not show
The figures are strong, and they are easy to read as more than they are. Four limits come from the report itself:
- 948 is a count of distinct patches, not of fixes merged upstream. The report gives no count of OpenAI's own merged patches. It says that after the 10-day scan, 61 of the LPEs had already been patched upstream and 43 had patches in staging, a figure that includes fixes from other contributors.
- Remediation still involves people. Model-written patches were functionally correct but occasionally bloated, off-convention or missing variants of the same bug. OpenAI writes that extra instructions and iteration improved them, and that it believes expert-guided iteration can make them sound.
- The dollar value is hypothetical. OpenAI applies past payouts from the Pwn2Own and TyphoonPWN hacking contests ($20,000 and $70,000 per exploit) to the 948 unique vulnerabilities, for a valuation of $18.9 million to $66.3 million. That is a comparison, not money anyone paid.
- The results are OpenAI's own. The pipeline ran in a controlled research environment, and the report presents no independent reproduction.
So the research shows that exploit discovery now scales with compute. It does not yet show that safe remediation scales the same way, and the wrong-path finding is one reason why.
Scaffolding is shrinking. Verification is not.
A second finding concerns scaffolding: the instructions and workflow a team builds around a model to help it succeed. It shows which kind of effort keeps its value. With an earlier OpenAI model, GPT-5.5 Cyber, giving the agent 103 exploitation techniques to draw on raised its success rate on 63 candidates from 76.2% to 88.9%. With the newer GPT-5.6 Cyber, a light workflow outperformed that heavily scaffolded setup, and adding the techniques back gained only 1.5 points.
So the procedural help that once made agents work is losing value as models improve. The independent path check is the opposite case. OpenAI added it because the agent was capable enough to find another route to root, and nothing about a more capable model makes such routes less likely. Teams deciding where to spend effort should weigh that: checks outside the agent keep paying off as models change, while orchestration built around one model's weaknesses may not.
What engineering leaders should do
- Separate result checks from path checks in your own pipeline. List what your CI verifies today. Most of it will be results. Name the routes you have ruled out, such as direct database access, a forbidden dependency or a bypassed approval step.
- Make the path check independent of the agent. OpenAI's check did not trust the agent's report of which bug it used. Your check should not trust an agent's summary of what it changed; it should read the change.
- Write down the decisions a path check needs. A check cannot enforce a decision that exists only in a reviewer's memory. Record the decision, its scope and the reason for it, in the repository.
- Sample and review even passing work. OpenAI found the 20 wrong-path exploits by human review of successes, not failures. Keep a reviewer reading a share of the changes that passed.
Where Mneme fits
Mneme is not a vulnerability scanner and does not test exploits. It is an open-source decision and control layer for agentic software development, and it covers part of the path check for code changes.
Mneme enforces decisions that carry an active typed rule: a rule a machine can check, such as an exact piece of text that must not appear in code, optionally limited to certain paths. For the example above, the rule forbids the database driver's import in the handler directories and excludes the data-access layer. It returns a FAIL when an agent's change adds that import. A decision without an active typed rule is not enforced, and a path a literal rule cannot express needs its own test.
The checks run in continuous integration (CI) and in coding agents including Claude Code, and the command-line interface (CLI) agents Codex CLI and Kiro CLI 3.0, where each agent's native write tools are checked before the write lands. Files an agent changes through shell commands reach disk first; Claude Code and Codex CLI check them when the agent finishes its response, and CI is the backstop for the rest. Each violation names the decision it broke. Decisions live in the Decision Index, Mneme's persisted, versioned record of a repository's decisions.