Google Antigravity's Teamwork: Every Claim, Checked

📺 Watch the full breakdown — 12 minutes, claim by claim · 📓 The Buy-Back Playbook

On August 27, 2026, Google's Antigravity account announced that researchers at Google Research and DeepMind used Teamwork — the multi-agent orchestration layer inside Antigravity — to produce results in theoretical computer science, research mathematics, and systems engineering. The thread came with a blog post, five arXiv papers, a Lean-verified proof, and two patches merged into open-source libraries.

This page exists so there's one place that separates the checkable claims from the framing. Every figure below is labeled with where it comes from — and whether anyone outside Google has been able to verify it.

The one-paragraph version

Teamwork runs agents in a tournament: many candidate strategies generated in parallel, each paired with a falsifier agent whose only job is to break it, with survivors decomposed into subproblems and failed attempts kept in a shared "pitfall registry." Google says this system closed or advanced seven open math and TCS problems (five with arXiv papers), built a cycle-accurate RISC-V CPU simulator that boots Unix, and landed two patches in Eigen and ParlayHash that external maintainers reviewed and merged. Three of the seven math results were reproduced with Gemini 3.7 Flash — the cheap model — which Google calls a first for a Flash-tier model. Google also says, in its own blog, that Teamwork burns a lot of tokens and is overkill for everyday work.

The receipt hierarchy

Not all seven results carry the same kind of evidence. Before the scoreboard, here's the scale this page uses:

Tier	What it means
🟢 Hard receipt	Externally checkable by anyone: a paper that credits the AI in its own text, a machine-verified proof, a merged public commit
🟡 Real artifact, Google's attribution	The result is real and public, but the AI's role is only claimed in Google's blog
⬜ Google's word	Internal evals and benchmarks nobody outside Google has run

The scoreboard — seven problems

#	Problem	Claimed result	Receipt
1	Coresets for ℓp subspace approximation (FOCS 2025 open problem)	Tighter coreset sizes, ε⁻² dependence	🟡 arXiv:2608.26047 — real paper, heavyweight authors (David Woodruff, Vahab Mirrokni), but the PDF does not mention AI. The agent connection is the blog's claim.
2	Sparse convex optimization (JMLR 2021 conjecture)	Conditional lower bound on condition number for sparse least squares	🟢 arXiv:2608.02588 — the paper itself says the proof was first obtained by a fully automated Gemini agentic system, then verified and edited by the human authors.
3	Maximal inner product / Chamfer embeddings	Nearly closes a complexity gap	🟡 arXiv:2607.20393
4	Provable Hadamard quantization	Drops a second quantization stage; ~5.93× better leading constant	🟡 arXiv:2608.02564
5	Erdős unit-distance problem	Reproduced an existing breakthrough with no internet access	🟡 GitHub — a replication, not a new theorem. Impressive as a contamination test; not a discovery.
6	Prefix-matrix factorizations	Near-optimal lower bound	🟡 arXiv:2608.08238
7	Knuth's Cycles, even case	First proofs for two simpler even-integer constructions (40+ and 70+ pages)	🟢 GitHub — the 40-page proof is formally verified in Lean. A proof checker doesn't care about anyone's marketing budget.

Two things the table makes obvious:

Paper #2 is the smoking gun. It's the only paper that admits, in its own abstract, that the machine found the proof first. The authors put their names on a document saying so, then verified the proof themselves. That's a fundamentally different kind of evidence than a blog post describing a paper.

Don't confuse the Knuth results. Earlier in 2026, Claude found a construction for the odd case of this problem — people called it "Claude's Cycles." What's new here is the even case, from Teamwork. Two different models, two different halves of the problem.

How Teamwork actually works

Google's stated reason for building this: naive multi-agent setups fail on hard problems because agents agree with each other's first mistake and then build on it.

Teamwork's answer is structural, not vibes:

Generate many candidate strategies in parallel
Pair each with a falsifier whose only job is to kill it
Keep the broken routes around — a failed proof can still contain a useful idea
Decompose the surviving strategy into a dependency graph
Give each subproblem its own generate → critique → synthesize loop
Feed failed drafts and verifier findings into a shared pitfall registry, so agent #47 doesn't rediscover the trap agent #3 already fell into

Five patterns, auto-selected from your prompt:

Pattern	For
Iterative Coding	One hard, non-decomposable coding problem
Distributed Coding	Big engineering work that fans out, with critic review
Long Proof	Open math / TCS problems
Self-Verification	Deep math with check-every-step rigor
Document Review	Papers and specs

The CPU simulator

Teamwork, running Gemini 3.7 Flash, built an out-of-order RISC-V CPU simulator from scratch that:

Boots xv6 (a real Unix teaching OS) to a shell
Runs 100+ standard RISC-V benchmarks
Lands within 0.71% average cycle-alignment error on unseen workloads (⬜ Google's validation, against air-gapped Spike and BOOM references)

The hard part is what CPU engineers call the silent execution gap: the simulated processor's internal state can drift for hundreds of cycles before anything visibly breaks — the bug that crashes your boot at cycle two million actually happened thousands of cycles earlier, and nothing looked wrong in between. Google's setup ran lockstep co-simulation against a sandboxed reference oracle, arranged so the agents could check their answers but couldn't read the reference source code. A well-designed exam, and the model passed it.

The merged patches — the only referees who don't work at Google

This is quietly the strongest evidence in the whole announcement:

Eigen (the C++ linear algebra library half the numerical world sits on): the agents found a slow matrix-vector path when the matrix is a single row or column, and shipped a SIMD fast path with 4-way unrolling. Went through Eigen's real review process. 🟢 Commit 944a219 on Eigen's GitLab — go read the diff.
ParlayHash ("Swiss Parlay"): hash-table ideas borrowed from Swiss Tables. Landed upstream (🟢 the merge; ⬜ the numbers — claimed 2× insert throughput at 64 threads, 1.5× single-threaded, ~25% less memory are Google's benchmarks).

Benchmarks can be staged. Blog posts can be framed. An external maintainer merging your patch is a third party with no stake in Google's stock price saying "this code is good."

What's solid vs. what's soft

Solid

A paper that credits the agent in writing, with named, serious authors verifying the proof
A 40-page proof checked by Lean — machine verification, not peer pressure
Two patches merged by external maintainers
Google being unusually honest that this is expensive and niche

Soft — keep these caveats attached

"Breakthroughs" is Google's word. Some items are improvements on recent open questions, one is a reproduction, and one is a conditional lower bound (it depends on a complexity assumption).
Human review so far is in-house. Google experts reviewed the papers; none have been through journal or conference referees yet. These are preprints.
TCSBench is Google's own eval. The reported 71% (up from 67.7%) for Long Proof with 3.7 Flash + 3.1 Pro is internal testing, not an external leaderboard.
The public product is a cheaper cousin. /teamwork-preview on paid Antigravity plans is cost-capped; Google says some research runs used more parallelism than the public default allows. Same workflow, less firepower.

Why this matters if you're not Google

The interesting claim isn't "big model smart." It's that orchestration plus a cheap model reproduced three of the seven results — with the expensive model reserved for the hardest math. If that pattern holds, the frontier stops being "who has the biggest model" and starts being "who builds the best tournament around a cheap one."

That's directly relevant to anyone building agent systems at normal-person budgets: propose/critique loops, falsifier agents, and shared failure logs are patterns you can implement today with the tools you already have. You don't need Google's parallelism to steal the shape of the idea.

And the part nobody frames correctly: humans didn't leave this loop. Humans picked the problems, designed the falsifier tournament, verified the proofs, and accepted the answers. The agents did the middle. The middle got a lot bigger this week — but it's still the middle.

Three things worth doing this week

Ten minutes. Read the abstract of arXiv:2608.02588 — the paper that credits the agent. It's the single best receipt in the announcement, and it's free.
Ten minutes. Pull up Eigen commit 944a219 and skim the diff. This is what "AI contribution that survived real code review" looks like.
One build. Add a falsifier step to an agent workflow you already run: one agent proposes, a second agent's only instruction is to break the proposal. It's the core mechanic of Teamwork, and it costs you one extra prompt.

Sources

Primary

Papers

Code

Eigen commit 944a219 (Eigen GitLab) — GeMV single row/column fast path
ParlayHash upstream repository — "Swiss Parlay" changes