待翻譯：Antigravity Teamwork

AI 服務暫時不可用，以下為來源正文，待恢復後補全翻譯。

·Aug 27, 2026·11 min read 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. ProblemResultProblem and Solution Links 1. Coresets for Lp Subspace ApproximationImproved coreset construction bounds for ℓp subspace approximation for p>2Open problem: FOCS 2025 Solution: arXiv:2608.26047 2. Sparse Convex OptimizationEstablished a conditional lower bound on condition number for sparse least-squares objectivesOpen problem: JMLR 2021 Solution: arXiv:2608.02588 3. Maximal Inner Product EmbeddingsNearly closes the gap in complexity for Chamfer similarity for single and multi-vector embeddingsOpen problem: Jayaram 2026 Solution: arXiv:2607.20393 4. Provable Hadamard QuantizationEliminated 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 ProblemIndependently reproduced the initial breakthrough on the unit-distance exponentSolution: GitHub Rediscovered a solution to the problem with no internet access 6. Prefix-Matrix FactorizationsNear-optimal lower bound for prefix-matrix factorizationsOpen problem: Bulanek et al. 2026 Solution: arXiv:2608.08238 7. Knuth’s Cycles ConjectureFirst 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 [truncated for AI cost control]