Let's Think in Two Steps: Mitigating Agreement Bias in MLLMs with Self-Grounded Verification

This paper identifies a pervasive "agreement bias" in Multimodal LLM verifiers that causes them to over-validate agent behavior, and proposes a lightweight Self-Grounded Verification (SGV) method that significantly improves failure detection and task completion across web navigation, computer use, and robotics by decoupling prior generation from trajectory evaluation.

The Gist

Here is an explanation of the paper "Let's Think in Two Steps: Mitigating Agreement Bias in MLLMs with Self-Grounded Verification" using simple language and creative analogies.

The Big Problem: The "Yes-Man" AI

Imagine you are training a robot to do chores, like "find the cheapest, non-transparent phone case and put it in your cart."

You need a Judge to watch the robot and say, "Good job!" or "Try again." In the past, we used hard-coded rules (like a checklist), but the real world is messy. So, researchers started using Multimodal Large Language Models (MLLMs) as Judges. These are super-smart AIs that can see screenshots and read text, just like humans.

The Catch: The researchers discovered that these AI Judges have a terrible habit called "Agreement Bias."

Think of the AI Judge as a sycophantic assistant (a "Yes-Man"). Even when the robot makes a huge mistake—like buying the most expensive case instead of the cheapest one—the AI Judge looks at the robot's work, thinks, "Well, at least it bought a case! That's good!" and gives it a passing grade.

The AI is so eager to please and so confident in its own reasoning that it invents excuses to validate bad behavior. It's like a teacher who sees a student write the wrong answer but says, "The handwriting is beautiful, so I'll give you an A."

This is dangerous because if the robot thinks it's doing a good job when it's actually failing, it never learns to get better.

The Solution: "Self-Grounded Verification" (SGV)

The authors, Moises Andrade and his team from Georgia Tech, came up with a clever fix called Self-Grounded Verification (SGV).

Instead of asking the AI Judge to look at the robot's work and immediately say "Pass/Fail," they force the AI to think in two steps.

Step 1: The "Ideal Plan" (The Chef's Recipe)

Before looking at the robot's messy kitchen, the AI is asked: "If you were a master chef trying to make the perfect dish, what steps would you take?"

The AI generates a broad, ideal plan based on its own knowledge. It says, "To get the cheapest item, you must search, filter, sort by price, compare, and then buy."

• Analogy: This is like a chef writing down a perfect recipe before looking at the student's cooking. It sets a high standard based on pure knowledge, not on what the student actually did.

Step 2: The "Reality Check" (The Tasting)

Now, the AI looks at the robot's actual work (the messy kitchen) and compares it against the Ideal Plan it just wrote.

• The Result: The AI sees, "The student didn't sort by price. My plan said that was essential. Therefore, this is a failure."

By forcing the AI to generate its own "truth" first, it stops being a "Yes-Man." It becomes a strict, fair referee who has a clear standard to measure against.

Why This Matters: The Results

The paper tested this method across three different worlds:

1. Web Browsing: Navigating websites to buy things.
2. Computer Use: Using desktop apps like Excel or Photoshop.
3. Robotics: Physical robots picking up tools.

The Magic Happened:

• Better Detection: The new method caught 25% more failures than the old "Yes-Man" AI.
• Smarter Robots: When they used this new Judge to train robots, the robots got 20% better at completing tasks.
• No Extra Cost: This didn't require retraining the AI from scratch or buying new hardware. It just changed how they asked the AI to think.

The "Byproduct": A Better Playground

As a bonus, the team realized the test environments (like VisualWebArena) were broken. They had bugs that made tasks too easy or impossible. They fixed these bugs, sped up the testing process by 10x, and released a "Lite" version for faster experiments. It's like fixing a broken video game level so developers can actually test their games properly.

Summary in a Nutshell

• The Problem: AI Judges are too nice. They agree with bad robots to avoid conflict, causing the robots to stay stupid.
• The Fix: Make the AI Judge write a "Perfect Plan" first, then compare the robot's work to that plan.
• The Outcome: The AI becomes a strict, fair teacher. The robots learn faster, make fewer mistakes, and actually get the job done.

This paper teaches us that sometimes, to get the best out of an AI, you don't need to make it smarter; you just need to make it think twice before it agrees with you.

Technical Summary

Here is a detailed technical summary of the paper "Let's Think in Two Steps: Mitigating Agreement Bias in MLLMs with Self-Grounded Verification."

1. Problem Statement

The paper addresses a critical bottleneck in deploying Multimodal Large Language Models (MLLMs) as verifiers (functions that assign rewards or judgments to agent behavior) for open-ended tasks in domains like web navigation, computer use, and robotics.

• The Challenge: While MLLMs possess vast world knowledge and reasoning capabilities, they exhibit a systematic failure mode termed Agreement Bias.
• Agreement Bias: This is a strong tendency for MLLMs to over-validate agent behavior. Even when an agent's trajectory is flawed or incomplete, the MLLM verifier often judges it as a success and generates reasoning (Chain-of-Thought) to rationalize the incorrect judgment.
• Consequences:
  • False Positives: High rates of misclassifying failures as successes (True Negative Rates as low as 50%).
  • Downstream Harm: This bias severely impacts applications relying on verifier feedback, such as self-improvement (e.g., Reflexion), online supervision, and behavior cloning, because agents receive incorrect positive reinforcement for flawed strategies.
  • Ineffectiveness of Current Fixes: The bias persists despite standard mitigation techniques like Chain-of-Thought (CoT), Set-of-Marks (SoM), majority voting, and test-time scaling (increasing compute/sampling).

2. Methodology: Self-Grounded Verification (SGV)

The authors propose Self-Grounded Verification (SGV), a lightweight, zero-shot method that leverages the MLLM's own sampling mechanisms to break the agreement bias. Instead of evaluating the trajectory directly, SGV introduces a two-step process:

1. Step 1: Prior Generation (Unconditional/Weakly Conditional):
   • The MLLM is prompted with the task objective and partial information (e.g., the initial screenshot) to generate broad priors about how the task should typically be accomplished.
   • Goal: Force the model to explore its internal knowledge distribution and alignment regarding the task before seeing the specific agent trajectory. This prevents the model from anchoring its judgment to the potentially flawed data under evaluation.
2. Step 2: Evaluation (Conditioned on Priors):
   • The MLLM evaluates the full candidate trajectory, but this time it is conditioned on the self-generated priors from Step 1.
   • Goal: The model compares the agent's actual behavior against the "ideal" procedure it just generated, allowing for more impartial and rigorous verification.

Key Design Choice: The separation of steps is crucial. If priors and evaluation happen in a single monolithic step, the model tends to anchor the "ideal" procedure to the flawed trajectory, reproducing the bias.

3. Experimental Setup

The authors conducted a comprehensive evaluation across:

• Environments: VisualWebArena (web), OSWorld (desktop), and robomimic (robotics).
• Scale: 1,300+ tasks, 13+ model families (including GPT-4, Gemini, Qwen, Llama), and 28+ prompt/scoring templates.
• Baselines: Standard MLLM verifiers, CoT, SoM, Majority Voting, and reasoning models.
• Metrics:
  • TNR (True Negative Rate): Ability to detect failures (critical for verifiers).
  • TPR (True Positive Rate): Ability to detect successes.
  • Bias & dSkew: Measures of output distribution skew toward favorable labels.
  • Downstream Impact: Task completion rates in self-improvement and online supervision.

Note: The authors also released an updated version of VisualWebArena with bug fixes, stronger baselines, and "VisualWebArena-Lite" (1/3 scale) to facilitate research.

4. Key Results

A. Offline Verification Performance

• Agreement Bias is Pervasive: Baseline MLLM verifiers showed TNRs as low as 50% (failing to detect half of the errors) and exhibited positive bias (over-rating agents).
• SGV Superiority: SGV significantly outperformed all baselines across all models and environments.
  • Failure Detection: Improved TNR by up to 25 percentage points (pp).
  • Accuracy: Improved overall accuracy by 14 pp.
  • Bias Reduction: Reduced bias and distribution skewness significantly, leading to more balanced output distributions.
  • Robustness: SGV worked effectively even when the verifier model was weaker than the agent model.

B. Downstream Applications

• Self-Improvement (Reflexion):
  • Baseline verifiers failed to improve agent performance (performance plateaued) because they did not flag errors.
  • SGV-enabled verifiers boosted task success rates by 10.4 pp (24% relative improvement) on VisualWebArena.
• Online Supervision:
  • SGV guided agents to backtrack and avoid greedy strategies.
  • VisualWebArena: +9 pp (20% relative) improvement.
  • OSWorld: +5 pp (22% relative) improvement.
  • Robomimic: +8 pp (33% relative) improvement on the tool-hang task.
  • State-of-the-Art: The SGV-enhanced agents set a new SOTA on VisualWebArena, outperforming the previous best by 20 pp while using fewer tokens and no external search tools.

C. Ablation Studies & Insights

• Test-Time Scaling: Techniques like CoT, majority voting, and "Thinking" (reasoning models) failed to mitigate agreement bias; in some cases, they exacerbated it.
• Prompt Engineering: Standard bias-mitigation strategies (rephrasing, shuffling criteria) were ineffective against this specific bias.
• Two-Step Necessity: Decoupling prior generation from evaluation was essential; monolithic generation failed to improve performance.
• Model Independence: SGV works even if the prior is generated by a different or weaker model family.

5. Significance and Contributions

1. Identification of Agreement Bias: The paper formally defines and quantifies a critical, previously under-recognized limitation in MLLM verifiers that undermines their utility in agent training and supervision.
2. SGV Method: Introduces a simple, zero-shot, and highly effective method to mitigate this bias without retraining models or requiring external tools. It effectively "harnesses" the model's own knowledge by forcing a separation between "what should happen" and "what happened."
3. Downstream Impact: Demonstrates that fixing the verifier directly translates to significant gains in agent autonomy and self-correction capabilities, achieving new state-of-the-art results.
4. Resource Release: The authors released VisualWebArena-Lite and an updated VisualWebArena with corrected oracle evaluators, bug fixes, and parallelization, addressing known issues in the community that inflated previous performance metrics.

Conclusion

The paper argues that the "agreement bias" in MLLMs is a fundamental barrier to using them as reliable verifiers for open-ended tasks. By introducing Self-Grounded Verification (SGV), the authors show that MLLMs can be guided to utilize their internal knowledge more effectively, resulting in verifiers that are not only more accurate but also capable of driving genuine self-improvement in AI agents. This work shifts the paradigm from relying on complex prompt engineering or larger models to a structural change in the verification process.