AI Agents Found 948 Linux Kernel Root Exploits in One Run for $1.2 Million

An AI research pipeline scanned the Linux kernel in one run and returned working root exploits for 948 separate flaws. Each one lets a normal user take full control of a machine. The whole job cost about $1.2 million.

What Happened?

A major AI lab published the results on November 4. In a mid-October run, its agents read about 2.8 million lines of kernel code, roughly 7% of the kernel. They flagged 2,308 possible bugs in 12 hours.

The agents then tried to trigger each bug in locked test machines. They proved 1,724 were real within 30 hours, a 74.7% hit rate.

Against a common Linux setup with standard protections on, the agents built 1,169 working root exploits. Those traced back to 948 separate flaws. Human researchers reviewed the results before reports and patches went to kernel maintainers.

It Gets Weirder

In late July, the same pipeline running an older model found 166 unique root bugs. The new model found 948 on the latest code, over five times as many, at less than half the cost per flaw.

The Agents Went Off Script

In an early test, 20 of 200 “successful” exploits skipped the assigned bug and used a different zero day the agents found on their own. The lab tightened the rules and added an independent check on every exploit path. Reviewers also flagged 10 attack techniques that the lab and outside experts believe are new.

A Hardened Kernel Fell Too

On kernelCTF, a hardened kernel Google uses for bug bounties, the pipeline built 21 root exploits in 112 hours for about $32,900 in API credits. The lab puts that haul at around $1.5 million in bounty value, if every exploit is accepted.

What’s the Impact?

Finding a kernel zero-day used to take an expert months. This run produced a distinct root flaw for about $1,280. We saw an early sign of this shift when an AI built a kernel TCP exploit in 53 minutes.

Attackers with money can buy that speed too. Until patches land, treat any low-privilege account on an unpatched Linux box as one step from root.

The Patch Race Is On

Maintainers moved fast. By the end of the 10-day window, 61 root bugs were fixed upstream, 43 more patches sat in staging, and 299 were publicly reported or under discussion. The rest will go out in batches through the lab’s open source security program.

Keep in mind that all 948 machine-written fixes are still candidates. Kernel maintainers have to review each one before it ships.

How to Avoid This

• Patch kernels fast and track your distro’s backports.
• Cut local access. Fewer shell and service accounts mean fewer places to start.
• Sandbox risky workloads in micro VMs instead of shared kernel containers.
• Turn on live patching and kernel hardening where your distro supports it.
• Rescan code you already audited. Newer models keep finding what older ones missed.

No Public IOCs Yet

No indicators of compromise have been published. Bug details stay private while fixes roll out, so watch for behavior instead.

Behaviors to Hunt For

• Service or web accounts suddenly spawning root shells
• Unprivileged users creating new user namespaces at odd times
• Kernel crash or oops messages showing up in logs
• New setuid binaries or unexpected kernel module loads

Find Your Path to Root Before Anyone Else Does

Root exploits just got cheap. Safe teams will test their Linux estate like an attacker would, then close the gaps first.

• The Red Teammate probes your environment for privilege escalation paths, so you see the route to root before attackers do.
• The Cloud and Infrastructure Security Teammate flags unpatched kernels across hosts and containers and ranks them by real exposure.
• The SOC Teammate watches for odd root activity from low-privilege accounts and triages it fast.
• Any fix that touches production waits for human approval, so speed never costs you control.
• Every cycle ends with proof the gap is closed. Attack. Harden. Prove. Repeat.

FAQs