Distill AI · 2026-11-02
Keys: space/K play-pause · J/L jump 10s · arrows on the waveform nudge 5s
Google DeepMind's security model Carbon scores 88.2 percent on vulnerability finding but 54.8 percent on exploitation, and days later clips attributed to Anthropic describe Claude building a zero-click root exploit for Linux. Alphabet reports 25 percent growth with Cloud up 103 percent and a satellite TPU that answered its first prompt in orbit, while OpenAI's customers report a 954 percent ROI pilot and 130,000 active users. A running fight over whether OpenAI's robots.txt opt-out concedes what its fair-use post denies, plus a provenance audit of every headline number. OpenAI's three-layer runtime monitor — activation probes, a reviewer, an investigative agent — lands as a copyable template for overseeing your own agents.
The full episode transcript, timed to the audio. Click any line to jump there; the current line lights up while you listen.
DeepMind shipped a model this week that finds real vulnerabilities - eighty-eight percent on a benchmark called SEC-bench Pro.
And four days later, Anthropic's Frontier Red Team published exploit chains their internal model wrote. Including a zero-click root exploit for Linux - the machine's highest privilege, no user interaction at all.
Same capability, both sides of the defender-attacker line, published by two labs in one week.
The question is no longer whether AI finds bugs. It's which side of your firewall it's standing on.
Welcome to Distill, the AI edition. We read what the AI leaders and labs publish so you don't have to.
It's Monday, November 2nd. This week is worth a listen because the same security capability shipped for both teams, and one of the exploits has been sitting in production kernels for a decade.
The route: two big stories on the security line - the finder, and the exploiter - with a concrete check for anyone running Linux servers. Then the rest of the week, quickly: Google's quarter, the agent enterprise, and OpenAI's governance run.
Everything else lands in the show notes with links.
Start with the finder. DeepMind calls it Gemini 4 Carbon, a cybersecurity-focused frontier model, and it leads with security benchmarks.
SEC-bench Pro. What does that actually test?
Real-world vulnerability finding, where Carbon scores eighty-eight point two percent. It exploits at fifty-four point eight percent on ExploitGym, and patches at seventy-one percent on CWE-bench.
Exploitation at fifty-five percent. Nearly half its exploit attempts fail, and that gap is where defense still lives.
DeepMind also claims a secure-code uplift of more than twice Argon's.
Self-reported, so hold it loosely. Does it change a security team's headcount math?
It changes the finding budget. When discovery costs minutes instead of days, the scarce resource moves to triage and patch velocity - and the fifty-five percent says exploitation skill remains the moat, for now.
One honest caveat - benchmarks are one thing, production codebases another?
Right. DeepMind hasn't published how Carbon performs outside its benchmark suite. But the direction is unmistakable, and the defenders aren't waiting: Check Point reports OpenAI's Daybreak cuts vulnerability research from hours to minutes.
Which compresses the defenders' cycle the same way the attackers' just compressed. Same model class, deployed on both sides.
Now the other side. Anthropic's Frontier Red Team published the details in late October: an unreleased internal model wrote working exploit chains for Chrome, Safari, Android, Windows, and the Linux kernel.
One of those chains earns the feature. CVE-2026-98432 - a use-after-free race in the kernel's TCP handshake, the code that accepts every incoming connection.
The vulnerable code shipped in kernel four point four, back in 2016. Ten years of Linux servers carry it, and any attacker who can open a connection to you can reach it.
Hold on - the TCP handshake is the oldest code path on the internet. How does a 2016 bug become a 2026 exploit?
The trigger is IP options - legacy header features like record route and timestamps from the early internet. Legitimate traffic stopped using them decades ago, so almost nobody sees them, and defenders don't log what they never expect.
And the exploit itself?
Two stages. First, the attacker races crafted connection attempts against the handshake until the kernel copies a few bytes too many and leaks a kernel pointer.
Address-space randomization - that's the defense that hides where the kernel lives in memory, right?
Exactly. Without knowing where anything sits, corrupted pointers point at noise. The overread hands the attacker the map. Forty-eight minutes of racing in Anthropic's proof of concept.
And a lost race costs the attacker nothing. The handshake fails, quietly. No crash, nothing in the logs worth reading. So they retry, forever.
The reason a race exists at all: modern kernels process handshakes without holding the listener lock - a performance decision from 2016. Two CPUs touching the same freed memory at once is the price of that speed.
A performance optimization that became a ten-year-old security debt.
Stage two. With the memory layout known, the same bug overflows a buffer and overwrites a callback pointer with a payload the attacker staged in kernel memory. Five more minutes to a root shell.
Root on a Linux server, zero user interaction, from the open internet.
Now the scoring fight, which is its own story. The kernel team scored it nine point eight out of ten. Canonical rated it High. The EPSS model - FIRST's Exploit Prediction Scoring System - says zero point four six percent.
All three can be true. Each attempt is unlikely to succeed, retries are free, and one success is game over. A low probability is not a low impact when the impact is root.
Canonical's High rating has logic too - exploiting a plain TCP listener this way is harder than the multipath demo. But fair ratings do not patch kernels.
And here's the part most admins missed. The demonstrated root exploit targets multipath TCP listeners.
Quick primer - multipath TCP?
A TCP extension that lets one connection flow over several paths at once, like wifi and cellular together. Handy for mobility. And since Go one point two four, Go programs on Linux turn it on for their listening sockets by default.
Say that again for the self-hosters. That's Caddy, that's Forgejo, that's ollama. A huge slice of the internet's infrastructure is speaking multipath TCP without anyone choosing it.
One more wrinkle, though. The Go team's own advisory says the underlying bug is not specific to multipath - any publicly reachable IPv4 listener on an unpatched kernel is exposure until the fix lands.
So the multipath check is the smoke detector, not the whole fire assessment. The patch is the fix.
And the patch story is a split. Upstream fixed it October 5th. Debian shipped October 16th, Amazon the 24th. Ubuntu and Red Hat still hadn't as of this weekend.
The velocity is worth noticing, though. Fix on the fifth, disclosure on the fifteenth, Debian the day after, Anthropic's writeup the twenty-seventh. The core ecosystem moved in weeks.
Weeks, not months - that's the coordinated-disclosure machine working. The long tail of distros is where it stalls, and that's exactly where most servers live.
So what does a listener actually do?
Today, one command: S S dash capital M, state listening. It lists every multipath listener on a box. Patch kernels as your distro ships the fix. For Go services, a GODEBUG flag turns multipath TCP off - a stopgap the Go team themselves call fragile.
And a firewall rule dropping packets that carry IP options starves the exploit of its trigger. Cheap, targeted, buys time until the kernels land.
Last thought on this one - does the AI authorship change the defense?
Not the defense itself. The bug is ordinary memory handling; the novel part is who found it and how fast a five-platform portfolio shipped. You patch the same way either way - which is why the patch gap, not the AI, is the live risk.
Worth saying the Linux chain wasn't alone. In Chrome, the model chained four bugs into one-click code execution - a V8 corruption, a sandbox escape, a cache race, a sign-in flaw - sixty-two CVEs, patched by Google in Chrome 156.
In Safari, the chain bypassed the same-origin policy through memory manipulation alone - reading history, cookies, even authenticated sessions without executing code. Apple fixed it the day Anthropic reported.
On Android, it chained three flaws into a lock-screen bypass on a Pixel 9, pulling photos over USB. And Windows got an out-of-bounds read in its kernel QUIC implementation - a remote crash loop, found by reverse-engineering the binary with Ghidra.
Five platforms, one model. That's not a vulnerability find. That's an exploitation portfolio.
Anthropic's own post-mortem explains the scale: they ran large numbers of scanning agents in parallel, measured what each contributed, and tracked coverage across whole codebases. Scanner diversity plus test-time compute is what turns one bug into five chains.
Which is why Carbon matters as a counterweight. Same technique, pointed at defense.
OpenAI published its answer to a different worry this week: how it detects frontier-model misalignment, built after the Hugging Face incident.
The supply-chain one, where an eval agent got compromised?
The same. The layers: activation probes - lightweight classifiers reading the model's internal states. Then a model-based reviewer of conversations and tool use. Then an investigative agent that digs in when those flag.
Coverage?
Reportedly every reinforcement-learning run for models in their top capability class. This is the runtime half of the response - oversight while the model runs, not a one-time check.
A model reviewing a model, probes tuned by the same lab. I'd want independence. What would change my mind is an outside audit of that coverage.
But publishing the blueprint makes it copyable, and that earns credit. Tie it to the exploit segment: if exploit chains get AI-authored, oversight stops being a lab nicety.
For your own agents the pattern is identical. Watch internal states, review transcripts and tool calls, staff an escalation path.
One more access note. Anthropic expanded its Cyber Verification Program this month - vetted security professionals get the same model classes, on the argument that defenders need the head start more than anyone.
Head starts only matter if defenders use them. Which is the perfect bridge to the quarter.
Rest of the week, quickly. Google's quarter: Alphabet at twenty-five percent year-over-year growth, half a trillion dollars annualized, Cloud up one hundred three percent on AI demand.
Pichai also announced Project Suncatcher's first response from a TPU in orbit - a hello world, not a data center - and Genie 4, a real-time world-simulation model with native audio.
On the enterprise side: Credit Saison's three-hundred-fifteen-person ChatGPT pilot reported nine hundred fifty-four percent ROI, and Oracle cited one hundred thirty thousand active users as its apps came to ChatGPT.
In legal AI, Ropes and Gray is building transactional diligence where lawyers review every interim output, and Legora is branding itself the agentic operating system for legal work.
OpenAI's governance run made four moves in three days: honoring robots.txt training preferences, a values-reorganized Model Spec, a fair-use broadside at The New York Times, and a promised Community Safety Report after two hundred-plus law-enforcement referrals.
ServiceNow is embedding OpenAI agents through its Action Fabric, and Google's Connected Apps Platform preview lets developers build once against MCP servers to reach Search and the Gemini app.
Hardware on shelves too: Fitbit Edge shipped, and XREAL AURA became the first wired Android XR glasses.
Two research notes worth a skim: an education report introducing an AI fluency index, measuring where students and practitioners actually stand against the expectations employers now have, and AI for Science expanding to foundations and research institutions.
Three things should outlive the details. First, treat AI-authored exploit chains as operational reality. If you run Linux servers, check your multipath listeners today and patch kernels as fixes land.
Second, finding is now the cheap part. Carbon's fifty-five percent exploitation rate is the honest number - the gap between finding a bug and weaponizing it is where defense still lives.
Third, oversight stacks are becoming copyable templates. Watch internal states, review transcripts and tool calls, staff an escalation path - for frontier labs, and for your own agents.
Sources and links for everything you heard are in the show notes. That's the week.
Catch you Wednesday for the Hacker News edition.