Google's /teamwork Agents Lean on Checkers, Not Trust, for Lean Proofs and Rust Rewrites
Google Research said on November 13 that Antigravity's /teamwork multi-agent system, built on Gemini 4 models, pairs parallel agents with dedicated falsifiers such as the Lean 4 proof checker and unmodified test suites, and gives each agent only the context it needs. Google says the system autonomously produced a machine-checked Lean formalisation of the Weil conjectures of about 1.8 million lines across 28,800 subagent invocations, rewrote the remaining C++ of the Zircon microkernel into about 800,000 lines of safe Rust in two weeks, and cut TPU workload preemption by 24% on some hardware types. External developers can use /teamwork and /boost in Antigravity now; the formal-proof and rewrite patterns are still to come. The results are self-reported.

Google's case for long-running agent teams rests on a component that is not a model: the checker that tells an agent it is wrong. In a Google Research post on November 13, Vahab Mirrokni describes Antigravity's /teamwork as parallel agents paired with "dedicated falsifiers," including the Lean 4 proof checker, unmodified software test suites, execution simulators, web search and hardware counters, that decide which candidate solutions work. The headline numbers are large. What makes any of them believable is that most were graded by a machine that does not care how confident the agent sounded.
How Google says it works#
Google names two limits of current models that the design addresses. A single attempt is unpredictable, so /teamwork runs candidates in parallel and lets the falsifiers sort them. And models "often lose track of details over multi-day tasks," so the system partitions context: each agent gets only the files and tools for its step, coordinators hand work to fresh successors, and critics and auditors check results from a clean context without the producer's reasoning. Workflows are written as natural-language patterns, and the system routes each prompt to one of them. Google first announced Teamwork at I/O and opened a preview on paid Antigravity plans in August.
What Google says it produced#
- Weil conjectures: /teamwork "fully autonomously produced an end-to-end, machine-checked formalization" of the Weil conjectures, about 1.8 million lines of Lean across 28,800 subagent invocations.
- Courtade–Kumar conjecture: researchers from Google, CUHK, USC and CMU used its Long Proof pattern to prove the 2013 information-theory conjecture in full generality, formalising the proof in Lean 4; human researchers supplied a key reduction and lower bound.
- Zircon in Rust: building on an earlier 25% port, a two-week Gemini 4 Argon campaign rewrote the rest of the Zircon microkernel's C++, adding about 800,000 lines of safe Rust that Google says pass all kernel unit tests and boot on arm64 hardware. The pattern schedules each module only after its dependencies compile and links every module against the original, unmodified tests, a guard against agents that stub out code or edit tests to make a port pass.
- Google's own fleet: two shipped changes to Borg scheduling cut TPU workload preemption by 24% on some hardware types, Google says.
One finding cuts against the parallel story. A /teamwork campaign that analysed past runs found tightly coupled code is better handled in sequential implement-and-revise stages than in parallel splits, and Google folded that into /boost, its packaged coding loop.
What is available#
External developers can use Gemini 4 models with /teamwork and /boost in Antigravity and Deep Review today, Google says, and it has opened applications for 10,000 academic researchers to get six months of free access to its highest usage tier. The formal-proof pattern and the rewrite pattern behind the Zircon result are listed as coming later. The models underneath include Gemini 4 Hydrogen, released on November 12, and the checker-first approach mirrors DeepMind's machine-checked Signal proofs earlier in the month.
Limits#
- Every result is Google's own description. We have not seen independent review of the mathematical results or the Rust rewrite.
- A Lean check verifies the formal statements as written; it does not show those statements match the intended theorems, and the post does not describe how that was reviewed.
- Lines of code measure size, not quality. Passing the kernel's unit tests is only as strong as those tests.
- The 24% preemption cut applies to "some hardware types" and Google gives no baseline.