wasl.tech

Google Antigravity Teamwork: AI Agent Teams Just Proved a 13-Year-Old Math Conjecture

For thirteen years, a maths problem sat quietly on the shelf, untouched by every attempt to solve it. Then a team of researchers handed it to a room full of AI agents — and watched them take it apart, piece by piece, until nothing was left to prove.

The problem was the Courtade–Kumar conjecture, an information-theory puzzle from 2013. Google Research says its Antigravity /teamwork system helped solve it, and the result is now a formal, machine-checked proof. The same agent teams also rewrote parts of Google’s own production software.

Google Antigravity teamwork is not one chatbot working alone. It is a crew of specialist agents built on the Gemini 4 family — Argon, Gemini 4 Carbon and Gemini 4 Hydrogen — each given a narrow job, a small slice of context and a verifier that checks its work. Humans set the question and judge the answer.

Google published the results on November 13, 2026, in a research post by Vahab Mirrokni, a Google Fellow and vice president at Google Research. The company says it is now making the tools available outside Google, inside Antigravity, alongside its /boost agents.

What Google Antigravity teamwork actually is

Antigravity is Google’s agent-first development environment. It runs as a desktop app, a command-line tool and IDE extensions, and its whole idea is that AI agents do the coding while a person directs them.

/teamwork is the multi-agent mode inside it. Instead of asking one model to solve a hard problem end to end, it splits the work across a team. Some agents explore candidate solutions. Others play the critic, hunting for flaws. A third group verifies the results against something that cannot be bluffed.

The system exists because Google says single models have two weaknesses on long jobs. They can produce a wrong answer even when a correct one exists, and they lose track of details when a task stretches across days.

/teamwork answers both problems with structure. It runs many attempts in parallel and hands them to dedicated falsifiers: the Lean 4 proof checker, unchanged software test suites, execution simulators, web search and hardware counters. If a candidate solution cannot survive those checks, it is thrown out.

How the agent teams keep each other honest

The second fix is about memory. Each specialist agent receives only the files and tools it needs for one step, so its context stays small and focused. Coordinators hand work to fresh successors. Critics and auditors review results from clean contexts, without ever seeing the original producer’s reasoning.

That separation matters. An auditor that has already read a confident-sounding argument is more likely to nod along. An auditor starting cold has to rebuild the case from scratch — and that is exactly what catches mistakes.

Google describes the whole approach as declarative, self-improving natural-language patterns. The system routes each prompt to the pattern that fits it best: distributed coding, iterative problem solving through /boost, long-proof workflows, or document review.

People are not bystanders in any of this. According to Google Research, humans frame the questions, define the theoretical or physical constraints, and evaluate the outputs. Researchers verified, simplified and edited the resulting algorithms and proofs before publication.

The 13-year-old conjecture that fell first

The headline result is the Courtade–Kumar conjecture. In plain terms, it asks a question about noisy channels: when a random string of bits passes through one, and you compress the result down to a single bit, how much information can you possibly keep?

The conjecture says the answer is no more than a dictator function can manage — a function that simply copies one input bit and ignores the rest. It is a clean, sharp claim, and it resisted proof for thirteen years.

The team behind the proof brought together researchers from Google, the Chinese University of Hong Kong, the University of Southern California and Carnegie Mellon University. Early on, Gemini found counterexamples to a generalised version of the conjecture from an earlier CUHK paper, which narrowed the search.

The researchers then proposed a new candidate function and reduced the problem to a 14-variable optimisation. Gemini 4 Argon and earlier Gemini models helped partition that parameter space and develop analytical bounds and interval-arithmetic certificates — the kind of exhaustive, fiddly arithmetic that would take a human team months.

The complete proof was then formalised in Lean 4, producing 50 million lines of code. That number needs context. An independent check found that only around 239,000 of those lines are proof a person could actually read. The rest is generated certificate data that the Lean kernel checks mechanically.

A million lines of proof for the Weil conjectures

The Courtade–Kumar result was not the only piece of mathematics in the report. Google says its agent teams also produced an approximately 1.8-million-line Lean 4 formalisation of the Weil conjectures, built across 28,800 subagent invocations.

The Weil conjectures concern the number of solutions to polynomial equations over finite fields. They are among the deepest results in modern mathematics, proved by André Weil and later Pierre Deligne. Formalising them in machine-checkable form is a translation exercise on an enormous scale.

One caveat is worth stating plainly. Google’s post links to Wikipedia pages for the Weil conjectures and Deligne, but it did not link a public repository for its formalisation, so the claim cannot yet be independently inspected. Axiom, a separate research group, published its own public formalisation on November 6, a week before Google’s announcement.

Other reported results include a Lean-verified result on sample bounds in adaptive data analysis, a new quantum-computing construction settling a question from 2014, and a deterministic algorithm for a Boolean matrix multiplication problem left open at STOC 2024.

From maths to real code: Rust, decoders and kernels

The most concrete results may be the engineering ones, because they touch software people actually run. Google says /teamwork rewrote libgav1, its production AV1 video decoder, from C++ into around 170,000 lines of Rust — and the rewritten decoder runs 20 to 30 percent faster.

A second project ported the remaining C++ components of the Fuchsia Zircon microkernel into roughly 800,000 lines of safe Rust in about two weeks. A microkernel is the heart of an operating system, so this is not a toy exercise. It is the kind of migration a human team would schedule in quarters, not days.

The report also mentions molecular-structure discoveries and optimised TPU kernels. Google has not published the details of those yet.

The pattern is the same in every case: agents propose, verifiers check, humans decide. A Rust migration either passes the unchanged test suite or it does not. A kernel either runs faster on the hardware counters or it does not. The system is built around checks that cannot be talked into agreement.

Why humans still run the show

Google is careful, in its own telling, not to claim the agents discovered these results alone. The Courtade–Kumar proof came from a collaboration: the models found counterexamples and did the arithmetic, the researchers proposed the candidate function and shaped the argument.

That distinction matters because the alternative would be a very different story — an AI that quietly solves open problems on its own. What Google is describing is closer to a research team with tireless junior members: fast at exploring, and dependent on a supervisor who can tell a real proof from a convincing one.

It is a familiar pattern from Google’s own recent history. Earlier this month, DeepMind’s AlphaProof Code formally verified the security properties of Signal’s real encryption code, with agents writing more than six million lines of Lean in about four weeks. The tools are different, but the shape of the work is the same.

What happens next for Antigravity /teamwork

Google says the tools are being made available externally in Antigravity, alongside /boost and other agents, so researchers and developers can apply the workflows to their own work. The /teamwork and /boost workflows are available now to paid users on Google AI Pro and Ultra plans.

The specialised formal-proof and software-rewrite patterns are scheduled for later releases, and a researcher access programme is listed on the announcement page. For developers, the immediate question is practical: how much of this survives contact with an ordinary codebase?

Google’s bet is that the future of hard problems looks like this: a human with a question, a team of agents with different jobs, and a verifier that cannot be charmed. The Courtade–Kumar conjecture took thirteen years to fall. The next one may not take nearly as long.

Leave a Comment

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

Scroll to Top