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.
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.
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.