← Back to all posts
Published on · by Renaud Deraison

The unprivileged user was root

On November 4, OpenAI said an agent pipeline running its upcoming cyber model built 948 working Linux root exploits in one run, at about $1,279 each, and that a low-privileged account on an unpatched system should now be treated as root. Most coding agents on Linux are contained by a user account, a process sandbox or a container, and all three share the host's kernel. In Bromure Agentic Coding, each agent runs in a VM with its own kernel and already has sudo there. Root in that VM gets a set of stand-in keys, a firewall it can't edit and a system disk that resets to a signed image.

OpenAI's advice is blunt: a low-privileged account on a system that isn't fully patched "should be considered functionally equivalent to root access." Coding agents run code as a low-privileged account all day long.

On November 4, OpenAI published A thousand fewer paths to root, a report on an agent pipeline that hunts for bugs in the Linux kernel, proves them, writes exploits for them and drafts the patches. The Hacker News covered it the next day.

In one run in mid-October, using an upcoming cyber model, the pipeline:

  • picked 5,034 audit targets, about 2.8 million lines or 7% of the kernel, chosen because a low-privileged user can reach them;
  • produced 2,308 candidate findings in 12 hours;
  • reproduced 1,724 of them in isolated VMs within 30 hours;
  • built 1,169 working local privilege escalation exploits, which traced back to 948 distinct bugs once OpenAI wrote one patch per bug.

The targets were VMs running "a stock desktop operating system, not a weakened target," with SMEP, SMAP, KASLR and hardened usercopy switched on. Each exploit takes an ordinary user to root. The run cost $1,213,430 in API credits, about $1,279 per exploit. At past Pwn2Own and TyphoonPWN bounty prices, OpenAI puts the haul at $18.9 million to $66.3 million.

In July, GPT-5.6 Sol found 166 of these bugs on the same kernel branch. Three months of hardening later, the newer model found 948. The agents also came up with at least 10 exploitation techniques that outside kernel experts hadn't seen before.

One run, about 30 hours of agent work, a stock Linux desktopScout agents5,034audit targets, ~7%of the kernelAnalyst agents2,308candidate findingsin 12 hoursTriage agents1,724reproduced inisolated VMsExploit agents1,169working exploits,user to rootDistinct bugs948one candidatepatch each$1,213,430 in API credits, about $1,279 per root exploitSMEP, SMAP, KASLR and hardened usercopy on; at least 10 exploitation techniques new to outside kernel experts
OpenAI's mid-October run, stage by stage. Scout agents picked the code a low-privileged user can reach, analyst agents produced candidate findings, triage agents reproduced them in VMs, and exploit agents turned them into working root exploits on a stock desktop distribution with standard protections on.

The patches take time to reach machines

OpenAI says the kernel maintainers moved fast. Ten days after the scan, 61 of the bugs were patched upstream, 43 had patches in staging and 299 were being reported and discussed in public. OpenAI has sent hundreds of reports and is sending the rest with partners in its Patch the Planet program.

Upstream is where a fix starts. It then has to reach a distribution kernel, get installed and get booted. Until it does, OpenAI's report says what to assume about that machine: anyone who can run code on it as a regular user can, with enough resources, become root. The report also says what helps: "Defense in depth, using sandboxes and isolation approaches like Firecracker and gVisor are important for limiting the blast radius."

In an early run, exploit agents reported 200 root shells. When OpenAI checked, 20 of them came from a different, unknown bug than the one OpenAI had assigned. The agents found their own route to root, and OpenAI added a check for it.

Coding agents are the regular user

A coding agent runs code it didn't write all day. It runs npm install and whatever install scripts come along, test suites, build scripts, the setup command in a README, and the helper a web page suggested. Every one of those runs as the account the agent uses.

On Linux, one of three things holds the agent in:

  • A user account. The agent runs as you, or as a dedicated low-privileged user on a dev box or CI runner. Per OpenAI, on an unpatched kernel that user can become root.
  • A process sandbox. The sandboxes built into coding CLIs on Linux use kernel features such as namespaces, seccomp and Landlock to fence the agent in. The kernel enforcing that fence is the kernel the exploits target.
  • A container. A Dev Container or a Docker container gets its own filesystem, but it shares the host's kernel. A kernel exploit run inside the container works on the host. OpenAI's own team says it found and patched vulnerabilities in Kata, Moby/Docker and gVisor while hardening the infrastructure it ran this research on.

On a Mac, the agent runs as your login and has your files and your SSH agent without any exploit at all.

Kernel root on a shared Linux host gives the attacker every container on the machine, the Docker socket, the cloud credentials in other users' home folders, the SSH keys, the CI secrets, and the logs you would read to find out how it happened.

Shared kernel: the exploit owns the hostAgent runs an install script in a containerunprivileged user, own filesystem, the host's kernelKernel exploit: root on the hostthe sandbox and the container end where the kernel doesEverything on the machineother containers, the Docker socket, cloud and SSH keys,CI secrets, and the logs that would show what happenedBromure: root in a VM that holds nothingMachine VM with its own kernelthe agent already has sudo; the exploit adds nothingevery connection goes through the MacOn the Mac, out of root's reachreal keys, the egress firewall, package checks,the compromise detector, the Security TimelineBack to a known stateReset disk re-clones the signed base image;Rewind home restores the home from an earlier boot
Where a kernel exploit lands. A container or process sandbox shares the host's kernel, so a root exploit run inside it owns the host and everything on it. In Bromure, each machine has its own kernel in a VM. The agent already has sudo there, and what root can reach is stand-in keys, a network that goes through the Mac, and a disk that resets to a signed image.

Root, in Bromure Agentic Coding

Bromure Agentic Coding runs Claude Code, Codex, Grok, Kimi and omp in Ubuntu 24.04 VMs on your Mac, under Apple's Virtualization.framework. Each machine is its own VM, with its own kernel, disks, MAC address and network. This is the isolation OpenAI's report recommends, built into every machine with nothing to configure.

The agent already has sudo

Inside a machine, the agent runs as ubuntu, an ordinary user with sudo. It can apt install what a project needs, run Docker, and edit /etc. Bromure never relied on the line between user and root inside the VM, so a kernel exploit gets the agent something it already had.

The Mac decides what root can reach from there.

Root finds stand-ins

When a machine boots, the Mac writes invalid placeholders into it. ANTHROPIC_API_KEY starts with sk-ant-api03-brm-, and ~/.git-credentials, ~/.docker/config.json and ~/.kube/config hold fakes shaped like the real thing. The real values stay encrypted on the Mac, with a master key in the macOS Keychain, and sit in the memory of a proxy on the Mac. The proxy swaps a fake for the real value only on a request to the host that credential belongs to.

Root can read every file and every process's memory in the guest and still comes away with fakes. If the attacker sends one to their own server, the compromise detector sees a credential going to a host it wasn't minted for. The proxy blocks the request with HTTP 451 and pauses the VM. An alert titled This environment may have been compromised names the credential, its real host and the host it was sent to. Shut down is the default answer.

Root can't edit the firewall

On a shared host, root rewrites iptables and opens whatever tunnel it likes. A Bromure machine's Outbound connections firewall lives in the Guardrails pane on the Mac, and the Mac enforces it twice: the VM's virtual network switch checks every connection by destination IP and by the hostname seen in DNS, for every protocol, and the proxy checks HTTPS again by TLS server name. With Unmatched traffic set to Deny, the machine reaches the hosts you listed and nothing else:

allow web anthropic.com
allow web github.com
allow web registry.npmjs.org
allow web pypi.org
default deny

Root in the guest can flush iptables inside the VM, and the Mac keeps enforcing its own rules. The Mac refuses a reverse shell to the attacker's server and logs a red "deny" row in the Security Timeline.

The exploit has to arrive through the proxy

On a coding machine, a kernel exploit most often arrives in a package. Bromure checks every package fetch on the Mac before a byte reaches the VM. An age gate hides versions younger than the cutoff, so the agent never sees a release hijacked this morning. OSV flags versions with known advisories. socket.dev and Depi flag malware and typosquats. npm install scripts can be stripped before the tarball lands. The policy lives on the host, so root in the guest can't loosen it, and every fetch is recorded in the Security Timeline.

Containers run on the machine's kernel

Docker in a Bromure machine runs on that machine's kernel. An agent that breaks out of a container lands in the same VM it started in, holding the same stand-ins. Bromure's Kubernetes clusters run in node VMs of their own, and the container registry gets its own small VM, so a cluster workload and the agent that deployed it don't share a kernel either.

Root's changes come out

A root compromise tends to leave something behind: a modified binary in /usr, a new unit under /etc, a cron entry. A Bromure machine keeps those on its system disk, which is an APFS copy-on-write clone of a signed base image. Reset disk re-clones it from the current base image and leaves your home folder alone. For what the attacker left in the home, Bromure takes a checkpoint on every boot, and Rewind home… restores the home as it was at an earlier boot. When the compromise detector fires, Bromure marks the machine compromised and won't boot it until you wipe its disk and home. Bromure keeps your tokens, SSH keys and settings. Save for Investigation exports the disk and home first if you want to see what the exploit did.

Patching is one prompt per machine

OpenAI's report ends on keeping software current. Bromure republishes its prebuilt base images every week with fresh Ubuntu packages. When a new base version is installed, each machine asks at its next start: A newer base image is available. Yes, upgrade moves the system disk onto the new base and keeps everything in /home/ubuntu. You get a new kernel on every agent machine without rebuilding a dev environment.

Its own kernel

Every machine is a VM under Virtualization.framework. A kernel exploit becomes root in that VM and goes no further.

Nothing for root to take

Keys in the VM are stand-ins. A stand-in sent to the wrong host gets a 451, and the VM pauses.

Rules root can't change

The firewall and package checks run on the Mac, at the network switch and the proxy. Nothing inside the VM can edit them.

A known state on demand

Reset disk re-clones the signed base image. Rewind home restores the home from an earlier boot.

What to do this week

OpenAI's findings apply to every Linux machine an agent touches:

  • Treat every Linux host where an agent runs code as one exploit away from root, and patch and reboot those kernels first.
  • Don't put an agent in a container on a host that holds anything you need to keep: cloud keys, CI secrets, other teams' workloads.
  • Keep real credentials out of whatever environment the agent can read. A kernel exploit reads everything in it.
  • Enforce egress somewhere the agent's root can't reach.

Bromure Agentic Coding does the last three on every machine and turns the first into one prompt per machine. The agent can have root in its VM while your Mac holds the keys, the rules and the record.

For the browser side of the same AI-exploit story, see The page load was enough. For why a VM boundary beats a sandbox for coding agents, read Why Bromure Agentic Coding is not a sandbox.