Google pitted AIs against each other for several days, and the small model surprisingly reproduced three doctoral-level challenging problems.

If you don't look at the name, you would definitely think this is another top-tier model so powerful that it cannot be publicly released, with a set of "cheat-enabled" achievements:

For scientific research: It solved 7 top-tier mathematics and computer science problems in one go, and the 40-page long proof it submitted had no flaws even the strictest machine review could spot;

For engineering: It wrote an extremely realistic CPU simulator from scratch, which not only successfully booted the system, but also achieved a running error of only 0.71%;

For coding: It conveniently optimized the core code of two mainstream open source libraries, Eigen and ParlayHash, and the changes were directly merged by upstream maintainers.

This is a report card newly released by Google's Antigravity team on August 27.

In the long technical article on Teamwork, Google's Antigravity team publicly released three categories of achievements in mathematics, systems and open source.

Surprisingly, the heavy lifter this time is not some computationally power-hungry monster, but a small model focused on "speed and low cost": Gemini 3.7 Flash.

Google's official side even set the tone: This is the first time a Flash-level model has produced doctoral-level mathematical research results.

Why can a low-cost model punch above its weight class?

The secret does not lie in the parameters, but in a multi-agent orchestration framework called Teamwork.

The signal Google really wants to convey to the industry is: It's not that Flash suddenly got smarter, but that the way the work is organized has changed.

Pro Leads the Exploration

Flash Successfully Reproduces the Results

Who is the protagonist of this report card? Google's long technical article gives a very rigorous definition:

All 7 results in mathematics and theoretical computer science were initially achieved by Gemini 3.1 Pro under the long proof mode of Teamwork.

But the amazing part is that 3 of these hardcore results were fully reproduced by Gemini 3.7 Flash.

These 3 are by no means marginal problems used to pad the numbers: coreset construction for ℓp subspace approximation, dimension lower bound for maximum inner product embedding, and Hadamard quantization that directly reduces the leading constant by about 5.93 times.

Each of them is a legitimate open problem in the academic circle.

The remaining 4 results were led solely by 3.1 Pro, including the condition number lower bound for sparse convex optimization, the near-optimal lower bound for prefix matrix factorization, the Knuth's Cycles problem, and the Erdős unit distance problem independently reproduced under offline conditions.

Moreover, the 71% highest score on the TCSBench benchmark that refreshed Google's internal record was also achieved by the strong collaboration between 3.7 Flash and 3.1 Pro, directly surpassing the 67.7% record set by the previous generation 3.6 Flash paired with 3.1 Pro.

Among them, the signal that really deserves our attention is:

As long as the orchestration framework is properly set up, lightweight small models like Flash can fully re-run and reproduce the research results produced by flagship models.

This is enough to refresh the cognitive boundary of "what small models can do".

Teamwork Turns "Fault-Finding" Into a Hardcore System

Teamwork is a multi-agent orchestration framework developed by the Antigravity team.

You only need to type /teamwork-preview, and Gemini will read the prompt, select the appropriate mode on its own, immediately gather to form an "AI expert group", and run for hours or even days.

All the mathematical achievements mentioned earlier come from its Long Proof mode.

Its design idea is extremely counterintuitive: instead of stacking parameters, it lets a group of Flash models gather together to "find faults, argue, and point out weaknesses" for each other.

So how exactly do these AIs hold their meetings? The process can be broken down into four steps:

Step 1: The fiercely competitive "Competitive Strategy Search".

The system will incubate a large number of candidate solutions at the same time, and assign a dedicated "devil's advocate" to each solution, whose only KPI is to refute that solution.

Interestingly, solutions that have been torn apart by criticism are never directly thrown into the recycle bin, but stay in the process with all the opposing opinions attached.

After all, an unworkable "wrong path" often hides a life-saving inspiration.

Step 2: Follow the map to find the target, "Precise Decomposition".

Once a reliable strategy is selected, the system will split it into a bunch of sub-problems with dependencies, and draw a strict topological diagram. Independent sub-problems that can be processed in parallel are pushed forward separately, and those with sequential dependencies will queue up in order.

Step 3: The fiercely competitive "Internal Tournament".

Each sub-problem will start a knockout round on its own. The nodes read the candidate solutions while looking at the sharp criticisms, and jointly polish out an upgraded version.

If the integrated result fails, it will re-run with all accumulated opposing opinions until all loopholes are patched up.

Step 4: The "Cross-Round Learning" that learns from past mistakes.

The failed drafts are kept intact for the next round, and every big pitfall the verifier has stepped on is precipitated into the "Trap Register".

All the dead ends that have been traversed and the conclusions that have been proven are synchronized in real time to the shared knowledge base for all members to call at any time.

The tournament network in Long Proof mode: Each candidate strategy is equipped with a falsifier, and the rejected routes stay in the process with opposing opinions attached.

After this whole process, it is not so much a cold super brain, but rather a reproduction of an extremely cruel academic group meeting where no one can muddle through.

Here, every solution has to be torn apart in several rounds first, and only the hard bones that cannot be torn apart can pass smoothly.

This directly cures the mass hysteria that traditional multi-agent systems are most prone to:

In the past, if one AI accidentally led the rhythm astray, other AIs would blindly act as "echo chambers", and finally build higher and higher on the wrong foundation.

Teamwork's unique trick is nothing more than turning "mutual fault-finding" into a solid hardcore system that no one can avoid.

The Truth Behind the Knuth's Cycles Problem

Among these 7 achievements, the most eye-catching and most easily misinterpreted one is none other than the Knuth's Cycles problem proposed by Donald Knuth.

In fact, this problem was already solved by the relay of AIs back in this spring.

Donald Knuth, 2023 Stanford Christmas Lecture.

At the end of February this year, Claude Opus 4.6 only took about an hour to quickly give the construction for the odd case, forcing Donald Knuth to write two consecutive "Shock!" at the beginning of his paper.

Immediately after that, models including gpt-5.3-codex and GPT-5.4 Pro took over the relay, and completed the most difficult even case.

By mid-April, Donald Knuth clearly stated in the revised version of his paper that the even case was completely settled.

So what did Google do this time?

Simply put, Google found two more elegant and simpler new constructions for the even case, and conveniently produced the first two long proofs of more than 40 pages and more than 70 pages respectively.

The 40+ page hardcore proof has even passed Lean formal verification, with no flaws that the machine can spot at all.

This is of course a very solid academic contribution, but its real significance lies in "providing a more elegant proof", rather than making a real breakthrough from scratch.

This instead shows where Teamwork's true strength lies:

It does not make up for the "island intelligence" of a single model, but through institutionalized game and orchestration, completely solves the collaboration shortcoming of multi-agent systems that are scattered and echo each other, and releases "collective intelligence".

From Theorems to Shell

This Time It's Really Flash That Did the Job

With the same fault-finding mechanism, Google changed the mode and directly used it to tackle hardcore engineering problems.

This time the long technical article clearly states "using Gemini 3.7 Flash". Teamwork built a cycle-level, out-of-order execution RISC-V CPU simulator from scratch.

Out-of-order execution is the standard configuration of modern high-performance CPUs, and it is also the part that is most prone to bugs when writing a simulator.

Teamwork took two steps: first ensure the correctness of the microarchitecture function, write the out-of-order pipeline and reorder buffer on its own, and successfully boot the xv6 operating system to Shell; then align the timing cycle by cycle.

The process of the RISC-V simulator built by Teamwork booting the xv6 kernel and entering Shell.

The most difficult hurdle is what Google calls the "Silent Execution Gap".

The microarchitecture state of the simulator may deviate quietly over hundreds of cycles, and by the time the architecture layer reports an error, the root cause can no longer be found.

Teamwork's solution is to sandbox and isolate the reference simulator Spike to prevent agents from cheating and plagiarizing, then perform lockstep co-simulation throughout the whole process, and check the accounts at every step.

In the end, this simulator ran more than 100 RISC-V standard benchmarks, and on unseen test loads, the average cycle error with BOOM hardware was only 0.71%.

Google disclosed: Cycle alignment comparison between the Teamwork simulator and BOOM hardware, with an average error of 0.71% on unseen test loads.

However, it needs to be made clear that this is a software-level simulator, not an RTL chip design, let alone a taped-out manufactured chip.

Real-World Open Source Practice

The Second Half of AI Scientific Research Depends on Implementation and Acceptance

Compared with the mathematics achievements and the simulator, the last category of achievements looks the most unremarkable, but the evidence is the most hardcore.

Eigen is a high-performance linear algebra library that is extremely widely used in the C++ ecosystem.

Teamwork spotted a suboptimal implementation of single-row or single-column matrix-vector multiplication in it, and directly wrote a SIMD fast path for it.

As for the concurrent hash table ParlayHash, Teamwork introduced the optimization idea of Swiss Table, which directly doubled the initial insertion throughput for 64 threads, increased the overall single-thread throughput by 1.5 times, and at the same time reduced the memory usage per element by 25%.

These two changes are by no means self-indulgent benchmark scores made behind closed doors. They are real pieces of code that have gone through strict open source code review and have been officially merged into the upstream branch by external human maintainers.

What is more noteworthy than the benchmark scores is a statement by the author at the end of a mathematical paper: The proof was first made by Google's internal Gemini agent system, and then verified and edited by the author.

Agents are responsible for frantically exploring on endless drafts, while humans are responsible for signing off and final acceptance. This is the most realistic division of labor in current AI scientific research.

Google itself made it very clear: These problems would originally take top experts months to solve, and what Teamwork compresses is the trial and error cycle, while the steering wheel and the final signing right are still in human hands.

In the second half of AI scientific research, the competition is no longer about who has a model with larger parameters, but about who has a better organized AI team.

The cheaper the model is, the more it looks like a daily commodity that can be used whenever needed, the more valuable human acceptance and quality control will be.

In the past, humans were the ones solving problems. Now, humans are the ones setting problems and performing acceptance checks.

Donald Knuth handwrote the proof for the construction found by Claude, and later learned that someone had verified it with Lean. He said "this is really a good thing" because he "has been making mistakes more and more easily recently".

Even the proof of the 88-year-old Turing Award winner has to pass the verifier, and proofs written by AIs are no exception.

Machines will do more and more problem-solving work. Someone must stand guard at the acceptance checkpoint.

References: