Google says its AI agents have finished moving Zircon, the kernel at the core of its Fuchsia operating system, from C++ to Rust. After an initial port of 25% of the code, the agents rewrote the rest in two weeks, adding about 800,000 lines of Rust. The Rust version passes all the kernel’s automated unit tests and boots on arm64 chips.
Vahab Mirrokni, a Google Fellow and vice president, described the work in a Google Research post on November 13, 2026. It says the agents also rewrote Google’s AV1 video decoder in Rust and made it 20 to 30% faster than the original on Google’s sample clips.
Six weeks earlier, on September 30, Google said its agents “are working on” the kernel migration, and its Rust decoder was still slower than the C++. No outside check of the new figures has been published.
The kernel port, checked by its original tests
Zircon is “the core platform that powers Fuchsia,” Fuchsia’s documentation says: a kernel plus the few services the system needs to run. The new code is safe Rust, the part of the Rust programming language that rules out memory errors such as writing data past its allotted memory. Google does not say who did the first 25% of the port.
The work ran on Gemini 4 Argon, Google’s new frontier AI model, announced September 30 (our guide to Gemini 4 Argon covers its launch and pricing). A feature of Google’s AI coding tool Antigravity, called /teamwork, split the work among many agents with separate roles.
Large ports fail, Google says, when agents “stub out dependencies,” faking code the port relies on, “or alter tests to make a broken port pass.” Google’s new rewrite pattern blocks both shortcuts.
Each module is scheduled only after its dependencies compile. Every leaf module, at the end of a dependency chain, is tested against “the original, unmodified test suite.” Google says the pattern is “soon to be available in Antigravity.”
A video decoder faster than its hand-tuned original
The decoder, libgav1, is Google’s open-source software for decoding AV1, a compressed video format. The agents rewrote it from C++ into about 170,000 lines of Rust. Its output matched the original bit for bit “across a broad conformance test suite,” Google says.
The first Rust version ran about four times slower than the C++. The agents then got profiling tools, which measure where a program spends its time, and “a mandate to maximize speed on sample video clips.” On those clips, the final port ran 20 to 30% faster than the original C++ and its hand-optimized assembly, code written in the processor’s own instructions, on x86_64 and ARM chips.
On Hacker News, one reader asked what the same tools would have done for the C++ itself. Google’s post does not say.
Where the work stood on September 30
Google DeepMind’s Koray Kavukcuoglu wrote the September 30 launch post for Gemini 4 Argon. Agents “are working on migrating C/C++ codebases to Rust across Google,” the post said, “up to 800K+ lines for the Fuchsia Zircon kernel.” The same post said such rewrites “are undergoing rigorous automated and manual auditing, emulation testing, and review before rolling out to production.”
For the decoder, agents had taken “an existing Rust port” and replaced 32,000 lines of its SIMD code, which runs one instruction on many values at once. That made it 2.7 times faster, “bringing it closer to the optimized C++.” The November 13 port started again from C++, so the two sets of numbers do not form one curve.
Agents had also found changes that would free “over 300 TiB of memory” in Google’s data centers once rolled out. Google estimated total savings at 500 TiB to 1 PiB, up to roughly a million gigabytes. The November 13 post says the savings identified since then exceed that 1 PiB estimate.
Math proofs checked by software
In math, the checker is Lean, a proof assistant that accepts a proof, written as code, only if every logical step checks out. Writing a proof this way is called formalization.
The Courtade-Kumar conjecture, posed in 2013, is an information theory problem about random bits sent through a noisy channel, which flips some of them. It says no rule that boils the input down to one bit keeps more information than simply copying one input bit.
Researchers from Google, the Chinese University of Hong Kong, USC and Carnegie Mellon proved it with Gemini models, in their paper posted September 21. Gemini found counterexamples to a broader version, Google says. The Hong Kong team reduced the problem to an optimization over 14 variables, and Gemini models produced most of the new bounds. The team then formalized the whole proof in Lean: 50 million lines.
Two other teams posted their own proofs on arXiv, on September 21 and September 22, and a fourth followed on November 3.
A November 4 paper by Piaoyang Cui, Yiming Liu and David Woodruff says the most about the agents’ share. At the STOC 2024 computer science conference, five researchers broke a 50-year barrier for combinatorial algorithms that multiply Boolean matrices, tables of zeros and ones. They asked whether a much better bound was possible, and the paper answers yes.
Its “AI Disclosure” section says the humans chose the problem and the direction, and “Gemini 4 agents developed the proofs and algorithmic constructions in all phases of the project.” The humans checked and edited the paper.
Google says its agents “fully autonomously” produced a Lean version of the Weil conjectures, results on counting the solutions of polynomial equations that Pierre Deligne’s 1974 proof completed. It runs to about 1.8 million lines of Lean, produced across 28,800 agent calls. The startup Axiom Math published its own Lean formalization of the same conjectures on November 6.
While formalizing the 3D Bochner-Riesz conjecture, from harmonic analysis (the math of breaking functions into waves), the agents found and fixed a gap in a recently released proof, Google says. Mirrokni summed up the theory work on Hacker News as “10+ open math and CS theory problems solved.”
In a separate paper submitted November 6, Google DeepMind and Google Quantum AI researchers reported agents that found quantum programs up to 290x cheaper and proved them correct in Lean.
Chemistry, the game of Go and Google’s own chips
In chemistry, 30 agents and a spectrum simulator worked out molecular structures from nuclear magnetic resonance, a standard lab test. Their first answer was exactly right for 95% of complex test molecules, nearly double a single agent’s score, Google says.
In the board game Go, agents worked on their own for under eight days to improve a basic AlphaZero program for the small 9×9 board. Humans set the chip allocation and the evaluation rules.
The program gained roughly 2,600 Elo rating points, a chess-style scale, reaching 1,885. That puts it between the open-source KataGo engine at 16 and at 32 visits per move. Mirrokni called it “the medium Elo level.”
On some types of Google’s AI chips, called TPUs, two scheduling changes shipped by an agent workflow cut by 24% the number of jobs bumped for other work.
What Google has not shown
Google’s post links to none of the new kernel or decoder code. Fuchsia’s public source tree does hold Rust files in the Zircon kernel, whose main file refers to an “initial Rust conversion process.” Google does not say which of them the agents wrote. The libgav1 repository still asks for “a C++17 compiler” and holds no Rust version.
The post does not say whether the Rust kernel runs in any product or has passed the audits the September post described.
A test suite checks only what its tests cover, and Lean checks a proof only against the statement it is given. Google’s post makes the same point: a Lean proof settles a question “once human mathematicians confirm that the formal theorem statement matches the original problem.”
The post says all the work was “done in collaboration with human experts” but, except in the matrix paper, rarely says what the humans did.
What it means
Google’s two posts make a six-week report card for Google’s Argon agents. The kernel went from work in progress to booting with every unit test passing. The best Rust decoder trailed the C++ in September, and in November a new port beat it on Google’s sample clips.
A kernel, a video decoder and a math proof share one setup: many agents propose candidates, and automatic checks decide which ones work. Google calls these checks “falsifiers,” and they do not care who wrote the code. Examples include an unmodified test suite, the Lean proof checker and a hardware counter.
That is how the volumes get so large: a program checks the 50 million lines of the Courtade-Kumar proof. The same pattern sat behind Amazon’s AWS emulator, built by agents and released November 11.
Three questions sit outside any checker’s reach: whether the specifications were right, whether the Rust kernel passes Google’s audits before production use, and whether anyone outside Google can reproduce the results.
Next to watch are the rewrite pattern Google says is coming to Antigravity, and whether Google identifies the agents’ code in the Fuchsia tree and publishes the Rust decoder.
Sources
- Advancing science & engineering with Antigravity’s /teamwork, Vahab Mirrokni, Google Research, November 13, 2026
- Gemini 4 Argon: our next era of frontier intelligence, Koray Kavukcuoglu, Google, September 30, 2026
- Combinatorial Boolean Matrix Multiplication in n³/2^Ω(√log n) Time, Piaoyang Cui, Yiming Liu and David P. Woodruff, arXiv, November 4, 2026 (revised November 10, 2026)
- A Proof of the Most Informative Boolean Function Conjecture, Zijie Chen, Amin Gohari, Adel Javanmard, Honghao Lin, Vahab Mirrokni, Chandra Nair and David P. Woodruff, arXiv, September 21, 2026
- Zircon, Fuchsia documentation, read November 15, 2026
- zircon/kernel, Fuchsia source tree, Git at Google, read November 15, 2026
- codecs/libgav1, libgav1 repository, Git at Google, read November 15, 2026
- Advancing science and engineering with Antigravity’s /teamwork, Hacker News thread with comments by Vahab Mirrokni, November 14, 2026
Header image: chart by MACCUS, data from Google Research, November 13, 2026
