Antigravity might not be getting as much attention as some other harnesses, but it’s coming up with some impressive results all the same.
Google has put out a rundown of what its multi-agent framework Teamwork, running inside Antigravity, managed to do when paired with the recently released Gemini 3.7 Flash model. The list includes seven previously unsolved problems in math and theoretical computer science, a working CPU simulator built from scratch, and code changes that are now merged into libraries used across the industry.
The headline result is Knuth’s Cycles Conjecture, a problem that has sat unresolved in combinatorics for decades. Teamwork produced proofs for two simpler constructions of the conjecture’s even integer case, running to more than 40 and 70 pages respectively, and the shorter one was formally verified using Lean, a proof assistant that checks mathematical arguments line by line rather than taking a human reviewer’s word for it.
What Teamwork actually is
Teamwork is Google’s name for a setup where multiple AI agents work on the same problem at once, but instead of just running in parallel, they critique each other. One agent proposes an approach, another tries to find the hole in it, and a third combines the surviving pieces into something stronger. Google says this cycle can run for hours or even days without a human in the loop, with people only stepping back in to set the goal and sign off on the final answer.
The company built several different “patterns” for this kind of teamwork, each suited to a different type of problem. One is tuned for coding tasks that can be broken into independent chunks and farmed out to separate agents. Another, called Long Proof, is built for open-ended math and computer science research, where an agent has to pick a strategy long before it knows whether that strategy will actually work. A third pattern, called Self-Verification, has a single line of reasoning check and re-check itself at every step, similar to how the Aletheia system Google mentioned earlier this year was used for autonomous math research.
The Long Proof pattern is where most of the math results came from. Rather than just writing out a proof attempt and hoping it holds up, the system generates several candidate strategies in parallel, assigns each one a dedicated critic whose only job is to try to break it, and then merges whatever survives into a more refined attempt. Google says even strategies that get shot down stay in the system, because a wrong approach can still contain a useful idea for the next round.
The seven math and computer science problems
Beyond Knuth’s Cycles Conjecture, the other six results touch some fairly technical corners of theoretical computer science, but the practical upshot is easier to follow.
One result improves the bounds on how much data you need to approximate a large dataset in reduced form — relevant to problems from FOCS, one of the top conferences in the field. Another establishes a lower bound on how badly certain optimization problems can behave, addressing a question that had been open since a JMLR paper in 2021. A third nearly closes the gap on how efficiently you can compare vector embeddings, which is directly relevant to how search and recommendation systems work under the hood. A fourth improves quantization, the technique used to shrink AI models so they run faster and cheaper, by removing an entire processing stage and cutting a key constant by close to six times.
There’s also a result on the Erdős Unit Distance Problem, an old and well-known geometry question, where Teamwork rediscovered a recent breakthrough on its own, without internet access, and a near-optimal lower bound on a data structure problem called prefix-matrix factorization.
Google says five of these seven results already have papers up on arXiv, and all but the Knuth proof were checked by human experts rather than machines. Most of the results came from Gemini 3.1 Pro, but three of the seven were reproduced using Gemini 3.7 Flash, which Google is calling the first time a Flash-tier model — its cheaper, faster line of models — has produced research at this level with the right orchestration around it. On TCSBench, an internal benchmark of hard theoretical computer science problems, the Flash and Pro combination scored 71%, its best result yet on that test.
A CPU simulator that boots an actual operating system
The systems engineering example is a different kind of test. Teamwork built a cycle-accurate simulator of an out-of-order RISC-V processor, essentially a piece of software that mimics how a real chip executes instructions, cycle by cycle, including the complicated bits like reordering instructions on the fly to keep the processor busy. It’s the kind of project that normally takes a dedicated hardware team a long stretch of time to get right, because a single wrong assumption about timing can throw off the whole simulation without triggering an obvious error.
Google says the finished simulator successfully boots xv6, a small teaching operating system, all the way to a working shell prompt, and ran more than 100 standard RISC-V benchmarks. When measured against real hardware timing data, its cycle counts were off by only 0.71%. To stop the agents from cheating by peeking at the reference simulator’s source code, Google kept that reference system sealed off and only let Teamwork compare its own results against its output.
Code changes that actually shipped
The last piece is less flashy but arguably the most concrete, since it isn’t measured against a benchmark at all. Teamwork went looking for slow spots in Eigen, a widely used linear algebra library, and found an inefficient code path for a specific kind of matrix-vector multiplication. It wrote a faster version using direct memory access and hardware-level parallel instructions, and that change has now been merged into Eigen’s actual codebase after going through the normal external review process, with some help from an earlier Gemini model.
A second contribution went into ParlayHash, a concurrent hash table used in high-performance computing. Teamwork helped design an optimization Google calls Swiss Parlay, which roughly doubled insertion speed when using 64 threads at once and cut memory use per entry by about a quarter, while keeping performance close to the fastest sequential alternative available. That change has also landed in the upstream library.
Google is careful to frame all of this as results confirmed and accepted by outside maintainers and reviewers, not just numbers Teamwork generated for itself. Whether that holds up as more researchers put the underlying papers and code changes under scrutiny is the part worth watching. Teamwork is currently available as a preview command inside Antigravity on paid plans, and Google says it plans to keep expanding the patterns available over the coming weeks.