Teamwork: When AI Becomes a Research Partner

Antigravity’s Teamwork multi-agent framework is powering breakthroughs in mathematics, hardware simulation, open source optimization, and beyond. Learn how Teamwork can tackle challenging, open-ended problems.

Today, we’re announcing several updates to Teamwork, a multi-agent orchestration framework in Antigravity that we first announced at Google I/O. In Teamwork, agents propose, critique, and refine each other’s work autonomously over hours or days. These capabilities build on the launch of Gemini 3.7 Flash, our most intelligent model yet.

Gemini 3.7 Flash delivers the speed and cost efficiency needed for everyday developer tasks, but pairing it with Teamwork’s frontier orchestration unlocks strong performance on complex, long-horizon problems across research and software engineering.

In this post, we share some of the latest updates to Teamwork in Antigravity and notable results achieved using Gemini models with Teamwork across domains where the goal was to maximize intelligence:

• Research Mathematics & Theoretical Computer Science: Seven open problems solved — including sparse convex optimization (JMLR), subspace approximation (FOCS), provable LLM quantization, vector embeddings, Prefix-Matrix Factorizations, and Knuth’s Cycles Conjecture (verified in Lean) — alongside 71% on TCSBench (the highest score in our internal testing).
• Systems Engineering: A cycle-accurate RISC-V CPU simulator that boots an operating system from scratch.
• Open-Source Software: Performance optimizations contributed and merged directly into upstream libraries, including Eigen and ParlayHash.

---

What is Teamwork?

At first glance, multi-agent setups can seem interchangeable. For routine tasks, basic multi-agent approaches are often enough — but on hard research and engineering problems, multi-agent systems frequently encounter orchestration issues. Loosely organized agents quickly go off track, agreeing with other agents’ early mistakes and building confidently on flawed ideas.

Many research and engineering problems share a common structure: generate candidates, stress-test them, and combine the best ideas into a stronger candidate. Teamwork makes this loop concrete and configurable, automating the iteration while keeping humans in charge of objectives and final acceptance. The feature is built for problems that are too large, too uncertain, or too open-ended for a single agent loop. Available today as /teamwork-preview in Antigravity on all paid plans, Teamwork organizes agents into teams that actively challenge each other’s work, look for flaws before building further, and combine the strongest pieces into working solutions — autonomously, over hours or days.

One framework, many patterns

Teamwork is not a monolithic agent team. Different challenges demand different team structures, and we call each distinct configuration a pattern—a blueprint defining which agents participate, what roles they serve, and the criteria required for work to move forward.

When you invoke /teamwork-preview, Gemini analyzes your prompt and automatically selects the appropriate pattern. The examples below showcase results from several of these patterns, with a deeper look at the Long Proof pattern.

The adaptability of Teamwork’s patterns relies on a fundamental separation: orchestration logic is decoupled from agent descriptions. A pattern is a specification rather than an executable program. It contains no orchestration code of its own; instead, the framework reads the pattern and spins up the right agents automatically based on the task. As a result, specialized mechanisms—such as an adversarial critique loop—can be ported across entirely different domains without modification.

Critically, patterns are adaptive at runtime. The framework dynamically decides how many agents to spawn based on task requirements, not a preset number. Agent count and team structure can shift mid-run as the problem reveals itself — making each campaign a living process, not a fixed pipeline.

Today, Teamwork ships specialized patterns, selected automatically based on your task, each tuned to a different class of problem:

• Iterative Coding for non-decomposable problems solved through tight agent–test–refine loops;
• Distributed Coding for decomposable engineering tasks that fan out across parallel workers with critic review;
• Long Proof for open-ended mathematics and theoretical computer science, where each candidate is stress-tested before it can advance;
• Self-Verification for depth-first mathematical reasoning with rigorous self-checking at every step;
• Document Review for structured analysis and critique of papers and technical documents.

For example, here’s how the Distributed coding pattern operates:

While the diagram shows the core roles involved, the actual execution is dynamic — the orchestrator decides how many agents to deploy and how many rounds to run based on the problem at hand.

---

Mathematics & Computer Science

Solving open problems in mathematics and computer science

Beyond coding and ML tasks, we built two patterns for long-horizon PhD-level math and computer science research: Long Proof for open-ended problem solving through competitive strategy search, and Self-Verification for depth-first reasoning with rigorous self-checking at every step. Expanding on our previous work, the Long Proof pattern was originally developed as a standalone research harness and subsequently ported to the Teamwork framework.

How the Long Proof pattern works

Long Proof devotes substantial effort to strategy selection, not just proof writing. For open problems, many promising approaches eventually fail — and the flaw stays invisible until deep into the attempt. The core design principles:

• Competitive Strategy Search. Many candidate strategies are generated in parallel, each paired with a falsifier whose sole job is to break it. A synthesis tree then combines the candidates and their reports. Refuted routes remain in the process with their objections attached — a broken route may still contain a useful idea.
• Decomposition makes long proofs tractable. The selected strategy is expanded into a proof plan whose subproblems have clear goals and explicit dependencies. The resulting dependency graph allows independent subproblems to run in parallel, while dependent ones follow topological order.
• Each subproblem has its own tournament network. Within the synthesis tree, each node reads a sample of candidates together with their critiques and produces an improved solution. If the synthesized solution fails, the network reruns with the accumulated objections.
• It learns across rounds. Failed drafts remain available to the next attempt, while verifier findings are distilled into an answer-agnostic pitfall registry. A shared knowledge directory records proved results, useful observations, failed approaches, and relevant references for later use.

Results from Teamwork’s Long Proof pattern

Using the long proof pattern — which significantly strengthens and generalizes the reasoning workflow used in our earlier work — we have addressed several open problems in theoretical computer science, including questions from top venues such as FOCS and JMLR, as well as for practical problems such as quantization and vector embeddings. Below, we present seven notable results, which have been reviewed and confirmed correct by human experts with the exception of the Knuth’s Cycles result — where the 40-page proof was formally verified in Lean. Five of the resulting papers are available on arXiv. While these results are obtained using Gemini 3.1 Pro, three of them (Problems 1, 3, 4) are reproduced with Gemini 3.7 Flash — the first time a Flash-tier model has produced such PhD-level mathematical research with the right orchestration framework. Some of these results used higher parallelism than the default. The version available on Antigravity balances cost and capability, while still supporting the same workflow.

Problem	Result	Problem and Solution Links
1. Coresets for Lp Subspace Approximation	Improved coreset construction bounds for ℓp subspace approximation for p>2	Open problem: FOCS 2025 Solution: arXiv:2608.26047
2. Sparse Convex Optimization	Established a conditional lower bound on condition number for sparse least-squares objectives	Open problem: JMLR 2021 Solution: arXiv:2608.02588
3. Maximal Inner Product Embeddings	Nearly closes the gap in complexity for Chamfer similarity for single and multi-vector embeddings	Open problem: Jayaram 2026 Solution: arXiv:2607.20393
4. Provable Hadamard Quantization	Eliminated the second quantization stage, reducing the leading constant by ~5.93×	Open problem: Feng et al. 2026 Solution: arXiv:2608.02564
5. Erdős Unit Distance Problem	Independently reproduced the initial breakthrough on the unit-distance exponent	Solution: GitHub Rediscovered a solution to the problem with no internet access
6. Prefix-Matrix Factorizations	Near-optimal lower bound for prefix-matrix factorizations	Open problem: Bulanek et al. 2026 Solution: arXiv:2608.08238
7. Knuth’s Cycles Conjecture	First proofs for two simpler constructions of the even integer case (40+ & 70+ page proofs).	Solution: GitHub

Theoretical computer science benchmark with 3.7 Flash and Teamwork

Teamwork Long Proof is designed to get the most out of Flash models by coordinating many agents rather than relying on a single, larger model. We tested this on TCSBench, an evaluation suite of open and challenging problems in theoretical computer science independently developed within Google. Using Gemini 3.7 Flash together with 3.1 Pro, the Long Proof pattern achieves 71% on TCSBench — up from the 67.7% reported in the TCSBench paper with Gemini 3.6 Flash and 3.1 Pro, and the highest score in our internal testing. The ability to combine Flash and Pro models within the Long Proof pattern will be available in upcoming updates.

Self-Verification with Aletheia

Teamwork also introduces the Self-Verification pattern, which iteratively generates, verifies, and revises mathematical arguments. This pattern is inspired by the Aletheia agent announced earlier this year for autonomous mathematics research. Aletheia demonstrated research-level mathematical abilities in the FirstProof Challenge, and we are now sharing a pattern inspired by this harness to mathematicians and scientists via /teamwork-preview in Antigravity.

---

Systems

An example in CPU simulation

RISC-V simulator that boots an operating system

Using Gemini 3.7 Flash, Teamwork built a highly-accurate cycle-level out-of-order (OoO) RISC-V CPU simulator from scratch that successfully boots an operating system to shell (xv6) and successfully simulates 100+ RISC-V standard benchmarks. Teamwork achieves this goal through two separate phases: (1) Microarchitectural Functional Correctness and (2) Cycle-Level Timing Validation. In the first phase, the agents develop the core execution logic, including out-of-order (OoO) pipelines and Reorder Buffers (ROB). This phase focused on ensuring the simulator could boot an OS and maintain correct architectural state when validated against a functional oracle. In the second phase, Teamwork aligns performance characteristics with strict timing oracles.

Teamwork autonomously builds and verifies different microarchitectural units (e.g. MSHR, ROB, Cache, etc.) by executing architectural microbenchmarks and reasoning about its own generated architectural traces and comparing the gap between final cycle counts of an air-gapped Boom simulator and Teamwork generated solution. Validated against BOOM hardware execution ground truth, the Teamwork Simulator achieved an average cycle alignment error of 0.71% on unseen test workloads.

This work goes beyond static software translation into complex, non-deterministic temporal hardware simulation. The central challenge is what we call the “silent execution gap”: a window of up to hundreds of cycles where the microarchitectural state may diverge silently before an architectural failure becomes visible. To prevent cheating, we sandboxed the Spike simulator source code. Teamwork’s solution addresses the execution gap by maintaining continuous lockstep co-simulation against the air-gapped Spike reference simulator.

---

Engineering & Coding

Open-source engineering contributions

Performance optimization: Eigen and ParlayHash

Eigen is a highly-optimized C++ template library for linear algebra, widely used inside Google and across the broader community. We gave Teamwork instructions to run Eigen microbenchmark suites with no restrictions on implementation — only the benchmark itself had to remain intact.

Teamwork identified a suboptimal implementation in Eigen for GeMV operations where the matrix has a single row or column. It created a dedicated fast execution path, implementing direct data access and SIMD operations with 4-way accumulator unrolling. We followed through the open-source code review process with the assistance of Gemini 3.6 Flash and successfully contributed the change to the upstream Eigen library.

Separately, Teamwork contributed to the ideation of Swiss Parlay, incorporating optimizations from Swiss Table to ParlayHash – a high-performance open-source concurrent hash table. Compared to ParlayHash, Swiss Parlay achieved:

• 2× throughput on initial inserts with 64 threads
• 1.5× throughput overall with a single thread
• Close to the best sequential table performance (FlatHashMap) using 25% less memory per element
• Improvement landed in the upstream ParlayHash library

Both changes are already checked into these open-source libraries (Eigen commit, ParlayHash branch). These aren’t benchmark-only results — they are real contributions accepted by external maintainers through standard open-source code review.

---

What’s next

The problems we’ve shown here — open mathematical conjectures, performance-critical library code, and hardware simulation — are each traditionally the province of deep specialists working over months. Teamwork compresses the iteration cycle while keeping experts in charge of direction and acceptance.

Teamwork is powered by publicly available Gemini models, and we are rolling out these improvements and more to /teamwork-preview in Antigravity over the next few weeks. If you are working on frontier innovation tasks, where any increment in intelligence could make a difference, try /teamwork-preview on Google Antigravity to see what multi-agent collaboration can do for your own research and engineering challenges.