Google's AI agent teams crack decades-old math problems and rewrite a kernel in Rust

What's going on

On November 13, 2026, Google Research published a long report on new results from /teamwork, a feature in Antigravity, Google's AI-powered development environment. Instead of a single language model, /teamwork runs a whole team of AI agents: programs that handle subtasks on their own, use tools and check each other's work. The post was written by Vahab Mirrokni, a Google Fellow and VP at Google Research, and you can read it on the Google Research blog.

Over the past few weeks, teams at Google and partner universities used the new models Gemini 4 Argon, Gemini 4 Carbon and Gemini 4 Hydrogen on problems that had been open for years, some for decades. These included questions in mathematics, theoretical computer science and chemistry, plus software projects inside Google. Google stresses that all of this work was done together with human experts. The tools are open to outsiders too: Google says /teamwork, its smaller sibling /boost and the review tool Deep Review are already available in Antigravity.

Antigravity is a programming environment from Google DeepMind. A beginner's overview from Geeky Gadgets lists an "Agent Manager" for creating and managing AI agents, an AI-assisted code editor and browser testing directly in Chrome. Several agents can work in parallel on different parts of a project.

How /teamwork works

Google says the design addresses two weaknesses of today's language models. The first is that their output is unpredictable, so a single attempt rarely gets the right answer straight away. /teamwork therefore explores many approaches in parallel and runs each one through a falsifier, a tool that checks objectively whether something holds up. That might be the Lean 4 proof checker, an unmodified test suite, a simulator, a web search or a hardware counter.

The second is that models lose track during multi-day tasks, because their attention gets spread across an ever-growing context window, the amount of text a model can take in at once. /teamwork splits the context up from the start. Each specialized agent gets only the files and tools it needs for its step. Coordinators hand tasks off to "fresh" successors. Critics and verifiers judge the results without seeing the original agent's reasoning, which is meant to keep them unbiased.

The workflows are written as self-improving patterns in natural language, and /teamwork picks the right one for each prompt. There are patterns for distributed coding, long proofs and document review. /boost is a standalone solve-and-verify loop for everyday coding. Google says a long /teamwork campaign analyzed past runs and found that tightly coupled code works better when handled sequentially rather than in parallel. That finding went into improving /boost, so one system effectively optimized another.

A 36Kr report on an earlier /teamwork release from August 27 shows what this looks like in practice. The "Long Proof" mode runs as a tournament: every approach gets a "devil's advocate" whose only job is to refute it. Rejected paths are kept along with the objections, and common mistakes go into a shared "trap registry." Even back then, the small Gemini 3.7 Flash model, working as a team, reproduced three research results that Gemini 3.1 Pro had reached first. 36Kr also adds some context: on the widely discussed Knuth cycles problem, other AI models (Claude Opus 4.6, GPT-5.4 Pro) had already found the solution in the spring. Google's contribution there was more elegant constructions and formally verified proofs, not a breakthrough out of nowhere.

Results in math and computer science

The headline result is a complete proof of the 2013 Courtade–Kumar conjecture. It says that when you send a random bit string through a noisy channel, no way of compressing the input down to a single bit preserves more information than a "dictator function," which simply copies one input bit. Gemini first found counterexamples to a generalized conjecture from the CUHK team. The researchers then reduced the problem to an optimization over 14 variables. Gemini 4 Argon and earlier Gemini models supplied most of the new bounds and certificates using interval arithmetic, a method that rigorously bounds rounding errors. Google says the extension to unbalanced functions happened with no human input. The full proof was formalized in Lean 4, a programming language in which a computer checks every proof step line by line. The result runs to 50 million lines of code.

Other results, according to Google:

• Adaptive data analysis: near-optimal bounds for statistical queries that react to earlier answers, closing a gap open since 2014.
• Quantum computing: the first n-bit Boolean functions that need more than n/2 quantum queries (open since 2014).
• Boolean matrix multiplication: a deterministic algorithm that answers the central open question from STOC 2024.
• Integer multiplication: a new O(n log n) algorithm whose C implementation matches the GMP library bit for bit up to one billion bits.
• Tarjan's deque conjecture from 1985: a new upper bound for splay trees (self-adjusting search trees), verified in Lean 4.
• Plus results on sparse networks, matrix compression, streaming algorithms for graphs, online optimization and cross-validation in statistics.

Google says the authors checked, simplified and revised the proofs the system produced before publication.

Machine-checked mega-proofs

The agent system LEAP, built with Google Cloud AI, translates existing proofs written informally by humans into Lean. Google says it formalized the Weil conjectures completely on its own. Pierre Deligne finished proving them in 1974. The formalization comes to about 1.8 million lines of Lean from 28,800 sub-agent calls. There's more:

One thing to keep in mind: in most of these cases, the AI made proofs found by humans machine-checkable. It didn't solve the problems itself. Google argues that a formalization rules out hidden errors, as long as humans have confirmed that the formal statement matches the original problem.

Ahead of the STOC 2027 conference, Google also offered Deep Review, a tool that checks manuscripts for errors. Authors of 578 submissions used it, more than a third of all submissions. In an ongoing survey of 70 participants, 90 percent said the feedback was mostly accurate. More than 30 percent said it caught real errors in their proofs. You get two free Deep Review runs per week.

Chemistry, benchmarks and software

In chemistry, 30 agents used a physics-based spectrum simulator to work out molecular structures from nuclear magnetic resonance (NMR) data. They got the exact structure on the first guess 95 percent of the time and within the top three 100 percent of the time, almost twice as good as a single agent. Separately, 29 agents spent 11.5 hours building a 50-task causal inference benchmark from 13 public datasets.

The software numbers stand out the most. A new rewrite pattern, coming to Antigravity soon, schedules each module only once its dependencies compile and checks it against the original, unmodified test suite. The point is to stop agents from gaming the tests. This approach produced about 800,000 lines of safe Rust for the Zircon microkernel in two weeks. The code passes all kernel unit tests and boots on arm64 hardware. The AV1 decoder libgav1 was rewritten in about 170,000 lines of Rust, with 100 percent bit-exact output. At first the Rust version was about four times slower. Once the agents got profiling tools, which measure where compute time goes, it ended up 20 to 30 percent faster than the C++ original and its hand-optimized assembly.

More examples: a Go engine for the 9x9 board gained about 2,600 Elo points in under eight days and reached 1,885 Elo. When optimizing TPU kernels, the compute routines for Google's AI chips, the DuoDiscover pattern delivered an average 4.09x speedup across 17 kernels. Internally, /teamwork found more than 1 PiB of memory savings in Google's data centers. In Borg, Google's cluster management system, it cut TPU job interruptions by 24 percent on some hardware types.

Availability

Google says Gemini 4 with /teamwork, /boost and Deep Review is available in Antigravity now. According to 36Kr, you start the mode with the /teamwork-preview command. Google has opened applications for 10,000 researchers to get six months of free access to the highest usage tier. The formal proof pattern and other specialized workflows are due in the coming weeks, along with detailed tutorials. The post doesn't give pricing for regular use.

Our take

The results are broad and impressive, but much of this comes from Google itself. The math results are slated to appear as papers, and many haven't been peer reviewed yet. Lean formalizations make a strong case, because the computer checks every step. That only holds, though, if the formal statement really matches the problem. For formalizations like the Weil conjectures or Navier–Stokes, the AI rebuilt known proofs rather than finding new ones. And as 36Kr notes, the Knuth problem shows that "solved" sometimes means "re-proved more elegantly."

The real story is about method. The progress here comes less from a bigger model than from how the work is organized: many agents with separate contexts, strict automated verifiers and independent critics working together. OpenAI and Anthropic are pursuing similar approaches. Google, however, is putting these tools straight into a product the public can use. Some questions remain open: how much compute these multi-day campaigns burn, what they'll cost outside users, and how well they work without Google's in-house experts.