🤖 AI

Inference-Time Scaling of Verification: Self-Evolving Deep Research Agents via Test-Time Rubric-Guided Verification

This paper introduces DeepVerifier, a self-evolving framework that enhances Deep Research Agents through inference-time scaling by iteratively verifying and refining outputs using rubrics derived from a novel failure taxonomy, achieving significant accuracy gains without additional training while releasing a corresponding dataset to support open-source advancement.

Original authors: Yuxuan Wan, Tianqing Fang, Zaitang Li, Yintong Huo, Wenxuan Wang, Haitao Mi, Dong Yu, Michael R. Lyu

Published 2026-04-30

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yuxuan Wan, Tianqing Fang, Zaitang Li, Yintong Huo, Wenxuan Wang, Haitao Mi, Dong Yu, Michael R. Lyu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant but sometimes overconfident research assistant named "Deep Research Agent" (DRA). This assistant is great at finding information, reading hundreds of websites, and writing reports. However, like any human, they sometimes make mistakes: they might read the wrong website, misunderstand a question, or confidently state a fact that isn't true.

Usually, if this assistant makes a mistake, you have to stop them, explain what went wrong, and hope they do better next time. But what if the assistant could check their own work before you even see it, find their own errors, and fix them on the fly?

That is exactly what this paper proposes. They built a system called DeepVerifier that acts like a "self-correcting editor" for these AI agents.

Here is how it works, broken down into simple concepts:

1. The Problem: The "All-or-Nothing" Trap

When an AI tries to solve a hard problem (like "Find the earliest publication of a specific researcher"), it often gets lost in a maze of steps. If you ask a standard AI to "check if this answer is right," it often fails because checking a complex answer is just as hard as solving the problem in the first place. It's like asking a student to grade their own 50-page essay without a rubric; they might miss subtle errors.

2. The Solution: The "Rubric" and the "Rubber Stamp"

The researchers realized that checking an answer is actually easier than creating one. They call this the "asymmetry of verification."

To make this work, they created a Failure Taxonomy. Think of this as a giant checklist of every way an AI can mess up. They analyzed thousands of past mistakes and categorized them into 5 main groups and 13 sub-groups (e.g., "Used the wrong source," "Misread the instructions," or "Made up a fact").

DeepVerifier uses this checklist to act as a strict editor:

The Decomposer: Instead of asking the AI to re-read the whole messy report, this module breaks the problem down into tiny, simple questions. Instead of "Is the whole report right?", it asks, "Did Source X actually say Y?" or "Is this number correct in the latest report?"
The Verifier: It answers these tiny questions using the checklist.
The Judge: It gives a score (1 to 4) and specific feedback. If the answer is wrong, it doesn't just say "No." It says, "You used the wrong source for this fact. Go back and find the original document."

3. The Magic: "Self-Evolving" at Test Time

The coolest part is that this happens while the AI is working, without needing to retrain the AI's brain (which is expensive and slow).

Imagine the AI writes an answer. DeepVerifier reads it, finds a flaw, and says, "Hey, you missed this detail." The AI then uses that feedback to rewrite the answer. They do this in a loop (like a round of editing).

Round 1: AI writes answer.
Round 2: DeepVerifier finds errors, AI fixes them.
Round 3: DeepVerifier finds more subtle errors, AI fixes again.

The paper shows that with just a few rounds of this "self-editing," the AI gets significantly smarter. On difficult tests (like the GAIA benchmark), the AI's accuracy jumped by 8% to 11%. That's a huge leap for an AI that wasn't retrained, just given a better way to check its own work.

4. The Gift to the Community: "DeepVerifier-4K"

The researchers didn't just keep this trick to themselves. They realized that for open-source AI models (the free ones) to get good at this self-checking, they need practice.

So, they created a dataset called DeepVerifier-4K. Think of this as a "training manual" containing 4,646 examples of:

An AI making a mistake.
The "Editor" (DeepVerifier) pointing out exactly what went wrong using the checklist.
The AI fixing the mistake.

They used this manual to teach open-source models how to be their own editors. The result? These open models became much better at reasoning and catching their own errors, closing the gap with the expensive, closed-source models.

Summary

In short, this paper teaches AI agents to stop and think before they submit their work. By breaking big problems into small, checkable facts and using a strict checklist of common mistakes, the AI can self-correct in real-time. It's like giving the AI a mirror and a rulebook, allowing it to evolve and improve its answers instantly, without needing a teacher to retrain it from scratch.

1. Problem Statement

Deep Research Agents (DRAs) powered by Large Language Models (LLMs) are transforming automated knowledge discovery but suffer from reliability issues. Common failure modes include hallucinations, incorrect API usage, reliance on incomplete secondary sources, and reasoning errors.

Limitations of Current Approaches: Existing methods primarily focus on enhancing policy capabilities via post-training (Supervised Fine-Tuning or Reinforcement Learning). While "Test-Time Scaling" (e.g., Best-of-N sampling) exists, it often fails because different rollouts tend to repeat the same systematic errors.
The Gap: There is a lack of scalable, automated frameworks that enable agents to self-evolve during inference by verifying their own outputs, generating targeted feedback, and refining answers without additional training. Furthermore, generating high-quality feedback is difficult as it requires sophisticated reasoning capabilities.

2. Methodology

The authors propose DeepVerifier, a framework that leverages the asymmetry of verification (checking an answer is often easier than generating it) to enable iterative self-improvement. The methodology consists of three core components:

A. DRA Failure Taxonomy

To guide verification, the authors constructed a systematic taxonomy of agent failures based on an analysis of 555 error points from the WebAggregatorQA dataset.

Structure: The taxonomy classifies failures into 5 major categories and 13 sub-categories.
Key Findings: The most frequent failure mode is "Finding Sources" (e.g., consulting wrong evidence, generic searches), followed by "Reasoning" (premature conclusions, hallucinations).
Usage: This taxonomy serves as the foundation for creating structured rubrics that guide the verification process.

B. The DeepVerifier Framework

DeepVerifier is a three-stage, multi-module pipeline designed to decompose complex verification tasks:

Decomposition Agent:
- Instead of asking an LLM to re-solve the entire complex task (which is error-prone), this agent summarizes the original trajectory and identifies potential error points based on the Failure Taxonomy.
- It formulates high-leverage follow-up questions targeting specific vulnerabilities (e.g., "Does Source X explicitly state Claim Y?").
Verification Agent:
- Executes the follow-up questions using external tools (web search, code execution) to gather concrete evidence.
Judge Agent:
- Evaluates the original answer against the trajectory summary, the list of potential errors, and the evidence gathered from the follow-up questions.
- Outputs a rubric-based score (1–4) and detailed, actionable feedback.

C. Test-Time Scaling & Self-Evolution

Iterative Loop: The agent generates an answer $\rightarrow$ DeepVerifier checks it $\rightarrow$ Feedback is provided $\rightarrow$ The agent retries/refines the answer.
Rubric-Guided Feedback: The feedback is not generic; it is derived from the specific failure taxonomy, ensuring the agent knows exactly why it failed (e.g., "You relied on a generic search instead of a primary source").
No Training Required: This process happens entirely at inference time, requiring no gradient updates to the base model.

D. DeepVerifier-4K Dataset

To enable open-source models to develop robust verification capabilities, the authors created DeepVerifier-4K, a curated Supervised Fine-Tuning (SFT) dataset containing 4,646 high-quality prompt-response pairs. These pairs focus on the reflection and self-critique process, allowing open models (like Qwen) to learn how to verify and refine their own outputs.

3. Key Contributions

Formalization of Agent Reflection: The paper formalizes a reflection pipeline for DRAs that exploits the verification asymmetry, moving beyond holistic judging to targeted evidence checking.
DRA Failure Taxonomy: The creation of a comprehensive, automatically constructed taxonomy (5 classes, 13 sub-classes) that systematically categorizes agent failures, serving as a blueprint for rubric-based rewards.
DeepVerifier Framework: A plug-and-play module that integrates verification and feedback generation, outperforming standard "Agent-as-Judge" and LLM judge baselines.
DeepVerifier-4K Dataset: A high-quality SFT dataset released to the open community to train models in reflection and self-critique, addressing the scarcity of data for this specific capability.

4. Experimental Results

Verification Performance (Meta-Evaluation)

DeepVerifier significantly outperforms vanilla "Agent-as-Judge" and standard LLM judges.
Metric: It achieves a 12%–48% improvement in meta-evaluation F1 scores.
Ablation: Removing the decomposition module leads to high precision but low recall (missing subtle errors). Removing the verification module leads to poor accuracy. The full pipeline balances both.

Inference-Time Scaling (Performance Gains)

Closed-Source Models (Claude-3.7-Sonnet):
- On the GAIA benchmark, accuracy improved by 8%–11% (e.g., GAIA-Web rose from ~52% to ~63.5%).
- On XBench-DeepSearch, gains reached 6%.
- On BrowseComp (extremely difficult), gains reached 5%.
Open-Source Models (Qwen3-8B / DeepVerifier-8B):
- Models fine-tuned on DeepVerifier-4K showed superior reflection capabilities.
- DeepVerifier-8B achieved a 5.5% accuracy gain after 10 rounds of reflection, significantly outperforming the base Qwen3-8B and the CK-Pro-8B (trained only on standard data).

Scaling Trends

Performance typically peaks around 3–4 feedback rounds.
Early rounds fix many errors (Incorrect $\to$ Correct), but later rounds risk over-correction (Correct $\to$ Incorrect). The framework includes an early stopping mechanism when the verifier accepts an answer.

5. Significance and Impact

Paradigm Shift: The paper shifts the focus from solely training better agents to scaling verification at inference time. It demonstrates that agents can self-correct effectively without additional training costs.
Scalability: The approach is model-agnostic, working effectively with both powerful closed-source APIs and fine-tuned open-source models.
Resource Efficiency: By decomposing verification into small sub-tasks rather than re-solving the whole problem, it offers a better accuracy-to-cost tradeoff compared to brute-force methods like Best-of-N.
Community Contribution: The release of the Failure Taxonomy and DeepVerifier-4K dataset provides a critical foundation for future research in reflection-enhanced Reinforcement Learning (RL) and trustworthy agent development.

In summary, this work establishes that structured, rubric-guided verification is a powerful mechanism for scaling the reliability of Deep Research Agents, turning inference-time computation into a self-improving loop that significantly boosts accuracy on complex, multi-step reasoning tasks.