Google has published a long list of results from Antigravity teamwork, the multi-agent feature inside its Antigravity coding app. In a Google Research post dated November 13, the company says teams of Gemini 4 agents produced a machine-checked formalization of the Weil conjectures in about 1.8 million lines of Lean, rewrote large C++ codebases in Rust, and helped settle several open problems. Google is also opening the tools to outside developers and offering 10,000 academic researchers six months of free top-tier access.
Key takeaways
- Google’s /teamwork-LEAP system autonomously formalized the Weil conjectures: about 1.8 million lines of Lean across 28,800 subagent calls.
- Other reported results include a 50-million-line Lean proof of the 2013 Courtade–Kumar conjecture and a Rust port of the libgav1 video decoder that runs 20–30% faster than the C++ original.
- The design rests on two ideas: automatic “falsifiers” that check every candidate answer, and agents that each see only the files they need.
- /teamwork and /boost are available in Antigravity now; the proof and rewrite patterns behind some headline results are still “coming soon”.
- All figures are Google’s own. Lean proofs verify themselves once published, but most systems results have no independent replication yet.
What happened
The post, signed by Google Fellow Vahab Mirrokni, is a progress report on work done over several weeks by Google teams and academic partners using Antigravity’s /teamwork with the Gemini 4 model family, mainly Gemini 4 Argon. It covers mathematics, chemistry, systems software and machine-learning engineering.
The headline is mathematical. The Weil conjectures describe how many solutions polynomial equations have over finite fields; Pierre Deligne completed their proof in 1974, and it is regarded as one of the landmark results of 20th-century mathematics. Google says its /teamwork-LEAP pipeline turned that body of work into an end-to-end formal proof in Lean, a language where a small computer kernel checks every logical step. The output runs to roughly 1.8 million lines and took 28,800 subagent invocations, figures also reported by Interesting Engineering.
The same pipeline produced more than 919,000 lines of Lean for the first formalization of a recent proof of Hilbert’s tenth problem over general rings of integers, and reproduced a formal version of a recent finite-time blowup result for the 3D Navier–Stokes equations with smooth forcing. Separately, researchers from Google, CUHK, USC and CMU used /teamwork to prove the 2013 Courtade–Kumar conjecture in information theory, then formalized the full proof in about 50 million lines of Lean.
The engineering results are closer to everyday developer work. Google says a two-week campaign rewrote the remaining C++ of its Zircon microkernel into roughly 800,000 lines of safe Rust that passes the kernel’s unit tests and boots on arm64 hardware. A second campaign ported libgav1, Google’s AV1 video decoder, into about 170,000 lines of Rust with bit-exact output. The port started around four times slower than the original; after the agents were given profilers and told to optimise, it ended up 20–30% faster than the C++ and hand-tuned assembly on both x86_64 and ARM. In chemistry, 30 cooperating agents identified complex molecules from NMR data with 95% top-1 accuracy, roughly double a single agent.
How /teamwork works
Google frames the design around two weaknesses of today’s models. First, a single generation is unreliable, so /teamwork runs many attempts in parallel and lets a “falsifier” decide which ones survive. A falsifier can be the Lean proof checker, an unmodified test suite, a simulator, web search or hardware performance counters. The point is that an external, objective check, not the model’s own confidence, decides what counts as done.
Second, models lose track of detail on multi-day tasks as their context fills up. /teamwork splits context by design: each specialist agent gets only the files and tools for its step, coordinators hand work to fresh successors between milestones, and critics or auditors review results without seeing the original agent’s reasoning. Workflows are written as natural-language “patterns” (distributed coding, long proofs, document review, rewrites), and the system routes each request to the pattern that fits.
If you have followed our explainer on multi-agent coding, the shape will look familiar. What is new here is the scale of the runs and the insistence on hard verification at every step.
Why it matters
Formal proof is one of the few areas where AI output can be trusted without trusting the AI. If a Lean file compiles against a correct statement of the theorem, the proof is valid, however it was written. That makes the Weil result a meaningful test of long-horizon agents: a 1.8-million-line artifact cannot be bluffed past a proof checker. The open question is the statement itself. Human mathematicians still have to confirm that the formal theorem says what the original conjecture says, and Google’s post does not link a public Lean repository for the Weil work, so outside experts cannot yet check it.
The Rust rewrites matter for a different reason. Large migrations usually fail when agents quietly stub out dependencies or edit tests until a broken port passes. Google says its new rewrite pattern prevents this by only scheduling a module once its dependencies compile and by linking every module against the original, untouched test suite. That is a practical recipe any team can borrow, with or without Antigravity.
What it means for developers
According to the Google post, external developers can use Gemini 4 models with /teamwork and /boost in Antigravity today. /boost packages the iterative solve-and-verify loop for hard single problems such as race conditions and tightly coupled refactors. Coverage by Data Studios, citing Antigravity’s documentation, says both commands sit on paid plans.
Three lessons travel well beyond Google’s tooling:
- Define the falsifier first. Agents are only as good as the check that grades them. A real test suite, benchmark or type checker beats an LLM judge.
- Keep context small. Give each agent the files it needs and nothing else, and let a reviewer work from a clean context.
- Protect the tests. Never let the agent that writes the code also edit the tests that judge it.
Cost is the unknown. Most results ran on Gemini 4 Argon, Google’s top model, and long multi-agent runs consume a lot of tokens. If you are weighing models for agent work, our breakdowns of Gemini 4 Carbon pricing and Gemini 4 Hydrogen are a useful starting point. Start with a bounded task and measure usage before committing to a multi-day campaign.
What it means for researchers
Google has opened applications for 10,000 academic researchers to get six months of free access to Antigravity’s highest usage tier, through a form linked from the research post. It has not published selection criteria or a deadline. The post also says Deep Review, its agentic paper reviewer, was used on 578 STOC 2027 submissions, with over 30% of surveyed authors saying it caught substantive proof bugs or significant typos.
What to watch next
- Public artifacts: whether Google releases the Weil and Hilbert Lean files so mathematicians can check the formal statements.
- Rollout: Google says the formal-proof and rewrite patterns, plus tutorials, arrive in Antigravity “in the coming weeks”.
- Independent replication: the Rust speedups, chemistry accuracy and kernel gains are self-reported and need outside benchmarks.
- Competition: OpenAI, Anthropic and open-source agent frameworks are all pushing long-running agents; verified, multi-day work is becoming the new benchmark.
The takeaway is not that AI now does mathematics on its own. It is that agents paired with strict, external checkers can carry very long projects to a verifiable finish, and that is a pattern developers can start using this week.