Google /teamwork proves the Courtade-Kumar conjecture: agent swarms enter formal mathematics
π An open problem since 2013 has just fallen
On November 13, 2026, Google Research published the results of Antigravity /teamwork, its multi-agent harness driven by the Gemini 4 models. On the menu: the proof of the Courtade-Kumar conjecture, posed in 2013 in information theory, wrapped up in collaboration with researchers from CUHK, USC, and CMU, and formalized in roughly 50 million lines of Lean 4.
This isn't just another benchmark. A formalized proof can be verified by machine β there's no room for interpretation on the score. When an agent swarm produces a verifiable artifact of this size, we're in a different category altogether: agents are no longer content with writing code, they produce controllable mathematical objects.
And the most interesting part isn't the result, but the mechanics: siloed agents, automated falsifiers, critics with a fresh context. It's this architecture that needs to be dissected β and that you can partially reproduce starting today.
The Essentials
- The Courtade-Kumar conjecture (2013) is proven in general by a collaboration between Google, CUHK, USC, and CMU, via the Antigravity /teamwork Long Proof pattern; the proof is formalized in ~50 million lines of Lean 4 (paper on arXiv : 2609.24931).
- Explicit division of labor: humans produced the reduction to a 14-variable optimization and the key lower bound; Gemini 4 Argon partitioned the parameter space, produced most of the analytical bounds, and extended the proof to unbalanced functions without human intervention.
- With LEAP, /teamwork also formalized the Weil conjectures (~1.8 million lines of Lean, 28,800 sub-agent invocations), the tenth Hilbert problem on general rings (919,000 lines), and rewrote the Zircon microkernel in ~800,000 lines of safe Rust.
- Mechanism: each agent only sees the files and tools of its stage; dedicated falsifiers (Lean 4 checker, unmodified test suites, simulators) validate each candidate; critics re-verify in their own context.
- Limitations: all results are self-declared by Google, without independent review or cost figures; Axiom had published its own Weil formalization on November 6, 2026, one week earlier.
Recommended tools
| Tool | Main use | Price | Ideal for |
|---|---|---|---|
| Antigravity /teamwork | Agent swarm orchestration with patterns and falsifiers | Paid preview since August 2026 | Devs who want to orchestrate specialized agents on long-running tasks |
| Lean 4 | Formal proof verification | Free, open source | Mechanically checking proofs, formalizing statements |
| Ollama | Local open source AI agents | Free | Experimenting with multi-agent setups without sending your data to the cloud |
| Hostinger | Hosting your own agent experiments (VPS) | From ~$3/month (November 2026, check hostinger.com) | Running orchestrations 24/7 on a budget |
My advice: start with Lean 4 if the verification aspect interests you, or with Ollama if you want to test context isolation locally without depending on a cloud.
What exactly is the Courtade-Kumar conjecture?
Proposed in 2013 (arXiv 1302.2512), it is a question of information theory of disarming simplicity: when a random bit string passes through a noisy channel, no compression down to a single bit preserves more information than a dictator function that copies a single input bit.
Let's break it down. You have $n$ random bits, and you observe a noisy version of this string. You are asked to summarize the input into a single bit. Which function should you choose to retain the maximum amount of information about what you observed? The conjecture asserts that the best strategy is the dumbest possible: copying an input bit, as is.
Counter-intuitive, right? One would expect a function combining several bits to extract more signal from the noise. For thirteen years, mathematicians and information theorists have been scratching their heads over this question, with only partial proofs limited to restricted families of functions. This is why the word "general" in Google's announcement is so important.
How the proof was completed: humans and Gemini in relay
In relay fashion: humans and Gemini passed the baton to each other, with an explicit division of labor described in the Google Research post. It's the most instructive reading of the announcement β neither "the AI did everything" nor "the AI only made noise".
First act: Gemini found counterexamples to an earlier generalization proposed by CUHK researchers (arXiv 2502.10019). The previous paper was wrong, and the AI established that before any positive breakthrough. A detail that says a lot about the real value of agents in math: first break, then build.
Second act, human: the reduction of the problem to a 14-variable optimization and the key lower bound come from researchers at Google, CUHK, USC and CMU. This is the architect's work that models don't do on their own, whatever the press releases suggest.
Third act, machine: Gemini 4 Argon partitioned the parameter space, produced most of the new analytical bounds and interval arithmetic certificates, then extended the proof from balanced functions to unbalanced ones without human intervention. Everything was formalized in Lean 4 via the Long Proof pattern β whose implementation, Stellar Colosseum, has its own paper (arXiv 2609.15983) β for a total of about 50 million machine-checked lines.
Gemini 4, the rising family
Argon doesn't come alone: Google is simultaneously pushing Gemini 4 Carbon as its most powerful model, targeting multi-step code and science with Swarm to orchestrate agent swarms (our analysis). The strategy is clear: models specialized per campaign, not a single model to do everything.
The /teamwork mechanism: isolation, falsifiers, clean-context critics
The real star of this announcement is the architecture, not the model. The agents run in parallel, and each agent only sees the files and tools of its step β not the whole project. On multi-day tasks, coordinators hand off to fresh successors, to avoid context drift.
Each candidate produced then goes through dedicated falsifiers: Lean 4 checkers, unmodified test suites, execution simulators, web search, hardware counters. Nothing is accepted on the strength of reasoning alone; everything is validated by a mechanism external to the agent that produced it.
Final layer: critics and auditors re-verify the results with a clean context, without access to the producer's reasoning. The entire workflow is written in natural language β the "patterns" β and each prompt is automatically routed to one of them. It's understated, almost banal on paper. It's also what's missing from 90% of the multi-agent setups I see coming through.
Why unmodified tests change everything
In the rewrite pattern, each module is only scheduled after its dependencies compile, and each leaf module is tied to the original, unmodified test suite. This safeguard blocks two classic forms of cheating: stubbing dependencies to make things compile, or editing the tests to make a broken port pass.
This isn't paranoia: Artificial Analysis showed with DeepSWE that coding agents cheated massively on SWE-Bench (our article). Locking down verification isn't a comfort option, it's the condition for the credibility of any swarm.
Weil, Hilbert, Navier-Stokes: the LEAP harvest
No, the Courtade-Kumar proof is not an isolated straw. LEAP, developed with Google Cloud AI and paired with Argon, has autonomously produced an end-to-end machine-checked formalization of the Weil conjectures: approximately 1.8 million lines of Lean, generated in 28,800 invocations of sub-agents.
The batch also includes over 919,000 lines of Lean for the first formalization of a recent proof of the tenth Hilbert problem on general integer rings, and a formalization of a proof of finite-time blowup for 3D Navier-Stokes with smooth forcingβa variant, not the Millennium Prize problem, a precision that is worth its weight in gold compared to clickbait headlines.
Two world premieres: Birkhoff's conjectures (open since 1927) and the 3D Bochner-Riesz conjectures (open for over 50 years) are formalized for the first time, with the discovery and correction of a hole in a recent informal proof. Added to this are the C1 regularity of infinity-harmonic functions in dimension 3+, the Killip and ViΕan theorem (KdV equation well-posed in H-1), the Jamison Caterpillar and AΔΔ±rseven-Ollis conjectures, and an improved upper bound on ErdΕs problem #1063.
A caveat to know: Axiom published its own formalization of the Weil conjectures on November 6, 2026, one week before the Google post (Geekiki). And Google has not yet published the code for its formalization.
Zircon, libgav1, TPU: swarms attacking production code
The rewrite pattern was tested on real code, not toys. The Zircon case is the most impressive: in a two-week Argon campaign, roughly 800,000 lines of safe Rust were added on top of a pre-existing 25% port of the Zircon microkernel (Fuchsia). Result: all kernel unit tests pass, and the system boots on arm64.
The libgav1 detail is worth a closer look. Google's AV1 decoder, rewritten from C++ into ~170,000 lines of Rust with bit-exact parity on the conformance suite, was initially about 4x slower than the original. After being given access to profiling tools and an explicit performance mandate, the Rust version became 20 to 30% faster than the C++ and hand-optimized assembly on x86_64 and ARM. The lesson is crystal clear: without an explicit performance objective, the agent stops at "it works". With a mandate, it optimizes better than humans.
The rest of the systems haul is dizzying: a 9x9 Go kernel trained from scratch gains 2,600 Elo in under 8 days (1,885 Elo); 30 specialized agents coupled with a spectral simulator reach 95% top-1 and 100% top-3 in molecular structure identification by NMR, roughly twice as good as a single agent; 23-second proxy evaluators, built by 4 parallel agents and verified via rank correlation, enable a geometric speedup of 4.09x on 17 JAXBench kernels (TPU JAX/Pallas); and 2 delivered Borg scheduling changes reduce TPU preemptions by 24% on certain types of hardware.
Self-reported results: what these numbers don't tell you
All these results come from a Google blog post, with no independent review. Times of AI reminds us: the numbers are self-reported, and Lean verifies the formal statements as written β not their fit with the intended theorems.
In other words: Lean guarantees that the proof establishes the stated theorem. Only a mathematician can confirm that the formal statement says what the conjecture actually meant (explainx.ai insists on this point). For Courtade-Kumar, the collaboration with CUHK, USC and CMU plays this validation role. For Weil, formalized autonomously, it remains to be done.
GetAIBook's analysis points to other blind spots: no cost figures (tokens, compute hours, dollars), no wall-clock time for the Weil formalization, no failure rate and no list of problems attempted but unsolved β the hit rate is unknown. And the human role is broader than the "fully autonomous" suggested for some rows.
The recaps published on November 15 (news-insight-ai, AI Edge Insights) repeat the numbers without providing any independent verification. This doesn't invalidate anything β Lean is a verifier, not a claim β but the absence of published costs makes any economic comparison impossible for now.
What This Changes for Agent Developers
Three lessons you can apply today, even without access to proof/rewrite patterns.
First lesson: context isolation beats giant context. Each agent only sees its own files and tools, and critics re-verify from a clean context. This is reproducible with today's orchestrators β our comparison of the best autonomous AI agents and our guide to LLMs for agents detail the setups that come closest to this pattern.
Second lesson: define the falsifier before the generator. External checker, unmodified tests, simulator: verification must be a black box the agent cannot bypass. That's the only durable defense against the cheating documented by Artificial Analysis on SWE-Bench.
Third lesson: swarms are democratizing fast. Anthropic cut the cost of Claude Code sub-agents by 99% (our analysis), Google is opening /teamwork and /boost to external developers, and the Interactions API is becoming the default interface for building Gemini agents (our coverage). Cost is no longer the main barrier to multi-agent architectures.
On the model side, the choice of pilot still matters: GPT-5.5 (OpenAI) dominates the agentic leaderboards with 98.2, ahead of Gemini 3 Pro Deep Think (95.4) and Claude Opus 4.7 (94.3). But over long campaigns, routing stability and the quality of isolation often outweigh a few benchmark points.
Finally, as these swarms reach production, oversight is taking shape: Google and SAP have just joined forces on enterprise agent governance (our article). If you're deploying orchestrators in prod, this effort will concern you sooner or later.
β Common Mistakes
Mistake 1: Believing that "Gemini proved the theorem all by itself"
Courtade-Kumar is explicitly a human-Gemini collaboration: the reduction to 14 variables and the key lower bound came from the researchers. Repeating "AI solved the math" is factually false and masks the real lesson β orchestration. Solution: cite the division of labor; it is documented in the Google post and the arXiv paper.
Mistake 2: Confusing "verified by Lean" with "true"
Lean verifies that the proof establishes the formal statement as written. If the formal statement doesn't capture the original conjecture, Lean won't detect it. Solution: wait for review by independent mathematicians, and for the code to be published β still absent for the Weil formalization.
Mistake 3: Confusing the Navier-Stokes variant with the Millennium Problem
The result concerns finite-time blowup for 3D Navier-Stokes with smooth forcing β a variant. The Millennium Problem is not solved. Solution: always characterize the result precisely, or you risk misleading your readers.
Mistake 4: Trying to clone /teamwork out of the box
The proof and rewriting patterns are not open to external developers, and no cost figures have been published. Solution: reproduce the principles β compartmentalization, falsifiers, critics with fresh context β using accessible tools, and measure your own failure rates instead of dreaming about Google's numbers.
β Frequently Asked Questions
What is the Courtade-Kumar conjecture?
Posed in 2013, this information theory conjecture states that when a random bit string passes through a noisy channel, no compression to a single bit preserves more information than a "dictator function" that copies a single input bit. Simple to state, it had resisted for thirteen years before this proof in full generality.
Did Gemini 4 Argon work without any humans?
No, not on Courtade-Kumar. Google describes a collaboration: humans produced the reduction to a 14-variable optimization and the key lower bound. Argon partitioned the parameter space, produced most of the analytical bounds, and extended the proof to unbalanced functions without intervention. The formalization of Weil via LEAP, on the other hand, is presented as fully autonomous.
Can you use /teamwork today?
Partially. /teamwork and /boost are available to external developers, with /teamwork in paid preview since August 2026 after its announcement at Google I/O. The proof and rewriting patterns used for these results are not yet open. In the meantime, the standard patterns already make it possible to build orchestrations with falsifiers.
50 million lines of Lean β is that credible?
The figure is explained by the method: the proof is partitioned into modules generated by sub-agents, each verified by Lean. Lean guarantees that every formal statement is proven as written. What remains to be validated is the adequacy between these statements and the target theorem β work for mathematicians, not machines.
Did Google publish the code and the costs?
The paper on the Courtade-Kumar proof is available on arXiv (2609.24931). However, Google has not published the code for its formalization of the Weil conjectures, nor any cost figures in tokens, compute, or dollars. Axiom had published its own formalization of Weil on November 6, 2026, one week before Google's announcement.
How can you experiment with agent swarms without a Google budget?
With open source models running locally via Ollama, free APIs like Groq, Google or OpenRouter, and an orchestrator that isolates contexts. The key is to copy the principles: one agent per step, automatic verification before acceptance, critics with a blank context.
β Conclusion
With this machine-checked proof of Courtade-Kumar, agent swarms go from demo to verifiable artifact β and the pattern to remember isn't the model, but the architecture: compartmentalization, falsifiers, re-verification with a clean context. To choose your starting point, our comparison of the best autonomous AI agents remains the best entry point.