/teamwork: What Changes When AI Agents Check Each Other’s Work?
More agents produce more answers; better verification decides which survive. What Google Antigravity's /teamwork reveals about independent review and the economics of checking AI work.
TL;DR
Reading the post…
More agents can produce more answers. Better verification determines which answers deserve to survive. What Google Antigravity’s /teamwork reveals about independent review, reliable agent teams, and the economics of checking AI work.
TL;DR
-
Google Antigravity’s /teamwork makes generation, challenge, and acceptance distinct responsibilities within an agent workflow.
-
A second agent is useful when it brings a different check, evidence source, or method. Agreement alone provides weak assurance when reviewers share the same blind spots.
-
Executable tests, source checks, simulations, and formal proofs establish different kinds of evidence. None automatically validates the entire business outcome.
-
Verification has costs: additional model calls, tools, latency, false alarms, and human review. Compare complete systems under comparable budgets.
-
Humans still define the objective, validate important assumptions, set acceptable risk, and authorize consequential decisions.
What Google’s latest work changes
The most reassuring sentence in an AI workflow may also be one of the least informative:
“A second agent checked it.”
Checked what? Against which evidence? Using which tools? Could that reviewer discover a mistake the original agent could not? And what happens when the reviewer is wrong?
These questions determine whether an agent team provides useful assurance or simply adds another confident voice.
Google Research’s 13 November update describes Antigravity /teamwork combining parallel exploration, context partitioning, and critics working without the producer’s reasoning. Checks include unchanged software tests, simulators, hardware measurements, and Lean, a formal proof assistant. In one reported chemistry benchmark, 30 specialized agents and a physics-informed simulator achieved 95% top-1 exact match. That is a result for a particular system and benchmark, not a general reliability rate for agent teams. Source
The architectural implication is more broadly useful than the headline number: the mechanism for rejecting a bad result deserves as much design attention as the mechanism for producing a candidate.
That changes the conversation for engineering leaders. The question becomes how a system earns acceptance, where that evidence can fail, and how much assurance the task justifies.
How /teamwork separates building from checking
Google’s documentation describes /teamwork as a coordinated workflow for substantial engineering and research tasks. Its roles distinguish a Critic, which reviews correctness and completeness; a Challenger, which probes edge cases and failure paths; an Auditor, which checks integrity and execution evidence; and a Success Auditor, which performs final end-to-end verification. Source
This separation matters because those jobs ask different questions:
| Review responsibility | Question the enterprise needs answered |
|---|---|
| Correctness review | Does the artifact satisfy the stated requirements? |
| Adversarial testing | Under which conditions does it fail? |
| Evidence audit | Were the claimed checks actually performed on this artifact? |
| Final acceptance | Do the components work together in the intended workflow? |
A review comment is not proof that a test ran. A test log is not proof that the correct version was tested. A collection of individually passing components is not proof that their integration works.
The documentation also describes agreeing requirements and checks before execution, and currently lists /teamwork on paid Antigravity App and command-line interface plans. Research patterns and product availability should be checked separately: Google’s November update says some specialized workflows are still forthcoming. Sources: documentation and research update
Google’s earlier August description adds context: Teamwork uses task-dependent patterns, including iterative coding, distributed coding, proof work, and document review. Its long-proof approach attaches falsifiers to candidate strategies and preserves objections so later attempts can learn from failed routes. Source
For enterprise teams, the transferable idea is a division of responsibility. A builder proposes an artifact. A challenger searches for reasons it should fail. An acceptance mechanism determines whether the evidence meets the contract.
Why agreement is different from verification
Three reviewers can independently repeat the same misunderstanding.
If every agent receives an outdated pricing sheet, they may all approve an incorrect commercial comparison. If every reviewer uses the same incomplete test fixture, they may all miss the same integration bug. Changing role names does not change the evidence.
Research on large language models (LLMs) as judges has documented position, verbosity, and self-enhancement biases. That work concerns particular evaluated models and tasks, rather than a universal failure rate for today’s systems, but it establishes why a judge’s judgment also needs evaluation. Source
A separate ICLR 2024 study examined intrinsic self-correction: asking a model to revise its reasoning without external feedback. It found that correction could fail or degrade performance in the tested settings. It does not establish that current models cannot self-correct; it does warn against treating another reasoning pass as new evidence. Source
Consider an agent estimating a provider’s annual growth. A second agent reads the draft and agrees with the percentage. A more useful check retrieves the underlying periods, confirms the currency and reporting basis, and recomputes the growth.
Both processes can involve two agents. Only the second introduces a direct way to discover a particular mistake.
The value of a reviewer comes from the errors it can detect, not the confidence with which it agrees.
What independent verification actually requires
Independence has several dimensions. Treat it as a design property you can strengthen and test, rather than a binary label attached to a second model call.
Context independence
Give the reviewer the original task, the candidate artifact, the necessary references, and the acceptance criteria. For an initial review, consider withholding the producer’s persuasive account of why the answer is correct.
That reduces one source of anchoring. It does not mean withholding information required to understand the work. A reviewer denied the relevant interface contract cannot meaningfully verify interface conformance.
For complex tasks, use two passes: an initial assessment from the artifact and specification, followed by targeted clarification of unresolved questions.
Evidence independence
A reviewer should be able to inspect the underlying evidence. A citation attached to a sentence is only a pointer until the source has been checked for support.
However, a different URL is not necessarily an independent source. Five articles may repeat one company announcement. A useful research review traces important claims to their origin and distinguishes independent corroboration from repetition.
Method independence
Use a different mechanism when one is available. Recompute arithmetic with code. Exercise an interface through its public contract. Test a migration against protected fixtures. Check a mathematical claim with a suitable formal system when a valid formalization exists.
Different methods still have boundaries. Passing a test suite establishes behavior on the tested cases. A formal proof establishes a statement within its formal assumptions. Neither guarantees that the original requirements captured the real problem.
Model diversity
A reviewer from another model family may find different mistakes. It may also be weaker on the task, follow a different interpretation, or introduce errors the original model avoided.
Treat cross-model review as an experimental option. Compare it with a same-model reviewer using better evidence and with direct executable checks. A different logo is not a substitute for measured detection quality.
Authority independence
The producer should not be able to quietly edit the acceptance criteria, suppress a failed check, or replace the evidence record.
For consequential work, have trusted infrastructure enforce which artifacts are reviewed, which checks must pass, and what actions require human authorization. An auditor agent can help interpret evidence; its role description does not itself create a security boundary.
A practical architecture for agent review
The following is a reference design inspired by these principles, not a reproduction of Google’s internal implementation.
The important part is the contract between stages.
Before production, record the goal, constraints, evidence requirements, acceptance thresholds, and limits on time or spending. Identify what must be checked mechanically and what requires judgment.
During review, require specific findings. A useful objection identifies the affected requirement, the artifact location, supporting evidence, and a way to reproduce or inspect the problem. “Improve robustness” gives the producer little to work with.
During revision, preserve objections and their resolution. Do not replace a failed review with a summary saying “addressed.” Connect the new artifact version to the checks that were rerun.
At acceptance, confirm that evidence refers to the exact version being accepted. A successful test before the final edit does not establish the final edit’s correctness.
Use bounded states such as accepted, changes required, inconclusive, and verification unavailable. A tool timeout should remain distinguishable from a negative finding. An inconclusive review should not silently become a pass.
Finally, protect the evaluation machinery. If an agent generates a test, that test can be useful development feedback, but final acceptance also needs criteria maintained independently of the implementation.
Where agent teams earn their cost
Start with tasks where important errors are detectable and expensive enough to justify another stage.
| Task | Useful independent check | What still needs judgment |
|---|---|---|
| Code migration | Protected regression tests and interface compatibility | Whether the migration is worth its operational risk |
| Performance optimization | Repeatable measurements on representative workloads | Which workload and resource tradeoffs matter |
| Enterprise research | Source support, dates, definitions, and reproducible calculations | Relevance, interpretation, and recommendation quality |
| Spreadsheet analysis | Recomputed totals and reconciled inputs | Whether assumptions fit the business decision |
| Technical design | Counterexamples, dependency checks, and requirement coverage | Strategic fit and acceptable complexity |
A bounded bug fix may need one agent and a strong test. A research task with several distinct evidence streams may benefit from parallel investigation and a separate source audit. A tightly coupled redesign may work better sequentially, with review at milestones.
Google’s November report includes a relevant finding: its analysis of coding trajectories favored sequential implementation and revision for tightly coupled code over parallel splitting. That is a useful counterweight to the assumption that a larger team is always better. Source
Avoid elaborate review teams when the task is low impact, the check is trivial, or the reviewer has no credible way to distinguish a correct answer from a plausible one.
If a deterministic validator can settle the issue, run it. If the requirement is unclear, clarify it. Additional agents should solve an identified constraint.
A worked example in enterprise research
Imagine an analyst asking for a recommendation between three technology providers. The draft recommends Provider A partly because it appears to have the fastest growth.
A general reviewer might assess whether the argument is coherent. A verification-oriented workflow asks narrower questions first:
-
Do the compared figures cover the same reporting period?
-
Do they use the same definition of revenue and the same currency basis?
-
Does each source actually support the attributed figure?
-
Are the calculations reproducible from the extracted inputs?
-
Would correcting a disputed figure change the recommendation?
Suppose the challenger finds that Provider A’s number covers a product segment while the others cover whole companies. The issue is not a bad sentence. The comparison itself is invalid.
The producer must either find comparable evidence, narrow the claim, or mark the criterion inconclusive. The final reviewer then checks whether the revised recommendation still depends on the rejected comparison.
This is an illustrative workflow, not a measured /teamwork result. It shows why verification belongs throughout the reasoning process. Catching a defective premise early avoids polishing an entire recommendation built on it.
It also shows where humans remain important. Even with comparable figures, choosing a provider requires weighting integration effort, commercial priorities, and organizational constraints that no generic reviewer can infer reliably.
The economics of checking AI work
Every additional reviewer consumes resources, and some reviews consume substantial resources.
Anthropic’s June 2025 account reported roughly 15 times as many tokens for its multi-agent systems as for chat interactions in its observed setting. That comparison is neither a /teamwork price estimate nor a universal ratio between multi-agent and single-agent systems. It illustrates why architecture choices need an economic test. Source
Count the full workflow: generation, review, tool execution, repeated context, revisions, integration, and human handling of unresolved findings. Parallel reviewers can shorten elapsed time while increasing total computation. Repeated review cycles can increase both.
A practical decision rule is:
Add verification when the expected reduction in error losses exceeds the added cost of checking, delay, and handling false alarms.
The inputs vary by task. A small reduction in escaped defects can justify extensive checks for a critical migration. The same workflow may be wasteful for an internal draft that a person will immediately rewrite.
False alarms are part of the bill
Consider a hypothetical reviewer assessing 1,000 outputs. An independent assessment establishes that 100 contain material errors and 900 are correct.
Suppose the reviewer catches 80 of the errors and incorrectly flags 45 correct outputs.
| Reviewer outcome | Outputs |
|---|---|
| Material errors correctly flagged | 80 |
| Material errors missed | 20 |
| Correct outputs incorrectly flagged | 45 |
| Correct outputs passed | 855 |
The reviewer catches 80% of material errors, but only 64% of its 125 flags identify a real material error. The remaining flags consume investigation or rework capacity. Detection alone also does not mean the defect was successfully fixed.
This is why “our critic found 200 issues” is an incomplete performance claim. Some issues may be duplicates, preferences, or incorrect objections.
Spend verification effort according to consequence and uncertainty. Apply inexpensive structural checks broadly, then reserve deeper source investigation or adversarial testing for important claims, risky changes, and unresolved conflicts. The reviewer’s own confidence should not be the only routing signal.
How to evaluate the reviewers
Judge the complete system against an external assessment. The reviewer being tested cannot also be the sole source of truth about its effectiveness.
Compare at least four configurations:
-
A strong single agent with the available tools.
-
The same agent given a comparable additional time or computation budget.
-
A producer plus a separate reviewer.
-
A producer plus targeted executable or source checks, with review where needed.
Where useful, add a cross-model reviewer as a fifth option. Keep the task set, source snapshots, acceptance criteria, and operating constraints comparable.
This separates the benefit of a review architecture from the benefit of simply spending more compute. For workloads that can run in parallel, compare both elapsed time and total cost; equal spending does not imply equal latency.
Include correct outputs as well as flawed ones in the evaluation. A reviewer tested only on broken artifacts can look impressive by rejecting everything. Seed realistic defects, but also preserve naturally occurring failures and untouched held-out cases.
Track:
-
Defect detection: the proportion of independently confirmed material defects the review catches.
-
False rejection: the proportion of correct outputs incorrectly blocked.
-
Escaped errors: material errors that survive the complete acceptance process.
-
Repair effectiveness: flagged defects actually resolved without introducing new defects.
-
Coverage and abstention: completed tasks, inconclusive reviews, and unavailable checks.
-
Operating burden: cost, slow-case latency, and human review minutes per accepted outcome.
The 2025 Multi-Agent System Failure Taxonomy research identifies 14 failure modes across system design, inter-agent alignment, and task verification. Its relevance is the wider failure surface: review quality depends on coordination and acceptance logic as well as model judgment. Source
Keep review results explicit. A failed tool call, an unparseable response, a confirmed defect, and a lack of evidence are different events. Aggregating them into one negative score hides what the team needs to fix.
Where human judgment remains essential
Automation can move human work toward decisions that matter more. It does not eliminate responsibility for those decisions.
Defining the right problem
A team can perfectly implement an unhelpful requirement. Humans need to decide the intended outcome, relevant constraints, and acceptable tradeoffs before optimizing execution.
For research, this includes deciding what would change the business decision. For engineering, it includes deciding whether a change should exist and what operational risk is acceptable.
Validating the checks
A benchmark may measure the wrong workload. A source may be authoritative yet irrelevant. A test suite may exclude the failure mode that matters most.
Someone must challenge the measurement system itself. Otherwise, increasingly capable agents can become increasingly efficient at satisfying an incomplete specification.
Resolving genuine ambiguity
Two sources may conflict because their definitions differ. Two designs may each satisfy the requirements while carrying different long-term costs.
Another debate round will not necessarily produce the missing business preference. Escalate with a precise question, the competing evidence, the consequences of each option, and the decision required.
Owning consequential action
An agent’s approval should not automatically authorize a deployment, a commercial commitment, or expanded data access. Use the organization’s actual authorization process.
Human oversight is most useful when it is placed at clear decision boundaries and supported by inspectable evidence. A person rubber-stamping a long agent transcript provides little assurance.
A practical enterprise pilot
Choose a workflow with recurring demand, observable quality, and a meaningful cost of error. A bounded code migration or a structured research comparison is a better starting point than an open-ended instruction to improve the business.
First, establish the baseline. Preserve examples of successful and failed work. Define material defects and the independent assessment process. Record current cost, delivery time, and human effort.
Second, add one distinct verification responsibility. Give a reviewer the original requirements and access to relevant evidence. Ask it for specific, supported findings. Use executable checks for questions they can answer directly.
Third, close the revision loop. Record artifact versions, objections, revisions, and check outcomes. Cap retries and define when the system should return an incomplete result or escalate.
Fourth, test the reviewer’s failure modes. Include correct outputs, plausible wrong answers, misleading citations, unavailable tools, and changes made after an earlier successful check. Verify that missing evidence cannot quietly become acceptance.
Finally, compare complete outcomes. Expand the team only if the new configuration improves independently assessed results at an acceptable operating cost. Preserve a simpler fallback.
My expectation is that enterprise differentiation will increasingly depend on domain-specific acceptance criteria, evidence access, and failure data. Generic orchestration is easier to reproduce than a trusted way to determine whether a particular organization’s work is correct.
For vendors, that means demonstrating review quality and traceability alongside agent capability. For engineering leaders, it means funding evaluation and domain expertise as part of delivery, rather than treating them as cleanup after the demo.
Frequently asked questions
What is Google Antigravity /teamwork?
It is Antigravity’s coordinated multi-agent capability for substantial engineering and research work, with distinct execution and review responsibilities. For current commands, access, and supported behavior, use the official documentation.
Is multi-agent verification the same as agents voting?
No. Voting combines judgments. Verification checks an artifact against evidence or acceptance criteria. Voting can be one signal, but agreement does not establish correctness when agents repeat the same mistake.
Does the verifier need a different AI model?
Not necessarily. A same-model reviewer with fresh context, independent evidence, and useful tools may provide more value than a different model repeating the producer’s process. Test the alternatives on representative failures and correct outputs.
Can agent review replace testing?
Agent review can suggest tests, identify gaps, and interpret failures. It should complement direct execution checks where those checks are possible. The review process also needs protection against tests being skipped, weakened, or run against the wrong artifact.
When should a review loop stop?
Stop when the acceptance criteria are satisfied, the budget is exhausted, the system cannot obtain required evidence, or a decision requires human judgment. Report which condition occurred. Repeated discussion is not evidence of progress.
The question to ask before adding another agent
The strongest agent teams will need more than a convincing conversation between specialized roles. They need a way to expose a bad premise, reproduce a defect, preserve an objection, and refuse acceptance when the evidence is insufficient.
Google Antigravity’s /teamwork makes this an immediate architecture question for teams building enterprise agents. The useful lesson is to design the challenge-and-check process with the same care as the production process.
Before adding another reviewer, ask:
What error can this agent detect that our current process would miss, and how will we establish that it actually does?
That answer is the foundation of useful multi-agent verification.
Related reading
Thanks for reading.
More on enterprise ai & ai agents and software & systems architecture