AI Multi-Agent Systems: What Google’s Teamwork Shows12 min read2,449 words

AI Multi-Agent Systems: What Google’s Teamwork Shows

See how Google’s Antigravity /teamwork uses specialized AI agents, independent verification and human review to tackle research, science and engineering work.

AI multi-agent systemsAntigravity TeamworkAI agent verificationformal verification AIAI research tools
AI Multi-Agent Systems: What Google’s Teamwork Shows

Google's Antigravity Teamwork Puts Multi-Agent AI to Work

A capable AI model can write code, explain a paper, or propose a proof. But getting a single useful answer is different from finishing a job that takes days, touches lots of tools, and has to hold up when other people try to verify it. In research and engineering, "sounds plausible" isn't enough. The result has to survive a proof checker, a test suite, a physical measurement, or some other independent check.

Google's Antigravity /teamwork is built for that gap. Instead of leaning on one model to carry a long task through a conversation, it coordinates specialized agents, limits what each one sees, and then checks what they produce using external evaluators. Google Research describes applications that range from formal math and molecular structure prediction to kernel optimization and large software rewrites.

The headline results deserve a careful read. They come from human-AI collaboration, and they don't mean agents can replace expert judgment. This article walks through how the system works, what Google says it achieved, where verification actually matters, and what teams should think about before copying this workflow.

What is Antigravity Teamwork?

Antigravity /teamwork is a multi-agent workflow system. It breaks a complex task into steps, assigns those steps to agents, and then uses separate checks to assess what the agents produced. The goal isn't just "run several chatbots." It's to control how the work gets decomposed, what tools each agent can use, and how one stage hands off to the next.

That distinction matters because language models have two common failure modes on long jobs. First, they can be inconsistent - one run might be wrong even if the model is otherwise capable. Second, as the task grows, important details can fall out of view. Longer prompt history doesn't automatically fix that.

The /teamwork approach tackles these issues with two main design choices:

  • Parallel exploration: agents can investigate candidate solutions or different strategies side by side, so you're more likely to find a path that actually works.
  • Independent checking: dedicated critics or auditors evaluate outputs using tools such as Lean 4, software tests, simulators, search, or hardware counters.

It also partitions context on purpose. Each agent gets the files and tools it needs for its step, instead of inheriting everything from the whole project. Coordinators can bring in fresh agents, while reviewers examine a result without relying on the original agent's reasoning transcript. The idea is to reduce context overload and make it easier to catch mistakes the "producer" might have missed.

Google describes these workflows as declarative, natural-language patterns that can be chosen for different task types. That includes long-proof and document-review patterns, plus /boost - a more sequential solve-and-verify loop for coding tasks. The underlying point is that the workflow should match the problem. Tightly coupled code may need staged implementation and revisions. Research paths that don't depend on each other can benefit from parallel exploration.

This is a process design, not a guarantee that results are correct. Teams still have to define the task clearly, set meaningful constraints, and decide what counts as a valid outcome. Agents can make the process more systematic, but they can't rescue a bad specification or a weak evaluator.

What research results has Google reported?

Google's examples cover theoretical computer science, mathematics, and formal proof. The common thread isn't simply that an AI generated an answer on its own. In the reported work, researchers collaborated with the agents, reviewed the outputs, and often formalized results so a proof-checking kernel could verify each logical step.

One frequently cited example is the Courtade-Kumar conjecture in information theory, proposed in 2013. Google reports that researchers from Google, CUHK, USC, and CMU used the Long Proof pattern to prove the conjecture in full generality. The collaboration included human work proposing a candidate function and an analytical bound, followed by Gemini models exploring parameter regions and developing bounds and interval-arithmetic certificates. The team then formalized the proof in Lean 4, producing on the order of 50 million lines of code.

Google also reports near-optimal sample bounds for adaptive data analysis (addressing a gap dating back to 2014) and a quantum computing result that resolves a 2014 question about Boolean functions - specifically about needing more than half the input size in quantum queries. The company further describes advances in Boolean matrix multiplication, graph sparsification, randomized linear algebra, and online inverse linear optimization. These are specialized results, and their real value depends on the assumptions and guarantees in each paper, not just the size of the claim.

Another workflow, LEAP, is described as focusing on formalizing mathematical proofs. Google reports an end-to-end Lean formalization of the Weil conjectures totaling roughly 1.8 million lines and 28,800 subagent invocations. It also reports formalizations related to Hilbert's tenth problem over general rings of integers and work on finite-time blowup for the 3D Navier-Stokes equations with smooth forcing. Additional examples include formalizations of the Birkhoff conjecture and the 3D Bochner-Riesz conjecture. In the latter case, Google says the process found and fixed a gap in a recently released informal proof.

Taken together, these examples suggest where agentic systems can help: problems with huge search spaces and long proof chains where human verification is costly. They also underline a key limitation. The human role stays central - researchers define the statement, decide what problem the formalization is actually capturing, and interpret what the verified result means. A formal proof can show that a theorem follows from the formal assumptions; it can't, by itself, prove that those assumptions match the original real-world question.

Why does independent verification matter?

A language model can produce a confident explanation that includes a subtle mistake. In complex research or production software, you might not notice the cost of that mistake until much later. That's why /teamwork separates producing a candidate from checking whether it works.

Which checker you use depends on the task. For math, Lean 4 can verify that a formal proof follows from a theorem statement. For code migration, an unmodified test suite can check whether expected behavior still holds. For hardware optimization, counters and timed runs can measure performance. For scientific work, a physics-informed simulator or comparisons to experimental measurements can constrain what results are plausible.

Even strong evaluators have limits. Passing tests only tells you that the tested cases pass; it doesn't prove defect-free behavior. A benchmark can reward an optimization that looks great on its own workload while failing elsewhere. A formal proof verifies the proposition you wrote down - not whether the formalization faithfully matches the informal claim you had in mind. Verification helps when it's independent and aligned with the right requirement, but it doesn't remove the need for expert review.

Google's Deep Review example makes the "review problem" concrete. Ahead of STOC 2027, authors of 578 submissions opted in to receive feedback on drafts. In a survey of 70 authors, Google reports that 90% rated the feedback mostly or almost entirely factual, and 90% said they'd use the tool again. Over 30% said it caught substantive proof bugs or mathematically significant typos, and 14% said it found technical gaps that took more than an hour to fix. Those survey results are encouraging, but the sample is limited and the responses are self-reported, so they shouldn't be treated as a controlled measurement of review quality.

For teams adopting agent workflows, the practical takeaway is simple: define the acceptance test before asking agents to optimize for it. Keep tests, evaluation data, and promotion criteria out of the agents' control when possible. Use independent reviewers who can inspect the actual artifact, not just evaluate an agent's explanation. This reduces the chance that an agent "wins" by changing the test, missing a dependency, or presenting an unverified result as complete.

Where is the system being used beyond mathematics?

Google's reported applications also extend into chemistry, software systems, and machine-learning infrastructure - settings where you can often compare outputs against measurements or executable evaluators.

In chemistry, Google describes using 30 specialized agents in a self-correcting workflow with a physics-informed spectral simulator to infer molecular structures from nuclear magnetic resonance data. The company reports 95% top-1 exact-match accuracy and 100% top-3 accuracy on complex benchmark molecules - nearly twice the single-agent performance. That's a strong example of a multi-agent approach paired with a domain-specific evaluator, but it's not, by itself, proof that the same accuracy will hold across every molecule or lab environment.

In systems engineering, Google reports a two-week campaign that rewrote the remaining C++ code in its Zircon microkernel port, adding about 800,000 lines of safe Rust that passed kernel unit tests and booted on arm64 hardware. It also describes a separate rewrite of the libgav1 AV1 decoder reaching bit-exact parity across a broad conformance suite. Google says the initial Rust version ran slower, but after the agents were given profiling tools and a performance objective, it became 20-30% faster than the original on x86_64 and ARM. The sequence is instructive: correctness checks first, then profiling and measurements to guide optimization.

For machine-learning systems, Google reports that full hardware evaluations of custom JAX and Pallas TPU kernels took 7 to 32 minutes each. Its DuoDiscover workflow used four parallel agents to build proxy evaluators (yardsticks) that took about 23 seconds. Their rankings were then checked against periodic full hardware runs using Kendall's rank correlation. Google reports geometric-mean speedups of 4.09x across 17 JAXBench kernels and 2.99x across seven hand-optimized vLLM TPU-inference kernels. Proxies can speed up exploration, but periodic validation is essential: if a proxy's ranking drifts, the system will optimize the wrong thing.

Other examples include custom TPU kernels for graph neural networks and a Go engine trained through autonomous optimization campaigns. Google reports up to 185x lower high-bandwidth-memory use for the graph kernels and a 2,300x speedup in self-play for the Go campaign. These numbers are tied to specific workloads, hardware, and evaluation setups. For buyers and engineering teams, the useful question isn't "can agents claim a big speedup?" - it's whether the measurement reflects the real production constraints and trade-offs.

What should teams learn from these results?

If there's one strong takeaway, it's architectural: multi-agent AI tends to work best when you can break the task into parts and when each stage has a credible way to check its output. More agents don't automatically mean better results. Coordination overhead, duplicated work, and token spend can add up quickly if the task is poorly divided or if agents share too much context.

Before dropping a long-running agent workflow into a research or engineering process, it helps to answer five questions:

  1. What is the deliverable? Define an artifact you can inspect, like a proof, patch, benchmark result, or tested design - not "solve a big problem."
  2. How will success be measured? Pick an evaluator up front. Use real test suites, target hardware, representative data, or a clearly stated formal proposition.
  3. Which steps can be separated? Parallelize exploration that doesn't depend on each other. Keep tightly coupled changes sequential when later steps rely on earlier ones.
  4. Who audits the result? Have an agent or person review the artifact independently, and keep humans responsible for the final decision.
  5. What does the workflow cost? Track runtime, compute, human review time, and the cost of failures. Faster isn't automatically cheaper or safer.

Operational risk often doesn't look like a blatant failure. It can be a result that passes a narrow check while breaking an unstated requirement - like a migration that changes behavior outside the test suite, an optimization that only works on benchmark inputs, or a proof formalized against the wrong statement. Strong workflows make assumptions visible, keep the original tests, and compare candidate performance with independent measurements.

There are also governance issues to think about. Teams should decide what data agents can access, how generated code is reviewed, and who's accountable once outputs reach users or production systems. In regulated or safety-sensitive settings, traceability matters: record the task specification, models and tools used, what checks ran, and the human approval that allowed deployment. The right controls depend on the risk level, but they should be designed into the workflow rather than bolted on after something goes wrong.

Google says Gemini models, /teamwork, and /boost are available to external users in Antigravity, with additional formal-proof workflows planned. Access and availability can change, so teams should verify the current product terms and limits before building a process around them. More broadly, treat the reported work as evidence of what carefully constrained agent systems can do - not as proof that every hard task is ready for full automation.

Conclusion

Antigravity /teamwork offers a practical model for using AI on work that's too long or complex for a single prompt. The core ideas are straightforward: split the job, limit what each agent sees, and verify outputs with tools that match the task. Google's reported results are ambitious, but the most transferable lesson is the system around the models - especially independent evaluation and human review. If you're considering an agent workflow, start with a measurable task, keep trustworthy checks in place, and expand only when the process improves both quality and total cost.

Frequently Asked Questions

Antigravity /teamwork is Google’s multi-agent workflow system for coordinating specialized AI agents on complex tasks. It assigns agents limited contexts and tools, then uses critics, auditors or external evaluators to check candidate results. Google presents it for research, coding, document review and other long-running work.
No. Google reports substantial formalization work, including large Lean 4 projects, but human researchers still define and inspect the theorem statements and assess their relevance. A proof checker verifies reasoning against a formal statement; it does not decide whether that statement correctly captures the intended research question.
It depends on the task. Examples include Lean 4 for formal proofs, unmodified software test suites for code, simulators for scientific candidates and hardware counters for performance work. These checks are useful only when they measure the right requirement and are sufficiently independent of the agent that produced the result.
Tasks with clear subproblems, large search spaces and objective evaluation are promising candidates. Examples include code migration, optimization, proof exploration and benchmark generation. Work that depends on tacit context, ambiguous goals or high-stakes judgment still requires substantial human oversight and carefully designed acceptance criteria.

Related articles