I have been building websites with WordPress and Elementor for years, and I have watched AI coding tools go from a fun autocomplete trick to something that genuinely changes how I work. But every few months, something lands that makes me stop and rethink what “AI can do” actually means. Google Research’s new report on Antigravity’s /teamwork is one of those moments.
On November 13, Google Research published “Advancing science & engineering with Antigravity’s /teamwork.” Teams of AI agents, running inside Google’s Antigravity coding environment and powered by Gemini 4, helped prove a mathematics conjecture open since 2013 — and produced a machine-checked formal proof spanning 50 million lines.
I read the full report, and then the independent coverage around it, because claims this big deserve a second look. Here is what actually happened, what it means for people like us who build things for a living, and how you can try the tools yourself.
What Is Antigravity’s /teamwork, Exactly?
Google Antigravity is Google’s agent-first development environment — a desktop app, a command-line tool, and IDE extensions where AI agents do the coding while you direct them. If you have used Claude Code, Cursor, or GitHub Copilot’s agent mode, you know the shape of it.
/teamwork is the multi-agent mode inside Antigravity. Instead of one agent doing everything, it splits a hard problem across a team of specialist agents with separate roles. Producers draft candidate solutions, critics look for flaws, and auditors check the result from a clean context, without being influenced by the reasoning that produced it. Before anything is accepted, verifier agents backed by objective checkers — the Lean 4 proof checker, unmodified software test suites, execution simulators, or hardware counters — verify which candidates actually work.
That last part is the key idea. A single AI model guessing an answer is unreliable. A team of agents where every claim has to survive an independent, mechanical check is a different machine entirely. Google’s framing is “try many, check every one.” The agents explore in parallel, the checkers decide what is true, and the critics make sure nobody fools themselves.
/teamwork builds on the Gemini 4 family — Argon, Carbon, and Hydrogen. Carbon is the heavy reasoner, recommended for the coordinator and the hardest thinking. Hydrogen is the fast, cheap execution engine. Argon sits in the middle and, according to Google, remains the ideal choice for most advanced engineering work. There is also /boost, a related mode for parallel work. The point is the same: the right model for each job, instead of one model doing everything.
The Headline Result: A 13-Year-Old Conjecture, Proved and Machine-Checked
The result that got everyone talking is the Courtade–Kumar conjecture, an information theory problem posed in 2013. Researchers from Google, CUHK, USC, and Carnegie Mellon used /teamwork’s “Long Proof” pattern to prove it, and extended the proof from balanced to unbalanced functions without human input.
Then they did the part that matters most to mathematicians: they formalized the entire proof in Lean 4, a language for writing mathematical proofs that a computer kernel can verify step by step. If the Lean kernel accepts the proof, every inference, inequality, and case split has been mechanically checked. There is no “trust me” in a Lean proof. It either compiles or it does not.
Google puts that formalisation at 50 million lines of code. I want to be honest with you, because the number needs context. An independent check confirmed the 50 million lines are real, but only about 239,000 of them are proof a person could actually read — the rest is generated certificate data that the Lean kernel checks mechanically. The audit trail is strong, with a clean rebuild and acceptance by the Lean Foundation’s external checker, but the headline number is mostly machine-generated verification data.
Still, step back and look at what happened: a problem open for thirteen years now has a complete, machine-verified proof, produced by agents working with human researchers. That is genuinely new.
The Weil Conjectures and 28,800 Subagents
The report goes further. Google says a framework called /teamwork-LEAP, paired with Gemini 4 Argon, “fully autonomously produced an end-to-end, machine-checked formalization of the Weil conjectures” — one of the most famous results in twentieth-century mathematics. The formalisation spans about 1.8 million lines of Lean, produced across 28,800 subagent invocations.
Here I have to add a caveat. As of the reporting I read, Google’s post links to Wikipedia pages for the Weil conjectures and Deligne, with no public repository, no paper, and no statement file — so the claim cannot yet be independently checked. The Courtade–Kumar formalisation is public, audited, and machine-verified. The Weil claim is not yet in that category. It may well be real, but until the code is public, treat it as Google’s claim rather than a verified result.
Even with that caveat, the pattern is what matters. The same architecture — parallel exploration plus objective verification — is doing mathematics, and the results are getting harder to dismiss.
The Part Developers Should Actually Care About: The Rust Rewrites
For most of us, the math is impressive but abstract. The systems engineering results are the ones that hit home, because they are about the kind of code we actually ship.
Google used /teamwork to rewrite libgav1, its production AV1 video decoder, from C++ into around 170,000 lines of Rust. The result runs 20 to 30 percent faster than the highly tuned C++ original, with 100 percent bit-exact parity across a broad conformance test suite. Let that sink in. An agent team rewrote a production video decoder in a memory-safe language and made it faster. A few years ago, “rewrite it in Rust” was a joke and a multi-year project. Now it is a two-week campaign.
The same pattern was applied to the Zircon microkernel. Building on an initial 25 percent port, a two-week Argon campaign rewrote the remaining C++ code, adding about 800,000 lines of safe Rust that pass all kernel unit tests and boot on arm64 hardware.
There is more. Using /teamwork and Argon, Google built FarArray, a low-latency kernel-bypass Partitioned Global Address Space based on the SNAP microkernel, and created custom TPU kernels for Graph Neural Networks, delivering up to a 185x reduction in High Bandwidth Memory usage and 8x to 15x speedups.
The rewrite pattern itself is a recipe any team can learn from: each module is scheduled only after its dependencies compile, every leaf module is linked against the original, unmodified test suite, and nothing is accepted until the tests pass.
It Is Not Just Code: Chemistry and Drug Discovery
The report also covers work outside software. In medicinal chemistry, it reportedly achieved 95 percent top-1 accuracy in identifying molecular structures, and one demo produced a lung cancer drug synthesis in about an hour. I have less first-hand feel for chemistry than for code, so I will not overstate this — but the shape is identical: agents propose candidates, objective validators check them, and the loop runs until something real comes out.
That is the thread running through the whole report. /teamwork is not a better autocomplete. It is a way of turning hard problems into a search over candidates, with a mechanical judge deciding what survives. Mathematics has the Lean kernel. Code has test suites. Chemistry has synthesis validators. Give the system a real checker, and the agents can do real work.
How This Changes My Day Job (and Probably Yours)
So what does any of this mean for someone who builds WordPress sites and client projects? More than the math headlines suggest.
First, the multi-agent pattern is coming to our tools fast. Antigravity already has /teamwork, /boost, and /swarm. Claude Code has subagents, Cursor has multi-agent workflows. The single-agent assistant is becoming a team. I have started structuring my own prompts that way — one agent to build, one to review, one to test — and the results are noticeably better.
Second, the “rewrite it in Rust” story previews what happens to legacy code. Every freelancer I know has old plugins and themes nobody wants to touch. If agent teams can port a microkernel to safe Rust in two weeks, the economics of modernizing old WordPress plugins or migrating jQuery spaghetti to modern JavaScript are about to change. The constraint will not be the writing — it will be the tests.
Third, verification is the skill that matters now. The agents in /teamwork are only as good as the checkers behind them, and the same is true for us. A developer who can write a sharp test suite, define acceptance criteria, and spot a bad merge is more valuable than ever. I now treat test-writing as the core skill in my AI workflow: when I ask an agent to build a feature, I write the tests first.
How to Get Access
Google says external scientists and developers can use Gemini 4 models with /teamwork and /boost in Antigravity and Deep Review today. The tools are available to paid users now, on Google AI Pro and Ultra plans, in the app and the CLI. On top of that, Google has opened applications giving 10,000 academic researchers six months of free access to its highest usage tier. If you are at a university or work with researchers, that is worth applying for.
Google warns, fairly, that a multi-agent session burns quota much faster than a single conversation — you are running several models at once. Start with a small, well-defined job and a good test suite before you hand it a big migration.
My Honest Take
I am excited about this, and I am also cautious, and I think both reactions are correct. The Courtade–Kumar proof is real and machine-verified. The libgav1 rewrite is real and faster. The Zircon port boots. Those are facts, not marketing. The Weil conjectures claim needs public code before I will treat it as settled. The 50-million-line number is real but mostly certificate data. And none of this replaces the developer — it replaces the typing, the boilerplate, and the first draft.
What it does not replace is the person who decides what to build, what “correct” means, and whether the result is worth shipping. That is still us.
Conclusion
Google’s Antigravity /teamwork is the clearest sign yet that AI coding has moved from single assistants to teams of agents with independent verification. A 13-year-old conjecture now has a machine-checked proof. A production video decoder runs 20 to 30 percent faster in safe Rust. A microkernel boots after an agent-led port. The tools are available to developers today. The developers who benefit most will not be the ones who type the fastest — they will be the ones who write the best tests and define the clearest goals.
Frequently Asked Questions
What is Google Antigravity /teamwork?
/teamwork is a multi-agent mode inside Google Antigravity, Google’s agent-first development environment. It splits a hard problem across specialist agents — producers that draft solutions, critics that find flaws, and auditors that verify from a clean context — with objective checkers like the Lean 4 proof checker or software test suites deciding which results are accepted.
How did /teamwork improve real Google software?
Agent teams rewrote Google’s libgav1 AV1 video decoder from C++ into about 170,000 lines of Rust that runs 20 to 30 percent faster with full bit-exact parity, and ported the remaining Zircon microkernel code into about 800,000 lines of safe Rust that boots on arm64.
Can developers use /teamwork today?
Yes. Google says Gemini 4 models with /teamwork and /boost are available in Antigravity and Deep Review for paid users today, on Google AI Pro and Ultra plans. Google has also opened applications for 10,000 academic researchers to receive six months of free access to its highest usage tier.
How is /teamwork different from /swarm in Antigravity?
/teamwork is the multi-agent research and engineering workflow Google highlighted in its November 13 research report, focused on long-horizon problems with dedicated verifiers. /swarm is a related preview command that turns one prompt into a coordinated team — a coordinator, named workers, and a verifier — on a shared message board. Both use the same idea: parallel agents plus independent checking.
