Report Response AI coding agents 8 min read

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:

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 checkPath check
OpenAI's exploit pipelineDid the exploit produce a root shell?Did it use the assigned vulnerability?
A coding agent's changeDoes 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 itUsually already exists: tests, CI, reviewHas 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:

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

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.

Frequently asked questions

What did OpenAI's A thousand fewer paths to root report find?+
OpenAI's November 2026 report describes AI agents that audited about 7% of the Linux kernel, reproduced 1,724 of 2,308 candidate findings, produced 1,169 working local privilege escalation exploits and wrote 948 distinct patches, at $1,213,430 in API credits. It also found that 20 of 200 early successful exploits used a different vulnerability than the one assigned.
What is the difference between verifying a result and verifying a path?+
A result check asks whether the agent reached the goal, such as a root shell or a passing test suite. A path check asks whether it reached the goal the intended way, such as through the assigned vulnerability or through the team's approved data-access layer. OpenAI added an independent path check after finding that result checks alone counted wrong-path exploits as successes.
Does the report show that AI can fix kernel vulnerabilities at scale?+
Not yet. The 948 figure counts distinct patches the agents wrote, not fixes merged upstream, and the report gives no count of OpenAI's merged patches. Model-written patches were occasionally bloated, off-convention or missing variants, and OpenAI believes expert-guided iteration can make them sound. The report shows that exploit discovery scales; safe remediation is not shown to scale the same way.