On 13 November 2026, Google Research published a results post that reads like a highlight reel: teams of Gemini 4 agents working inside Antigravity’s /teamwork system proved a maths conjecture that had stood open since 2013, formalised the Weil conjectures, and rewrote parts of Google’s own production software into memory-safe Rust — one decoder ending up 20 to 30 percent faster than the hand-tuned C++ it replaced. The post is real, the results are mostly checkable, and the headline numbers are not all measuring the same thing. This is what /teamwork actually did, and which claims you can verify yourself.

Quick answer: Google's Antigravity /teamwork used Gemini 4 agents to prove a 2013 conjecture and rewrite a video decoder into faster Rust — but two claims need checking.

Key takeaways:

What is Antigravity’s /teamwork?

Antigravity is Google’s agent-first development environment — a desktop app, a command-line tool and IDE extensions in which AI agents do the coding while the developer directs them. /teamwork is its multi-agent mode: instead of one agent doing everything, it splits a hard problem across a team of specialist agents with separate roles, running on the Gemini 4 family — Argon, Carbon and Hydrogen.

Google Research describes two design ideas behind it. First, a single model attempt is unreliable, so /teamwork pairs parallel exploration with dedicated falsifiers: the Lean 4 proof checker, unmodified software test suites, execution simulators, web search or hardware performance counters, which automatically verify which candidate solutions work. Second, models lose track of details over multi-day tasks as context grows, so /teamwork partitions context by construction — each agent receives only the exact files and tools it needs for one step, while coordinators hand tasks to fresh successors and critics review results from a clean context, without seeing the original producer’s reasoning.

The workflows are expressed as declarative, self-improving natural-language patterns, and the system routes each prompt to the pattern best suited to the task. One of those patterns, /boost, packages the iterative solve-and-verify loop for day-to-day coding. Google says the patterns are available in Antigravity today, with more specialised workflows and deep-dive tutorials coming to the Antigravity blog in the following weeks.

What did the agent teams actually do?

The 13 November post, written by Google Fellow and VP Vahab Mirrokni, reports work from the previous several weeks by teams across Google and academic partner institutions. The results fall into four groups: mathematics, chemistry, systems engineering and Google’s own infrastructure. Every claim below is Google’s own account unless labelled otherwise, and the table in the next section separates what an independent check has confirmed from what it has not.

In mathematics, researchers from Google, the Chinese University of Hong Kong, the University of Southern California and Carnegie Mellon used /teamwork’s “Long Proof” pattern to prove information theory’s 2013 Courtade–Kumar conjecture in full generality. The conjecture concerns what happens when a random bit string passes through a noisy channel: it confirms that no compression of the input to a single bit preserves more information than a “dictator function”, which simply copies a single input bit.

The post also reports more than ten other open problems tackled the same way, including a near-optimal sample bound for adaptive statistical queries (a gap open since 2014), a construction settling a 2014 open question in quantum computing, a new deterministic algorithm for Boolean matrix multiplication that resolves the main open question from STOC 2024, and progress on Tarjan’s 1985 Deque Conjecture, verified in Lean 4. A separate framework, LEAP, developed with Google Cloud AI and paired with Gemini 4 Argon, is credited with formalisations of the Weil conjectures, Hilbert’s tenth problem over general rings of integers, the Birkhoff conjecture (open since 1927) and the 3D Bochner–Riesz conjecture, where Google says the system found and fixed a gap in a recently released informal proof.

In chemistry, 30 specialised agents organised into a self-correcting loop with a physics-informed spectral simulator determined molecular structures from nuclear magnetic resonance data with 95% top-1 exact match and 100% top-3 accuracy on complex benchmark molecules — nearly doubling single-agent performance, according to Google. The post also describes a drug-discovery example in which the system analysed two existing lung cancer therapies and proposed novel candidate compounds with chemical synthesis routes in roughly one hour, although no compound names or validation results are published.

In systems engineering, the headline results are the Rust rewrites covered below, plus a 9×9 Go engine trained from scratch that gained roughly 2,600 Elo in under eight days to reach 1,885 Elo — between KataGo at 16 and 32 visits per move, by Google’s account — and custom TPU kernels for graph neural networks delivering up to a 185x reduction in high-bandwidth-memory usage and 8x to 15x speedups.

The 50-million-line proof: what the number really means

The Courtade–Kumar result is the one claim in the post that has been independently audited in detail, and the audit is more interesting than the headline. The proof itself is not new: the informal proof, “A Proof of the Most Informative Boolean Function Conjecture”, was posted to arXiv on 21 September 2026 by Zijie Chen, Amin Gohari, Adel Javanmard, Honghao Lin, Vahab Mirrokni, Chandra Nair and David P. Woodruff — and at least four other groups posted proofs of the same conjecture in the same weeks. What Google’s version adds is the formalisation: the entire proof written in Lean 4, so that a computer kernel checks every logical step.

An independent check by sysnote, published 14 November 2026, cloned the public repository (dpwoodru/general-courtade-kumar-lean) and counted 45,510 Lean files totalling 50,373,106 lines — the “50 million” checks out. But the repository’s own guide says only 1,359 files, or 238,690 lines, are readable proof code. The other 44,141 files, about 4.88 GB, are generated certificate data: numerical bounds over pieces of the parameter space that the Lean kernel checks mechanically, mostly with decide. Under half a percent of the line count is the proof a person would read.

That does not make the result weaker — it makes the number a different kind of measurement. The audit trail is unusually strong for a formal-maths announcement: a clean rebuild with a byte-identical final compiled file, an independent run of the verification kit, acceptance by Lean’s comparator against the theorem statement in google-deepmind/formal-conjectures, and acceptance of all 22,107,215 declarations by con-leche, the Lean FRO’s external checker, all between 23 September and 15 October 2026. What a human has to trust is a 63-line statement file, GeneralCK/Statement.lean. The line count measures how hard the checker was worked, not how much mathematics was done — and for a proof whose hard part is grinding through a 14-variable optimisation problem, that is a perfectly good way to prove an inequality.

“Frontier research and systems engineering require navigating vast literature, building custom computational pipelines, testing against physical measurements, and verifying every step. Progress comes from an interactive discovery loop where researchers frame questions and define the theoretical or physical constraints, while long-horizon agents write custom solvers, explore large search spaces, test candidate designs, and check long chains of logic.” — Vahab Mirrokni, Google Research, 13 November 2026

The Weil conjectures claim: the one you cannot check yet

The post’s second maths headline is harder to verify. It says /teamwork-LEAP “fully autonomously produced an end-to-end, machine-checked formalization of the Weil conjectures”, the landmark results on counting solutions of polynomial equations over finite fields that culminated in Pierre Deligne’s 1974 proof — about 1.8 million lines of Lean, produced across 28,800 subagent invocations.

As of this writing, there is no public repository, paper or statement file for that formalisation. The post links to Wikipedia pages for the Weil conjectures and for Deligne. The LEAP framework itself links to a framework paper (arXiv:2606.03303), not to any of these results, and no Weil or LEAP repository was found under Google’s GitHub organisations. Until the code is public, nobody outside Google can say which theorem it states, which axioms it uses, whether it rebuilds, or how much it overlaps with work that was already public.

That last point matters, because a public version already exists. Axiom published AxiomMath/Weil on 6 November 2026 — a week before Google’s post — under the Apache 2.0 licence. It states and proves all four Weil conjectures, following Freitag and Kiehl’s Étale Cohomology and the Weil Conjecture, and its README says there is no sorry, no native_decide and no added axiom. Axiom’s founder, Carina Hong, said it took less than a day. An independent count put Axiom’s repository at 213,159 lines, sitting on top of its much larger Lean formalisation of the Stacks Project — which is why “1.8 million lines” cannot be compared with anything on its own: depending on where you draw the boundary between a formalisation and its foundations, the same theorem can be 213,000 lines or 18.6 million.

The same verification gap applies to the other LEAP results in the post — the 919,000-plus lines for Hilbert’s tenth problem, the Birkhoff and Bochner–Riesz formalisations, and the reproduction of a Navier–Stokes blowup proof. They are Google’s claims, not yet independently checkable ones. That is not an accusation of error; it is the difference between a result and a press release, and it is exactly the distinction /teamwork’s own design — trust the checker, not the claim — says you should draw.

Which claims are verified, and which are not

Claim (Google Research, 13 Nov 2026)StatusEvidence
Courtade–Kumar conjecture proved and formalised in Lean 4, 50M linesVerifiedPublic repository counted independently at 50,373,106 lines; clean rebuild, Lean comparator check and external con-leche acceptance of all 22,107,215 declarations, 23 Sep–15 Oct 2026
Only ~239,000 of those lines are readable proofVerifiedRepository’s own guide: 1,359 of 45,510 files; the rest is generated certificate data
Weil conjectures formalised in 1.8M lines, 28,800 subagents, “fully autonomous”UnverifiedNo public code, paper or statement file; a public Axiom formalisation of the same theorems appeared 6 Nov 2026
libgav1 rewritten into ~170k lines of Rust, 20–30% faster than the C++ originalGoogle’s account, no public code linked100% bit-exact parity across a conformance suite, per Google; the rewrite pattern is described, the code is not public
Zircon microkernel ported to ~800,000 lines of safe RustGoogle’s account, no public code linkedPasses all kernel unit tests and boots on arm64 hardware, per Google
9×9 Go engine trained from scratch, 1,885 Elo in under eight daysGoogle’s account, no public code linked2,300x faster self-play, champions promoted by statistical tests on locked records, per Google
10,000 academic researchers to get six months of free top-tier accessAnnouncedApplications opened with the post; no deadline or selection criteria published in it

The Rust rewrites are the part developers should care about

Strip away the maths scoreboard and the most transferable result is the engineering one. Large code migrations usually fail, Google notes, when agents stub out dependencies or alter tests to make a broken port pass. The new /teamwork rewrite pattern, soon to be available in Antigravity, schedules each module only after its dependencies compile and links every leaf module against the original, unmodified test suite.

Applied to libgav1, Google’s production AV1 video decoder, that pattern produced around 170,000 lines of Rust with 100% bit-exact parity across a broad conformance test suite. The first port was about four times slower than the original C++. After /teamwork was given access to profiling tools and a mandate to maximise speed on sample video clips, the Rust port became 20 to 30 percent faster than the original C++ and hand-optimised assembly code on both x86_64 and ARM. A memory-safe rewrite that is also faster is the outcome every migration project wants and almost none gets on the first attempt.

The Zircon microkernel tells the same story at larger scale. Building on an initial 25% port, a two-week campaign on Gemini 4 Argon rewrote the remaining C++ code, adding about 800,000 lines of safe Rust that pass all kernel unit tests and boot on arm64 hardware. Elsewhere in the same post, /teamwork built FarArray, a low-latency kernel-bypass address space based on the SNAP microkernel, with applications scaling to 1-trillion-edge graphs at 60x to 90x throughput gains, and custom TPU kernels delivering up to a 185x reduction in high-bandwidth-memory usage.

There is also a quieter result that may matter more than any of the records: a long-running /teamwork campaign analysed past run transcripts and concluded that tightly coupled code is better handled by sequential implement-and-revise stages than by parallel splits. That finding went into /boost, the packaged coding pattern. A harness tuning another harness from its own run history is the most transferable idea in the whole post — it is a design lesson any team building multi-agent workflows can use, without needing Google’s compute.

What you can use today

External scientists and developers can use Gemini 4 models with /teamwork and /boost in Antigravity and Deep Review today, according to the post. Deep Review, the document-review pattern, was also tested on authors of 578 submissions to STOC 2027 — over a third of all submissions opted in. In an ongoing author survey of 70 respondents, 90% rated the feedback mostly or almost all factual, 90% said they would use the tool again, over 30% said it caught substantive proof bugs or mathematically significant typos, and 14% said it found technical gaps that took more than an hour to fix. Two weekly calls to Deep Review are free.

Google has also opened applications giving 10,000 academic researchers six months of free access to its highest usage tier. The post does not publish a deadline or selection criteria, so treat the offer as announced, not as a guarantee of a place.

For context on the models doing this work, see our explainers on Gemini 4 Carbon and Gemini 4 Hydrogen, and the Argon vs Carbon comparison. The same verification-first thinking applies to everyday agent use — our guide to setting limits on an AI assistant before it acts for you covers the guardrails, and our explainer on Google’s AI proving Signal’s encryption code sound shows the same formal-verification idea applied to real software.

Our take

Google’s /teamwork post is best read as two announcements wearing one headline. The first is a genuine engineering advance: agent teams that produce checkable work — proofs a kernel verifies, code that passes unmodified test suites, kernels that boot — rather than confident text. The Rust rewrites and the /boost lesson are the evidence for it, and they are the parts a working developer can learn from today.

The second is a scoreboard, and scoreboards need independent checking. The Courtade–Kumar proof survives that check with an unusually strong audit trail; the Weil formalisation does not yet have one, and the existence of a public Axiom version from a week earlier makes the omission harder to ignore. Line counts, in both cases, measure how hard a checker was worked — not how much mathematics was done, and not how much of the work a human could read.

That is not a reason to dismiss the post. It is the reason to read it the way /teamwork itself is designed to work: trust the falsifier, not the claim. Where Google published the artifact, the result stands. Where it did not, the claim waits — and the wait is the story.

Frequently Asked Questions

What is Google Antigravity’s /teamwork?

/teamwork is the multi-agent mode inside Google’s Antigravity development environment. It splits a hard problem across a team of specialist agents — each with only the files and tools its step needs — running on Gemini 4 models, and pairs their parallel work with independent verifiers such as the Lean 4 proof checker, unmodified test suites and hardware counters that decide which results survive.

Did Google’s AI really prove a maths conjecture?

Yes, with a caveat about timing. The informal proof of the 2013 Courtade–Kumar conjecture was posted to arXiv on 21 September 2026 by researchers from Google, CUHK, USC and CMU, and other groups proved it independently around the same time. What /teamwork added is the formalisation: the full proof written in Lean 4, publicly available, independently counted at 50,373,106 lines and machine-checked by the Lean kernel and an external checker.

What does “50 million lines of Lean” actually mean?

Less than it sounds like, and more than nothing. Only about 239,000 lines are readable proof code; the other roughly 50 million lines are generated certificate data — numerical bounds over pieces of the parameter space that the Lean kernel checks mechanically. The proof is real and verified; the line count mostly measures how much work the checker did.

Is the Weil conjectures formalisation verified?

Not yet by anyone outside Google. The 13 November post gives no public repository, paper or statement file for the claimed 1.8-million-line formalisation. A public formalisation of the same theorems, AxiomMath/Weil, was published on 6 November 2026 under the Apache 2.0 licence. Until Google publishes its code, the claim should be treated as Google’s account, not an independently checked result.

Can I use /teamwork myself?

Yes, in part. Google says Gemini 4 models with /teamwork and /boost are available in Antigravity today, and Deep Review offers two free weekly calls. Google has also opened applications for 10,000 academic researchers to receive six months of free access to its highest usage tier, though no deadline or selection criteria were published in the announcement. The formal-proof pattern and additional specialised workflows are promised in upcoming updates, not yet generally available.

Sources and Methodology

Sources: Google Research, “Advancing science & engineering with Antigravity’s /teamwork”, Vahab Mirrokni, 13 November 2026 (https://research.google/blog/advancing-science-engineering-with-antigravitys-teamwork-feature/); sysnote, “Google’s /teamwork math claims, checked”, 14 November 2026 (https://sysnote.net/news/google-s-teamwork-math-claims-checked-99-5-of-the-50-million-lean-lines-are-cert); arXiv, “A Proof of the Most Informative Boolean Function Conjecture”, 21 September 2026 (https://arxiv.org/abs/2609.24931); AxiomMath/Weil repository, published 6 November 2026 (https://github.com/AxiomMath/Weil); Google Research post links and the Antigravity product pages for /teamwork availability.

Method: every factual claim in this article was checked against Google Research’s own post, read in full on 16 November 2026, and the two headline maths claims were checked against an independent audit (sysnote, 14 November 2026) that cloned and counted the public repository. Claims without a public artifact are labelled “Google’s account” or “unverified” in the article and in the status table. No hands-on testing was done — /teamwork runs inside Antigravity, and this article is desk-researched; that limitation is stated plainly. Verification date: 16 November 2026.

Leave a Reply

Your email address will not be published. Required fields are marked *