Upload folder using huggingface_hub

benchmark_dataset/papers/ICLR2026_0001_2507.11662/metadata.json

@@ -0,0 +1,81 @@
+{
+  "paper_id": "ICLR2026_0001_2507.11662",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "Let's Think in Two Steps: Mitigating Agreement Bias in MLLMs with Self-Grounded Verification",
+  "authors": [
+    "Moises Andrade",
+    "Joonhyuk Cha",
+    "Brandon Ho",
+    "Vriksha Srihari",
+    "Karmesh Yadav",
+    "Zsolt Kira"
+  ],
+  "domain_score": 32,
+  "domain_areas": [
+    "model_architecture",
+    "pretraining_posttraining_instruction_alignment",
+    "test_time_reasoning_compute",
+    "rag_agents_tools",
+    "multimodal",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "rwo7bVlnzo",
+  "openreview_forum": "rwo7bVlnzo",
+  "openreview_url": "https://openreview.net/forum?id=rwo7bVlnzo",
+  "arxiv_id": "2507.11662",
+  "arxiv_id_versioned": "2507.11662v3",
+  "arxiv_abs_url": "http://arxiv.org/abs/2507.11662v3",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2507.11662v3",
+  "arxiv_source_url": "https://arxiv.org/e-print/2507.11662",
+  "arxiv_title": "Let's Think in Two Steps: Mitigating Agreement Bias in MLLMs with Self-Grounded Verification",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-07-15T18:50:29Z",
+  "arxiv_updated": "2026-03-08T00:45:24Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 42,
+  "status": "ok",
+  "main_tex_original_path": "main.tex",
+  "expanded_inputs_count": 9,
+  "removed_inputs_count": 32,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "trabucco2025towards",
+    "pan2024autonomous",
+    "ma2024visionlanguagemodelsincontext",
+    "wang2024agentworkflowmemory",
+    "yu2025exact",
+    "shinn2023reflexion",
+    "sarch2025vlmagentsgeneratememories",
+    "pan2024webcanvas",
+    "koh2024treesearchlanguagemodel",
+    "yang2025agentoccamsimplestrongbaseline",
+    "sun2025mmverifyenhancingmultimodalreasoning",
+    "koh2024visualwebarena",
+    "li2024effects",
+    "liu2023agentbench",
+    "yu2024exact",
+    "koh2024tree",
+    "zhou2023webarena",
+    "bai2024digirltraininginthewilddevicecontrol",
+    "snell2024scaling",
+    "welleck2024decodingmetagenerationinferencetimealgorithms",
+    "wei2022chain",
+    "kojima2022large",
+    "zhang2023multimodal",
+    "zawalski2024robotic",
+    "yao2023react",
+    "yao2023tree",
+    "hao2023reasoninglanguagemodelplanning",
+    "wang2022self",
+    "shao2024deepseekmathpushinglimitsmathematical",
+    "lightman2023letsverifystepstep",
+    "deepseekai2025deepseekr1incentivizingreasoningcapability",
+    "openai2024reasoning",
+    "team2025kimi",
+    "deepmind2025gemini2.5"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0001_2507.11662/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab815de8e0fc3d5162e591eface819e13bfe6e37cb0f43b150c1d144d077d322
+size 16834709

benchmark_dataset/papers/ICLR2026_0001_2507.11662/source_extracted.tex

@@ -0,0 +1,327 @@
+\begin{abstract}
+
+\looseness=-1
+Verifiers---functions assigning rewards to agent behavior---have been key to AI progress in domains such as math, code, and games.
+However, extending these gains to domains without clear-cut success criteria (e.g., computer use) remains a challenge: while humans can recognize desired outcomes, translating this intuition into scalable rules is nontrivial.
+Multimodal Large Language Models (MLLMs) offer a promising solution, given their vast world knowledge, human-preference alignment, and reasoning capabilities.
+We evaluate MLLMs as verifiers across web navigation, computer use, and robotics, spanning 13+ model families, 28+ design templates, distinct downstream applications, and thousands of trajectories of varying lengths from diverse agents.
+We identify a critical limitation: a strong tendency for MLLMs to over-validate agent behavior---a phenomenon we term agreement bias.
+This bias is pervasive across models, is resilient to test-time scaling, and can harm applications relying on MLLM judgments/rewards (e.g., self-improvement, steering, online supervision).
+We discuss several considerations for evaluating and designing MLLM verifiers and introduce SGV---a lightweight, zero-shot method that harnesses MLLMs' own sampling mechanisms by modulating (un)conditional generation to better leverage their knowledge, alignment, and reasoning.
+In SGV, the MLLM is first elicited to generate broad priors about desired behavior, conditioned on partial information about the data under evaluation.
+Then, conditioned on self-generated priors, it reasons over and evaluates a candidate trajectory.
+Our methods yield more human-aligned verifiers, improving failure detection by 25~pp and accuracy by 14~pp, with benefits extending to downstream applications.
+In self-improvement and online supervision, they boost task completion of a GUI specialist in OSWorld, a diffusion policy in robomimic, and a ReAct agent in VisualWebArena---surpassing the previous state of the art by 20~pp.
+As a byproduct, we release an updated version of VisualWebArena featuring strong agent baselines, more human-aligned oracles, environment parallelism with high fidelity and proper resets, runtime speedups exceeding 10×, and VisualWebArena-Lite, a 1/3-scale subset with comparable evaluation fidelity.
+Our code, models, and data are publicly available at \href{https://mshalimay.github.io/agreement-bias-sgv/}{our project page}.
+
+\end{abstract}
+
+
+\section{Introduction}
+\looseness-1
+Several breakthroughs in artificial intelligence can be viewed through the lens of search guided by verifiers---functions assigning rewards to agent behavior aligned with desired criteria.
+Notable examples include seminal work in Go~ and Chess~, where search and learning are guided by 0/1 rewards tied to the game's final outcome, and recent advancements in large reasoning models (LRMs), leveraging formal verifiers in code and math~.
+
+However, while domains such as math, code, and games benefit from relatively well-defined criteria to evaluate agent behavior, this clarity diminishes in open-ended settings.
+Evaluation in such scenarios often requires nuanced criteria and reasoning over possibly long sequences of multimodal inputs.
+For example, consider evaluating the trajectory in~\cref{fig:main_figure} (top) produced by a digital agent asked to ``add the least expensive opaque phone case to a shopping cart''.
+Should the agent sort products by price?
+Perform an advanced search?
+What is ``opaque enough''?
+Although humans can often recognize satisfactory outcomes, formalizing this intuition into precise and scalable rules remains a challenge.
+
+Multimodal Large Language Models (MLLMs) emerge as a promising solution to bridge this gap.
+With vast world knowledge, human-preference alignment, and large context windows, MLLMs hold the potential to serve as general-purpose verifiers, capable of handling inputs and producing rewards in multiple modalities.
+In this work, we probe this potential through a comprehensive study of MLLM-as-verifiers on open-ended tasks, spanning diverse environments, agent architectures, state-of-the-art MLLMs and LRMs, test-time scaling techniques, verifier designs, and evaluation metrics.
+We consider web, desktop, and robotic environments---VisualWebArena~, OSWorld~, and robomimic~---covering roughly 1,300 tasks across varied domains, where verification demands nuanced criteria and multimodal reasoning.
+
+We identify a systematic and critical limitation: a strong tendency for MLLMs to over-validate agent behavior, a phenomenon we call \textit{agreement bias}.
+As shown in \cref{fig:main_figure} (middle), an MLLM verifier validates flawed behavior and even generates chains-of-thought (CoT) to rationalize incorrect judgments.
+This bias limits MLLMs' ability to fulfill a core function of a verifier---identifying flawed behavior and providing feedback to improve performance---posing risks to methods that rely on MLLM-based evaluations.
+In particular, it can limit MLLMs' effectiveness as data curators for fine-tuning and self-improvement pipelines~; as providers of rewards for training, search, and agent steering~; and as judges~ and monitors~ of agent behavior, where failure detection is essential for balanced assessments and to prevent harmful outcomes.
+
+Notably, such failures occur despite MLLMs exhibiting human-aligned priors about desired behavior, suggesting a bottleneck in knowledge extraction---potentially rooted in fundamental limitations in pretraining~ and RLHF~---that remains unresolved by major test-time scaling techniques and training for reasoning.
+To address this, we propose Self-Grounded Verification (SGV), a simple yet effective method that harnesses MLLMs' own sampling mechanisms by modulating (un)conditional generation to better leverage their knowledge, alignment, and reasoning (\cref{fig:main_figure}, bottom).
+In SGV, the MLLM is first elicited to produce broad priors about desired behavior, conditioned on partial information about the trajectory under evaluation.
+Then, conditioned on self-generated priors, the model reasons over and evaluates a candidate trajectory.
+
+\looseness=-1
+To assess the benefits and limitations of MLLM-based verifiers, as well as the effectiveness of SGV, we evaluate performance across three representative settings: offline evaluation of agent performance and two downstream applications---online supervision and self-improvement via Reflexion.
+Our findings and contributions can be summarized as follows:
+
+\looseness=-1
+\begin{itemize}[leftmargin=*, itemsep=0pt, topsep=1pt, parsep=3pt, partopsep=0pt]
+ \item Agreement bias is pervasive across MLLMs and LRMs, manifesting as output distributions skewed toward favorable labels and failure-detection rates as low as 50\%. This bias persists across 28+ scoring templates, including techniques to mitigate biases in LLM judges. The bias holds for trajectories from both weak and strong agents built on models distinct from the verifier, grows with the capability gap between agent and verifier, and is exacerbated when verification is cast as binary success-or-failure classification. This imbalance in output distribution is resilient to test-time scaling and impairs the effectiveness of model calibration and mode-seeking techniques such as majority voting.
+
+ \item We clarify how several applications rely on rewards produced by MLLM-based verifiers, and are therefore sensitive to their quality. We show that agreement bias can impair agent performance benchmarking, behavior cloning, self-improvement, and online supervision.
+
+ \item Notably, these findings apply to a verifier with strong aggregate metrics (e.g., over 90\% recall) that sets a state of the art on concurrent reward benchmarks. We discuss key factors for evaluating verifiers, including the importance of fine-grained and downstream metrics, challenges due to leniency-strictness trade-offs, and confounders that can inflate numbers (e.g., simulator bugs, agent strength).
+
+ \item We discuss several design choices for building and evaluating MLLM-based verifiers, including the impact of Likert and score-based scales, trajectory length, agent strength, tools, model calibration, techniques to mitigate biases in LLM judges, and periodic vs. outcome-based verification.
+
+ \item Our methods yield gains of up to 25~pp in failure identification, 14~pp in accuracy, and more human-aligned evaluations across models and environments, with benefits to downstream applications.
+
+ \item In self-improvement, a stronger SGV-based verifier promotes gains of up to 10~pp (24\% relative) on VisualWebArena. In online supervision, it encourages agents to backtrack and avoid greedy strategies, yielding gains of 9~pp (20\%) for a ReAct agent on VisualWebArena, 5~pp (22\%) for the GUI-Specialist UI-TARS on OSWorld, and 8~pp (33\%) for a diffusion policy on robomimic's tool-hang task. Our agents set a \textbf{new state-of-the-art on VisualWebArena}, outperforming the previous best by 20 pp while incurring lower token overhead and only utilizing native web actions.
+
+
+ \item As a byproduct, we release an updated version of VisualWebArena featuring strong agent baselines, more human-aligned evaluators, high-fidelity environment parallelism, runtime speedups exceeding 10×, and VisualWebArena-Lite—a 1/3-scale subset with comparable evaluation fidelity.
+\end{itemize}
+
+
+\section{Problem Setup} \label{sec:method}
+\subsection{Preliminaries and Definitions}\label{sec:setup1}
+\looseness-1
+\textbf{Agents and Multimodal Verifiers.}
+Our goal is to study functions that approximate human judgment of agent behavior in interactive environments.
+Specifically, an agent is tasked to complete a task $q \in \mathcal{Q}$ through a series of actions $a_t$.
+Given a history of environment states $s_{p:t} \equiv [s_p, ..., s_t]$, the agent executes an action sampled from a policy $\pi$: $a_t = \pi(s_{p:t}, q)$, leading to a new state $s_{t+1}$.
+The repetition of this process yields a \textbf{trajectory} $\tau_{p:t} \equiv (s_p, a_p, \dots, s_t, a_t)$ that, along with the task $q$, serves as the basis for evaluating agent performance.
+To evaluate trajectory-task pairs $(q, \tau_{p:t})$, humans process and produce information in multiple modalities, motivating our definition of a verifier and the scope of tasks considered.
+We define a \textbf{multimodal verifier} as a function $r: \mathcal{T} \times \mathcal{Q} \to \mathbb{R} \times \left(\mathcal{V} \cup \{\emptyset\} \right), r \in \mathcal{R}$, that maps trajectory-task pairs to rewards consisting of a real-valued score and optional outputs in other modalities from $\mathcal{V}$.
+These multimodal aspects are reflected in our settings. A task $q$ can be represented as images, text, or both, states $s_t$ as screenshots or DOM trees, actions $a_t$ as text (e.g. <type opaque phone>) or images from URLs, and verifier outputs as 0/1 scalars or natural language.
+
+\looseness-1
+\textbf{Oracle Verifiers.}
+In the benchmarks we study, instantiations of $r$ are obtained via human-written scripts that have privileged access to task and environment states, which we refer to as \textbf{oracle} verifiers.
+They produce $0/1$ rewards reflecting task completion, which we treat as aligned with human judgments.
+These functions, however, are not perfect, and we discuss limitations in~\cref{sec:setup2,sec:offline-results}.
+
+\looseness-1
+
+\textbf{Applications of Verifiers.}
+To characterize the potential benefits and risks of MLLM verifiers, we unify the view of several applications by how they use $r$ and are therefore affected by its quality, categorizing them into \textit{offline} and \textit{online}.
+The \textit{offline} setting covers cases where $r$ is applied to trajectories post hoc.
+A canonical example is agent performance evaluation, where $r$ maps trajectories to scores reflecting task completion.
+Composite applications include methods that use $r$ to improve the agent's subsequent performance, such as filtering successful trajectories for finetuning~, as well as Reflexion-style refinement pipelines, where $r$ filters trajectories to induce prompts---e.g., memories, reflections~, and tools~---that are included in the agent's context in subsequent executions.
+The \textit{online} setting covers cases where $r$ influences policy distribution \textit{during} execution.
+Applications include online supervision, where $r$ maps trajectories to scalars or text rewards to steer agents toward task completion and possibly update policy parameters~, as well as using $r$ to rank state-action samples to guide (tree) search~.
+
+\subsection{MLLM Verifiers, Agreement Bias, and Self-Grounded Verification} \label{sec:setup2}
+Human and scripted evaluation for open-ended tasks is hard to scale, motivating the use of MLLMs as an alternative.
+The usual approach to obtain $r$ with an MLLM is to prompt it with the task $q$, trajectory $\tau_{p:t}$, and context $C$ that can include evaluation rubrics and instructions for reasoning steps:
+{\small
+\[
+r_{MLLM}(q, \tau_{p:t}, C) = h\bigl(\textstyle\prod_{i=1}^{n} P(y_i \mid y_{<i}, q,\tau_{p:t},C)\bigr)
+\]
+}
+where $y = y_1, \dots, y_n$ are MLLM outputs, and $h$ is a function mapping them to rewards---e.g., a regex that maps model completions to 0/1 scores or natural language feedback.
+
+However, this approach is subject to a failure mode we term \textbf{agreement bias} (\cref{fig:trajectory_bias,fig:permissive-oracle-bias-extreme,fig:trajectory_bias2}): a tendency to over-validate agent behavior, judging flawed trajectories as aligned with the task $q$ despite the use of carefully crafted instructions $C$, established test-time scaling techniques, and decoding algorithms.
+This bias degrades the quality of MLLM-based rewards, $r_{MLLM}$, and can negatively impact several applications that rely directly or indirectly on them (\cref{sec:setup1}).
+
+Notably, this bias occurs despite MLLMs exhibiting strong, human-aligned priors on desired behavior---e.g., first-step generations in \cref{fig:main_figure,fig:trajectory_bias}---that are not properly leveraged during verification, even utilizing techniques to elicit intermediate reasoning steps.
+These observations align with documented limitations of pretraining~ and RLHF~, in which knowledge extraction can be hindered by the way information is presented, and models may conflate truthfulness with human rater satisfaction.
+However, addressing these issues by modifying pretraining corpora, training recipes, or retraining large models remains both unclear and costly, highlighting the need for alternative solutions.
+
+\looseness-1
+Motivated by this, we propose \textbf{Self-Grounded Verification (SGV)} (\cref{fig:main_figure} (middle)), a simple yet effective method that substantially improves MLLM-based verification.
+First, the MLLM is elicited to extract broad priors $\hat{k}$ about desired behavior for task $q$, conditioned on partial information:
+{\small
+\[
+\hat{k}_{q, u:v}
+= g\bigl(\textstyle\prod_{i=1}^{n} P(y_i \mid y_{<i}, \tau_{u:v}, C, q)\bigr)
+\]
+}
+where $\tau_{u:v}$ is partial trajectory data needed to frame the verification (e.g., an initial screenshot) and $g$ is a function to select a completion.
+In the second step, the MLLM evaluates the trajectory conditioned on its own priors:
+{\small
+\[
+r_{\text{SGV}}(\tau_t, C, q)
+= h\bigl(\textstyle\prod_{i=1}^{n} P(y_i \mid y_{<i}, q, \tau_{p:t}, C, \boldsymbol{\hat{k}}_q)\bigr)
+\]
+}
+
+\looseness-1
+Intuitively, by modulating (un)conditional generation, SGV harnesses MLLMs' own sampling mechanisms to enable more effective use of their knowledge, alignment, and reasoning capabilities.
+Conditioning on less information in the first step encourages the model to explore its probability distribution more freely, extracting knowledge pertinent to the task at hand and independent of the data under evaluation.
+In the second step, the MLLM evaluates a candidate trajectory by sampling from a conditional distribution induced by its own priors.
+We hypothesize that MLLMs, given their extensive world knowledge and human-preference alignment, can produce effective priors that serve as impartial references for verification, yielding more balanced output distributions and better-calibrated judgments.
+
+In this paper, we obtain $\hat{k}_q$ from initial screenshots and task $q$. More generally, SGV can be applied multiple times, either to intermediate partial trajectories as the task progresses or by decomposing task $q$ into subtasks; we leave this exploration to future work.
+
+\subsection{Evaluating MLLM Verifiers}\label{sec:setup3}
+This section outlines several factors considered for a reliable assessment of MLLM verifiers and for empirically demonstrating agreement bias and validating our hypotheses.
+
+\textbf{Environment Diversity and Multimodality.}
+We consider benchmarks that require nuanced verification, multimodal reasoning, and collectively span a diverse range of tasks.
+VisualWebArena (VWA)~ emulates a web browser and spans 910 tasks, many of which combine text and image instructions (e.g., \textit{``Buy this product'' + <image>}).
+OSWorld~ emulates a computer and comprises 369 tasks involving widely used desktop applications across both single- and multi-application workflows.
+Finally, robomimic~ provides long-horizon robot manipulation tasks, and we focus on \textit{tool hang}, the most challenging among them, which consists of two subtasks: (1) inserting an L-shaped pencil into a base and (2) hanging a wrench on it.
+\cref{app:figs-task-examples} provides illustrations of representative tasks and trajectories.
+
+\textbf{Trajectory Annotations.}
+Similar to prior work~, we use benchmark--provided oracle verifiers as proxies for human judgment due to the high cost of large-scale annotation.
+However, we observed several issues with the oracles in VWA, an issue also noted in concurrent work~ comparing rule-based evaluation with human annotations.
+To establish a reliable reference, we corrected non-ambiguous issues in the VWA oracles---e.g., string parsing bugs, mismatches between task intents and oracle requirements, and incorrect annotations.
+To validate the effectiveness and impartiality of these changes, we evaluated the revised oracles on external labeled trajectories from~, observing near-perfect agreement with human judgments (\cref{tab:fixed_oracle}).
+For details about these and other refinements to (Visual)WebArena, see~\cref{app:vwa_details}.
+
+\looseness-1
+\textbf{Agents and Trajectory Quality.}
+Weak agents and buggy environments lead to trajectories that are trivial to verify and can artificially inflate verifier performance.
+For instance, some trajectories in~ exhibit long action loops, as well as ``page not found'' errors due to bugs in the browsergym~ suite.
+Moreover, incorporating trajectories generated by diverse methods is crucial to ensure the generalization of our findings.
+Therefore, we fixed several bugs in the (Visual)WebArena environments and considered agents built from different methods.
+To generate trajectories in VWA, we build a strong ReAct agent~ that yields a balanced ratio of successes and failures.
+For OSWorld, we employ the GUI-Specialist UI-TARS-1.5~, the best-performing agent on the benchmark at the time of this work.
+For robomimic, we train a diffusion policy on the expert demonstrations collected by~.
+
+\textbf{Choice of Verifier Applications.}
+MLLMs have been used to approximate $r$ in several of the applications discussed in \cref{sec:setup1}.
+While exploring this whole range is infeasible, we focus on three representative cases that can inform general applicability: offline evaluation of agent trajectories, self-refinement via Reflexion, and online supervision.
+These applications: (1) introduce fewer confounding factors; (2) are of direct practical interest and often serve as building blocks in larger pipelines; and (3) yield informative signals for broader applicability. For instance, if $r_{\text{MLLM}}$ produces many false positives in trajectory evaluation, finetuning on those trajectories is likely to be affected. Similarly, if $r_{\text{MLLM}}$ yields weak rewards for online supervision or Reflexion, it is likely to be suboptimal for online training and more complex Reflexion-style self-refinement pipelines.
+
+\textbf{Baselines and Ablations.}
+To probe limitations of MLLM verifiers and set strong baselines, we build verifiers with several methods, including chain-of-thought (CoT)~ and set-of-marks (SoM) prompting~, majority voting~, and reasoning models.
+For VWA, we also consider the approach from~, where we additionally provide benchmark-specific rubrics for evaluation.
+MLLMs are given full trajectories represented as sequences of screenshot-action pairs and asked to assign a ternary Likert label: \texttt{SUCCESS}, \texttt{PARTIAL SUCCESS}, or \texttt{FAILURE}, mapped to \texttt{[1, 0, 0]} to align with oracle scores.
+For reference,~\cref{tab:agrb_models} shows that our \textbf{baseline MLLM verifier} is already strong, achieving \textbf{state-of-the-art performance on AgentRewardBench}. \textbf{SGV further improves} upon that, surpassing even the original VisualWebArena oracles.
+\cref{app:ablations} ablates on all such choices, including model family and size, prompt/scoring templates, and SGV design and prior generation mechanism.
+
+\textbf{Quantitative Metrics.}
+Verifiers should negatively (positively) evaluate trajectories marked as failures (successes) by humans or proxies to them.
+Evaluations consistently biased toward either side are likely undesirable.
+To capture the degree of alignment in MLLM responses, we evaluate (1) bias, (2) distance skewness, and (3) true positive and true negative rates:
+{\footnotesize
+\setlength{\abovedisplayskip}{6pt}
+\setlength{\belowdisplayskip}{6pt}
+\[
+\text{bias} = \tfrac{1}{n}\textstyle\sum_{i}\mathbb{E}[d_i],
+\;
+\text{dSkew} = 1 - \frac{\sum_{ij}\lVert d_i-d_j\rVert}{\sum_{ij}\lVert d_i+d_j\rVert},
+\;
+\text{T?R}(c) = \frac{\sum_{i}\mathbf{1}(\hat r_i=c \wedge r_i^*=c)}{\sum_{i}\mathbf{1}(r_i^*=c)}
+\approx \hat P(\hat r_i=c\mid r_i^*=c),\; c\in\{0,1\}
+\]
+\noindent where $\hat r_i$ is the MLLM verifier reward, $r_i^*$ is the human or oracle reward, and $d_i = \hat r_i - r_i^*$.
+}
+
+Ultimately, a verifier should also be evaluated by its downstream impact: if its feedback is effective, agent performance should improve.
+Therefore, \textbf{for downstream applications}, we use \textbf{task completion rates (SR)} of base agents with and without verifier interventions as the primary metric.
+
+The following highlights key aspects regarding quantitative analysis of verifiers: \textbf{(1)} $bias$ and $dSkew$, also adopted by~, are summary statistics of the distribution of MLLM responses.
+Positive values indicate rewards systematically higher than those given by humans, whereas values near zero indicate closer alignment.
+\textbf{(2)} TNR measures how often MLLMs identify failures among trajectories marked as failures by humans, and is therefore an empirical estimate of the probability of classifying a trajectory as flawed when it truly is.
+Moreover, we use low TNR and high false-positive rate interchangeably, since {\footnotesize$TNR = 1 - False Positive Rate$} (analogous for TPR).
+\textbf{(3)} While we report multiple metrics for robustness, we emphasize the practical importance of statistics such as TPR and TNR, which directly relate to the core function of verifiers: identifying flawed behavior and providing feedback to improve agent performance.
+Low values indicate not only misalignment but also risks to downstream applications. \textbf{(4)} Accuracy (ACC) is included as an \textit{auxiliary} metric for interpretation and comparison, as it provides a summary of TPR-TNR trade-offs: {\footnotesize$ACC = (1 - \text{SR}) \cdot TNR + \text{SR} \cdot TPR$}.
+
+
+\section{Offline Evaluation of Agent Trajectories}\label{sec:offline-results}
+In this section we evaluate MLLM verification performance for about 1,300 trajectories generated in VisualWebArena (VWA) and OSWorld.
+Trajectories are based on \texttt{Gemini-2.5-Flash} in VWA and \texttt{UI-Tars-1.5} in OSWorld, with success rates of 47\% and 22\%, respectively.
+\cref{tab:abias-sgv,tab:tts-ablation} report performance across a range of models and test-time scaling techniques.
+\cref{app:exper_details,app:breakdowns-offline,app:ablations} provide breakdowns by environment and trajectory length, as well as other ablations.
+
+
+\looseness-1
+\textbf{Agreement Bias.} MLLMs display a strong tendency to over-validate agent behavior.
+This manifests as a high number of false positives (1-TNR), responses tilted toward favorable evaluations (strictly positive bias and skewness), and a low probability of flagging failures (TNR as low as 50\%).
+As shown in \cref{tab:tts-ablation}, this pattern persists despite techniques such as CoT and SoM (rows 3 and 4), majority voting (row 5), and the inclusion of task-specific evaluation criteria (row 6).
+\cref{fig:trajectory_bias,fig:permissive-oracle-bias-extreme,fig:permissive-oracle-bias} illustrate a reason behind this pattern: MLLMs generate reasoning that rationalizes flawed trajectories and their wrong judgments.
+Sampling fails to mitigate this issue and may even exacerbate it, as higher temperatures can increase the likelihood of hallucinations and spurious correlations.
+
+
+\looseness-1
+\cref{tab:resp-dist} further contextualizes results through the distribution of MLLM responses.
+The top panel shows distributions averaged across 28+ evaluation templates that incorporate commonly used bias-mitigation strategies, such as criteria-order randomization and label rephrasing (see \cref{app:ablation_templates_distribution} for details and all histograms).
+The bottom panel reports oracle--MLLM agreement rates over 10,000+ samples stratified by success and failure subsets, measuring the probability of sampling a correct verification from the MLLM output distribution.
+\cref{tab:resp-dist} (top) reveals that \textbf{(i)} MLLMs tend to concentrate responses in high score regions; \textbf{(ii)} binary scales (e.g., success/failure as adopted in~ and subsequent work) tend to amplify this bias (e.g., 72\% SR vs. 57\% expected); and \textbf{(iii)} increasing label granularity (as in our ternary Likert-scale) can partially mitigate this issue.
+\cref{tab:resp-dist} (bottom) shows that over-validation is reflected in the model's output distribution: on failure subsets, the probability of sampling a correct response from the MLLM is at or below chance (e.g., 48\% in VWA).
+This imbalance explains the ineffectiveness of methods like majority voting (that rely on the mode of the distribution), model calibration (\cref{app:platt_1}), and opens opportunities for test- and training-time methods that account for it during sampling (see \cref{app:platt_2} for a proof of concept).
+
+\textbf{Cross-Model Variations and Verification Difficulty.}
+Agreement bias arises even when verifiers and agents are built from different model families, sizes, and methods---in~\cref{tab:abias-sgv}, models such as GPT-4.1, and Qwen3 belong to distinct families and are stronger than the models used to build the agents.
+Likewise, it occurs for trajectories produced by weak and strong agents, as evidenced by the suboptimal performance in both OSWorld (22\% SR) and VWA (47\% SR)(\cref{tab:tts-ablation,tab:offline-osw,tab:offline-vwa}) and weaker agents in VWA (\cref{tab:weak-vs-strong}).
+It is, however, more severe when models are weaker (e.g., GPT-4.1-mini) and for trajectories generated by stronger agents.
+This suggests that closing the gap between agent and verifier capabilities can alleviate (though not eliminate) the issue, whereas strategies such as building verifiers with (ensembles of) models that differ from the agents are insufficient.
+
+\looseness-1
+\textbf{Adverse Impacts.}
+The bias toward over-validation means that MLLM verifiers fail precisely when most needed---when agent behavior is flawed and requires correction---with consequences extending beyond imprecise evaluation of agent performance.
+For example, for the task \textit{“Buy the cheapest <product> from <category> with <attribute>”}, a trajectory as in~\cref{fig:trajectory_bias} where the agent searches for \textit{``<product>''}, clicks the first result, and adds it to the cart, is deemed successful despite omitting steps such as filtering, sorting, and completing the checkout. \Cref{fig:permissive-oracle-bias-extreme} illustrates an even more extreme case: the agent produces an answer unsupported by any trajectory information, yet an MLLM verifier validates it---even though, by construction, no information exists to justify such a judgment.
+
+\looseness-1
+\textbf{Relation to Other Biases.} Agreement bias has distinct characteristics from other biases identified in LLM literature, such as ``self-bias''~---where models favor their own text generations and for which external knowledge injection is a typical remedy---and biases attributable to positional or phrasing dependencies in evaluation templates~.
+In our settings, agreement bias arises despite the verifier's inputs omitting text directly produced by agents, and including \textit{multimodal} inputs augmented with \textit{external} information derived from truthful environment data, such as screenshots augmented with Set-of-Marks, and low-level action representations enriched with DOM data.
+Likewise, it persists when agents and verifiers are built from different methods and models and despite interventions such as label shuffling and rephrasing, as well as access to grounding tools (\cref{tab:resp-dist,app:ablation_templates_distribution,app:websearch_noise_ablation}).
+
+\textbf{Effectiveness of SGV.} SGV improves verification across all metrics, models, and benchmarks, increasing TNR by up to 25 percentage points (pp), overall accuracy by up to 14pp, and promoting responses more aligned with human preferences.
+This is reflected in reduced bias and skewness, and in more balanced response distributions across 28+ evaluation templates (see \cref{tab:resp-dist}(top)), as well as in the models' output distribution (\cref{tab:resp-dist}(bottom)).
+These gains hold even in settings where the verifier is weaker than the generator (e.g., Gemini 2.0 and GPT-4.1-Mini; see also \cref{app:crossmodal_ablation}).
+Moreover, SGV outperforms instructions with task-specific evaluation criteria (\cref{tab:tts-ablation}, row 5), indicating it enables models to generate completions to condition themselves that can surpass human-written rubrics, offering a more scalable alternative.
+Finally, additional results in~\cref{app:websearch_noise_ablation} show that SGV outperforms grounding via web-search tools and is robust to moderate noise in priors generated in the first step; that weaker models can produce effective priors for stronger models and models of different families; and that multiple and diverse priors in the first step can further improve performance.
+
+\looseness-1
+Remarkably, SGV (i) enables non-reasoning models to match the performance of reasoning counterparts, and (ii) boosts the accuracy of reasoning models by up to 11pp---a perhaps surprising result, given that LRMs are explicitly trained to produce intermediate traces, and interventions can degrade performance~.
+These results align with intuitions about limitations stemming from earlier phases of LLM training, raising questions about the potential benefits of augmenting reasoning-oriented training with an SGV step, pretraining data rewriting~, or methods that account for imbalances in MLLMs' output distributions.
+
+\looseness-1
+\textbf{Fine-Grained Metrics.}
+These results highlight the importance of reporting fine-grained metrics in works proposing MLLMs in evaluative roles and artifacts produced by them.
+Given the trade-offs inherent to verification, it is crucial to report statistics capturing \textit{both} the probability of identifying correct behavior and especially, flawed behavior.
+Reporting only single or aggregate metrics can be misleading.
+As shown in~\cref{tab:abias-sgv,tab:tts-ablation}, verifiers can display about 97\% recall and 70\% accuracy, yet misclassify \textasciitilde 50\% of failed trajectories as successes, which can severely harm downstream applications.
+
+\textbf{Leniency-Strictness Trade-offs in Verification.}
+For some models, SGV can lead to a lower TPR.
+This pattern stems from two main causes: disagreements with lenient oracles on simplistic tasks and stricter verification.
+Specifically, evaluation in these digital benchmarks is based on hard-coded rules applied to a subset of states.
+This means that trajectories such as in~\cref{fig:permissive-oracle-bias} where an agent ``Buy the cheapest <product>,'' by searching for ``<product>,'' and purchasing the first result are deemed successful by oracle scripts.
+Influenced by agreement bias, MLLMs tend to validate such trajectories, but when SGV is applied, this behavior is rejected for lacking steps that confirm that the item is the cheapest, thereby reducing TPR.
+On the flip side,~\cref{fig:online-same} illustrates a case where SGV only validates an otherwise correct trajectory after the agent performs extra steps to double-check item attributes.
+
+These examples highlight the challenges of open-ended verification, as well as the potential and limits of MLLMs as alternatives.
+For humans, it is readily apparent that behaviors such as in~\cref{fig:permissive-oracle-bias} do not generalize.
+Yet, translating this intuition into precise rules is far from trivial: stricter criteria can reject valid solutions, whereas permissive ones may encourage brittle behavior.
+MLLMs, like humans, offer flexibility in interpretation, but this comes at the cost of formal guarantees and vulnerabilities---with agreement bias being a strong one.
+In the next section, we analyze the impact of these trade-offs on downstream applications and show that SGV interventions are typically non-disruptive (\cref{fig:online-same}), ultimately improving task completion through more generalizable behavior.
+
+
+\section{Downstream Applications} \label{sec:downstream-results}
+In this section, we evaluate MLLM verifiers on downstream applications, focusing on their ability to boost agent performance in self-improvement and online supervision.
+These are applications of direct interest that, so far, have shown limited benefits and occasional performance degradation~.
+Importantly, these experiments provide an assessment of verifiers' net impact, given the trade-offs discussed in~\cref{sec:offline-results}.
+Below we discuss main results; for experimental details and qualitative analysis, see~\cref{app:online_exper_details,app:qualitative_online}.
+
+
+\textbf{Self-Improvement}.
+In this setting, after each episode: (i) a verifier evaluates the trajectory; (ii) the agent reflects on its previous attempt conditioned on the verifier's evaluation; and (iii) reflections are given to the agent in subsequent attempts to enable self-correction over time.
+As shown in~\cref{fig:reflexion}, under oracle verifier supervision, task success rate (SR) increases by up to 21~pps after three iterations, confirming the feasibility and defining an upper bound for self-refinement.
+When supervised by the (strong) baseline MLLM verifier, the base agent's performance quickly plateaus, yielding minimal improvements, whereas SGV enables consistent progress, boosting SR by up to 10.4 pps.
+This pattern demonstrates how agreement bias limits the effectiveness of MLLM verifiers.
+Referring back to~\cref{sec:offline-results}, a TNR close to 50\% implies that the verifier fails to provide a corrective signal in about half of the cases where agent behavior is flawed, hindering its ability to self-improve.
+
+\textbf{Online Supervision}.
+Similarly, agreement bias impairs the effectiveness of MLLM-derived rewards for online methods.
+\cref{tab:vwa-online-results} shows that the (strong) baseline verifier fails to meaningfully improve digital agent performance.
+In contrast, SGV boosts SR by 9 percentage points (pp) on VisualWebArena (20\% relative) and by 5 pp on OSWorld (22\% relative).
+Notably, our agent sets a new \textbf{state of the art on VisualWebArena}, surpassing the previous best by 20 pp (58\% relative) while requiring substantially fewer tokens, no access to prior trajectories, and using only native web actions.
+
+\looseness-1
+A few factors explain these results.
+First, SGV identifies suboptimal behavior and provides feedback that enables agents to backtrack and complete the task (e.g.,~\cref{fig:online-improves}).
+Without SGV, agreement bias prevents verifiers from intervening precisely when agent behavior is flawed, limiting their effectiveness (e.g.,~\cref{fig:trajectory_bias}).
+Second, while SGV can lead to stricter verification, interventions are mostly non-disruptive.
+For example, in~\cref{fig:online-same} the verifier rejects a greedy strategy that technically satisfies the benchmark, prompting the agent to search for and confirm user-requested attributes, ultimately leading to task completion through a more robust approach. \cref{fig:transition-compare} quantifies this pattern: without SGV, the verifier endorses flawed behavior in 30\% of the tasks, offering no signal for improvement.
+With SGV, 10\% of tasks improve due to accurate failure detection, and among the 7.4\% of tasks marked as false negatives, 6.6\% remain successful, whereas only 0.8\% transition to failure.
+\looseness-1
+Likewise, robomimic results (\cref{tab:robomimic}) show that the baseline MLLM verifier is able to guide the policy to partial completion (high PSR). However, influenced by agreement bias, it struggles to further guide the policy toward full completion, as evidenced by the low number of replans and SR \textit{lower} than the baseline.
+In contrast, SGV triggers replans more often, improving over the baseline by 8~pp.
+For a categorization of factors influencing success rates and the impact of verifier design choices, see~\cref{app:qualitative_online,app:outcome-vs-process}.
+
+\looseness-1
+\textbf{Discussion}. These results illustrate the risks posed by agreement bias: MLLMs' tendency to over-validate agent behavior leads to unreliable evaluations precisely when most needed—when behavior is flawed and requires correction---limiting their effectiveness for trajectory selection and online feedback.
+Notably, this holds for an MLLM verifier with \textbf{strong} numbers in judging trajectories post-hoc: over 91\% recall (higher than SGV) and state-of-the-art performance (precision) on AgentRewardBench.
+This highlights the importance of evaluating verifier performance using (i) fine-grained metrics and (ii) downstream applications, as leniency–strictness trade-offs in verification can render post-hoc metrics insufficient to characterize a verifier's practical utility.
+
+
+\section{Conclusion, Limitations, and Future Work}\label{sec:conclusion}
+\looseness=-1
+We identify agreement bias, a critical limitation that hinders MLLMs from serving as verifiers of agent behavior. We demonstrate its adverse effects on existing applications, discuss methods for evaluating and improving MLLM-based verification, and introduce SGV, a simple yet effective method that improves verification across multiple models and environments.
+Although SGV mitigates agreement bias, it does not eliminate it.
+Our qualitative analysis (\cref{app:qualitative_bias}) indicates that remaining failures often stem from limitations in base models' integration of visual perception and language.
+Future work may explore methods to enhance these capabilities, such as integrating visual experts for fine-grained perception, potentially yielding gains complementary to SGV.
+In parallel, compelling directions for open-ended verification include combining MLLMs with symbolic methods~ and training- or test-time strategies that account for skewness in MLLM output distributions associated with agreement bias (\cref{app:platt}).
+Finally, an important question concerns \emph{when} to invoke a verifier and the relative value of process and outcome-based verification, particularly in digital environments where state spaces are often discrete, and actions can be irreversible or destructive (\cref{app:outcome-vs-process}).

benchmark_dataset/papers/ICLR2026_0001_2507.11662/source_references.tex

@@ -0,0 +1,292 @@
+@article{trabucco2025towards,
+  title={Towards Internet-Scale Training For Agents},
+  author={Trabucco, Brandon and Sigurdsson, Gunnar and Piramuthu, Robinson and Salakhutdinov, Ruslan},
+  journal={arXiv preprint arXiv:2502.06776},
+  year={2025}
+}
+
+@article{pan2024autonomous,
+  title={Autonomous evaluation and refinement of digital agents},
+  author={Pan, Jiayi and Zhang, Yichi and Tomlin, Nicholas and Zhou, Yifei and Levine, Sergey and Suhr, Alane},
+  journal={arXiv preprint arXiv:2404.06474},
+  year={2024}
+}
+
+@misc{ma2024visionlanguagemodelsincontext,
+      title={Vision Language Models are In-Context Value Learners}, 
+      author={Yecheng Jason Ma and Joey Hejna and Ayzaan Wahid and Chuyuan Fu and Dhruv Shah and Jacky Liang and Zhuo Xu and Sean Kirmani and Peng Xu and Danny Driess and Ted Xiao and Jonathan Tompson and Osbert Bastani and Dinesh Jayaraman and Wenhao Yu and Tingnan Zhang and Dorsa Sadigh and Fei Xia},
+      year={2024},
+      eprint={2411.04549},
+      archivePrefix={arXiv},
+      primaryClass={cs.RO},
+      url={https://arxiv.org/abs/2411.04549}, 
+}
+
+@misc{wang2024agentworkflowmemory,
+      title={Agent Workflow Memory}, 
+      author={Zora Zhiruo Wang and Jiayuan Mao and Daniel Fried and Graham Neubig},
+      year={2024},
+      eprint={2409.07429},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2409.07429}, 
+}
+
+@inproceedings{
+yu2025exact,
+title={Ex{ACT}: Teaching {AI} Agents to Explore with Reflective-{MCTS} and Exploratory Learning},
+author={Xiao Yu and Baolin Peng and Vineeth Vajipey and Hao Cheng and Michel Galley and Jianfeng Gao and Zhou Yu},
+booktitle={The Thirteenth International Conference on Learning Representations},
+year={2025},
+url={https://openreview.net/forum?id=GBIUbwW9D8}
+}
+
+@article{shinn2023reflexion,
+  title={Reflexion: Language agents with verbal reinforcement learning},
+  author={Shinn, Noah and Cassano, Federico and Gopinath, Ashwin and Narasimhan, Karthik and Yao, Shunyu},
+  journal={Advances in Neural Information Processing Systems},
+  volume={36},
+  pages={8634--8652},
+  year={2023}
+}
+
+@misc{sarch2025vlmagentsgeneratememories,
+      title={VLM Agents Generate Their Own Memories: Distilling Experience into Embodied Programs of Thought}, 
+      author={Gabriel Sarch and Lawrence Jang and Michael J. Tarr and William W. Cohen and Kenneth Marino and Katerina Fragkiadaki},
+      year={2025},
+      eprint={2406.14596},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2406.14596}, 
+}
+
+@article{pan2024webcanvas,
+  title={Webcanvas: Benchmarking web agents in online environments},
+  author={Pan, Yichen and Kong, Dehan and Zhou, Sida and Cui, Cheng and Leng, Yifei and Jiang, Bing and Liu, Hangyu and Shang, Yanyi and Zhou, Shuyan and Wu, Tongshuang and others},
+  journal={arXiv preprint arXiv:2406.12373},
+  year={2024}
+}
+
+@misc{koh2024treesearchlanguagemodel,
+      title={Tree Search for Language Model Agents}, 
+      author={Jing Yu Koh and Stephen McAleer and Daniel Fried and Ruslan Salakhutdinov},
+      year={2024},
+      eprint={2407.01476},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2407.01476}, 
+}
+
+@misc{yang2025agentoccamsimplestrongbaseline,
+      title={AgentOccam: A Simple Yet Strong Baseline for LLM-Based Web Agents}, 
+      author={Ke Yang and Yao Liu and Sapana Chaudhary and Rasool Fakoor and Pratik Chaudhari and George Karypis and Huzefa Rangwala},
+      year={2025},
+      eprint={2410.13825},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2410.13825}, 
+}
+
+@misc{sun2025mmverifyenhancingmultimodalreasoning,
+      title={MM-Verify: Enhancing Multimodal Reasoning with Chain-of-Thought Verification}, 
+      author={Linzhuang Sun and Hao Liang and Jingxuan Wei and Bihui Yu and Tianpeng Li and Fan Yang and Zenan Zhou and Wentao Zhang},
+      year={2025},
+      eprint={2502.13383},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2502.13383}, 
+}
+
+@article{koh2024visualwebarena,
+  title={Visualwebarena: Evaluating multimodal agents on realistic visual web tasks},
+  author={Koh, Jing Yu and Lo, Robert and Jang, Lawrence and Duvvur, Vikram and Lim, Ming Chong and Huang, Po-Yu and Neubig, Graham and Zhou, Shuyan and Salakhutdinov, Ruslan and Fried, Daniel},
+  journal={arXiv preprint arXiv:2401.13649},
+  year={2024}
+}
+
+@article{li2024effects,
+  title={On the Effects of Data Scale on Computer Control Agents},
+  author={Li, Wei and Bishop, William and Li, Alice and Rawles, Chris and Campbell-Ajala, Folawiyo and Tyamagundlu, Divya and Riva, Oriana},
+  journal={arXiv preprint arXiv:2406.03679},
+  year={2024}
+}
+
+@article{liu2023agentbench,
+  title={Agentbench: Evaluating llms as agents},
+  author={Liu, Xiao and Yu, Hao and Zhang, Hanchen and Xu, Yifan and Lei, Xuanyu and Lai, Hanyu and Gu, Yu and Ding, Hangliang and Men, Kaiwen and Yang, Kejuan and others},
+  journal={arXiv preprint arXiv:2308.03688},
+  year={2023}
+}
+
+@article{yu2024exact,
+  title={Exact: Teaching ai agents to explore with reflective-mcts and exploratory learning},
+  author={Yu, Xiao and Peng, Baolin and Vajipey, Vineeth and Cheng, Hao and Galley, Michel and Gao, Jianfeng and Yu, Zhou},
+  journal={arXiv preprint arXiv:2410.02052},
+  year={2024}
+}
+
+@article{koh2024tree,
+  title={Tree search for language model agents},
+  author={Koh, Jing Yu and McAleer, Stephen and Fried, Daniel and Salakhutdinov, Ruslan},
+  journal={arXiv preprint arXiv:2407.01476},
+  year={2024}
+}
+
+@article{zhou2023webarena,
+  title={Webarena: A realistic web environment for building autonomous agents},
+  author={Zhou, Shuyan and Xu, Frank F and Zhu, Hao and Zhou, Xuhui and Lo, Robert and Sridhar, Abishek and Cheng, Xianyi and Ou, Tianyue and Bisk, Yonatan and Fried, Daniel and others},
+  journal={arXiv preprint arXiv:2307.13854},
+  year={2023}
+}
+
+@misc{bai2024digirltraininginthewilddevicecontrol,
+      title={DigiRL: Training In-The-Wild Device-Control Agents with Autonomous Reinforcement Learning}, 
+      author={Hao Bai and Yifei Zhou and Mert Cemri and Jiayi Pan and Alane Suhr and Sergey Levine and Aviral Kumar},
+      year={2024},
+      eprint={2406.11896},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2406.11896}, 
+}
+
+@article{snell2024scaling,
+  title={Scaling llm test-time compute optimally can be more effective than scaling model parameters},
+  author={Snell, Charlie and Lee, Jaehoon and Xu, Kelvin and Kumar, Aviral},
+  journal={arXiv preprint arXiv:2408.03314},
+  year={2024}
+}
+
+@misc{welleck2024decodingmetagenerationinferencetimealgorithms,
+      title={From Decoding to Meta-Generation: Inference-time Algorithms for Large Language Models}, 
+      author={Sean Welleck and Amanda Bertsch and Matthew Finlayson and Hailey Schoelkopf and Alex Xie and Graham Neubig and Ilia Kulikov and Zaid Harchaoui},
+      year={2024},
+      eprint={2406.16838},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2406.16838}, 
+}
+
+@article{wei2022chain,
+  title={Chain-of-thought prompting elicits reasoning in large language models},
+  author={Wei, Jason and Wang, Xuezhi and Schuurmans, Dale and Bosma, Maarten and Xia, Fei and Chi, Ed and Le, Quoc V and Zhou, Denny and others},
+  journal={Advances in neural information processing systems},
+  volume={35},
+  pages={24824--24837},
+  year={2022}
+}
+
+@article{kojima2022large,
+  title={Large language models are zero-shot reasoners},
+  author={Kojima, Takeshi and Gu, Shixiang Shane and Reid, Machel and Matsuo, Yutaka and Iwasawa, Yusuke},
+  journal={Advances in neural information processing systems},
+  volume={35},
+  pages={22199--22213},
+  year={2022}
+}
+
+@article{zhang2023multimodal,
+  title={Multimodal chain-of-thought reasoning in language models},
+  author={Zhang, Zhuosheng and Zhang, Aston and Li, Mu and Zhao, Hai and Karypis, George and Smola, Alex},
+  journal={arXiv preprint arXiv:2302.00923},
+  year={2023}
+}
+
+@article{zawalski2024robotic,
+  title={Robotic control via embodied chain-of-thought reasoning},
+  author={Zawalski, Micha{\l} and Chen, William and Pertsch, Karl and Mees, Oier and Finn, Chelsea and Levine, Sergey},
+  journal={arXiv preprint arXiv:2407.08693},
+  year={2024}
+}
+
+@inproceedings{yao2023react,
+  title={React: Synergizing reasoning and acting in language models},
+  author={Yao, Shunyu and Zhao, Jeffrey and Yu, Dian and Du, Nan and Shafran, Izhak and Narasimhan, Karthik and Cao, Yuan},
+  booktitle={International Conference on Learning Representations (ICLR)},
+  year={2023}
+}
+
+@article{yao2023tree,
+  title={Tree of thoughts: Deliberate problem solving with large language models},
+  author={Yao, Shunyu and Yu, Dian and Zhao, Jeffrey and Shafran, Izhak and Griffiths, Tom and Cao, Yuan and Narasimhan, Karthik},
+  journal={Advances in neural information processing systems},
+  volume={36},
+  pages={11809--11822},
+  year={2023}
+}
+
+@misc{hao2023reasoninglanguagemodelplanning,
+      title={Reasoning with Language Model is Planning with World Model}, 
+      author={Shibo Hao and Yi Gu and Haodi Ma and Joshua Jiahua Hong and Zhen Wang and Daisy Zhe Wang and Zhiting Hu},
+      year={2023},
+      eprint={2305.14992},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2305.14992}, 
+}
+
+@article{wang2022self,
+  title={Self-consistency improves chain of thought reasoning in language models},
+  author={Wang, Xuezhi and Wei, Jason and Schuurmans, Dale and Le, Quoc and Chi, Ed and Narang, Sharan and Chowdhery, Aakanksha and Zhou, Denny},
+  journal={arXiv preprint arXiv:2203.11171},
+  year={2022}
+}
+
+@misc{shao2024deepseekmathpushinglimitsmathematical,
+      title={DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}, 
+      author={Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Xiao Bi and Haowei Zhang and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo},
+      year={2024},
+      eprint={2402.03300},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2402.03300}, 
+}
+
+@misc{lightman2023letsverifystepstep,
+      title={Let's Verify Step by Step}, 
+      author={Hunter Lightman and Vineet Kosaraju and Yura Burda and Harri Edwards and Bowen Baker and Teddy Lee and Jan Leike and John Schulman and Ilya Sutskever and Karl Cobbe},
+      year={2023},
+      eprint={2305.20050},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2305.20050}, 
+}
+
+@misc{deepseekai2025deepseekr1incentivizingreasoningcapability,
+      title={DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning}, 
+      author={{DeepSeek-AI}},
+      year={2025},
+      eprint={2501.12948},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2501.12948}, 
+}
+
+@misc{openai2024reasoning,
+  author       = {OpenAI},
+  title        = {Learning to reason with LLMs},
+  howpublished = {\url{https://openai.com/index/learning-to-reason-with-llms/}},
+  month        = sep,
+  year         = {2024},
+  note         = {Accessed: 2025-07-09}
+}
+
+@article{team2025kimi,
+  title={Kimi k1.5: Scaling reinforcement learning with llms},
+  author={{Kimi Team}},
+  journal={arXiv preprint arXiv:2501.12599},
+  year={2025}
+}
+
+@techreport{deepmind2025gemini2.5,
+  author       = {{Gemini Team}},
+  title        = {Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities},
+  institution  = {Google DeepMind},
+  type         = {Technical Report},
+  number       = {–},
+  address      = {Mountain View, CA},
+  month        = jun,
+  year         = {2025},
+  day          = {17},
+  howpublished = {\url{https://storage.googleapis.com/deepmind-media/gemini/gemini_v2_5_report.pdf}},
+  note         = {Accessed 9 July 2025}
+}

benchmark_dataset/papers/ICLR2026_0001_2507.11662/source_related_work.tex

@@ -0,0 +1,29 @@
+\section{Related Work} \label{sec:related}
+\looseness=-1
+\textbf{MLLMs as Evaluators.}
+(M)LLMs have been employed as evaluators of model outputs in various scenarios under various names---(M)LLMs as judges, critics, reward models, value functions.
+This work focuses on multimodal and environment-interaction scenarios.
+MLLMs have been used to score and filter agent trajectories for subsequent use in finetuning~, and test-time refinements such as to induce prompts, reflections, and tools~.
+They have also served as a source of real-time feedback by producing natural language ``critiques''~, scores to rank action proposals in search~, and rewards for training~.
+
+\looseness=-1
+\textbf{AI Agents.}
+There is growing interest in building AI agents to act in various environments, including the web~, mobile phones~, and computers~.
+In this field, the work most closely related to ours is~, which uses a GPT-4V-based evaluator, prompted with benchmark-specific rubrics, to evaluate trajectories for Reflexion~ and behavior cloning.
+Following works employ a similar evaluator to guide tree search~, filter trajectories to generate text-based memories or tools~ to boost agent performance in (Visual)WebArena~, and for RL training in simpler environments~.
+
+\looseness=-1
+\textbf{Test-time scaling} (TTS) is a major paradigm to improve model performance without increasing parameters~.
+Early work~ shows that prompting LLMs to generate ``chains-of-thought'' yields substantial gains in reasoning-oriented tasks.
+This idea has been extended to several settings, including multimodal~ and environment-interaction~.
+Orthogonal approaches scale test-time compute via sampling and search~, where multiple generations are selected through heuristics~ or verifiers~.
+Recent work leverages sampling, RL, and formal verifiers to train (M)LLMs that autonomously generate reasoning traces~.
+Extending these methods to open-ended problems requires flexible and multimodal verification, for which MLLMs offer an appealing solution.
+
+Compared to this body of work, we
+\textbf{(1)} consolidate disparate applications of MLLM evaluators under a shared framework based on multimodal rewards derived from MLLM verifiers.
+\textbf{(2)} Evaluate MLLM verifiers across a broader range of models, multimodal benchmarks, agents, TTS techniques, evaluation templates, and applications.
+\textbf{(3)} Dissect MLLM verifier performance over fine-grained metrics, offering guidance on how to measure the quality of their evaluations and artifacts derived from them.
+\textbf{(4)} Identify agreement bias, show its resilience to TTS techniques, and the risks it poses for downstream applications.
+\textbf{(5)} Discuss several design choices for building MLLM verifiers and introduce SGV, a lightweight method easy to integrate into pipelines involving MLLM verifiers.
+\textbf{(6)} Improve MLLM verification with benefits extending to downstream applications such as online supervision and self-improvement, achieving a new state of the art on VisualWebArena.

benchmark_dataset/papers/ICLR2026_0002_2507.21071/metadata.json

@@ -0,0 +1,75 @@
+{
+  "paper_id": "ICLR2026_0002_2507.21071",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "FingerTip 20K: A Benchmark for Proactive and Personalized Mobile LLM Agents",
+  "authors": [
+    "Qinglong Yang",
+    "Haoming Li",
+    "Haotian Zhao",
+    "Xiaokai Yan",
+    "Jingtao Ding",
+    "Fengli Xu",
+    "Yong Li"
+  ],
+  "domain_score": 28,
+  "domain_areas": [
+    "model_architecture",
+    "pretraining_posttraining_instruction_alignment",
+    "test_time_reasoning_compute",
+    "rag_agents_tools",
+    "multimodal",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "n3iFV0gLMc",
+  "openreview_forum": "n3iFV0gLMc",
+  "openreview_url": "https://openreview.net/forum?id=n3iFV0gLMc",
+  "arxiv_id": "2507.21071",
+  "arxiv_id_versioned": "2507.21071v2",
+  "arxiv_abs_url": "http://arxiv.org/abs/2507.21071v2",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2507.21071v2",
+  "arxiv_source_url": "https://arxiv.org/e-print/2507.21071",
+  "arxiv_title": "FingerTip 20K: A Benchmark for Proactive and Personalized Mobile LLM Agents",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-06-09T06:38:41Z",
+  "arxiv_updated": "2026-03-16T09:14:01Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 9,
+  "status": "ok",
+  "main_tex_original_path": "iclr2026_conference.tex",
+  "expanded_inputs_count": 8,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related work",
+  "related_citation_keys": [
+    "chai2024amex",
+    "li2024effects",
+    "rawles2023androidinthewild",
+    "rawles2024androidworld",
+    "xu2024androidlab",
+    "chai2025a3",
+    "ran2025beyond",
+    "chen2024spa",
+    "zhang2024llamatouch",
+    "lee2024benchmarking",
+    "xing2024understanding",
+    "yan2023gpt",
+    "he2024webvoyager",
+    "koh2024visualwebarena",
+    "kim2023language",
+    "zheng2023synapse",
+    "zhang2025appagent",
+    "wen2024autodroid",
+    "nakano2022webgpt",
+    "qin2025ui",
+    "hong2024cogagent",
+    "xu2024aguvis",
+    "gur2023real",
+    "wu2021ai",
+    "chen2020methodological",
+    "qian2024tell",
+    "lu2024proactive"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0002_2507.21071/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:071647c96de3c07667e0cc236251e4873a0a028be8ff499231286b5c132e1a01
+size 35695393

benchmark_dataset/papers/ICLR2026_0002_2507.21071/source.tex

@@ -0,0 +1,788 @@
+\documentclass{article}
+\usepackage{iclr2026_conference,times}
+
+
+\usepackage{amsmath,amsfonts,bm}
+
+\newcommand{\figleft}{{\em (Left)}}
+\newcommand{\figcenter}{{\em (Center)}}
+\newcommand{\figright}{{\em (Right)}}
+\newcommand{\figtop}{{\em (Top)}}
+\newcommand{\figbottom}{{\em (Bottom)}}
+\newcommand{\captiona}{{\em (a)}}
+\newcommand{\captionb}{{\em (b)}}
+\newcommand{\captionc}{{\em (c)}}
+\newcommand{\captiond}{{\em (d)}}
+
+\newcommand{\newterm}[1]{{\bf #1}}
+
+
+\def\figref#1{figure~\ref{#1}}
+\def\Figref#1{Figure~\ref{#1}}
+\def\twofigref#1#2{figures \ref{#1} and \ref{#2}}
+\def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}}
+\def\secref#1{section~\ref{#1}}
+\def\Secref#1{Section~\ref{#1}}
+\def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}}
+\def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}}
+\def\eqref#1{equation~\ref{#1}}
+\def\Eqref#1{Equation~\ref{#1}}
+\def\plaineqref#1{\ref{#1}}
+\def\chapref#1{chapter~\ref{#1}}
+\def\Chapref#1{Chapter~\ref{#1}}
+\def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}}
+\def\algref#1{algorithm~\ref{#1}}
+\def\Algref#1{Algorithm~\ref{#1}}
+\def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}}
+\def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}}
+\def\partref#1{part~\ref{#1}}
+\def\Partref#1{Part~\ref{#1}}
+\def\twopartref#1#2{parts \ref{#1} and \ref{#2}}
+
+\def\ceil#1{\lceil #1 \rceil}
+\def\floor#1{\lfloor #1 \rfloor}
+\def\1{\bm{1}}
+\newcommand{\train}{\mathcal{D}}
+\newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}}
+\newcommand{\test}{\mathcal{D_{\mathrm{test}}}}
+
+\def\eps{{\epsilon}}
+
+
+\def\reta{{\textnormal{$\eta$}}}
+\def\ra{{\textnormal{a}}}
+\def\rb{{\textnormal{b}}}
+\def\rc{{\textnormal{c}}}
+\def\rd{{\textnormal{d}}}
+\def\re{{\textnormal{e}}}
+\def\rf{{\textnormal{f}}}
+\def\rg{{\textnormal{g}}}
+\def\rh{{\textnormal{h}}}
+\def\ri{{\textnormal{i}}}
+\def\rj{{\textnormal{j}}}
+\def\rk{{\textnormal{k}}}
+\def\rl{{\textnormal{l}}}
+\def\rn{{\textnormal{n}}}
+\def\ro{{\textnormal{o}}}
+\def\rp{{\textnormal{p}}}
+\def\rq{{\textnormal{q}}}
+\def\rr{{\textnormal{r}}}
+\def\rs{{\textnormal{s}}}
+\def\rt{{\textnormal{t}}}
+\def\ru{{\textnormal{u}}}
+\def\rv{{\textnormal{v}}}
+\def\rw{{\textnormal{w}}}
+\def\rx{{\textnormal{x}}}
+\def\ry{{\textnormal{y}}}
+\def\rz{{\textnormal{z}}}
+
+\def\rvepsilon{{\mathbf{\epsilon}}}
+\def\rvtheta{{\mathbf{\theta}}}
+\def\rva{{\mathbf{a}}}
+\def\rvb{{\mathbf{b}}}
+\def\rvc{{\mathbf{c}}}
+\def\rvd{{\mathbf{d}}}
+\def\rve{{\mathbf{e}}}
+\def\rvf{{\mathbf{f}}}
+\def\rvg{{\mathbf{g}}}
+\def\rvh{{\mathbf{h}}}
+\def\rvu{{\mathbf{i}}}
+\def\rvj{{\mathbf{j}}}
+\def\rvk{{\mathbf{k}}}
+\def\rvl{{\mathbf{l}}}
+\def\rvm{{\mathbf{m}}}
+\def\rvn{{\mathbf{n}}}
+\def\rvo{{\mathbf{o}}}
+\def\rvp{{\mathbf{p}}}
+\def\rvq{{\mathbf{q}}}
+\def\rvr{{\mathbf{r}}}
+\def\rvs{{\mathbf{s}}}
+\def\rvt{{\mathbf{t}}}
+\def\rvu{{\mathbf{u}}}
+\def\rvv{{\mathbf{v}}}
+\def\rvw{{\mathbf{w}}}
+\def\rvx{{\mathbf{x}}}
+\def\rvy{{\mathbf{y}}}
+\def\rvz{{\mathbf{z}}}
+
+\def\erva{{\textnormal{a}}}
+\def\ervb{{\textnormal{b}}}
+\def\ervc{{\textnormal{c}}}
+\def\ervd{{\textnormal{d}}}
+\def\erve{{\textnormal{e}}}
+\def\ervf{{\textnormal{f}}}
+\def\ervg{{\textnormal{g}}}
+\def\ervh{{\textnormal{h}}}
+\def\ervi{{\textnormal{i}}}
+\def\ervj{{\textnormal{j}}}
+\def\ervk{{\textnormal{k}}}
+\def\ervl{{\textnormal{l}}}
+\def\ervm{{\textnormal{m}}}
+\def\ervn{{\textnormal{n}}}
+\def\ervo{{\textnormal{o}}}
+\def\ervp{{\textnormal{p}}}
+\def\ervq{{\textnormal{q}}}
+\def\ervr{{\textnormal{r}}}
+\def\ervs{{\textnormal{s}}}
+\def\ervt{{\textnormal{t}}}
+\def\ervu{{\textnormal{u}}}
+\def\ervv{{\textnormal{v}}}
+\def\ervw{{\textnormal{w}}}
+\def\ervx{{\textnormal{x}}}
+\def\ervy{{\textnormal{y}}}
+\def\ervz{{\textnormal{z}}}
+
+\def\rmA{{\mathbf{A}}}
+\def\rmB{{\mathbf{B}}}
+\def\rmC{{\mathbf{C}}}
+\def\rmD{{\mathbf{D}}}
+\def\rmE{{\mathbf{E}}}
+\def\rmF{{\mathbf{F}}}
+\def\rmG{{\mathbf{G}}}
+\def\rmH{{\mathbf{H}}}
+\def\rmI{{\mathbf{I}}}
+\def\rmJ{{\mathbf{J}}}
+\def\rmK{{\mathbf{K}}}
+\def\rmL{{\mathbf{L}}}
+\def\rmM{{\mathbf{M}}}
+\def\rmN{{\mathbf{N}}}
+\def\rmO{{\mathbf{O}}}
+\def\rmP{{\mathbf{P}}}
+\def\rmQ{{\mathbf{Q}}}
+\def\rmR{{\mathbf{R}}}
+\def\rmS{{\mathbf{S}}}
+\def\rmT{{\mathbf{T}}}
+\def\rmU{{\mathbf{U}}}
+\def\rmV{{\mathbf{V}}}
+\def\rmW{{\mathbf{W}}}
+\def\rmX{{\mathbf{X}}}
+\def\rmY{{\mathbf{Y}}}
+\def\rmZ{{\mathbf{Z}}}
+
+\def\ermA{{\textnormal{A}}}
+\def\ermB{{\textnormal{B}}}
+\def\ermC{{\textnormal{C}}}
+\def\ermD{{\textnormal{D}}}
+\def\ermE{{\textnormal{E}}}
+\def\ermF{{\textnormal{F}}}
+\def\ermG{{\textnormal{G}}}
+\def\ermH{{\textnormal{H}}}
+\def\ermI{{\textnormal{I}}}
+\def\ermJ{{\textnormal{J}}}
+\def\ermK{{\textnormal{K}}}
+\def\ermL{{\textnormal{L}}}
+\def\ermM{{\textnormal{M}}}
+\def\ermN{{\textnormal{N}}}
+\def\ermO{{\textnormal{O}}}
+\def\ermP{{\textnormal{P}}}
+\def\ermQ{{\textnormal{Q}}}
+\def\ermR{{\textnormal{R}}}
+\def\ermS{{\textnormal{S}}}
+\def\ermT{{\textnormal{T}}}
+\def\ermU{{\textnormal{U}}}
+\def\ermV{{\textnormal{V}}}
+\def\ermW{{\textnormal{W}}}
+\def\ermX{{\textnormal{X}}}
+\def\ermY{{\textnormal{Y}}}
+\def\ermZ{{\textnormal{Z}}}
+
+\def\vzero{{\bm{0}}}
+\def\vone{{\bm{1}}}
+\def\vmu{{\bm{\mu}}}
+\def\vtheta{{\bm{\theta}}}
+\def\va{{\bm{a}}}
+\def\vb{{\bm{b}}}
+\def\vc{{\bm{c}}}
+\def\vd{{\bm{d}}}
+\def\ve{{\bm{e}}}
+\def\vf{{\bm{f}}}
+\def\vg{{\bm{g}}}
+\def\vh{{\bm{h}}}
+\def\vi{{\bm{i}}}
+\def\vj{{\bm{j}}}
+\def\vk{{\bm{k}}}
+\def\vl{{\bm{l}}}
+\def\vm{{\bm{m}}}
+\def\vn{{\bm{n}}}
+\def\vo{{\bm{o}}}
+\def\vp{{\bm{p}}}
+\def\vq{{\bm{q}}}
+\def\vr{{\bm{r}}}
+\def\vs{{\bm{s}}}
+\def\vt{{\bm{t}}}
+\def\vu{{\bm{u}}}
+\def\vv{{\bm{v}}}
+\def\vw{{\bm{w}}}
+\def\vx{{\bm{x}}}
+\def\vy{{\bm{y}}}
+\def\vz{{\bm{z}}}
+
+\def\evalpha{{\alpha}}
+\def\evbeta{{\beta}}
+\def\evepsilon{{\epsilon}}
+\def\evlambda{{\lambda}}
+\def\evomega{{\omega}}
+\def\evmu{{\mu}}
+\def\evpsi{{\psi}}
+\def\evsigma{{\sigma}}
+\def\evtheta{{\theta}}
+\def\eva{{a}}
+\def\evb{{b}}
+\def\evc{{c}}
+\def\evd{{d}}
+\def\eve{{e}}
+\def\evf{{f}}
+\def\evg{{g}}
+\def\evh{{h}}
+\def\evi{{i}}
+\def\evj{{j}}
+\def\evk{{k}}
+\def\evl{{l}}
+\def\evm{{m}}
+\def\evn{{n}}
+\def\evo{{o}}
+\def\evp{{p}}
+\def\evq{{q}}
+\def\evr{{r}}
+\def\evs{{s}}
+\def\evt{{t}}
+\def\evu{{u}}
+\def\evv{{v}}
+\def\evw{{w}}
+\def\evx{{x}}
+\def\evy{{y}}
+\def\evz{{z}}
+
+\def\mA{{\bm{A}}}
+\def\mB{{\bm{B}}}
+\def\mC{{\bm{C}}}
+\def\mD{{\bm{D}}}
+\def\mE{{\bm{E}}}
+\def\mF{{\bm{F}}}
+\def\mG{{\bm{G}}}
+\def\mH{{\bm{H}}}
+\def\mI{{\bm{I}}}
+\def\mJ{{\bm{J}}}
+\def\mK{{\bm{K}}}
+\def\mL{{\bm{L}}}
+\def\mM{{\bm{M}}}
+\def\mN{{\bm{N}}}
+\def\mO{{\bm{O}}}
+\def\mP{{\bm{P}}}
+\def\mQ{{\bm{Q}}}
+\def\mR{{\bm{R}}}
+\def\mS{{\bm{S}}}
+\def\mT{{\bm{T}}}
+\def\mU{{\bm{U}}}
+\def\mV{{\bm{V}}}
+\def\mW{{\bm{W}}}
+\def\mX{{\bm{X}}}
+\def\mY{{\bm{Y}}}
+\def\mZ{{\bm{Z}}}
+\def\mBeta{{\bm{\beta}}}
+\def\mPhi{{\bm{\Phi}}}
+\def\mLambda{{\bm{\Lambda}}}
+\def\mSigma{{\bm{\Sigma}}}
+
+\DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl}
+\SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{n}
+\newcommand{\tens}[1]{\bm{\mathsfit{#1}}}
+\def\tA{{\tens{A}}}
+\def\tB{{\tens{B}}}
+\def\tC{{\tens{C}}}
+\def\tD{{\tens{D}}}
+\def\tE{{\tens{E}}}
+\def\tF{{\tens{F}}}
+\def\tG{{\tens{G}}}
+\def\tH{{\tens{H}}}
+\def\tI{{\tens{I}}}
+\def\tJ{{\tens{J}}}
+\def\tK{{\tens{K}}}
+\def\tL{{\tens{L}}}
+\def\tM{{\tens{M}}}
+\def\tN{{\tens{N}}}
+\def\tO{{\tens{O}}}
+\def\tP{{\tens{P}}}
+\def\tQ{{\tens{Q}}}
+\def\tR{{\tens{R}}}
+\def\tS{{\tens{S}}}
+\def\tT{{\tens{T}}}
+\def\tU{{\tens{U}}}
+\def\tV{{\tens{V}}}
+\def\tW{{\tens{W}}}
+\def\tX{{\tens{X}}}
+\def\tY{{\tens{Y}}}
+\def\tZ{{\tens{Z}}}
+
+
+\def\gA{{\mathcal{A}}}
+\def\gB{{\mathcal{B}}}
+\def\gC{{\mathcal{C}}}
+\def\gD{{\mathcal{D}}}
+\def\gE{{\mathcal{E}}}
+\def\gF{{\mathcal{F}}}
+\def\gG{{\mathcal{G}}}
+\def\gH{{\mathcal{H}}}
+\def\gI{{\mathcal{I}}}
+\def\gJ{{\mathcal{J}}}
+\def\gK{{\mathcal{K}}}
+\def\gL{{\mathcal{L}}}
+\def\gM{{\mathcal{M}}}
+\def\gN{{\mathcal{N}}}
+\def\gO{{\mathcal{O}}}
+\def\gP{{\mathcal{P}}}
+\def\gQ{{\mathcal{Q}}}
+\def\gR{{\mathcal{R}}}
+\def\gS{{\mathcal{S}}}
+\def\gT{{\mathcal{T}}}
+\def\gU{{\mathcal{U}}}
+\def\gV{{\mathcal{V}}}
+\def\gW{{\mathcal{W}}}
+\def\gX{{\mathcal{X}}}
+\def\gY{{\mathcal{Y}}}
+\def\gZ{{\mathcal{Z}}}
+
+\def\sA{{\mathbb{A}}}
+\def\sB{{\mathbb{B}}}
+\def\sC{{\mathbb{C}}}
+\def\sD{{\mathbb{D}}}
+\def\sF{{\mathbb{F}}}
+\def\sG{{\mathbb{G}}}
+\def\sH{{\mathbb{H}}}
+\def\sI{{\mathbb{I}}}
+\def\sJ{{\mathbb{J}}}
+\def\sK{{\mathbb{K}}}
+\def\sL{{\mathbb{L}}}
+\def\sM{{\mathbb{M}}}
+\def\sN{{\mathbb{N}}}
+\def\sO{{\mathbb{O}}}
+\def\sP{{\mathbb{P}}}
+\def\sQ{{\mathbb{Q}}}
+\def\sR{{\mathbb{R}}}
+\def\sS{{\mathbb{S}}}
+\def\sT{{\mathbb{T}}}
+\def\sU{{\mathbb{U}}}
+\def\sV{{\mathbb{V}}}
+\def\sW{{\mathbb{W}}}
+\def\sX{{\mathbb{X}}}
+\def\sY{{\mathbb{Y}}}
+\def\sZ{{\mathbb{Z}}}
+
+\def\emLambda{{\Lambda}}
+\def\emA{{A}}
+\def\emB{{B}}
+\def\emC{{C}}
+\def\emD{{D}}
+\def\emE{{E}}
+\def\emF{{F}}
+\def\emG{{G}}
+\def\emH{{H}}
+\def\emI{{I}}
+\def\emJ{{J}}
+\def\emK{{K}}
+\def\emL{{L}}
+\def\emM{{M}}
+\def\emN{{N}}
+\def\emO{{O}}
+\def\emP{{P}}
+\def\emQ{{Q}}
+\def\emR{{R}}
+\def\emS{{S}}
+\def\emT{{T}}
+\def\emU{{U}}
+\def\emV{{V}}
+\def\emW{{W}}
+\def\emX{{X}}
+\def\emY{{Y}}
+\def\emZ{{Z}}
+\def\emSigma{{\Sigma}}
+
+\newcommand{\etens}[1]{\mathsfit{#1}}
+\def\etLambda{{\etens{\Lambda}}}
+\def\etA{{\etens{A}}}
+\def\etB{{\etens{B}}}
+\def\etC{{\etens{C}}}
+\def\etD{{\etens{D}}}
+\def\etE{{\etens{E}}}
+\def\etF{{\etens{F}}}
+\def\etG{{\etens{G}}}
+\def\etH{{\etens{H}}}
+\def\etI{{\etens{I}}}
+\def\etJ{{\etens{J}}}
+\def\etK{{\etens{K}}}
+\def\etL{{\etens{L}}}
+\def\etM{{\etens{M}}}
+\def\etN{{\etens{N}}}
+\def\etO{{\etens{O}}}
+\def\etP{{\etens{P}}}
+\def\etQ{{\etens{Q}}}
+\def\etR{{\etens{R}}}
+\def\etS{{\etens{S}}}
+\def\etT{{\etens{T}}}
+\def\etU{{\etens{U}}}
+\def\etV{{\etens{V}}}
+\def\etW{{\etens{W}}}
+\def\etX{{\etens{X}}}
+\def\etY{{\etens{Y}}}
+\def\etZ{{\etens{Z}}}
+
+\newcommand{\pdata}{p_{\rm{data}}}
+\newcommand{\ptrain}{\hat{p}_{\rm{data}}}
+\newcommand{\Ptrain}{\hat{P}_{\rm{data}}}
+\newcommand{\pmodel}{p_{\rm{model}}}
+\newcommand{\Pmodel}{P_{\rm{model}}}
+\newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}}
+\newcommand{\pencode}{p_{\rm{encoder}}}
+\newcommand{\pdecode}{p_{\rm{decoder}}}
+\newcommand{\precons}{p_{\rm{reconstruct}}}
+
+\newcommand{\laplace}{\mathrm{Laplace}}
+
+\newcommand{\E}{\mathbb{E}}
+\newcommand{\Ls}{\mathcal{L}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\emp}{\tilde{p}}
+\newcommand{\lr}{\alpha}
+\newcommand{\reg}{\lambda}
+\newcommand{\rect}{\mathrm{rectifier}}
+\newcommand{\softmax}{\mathrm{softmax}}
+\newcommand{\sigmoid}{\sigma}
+\newcommand{\softplus}{\zeta}
+\newcommand{\KL}{D_{\mathrm{KL}}}
+\newcommand{\Var}{\mathrm{Var}}
+\newcommand{\standarderror}{\mathrm{SE}}
+\newcommand{\Cov}{\mathrm{Cov}}
+\newcommand{\normlzero}{L^0}
+\newcommand{\normlone}{L^1}
+\newcommand{\normltwo}{L^2}
+\newcommand{\normlp}{L^p}
+\newcommand{\normmax}{L^\infty}
+
+\newcommand{\parents}{Pa}
+
+\DeclareMathOperator*{\argmax}{arg\,max}
+\DeclareMathOperator*{\argmin}{arg\,min}
+
+\DeclareMathOperator{\sign}{sign}
+\DeclareMathOperator{\Tr}{Tr}
+\let\ab\allowbreak
+
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{url}
+\usepackage{booktabs}
+\usepackage{amsfonts}
+\usepackage{nicefrac}
+\usepackage{microtype}
+\usepackage{xcolor}
+\usepackage{amsmath}
+\usepackage{textgreek}
+\usepackage{multirow}
+\usepackage{graphicx}
+\usepackage{subcaption}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{arydshln}
+\usepackage{float}
+\usepackage{listings}
+\usepackage[most]{tcolorbox}
+\usepackage{cases}
+\usepackage{lipsum}
+\usepackage{arydshln}
+\usepackage{titlesec}
+\usepackage[table]{xcolor}
+\usepackage{amssymb}
+\usepackage{pifont}
+
+\usepackage{listings}
+\usepackage{xcolor}
+\lstdefinestyle{promptbox}{
+ basicstyle=\ttfamily\small,
+ breaklines=true,
+ columns=fullflexible,
+ backgroundcolor=\color{gray!10},
+ frame=single,
+ rulecolor=\color{gray!70},
+ showstringspaces=false
+ basewidth=0.5em,
+ breakindent=0pt,
+ xleftmargin=0pt,
+ framexleftmargin=0pt
+}
+
+\newcommand{\gcheck}{{\color{green}\ding{51}}}
+\newcommand{\rcross}{{\color{red}\ding{55}}}
+
+\renewcommand{\thefootnote}{\fnsymbol{footnote}}
+
+\newcommand{\fix}{\marginpar{FIX}}
+\newcommand{\new}{\marginpar{NEW}}
+
+\iclrfinalcopy
+\begin{document}
+
+
+\begin{abstract}
+
+Mobile GUI agents are becoming critical tools to improve user experience on smart devices, with multimodal large language models (MLLMs) emerging as the dominant paradigms in this domain. Current agents, however, rely on explicit human instructions, overlooking the potential to leverage the contextual information (like location, time, user profile) and historical data for proactive task suggestions. Besides, previous works focus on optimizing the success rate during task execution, but pay less attention to the personalized execution trajectory, thereby neglecting potentially vast differences in user preferences. To address these challenges, we introduce the FingerTip 20K benchmark. We collected 20K unique human demonstrations of multi-step Android device interactions across a variety of everyday apps. These demonstrations are not isolated but are continuously acquired from the users' long-term usage in their real lives, and encompass essential user-related contextual information. The benchmark contains two new tracks: proactive task suggestions by analyzing environment observation and users' previous intents, and personalized task execution by catering to users' action preferences. Our experiments reveal that the tracks we propose pose significant challenges for leveraging user-related information in GUI tasks. We also performed a human study to show that there exists a huge gap between existing agents and humans. The model fine-tuned with the data we collected effectively utilized user information and achieved good results, highlighting the potential of our approach in building more user-oriented mobile LLM agents. Our code is open-source at \url{https://github.com/tsinghua-fib-lab/FingerTip-20K} for reproducibility.
+
+\end{abstract}
+
+\footnotetext[1]{Corresponding authors.}
+
+
+\section{Introduction}
+\label{introduction}
+
+
+Recent studies have explored how to utilize multimodal large language models (MLLMs) to build graphical user interface (GUI) control agents~, with a significant direction being mobile phone GUI control agents. These mobile LLM agents have the potential to tremendously improve user experience with mobile devices, since GUI is a universal interface across various applications. These agents receive a natural language task instruction, such as "Set an alarm for 7:30 for me", and then perceive the device state by observing the device screen (via screenshots or textual UI trees), and generate actions (click, type, scroll, etc.) to interact with the device environment to fulfill human instructions.
+
+
+Despite rapid progress, currently, most existing mobile LLM agents are confined to a completely passive paradigm: they only perform tasks upon receiving a clear instruction. This paradigm restricts their ability to proactively offer task suggestions and assistance in the absence of direct human instructions. If users have to formulate detailed instructions for every intent when interacting with mobile LLM agents, it will significantly increase the cognitive burden of mobile phone usage. Moreover, humans sometimes may not clearly express some latent needs. Therefore, mobile LLM agents need to be more proactive to provide users with more comprehensive and seamless services. Furthermore, the existing agents utilize almost exclusively user instructions as textual information when performing tasks, without taking into account any additional user-related information (e.g., time and location, user profile, user historical intents and actions), thus failing to provide personalized services to users. We argue that these limitations stem largely from the lack of suitable training data and standardized evaluation benchmarks that incorporate rich user-related information.
+
+
+To comprehensively evaluate the proactive and personalized capabilities of mobile LLM agents, we propose the FingerTip 20K benchmark, which includes two new tracks: (i) proactive task suggestion, where the agent needs to integrate the user's past intents and the current environmental state to infer the user's potential current intent; (ii) personalized task execution, where the agent needs to refer to the user's past action preferences to execute current instructions. The overall task scenario we envision is shown in Figure~\ref{Fig1}. Since existing benchmarks do not provide user-related contextual information and historical data, we spent over one month collecting new diverse data from 95 users in their daily mobile phone usage, including 21,437 episodes covering 506 apps. We then conducted experiments on the FingerTip 20K benchmark to evaluate the capabilities of generalist models and GUI-control agents built on specifically designed models and found that there is still much room for improvement in their proactive and personalized capabilities. Current agents still find it hard to reach or surpass the human level. The best-performing model achieved a success rate of 12.8\%, while humans reached 30.3\%. We fine-tuned a small model using the collected data and achieved better results.
+
+
+In summary, the main contributions of this work include:
+\begin{itemize}
+ \item We propose the FingerTip 20K benchmark, which includes two brand-new tracks, to evaluate the ability of mobile LLM agents to proactively predict user intents and offer suggestions, as well as their ability to personalize task execution in accordance with user preferences.
+ \item We collect large-scale user-oriented mobile GUI-control data, derived from scenarios in users' daily lives, which includes user-related contextual information and users' long-term mobile phone usage patterns.
+ \item We evaluated the capabilities of generalist models and GUI-control-specific models on the FingerTip 20K benchmark, demonstrating the difficulty of the tracks we propose. The excellent performance of the model fine-tuned with our collected data highlights the potential of our approach in building more proactive and personalized mobile agents.
+\end{itemize}
+
+
+\section{Problem formulation}
+\subsection{Proactive task suggestion}
+\label{Proactive task suggestion}
+
+
+In the FingerTip 20K benchmark we propose, unlike the evaluation tasks of traditional mobile LLM agent benchmarks that rely entirely on explicit instructions, we introduce a new task where the agent proactively predicts the user's current intent and proposes tasks suggestion that the user might want to perform, as shown in Figure~\ref{Fig2}. The agent's task is to generate an intent prediction $I$ based on the user profile $U$, the current time $T$, the current scenario $S$, the user's historical intents $I_{\text{history}}$, and the partial screenshots $O$ observed at present. This can be formalized as:
+\begin{equation}
+ \ I=f\ (U,\ T,\ S,\ I_{\text{history}},\ O)
+\end{equation}
+where $f$ represents the agent. $I$ is a sentence that unambiguously predicts the intent of the user. It should clearly state the name of the app that the user wants to use, and the final effect that the user wants to achieve. $U$ includes common user attributes such as age, sex, occupation, etc. $T$ represents the current timestamp, accurate to the second. $S$ represents the current scenario, expressed in common location categories. $I_{\text{history}}$ contains the user's historical intents in the recent period, up to 20 items, which may include the potential patterns and preferences of the user's mobile phone usage. $O$ includes the first few screenshots of the user's current actions (e.g., opening the home page of a certain app). We hope that the agent can utilize the above-mentioned user-related contextual information and historical intents to infer the user's potential intents, and thereby proactively offer helpful task suggestions.
+
+
+\subsection{Personalized task execution}
+\label{Personalized task execution}
+
+In addition to proactive task suggestion, we also aim to evaluate the agent's ability to carry out tasks under the condition of explicit instructions, that is, when the user's intent is known. The setting of this part is similar to the existing benchmarks. The difference lies in that we additionally assess the agent's ability to execute tasks in a personalized manner specifically catering to the action preferences of different users. Given user profile $U$, user intent $I_{\text{true}}$, user's historical actions $A_{\text{history}}$, agent's action sequence $A_{\text{agent}}$, and the current screenshot $O_t$ and the corresponding accessibility tree $AT_t$, the agent needs to perform the next action $A_{t+1}$, and then observe $O_{t+1}$ and $AT_{t+1}$. This can be formalized as:
+\begin{equation}
+ \ A_{t+1},\ O_{t+1},\ AT_{t+1}=f\ (U,\ I_{\text{true}},\ A_{\text{history}},\ A_{\text{agent}},\ O_t,\ AT_t)
+\end{equation}
+where $f$ represents the agent. $I_{\text{true}}$ is equivalent to the user's true intent that needs to be predicted in proactive task suggestion, and here it serves as the instruction to be executed. $A_{\text{history}}$ is the complete action sequence of the user when performing a similar task in the past, provided to the agent for in-context learning to imitate the user's action preferences. $A_{\text{agent}}$, on the other hand, is the action sequence $\{A_1,...,A_t\}$ that the agent has already executed in the current task, helping the agent determine the progress of the task. The agent needs to constantly interact with the mobile phone environment until it believes that $I_{\text{true}}$ has been fulfilled. We hope that the final sequence of agent actions $A_{\text{agent}}$ can reflect the user's action preferences.
+
+
+\section{The FingerTip 20K benchmark}
+\subsection{Overview}
+The motivation for FingerTip 20K data collection is to evaluate the dual tracks we have proposed, namely proactive task suggestion and personalized task execution. To this end, the most distinctive feature of the data should be user-oriented, containing sufficient user-related contextual information and being able to reflect the patterns and preferences of users in terms of intents and actions.
+
+
+\subsection{Data collection}
+\label{Data collection}
+The data collection pipeline is shown in Figure~\ref{Fig3}. We first recruited 95 data collectors (hereinafter referred to as users) using Android phones through crowdsourcing, covering a wide range of device types and Android versions. Users were required to download an APP developed by us on their own daily used phones and use it to collect data. Specifically, whenever users had a real intent to use their phones in their daily lives, they could open the FingerTip APP, record their intent at that moment in one sentence, and select the location category they were in. Then, users needed to switch to the app involved in the intent they recorded and demonstrate the specific action sequence to complete this intent.
+
+The FingerTip APP will automatically upload the intent they fill in (including time and location) and the demonstration process they provide (including screenshot sequences, corresponding accessibility tree XML file sequences, and UI action sequences) to the cloud server. This is regarded as the user collecting one piece of data. The APP may remind the user to collect data when they wake up the phone screen to prevent them from forgetting. Each user is required to use their phone to collect data for one month, with a maximum of 12 pieces of data uploaded per day. In this way, users can fully customize the data they upload. See Appendix~\ref{datacollect} and~\ref{dataformat} for more details on data collection and data format.
+
+FingerTip APP is developed based on the accessibility features of the Android system. It can automatically record the type and coordinates, as well as optional text descriptions of each user action. The actions we collect are unified into an action space, as shown in Table~\ref{Table2}. Among them, $finish$ is uniformly added to the last screenshot of all episodes.
+
+
+\subsection{Data statistics}
+\label{ranking}
+The summary of data statistics is presented in Table~\ref{Table1}. Additionally, Figure~\ref{Fig4} reports the distribution of user intent length, episode length, intent categories, and app name in all data. The intent categories are determined by DeepSeek-V3~.
+
+
+\subsection{Personalized action analysis}
+\label{Personalized action analysis}
+
+
+To verify the personalized differences in actions among users of different types, we first simply classified users into different categories based on age groups. Then, we randomly sampled one piece of data from each of the 40 intent categories. For the action sequence of such a piece of data, we calculated the Levenshtein similarity with the action sequence of the most intent-similar data from (i) the same user, (ii) users of the same type, and (iii) users of different type. All similarities were normalized to [0, 100] and plotted in Figure~\ref{Fig5}. It can be seen that even when performing similar intents, the similarity of action sequences with users of different type is significantly lower than that of the same user or users of the same type, indicating that user preferences on action sequences do exist and are measurable.
+
+
+\section{Experiments}
+
+We conducted experiments on some generalist models and some GUI-control agents built on specifically designed models, evaluating their capabilities on the two tracks proposed in the FingerTip 20K benchmark and assessing their performance under different task difficulties. Additionally, we fine-tuned a model using the collected data. For details on the data splits (including the training set, validation set, and two test sets), please refer to Appendix~\ref{datasplits}.
+
+
+\subsection{Experimental setup}
+\label{baseline}
+\paragraph{Proactive task suggestion}
+The LLMs we experiment with in this track include GPT-4.1, Qwen-VL-Max, DeepSeek-VL2~ and Qwen-2.5-VL-7B~. We also introduce Qwen-2.5-VL-72B~ to compare with the 7B version; and Qwen-QVQ-Max (thinking model) to compare with other non-thinking models. We set the temperature to zero for all models. For proactive task suggestion, the agent only needs one query to output the predicted intent. Since this is a brand new track proposed in our benchmark, there is no mature agent design available for direct use. We have designed a simple prompt to provide to all models evaluated in this track. This prompt contains all necessary inputs (see Section~\ref{Proactive task suggestion} and Appendix~\ref{prompt1}).
+
+\paragraph{Personalized task execution}
+In this track, in addition to the generalist models mentioned above, we also experiment with three GUI-control agents built on specifically designed models, including Aguvis-7B~, CogAgent-9B~ and UI-TARS-1.5-7B~. We also introduce AutoDroid~ and AppAgent~, two GUI-control agents based on prompt engineering (using GPT4.1 as the base model). For personalized task execution, the agent needs to interact with the environment in multiple steps to fulfill the user's instructions. We connect a physical phone to the computer via USB and use Android Debug Bridge (ADB) to provide this environment. Using an emulator would be a more convenient approach, but due to strict app control measures, most Chinese apps can only run on physical phones rather than emulators. For the generalist models, we designed a simple prompt to guide their output of the next action, with the action space consistent with Table~\ref{Table2}. This prompt contains all necessary inputs (see Section~\ref{Personalized task execution} and Appendix~\ref{prompt2}). For the GUI-control agents, they have specific format requirements for input and output. To ensure normal output effects, their original prompts were used, and the input information in Section~\ref{Personalized task execution} was uniformly integrated into these original prompts. Their output was converted into a form consistent with the action space.
+
+\paragraph{Metrics}
+In proactive task suggestion track, the goal of the agent is to maximize the textual similarity between the output and the user's true intent. We use a pre-trained model, paraphrase-multilingual-MiniLM-L12-v2~, to convert the agent's output and the user's true intent into embedding vectors and calculate their cosine similarity $S_1$. And, we calculate the Levenshtein similarity $S_2$ of these two strings. Both similarities are normalized to the range of [0, 1]. Finally, we take $Sim_1=(S_1+S_2)/2$ to comprehensively represent the text similarity. In addition to this numerical metric, we also use DeepSeek-V3~ to directly determine whether the agent's output and the user's true intent can be regarded as the same intent and provide a binary value to evaluate whether the agent successfully predicted the user's intent, thereby calculating the success rate $SR_1$.
+
+In personalized task execution track, the primary goal of the agent is to execute user instructions in a personalized manner. We calculate the final success rate $SR_2$ by manually checking whether the environment state when the agent outputs $finished()$ matches the user's instructions. In addition, when the agent steps exceed 2.5 times the golden steps, the task is automatically considered a failure. Note that the path to successfully execute the user's instructions is not unique. The agent should also make the action sequence reflect the user's action preferences as much as possible. We do not require the agent's action at each step to be exactly the same as the user's golden action. Instead, we calculate the Levenshtein similarity $S_I$ of the agent's complete action sequence and the user's complete action sequence as two strings. Then, following the approach in Section~\ref{Personalized action analysis}, we take the data that is most similar to the current user's intent from the users of different type, and calculate the Levenshtein similarity $S_{\text{II}}$ of the agent's complete action sequence and this data's complete action sequence. Finally, we take the value $Sim_2=S_I/S_{\text{II}}$. It is obvious that the larger this value is, the more similar the agent's action sequence is to that of the current user, and the more different it is from that of users of different type. In addition, we measure execution efficiency by comparing the agent steps with the user's golden steps to calculate the step ratio when the agent successfully execute the user's instructions. For the two tracks, we also tallied the average time and token count consumed per query to assess the model's cost.
+
+\subsection{Overall performance}
+\label{Overall Performance}
+
+The overall performance of the models we evaluated in proactive task suggestion is shown in Table~\ref{Table4}. Note that here we set the number of $O$ (the first few screenshots of the user's current actions) to 0. This makes the task quite challenging. The thinking model Qwen-QVQ-Max surpassed GPT-4.1, achieving the best performance among the generalist models with $SR_1=12.8$ and $Sim_1=0.39$, but also took the longest time and the most tokens. From $SR_1$, it can be intuitively seen that the success rate of all models in predicting the user's intent is very low. Additionally, we conducted a user study where 20 human annotators (distinct from the users who collected the data) labeled a subset of the test set (a total of 400 episodes), achieving a success rate of 30.3\%. This highlights the significant gap between the existing models and human in proactive task suggestion capabilities.
+
+
+The overall performance of the models we evaluated in personalized task execution is shown in Table~\ref{Table5}. Qwen-QVQ-Max and UI-TARS-1.5-7B achieved the best performance among the generalist models and GUI-control models respectively. AppAgent achieved the best performance among all models in $Sim_2$ and step ratio, possibly due to its proficiency in learning from human demonstrations, but time and token costs also increased significantly. The $SR_2$ of the generalist models were all very low, mainly due to their lack of precise GUI grounding ability, which led to incorrect UI coordinates being output even when they could correctly analyze the next action, thus failing to interact with the environment accurately. In contrast, the GUI-control models, having undergone targeted training, had stronger abilities to execute instructions and interact with the UI environment, resulting in higher $SR_2$, with UI-TARS-1.5-7B having the highest at 38.5. However, the $Sim_2$ of all models were approximately 1, indicating that the agent's action sequence did not favor either the current user or users of different type. This might suggest that the agent tends to complete tasks in a general way without catering to the specific action preferences of users, thus failing to complete tasks in a personalized manner.
+
+
+\subsection{Effect of task difficulty}
+
+
+We experiment with the models' performance under different task difficulty levels. For proactive task suggestion (see Figure~\ref{Fig6}.a), we varied the number of $O$ (the first few screenshots of the user's current actions). The $SR_1$ of all models increased as the number of screenshots increased. This was expected. Clearly, if the agent knew the first screenshot of the user's current action, it could basically infer which app the user was using, thereby significantly narrowing the range of the user's intent. With the second and third screenshots, the agent could further narrow the user's intent range by analyzing the actions therein (e.g. clicking the search box).
+
+For personalized task execution (see Figure~\ref{Fig6}.b), we calculated the $SR_2$ of GUI-control models on different subsets of action length (i.e., the number of action steps) in the test set. It can be seen that as the action length increases, the $SR_2$ decreases. This is in line with expectations, as the greater the action length required to complete a certain instruction, the more complex the instruction is, and the more difficult it is to complete.
+
+
+\subsection{Effect of fine-tuning}
+\label{fine-tuning}
+
+
+We fine-tuned Qwen-2.5-VL-7B and adopted the parameter-efficient fine-tuning method of LoRA, with the LoRA rank set to 4 or 64. Following the method of sampling the test set, we randomly sampled 1,000 data episodes from the training set for fine-tuning. These data covered all users, and the proportion of data for each user was the same as their proportion in the training set. We also used the complete training set (16,000 episodes) for fine-tuning. The data episodes were reorganized according to the input and output formats of the two tracks, respectively. The prompts used in fine-tuning are the same as those we designed for generalist models. Finally, we trained separately on two tracks and obtained two fine-tuned models, each suitable for one of the two tracks.
+
+
+The performance of fine-tuned models on the two tracks is shown in Table~\ref{Table6}. Despite using a smaller model and less training data, the fine-tuned models achieved significant performance improvements in all main metrics. Increasing the LoRA rank or the amount of training data both improve the model's performance, with the increase in training data having a particularly significant effect. In proactive task suggestion, compared with the best-performing generalist model Qwen-QVQ-Max, our fine-tuned models achieved better performance in both $SR_1$ and $Sim_1$. In personalized task execution, compared with the best-performing UI-TARS-1.5-7B, our fine-tuned models had a lower success rate $SR_2$. We consider this acceptable because UI-TARS is a model specifically designed and extensively trained for GUI grounding and GUI control, and thus has a more general instruction execution capability. However, our fine-tuned models had a significantly higher $Sim_2$, indicating that the action paths they select may not be optimal but are closer to the user's action preferences. When trained on the entire training set with a LoRA rank of 64, Qwen-2.5-VL-7B outperforms all the un-fine-tuned models in the experiment in terms of $SR_1$, $Sim_1$, and $Sim_2$, achieving the best performance. Overall, the models fine-tuned on our collected data demonstrated stronger proactivity and personalization capabilities, being able to utilize user-related contextual information to extract potential intent patterns and action preferences from the user's past intents and actions, which existing models have not or find it difficult to consider.
+
+\paragraph{More experiments}
+In Appendix~\ref{moreexperiment} we conducted more experiments to study the influence of other factors.
+
+
+\section{Conclusions}
+\label{conclusion}
+We present FingerTip 20K, a benchmark advancing mobile LLM agents toward proactive task suggestion and personalized task execution. Our data captures longitudinal user interactions, enriched with contextual information to model user-specific patterns. Experiments reveal significant gaps in existing models’ ability to mine such patterns. Fine-tuning Qwen-2.5-VL-7B on our data improved suggestion success rate while better aligning actions with user preferences, demonstrating the value of user-oriented training. This work establishes critical infrastructure for developing mobile agents that anticipate user needs and adapt to user action preferences.
+
+
+\section{Ethics statement}
+Our data collection involves human participants. We detail our data collection process and the multiple measures we have taken to reduce the risk of privacy leakage in Appendix~\ref{datacollect}. We also discuss the broader impacts of this study in Appendix~\ref{broaderimpact}.
+
+\section{Reproducibility statement}
+\label{reproducibility}
+
+
+To ensure the reproducibility of our work, we provide all the necessary resources and code used in this paper. All adopted models are fully open source or publicly accessible. Our project code, including the data format, data splits, and evaluation process of FingerTip 20K, can be publicly accessed via the following anonymous link: \url{https://github.com/tsinghua-fib-lab/FingerTip-20K}.
+
+
+\appendix
+
+\newpage
+\appendix
+\section{Appendix}
+
+\subsection{Limitations}
+Our study has several limitations. Firstly, all 95 contributors live in mainland China, and mainly interact with Chinese third-party apps. The recorded linguistic habits, UI layouts and action patterns may differ markedly from other regions. Secondly, our LoRA fine-tuning uses only a single 7B model. Due to cost constraints, we did not conduct larger-scale fine-tuning experiments. Finally, we assume that screenshots can be stored and shared after anonymization. In practice, fine-grained UI traces can still contain unique visual features that allow re-identification. Techniques such as selective redaction or synthetic replay should be explored before large-scale deployment.
+
+\subsection{Broader impacts}
+\label{broaderimpact}
+FingerTip 20K aims to advance mobile agents that anticipate user needs and adapt to individual preferences. If developed responsibly, such agents could reduce the interaction barrier for elderly or motor-impaired users, reduce screen time by automating repetitive tasks, and serve as a test bed for privacy-preserving personalization research. At the same time, the technology entails risks. Continuous screen capture combined with explicit user profiles gives models an intimate view of personal life. An attacker compromising the agent, or a service provider lacking strong governance, could reconstruct sensitive behaviors, contacts or locations. We encourage future work on on-device processing, differential privacy and audit mechanisms.
+
+\subsection{Data collection}
+\label{datacollect}
+The data collection was carried out through crowdsourcing, and participants were paid in accordance with the living wage laws of their country. Participants consist of one-third undergraduates, one-third postgraduates, and one-third employed individuals, including 54 males and 41 females, whose ages range from 18 to 60, with an average age of 25.9. Participants filled out a questionnaire, which collected their user profiles. Participants were informed of the expected use of the collected data and signed a data usage agreement. They were asked not to upload any data related to private information. We provided participants with detailed guidance documents and video tutorials on how to operate the FingerTip APP for data collection. All participants went through a training phase during which they became familiar with the FingerTip APP. They were encouraged to avoid using overly simplified or ambiguous language to collect clear and useful intent descriptions. They were clearly informed that they should not perform redundant or useless operations during the demonstration process, and the operation speed should not be too fast to avoid frequent repetitive operations. However, minor noisy operations (e.g., users making a typo or accidentally touching advertisements) are realistic situations in human interaction. A robust agent must be able to handle such scenarios. Even if the demonstrations are not collected from daily life but by recruiting annotators to perform operations in a simulator like existing datasets, such noise cannot be completely avoided. Therefore, we allow for its existence. During data collection, we conducted multiple timed quality checks on the data submitted by each participant and manually deleted the low-quality data. We also provided quality feedback to the corresponding participants, reminding them how to submit higher-quality data.
+
+It should be noted that the FingerTip APP only collects data when participants actively use it. It does not automatically collect data at other times. Participants can check or delete the data they upload at any time. We conducted two rounds of inspections. We first manually inspected the data and removed those that obviously involved privacy. Then, we used Qwen-VL-Max to examine the first and last screenshots of each episode and determine whether it involved privacy. Those episodes marked as potentially involving privacy were then rechecked by humans.
+
+Our primary goal for collecting the data was to capture deep and longitudinal user interactions in daily life settings. We believe that this context-rich dataset, even from a single region, provides a crucial foundation for the novel tasks of proactive task suggestion and personalized task execution. Considering the cost, we did not collect data in other regions. To our knowledge, previous datasets such as~ also contain a single language and UI ecosystem. We believe that this is a sufficient start for a first-of-its-kind study. However, user diversity is a crucial aspect in ensuring the global generalizability of our findings. To facilitate broader research, we plan to open source our APP for data collection. It can run on any (new version) Android personal phone, providing support for data collection in other regions and languages. We believe that our data collection methods and evaluation methods are universal.
+
+\subsection{Data format}
+\label{dataformat}
+Our data is released at~\url{https://github.com/tsinghua-fib-lab/FingerTip-20K}. The data contains several folders named with numbers (i.e. user IDs), and each of these folders contains multiple folders named with timestamps (e.g., 20250309\_133115), representing all the data episodes submitted by that user. For each data episode, the following information is included:
+\begin{itemize}
+ \item \textit{screenshots}: a list of screenshots for each observation encoded as JPGs.
+ \item \textit{accessibility trees}: a list of Android accessibility tree XML files for each observation.
+ \item \textit{actions}: a list of actions represented in the form of JSON dictionaries. Each screenshot corresponds to an action.
+ \item \textit{intent\_description}: the user's true intent in this episode.
+ \item \textit{user\_id}: the unique integer identifier of the user to whom this episode belongs. This information can be used to retrieve the corresponding user's user profile.
+ \item \textit{time}: the timestamp when this episode was collected.
+ \item \textit{scenario}: the category of location where the user was when this episode was collected.
+ \item \textit{app}: the name of the activity running when the episode was collected. This information is only used to launch the corresponding app in personalized task execution and is not provided to the LLM agent.
+\end{itemize}
+
+
+The example of an episode from FingerTip 20K is shown in Figure~\ref{Fig7}.
+
+\paragraph{Accessibility trees}
+Note that when using accessibility trees, the LLM agent utilizes a list of all accessible UI elements and their coordinates corresponding to a certain screenshot, which is extracted from the metadata XML file through a Python function.
+
+
+\paragraph{User profile}
+The types of information included in user profiles and an example can be seen in Table~\ref{Table7}.
+
+\paragraph{Scenario}
+When users record their intents with the FingerTip APP, they need to select the category of the location they are in. Specifically, they can choose from the following 12 common categories: residence, office, school, dining place, shopping mall, medical institution, entertainment and leisure venue, sports venue, cultural venue, transportation, urban street, and natural outdoor spaces. If users think that none of these categories can describe the location they are in, they can fill in a new category on their own.
+
+\subsection{Data splits}
+\label{datasplits}
+
+
+We created a training set, a validation set, and two test sets. The number of episodes and features in these sets are detailed in Table~\ref{Table3}. Please note that the two test sets contain partially overlapping episodes. The test sets were formed by randomly sampling the last 20\% of the data sorted by time of each user, and then concatenated to ensure coverage of all users and that the proportion of data from each user in the test sets is equal to their proportion in all data. These test sets were used in all main experiments. The collection method of the training set is similar to that of the test sets, except that it is sampled from the first 60\% of the data.
+
+
+\subsection{Supplementary experiment results}
+\label{moreexperiment}
+
+\subsubsection{Out-of-domain generalization}
+
+To explore generalizability, we randomly sampled from the original test set and obtained three small test subsets, which are: (1) User-unseen, containing 126 episodes from 3 users. All data of these 3 users in the training set were removed. (2) App-unseen, containing 106 episodes from 7 apps. All data of these 7 apps in the training set were removed. (3) Intent-unseen, containing 99 episodes from 4 intent categories. All data of these 4 intent categories in the training set were removed. The filtered training set has 14,706 episodes, and these data were used to re-fine-tune Qwen-2.5-VL-7B, with the LoRA rank set to 4. The fine-tuned model was tested on these three out-of-domain test sets and the original test set, and the results are shown in Table~\ref{generalization}.
+
+
+When tested on new users, new apps, and new intent categories that have not been seen in the training set, the decline in model performance is not particularly severe. This indicates that the model fine-tuned on partial data has certain generalization ability and robustness, and can maintain good proactive task suggestion and personalized task execution capabilities in unseen data as well.
+
+
+\subsubsection{Connection between two tracks}
+
+We believe that proactive task suggestion and personalized task execution are both crucial capabilities for an agent to act as a user-oriented intelligent assistant. In practical applications, it first predicts the user's needs and then fulfills them in a way preferred by the user, thereby facilitating the user's more convenient use of the mobile phone and demonstrating a kind of collaborative connection. However, the two tracks are conceptually distinct and emphasize different capabilities. Proactive task suggestion places more emphasis on the agent's ability to predict the user's intents in advance, rather than passively responding to the user's clear instructions, that is, understanding "what the user wants to do". Personalized task execution places more emphasis on aligning the agent's behavior with the user's preferences during the known instruction execution process, rather than standardizing the task execution, that is, understanding "how the user does it". In the fine-tuning of Section~\ref{fine-tuning}, we trained separately on two tracks and obtained two fine-tuned models, each suitable for one of the two tracks. Now we test these two models on the opposite track from the training data. Additionally, we jointly fine-tuned a model (trained on both tracks), and the results are shown in Table~\ref{connection}.
+
+
+The model fine-tuned on one track did not bring about performance improvement when tested on the other track; instead, there was a performance decline. The performance of the jointly fine-tuned model also slightly declined compared to the separately fine-tuned models. This indicates that the two tracks test two different abilities, and it is necessary to train and evaluate them separately.
+
+
+\subsubsection{Contribution of screenshots and historical intents}
+
+Our intention for the main results in Table~\ref{Table4} was to establish a baseline for the most challenging version of proactive task suggestion, where the agent has zero screenshots and must rely solely on historical and contextual data. This highlights the inherent difficulty of the task. To explore the performance of the agent under more screenshots or more historical information, we supplemented the experiments and obtained the following data in Table~\ref{Table8} (all using GPT4.1). Besides, we have already demonstrated the variation of performance with the number of screenshots in Figure~\ref{Fig6}.a.
+
+
+0 screenshot + 20 $I_{\text{history}}$ are the results we present in Table~\ref{Table4}. For All $I_{\text{history}}$, we use DeepSeek-V3 to summarize the 20 most relevant historical intents of the user to the current time and scenario among all historical intents. Additionally, we also tested the results of providing 3 initial screenshots and mixing them with All $I_{\text{history}}$. Both providing more screenshots and historical information can improve performance, but there is still much room for improvement. Offering more screenshots would lose the predictive meaning of this task and significantly increase costs. We hope that the agent can complete proactive task suggestion by relying on as few screenshots and historical information as possible. When $I_{\text{history}}$ was removed (cold-start users) while keeping three screenshots visible, the success rate dropped to 4.3\%, indicating a significant performance decline. It is evident that historical intents are crucial for predicting current intents, and relying solely on screenshots cannot effectively accomplish proactive task suggestion.
+
+
+\subsubsection{Contribution of contextual information}
+
+To study the contribution of each contextual information in the input to the proactive task suggestion, we supplemented the ablation study (all using GPT4.1) and obtained the following results in Table~\ref{Table9}.
+
+
+w/ User profile, Time, Scenario are the results we present in Table~\ref{Table4}. Eliminating User profile, Scenario, and Time all lead to performance degradation, among which the elimination of Time causes the most significant decline, indicating that time might be the most crucial factor in the patterns of user intent.
+
+
+\subsubsection{Effect of the probability setting}
+
+Our data is longitudinal and collected over one month. This means that we often capture multiple instances of similar intents from the same user. This structure is precisely what allows for modeling user preferences and "habitual" intents. That is to say, within a specific time period of a day, a specific user's intents roughly follow a fixed probability distribution. We first separate all the intents of the same user by time periods (e.g., dividing a day into 24 time periods by hour). Then, we convert all the intents within the same time period into embedding vectors using paraphrase-multilingual-MiniLM-L12-v2 and cluster them based on distance. All semantically similar intents are regarded as one category. If the number of intents in a certain category is larger, it indicates that the probability of the user generating this type of intent during this time period is higher. In this way, we obtain the probability distribution of intents (e.g., the user has a 35\% probability of ordering a hamburger for delivery and a 22\% probability of playing music from a self-built playlist between 12:00 and 13:00...). For each user, a unique probability distribution of intents can be calculated through the above method.
+
+We re-executed the proactive task suggestion experiment by having GPT4.1 output the probability distribution of the user's intents instead of a single intent. The calculation method of $SR_1$ was changed to be successful as long as one of the top three intents in the output probability distribution could be regarded as the same as the user's true intent. The calculation method of $Sim_1$ was changed to the cosine similarity between the output probability distribution's embedding vector and the true probability distribution's embedding vector. It can be seen in Table~\ref{probability} that by outputting the probability distribution, the agent provides multiple possible task suggestions, which is more likely to succeed than only outputting a single task suggestion.
+
+
+\subsubsection{Validity of \texorpdfstring{$Sim_2$}{Sim\_2}}
+
+$Sim_2$ is an automated metric for personalization. To quantitatively analyze the correlation between $Sim_2$ and users' subjective experience, we conducted a user study. Specifically, for four models in Table~\ref{Table6}, we combined their output (i.e., the complete action sequences output by the models) on the personalized task execution test set (200 episodes) with the users' true action sequences. Each episode has one ground truth action sequence and four randomly ordered action sequences output by the models. Then, we asked the users corresponding to these 200 episodes to rate the four models' action sequences on a five-point scale. The rating principle was whether the action sequence was personalized to execute the task according to the user's unique habits and preferences, even if it might not have been ultimately successful. Then, we calculated the average rating of the four models and compared it with their $Sim_2$. The results are shown in Table~\ref{user score}.
+
+
+The user rating increases with the increase of $Sim_2$, indicating a certain positive correlation between $Sim_2$ and users' subjective personalized experience. The fine-tuned model has the highest $Sim_2$ and its user rating also reached the highest 3.35 points, indicating that fine-tuning on our data indeed improved the model's personalization ability.
+
+
+\subsubsection{Effect of similar or same action sequence}
+
+In personalized task execution, we provide the agent with an action sequence of a similar task for in-context learning. However, this similar task might be the same as the current one, as the user has performed the same task before, and the agent might cheat on the same task. We used DeepSeek-V3 to determine whether the retrieved similar tasks and the current task could be regarded as the same task. If they were the same, we moved on to the next similar task until they could no longer be considered the same. Using this method, we re-conducted the experiment on UI-TARS-1.5-7B, and the performance in Table~\ref{Table10} showed no significant difference from the original. Therefore, we believe there is no obvious cheating phenomenon. While tasks may be the same, the exact UI states are unlikely to be identical, so is the action sequence. The goal is for the agent to generalize a user's style of interaction, not replicate a specific trace.
+
+
+\newpage
+\subsection{Prompts for the LLM agents}
+\subsubsection{Prompt for proactive task suggestion}
+\label{prompt1}
+
+
+\subsubsection{Prompt for personalized task execution}
+\label{prompt2}
+
+
+\end{document}

benchmark_dataset/papers/ICLR2026_0002_2507.21071/source_extracted.tex

@@ -0,0 +1,139 @@
+\begin{abstract}
+
+Mobile GUI agents are becoming critical tools to improve user experience on smart devices, with multimodal large language models (MLLMs) emerging as the dominant paradigms in this domain. Current agents, however, rely on explicit human instructions, overlooking the potential to leverage the contextual information (like location, time, user profile) and historical data for proactive task suggestions. Besides, previous works focus on optimizing the success rate during task execution, but pay less attention to the personalized execution trajectory, thereby neglecting potentially vast differences in user preferences. To address these challenges, we introduce the FingerTip 20K benchmark. We collected 20K unique human demonstrations of multi-step Android device interactions across a variety of everyday apps. These demonstrations are not isolated but are continuously acquired from the users' long-term usage in their real lives, and encompass essential user-related contextual information. The benchmark contains two new tracks: proactive task suggestions by analyzing environment observation and users' previous intents, and personalized task execution by catering to users' action preferences. Our experiments reveal that the tracks we propose pose significant challenges for leveraging user-related information in GUI tasks. We also performed a human study to show that there exists a huge gap between existing agents and humans. The model fine-tuned with the data we collected effectively utilized user information and achieved good results, highlighting the potential of our approach in building more user-oriented mobile LLM agents. Our code is open-source at \url{https://github.com/tsinghua-fib-lab/FingerTip-20K} for reproducibility.
+
+\end{abstract}
+
+\footnotetext[1]{Corresponding authors.}
+
+
+\section{Introduction}
+\label{introduction}
+
+
+Recent studies have explored how to utilize multimodal large language models (MLLMs) to build graphical user interface (GUI) control agents~, with a significant direction being mobile phone GUI control agents. These mobile LLM agents have the potential to tremendously improve user experience with mobile devices, since GUI is a universal interface across various applications. These agents receive a natural language task instruction, such as "Set an alarm for 7:30 for me", and then perceive the device state by observing the device screen (via screenshots or textual UI trees), and generate actions (click, type, scroll, etc.) to interact with the device environment to fulfill human instructions.
+
+
+Despite rapid progress, currently, most existing mobile LLM agents are confined to a completely passive paradigm: they only perform tasks upon receiving a clear instruction. This paradigm restricts their ability to proactively offer task suggestions and assistance in the absence of direct human instructions. If users have to formulate detailed instructions for every intent when interacting with mobile LLM agents, it will significantly increase the cognitive burden of mobile phone usage. Moreover, humans sometimes may not clearly express some latent needs. Therefore, mobile LLM agents need to be more proactive to provide users with more comprehensive and seamless services. Furthermore, the existing agents utilize almost exclusively user instructions as textual information when performing tasks, without taking into account any additional user-related information (e.g., time and location, user profile, user historical intents and actions), thus failing to provide personalized services to users. We argue that these limitations stem largely from the lack of suitable training data and standardized evaluation benchmarks that incorporate rich user-related information.
+
+
+To comprehensively evaluate the proactive and personalized capabilities of mobile LLM agents, we propose the FingerTip 20K benchmark, which includes two new tracks: (i) proactive task suggestion, where the agent needs to integrate the user's past intents and the current environmental state to infer the user's potential current intent; (ii) personalized task execution, where the agent needs to refer to the user's past action preferences to execute current instructions. The overall task scenario we envision is shown in Figure~\ref{Fig1}. Since existing benchmarks do not provide user-related contextual information and historical data, we spent over one month collecting new diverse data from 95 users in their daily mobile phone usage, including 21,437 episodes covering 506 apps. We then conducted experiments on the FingerTip 20K benchmark to evaluate the capabilities of generalist models and GUI-control agents built on specifically designed models and found that there is still much room for improvement in their proactive and personalized capabilities. Current agents still find it hard to reach or surpass the human level. The best-performing model achieved a success rate of 12.8\%, while humans reached 30.3\%. We fine-tuned a small model using the collected data and achieved better results.
+
+
+In summary, the main contributions of this work include:
+\begin{itemize}
+ \item We propose the FingerTip 20K benchmark, which includes two brand-new tracks, to evaluate the ability of mobile LLM agents to proactively predict user intents and offer suggestions, as well as their ability to personalize task execution in accordance with user preferences.
+ \item We collect large-scale user-oriented mobile GUI-control data, derived from scenarios in users' daily lives, which includes user-related contextual information and users' long-term mobile phone usage patterns.
+ \item We evaluated the capabilities of generalist models and GUI-control-specific models on the FingerTip 20K benchmark, demonstrating the difficulty of the tracks we propose. The excellent performance of the model fine-tuned with our collected data highlights the potential of our approach in building more proactive and personalized mobile agents.
+\end{itemize}
+
+
+\section{Problem formulation}
+\subsection{Proactive task suggestion}
+\label{Proactive task suggestion}
+
+
+In the FingerTip 20K benchmark we propose, unlike the evaluation tasks of traditional mobile LLM agent benchmarks that rely entirely on explicit instructions, we introduce a new task where the agent proactively predicts the user's current intent and proposes tasks suggestion that the user might want to perform, as shown in Figure~\ref{Fig2}. The agent's task is to generate an intent prediction $I$ based on the user profile $U$, the current time $T$, the current scenario $S$, the user's historical intents $I_{\text{history}}$, and the partial screenshots $O$ observed at present. This can be formalized as:
+\begin{equation}
+ \ I=f\ (U,\ T,\ S,\ I_{\text{history}},\ O)
+\end{equation}
+where $f$ represents the agent. $I$ is a sentence that unambiguously predicts the intent of the user. It should clearly state the name of the app that the user wants to use, and the final effect that the user wants to achieve. $U$ includes common user attributes such as age, sex, occupation, etc. $T$ represents the current timestamp, accurate to the second. $S$ represents the current scenario, expressed in common location categories. $I_{\text{history}}$ contains the user's historical intents in the recent period, up to 20 items, which may include the potential patterns and preferences of the user's mobile phone usage. $O$ includes the first few screenshots of the user's current actions (e.g., opening the home page of a certain app). We hope that the agent can utilize the above-mentioned user-related contextual information and historical intents to infer the user's potential intents, and thereby proactively offer helpful task suggestions.
+
+
+\subsection{Personalized task execution}
+\label{Personalized task execution}
+
+In addition to proactive task suggestion, we also aim to evaluate the agent's ability to carry out tasks under the condition of explicit instructions, that is, when the user's intent is known. The setting of this part is similar to the existing benchmarks. The difference lies in that we additionally assess the agent's ability to execute tasks in a personalized manner specifically catering to the action preferences of different users. Given user profile $U$, user intent $I_{\text{true}}$, user's historical actions $A_{\text{history}}$, agent's action sequence $A_{\text{agent}}$, and the current screenshot $O_t$ and the corresponding accessibility tree $AT_t$, the agent needs to perform the next action $A_{t+1}$, and then observe $O_{t+1}$ and $AT_{t+1}$. This can be formalized as:
+\begin{equation}
+ \ A_{t+1},\ O_{t+1},\ AT_{t+1}=f\ (U,\ I_{\text{true}},\ A_{\text{history}},\ A_{\text{agent}},\ O_t,\ AT_t)
+\end{equation}
+where $f$ represents the agent. $I_{\text{true}}$ is equivalent to the user's true intent that needs to be predicted in proactive task suggestion, and here it serves as the instruction to be executed. $A_{\text{history}}$ is the complete action sequence of the user when performing a similar task in the past, provided to the agent for in-context learning to imitate the user's action preferences. $A_{\text{agent}}$, on the other hand, is the action sequence $\{A_1,...,A_t\}$ that the agent has already executed in the current task, helping the agent determine the progress of the task. The agent needs to constantly interact with the mobile phone environment until it believes that $I_{\text{true}}$ has been fulfilled. We hope that the final sequence of agent actions $A_{\text{agent}}$ can reflect the user's action preferences.
+
+
+\section{The FingerTip 20K benchmark}
+\subsection{Overview}
+The motivation for FingerTip 20K data collection is to evaluate the dual tracks we have proposed, namely proactive task suggestion and personalized task execution. To this end, the most distinctive feature of the data should be user-oriented, containing sufficient user-related contextual information and being able to reflect the patterns and preferences of users in terms of intents and actions.
+
+
+\subsection{Data collection}
+\label{Data collection}
+The data collection pipeline is shown in Figure~\ref{Fig3}. We first recruited 95 data collectors (hereinafter referred to as users) using Android phones through crowdsourcing, covering a wide range of device types and Android versions. Users were required to download an APP developed by us on their own daily used phones and use it to collect data. Specifically, whenever users had a real intent to use their phones in their daily lives, they could open the FingerTip APP, record their intent at that moment in one sentence, and select the location category they were in. Then, users needed to switch to the app involved in the intent they recorded and demonstrate the specific action sequence to complete this intent.
+
+The FingerTip APP will automatically upload the intent they fill in (including time and location) and the demonstration process they provide (including screenshot sequences, corresponding accessibility tree XML file sequences, and UI action sequences) to the cloud server. This is regarded as the user collecting one piece of data. The APP may remind the user to collect data when they wake up the phone screen to prevent them from forgetting. Each user is required to use their phone to collect data for one month, with a maximum of 12 pieces of data uploaded per day. In this way, users can fully customize the data they upload. See Appendix~\ref{datacollect} and~\ref{dataformat} for more details on data collection and data format.
+
+FingerTip APP is developed based on the accessibility features of the Android system. It can automatically record the type and coordinates, as well as optional text descriptions of each user action. The actions we collect are unified into an action space, as shown in Table~\ref{Table2}. Among them, $finish$ is uniformly added to the last screenshot of all episodes.
+
+
+\subsection{Data statistics}
+\label{ranking}
+The summary of data statistics is presented in Table~\ref{Table1}. Additionally, Figure~\ref{Fig4} reports the distribution of user intent length, episode length, intent categories, and app name in all data. The intent categories are determined by DeepSeek-V3~.
+
+
+\subsection{Personalized action analysis}
+\label{Personalized action analysis}
+
+
+To verify the personalized differences in actions among users of different types, we first simply classified users into different categories based on age groups. Then, we randomly sampled one piece of data from each of the 40 intent categories. For the action sequence of such a piece of data, we calculated the Levenshtein similarity with the action sequence of the most intent-similar data from (i) the same user, (ii) users of the same type, and (iii) users of different type. All similarities were normalized to [0, 100] and plotted in Figure~\ref{Fig5}. It can be seen that even when performing similar intents, the similarity of action sequences with users of different type is significantly lower than that of the same user or users of the same type, indicating that user preferences on action sequences do exist and are measurable.
+
+
+\section{Experiments}
+
+We conducted experiments on some generalist models and some GUI-control agents built on specifically designed models, evaluating their capabilities on the two tracks proposed in the FingerTip 20K benchmark and assessing their performance under different task difficulties. Additionally, we fine-tuned a model using the collected data. For details on the data splits (including the training set, validation set, and two test sets), please refer to Appendix~\ref{datasplits}.
+
+
+\subsection{Experimental setup}
+\label{baseline}
+\paragraph{Proactive task suggestion}
+The LLMs we experiment with in this track include GPT-4.1, Qwen-VL-Max, DeepSeek-VL2~ and Qwen-2.5-VL-7B~. We also introduce Qwen-2.5-VL-72B~ to compare with the 7B version; and Qwen-QVQ-Max (thinking model) to compare with other non-thinking models. We set the temperature to zero for all models. For proactive task suggestion, the agent only needs one query to output the predicted intent. Since this is a brand new track proposed in our benchmark, there is no mature agent design available for direct use. We have designed a simple prompt to provide to all models evaluated in this track. This prompt contains all necessary inputs (see Section~\ref{Proactive task suggestion} and Appendix~\ref{prompt1}).
+
+\paragraph{Personalized task execution}
+In this track, in addition to the generalist models mentioned above, we also experiment with three GUI-control agents built on specifically designed models, including Aguvis-7B~, CogAgent-9B~ and UI-TARS-1.5-7B~. We also introduce AutoDroid~ and AppAgent~, two GUI-control agents based on prompt engineering (using GPT4.1 as the base model). For personalized task execution, the agent needs to interact with the environment in multiple steps to fulfill the user's instructions. We connect a physical phone to the computer via USB and use Android Debug Bridge (ADB) to provide this environment. Using an emulator would be a more convenient approach, but due to strict app control measures, most Chinese apps can only run on physical phones rather than emulators. For the generalist models, we designed a simple prompt to guide their output of the next action, with the action space consistent with Table~\ref{Table2}. This prompt contains all necessary inputs (see Section~\ref{Personalized task execution} and Appendix~\ref{prompt2}). For the GUI-control agents, they have specific format requirements for input and output. To ensure normal output effects, their original prompts were used, and the input information in Section~\ref{Personalized task execution} was uniformly integrated into these original prompts. Their output was converted into a form consistent with the action space.
+
+\paragraph{Metrics}
+In proactive task suggestion track, the goal of the agent is to maximize the textual similarity between the output and the user's true intent. We use a pre-trained model, paraphrase-multilingual-MiniLM-L12-v2~, to convert the agent's output and the user's true intent into embedding vectors and calculate their cosine similarity $S_1$. And, we calculate the Levenshtein similarity $S_2$ of these two strings. Both similarities are normalized to the range of [0, 1]. Finally, we take $Sim_1=(S_1+S_2)/2$ to comprehensively represent the text similarity. In addition to this numerical metric, we also use DeepSeek-V3~ to directly determine whether the agent's output and the user's true intent can be regarded as the same intent and provide a binary value to evaluate whether the agent successfully predicted the user's intent, thereby calculating the success rate $SR_1$.
+
+In personalized task execution track, the primary goal of the agent is to execute user instructions in a personalized manner. We calculate the final success rate $SR_2$ by manually checking whether the environment state when the agent outputs $finished()$ matches the user's instructions. In addition, when the agent steps exceed 2.5 times the golden steps, the task is automatically considered a failure. Note that the path to successfully execute the user's instructions is not unique. The agent should also make the action sequence reflect the user's action preferences as much as possible. We do not require the agent's action at each step to be exactly the same as the user's golden action. Instead, we calculate the Levenshtein similarity $S_I$ of the agent's complete action sequence and the user's complete action sequence as two strings. Then, following the approach in Section~\ref{Personalized action analysis}, we take the data that is most similar to the current user's intent from the users of different type, and calculate the Levenshtein similarity $S_{\text{II}}$ of the agent's complete action sequence and this data's complete action sequence. Finally, we take the value $Sim_2=S_I/S_{\text{II}}$. It is obvious that the larger this value is, the more similar the agent's action sequence is to that of the current user, and the more different it is from that of users of different type. In addition, we measure execution efficiency by comparing the agent steps with the user's golden steps to calculate the step ratio when the agent successfully execute the user's instructions. For the two tracks, we also tallied the average time and token count consumed per query to assess the model's cost.
+
+\subsection{Overall performance}
+\label{Overall Performance}
+
+The overall performance of the models we evaluated in proactive task suggestion is shown in Table~\ref{Table4}. Note that here we set the number of $O$ (the first few screenshots of the user's current actions) to 0. This makes the task quite challenging. The thinking model Qwen-QVQ-Max surpassed GPT-4.1, achieving the best performance among the generalist models with $SR_1=12.8$ and $Sim_1=0.39$, but also took the longest time and the most tokens. From $SR_1$, it can be intuitively seen that the success rate of all models in predicting the user's intent is very low. Additionally, we conducted a user study where 20 human annotators (distinct from the users who collected the data) labeled a subset of the test set (a total of 400 episodes), achieving a success rate of 30.3\%. This highlights the significant gap between the existing models and human in proactive task suggestion capabilities.
+
+
+The overall performance of the models we evaluated in personalized task execution is shown in Table~\ref{Table5}. Qwen-QVQ-Max and UI-TARS-1.5-7B achieved the best performance among the generalist models and GUI-control models respectively. AppAgent achieved the best performance among all models in $Sim_2$ and step ratio, possibly due to its proficiency in learning from human demonstrations, but time and token costs also increased significantly. The $SR_2$ of the generalist models were all very low, mainly due to their lack of precise GUI grounding ability, which led to incorrect UI coordinates being output even when they could correctly analyze the next action, thus failing to interact with the environment accurately. In contrast, the GUI-control models, having undergone targeted training, had stronger abilities to execute instructions and interact with the UI environment, resulting in higher $SR_2$, with UI-TARS-1.5-7B having the highest at 38.5. However, the $Sim_2$ of all models were approximately 1, indicating that the agent's action sequence did not favor either the current user or users of different type. This might suggest that the agent tends to complete tasks in a general way without catering to the specific action preferences of users, thus failing to complete tasks in a personalized manner.
+
+
+\subsection{Effect of task difficulty}
+
+
+We experiment with the models' performance under different task difficulty levels. For proactive task suggestion (see Figure~\ref{Fig6}.a), we varied the number of $O$ (the first few screenshots of the user's current actions). The $SR_1$ of all models increased as the number of screenshots increased. This was expected. Clearly, if the agent knew the first screenshot of the user's current action, it could basically infer which app the user was using, thereby significantly narrowing the range of the user's intent. With the second and third screenshots, the agent could further narrow the user's intent range by analyzing the actions therein (e.g. clicking the search box).
+
+For personalized task execution (see Figure~\ref{Fig6}.b), we calculated the $SR_2$ of GUI-control models on different subsets of action length (i.e., the number of action steps) in the test set. It can be seen that as the action length increases, the $SR_2$ decreases. This is in line with expectations, as the greater the action length required to complete a certain instruction, the more complex the instruction is, and the more difficult it is to complete.
+
+
+\subsection{Effect of fine-tuning}
+\label{fine-tuning}
+
+
+We fine-tuned Qwen-2.5-VL-7B and adopted the parameter-efficient fine-tuning method of LoRA, with the LoRA rank set to 4 or 64. Following the method of sampling the test set, we randomly sampled 1,000 data episodes from the training set for fine-tuning. These data covered all users, and the proportion of data for each user was the same as their proportion in the training set. We also used the complete training set (16,000 episodes) for fine-tuning. The data episodes were reorganized according to the input and output formats of the two tracks, respectively. The prompts used in fine-tuning are the same as those we designed for generalist models. Finally, we trained separately on two tracks and obtained two fine-tuned models, each suitable for one of the two tracks.
+
+
+The performance of fine-tuned models on the two tracks is shown in Table~\ref{Table6}. Despite using a smaller model and less training data, the fine-tuned models achieved significant performance improvements in all main metrics. Increasing the LoRA rank or the amount of training data both improve the model's performance, with the increase in training data having a particularly significant effect. In proactive task suggestion, compared with the best-performing generalist model Qwen-QVQ-Max, our fine-tuned models achieved better performance in both $SR_1$ and $Sim_1$. In personalized task execution, compared with the best-performing UI-TARS-1.5-7B, our fine-tuned models had a lower success rate $SR_2$. We consider this acceptable because UI-TARS is a model specifically designed and extensively trained for GUI grounding and GUI control, and thus has a more general instruction execution capability. However, our fine-tuned models had a significantly higher $Sim_2$, indicating that the action paths they select may not be optimal but are closer to the user's action preferences. When trained on the entire training set with a LoRA rank of 64, Qwen-2.5-VL-7B outperforms all the un-fine-tuned models in the experiment in terms of $SR_1$, $Sim_1$, and $Sim_2$, achieving the best performance. Overall, the models fine-tuned on our collected data demonstrated stronger proactivity and personalization capabilities, being able to utilize user-related contextual information to extract potential intent patterns and action preferences from the user's past intents and actions, which existing models have not or find it difficult to consider.
+
+\paragraph{More experiments}
+In Appendix~\ref{moreexperiment} we conducted more experiments to study the influence of other factors.
+
+
+\section{Conclusions}
+\label{conclusion}
+We present FingerTip 20K, a benchmark advancing mobile LLM agents toward proactive task suggestion and personalized task execution. Our data captures longitudinal user interactions, enriched with contextual information to model user-specific patterns. Experiments reveal significant gaps in existing models’ ability to mine such patterns. Fine-tuning Qwen-2.5-VL-7B on our data improved suggestion success rate while better aligning actions with user preferences, demonstrating the value of user-oriented training. This work establishes critical infrastructure for developing mobile agents that anticipate user needs and adapt to user action preferences.
+
+
+\section{Ethics statement}
+Our data collection involves human participants. We detail our data collection process and the multiple measures we have taken to reduce the risk of privacy leakage in Appendix~\ref{datacollect}. We also discuss the broader impacts of this study in Appendix~\ref{broaderimpact}.
+
+\section{Reproducibility statement}
+\label{reproducibility}
+
+
+To ensure the reproducibility of our work, we provide all the necessary resources and code used in this paper. All adopted models are fully open source or publicly accessible. Our project code, including the data format, data splits, and evaluation process of FingerTip 20K, can be publicly accessed via the following anonymous link: \url{https://github.com/tsinghua-fib-lab/FingerTip-20K}.

benchmark_dataset/papers/ICLR2026_0002_2507.21071/source_references.tex

@@ -0,0 +1,203 @@
+@article{chai2024amex,
+  title={Amex: Android multi-annotation expo dataset for mobile gui agents},
+  author={Chai, Yuxiang and Huang, Siyuan and Niu, Yazhe and Xiao, Han and Liu, Liang and Zhang, Dingyu and Gao, Peng and Ren, Shuai and Li, Hongsheng},
+  journal={arXiv preprint arXiv:2407.17490},
+  year={2024}
+}
+
+@article{li2024effects,
+  title={On the effects of data scale on ui control agents},
+  author={Li, Wei and Bishop, William E and Li, Alice and Rawles, Christopher and Campbell-Ajala, Folawiyo and Tyamagundlu, Divya and Riva, Oriana},
+  journal={Advances in Neural Information Processing Systems},
+  volume={37},
+  pages={92130--92154},
+  year={2024}
+}
+
+@article{rawles2023androidinthewild,
+  title={Androidinthewild: A large-scale dataset for android device control},
+  author={Rawles, Christopher and Li, Alice and Rodriguez, Daniel and Riva, Oriana and Lillicrap, Timothy},
+  journal={Advances in Neural Information Processing Systems},
+  volume={36},
+  pages={59708--59728},
+  year={2023}
+}
+
+@article{rawles2024androidworld,
+  title={Androidworld: A dynamic benchmarking environment for autonomous agents},
+  author={Rawles, Christopher and Clinckemaillie, Sarah and Chang, Yifan and Waltz, Jonathan and Lau, Gabrielle and Fair, Marybeth and Li, Alice and Bishop, William and Li, Wei and Campbell-Ajala, Folawiyo and others},
+  journal={arXiv preprint arXiv:2405.14573},
+  year={2024}
+}
+
+@article{xu2024androidlab,
+  title={Androidlab: Training and systematic benchmarking of android autonomous agents},
+  author={Xu, Yifan and Liu, Xiao and Sun, Xueqiao and Cheng, Siyi and Yu, Hao and Lai, Hanyu and Zhang, Shudan and Zhang, Dan and Tang, Jie and Dong, Yuxiao},
+  journal={arXiv preprint arXiv:2410.24024},
+  year={2024}
+}
+
+@article{chai2025a3,
+  title={A3: Android agent arena for mobile gui agents},
+  author={Chai, Yuxiang and Li, Hanhao and Zhang, Jiayu and Liu, Liang and Liu, Guangyi and Wang, Guozhi and Ren, Shuai and Huang, Siyuan and Li, Hongsheng},
+  journal={arXiv preprint arXiv:2501.01149},
+  year={2025}
+}
+
+@article{ran2025beyond,
+  title={Beyond Pass or Fail: A Multi-dimensional Benchmark for Mobile UI Navigation},
+  author={Ran, Dezhi and Wu, Mengzhou and Yu, Hao and Li, Yuetong and Ren, Jun and Cao, Yuan and Zeng, Xia and Lu, Haochuan and Xu, Zexin and Xu, Mengqian and others},
+  journal={arXiv preprint arXiv:2501.02863},
+  year={2025}
+}
+
+@inproceedings{chen2024spa,
+  title={Spa-bench: A comprehensive benchmark for smartphone agent evaluation},
+  author={Chen, Jingxuan and Yuen, Derek and Xie, Bin and Yang, Yuhao and Chen, Gongwei and Wu, Zhihao and Yixing, Li and Zhou, Xurui and Liu, Weiwen and Wang, Shuai and others},
+  booktitle={NeurIPS 2024 Workshop on Open-World Agents},
+  year={2024}
+}
+
+@article{zhang2024llamatouch,
+  title={Llamatouch: A faithful and scalable testbed for mobile ui automation task evaluation},
+  author={Zhang, Li and Wang, Shihe and Jia, Xianqing and Zheng, Zhihan and Yan, Yunhe and Gao, Longxi and Li, Yuanchun and Xu, Mengwei},
+  journal={arXiv e-prints},
+  pages={arXiv--2404},
+  year={2024}
+}
+
+@article{lee2024benchmarking,
+  title={Benchmarking Mobile Device Control Agents across Diverse Configurations},
+  author={Lee, Juyong and Min, Taywon and An, Minyong and Hahm, Dongyoon and Lee, Haeone and Kim, Changyeon and Lee, Kimin},
+  journal={arXiv preprint arXiv:2404.16660},
+  year={2024}
+}
+
+@inproceedings{xing2024understanding,
+  title={Understanding the weakness of large language model agents within a complex android environment},
+  author={Xing, Mingzhe and Zhang, Rongkai and Xue, Hui and Chen, Qi and Yang, Fan and Xiao, Zhen},
+  booktitle={Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining},
+  pages={6061--6072},
+  year={2024}
+}
+
+@article{yan2023gpt,
+  title={Gpt-4v in wonderland: Large multimodal models for zero-shot smartphone gui navigation},
+  author={Yan, An and Yang, Zhengyuan and Zhu, Wanrong and Lin, Kevin and Li, Linjie and Wang, Jianfeng and Yang, Jianwei and Zhong, Yiwu and McAuley, Julian and Gao, Jianfeng and others},
+  journal={arXiv preprint arXiv:2311.07562},
+  year={2023}
+}
+
+@article{he2024webvoyager,
+  title={WebVoyager: Building an end-to-end web agent with large multimodal models},
+  author={He, Hongliang and Yao, Wenlin and Ma, Kaixin and Yu, Wenhao and Dai, Yong and Zhang, Hongming and Lan, Zhenzhong and Yu, Dong},
+  journal={arXiv preprint arXiv:2401.13919},
+  year={2024}
+}
+
+@article{koh2024visualwebarena,
+  title={Visualwebarena: Evaluating multimodal agents on realistic visual web tasks},
+  author={Koh, Jing Yu and Lo, Robert and Jang, Lawrence and Duvvur, Vikram and Lim, Ming Chong and Huang, Po-Yu and Neubig, Graham and Zhou, Shuyan and Salakhutdinov, Ruslan and Fried, Daniel},
+  journal={arXiv preprint arXiv:2401.13649},
+  year={2024}
+}
+
+@article{kim2023language,
+  title={Language models can solve computer tasks},
+  author={Kim, Geunwoo and Baldi, Pierre and McAleer, Stephen},
+  journal={Advances in Neural Information Processing Systems},
+  volume={36},
+  pages={39648--39677},
+  year={2023}
+}
+
+@article{zheng2023synapse,
+  title={Synapse: Trajectory-as-exemplar prompting with memory for computer control},
+  author={Zheng, Longtao and Wang, Rundong and Wang, Xinrun and An, Bo},
+  journal={arXiv preprint arXiv:2306.07863},
+  year={2023}
+}
+
+@inproceedings{zhang2025appagent,
+  title={Appagent: Multimodal agents as smartphone users},
+  author={Zhang, Chi and Yang, Zhao and Liu, Jiaxuan and Li, Yanda and Han, Yucheng and Chen, Xin and Huang, Zebiao and Fu, Bin and Yu, Gang},
+  booktitle={Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems},
+  pages={1--20},
+  year={2025}
+}
+
+@inproceedings{wen2024autodroid,
+  title={Autodroid: Llm-powered task automation in android},
+  author={Wen, Hao and Li, Yuanchun and Liu, Guohong and Zhao, Shanhui and Yu, Tao and Li, Toby Jia-Jun and Jiang, Shiqi and Liu, Yunhao and Zhang, Yaqin and Liu, Yunxin},
+  booktitle={Proceedings of the 30th Annual International Conference on Mobile Computing and Networking},
+  pages={543--557},
+  year={2024}
+}
+
+@article{nakano2022webgpt,
+  title={Webgpt: Browser-assisted question-answering with human feedback, 2022},
+  author={Nakano, Reiichiro and Hilton, Jacob and Balaji, Suchir and Wu, Jeff and Ouyang, Long and Kim, Christina and Hesse, Christopher and Jain, Shantanu and Kosaraju, Vineet and Saunders, William and others},
+  journal={URL https://arxiv. org/abs/2112.09332},
+  year={2022}
+}
+
+@article{qin2025ui,
+  title={UI-TARS: Pioneering Automated GUI Interaction with Native Agents},
+  author={Qin, Yujia and Ye, Yining and Fang, Junjie and Wang, Haoming and Liang, Shihao and Tian, Shizuo and Zhang, Junda and Li, Jiahao and Li, Yunxin and Huang, Shijue and others},
+  journal={arXiv preprint arXiv:2501.12326},
+  year={2025}
+}
+
+@inproceedings{hong2024cogagent,
+  title={Cogagent: A visual language model for gui agents},
+  author={Hong, Wenyi and Wang, Weihan and Lv, Qingsong and Xu, Jiazheng and Yu, Wenmeng and Ji, Junhui and Wang, Yan and Wang, Zihan and Dong, Yuxiao and Ding, Ming and others},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={14281--14290},
+  year={2024}
+}
+
+@article{xu2024aguvis,
+  title={Aguvis: Unified Pure Vision Agents for Autonomous GUI Interaction},
+  author={Xu, Yiheng and Wang, Zekun and Wang, Junli and Lu, Dunjie and Xie, Tianbao and Saha, Amrita and Sahoo, Doyen and Yu, Tao and Xiong, Caiming},
+  journal={arXiv preprint arXiv:2412.04454},
+  year={2024}
+}
+
+@article{gur2023real,
+  title={A real-world webagent with planning, long context understanding, and program synthesis},
+  author={Gur, Izzeddin and Furuta, Hiroki and Huang, Austin and Safdari, Mustafa and Matsuo, Yutaka and Eck, Douglas and Faust, Aleksandra},
+  journal={arXiv preprint arXiv:2307.12856},
+  year={2023}
+}
+
+@inproceedings{wu2021ai,
+  title={AI creativity and the human-AI co-creation model},
+  author={Wu, Zhuohao and Ji, Danwen and Yu, Kaiwen and Zeng, Xianxu and Wu, Dingming and Shidujaman, Mohammad},
+  booktitle={Human-computer interaction. theory, methods and tools: thematic area, HCI 2021, held as part of the 23rd HCI international conference, hCII 2021, virtual event, July 24--29, 2021, proceedings, part i 23},
+  pages={171--190},
+  year={2021},
+  organization={Springer}
+}
+
+@inproceedings{chen2020methodological,
+  title={A methodological approach to create interactive art in artificial intelligence},
+  author={Chen, Weiwen and Shidujaman, Mohammad and Jin, Jiangbo and Ahmed, Salah Uddin},
+  booktitle={HCI International 2020--Late Breaking Papers: Cognition, Learning and Games: 22nd HCI International Conference, HCII 2020, Copenhagen, Denmark, July 19--24, 2020, Proceedings 22},
+  pages={13--31},
+  year={2020},
+  organization={Springer}
+}
+
+@article{qian2024tell,
+  title={Tell me more! towards implicit user intention understanding of language model driven agents},
+  author={Qian, Cheng and He, Bingxiang and Zhuang, Zhong and Deng, Jia and Qin, Yujia and Cong, Xin and Zhang, Zhong and Zhou, Jie and Lin, Yankai and Liu, Zhiyuan and others},
+  journal={arXiv preprint arXiv:2402.09205},
+  year={2024}
+}
+
+@article{lu2024proactive,
+  title={Proactive Agent: Shifting LLM Agents from Reactive Responses to Active Assistance},
+  author={Lu, Yaxi and Yang, Shenzhi and Qian, Cheng and Chen, Guirong and Luo, Qinyu and Wu, Yesai and Wang, Huadong and Cong, Xin and Zhang, Zhong and Lin, Yankai and others},
+  journal={arXiv preprint arXiv:2410.12361},
+  year={2024}
+}

benchmark_dataset/papers/ICLR2026_0002_2507.21071/source_related_work.tex

@@ -0,0 +1,32 @@
+\section{Related work}
+\subsection{Mobile GUI-control datasets and benchmarks}
+Table~\ref{Table1} compares FingerTip 20K to existing mobile GUI-control datasets and benchmarks~. These datasets typically represent each data instance through two core components: a textual task instruction and its corresponding operational demonstration. The demonstration is encoded as a sequence of interface interactions (e.g., clicking, typing, scrolling) accompanied by relevant screenshots. What differentiates them is mainly whether they are single-step (grounding instructions to UI elements on the screen), and whether they have supplemental View Hierarchy (VH) data for each screenshot. These datasets share some common drawbacks. Firstly, their task instructions are either pre-defined by authors or generated by LLMs, and it is questionable to what extent they can reflect the real intents of people using mobile phones in their daily lives. Additionally, they collect task demonstrations mainly by having annotators operate simulators on computers, which is not the real scenario of people using mobile phones. Finally, each data instance is isolated, lacking temporal correlation and contextual information related to the user.
+
+
+\begin{table}[ht]
+\caption{Comparison of FingerTip 20K to existing mobile GUI-control datasets and benchmarks.}
+\label{Table1}
+\centering
+\resizebox{1\textwidth}{!}{
+\begin{tabular}{llllllll}
+\hline
+\multicolumn{1}{c}{\begin{tabular}[c]{@{}c@{}}Dataset \&\\ Benchmark\end{tabular}} & \#Episode & \#Apps & \begin{tabular}[c]{@{}l@{}}\#Avg\\ steps\end{tabular} & \begin{tabular}[c]{@{}l@{}}User-defined\\ tasks?\end{tabular} & \begin{tabular}[c]{@{}l@{}}Contextual\\ info?\end{tabular} & \begin{tabular}[c]{@{}l@{}}Historical\\ data?\end{tabular} & \begin{tabular}[c]{@{}l@{}}Task\\ setting\end{tabular} \\ \hline
+Android Instruct & 10.5k & - & 9.0 & {\rcross} & {\rcross} & {\rcross} & execution \\
+AMEX & 3046 & 192 & 12.8 & {\rcross} & {\rcross} & {\rcross} & execution \\
+AndroidControl & 15283 & 833 & 5.5 & {\rcross} & {\rcross} & {\rcross} & execution \\
+AitW & 715142 & 357 & 6.5 & {\rcross} & {\rcross} & {\rcross} & execution \\ \hline
+AndroidWorld & 116 & 20 & - & {\rcross} & {\rcross} & {\rcross} & execution \\
+AndroidLab & 138 & 9 & - & {\rcross} & {\rcross} & {\rcross} & execution \\
+A3 & 201 & 20 & - & {\rcross} & {\rcross} & {\rcross} & execution \\
+SPHINX & - & 100 & 8.1 & {\rcross} & {\rcross} & {\rcross} & execution \\
+SPA-Bench & 340 & 58 & - & {\rcross} & {\rcross} & {\rcross} & execution \\ \hline
+\rowcolor{cyan!5}
+FingerTip 20K & 21437 & 506 & 11.1 & {\gcheck} & {\gcheck} & {\gcheck} & \begin{tabular}[c]{@{}l@{}}proactive task suggestion \&\\ personalized task execution\end{tabular} \\ \hline
+\end{tabular}
+}
+\end{table}
+
+For benchmarks, the success rate is the most commonly used metric, and some studies also consider efficiency and cost. A common approach to assessing the success of a task is to determine whether essential states have been reached~. Some studies also compare agents' actions to golden actions~. However, these golden actions do not take into account potentially vast differences in user preferences, that is, the action sequences of different users to complete similar tasks may be very different. In addition, current benchmarks have similar task forms, that is, given an existing instruction, how to perform actions to complete it. To the best of our knowledge, there is no mobile LLM agent benchmark that discusses how to proactively suggest tasks based on user-related information when instructions are unknown.
+
+\subsection{Mobile GUI-control agents}
+Mobile GUI agents are designed to understand the UI and automate tasks on mobile apps in a manner similar to that of humans. Current agents leverage the extensive world knowledge and powerful embodied capabilities of multimodal large language models (MLLMs) for complex task planning and reasoning in multi-step GUI-control tasks. One notable approach is to directly guide generalist models like GPT-4v to perform tasks through extensive prompt engineering~. However, these methods require meticulously designed prompts to achieve the best results. Another research direction focuses on fine-tuning smaller models~ on GUI-specific datasets to endow them with GUI grounding capabilities and the ability to break down high-level instructions, thereby enhancing their operational efficiency. Despite these advancements, most current agents are still confined to passively following explicit instructions and are unable to proactively predict user needs. Moreover, they do not take into account any user preferences when performing tasks. Some studies focus on proactively clarifying users' ambiguous instructions~; however, these studies still require users to provide initial instructions. Proactive Agent~ predicts potential tasks by monitoring user activities and environmental states, but the input is text-only, and the task scenarios are mainly limited to computer or web environments rather than mobile ones.

benchmark_dataset/papers/ICLR2026_0004_2505.12299/metadata.json

@@ -0,0 +1,93 @@
+{
+  "paper_id": "ICLR2026_0004_2505.12299",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "MobileIPL: Enhancing Mobile Agents Thinking Process via Iterative Preference Learning",
+  "authors": [
+    "Kun Huang",
+    "Weikai Xu",
+    "Yuxuan Liu",
+    "Quandong Wang",
+    "Pengzhi Gao",
+    "Wei Liu",
+    "Jian Luan",
+    "Bin Wang",
+    "Bo An"
+  ],
+  "domain_score": 27,
+  "domain_areas": [
+    "pretraining_posttraining_instruction_alignment",
+    "test_time_reasoning_compute",
+    "rag_agents_tools",
+    "multimodal",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "PS8iu4PxKz",
+  "openreview_forum": "PS8iu4PxKz",
+  "openreview_url": "https://openreview.net/forum?id=PS8iu4PxKz",
+  "arxiv_id": "2505.12299",
+  "arxiv_id_versioned": "2505.12299v4",
+  "arxiv_abs_url": "http://arxiv.org/abs/2505.12299v4",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2505.12299v4",
+  "arxiv_source_url": "https://arxiv.org/e-print/2505.12299",
+  "arxiv_title": "MobileIPL: Enhancing Mobile Agents Thinking Process via Iterative Preference Learning",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-05-18T08:28:05Z",
+  "arxiv_updated": "2026-03-21T09:25:27Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 2,
+  "status": "ok",
+  "main_tex_original_path": "iclr2026_conference.tex",
+  "expanded_inputs_count": 1,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "achiam2023gpt",
+    "xu2025llm",
+    "xu2025mobile",
+    "sun-etal-2024-determlr",
+    "liu2026come",
+    "lieffects",
+    "wen2023empowering",
+    "liu2025mobilesteward",
+    "chen2025step",
+    "yang2023appagent",
+    "zheng2024gpt",
+    "qin2025ui",
+    "teamqwen2",
+    "ding2024mobileagent",
+    "li2024appagent",
+    "wang2024mobile",
+    "Luoling",
+    "cheng2024seeclick",
+    "wu2024atlas",
+    "niu2024screenagent",
+    "lu2024gui",
+    "gou2024navigating",
+    "wang2025fedmobileagent",
+    "you2024ferret",
+    "baechler2024screenai",
+    "zhang2024llamatouch",
+    "nong2024mobileflow",
+    "xu2024aguvis",
+    "qinghong2024showui",
+    "dorka2024training",
+    "rafailov2024direct",
+    "azar2024general",
+    "ethayarajh2023human",
+    "schulman2017proximal",
+    "luong2024reft",
+    "zhang2024rest",
+    "xie2024monte",
+    "bai2024digirl",
+    "wang2024distrl",
+    "wu2025reachagent",
+    "jiao2025tcpo",
+    "li2025treepo",
+    "hou2025treerl",
+    "guo2025segment"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0004_2505.12299/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7a7bde87a273b44254b6b3ff1fff3df9d5fed973551ac5a62c8af70c013f772
+size 4871850

benchmark_dataset/papers/ICLR2026_0004_2505.12299/source.tex

@@ -0,0 +1,995 @@
+\documentclass{article}
+\usepackage{iclr2026_conference,times}
+\iclrfinalcopy
+
+
+\usepackage{amsmath,amsfonts,bm}
+
+\newcommand{\figleft}{{\em (Left)}}
+\newcommand{\figcenter}{{\em (Center)}}
+\newcommand{\figright}{{\em (Right)}}
+\newcommand{\figtop}{{\em (Top)}}
+\newcommand{\figbottom}{{\em (Bottom)}}
+\newcommand{\captiona}{{\em (a)}}
+\newcommand{\captionb}{{\em (b)}}
+\newcommand{\captionc}{{\em (c)}}
+\newcommand{\captiond}{{\em (d)}}
+
+\newcommand{\newterm}[1]{{\bf #1}}
+
+
+\def\figref#1{figure~\ref{#1}}
+\def\Figref#1{Figure~\ref{#1}}
+\def\twofigref#1#2{figures \ref{#1} and \ref{#2}}
+\def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}}
+\def\secref#1{section~\ref{#1}}
+\def\Secref#1{Section~\ref{#1}}
+\def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}}
+\def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}}
+\def\eqref#1{equation~\ref{#1}}
+\def\Eqref#1{Equation~\ref{#1}}
+\def\plaineqref#1{\ref{#1}}
+\def\chapref#1{chapter~\ref{#1}}
+\def\Chapref#1{Chapter~\ref{#1}}
+\def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}}
+\def\algref#1{algorithm~\ref{#1}}
+\def\Algref#1{Algorithm~\ref{#1}}
+\def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}}
+\def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}}
+\def\partref#1{part~\ref{#1}}
+\def\Partref#1{Part~\ref{#1}}
+\def\twopartref#1#2{parts \ref{#1} and \ref{#2}}
+
+\def\ceil#1{\lceil #1 \rceil}
+\def\floor#1{\lfloor #1 \rfloor}
+\def\1{\bm{1}}
+\newcommand{\train}{\mathcal{D}}
+\newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}}
+\newcommand{\test}{\mathcal{D_{\mathrm{test}}}}
+
+\def\eps{{\epsilon}}
+
+
+\def\reta{{\textnormal{$\eta$}}}
+\def\ra{{\textnormal{a}}}
+\def\rb{{\textnormal{b}}}
+\def\rc{{\textnormal{c}}}
+\def\rd{{\textnormal{d}}}
+\def\re{{\textnormal{e}}}
+\def\rf{{\textnormal{f}}}
+\def\rg{{\textnormal{g}}}
+\def\rh{{\textnormal{h}}}
+\def\ri{{\textnormal{i}}}
+\def\rj{{\textnormal{j}}}
+\def\rk{{\textnormal{k}}}
+\def\rl{{\textnormal{l}}}
+\def\rn{{\textnormal{n}}}
+\def\ro{{\textnormal{o}}}
+\def\rp{{\textnormal{p}}}
+\def\rq{{\textnormal{q}}}
+\def\rr{{\textnormal{r}}}
+\def\rs{{\textnormal{s}}}
+\def\rt{{\textnormal{t}}}
+\def\ru{{\textnormal{u}}}
+\def\rv{{\textnormal{v}}}
+\def\rw{{\textnormal{w}}}
+\def\rx{{\textnormal{x}}}
+\def\ry{{\textnormal{y}}}
+\def\rz{{\textnormal{z}}}
+
+\def\rvepsilon{{\mathbf{\epsilon}}}
+\def\rvtheta{{\mathbf{\theta}}}
+\def\rva{{\mathbf{a}}}
+\def\rvb{{\mathbf{b}}}
+\def\rvc{{\mathbf{c}}}
+\def\rvd{{\mathbf{d}}}
+\def\rve{{\mathbf{e}}}
+\def\rvf{{\mathbf{f}}}
+\def\rvg{{\mathbf{g}}}
+\def\rvh{{\mathbf{h}}}
+\def\rvu{{\mathbf{i}}}
+\def\rvj{{\mathbf{j}}}
+\def\rvk{{\mathbf{k}}}
+\def\rvl{{\mathbf{l}}}
+\def\rvm{{\mathbf{m}}}
+\def\rvn{{\mathbf{n}}}
+\def\rvo{{\mathbf{o}}}
+\def\rvp{{\mathbf{p}}}
+\def\rvq{{\mathbf{q}}}
+\def\rvr{{\mathbf{r}}}
+\def\rvs{{\mathbf{s}}}
+\def\rvt{{\mathbf{t}}}
+\def\rvu{{\mathbf{u}}}
+\def\rvv{{\mathbf{v}}}
+\def\rvw{{\mathbf{w}}}
+\def\rvx{{\mathbf{x}}}
+\def\rvy{{\mathbf{y}}}
+\def\rvz{{\mathbf{z}}}
+
+\def\erva{{\textnormal{a}}}
+\def\ervb{{\textnormal{b}}}
+\def\ervc{{\textnormal{c}}}
+\def\ervd{{\textnormal{d}}}
+\def\erve{{\textnormal{e}}}
+\def\ervf{{\textnormal{f}}}
+\def\ervg{{\textnormal{g}}}
+\def\ervh{{\textnormal{h}}}
+\def\ervi{{\textnormal{i}}}
+\def\ervj{{\textnormal{j}}}
+\def\ervk{{\textnormal{k}}}
+\def\ervl{{\textnormal{l}}}
+\def\ervm{{\textnormal{m}}}
+\def\ervn{{\textnormal{n}}}
+\def\ervo{{\textnormal{o}}}
+\def\ervp{{\textnormal{p}}}
+\def\ervq{{\textnormal{q}}}
+\def\ervr{{\textnormal{r}}}
+\def\ervs{{\textnormal{s}}}
+\def\ervt{{\textnormal{t}}}
+\def\ervu{{\textnormal{u}}}
+\def\ervv{{\textnormal{v}}}
+\def\ervw{{\textnormal{w}}}
+\def\ervx{{\textnormal{x}}}
+\def\ervy{{\textnormal{y}}}
+\def\ervz{{\textnormal{z}}}
+
+\def\rmA{{\mathbf{A}}}
+\def\rmB{{\mathbf{B}}}
+\def\rmC{{\mathbf{C}}}
+\def\rmD{{\mathbf{D}}}
+\def\rmE{{\mathbf{E}}}
+\def\rmF{{\mathbf{F}}}
+\def\rmG{{\mathbf{G}}}
+\def\rmH{{\mathbf{H}}}
+\def\rmI{{\mathbf{I}}}
+\def\rmJ{{\mathbf{J}}}
+\def\rmK{{\mathbf{K}}}
+\def\rmL{{\mathbf{L}}}
+\def\rmM{{\mathbf{M}}}
+\def\rmN{{\mathbf{N}}}
+\def\rmO{{\mathbf{O}}}
+\def\rmP{{\mathbf{P}}}
+\def\rmQ{{\mathbf{Q}}}
+\def\rmR{{\mathbf{R}}}
+\def\rmS{{\mathbf{S}}}
+\def\rmT{{\mathbf{T}}}
+\def\rmU{{\mathbf{U}}}
+\def\rmV{{\mathbf{V}}}
+\def\rmW{{\mathbf{W}}}
+\def\rmX{{\mathbf{X}}}
+\def\rmY{{\mathbf{Y}}}
+\def\rmZ{{\mathbf{Z}}}
+
+\def\ermA{{\textnormal{A}}}
+\def\ermB{{\textnormal{B}}}
+\def\ermC{{\textnormal{C}}}
+\def\ermD{{\textnormal{D}}}
+\def\ermE{{\textnormal{E}}}
+\def\ermF{{\textnormal{F}}}
+\def\ermG{{\textnormal{G}}}
+\def\ermH{{\textnormal{H}}}
+\def\ermI{{\textnormal{I}}}
+\def\ermJ{{\textnormal{J}}}
+\def\ermK{{\textnormal{K}}}
+\def\ermL{{\textnormal{L}}}
+\def\ermM{{\textnormal{M}}}
+\def\ermN{{\textnormal{N}}}
+\def\ermO{{\textnormal{O}}}
+\def\ermP{{\textnormal{P}}}
+\def\ermQ{{\textnormal{Q}}}
+\def\ermR{{\textnormal{R}}}
+\def\ermS{{\textnormal{S}}}
+\def\ermT{{\textnormal{T}}}
+\def\ermU{{\textnormal{U}}}
+\def\ermV{{\textnormal{V}}}
+\def\ermW{{\textnormal{W}}}
+\def\ermX{{\textnormal{X}}}
+\def\ermY{{\textnormal{Y}}}
+\def\ermZ{{\textnormal{Z}}}
+
+\def\vzero{{\bm{0}}}
+\def\vone{{\bm{1}}}
+\def\vmu{{\bm{\mu}}}
+\def\vtheta{{\bm{\theta}}}
+\def\va{{\bm{a}}}
+\def\vb{{\bm{b}}}
+\def\vc{{\bm{c}}}
+\def\vd{{\bm{d}}}
+\def\ve{{\bm{e}}}
+\def\vf{{\bm{f}}}
+\def\vg{{\bm{g}}}
+\def\vh{{\bm{h}}}
+\def\vi{{\bm{i}}}
+\def\vj{{\bm{j}}}
+\def\vk{{\bm{k}}}
+\def\vl{{\bm{l}}}
+\def\vm{{\bm{m}}}
+\def\vn{{\bm{n}}}
+\def\vo{{\bm{o}}}
+\def\vp{{\bm{p}}}
+\def\vq{{\bm{q}}}
+\def\vr{{\bm{r}}}
+\def\vs{{\bm{s}}}
+\def\vt{{\bm{t}}}
+\def\vu{{\bm{u}}}
+\def\vv{{\bm{v}}}
+\def\vw{{\bm{w}}}
+\def\vx{{\bm{x}}}
+\def\vy{{\bm{y}}}
+\def\vz{{\bm{z}}}
+
+\def\evalpha{{\alpha}}
+\def\evbeta{{\beta}}
+\def\evepsilon{{\epsilon}}
+\def\evlambda{{\lambda}}
+\def\evomega{{\omega}}
+\def\evmu{{\mu}}
+\def\evpsi{{\psi}}
+\def\evsigma{{\sigma}}
+\def\evtheta{{\theta}}
+\def\eva{{a}}
+\def\evb{{b}}
+\def\evc{{c}}
+\def\evd{{d}}
+\def\eve{{e}}
+\def\evf{{f}}
+\def\evg{{g}}
+\def\evh{{h}}
+\def\evi{{i}}
+\def\evj{{j}}
+\def\evk{{k}}
+\def\evl{{l}}
+\def\evm{{m}}
+\def\evn{{n}}
+\def\evo{{o}}
+\def\evp{{p}}
+\def\evq{{q}}
+\def\evr{{r}}
+\def\evs{{s}}
+\def\evt{{t}}
+\def\evu{{u}}
+\def\evv{{v}}
+\def\evw{{w}}
+\def\evx{{x}}
+\def\evy{{y}}
+\def\evz{{z}}
+
+\def\mA{{\bm{A}}}
+\def\mB{{\bm{B}}}
+\def\mC{{\bm{C}}}
+\def\mD{{\bm{D}}}
+\def\mE{{\bm{E}}}
+\def\mF{{\bm{F}}}
+\def\mG{{\bm{G}}}
+\def\mH{{\bm{H}}}
+\def\mI{{\bm{I}}}
+\def\mJ{{\bm{J}}}
+\def\mK{{\bm{K}}}
+\def\mL{{\bm{L}}}
+\def\mM{{\bm{M}}}
+\def\mN{{\bm{N}}}
+\def\mO{{\bm{O}}}
+\def\mP{{\bm{P}}}
+\def\mQ{{\bm{Q}}}
+\def\mR{{\bm{R}}}
+\def\mS{{\bm{S}}}
+\def\mT{{\bm{T}}}
+\def\mU{{\bm{U}}}
+\def\mV{{\bm{V}}}
+\def\mW{{\bm{W}}}
+\def\mX{{\bm{X}}}
+\def\mY{{\bm{Y}}}
+\def\mZ{{\bm{Z}}}
+\def\mBeta{{\bm{\beta}}}
+\def\mPhi{{\bm{\Phi}}}
+\def\mLambda{{\bm{\Lambda}}}
+\def\mSigma{{\bm{\Sigma}}}
+
+\DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl}
+\SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{n}
+\newcommand{\tens}[1]{\bm{\mathsfit{#1}}}
+\def\tA{{\tens{A}}}
+\def\tB{{\tens{B}}}
+\def\tC{{\tens{C}}}
+\def\tD{{\tens{D}}}
+\def\tE{{\tens{E}}}
+\def\tF{{\tens{F}}}
+\def\tG{{\tens{G}}}
+\def\tH{{\tens{H}}}
+\def\tI{{\tens{I}}}
+\def\tJ{{\tens{J}}}
+\def\tK{{\tens{K}}}
+\def\tL{{\tens{L}}}
+\def\tM{{\tens{M}}}
+\def\tN{{\tens{N}}}
+\def\tO{{\tens{O}}}
+\def\tP{{\tens{P}}}
+\def\tQ{{\tens{Q}}}
+\def\tR{{\tens{R}}}
+\def\tS{{\tens{S}}}
+\def\tT{{\tens{T}}}
+\def\tU{{\tens{U}}}
+\def\tV{{\tens{V}}}
+\def\tW{{\tens{W}}}
+\def\tX{{\tens{X}}}
+\def\tY{{\tens{Y}}}
+\def\tZ{{\tens{Z}}}
+
+
+\def\gA{{\mathcal{A}}}
+\def\gB{{\mathcal{B}}}
+\def\gC{{\mathcal{C}}}
+\def\gD{{\mathcal{D}}}
+\def\gE{{\mathcal{E}}}
+\def\gF{{\mathcal{F}}}
+\def\gG{{\mathcal{G}}}
+\def\gH{{\mathcal{H}}}
+\def\gI{{\mathcal{I}}}
+\def\gJ{{\mathcal{J}}}
+\def\gK{{\mathcal{K}}}
+\def\gL{{\mathcal{L}}}
+\def\gM{{\mathcal{M}}}
+\def\gN{{\mathcal{N}}}
+\def\gO{{\mathcal{O}}}
+\def\gP{{\mathcal{P}}}
+\def\gQ{{\mathcal{Q}}}
+\def\gR{{\mathcal{R}}}
+\def\gS{{\mathcal{S}}}
+\def\gT{{\mathcal{T}}}
+\def\gU{{\mathcal{U}}}
+\def\gV{{\mathcal{V}}}
+\def\gW{{\mathcal{W}}}
+\def\gX{{\mathcal{X}}}
+\def\gY{{\mathcal{Y}}}
+\def\gZ{{\mathcal{Z}}}
+
+\def\sA{{\mathbb{A}}}
+\def\sB{{\mathbb{B}}}
+\def\sC{{\mathbb{C}}}
+\def\sD{{\mathbb{D}}}
+\def\sF{{\mathbb{F}}}
+\def\sG{{\mathbb{G}}}
+\def\sH{{\mathbb{H}}}
+\def\sI{{\mathbb{I}}}
+\def\sJ{{\mathbb{J}}}
+\def\sK{{\mathbb{K}}}
+\def\sL{{\mathbb{L}}}
+\def\sM{{\mathbb{M}}}
+\def\sN{{\mathbb{N}}}
+\def\sO{{\mathbb{O}}}
+\def\sP{{\mathbb{P}}}
+\def\sQ{{\mathbb{Q}}}
+\def\sR{{\mathbb{R}}}
+\def\sS{{\mathbb{S}}}
+\def\sT{{\mathbb{T}}}
+\def\sU{{\mathbb{U}}}
+\def\sV{{\mathbb{V}}}
+\def\sW{{\mathbb{W}}}
+\def\sX{{\mathbb{X}}}
+\def\sY{{\mathbb{Y}}}
+\def\sZ{{\mathbb{Z}}}
+
+\def\emLambda{{\Lambda}}
+\def\emA{{A}}
+\def\emB{{B}}
+\def\emC{{C}}
+\def\emD{{D}}
+\def\emE{{E}}
+\def\emF{{F}}
+\def\emG{{G}}
+\def\emH{{H}}
+\def\emI{{I}}
+\def\emJ{{J}}
+\def\emK{{K}}
+\def\emL{{L}}
+\def\emM{{M}}
+\def\emN{{N}}
+\def\emO{{O}}
+\def\emP{{P}}
+\def\emQ{{Q}}
+\def\emR{{R}}
+\def\emS{{S}}
+\def\emT{{T}}
+\def\emU{{U}}
+\def\emV{{V}}
+\def\emW{{W}}
+\def\emX{{X}}
+\def\emY{{Y}}
+\def\emZ{{Z}}
+\def\emSigma{{\Sigma}}
+
+\newcommand{\etens}[1]{\mathsfit{#1}}
+\def\etLambda{{\etens{\Lambda}}}
+\def\etA{{\etens{A}}}
+\def\etB{{\etens{B}}}
+\def\etC{{\etens{C}}}
+\def\etD{{\etens{D}}}
+\def\etE{{\etens{E}}}
+\def\etF{{\etens{F}}}
+\def\etG{{\etens{G}}}
+\def\etH{{\etens{H}}}
+\def\etI{{\etens{I}}}
+\def\etJ{{\etens{J}}}
+\def\etK{{\etens{K}}}
+\def\etL{{\etens{L}}}
+\def\etM{{\etens{M}}}
+\def\etN{{\etens{N}}}
+\def\etO{{\etens{O}}}
+\def\etP{{\etens{P}}}
+\def\etQ{{\etens{Q}}}
+\def\etR{{\etens{R}}}
+\def\etS{{\etens{S}}}
+\def\etT{{\etens{T}}}
+\def\etU{{\etens{U}}}
+\def\etV{{\etens{V}}}
+\def\etW{{\etens{W}}}
+\def\etX{{\etens{X}}}
+\def\etY{{\etens{Y}}}
+\def\etZ{{\etens{Z}}}
+
+\newcommand{\pdata}{p_{\rm{data}}}
+\newcommand{\ptrain}{\hat{p}_{\rm{data}}}
+\newcommand{\Ptrain}{\hat{P}_{\rm{data}}}
+\newcommand{\pmodel}{p_{\rm{model}}}
+\newcommand{\Pmodel}{P_{\rm{model}}}
+\newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}}
+\newcommand{\pencode}{p_{\rm{encoder}}}
+\newcommand{\pdecode}{p_{\rm{decoder}}}
+\newcommand{\precons}{p_{\rm{reconstruct}}}
+
+\newcommand{\laplace}{\mathrm{Laplace}}
+
+\newcommand{\E}{\mathbb{E}}
+\newcommand{\Ls}{\mathcal{L}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\emp}{\tilde{p}}
+\newcommand{\lr}{\alpha}
+\newcommand{\reg}{\lambda}
+\newcommand{\rect}{\mathrm{rectifier}}
+\newcommand{\softmax}{\mathrm{softmax}}
+\newcommand{\sigmoid}{\sigma}
+\newcommand{\softplus}{\zeta}
+\newcommand{\KL}{D_{\mathrm{KL}}}
+\newcommand{\Var}{\mathrm{Var}}
+\newcommand{\standarderror}{\mathrm{SE}}
+\newcommand{\Cov}{\mathrm{Cov}}
+\newcommand{\normlzero}{L^0}
+\newcommand{\normlone}{L^1}
+\newcommand{\normltwo}{L^2}
+\newcommand{\normlp}{L^p}
+\newcommand{\normmax}{L^\infty}
+
+\newcommand{\parents}{Pa}
+
+\DeclareMathOperator*{\argmax}{arg\,max}
+\DeclareMathOperator*{\argmin}{arg\,min}
+
+\DeclareMathOperator{\sign}{sign}
+\DeclareMathOperator{\Tr}{Tr}
+\let\ab\allowbreak
+
+
+\usepackage{hyperref}
+\usepackage{url}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{booktabs}
+\usepackage{amsfonts}
+\usepackage{nicefrac}
+\usepackage{microtype}
+\usepackage{xcolor}
+\usepackage{algorithmic}
+\usepackage[vlined, ruled]{algorithm2e}
+\usepackage[utf8]{inputenc}
+\usepackage{multirow}
+\usepackage{booktabs}
+\usepackage{graphicx}
+\usepackage{microtype}
+\usepackage{subcaption}
+\usepackage{inconsolata}
+\usepackage{times}
+\usepackage{latexsym}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage{microtype}
+\usepackage{inconsolata}
+\usepackage{graphicx}
+\usepackage{colortbl}
+\usepackage{amsmath}
+\usepackage{booktabs}
+\usepackage{amssymb}
+\usepackage{adjustbox}
+\usepackage{pifont}
+\newcommand{\cmark}{\ding{51}}
+\newcommand{\xmark}{\ding{55}}
+\usepackage{bm}
+\usepackage{longtable}
+\usepackage{multirow}
+\usepackage{multicol}
+\usepackage[framemethod=TikZ]{mdframed}
+\usepackage{xcolor}
+\usepackage{url}
+\usepackage{enumitem}
+\usepackage{verbatim}
+\usepackage{afterpage}
+\usepackage{subcaption}
+\usepackage{threeparttable}
+\usepackage{array}
+\usepackage{enumitem}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\usepackage{hyperref}
+\usepackage{mathtools}
+\usepackage{amsthm}
+\usepackage{siunitx}
+\usepackage{amsfonts}
+\usepackage{longtable}
+\usepackage{xspace}
+\usepackage{listings}
+\usepackage{wrapfig}
+\usepackage{graphicx}
+\newcommand{\cofirst}{$^\ast$}
+\newcommand{\corresponding}{\textsuperscript{$\dagger$}}
+\newcommand{\addnote}{$^\ddagger$}
+\newcommand{\bb}[1]{\textcolor{blue}{#1}}
+\newcommand{\fix}{\marginpar{FIX}}
+\newcommand{\new}{\marginpar{NEW}}
+
+
+\begin{document}
+
+
+\renewcommand{\thefootnote}{\fnsymbol{footnote}}
+ \footnotetext[1]{Equal contribution.}
+ \footnotetext[2]{Work done during the internship at XiaoMi. }
+ \footnotetext[3]{Bo An is the corresponding author.}
+
+\begin{abstract}
+The Chain of Action-Planning Thoughts (CoaT) paradigm has been shown to improve the reasoning performance of VLM-based mobile agents in GUI tasks.
+However, the scarcity of diverse CoaT trajectories limits the expressiveness and generalization ability of such agents. While self-training is commonly employed to address data scarcity, existing approaches either overlook the correctness of intermediate reasoning steps or depend on expensive process-level annotations to construct process reward models (PRM).
+To address the above problems, we propose an \textbf{\underline{I}}terative \textbf{\underline{P}}reference \textbf{\underline{L}}earning (\textit{IPL}) that constructs a CoaT-tree through iterative sampling, scores leaf nodes using rule-based reward, and backpropagates feedback to derive Thinking-level Direct Preference Optimization (T-DPO) pairs.
+To prevent overfitting during warm-up supervised fine-tuning, we further introduce a three-stage instruction evolution, which leverages GPT-4o to generate diverse Q\&A pairs based on real mobile UI screenshots, enhancing both generality and layout understanding\footnote[4]{\url{https://huggingface.co/datasets/xwk123/MobileIPL-dataset}}.
+Experiments on three standard Mobile GUI-agent benchmarks
+demonstrate that our agent \textit{MobileIPL} outperforms strong baselines, including continual pretraining models such as OS-ATLAS and UI-TARS. It achieves state-of-the-art performance across three standard Mobile GUI-Agents benchmarks and shows strong generalization to out-of-domain scenarios.
+\end{abstract}
+
+\section{Introduction}
+
+VLM-based mobile agents~ have attracted considerable attention due to their ability to seamlessly interact with mobile graphical user interfaces (GUIs) and their potential to autonomously perform daily tasks.
+Since actions are not directly specified in user instructions, mobile agents benefit from generating intermediate thoughts aligned with the current GUI context.
+Recent work such as \textsc{AITZ} has demonstrated that the Chain of Action-Planning Thoughts (CoaT) pattern---resembling the slow-thinking ``System 2'' process---is particularly effective in GUI domains.
+
+However, directly applying supervised fine-tuning (SFT) on CoaT trajectories may cause overfitting, leading the model to be trapped in fixed reasoning patterns.
+To address this limitation, recent studies in the general domain have explored self-training strategies. These approaches typically utilize the correctness of the final answer in output as a reward signal to train the model. While effective in some contexts, relying solely on final answers overlooks the quality of intermediate reasoning steps, which can result in reward hacking and suboptimal reasoning processes.
+Some search-based approaches, such as ReST-MCTS~, tackle this problem by learning a process reward model (PRM) to evaluate individual reasoning steps.
+However, these approaches often require large-scale manual annotation of intermediate steps~. This challenge is especially severe in the Mobile GUI Agent domain.
+Unlike text-based tasks in coding or math, GUI environments rely on real devices or simulators, making step-level reward annotation significantly more costly and labor-intensive.
+
+To address these limitations, we propose an iterative sampling framework that constructs a CoaT-tree based on Monte Carlo Tree Search (MCTS).
+Instead of relying on a PRM, we score each reasoning step and construct thinking-level DPO (T-DPO) pairs without manual step annotation.
+Specifically, we perform multi-turn dialogue with a vision-language model (VLM) to incrementally build a CoaT-tree, where each node corresponds to a sampled response at a given reasoning step, conditioned on the dialogue history. This hierarchical structure captures diverse reasoning paths and facilitates fine-grained assessment of intermediate thoughts.
+We first assign rewards to the leaf node, and then propagate these signals backward through the CoaT-tree to earlier reasoning steps. Based on the resulting values, we construct thinking-level DPO pairs to help agents optimize both final actions and the overall quality of their reasoning.
+
+To mitigate the lack of diversity after warm-up SFT, we adopt an instruction evolution strategy. Specifically, we generate diverse Q\&A pairs grounded in real mobile UI screenshots from downstream training datasets. These Q\&A pairs serve two purposes: (1) prevent agents from overfitting to static downstream instructions by introducing varied reasoning contexts, and (2) improve agents' understanding of UI layouts through visually grounded question-answering.
+We evaluate our approach on the CoaT dataset \textsc{AITZ} and long-horizon dataset AMEX, where it outperforms state-of-the-art GUI-agent continual pretraining agents such as OS-ATLAS~ (+4.04\%) and UI-TARS~ (+3.54\%). Furthermore, experiments on the AndroidControl dataset demonstrate the strong generalization capability of our method to unseen apps and instructions (tasks). Under limited training resources, IPL consistently outperforms naive DPO using only half of the data for one iterative training round (+4.5\%), or one-fifth of the data for two iterative training rounds (+0.3\%).
+Analytical experiments show instruction evolution simultaneously improves both the diversity and quality of reasoning.
+
+Overall, our main contributions are summarized as follows:
+
+$\bullet$We propose an iterative framework to construct a CoaT-tree, and utilize rule-based rewards with backward credit assignment to form thinking-level DPO pairs for reasoning optimization.
+
+$\bullet$ We introduce an instruction evolution strategy to mitigate overfitting during warm-up SFT, enhancing the model's generalization and UI understanding.
+
+$\bullet$ We demonstrate the effectiveness of our method on three GUI-agent benchmarks: AITZ, AMEX, and AndroidControl. Furthermore, our approach even surpasses SoTA continual pretraining models.
+
+
+\section{Methodology}
+In this section, we first introduce the multi-turn thinking process formulation ~(\S~\ref{3.1}) and explain our method.
+As shown in Figure \ref{fig:main}, our method starts with instruction evolution strategy~(\S~\ref{3.2}) to enhance output diversity in warm-up SFT stage.
+Then, a CoaT-tree through iterative sampling~(\S~\ref{3.3}) is employed for each action.
+Every leaf node represents a complete action and is scored using a rule-based reward function. We then backpropagate the rewards along the tree to assign credit to intermediate reasoning steps. This process yields thinking-level contrastive pairs for DPO, which further improves the model’s reasoning ability. The detailed process is presented in Algorithm \ref{alg: ipl_algorithm}.
+
+\subsection{Multi-turn Thinking Process Formulation} \label{3.1}
+Each mobile GUI task contains a trajectory $\mathcal{T}$, several pages $u$,
+actions $\hat{a}$, and an instruction $I$, which can be represented as:
+\begin{equation}
+\mathcal{T} = \big\{I, u_0, \hat{a}_0, u_1, \hat{a}_1, \cdots, u_{n}, \hat{a}_{n}\}
+\end{equation}
+We formulate action $\hat{a}_{i}$ in the CoaT reasoning process as a multi-turn dialogue $\hat{a}_{i}=[s_1, s_2, s_3, s_4]$, where $s_i$ represents description, action-thought, action-decision, and grounding, respectively. This thinking paradigm based on the thinking–decision–grounding triplet, has been widely validated as effective in previous GUI works .
+So the reasoning process can be formulated as:
+\begin{equation}
+s_1 = \mathrm{Description} ( P_1, u_{i} )
+\end{equation}
+\begin{equation}
+s_2 = \mathrm{Thought} ( P_2, u_{i}, I, \hat{a}_0,\cdots, \hat{a}_{i-1}, s_1 )
+\end{equation}
+$P$ represents each round of dialogue input prompt, $I$ is the task instruction, $u$ is the current GUI, and $\hat{a}_i$ is the step $i$ history action.
+Agents perform poorly when decoding the entire reasoning process in a single step, which is because image modal $u$ dominates the input tokens, surpassing textual instructions $I$ and action history $\hat{a}_i$, and diverting their attention away from the textual details.
+During autoregressive training, the agent is unaware that producing a final answer conforming to the required format is indispensable throughout the reasoning process.
+Multi-turn thinking process effectively mitigates this problem, because additional dialogue steps guarantee a final answer is generated:
+\begin{equation}
+s_3 = \mathrm{Action} ( P_3, u_{i}, I, s_1, s_2 )
+\end{equation}
+\begin{equation}
+s_4 = \mathrm{Grounding} ( P_4, u_{i}, I, s_1, s_2, s_3 )
+\end{equation}
+Previous work either performed RL in GUI-Agent directly on the trajectory without CoaT, missing the detailed thinking process of each action, or forced the model to bear the heavy burden of outputting the entire reasoning process at once.
+In our method, when the reasoning process ends, the final $s_4$ is recorded as $\hat{a}_{n+1}$, step $i$ moves one step forward on the trajectory $\mathcal{T}$ and its thinking step reward is calculated recursively based on final step $s_4$.
+Dialogue-level textual input helps balance cross-modal token proportions and steers the agent’s attention toward the current reasoning step.
+\subsection{Instruction Evolution}\label{3.2}
+
+
+As discussed in the previous section, the CoaT patterns in the mobile agent domain are typically fixed. As a result, agents tend to overfit these static paradigms and struggle to generate diverse reasoning paths after the warm-up SFT training (as detailed in Sec \ref{sec:Output Space Sampling}). To address this issue, we enhance the original training trajectories, denoted as $\mathcal{T}$, by appending additional Q\&A annotations to UI screenshots through an instruction evolution process, thereby creating a new dataset $\mathcal{Q}$ with a broader range of instruction formats.
+Specifically, as shown in Figure \ref{fig:ins}, the evolution process consists of three levels:
+
+\noindent \textbf{Level I: General GUI Q\&A tasks}. Grounding, Reference (Ref), and Page Descriptions are aimed at enhancing the agent's foundational capabilities. These tasks are proven to be the core capabilities of GUI agents during the pre-training.
+
+\noindent \textbf{Level II: Widget caption and relationships}. Descriptions of widget functions and the nested partition relationships between widgets. These tasks help agents understand the relationships between widgets, as previous work has found that agents tend to click on the textview, even in scenarios where the textview and the button are separate.
+
+\noindent \textbf{Level III: GUI advanced FAQ}. Inspired by , we design an advanced FAQ that features more complex Q\&A, including descriptions of the page’s structural framework as well as expectations and predictions about navigation outcomes triggered by control interactions.
+
+\textbf{Warm-up Supervised Fine-tuning}:
+To develop agents with standard thinking format and expand the reasoning space, we mix $\mathcal{T}$ and the instruction evolution data $\mathcal{Q}$, then perform warm-up SFT on
+$\mathcal D = \Big\{\mathcal{T},\mathcal{Q}\Big\}= \Big\{(u, e)^{(i)}\Big\}_{i=1}^{|\mathcal D|}$,
+where $u$ represents the prior knowledge (instructions, screenshot and action history) from $\mathcal{T}$ or the questions from $\mathcal{Q}$, and $e$ is the reasoning process from $\mathcal{T}$ or the answer from $\mathcal{Q}$ which is organized into multi-turn dialogues.
+To ensure output diversity, we select an earlier checkpoint with better potential correct space and diverse output to serve as the seed policy model. More details can be seen in Appendix \ref{appendix:seed_policy_model}.
+\subsection{Iterative Preference Learning}\label{3.3}
+After the warm-up SFT, the agent acquires basic GUI capabilities. We construct a CoaT-tree by iteratively sampling each reasoning step and then assign a score to the leaf nodes based on a rule-based reward function. Using these scores, we generate thinking-level DPO pairs to optimize the agent's reasoning process.
+
+\noindent \textbf{Iterative Sampling \& Rule-based Reward.}
+We iteratively sample each reasoning step along the CoaT paradigm .
+The $\mathcal{K}$ sampling results $(\hat{s}_{t}|\hat{s}_{1:t-1})^\mathcal{K}$ at step $t$ can be expressed as:
+\begin{equation}
+\hat{s}_t = \Big\{ (\hat{s}^{(k)}_{t} \mid \hat{s}_0, \cdots, \hat{s}_{t-1}) \Big\}^K_{k=1}
+\end{equation}
+Naturally, the final step in CoaT (the leaf node in the sampling tree) expresses a reward compared with the ground truth action $a^*$, which is then propagated back to other intra-nodes.
+The formula for the rule-based reward of leaf nodes is as follows:
+\begin{equation}
+\small
+v(s_t) =
+ \begin{cases}
+ 1, & s_t=a* \\
+ v_{type} + score_{match}, & type(s_t \sim a^*) \\
+ 0, & others
+ \end{cases}
+\label{eq:leaf_value}
+\end{equation}
+
+
+\begin{equation}
+\small
+score_{match}=
+\begin{cases}
+ v_{format} + 1\cdot (1-d(x,y))-(v_{type}+v_{format})\cdot d(x,y), & type(a*)=CLICK\\
+ v_{format} + (1 - v_{type} - v_{format}) \cdot F_1, & type(a*)=INPUT \\
+ 0, & others \\
+\end{cases}
+\end{equation}
+
+
+The reward score $v(s_t)$ ranges from 0 to 1, with a fully correct prediction receiving a score of 1.
+We use $v_{\text{type}}$ and $v_{\text{format}}$ to indicate whether the predicted action type and output format match the ground truth.
+For \texttt{click} and \texttt{input} actions, we further evaluate their internal structure using smooth rewards based on spatial distance $d(x,y)$ and text match $F_1$. The final reward is computed from the similarity between the prediction and the ground truth:
+
+\begin{itemize}
+ \item \textbf{Click:} A distance-based score between the predicted and ground-truth coordinates, normalized to $[0,1]$; smaller distances yield higher scores.
+ \item \textbf{Input:} The $F_1$ score between the predicted and ground-truth strings; greater textual overlap yields higher scores.
+\end{itemize}
+
+The full reward is defined in Equation~\ref{eq:leaf_value} and discussed further in Section~\ref{sec:Rule-based Reward Design}.
+
+Based on the structure of the CoaT-tree, we recursively compute the value of each intermediate reasoning step. Specifically, the value of $s_{t-1}$ is computed as the average value of its $\mathcal{K}$ sampled continuations at $s_t$:
+\begin{equation}
+v(s_{t-1}) = c\cdot \frac{1}{\mathcal{K}} \sum_{k=1}^\mathcal{K} v(s_{t}^{(k)})
+\label{eq:intra_value}
+\end{equation}
+Here, $\mathcal{K}$ denotes the number of sampled continuations for each reasoning step, and $c$ is a discount factor. The parameter searching experiment for $\mathcal{K}$ is described in detail in Section \ref{para-searching}.
+
+\noindent \textbf{Contrastive Data Filter.}
+After obtaining the sampling tree and node values, we evaluate the quality of the trees and extract contrastive data.
+We can divided the sampling trees into three categories $\mathcal{R} = \{\alpha, \beta, \gamma\}$ based on their output quality, and the classification standards of $\alpha, \beta, \gamma$ are as follows:
+\begin{equation}
+\small{
+\alpha = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \forall v_k \in \mathcal{S}^{(i)}, v_k=1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+\begin{equation}
+\small{
+\beta = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \exists v_{k}, v_{k'} \in \mathcal{S}^{(i)}, v_{k}=1, v_{k'} \neq 1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+\begin{equation}
+\small{
+\gamma = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \forall v_k \in \mathcal{S}^{(i)}, v_k \neq 1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+$\mathcal{S}^{(i)}$ and $v_k$ refer to the instruction $i$ sampling tree and the $k$-th leaf nodes value of $\mathcal{K}$ sampled output.
+$\alpha$ is considered a perfect sampling tree, which can stably output correct thoughts and actions with in-domain trajectories, $\beta$ represents potential correct trees that can be used to construct contrastive data, and $\gamma$ denotes sampling trees that require refinement.
+${\beta + \gamma}$ is considered a valid sampling space.
+In $\beta$, actions with a value of 1 and as many diverse action types as possible are extracted as positive samples.
+In $\gamma$, the final ground truth action $a^*$ is used as a positive sample, but the intermediate steps of CoaT are not provided, and the pairs can be represented as:
+\begin{equation}
+\begin{aligned}
+\beta_{pairs} &= \langle\hat{s}^{(k)}_{t}\uparrow ,\hat{s}^{(k')}_{t}\downarrow \mid (\hat{s}_1, \dots, \hat{s}_{t-1}), \\
+& ~~~~~~~~~~~~~~ v(\hat{s}^{(k)}_{t}) - v(\hat{s}^{(k')}_{t}) > 1 / \mathcal{K} \rangle
+\end{aligned} \label{eq:dpo_pair1}
+\end{equation}
+\begin{align}
+\gamma_{pairs} &= \langle a^*\uparrow,\hat{s}^{(k)}_{t}\downarrow \mid \hat{s}_1, \dots, \hat{s}_{t-1}\rangle
+\label{eq:dpo_pair2}
+\end{align}
+
+\textbf{Thinking-level Direct Preference Optimization}.
+After CoaT thinking-level Iterative Sampling, several positive and negative example pairs are collected.
+During this stage, the agent policy undergoes updates through the above data-pairs, SFT loss, and CoaT-DPO loss .
+Suppose the agent gets values to pair $\langle +, -\rangle$ at CoaT step $t$, which are named $s^+_{t}$ and $s^-_{t}$; we have the agent performing a comparison for these pairs based on the same thoughts $s_{1:t-1}$, which can be calculated as:
+\begin{equation}
+\begin{aligned}
+\mathcal L_{\mathrm{T\mbox{-}DPO}}= - \mathbb E_{(s_{1:t-1}, s^-_{t},s^+_{t})\sim \mathcal T_s}\bigg[\log\sigma(\beta \log\frac{\pi_\theta(s^+_{t}|s_{1:t-1})}{\pi_{ref}(s^+_{t}|s_{1:t-1})} &\\
+- \beta \log\frac{\pi_\theta(s^-_{t}|s_{1:t-1})}{\pi_{ref}(s^-_{t}|s_{1:t-1})} )\bigg]&,
+\end{aligned}
+\end{equation}
+To further refine the agent’s performance post-optimization, we employ the updated agent as the new base agent to continue collecting contrastive CoaT-action level pairs for additional T-DPO training.
+This iterative process is maintained until the agent reaches the performance bottleneck.
+
+
+\vspace{-9pt}
+\section{Experiments}
+\subsection{Experiments Setups}
+
+\noindent \textbf{Dataset.}
+\textbf{\textsc{AITZ}} is a high-quality trajectory set filtered and re-annotated from AITW , containing four subsets
+, which also includes five types of actions
+\textbf{AMEX} uses the same apps and action space as \textsc{AITZ}, but its task instructions are more complex and detailed, with an average trajectory length of 15+.
+\textbf{AndroidControl} includes OOD datasets, such as app unseen and task unseen.
+
+\noindent \textbf{Metrics.} For evaluation, we use \textbf{Step.Acc} as metrics, consistent with Auto-GUI, measures the agent's performance and uses \textbf{Action Type} to assess the degree of action type matching.
+This metric effectively evaluates the model's planning ability.
+
+\noindent \textbf{Baselines.} Following prior work, we use Qwen2-VL-7B~ as the backbone of our model.
+We select CogAgent , AUTO-GUI, Shpagent, OS-Atlas, UGround, UI-Tars and FedMobileAgent as baseline agents.
+GUI continuous pre-training agents can be further divided into two categories: (1) training the model as a GUI grounding agent, such as OS-Atlas-7B. (2) training the model as a general GUI agent, such as UI-Tars.
+More details are provided in Appendix \ref{appendix:setup}.
+\subsection{Main result}
+
+
+\noindent \textbf{\textsc{AITZ}.}
+As shown in Table \ref{tab:aitz},
+MobileIPL achieves SoTA performance on most metrics.
+The reason for the lower PRESS Acc. is discussed in Section \ref{IPL Scaling} and Appendix \ref{annotation preferences}.
+Multiple rounds of T-DPO improve MobileIPL by more than 10\% (55.40\% -> 69.15\%) compared to the seed model MobileIPL and Qwen2-VL-7B (60.36\% -> 69.15\%).
+Compared to continuous pre-training agents such as Falcon-UI, which is pre-trained on three million GUIs, MobileIPL still surpasses a performance difference of 0.05\%.
+The amount of training data required by our method is substantially smaller than that used by these pre-training approaches.
+
+
+\noindent \textbf{AMEX.}
+As shown in Table \ref{tab:amex}, MobileIPL surpasses the previous SOTA model, SphAgent-7B, by 3.58\%. It also outperforms the baseline model (Qwen2-vl+CoaT) by 3.36\%. Additionally, MobileIPL surpasses OS-Atlas (+3.69\%) and UI-Tars (+3.69\%), both of which also use Qwen2-vl as the backbone. With the incorporation of CoaT, the baseline model Qwen2-vl shows an increase of 1.92\%, demonstrating the effectiveness of CoaT patterns. In summary, these results confirm that MobileIPL delivers significant improvements over existing models in long trajectory scenarios.
+
+
+\noindent \textbf{AndroidControl.}
+As shown in Table \ref{tab:ac1}, MobileIPL achieves SOTA performance in Step.Acc (72.7\%), reaching the SOTA model Falcon-UI with fewer data. MobileIPL also outperforms continual pre-training agents in the GUI domain, such as OS-Atlas (+1.5\%) and UI-Tars (+0.2\%). Compared to the baseline model Qwen2-VL(SFT), MobileIPL not only improves Mobile Agent performance but also enhances grounding by 8.5\%. As shown in Table \ref{tab:ac2}, MobileIPL continues to achieve SOTA performance in unseen OOD settings, demonstrating strong generalization. In contrast, compared to performance in the IDD domain, the pre-trained model OS-Atlas shows a significant drop. MobileIPL exhibits less performance degradation in out-of-domain settings. We also ran GRPO with Qwen2-VL under the same computational resources, and found OOD performance similar to MobileIPL, because both are self-training. However, MobileIPL still outperforms GRPO in all subsets.
+\subsection{Ablation Study}
+To test the effectiveness of IPL and instruction evolution, we conducted ablation experiments. First, removing IPL and using only SFT caused performance to drop from 65.4\% to 60.4\%, compared to the first round of MobileIPL, highlighting the crucial role that IPL plays. Next, removing instruction evolution led to a 2.5\% drop in IPL performance in the first round. This occurs because, without evolution, the model generates fewer training samples (156{,}418 -> 113{,}239). And as shown in Figure \ref{fig:combined_fig} (a), without instruction evolution, the diversity of model outputs decreased, causing a drop in IPL performance. This further confirms that instruction evolution is crucial for improving IPL.
+
+
+\noindent \textbf{Ablation Study.}
+Additionally, we remove negative samples from IPL-R1, training the model using only fully correct samples. This results in a 4.0\% performance drop, suggesting that negative samples help the model learn how to reason rather than merely memorize (SFT).
+Furthermore, training on the entire trajectory with naive DPO reduces performance from 65.4\% to 60.3\%. Compared with SFT trained on CoaT tree positive data (–IPL Negative), naive DPO is still 1.1 \% lower, confirming the effectiveness of CoaT-tree sampling and the thinking-process optimization.
+
+
+\noindent \textbf{Low Resource.}
+We also perform low-resource on AITZ, sampling 1/2 and 1/5 of the training data. As shown in table \ref{tab:ablation1}, using only half of the data, the first round of IPL training already outperformed the best results achieved by the original CoAT-SFT (-IPL) and naive DPO training. Furthermore, when using only one-fifth of the data, the second round of IPL training surpassed the performance of CoAT-SFT (-IPL), demonstrating the effectiveness of our method even in low-resource scenarios.
+\subsection{Discussion and Analysis} \label{sec:Output Space Sampling}
+
+\noindent \textbf{Rollout Efficiency and Performance Trade-off.} We compare MobileIPL with GRPO and the MCTS-style baseline SPO-Chain. Although MobileIPL requires more rollout sampling than GRPO, it achieves better accuracy. Compared with SPO-Chain, MobileIPL uses only about half as many rollouts per sentence ($\sim$27 vs. $\sim$54) while still obtaining a +1.12 accuracy gain. We also observe that SPO-Chain is sensitive to hyperparameters (e.g., temperature and cut-point probabilities). Its best performance is achieved with a higher temperature (1.4) to enlarge the exploration space, but this also produces longer sentences and slows down sampling. Overall, MobileIPL offers a better efficiency–performance trade-off and is more practical for GUI settings.
+
+
+\noindent \textbf{Reasoning Space Sampling.}
+To evaluate the instruction evolution, we analyze the diversity of the sampling space for \textbf{Random 1000 steps}, the standard deviation of encoded embeddings, the dimensionality-reduced distribution, and the distribution of $S^{(i)}$ mentioned in Section \ref{3.3}.
+As shown in Figure \ref{fig:combined_fig} (a), the thoughts after instruction evolution exhibit a broader space than direct SFT.
+Additionally, the embedding standard deviation within each tree increases significantly compared to the original data (+ 0.158).
+The diversified outputs do not negatively impact the agent's reasoning process, while the proportion of action sampling that includes the correct answer improves from 72.7\% to 77.9\%.
+The bottom-right subplot reflects the distribution of output accuracy.
+\textbf{Consistently Correct} indicates that all samples for the current step match the golden answer, while \textbf{Consistently Error} is the opposite.
+\textbf{Both} represents cases where some samples are correct while others are incorrect, which serves as an ideal source for constructing T-DPO pairs.
+Compared to 47\% on the evolved data, the agent achieves 68.7\% convergence on the original data but exhibits a strong polarization(4\%).
+Three-stage instruction evolution significantly expands the sampling space (from 4\% to 31\%), proving that it simultaneously improves both the diversity and quality of reasoning.
+More details are in Appendix \ref{appendix:sampling}.
+
+
+\noindent \textbf{Parameters Searching.} \label{para-searching}
+We conducted an ablation study on the impact of the sampling number ($\mathcal{K}$) per stage and iterative round number ($R$).
+As shown in the table \ref{tab:sample_number}, increasing the number of samples generally leads to better model performance. However, since our framework adopts a tree structure, increasing the sampling number from 3 to 4 causes the minimum number of tree nodes to grow significantly from $3^3 = 27$ to $4^3 = 64$. Despite this sharp increase, the performance improvement is limited (less than 1\%). Therefore, we adopt a sampling number of 3 for the final experiments. Regarding the number of rounds, we observe that both IPL performance and the size of the self-training dataset converge after several iterations. We therefore select the convergence round as our default setting. Additional details on computational cost are provided in Appendix~\ref{compute_use}.
+
+
+\noindent \textbf{IPL Scaling.}
+\label{IPL Scaling}
+Although overall Step.Acc increases across IPL iterations, not all action types follow this trend. As shown in Figure~\ref{fig:combined_fig}(b), from the seed model to the first IPL round, PRESS accuracy drops sharply (58.22\% → 23.49\%), whereas CLICK rises (53.26\% → 71.12\%). In the second round, however, PRESS accuracy rebounds. This stems from the severe underrepresentation of PRESS actions early on: the proportion of PRESS samples in the preference data grows from 1.6\% (1 round) to 10.9\% (2 round) as training progresses. With greater reasoning diversity and more PRESS-related examples, the model gradually learns PRESS behaviors and recovers accuracy in later rounds.
+
+\noindent \textbf{Iterative Preference Learning On GUI Continuous Pre-training Agent.}
+As discussed in the previous experimental analysis, continuous pre-training in the GUI domain provides the agents with a stronger base model.
+However, we still need to explore the compatibility between post-training IPL, instruction evolution, and pre-training.
+As shown in Figure \ref{fig:combined_fig} (c), UI-Tars outperforms Qwen2-VL-7B in all training stages, demonstrating better performance during the instruction evolution phase (62.7\% > 55.4\%).
+After four rounds of IPL, UI-Tars Step.Acc improves by 1.4\% compared to MobileIPL (69.2\% -> 70.6\%).
+More importantly, UI-Tars nearly converges after the first round of IPL, significantly reducing the number of sampling and preference learning iterations, thereby keeping the computational cost of post-training within an acceptable range.
+\section{Conclusion}
+In this paper, we propose Mobile Iterative Preference Learning (\textbf{MobileIPL}), a self-training GUI agent framework that incorporates instruction evolution, iterative sampling in the CoaT-tree, and a rule-based reward.
+We extensively evaluate MobileIPL on the AITZ, AMEX, and AndroidControl benchmarks, demonstrating its effectiveness. Furthermore, MobileIPL exhibits strong generalization capabilities on the OOD subsets of AndroidControl.
+Experiments show that instruction evolution increases output diversity, generates more training data in IPL, and thereby improves IPL performance.
+Finally, Continuous Pre-training experiments confirm the mutual reinforcement between MobileIPL and pre-training, leading to enhanced performance.
+
+
+\section{Ethics Statement}
+We have rigorously refined our dataset to remove any elements that could compromise personal privacy, thereby guaranteeing the highest level of protection for individual data. Instruction evolution was completed by AI SoTA close-sourced VLM, to whom we paid the necessary compensation to ensure that the training data was not leaked. The human evaluation of our work was carried out through a meticulously randomized selection of IT professionals. This process ensured a gender-balanced and educationally diverse panel, reflecting a wide spectrum of perspectives and expertise.
+
+\section{Reproducibility statement}
+All models and datasets used in this paper are open-source. The full experimental setup is detailed in Appendix \ref{appendix:setup}. Unless noted, all experiments use the same settings. We describe compute resources in Appendix \ref{compute_use}. Overall, these practices make our results reproducible.
+
+\appendix
+\section{CoaT Thinking Process}
+The table \ref{tab:method_comparison} summarizes the CoT paradigms (inputs and outputs) used in prior related works.
+CoaT paradigm for fine-tuning agents: The effectiveness of the approach in AITZ stems from the inclusion of extra screen descriptions as part of the input, along with joint output of Screen Context, Action Think, Action Target, and Action Result. In contrast, our experiments show that a stage-wise multi-turn dialogue output leads to better performance. In this setup, the model focuses on a single sub-task at each stage, which not only improves clarity but also encourages a simplified and deliberate reasoning process. This insight aligns with UI-TARS, which only requires the model to generate a brief thought during inference.
+Small-scale agent framing: Even models with relatively small parameter sizes can benefit from task-decomposed downstream training. For instance, OS-ATLAS and Falcon-UI adopt a similar architecture using GPT-4o for textual description and OS-ATLAS-base as the grounding model. They fine-tune models separately on different downstream tasks, resulting in a collection of OS-ATLAS-pro models, each specialized for a specific sub-task.
+Large-scale prompting-based frameworks: Larger models typically adopt a multi-agent framework to support a CoT-style reasoning process. For example, AppAgent v2 and Mobile-Agent-v2 both utilize a plan–action–reflection architecture to complete tasks. In our work, we adopt a stage-wise CoaT multi-turn dialogue format, where the model focuses on one sub-task at a time. This design enables us to move away from the dependence on extra screen description inputs, as seen in AITZ, while leveraging the description + grounding structure proposed in OS-ATLAS to form the final structure of the MobileIPL CoaT paradigm.
+
+
+\section{Selection of Seed Policy Model}\label{appendix:seed_policy_model}
+
+In our preliminary experimental exploration, we discovered that for the seed policy model, better performance in the SFT phase does not necessarily translate to a higher upper bound in the subsequent IPL phase. This is because as training progresses, the model’s output space becomes increasingly aligned with the training data, reducing its diversity in sampling. Consequently, for incorrect instances, the model tends to generate erroneous outputs regardless of the sampling attempts.
+To address this, we propose a sampling-oriented selection method for the seed policy model, incorporating the following two evaluation metrics:
+
+\noindent \textbf{Sampling Accuracy($Acc_S$)}, which requires the model to hit more correct actions $a$ in the sampled output space $\mathcal{S}$.
+\begin{equation}
+\small
+ Acc_S= \frac{\sum_{i=1}^{|\mathcal{T}|} \Big| \big\{ e_j^{(i)} \mid a^{(i)} \sim e_j^{(i)}, e_j^{(i)}\in\mathcal{S}^{(i)}\big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |\mathcal{S}^{(i)}|}
+\end{equation}
+
+\noindent \textbf{Sampling Diversity($Div_R$)}, which requires the model to have a more diverse and extensive sampling space.
+Standard deviation calculation of a single sampled tree \(\mathcal Dev_{{S}^{(i)}}\):
+\begin{equation}
+\small
+Dev_{{S}^{(i)}} = \frac{1}{T} \sum_{t=1}^{T} \mathrm{StdDev} \left( \mathbf{E}(\hat{s}^{(k)}_t) \mid k = 1, \dots, \mathcal{K} \right)
+\end{equation}
+Among them, \(\mathbf{E}(\hat{s}^{(k)}_t)\) represents the representation of the \(k\)th sample output of the \(t\)th step after the encoder.
+Calculation of the standard deviation of the set $Div_S$:
+\begin{equation}
+Div_R = \frac{1}{N} \sum_{i=1}^{N} Dev_{{S}^{(i)}}
+\end{equation}
+where \( N \) is the number of sampled trees in the set $ \mathcal{R} $.
+
+
+\section{Rule-based Reward Design}
+\label{sec:Rule-based Reward Design}
+\noindent \textbf{Derivation Of The Value Function.}
+Our value function incorporates hyperparameters inspired by ReFT and is also influenced by the sampling number used during IPL. We explain the rationale behind key parameter choices in our method, especially those in Eq.(\ref{eq:leaf_value}), Eq.(\ref{eq:dpo_pair1}), and Eq.(\ref{eq:dpo_pair2}):
+
+\noindent \textbf{Strong Reward}: We follow the ReFT score to define strong reward signals, assigning values of 1 and 0, corresponding to fully correct and completely incorrect reasoning paths, respectively.
+In ReFT, a supervision signal of 0.1 encourages the model to produce a final answer following the predefined format. In our approach, this signal is repurposed to reward action type matching.
+Meanwhile, an additional $v_{format}$ reward is introduced to encourage proper formatting of actions.
+
+\noindent \textbf{Weak Reward}:
+For input action, the value linearly increases from $v_{format} + v_{type}$ up to the strong reward level, with $v_{format}$ acting as a threshold to distinguish weak from type-correct reward.
+For grounding actions, values range between $v_{format} + v_{type}$ and 1, too. A value of $v_{format}$ indicates minimal correctness (e.g., extractable coordinates), while 1 indicates a closest match with the golden action, suitable for DPO pairing.
+Except $v_{format}$ and $v_{type}$ serving as discrete supervision signals, all other value signals are maintained as continuous.
+1 / $\mathcal{K}$ in Eq. (\ref{eq:dpo_pair1}) arises naturally from our hierarchical training structure. For example, if one child is incorrect (e.g., value drops from 1 to 0), the average value for the parent node decreases by ~0.33 when the sampling number is 3. Thus, 1 / $\mathcal{K}$ serves as a meaningful threshold to distinguish positive vs. negative examples in the CoAT tree.
+
+\textbf{Text F1 vs.\ Text-Embedding Similarity: }
+We replaced the F1\mbox{-}based reward with a BERT\mbox{-}based semantic reward and evaluated both variants.
+As shown in Table~\ref{tab:reward-ablation}, the F1 reward outperforms the BERT embedding reward across all metrics, with the largest gain on \textit{TYPE ACTION (acc)} (+4.53\%).
+This aligns with the importance of exact keyword matching in GUI input, indicating that F1 is better suited than semantic similarity for reward design in mobile UI input scenarios.
+
+
+\section{Experiment Setup}\label{appendix:setup}
+\noindent \textbf{Models.}
+Unlike \textsc{AITZ}, we do not compare the CoaT result with the expected page and decide whether to roll back because most actions in real-device scenarios cannot be rolled back without cost.
+Previous work conducted continual pretraining on Qwen2-VL-7B using GUI domain data, resulting in a stronger base model. In our ablation study, we discuss the impact of continuous pretraining on IPL.
+
+
+\noindent \textbf{Setup.}
+We conduct hyperparameter searches on AITZ to reproduce the baseline results and find that the optimal learning rate ranges from 3e-5 to 3e-6.
+Therefore, all baseline fine-tuning experiments adopt this setting.
+Before IPL, during the instruction evolution stage, we apply LoRA fine-tuning with a LoRA rank of 128.
+For IPL Stage 1, we use a learning rate between 1e-6 and 1e-7. In subsequent stages, we apply a constant learning rate of 1e-7.
+The batch size is consistently set to 128.
+During fine-tuning (including baseline fine-tuning), we enable ViT training, whereas in the IPL phase, we experiment with freezing ViT.
+For AITZ training, we followed the Falcons' approach, utilizing a maximum 1540×1540 resolution. For other experiments, we reduce the resolution to 1280×720 to optimize computational efficiency. The maximum context length is set to 32K for all experiments.
+The fine-tuning experiments are conducted for 2 epochs, while IPL training is performed for 1 epoch.
+Since the large volume of Android control data, we sample 1/5 of the dataset for each IPL training iteration.
+
+\noindent \textbf{CoaT Multi-turn Dialogue Prompts.}
+\begin{enumerate}
+ \item \textbf{Page Description.}
+ \textit{Based on the mobile screenshot: Image URL, identify and describe the key elements visible on the screen, including any text, buttons, icons, input fields, or other interactive components.}
+ \item \textbf{CoaT Action Thought.}
+ \textit{Given the task: instruction, and considering the contextual details from the image alongside the full history of previous actions: action history, determine the most logical and effective next step. Focus on providing a clear, actionable, and goal-oriented response to advance the task.}
+ \item \textbf{CoaT Action Description.}
+ \textit{Task: Determine the Most Appropriate Next Step. Based on the previous analysis and the objective, determine the most appropriate next step to achieve the goal. Choose from the following options: - **click**: Select a button or specific UI element by specifying it clearly (e.g., `click xxx', where `xxx' is the button name or identifier).
+ - **scroll**: Perform a scrolling action if the required element is not visible, specifying the direction (e.g., `scroll up', `scroll down').
+ - **type**: Input specific text into a field or search bar, specifying the text clearly (e.g., type ``content'').
+ - **press**: Interact with device-level buttons such as Home, Back, or Enter, specifying the button (e.g., ``press Back'').
+ - **stop**: Conclude the task, indicating that the objective has been achieved. Provide the chosen action in the specified format and ensure it aligns with the analysis and the visible UI elements.}
+ \item \textbf{Click Action Grounding.}
+ \textit{As discussed earlier, your task now is to identify the precise screen region coordinates to tap for the action coat action. The coordinates must be integers and strictly within the range of 0 to 1000 for both axes. Please provide your response in the required format: <|box\_start|>(top\_x, top\_y),(bottom\_x, bottom\_y)<|box\_end|>. Ensure your output adheres to these constraints and remains concise.}
+\end{enumerate}
+
+\noindent \textbf{Instruction evolution Prompts.}
+\begin{enumerate}
+ \item \textbf{Page Description Annotation.}
+ \textit{ I will provide you with a mobile page. Please describe the current page. Your description should include the content of the page and its general functionality. Please note that the descriptions you generate should be of moderate length. Your page description should match the actual image.}
+ \item \textbf{Action Thought Annotation.}
+ \textit{**QUERY**: task,
+ **ACTION HISTORY**: To proceed with the query, your past actions include: action history,
+ **NEXT ACTION**: This is the next action you need to take: coat action,
+ **TASK**: Given the screen and the above information, you have three tasks to do. First, you have to analyze what you have done. Second, you should analyze the screen for relevant details that might
+ pertain to the given query. This includes checking for specific applications, icons, or buttons that are visible and any information or results that are currently
+ displayed on the screen.
+ Tip: If the screen does not have the information you need, you can scroll left or scroll up to try to get the information. Don't answer this logic question by saying that because the provided **NEXT ACTION** is..., therefore, the next action is... You need to think carefully on your own.
+ You must answer the question with suitable lengths and the following format: 'Think: I have done..., Current screen is..., I need to... So the next action is ...' Your final action should be the same as the NEXT ACTION above.
+ }
+ \item \textbf{Q\&A Annotation.}
+ \textit{Your goal is to draw inspiration from the given images and image description information to create multiple new questions and answers. This new creation is closely related to the given image and information, but the answers involved should be directly derived from the given information, because UI positions and UI text are one-to-one correspondence.
+ Specifically, you should construct the following three types of questions and answers, a total of 15: 1. the function of some elements in the image. 2. Grounding questions and answers (the coordinates and approximate location of the target in the image). 3. Partial detailed information questions and answers (the structural relationship between multiple elements, type, style, etc.).
+ Please try to keep your questions and answers diverse and informative, and ignore the message in the device status bar.
+ Here is the information related to the image:
+ UI positions: \{ui positions\},
+ UI text: \{ui text\},
+ coat screen desc: \{coat screen desc\},
+ Please provide the following information in JSON format with the key questions and answers, and Don't add annotation parsing:}
+\end{enumerate}
+
+
+\section{Human Annotation}
+\noindent \textbf{SoTA Model Cost}: We use GPT-4o for annotation, which is priced at 4 USD per 1M input tokens and 16 USD per 1M output tokens. As shown in Appendix B (Instruction Evolution Prompts), each image has a resolution of 1080 × 2440. The input prompt is approximately 2K tokens, and the output is around 0.5K tokens, resulting in a per-page annotation cost of 0.008 USD (input) + 0.004 USD (output) = 0.012 USD. Given that the Android in the Zoo dataset [1] contains around 18,000 pages, the total annotation cost is approximately 200 USD.
+
+\noindent \textbf{Human Verification}: Human verification is used to identify cases where the model produces incorrect thoughts due to being forced to align with the golden action. As shown in following table, some initial annotations contain template-like phrases (e.g., “Since”, “annotation”) and mention multiple possible actions. These mistakes often happen when the model tries to justify a given action even if it doesn’t match the actual screen.
+
+The bolded text in following Table highlights common errors. To address this, we regenerated the prompts and applied automatic filtering based on specific tokens, which helps reduce the need for manual work.
+
+\noindent \textbf{Before Human Verification:} "coat\_action\_think": "Reason for the Action: - To find and compare prices, the user needs to locate similar products. - Swiping up or scrolling down is a logical step to explore further information or discover additional options, as apps like Etsy often display "similar items" or "recommended products" below the primary product listing. - This action aligns with typical app design patterns where related items or comparison options are placed further down the page. 4. Logical Derivation of Action: - Since the task specifies comparing prices of similar items, and the current screen does not explicitly list such items, the user must navigate downward to uncover more options. - The instruction to "swipe up" (or scroll down) matches the action type ("action\_type": "scroll", "direction""down"), indicating an attempt to reveal additional content or sections. 5. \textbf{Since the next action swiping down matches the annotation, the next action is swiping down}.
+
+\noindent \textbf{After Human Verification:}
+Think: I have previously navigated "Back," which indicates that I may have returned to the previous screen or listing, likely as part of exploring options related to the query for comparing prices of men's athletic shoes. Current screen is displaying detailed information about a product on the Etsy app. This includes item details such as "Handmade item," "Made to order," and shipping information. There are also options to "Follow shop," "Message seller," and "Add to cart," but it does not appear to directly show other comparable items or prices for similar men's athletic shoes.I need to scroll further down on this screen to potentially uncover additional details, such as related products, a comparison section, or other useful information for the query. So the Next action is Scroll down."
+
+\section{Iterative Sampling in the CoaT-tree}\label{appendix:sampling}
+As shown in Figure \ref{fig:heatmap}, before instruction evolution, the distribution is highly concentrated, with only 8 points exceeding 1000 (including 3 points above 1200). After instruction evolution, the distribution becomes more balanced, with 20 points exceeding 1000 (including 2 points above 1500).
+
+
+\noindent \textbf{Potential correct space ratio.}
+The proportion of $|\alpha| + |\beta|$ represents the potential correct space on the training data, and the change of this metric can clearly express the agent's ability to repair and reason out the correct process based on the correct answer.
+
+\section{Computational Cost of IPL Across Iterations}\label{compute_use}
+
+
+As shown in Table \ref{tab:iter-stats}, while the first IPL iteration incurs higher cost due to the larger volume of preference data, subsequent iterations are significantly lighter. The training time per round decreases rapidly, as the model generates fewer low-quality samples and requires fewer updates. In fact, by the third iteration, the training time becomes comparable to or even lower than the initial supervised fine-tuning (SFT) stage.
+
+Therefore, the overall compute overhead of IPL remains moderate and manageable, especially considering its performance gains. Compared to SFT, IPL introduces only a modest increase in compute, but brings substantial improvements in reasoning and generalization.
+
+
+\section{Case Study}\label{casestudy}
+\noindent \textbf{Unstable annotation preferences.}\label{annotation preferences}
+As shown in Figure \ref{fig:action_prefer}, the left section illustrates two different annotation preferences when searching for an app from the Home Page: \textbf{SCROLL UP} and \textbf{SCROLL LEFT}, leading to different destination pages.
+The right part shows the overall preference distribution when annotators need to find an app. In rare cases, the annotation involves clicking on Google Play Store to perform a search.
+This phenomenon is quite common because, fundamentally, the task completion paths for a UI Agent are diverse. This is also the key difference between online evaluation and offline data evaluation.
+From this, we observe that RL training on data with unstable preferences performs worse than SFT (e.g., \textsc{AITZ} SCROLL).
+This is because the DPO pair training method inherently attempts to correct errors in sampled preferences.
+As a result, the agent oscillates between two decisions when encountering the same GUI and instruction, failing to achieve consistent alignment.
+
+\noindent \textbf{Action Equivalence.}
+Unlike Unstable Annotation Preferences, where different actions lead to different but equivalent pages, the issue here arises from annotators' random labeling habits in the training data, preventing the model from learning a consistent preference.
+Action Equivalence refers to the phenomenon where multiple actions on the same page can lead to the target page.
+However, since only one action is annotated as correct, other valid actions are mistakenly treated as incorrect.
+As shown in Figure \ref{fig:annotation_bias}, after entering a search query, clicking on a suggested item in the recommendation bar, and pressing the Enter key on the keyboard produce the same effect. Similarly, when navigating back, clicking the on-screen back button and pressing the hardware back button yield the same outcome.
+
+\noindent \textbf{Thinking-Level Sampling.}
+As shown in Figure \ref{fig:sampling-case}, unlike mathematical reasoning, the CoaT process may not exhibit clear logical or computational errors.
+For a given action, a sampling CoaT data may produce hallucinations (Page Description) due to insufficient detail in the page description or fabricated elements; generate repetitive thoughts (Action Thought) due to neglecting action history; describe the wrong relative position of the correct element (CoaT Action); or misgrounding an element (Grounding), which is then classified as a negative sample.
+At the same time, outputs with more detailed and accurate descriptions, diversified thoughts, and different ways of describing the same widget are classified as positive samples.
+Negative examples may be disadvantageous compared to positive examples, for example, because the description of the page is not detailed enough or the positioning of the elements is not accurate enough.
+At the same time, the wrong process may also give the correct result, but this is a very rare case.
+In this example, negative samples are generated due to the following three reasons: (1) \textbf{Rough page description: } The page contains eight app icons, but the agent's description includes only four apps: Play Store, Gmail, Phone, and YouTube; (2) \textbf{Hallucinated Thought:} The agent is unclear about its current page location. In reality, it is on the Home page, but it mistakenly believes it is in the Play Store (e.g., ''The Play Store app is already open"). (3) \textbf{Fabricated Position and Elements:} The agent generates the action "Click on the 'Spotify' app", even though there is no Spotify icon on the current page. This hallucination may stem from the instruction.
+Additionally, the Play Store icon should be located at the lower left part of the screen, but the agent incorrectly describes it as being in the middle and lower middle part.
+
+\section{Usage of LLM statement }
+This paper utilized an LLM to improve the clarity and fluency of the text.
+
+\end{document}

benchmark_dataset/papers/ICLR2026_0004_2505.12299/source_extracted.tex

@@ -0,0 +1,280 @@
+\begin{abstract}
+The Chain of Action-Planning Thoughts (CoaT) paradigm has been shown to improve the reasoning performance of VLM-based mobile agents in GUI tasks.
+However, the scarcity of diverse CoaT trajectories limits the expressiveness and generalization ability of such agents. While self-training is commonly employed to address data scarcity, existing approaches either overlook the correctness of intermediate reasoning steps or depend on expensive process-level annotations to construct process reward models (PRM).
+To address the above problems, we propose an \textbf{\underline{I}}terative \textbf{\underline{P}}reference \textbf{\underline{L}}earning (\textit{IPL}) that constructs a CoaT-tree through iterative sampling, scores leaf nodes using rule-based reward, and backpropagates feedback to derive Thinking-level Direct Preference Optimization (T-DPO) pairs.
+To prevent overfitting during warm-up supervised fine-tuning, we further introduce a three-stage instruction evolution, which leverages GPT-4o to generate diverse Q\&A pairs based on real mobile UI screenshots, enhancing both generality and layout understanding\footnote[4]{\url{https://huggingface.co/datasets/xwk123/MobileIPL-dataset}}.
+Experiments on three standard Mobile GUI-agent benchmarks
+demonstrate that our agent \textit{MobileIPL} outperforms strong baselines, including continual pretraining models such as OS-ATLAS and UI-TARS. It achieves state-of-the-art performance across three standard Mobile GUI-Agents benchmarks and shows strong generalization to out-of-domain scenarios.
+\end{abstract}
+
+\section{Introduction}
+
+VLM-based mobile agents~ have attracted considerable attention due to their ability to seamlessly interact with mobile graphical user interfaces (GUIs) and their potential to autonomously perform daily tasks.
+Since actions are not directly specified in user instructions, mobile agents benefit from generating intermediate thoughts aligned with the current GUI context.
+Recent work such as \textsc{AITZ} has demonstrated that the Chain of Action-Planning Thoughts (CoaT) pattern---resembling the slow-thinking ``System 2'' process---is particularly effective in GUI domains.
+
+However, directly applying supervised fine-tuning (SFT) on CoaT trajectories may cause overfitting, leading the model to be trapped in fixed reasoning patterns.
+To address this limitation, recent studies in the general domain have explored self-training strategies. These approaches typically utilize the correctness of the final answer in output as a reward signal to train the model. While effective in some contexts, relying solely on final answers overlooks the quality of intermediate reasoning steps, which can result in reward hacking and suboptimal reasoning processes.
+Some search-based approaches, such as ReST-MCTS~, tackle this problem by learning a process reward model (PRM) to evaluate individual reasoning steps.
+However, these approaches often require large-scale manual annotation of intermediate steps~. This challenge is especially severe in the Mobile GUI Agent domain.
+Unlike text-based tasks in coding or math, GUI environments rely on real devices or simulators, making step-level reward annotation significantly more costly and labor-intensive.
+
+To address these limitations, we propose an iterative sampling framework that constructs a CoaT-tree based on Monte Carlo Tree Search (MCTS).
+Instead of relying on a PRM, we score each reasoning step and construct thinking-level DPO (T-DPO) pairs without manual step annotation.
+Specifically, we perform multi-turn dialogue with a vision-language model (VLM) to incrementally build a CoaT-tree, where each node corresponds to a sampled response at a given reasoning step, conditioned on the dialogue history. This hierarchical structure captures diverse reasoning paths and facilitates fine-grained assessment of intermediate thoughts.
+We first assign rewards to the leaf node, and then propagate these signals backward through the CoaT-tree to earlier reasoning steps. Based on the resulting values, we construct thinking-level DPO pairs to help agents optimize both final actions and the overall quality of their reasoning.
+
+To mitigate the lack of diversity after warm-up SFT, we adopt an instruction evolution strategy. Specifically, we generate diverse Q\&A pairs grounded in real mobile UI screenshots from downstream training datasets. These Q\&A pairs serve two purposes: (1) prevent agents from overfitting to static downstream instructions by introducing varied reasoning contexts, and (2) improve agents' understanding of UI layouts through visually grounded question-answering.
+We evaluate our approach on the CoaT dataset \textsc{AITZ} and long-horizon dataset AMEX, where it outperforms state-of-the-art GUI-agent continual pretraining agents such as OS-ATLAS~ (+4.04\%) and UI-TARS~ (+3.54\%). Furthermore, experiments on the AndroidControl dataset demonstrate the strong generalization capability of our method to unseen apps and instructions (tasks). Under limited training resources, IPL consistently outperforms naive DPO using only half of the data for one iterative training round (+4.5\%), or one-fifth of the data for two iterative training rounds (+0.3\%).
+Analytical experiments show instruction evolution simultaneously improves both the diversity and quality of reasoning.
+
+Overall, our main contributions are summarized as follows:
+
+$\bullet$We propose an iterative framework to construct a CoaT-tree, and utilize rule-based rewards with backward credit assignment to form thinking-level DPO pairs for reasoning optimization.
+
+$\bullet$ We introduce an instruction evolution strategy to mitigate overfitting during warm-up SFT, enhancing the model's generalization and UI understanding.
+
+$\bullet$ We demonstrate the effectiveness of our method on three GUI-agent benchmarks: AITZ, AMEX, and AndroidControl. Furthermore, our approach even surpasses SoTA continual pretraining models.
+
+
+\section{Methodology}
+In this section, we first introduce the multi-turn thinking process formulation ~(\S~\ref{3.1}) and explain our method.
+As shown in Figure \ref{fig:main}, our method starts with instruction evolution strategy~(\S~\ref{3.2}) to enhance output diversity in warm-up SFT stage.
+Then, a CoaT-tree through iterative sampling~(\S~\ref{3.3}) is employed for each action.
+Every leaf node represents a complete action and is scored using a rule-based reward function. We then backpropagate the rewards along the tree to assign credit to intermediate reasoning steps. This process yields thinking-level contrastive pairs for DPO, which further improves the model’s reasoning ability. The detailed process is presented in Algorithm \ref{alg: ipl_algorithm}.
+
+\subsection{Multi-turn Thinking Process Formulation} \label{3.1}
+Each mobile GUI task contains a trajectory $\mathcal{T}$, several pages $u$,
+actions $\hat{a}$, and an instruction $I$, which can be represented as:
+\begin{equation}
+\mathcal{T} = \big\{I, u_0, \hat{a}_0, u_1, \hat{a}_1, \cdots, u_{n}, \hat{a}_{n}\}
+\end{equation}
+We formulate action $\hat{a}_{i}$ in the CoaT reasoning process as a multi-turn dialogue $\hat{a}_{i}=[s_1, s_2, s_3, s_4]$, where $s_i$ represents description, action-thought, action-decision, and grounding, respectively. This thinking paradigm based on the thinking–decision–grounding triplet, has been widely validated as effective in previous GUI works .
+So the reasoning process can be formulated as:
+\begin{equation}
+s_1 = \mathrm{Description} ( P_1, u_{i} )
+\end{equation}
+\begin{equation}
+s_2 = \mathrm{Thought} ( P_2, u_{i}, I, \hat{a}_0,\cdots, \hat{a}_{i-1}, s_1 )
+\end{equation}
+$P$ represents each round of dialogue input prompt, $I$ is the task instruction, $u$ is the current GUI, and $\hat{a}_i$ is the step $i$ history action.
+Agents perform poorly when decoding the entire reasoning process in a single step, which is because image modal $u$ dominates the input tokens, surpassing textual instructions $I$ and action history $\hat{a}_i$, and diverting their attention away from the textual details.
+During autoregressive training, the agent is unaware that producing a final answer conforming to the required format is indispensable throughout the reasoning process.
+Multi-turn thinking process effectively mitigates this problem, because additional dialogue steps guarantee a final answer is generated:
+\begin{equation}
+s_3 = \mathrm{Action} ( P_3, u_{i}, I, s_1, s_2 )
+\end{equation}
+\begin{equation}
+s_4 = \mathrm{Grounding} ( P_4, u_{i}, I, s_1, s_2, s_3 )
+\end{equation}
+Previous work either performed RL in GUI-Agent directly on the trajectory without CoaT, missing the detailed thinking process of each action, or forced the model to bear the heavy burden of outputting the entire reasoning process at once.
+In our method, when the reasoning process ends, the final $s_4$ is recorded as $\hat{a}_{n+1}$, step $i$ moves one step forward on the trajectory $\mathcal{T}$ and its thinking step reward is calculated recursively based on final step $s_4$.
+Dialogue-level textual input helps balance cross-modal token proportions and steers the agent’s attention toward the current reasoning step.
+\subsection{Instruction Evolution}\label{3.2}
+
+
+As discussed in the previous section, the CoaT patterns in the mobile agent domain are typically fixed. As a result, agents tend to overfit these static paradigms and struggle to generate diverse reasoning paths after the warm-up SFT training (as detailed in Sec \ref{sec:Output Space Sampling}). To address this issue, we enhance the original training trajectories, denoted as $\mathcal{T}$, by appending additional Q\&A annotations to UI screenshots through an instruction evolution process, thereby creating a new dataset $\mathcal{Q}$ with a broader range of instruction formats.
+Specifically, as shown in Figure \ref{fig:ins}, the evolution process consists of three levels:
+
+\noindent \textbf{Level I: General GUI Q\&A tasks}. Grounding, Reference (Ref), and Page Descriptions are aimed at enhancing the agent's foundational capabilities. These tasks are proven to be the core capabilities of GUI agents during the pre-training.
+
+\noindent \textbf{Level II: Widget caption and relationships}. Descriptions of widget functions and the nested partition relationships between widgets. These tasks help agents understand the relationships between widgets, as previous work has found that agents tend to click on the textview, even in scenarios where the textview and the button are separate.
+
+\noindent \textbf{Level III: GUI advanced FAQ}. Inspired by , we design an advanced FAQ that features more complex Q\&A, including descriptions of the page’s structural framework as well as expectations and predictions about navigation outcomes triggered by control interactions.
+
+\textbf{Warm-up Supervised Fine-tuning}:
+To develop agents with standard thinking format and expand the reasoning space, we mix $\mathcal{T}$ and the instruction evolution data $\mathcal{Q}$, then perform warm-up SFT on
+$\mathcal D = \Big\{\mathcal{T},\mathcal{Q}\Big\}= \Big\{(u, e)^{(i)}\Big\}_{i=1}^{|\mathcal D|}$,
+where $u$ represents the prior knowledge (instructions, screenshot and action history) from $\mathcal{T}$ or the questions from $\mathcal{Q}$, and $e$ is the reasoning process from $\mathcal{T}$ or the answer from $\mathcal{Q}$ which is organized into multi-turn dialogues.
+To ensure output diversity, we select an earlier checkpoint with better potential correct space and diverse output to serve as the seed policy model. More details can be seen in Appendix \ref{appendix:seed_policy_model}.
+\subsection{Iterative Preference Learning}\label{3.3}
+After the warm-up SFT, the agent acquires basic GUI capabilities. We construct a CoaT-tree by iteratively sampling each reasoning step and then assign a score to the leaf nodes based on a rule-based reward function. Using these scores, we generate thinking-level DPO pairs to optimize the agent's reasoning process.
+
+\noindent \textbf{Iterative Sampling \& Rule-based Reward.}
+We iteratively sample each reasoning step along the CoaT paradigm .
+The $\mathcal{K}$ sampling results $(\hat{s}_{t}|\hat{s}_{1:t-1})^\mathcal{K}$ at step $t$ can be expressed as:
+\begin{equation}
+\hat{s}_t = \Big\{ (\hat{s}^{(k)}_{t} \mid \hat{s}_0, \cdots, \hat{s}_{t-1}) \Big\}^K_{k=1}
+\end{equation}
+Naturally, the final step in CoaT (the leaf node in the sampling tree) expresses a reward compared with the ground truth action $a^*$, which is then propagated back to other intra-nodes.
+The formula for the rule-based reward of leaf nodes is as follows:
+\begin{equation}
+\small
+v(s_t) =
+ \begin{cases}
+ 1, & s_t=a* \\
+ v_{type} + score_{match}, & type(s_t \sim a^*) \\
+ 0, & others
+ \end{cases}
+\label{eq:leaf_value}
+\end{equation}
+
+
+\begin{equation}
+\small
+score_{match}=
+\begin{cases}
+ v_{format} + 1\cdot (1-d(x,y))-(v_{type}+v_{format})\cdot d(x,y), & type(a*)=CLICK\\
+ v_{format} + (1 - v_{type} - v_{format}) \cdot F_1, & type(a*)=INPUT \\
+ 0, & others \\
+\end{cases}
+\end{equation}
+
+
+The reward score $v(s_t)$ ranges from 0 to 1, with a fully correct prediction receiving a score of 1.
+We use $v_{\text{type}}$ and $v_{\text{format}}$ to indicate whether the predicted action type and output format match the ground truth.
+For \texttt{click} and \texttt{input} actions, we further evaluate their internal structure using smooth rewards based on spatial distance $d(x,y)$ and text match $F_1$. The final reward is computed from the similarity between the prediction and the ground truth:
+
+\begin{itemize}
+ \item \textbf{Click:} A distance-based score between the predicted and ground-truth coordinates, normalized to $[0,1]$; smaller distances yield higher scores.
+ \item \textbf{Input:} The $F_1$ score between the predicted and ground-truth strings; greater textual overlap yields higher scores.
+\end{itemize}
+
+The full reward is defined in Equation~\ref{eq:leaf_value} and discussed further in Section~\ref{sec:Rule-based Reward Design}.
+
+Based on the structure of the CoaT-tree, we recursively compute the value of each intermediate reasoning step. Specifically, the value of $s_{t-1}$ is computed as the average value of its $\mathcal{K}$ sampled continuations at $s_t$:
+\begin{equation}
+v(s_{t-1}) = c\cdot \frac{1}{\mathcal{K}} \sum_{k=1}^\mathcal{K} v(s_{t}^{(k)})
+\label{eq:intra_value}
+\end{equation}
+Here, $\mathcal{K}$ denotes the number of sampled continuations for each reasoning step, and $c$ is a discount factor. The parameter searching experiment for $\mathcal{K}$ is described in detail in Section \ref{para-searching}.
+
+\noindent \textbf{Contrastive Data Filter.}
+After obtaining the sampling tree and node values, we evaluate the quality of the trees and extract contrastive data.
+We can divided the sampling trees into three categories $\mathcal{R} = \{\alpha, \beta, \gamma\}$ based on their output quality, and the classification standards of $\alpha, \beta, \gamma$ are as follows:
+\begin{equation}
+\small{
+\alpha = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \forall v_k \in \mathcal{S}^{(i)}, v_k=1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+\begin{equation}
+\small{
+\beta = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \exists v_{k}, v_{k'} \in \mathcal{S}^{(i)}, v_{k}=1, v_{k'} \neq 1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+\begin{equation}
+\small{
+\gamma = \frac{\Big| \big\{ \mathcal{S}^{(i)} \mid \forall v_k \in \mathcal{S}^{(i)}, v_k \neq 1 \big\} \Big|}{\sum_{i=1}^{|\mathcal{T}|} |(u, e)^{(i)}|}
+}
+\end{equation}
+$\mathcal{S}^{(i)}$ and $v_k$ refer to the instruction $i$ sampling tree and the $k$-th leaf nodes value of $\mathcal{K}$ sampled output.
+$\alpha$ is considered a perfect sampling tree, which can stably output correct thoughts and actions with in-domain trajectories, $\beta$ represents potential correct trees that can be used to construct contrastive data, and $\gamma$ denotes sampling trees that require refinement.
+${\beta + \gamma}$ is considered a valid sampling space.
+In $\beta$, actions with a value of 1 and as many diverse action types as possible are extracted as positive samples.
+In $\gamma$, the final ground truth action $a^*$ is used as a positive sample, but the intermediate steps of CoaT are not provided, and the pairs can be represented as:
+\begin{equation}
+\begin{aligned}
+\beta_{pairs} &= \langle\hat{s}^{(k)}_{t}\uparrow ,\hat{s}^{(k')}_{t}\downarrow \mid (\hat{s}_1, \dots, \hat{s}_{t-1}), \\
+& ~~~~~~~~~~~~~~ v(\hat{s}^{(k)}_{t}) - v(\hat{s}^{(k')}_{t}) > 1 / \mathcal{K} \rangle
+\end{aligned} \label{eq:dpo_pair1}
+\end{equation}
+\begin{align}
+\gamma_{pairs} &= \langle a^*\uparrow,\hat{s}^{(k)}_{t}\downarrow \mid \hat{s}_1, \dots, \hat{s}_{t-1}\rangle
+\label{eq:dpo_pair2}
+\end{align}
+
+\textbf{Thinking-level Direct Preference Optimization}.
+After CoaT thinking-level Iterative Sampling, several positive and negative example pairs are collected.
+During this stage, the agent policy undergoes updates through the above data-pairs, SFT loss, and CoaT-DPO loss .
+Suppose the agent gets values to pair $\langle +, -\rangle$ at CoaT step $t$, which are named $s^+_{t}$ and $s^-_{t}$; we have the agent performing a comparison for these pairs based on the same thoughts $s_{1:t-1}$, which can be calculated as:
+\begin{equation}
+\begin{aligned}
+\mathcal L_{\mathrm{T\mbox{-}DPO}}= - \mathbb E_{(s_{1:t-1}, s^-_{t},s^+_{t})\sim \mathcal T_s}\bigg[\log\sigma(\beta \log\frac{\pi_\theta(s^+_{t}|s_{1:t-1})}{\pi_{ref}(s^+_{t}|s_{1:t-1})} &\\
+- \beta \log\frac{\pi_\theta(s^-_{t}|s_{1:t-1})}{\pi_{ref}(s^-_{t}|s_{1:t-1})} )\bigg]&,
+\end{aligned}
+\end{equation}
+To further refine the agent’s performance post-optimization, we employ the updated agent as the new base agent to continue collecting contrastive CoaT-action level pairs for additional T-DPO training.
+This iterative process is maintained until the agent reaches the performance bottleneck.
+
+
+\vspace{-9pt}
+\section{Experiments}
+\subsection{Experiments Setups}
+
+\noindent \textbf{Dataset.}
+\textbf{\textsc{AITZ}} is a high-quality trajectory set filtered and re-annotated from AITW , containing four subsets
+, which also includes five types of actions
+\textbf{AMEX} uses the same apps and action space as \textsc{AITZ}, but its task instructions are more complex and detailed, with an average trajectory length of 15+.
+\textbf{AndroidControl} includes OOD datasets, such as app unseen and task unseen.
+
+\noindent \textbf{Metrics.} For evaluation, we use \textbf{Step.Acc} as metrics, consistent with Auto-GUI, measures the agent's performance and uses \textbf{Action Type} to assess the degree of action type matching.
+This metric effectively evaluates the model's planning ability.
+
+\noindent \textbf{Baselines.} Following prior work, we use Qwen2-VL-7B~ as the backbone of our model.
+We select CogAgent , AUTO-GUI, Shpagent, OS-Atlas, UGround, UI-Tars and FedMobileAgent as baseline agents.
+GUI continuous pre-training agents can be further divided into two categories: (1) training the model as a GUI grounding agent, such as OS-Atlas-7B. (2) training the model as a general GUI agent, such as UI-Tars.
+More details are provided in Appendix \ref{appendix:setup}.
+\subsection{Main result}
+
+
+\noindent \textbf{\textsc{AITZ}.}
+As shown in Table \ref{tab:aitz},
+MobileIPL achieves SoTA performance on most metrics.
+The reason for the lower PRESS Acc. is discussed in Section \ref{IPL Scaling} and Appendix \ref{annotation preferences}.
+Multiple rounds of T-DPO improve MobileIPL by more than 10\% (55.40\% -> 69.15\%) compared to the seed model MobileIPL and Qwen2-VL-7B (60.36\% -> 69.15\%).
+Compared to continuous pre-training agents such as Falcon-UI, which is pre-trained on three million GUIs, MobileIPL still surpasses a performance difference of 0.05\%.
+The amount of training data required by our method is substantially smaller than that used by these pre-training approaches.
+
+
+\noindent \textbf{AMEX.}
+As shown in Table \ref{tab:amex}, MobileIPL surpasses the previous SOTA model, SphAgent-7B, by 3.58\%. It also outperforms the baseline model (Qwen2-vl+CoaT) by 3.36\%. Additionally, MobileIPL surpasses OS-Atlas (+3.69\%) and UI-Tars (+3.69\%), both of which also use Qwen2-vl as the backbone. With the incorporation of CoaT, the baseline model Qwen2-vl shows an increase of 1.92\%, demonstrating the effectiveness of CoaT patterns. In summary, these results confirm that MobileIPL delivers significant improvements over existing models in long trajectory scenarios.
+
+
+\noindent \textbf{AndroidControl.}
+As shown in Table \ref{tab:ac1}, MobileIPL achieves SOTA performance in Step.Acc (72.7\%), reaching the SOTA model Falcon-UI with fewer data. MobileIPL also outperforms continual pre-training agents in the GUI domain, such as OS-Atlas (+1.5\%) and UI-Tars (+0.2\%). Compared to the baseline model Qwen2-VL(SFT), MobileIPL not only improves Mobile Agent performance but also enhances grounding by 8.5\%. As shown in Table \ref{tab:ac2}, MobileIPL continues to achieve SOTA performance in unseen OOD settings, demonstrating strong generalization. In contrast, compared to performance in the IDD domain, the pre-trained model OS-Atlas shows a significant drop. MobileIPL exhibits less performance degradation in out-of-domain settings. We also ran GRPO with Qwen2-VL under the same computational resources, and found OOD performance similar to MobileIPL, because both are self-training. However, MobileIPL still outperforms GRPO in all subsets.
+\subsection{Ablation Study}
+To test the effectiveness of IPL and instruction evolution, we conducted ablation experiments. First, removing IPL and using only SFT caused performance to drop from 65.4\% to 60.4\%, compared to the first round of MobileIPL, highlighting the crucial role that IPL plays. Next, removing instruction evolution led to a 2.5\% drop in IPL performance in the first round. This occurs because, without evolution, the model generates fewer training samples (156{,}418 -> 113{,}239). And as shown in Figure \ref{fig:combined_fig} (a), without instruction evolution, the diversity of model outputs decreased, causing a drop in IPL performance. This further confirms that instruction evolution is crucial for improving IPL.
+
+
+\noindent \textbf{Ablation Study.}
+Additionally, we remove negative samples from IPL-R1, training the model using only fully correct samples. This results in a 4.0\% performance drop, suggesting that negative samples help the model learn how to reason rather than merely memorize (SFT).
+Furthermore, training on the entire trajectory with naive DPO reduces performance from 65.4\% to 60.3\%. Compared with SFT trained on CoaT tree positive data (–IPL Negative), naive DPO is still 1.1 \% lower, confirming the effectiveness of CoaT-tree sampling and the thinking-process optimization.
+
+
+\noindent \textbf{Low Resource.}
+We also perform low-resource on AITZ, sampling 1/2 and 1/5 of the training data. As shown in table \ref{tab:ablation1}, using only half of the data, the first round of IPL training already outperformed the best results achieved by the original CoAT-SFT (-IPL) and naive DPO training. Furthermore, when using only one-fifth of the data, the second round of IPL training surpassed the performance of CoAT-SFT (-IPL), demonstrating the effectiveness of our method even in low-resource scenarios.
+\subsection{Discussion and Analysis} \label{sec:Output Space Sampling}
+
+\noindent \textbf{Rollout Efficiency and Performance Trade-off.} We compare MobileIPL with GRPO and the MCTS-style baseline SPO-Chain. Although MobileIPL requires more rollout sampling than GRPO, it achieves better accuracy. Compared with SPO-Chain, MobileIPL uses only about half as many rollouts per sentence ($\sim$27 vs. $\sim$54) while still obtaining a +1.12 accuracy gain. We also observe that SPO-Chain is sensitive to hyperparameters (e.g., temperature and cut-point probabilities). Its best performance is achieved with a higher temperature (1.4) to enlarge the exploration space, but this also produces longer sentences and slows down sampling. Overall, MobileIPL offers a better efficiency–performance trade-off and is more practical for GUI settings.
+
+
+\noindent \textbf{Reasoning Space Sampling.}
+To evaluate the instruction evolution, we analyze the diversity of the sampling space for \textbf{Random 1000 steps}, the standard deviation of encoded embeddings, the dimensionality-reduced distribution, and the distribution of $S^{(i)}$ mentioned in Section \ref{3.3}.
+As shown in Figure \ref{fig:combined_fig} (a), the thoughts after instruction evolution exhibit a broader space than direct SFT.
+Additionally, the embedding standard deviation within each tree increases significantly compared to the original data (+ 0.158).
+The diversified outputs do not negatively impact the agent's reasoning process, while the proportion of action sampling that includes the correct answer improves from 72.7\% to 77.9\%.
+The bottom-right subplot reflects the distribution of output accuracy.
+\textbf{Consistently Correct} indicates that all samples for the current step match the golden answer, while \textbf{Consistently Error} is the opposite.
+\textbf{Both} represents cases where some samples are correct while others are incorrect, which serves as an ideal source for constructing T-DPO pairs.
+Compared to 47\% on the evolved data, the agent achieves 68.7\% convergence on the original data but exhibits a strong polarization(4\%).
+Three-stage instruction evolution significantly expands the sampling space (from 4\% to 31\%), proving that it simultaneously improves both the diversity and quality of reasoning.
+More details are in Appendix \ref{appendix:sampling}.
+
+
+\noindent \textbf{Parameters Searching.} \label{para-searching}
+We conducted an ablation study on the impact of the sampling number ($\mathcal{K}$) per stage and iterative round number ($R$).
+As shown in the table \ref{tab:sample_number}, increasing the number of samples generally leads to better model performance. However, since our framework adopts a tree structure, increasing the sampling number from 3 to 4 causes the minimum number of tree nodes to grow significantly from $3^3 = 27$ to $4^3 = 64$. Despite this sharp increase, the performance improvement is limited (less than 1\%). Therefore, we adopt a sampling number of 3 for the final experiments. Regarding the number of rounds, we observe that both IPL performance and the size of the self-training dataset converge after several iterations. We therefore select the convergence round as our default setting. Additional details on computational cost are provided in Appendix~\ref{compute_use}.
+
+
+\noindent \textbf{IPL Scaling.}
+\label{IPL Scaling}
+Although overall Step.Acc increases across IPL iterations, not all action types follow this trend. As shown in Figure~\ref{fig:combined_fig}(b), from the seed model to the first IPL round, PRESS accuracy drops sharply (58.22\% → 23.49\%), whereas CLICK rises (53.26\% → 71.12\%). In the second round, however, PRESS accuracy rebounds. This stems from the severe underrepresentation of PRESS actions early on: the proportion of PRESS samples in the preference data grows from 1.6\% (1 round) to 10.9\% (2 round) as training progresses. With greater reasoning diversity and more PRESS-related examples, the model gradually learns PRESS behaviors and recovers accuracy in later rounds.
+
+\noindent \textbf{Iterative Preference Learning On GUI Continuous Pre-training Agent.}
+As discussed in the previous experimental analysis, continuous pre-training in the GUI domain provides the agents with a stronger base model.
+However, we still need to explore the compatibility between post-training IPL, instruction evolution, and pre-training.
+As shown in Figure \ref{fig:combined_fig} (c), UI-Tars outperforms Qwen2-VL-7B in all training stages, demonstrating better performance during the instruction evolution phase (62.7\% > 55.4\%).
+After four rounds of IPL, UI-Tars Step.Acc improves by 1.4\% compared to MobileIPL (69.2\% -> 70.6\%).
+More importantly, UI-Tars nearly converges after the first round of IPL, significantly reducing the number of sampling and preference learning iterations, thereby keeping the computational cost of post-training within an acceptable range.
+\section{Conclusion}
+In this paper, we propose Mobile Iterative Preference Learning (\textbf{MobileIPL}), a self-training GUI agent framework that incorporates instruction evolution, iterative sampling in the CoaT-tree, and a rule-based reward.
+We extensively evaluate MobileIPL on the AITZ, AMEX, and AndroidControl benchmarks, demonstrating its effectiveness. Furthermore, MobileIPL exhibits strong generalization capabilities on the OOD subsets of AndroidControl.
+Experiments show that instruction evolution increases output diversity, generates more training data in IPL, and thereby improves IPL performance.
+Finally, Continuous Pre-training experiments confirm the mutual reinforcement between MobileIPL and pre-training, leading to enhanced performance.
+
+
+\section{Ethics Statement}
+We have rigorously refined our dataset to remove any elements that could compromise personal privacy, thereby guaranteeing the highest level of protection for individual data. Instruction evolution was completed by AI SoTA close-sourced VLM, to whom we paid the necessary compensation to ensure that the training data was not leaked. The human evaluation of our work was carried out through a meticulously randomized selection of IT professionals. This process ensured a gender-balanced and educationally diverse panel, reflecting a wide spectrum of perspectives and expertise.
+
+\section{Reproducibility statement}
+All models and datasets used in this paper are open-source. The full experimental setup is detailed in Appendix \ref{appendix:setup}. Unless noted, all experiments use the same settings. We describe compute resources in Appendix \ref{compute_use}. Overall, these practices make our results reproducible.

benchmark_dataset/papers/ICLR2026_0004_2505.12299/source_references.tex

@@ -0,0 +1,539 @@
+@article{achiam2023gpt,
+ author = {Achiam, Josh and Adler, Steven and Agarwal, Sandhini and Ahmad, Lama and Akkaya, Ilge and Aleman, Florencia Leoni and Almeida, Diogo and Altenschmidt, Janko and Altman, Sam and Anadkat, Shyamal and others},
+ journal = {ArXiv preprint},
+ title = {GPT-4 technical report},
+ url = {https://arxiv.org/abs/2303.08774},
+ volume = {abs/2303.08774},
+ year = {2023}
+}
+
+@article{xu2025llm,
+  title={LLM-Based Agents for Tool Learning: A Survey: W. Xu et al.},
+  author={Xu, Weikai and Huang, Chengrui and Gao, Shen and Shang, Shuo},
+  journal={Data Science and Engineering},
+  pages={1--31},
+  year={2025},
+  publisher={Springer}
+}
+
+@article{xu2025mobile,
+  title={Mobile-Bench-v2: A More Realistic and Comprehensive Benchmark for VLM-based Mobile Agents},
+  author={Xu, Weikai and Jiang, Zhizheng and Liu, Yuxuan and Gao, Pengzhi and Liu, Wei and Luan, Jian and Li, Yuanchun and Liu, Yunxin and Wang, Bin and An, Bo},
+  journal={arXiv preprint arXiv:2505.11891},
+  year={2025}
+}
+
+@inproceedings{sun-etal-2024-determlr,
+    title = "{D}eterm{LR}: Augmenting {LLM}-based Logical Reasoning from Indeterminacy to Determinacy",
+    author = "Sun, Hongda  and
+      Xu, Weikai  and
+      Liu, Wei  and
+      Luan, Jian  and
+      Wang, Bin  and
+      Shang, Shuo  and
+      Wen, Ji-Rong  and
+      Yan, Rui",
+    editor = "Ku, Lun-Wei  and
+      Martins, Andre  and
+      Srikumar, Vivek",
+    booktitle = "Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = aug,
+    year = "2024",
+    address = "Bangkok, Thailand",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.acl-long.531/",
+    doi = "10.18653/v1/2024.acl-long.531",
+    pages = "9828--9862",
+    abstract = "Recent advances in large language models (LLMs) have revolutionized the landscape of reasoning tasks. To enhance the capabilities of LLMs to emulate human reasoning, prior studies have focused on modeling reasoning steps using various thought structures like chains, trees, or graphs. However, LLM-based reasoning still encounters the following challenges: (1) Limited adaptability of preset structures to diverse tasks; (2) Insufficient precision in exploiting known conditions to derive new ones; and (3) Inadequate consideration of historical reasoning experiences for subsequent reasoning steps. To this end, we propose DetermLR, a novel perspective that rethinks the reasoning process as an evolution from indeterminacy to determinacy. First, we categorize known conditions into two types: determinate and indeterminate premises, facilitating the transformation process. Subsequently, we leverage quantitative measurements to prioritize more relevant premises to explore new insights. Furthermore, we automate the storage and extraction of available premises and reasoning paths with reasoning memory, preserving historical reasoning details for subsequent reasoning steps. Comprehensive experimental results demonstrate that DetermLR surpasses all baselines on various logical reasoning benchmarks: LogiQA, ProofWriter, FOLIO, PrOntoQA, and LogicalDeduction. Compared to previous multi-step reasoning methods, DetermLR achieves higher accuracy with fewer reasoning steps, highlighting its superior efficiency and effectiveness in solving logical reasoning tasks."
+}
+
+@article{liu2026come,
+  title={CoME: Empowering Channel-of-Mobile-Experts with Informative Hybrid-Capabilities Reasoning},
+  author={Liu, Yuxuan and Xu, Weikai and Huang, Kun and Chen, Changyu and Zhao, Jiankun and Gao, Pengzhi and Liu, Wei and Luan, Jian and Shang, Shuo and Du, Bo and others},
+  journal={arXiv preprint arXiv:2602.24142},
+  year={2026}
+}
+
+@inproceedings{lieffects,
+ author = {Wei Li and
+William E. Bishop and
+Alice Li and
+Christopher Rawles and
+Folawiyo Campbell{-}Ajala and
+Divya Tyamagundlu and
+Oriana Riva},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/nips/LiBLRCTR24.bib},
+ booktitle = {Advances in Neural Information Processing Systems 38: Annual Conference
+on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver,
+BC, Canada, December 10 - 15, 2024},
+ editor = {Amir Globersons and
+Lester Mackey and
+Danielle Belgrave and
+Angela Fan and
+Ulrich Paquet and
+Jakub M. Tomczak and
+Cheng Zhang},
+ timestamp = {Thu, 13 Feb 2025 00:00:00 +0100},
+ title = {On the Effects of Data Scale on {UI} Control Agents},
+ url = {http://papers.nips.cc/paper\_files/paper/2024/hash/a79f3ef3b445fd4659f44648f7ea8ffd-Abstract-Datasets\_and\_Benchmarks\_Track.html},
+ year = {2024}
+}
+
+@article{wen2023empowering,
+ author = {Wen, Hao and Li, Yuanchun and Liu, Guohong and Zhao, Shanhui and Yu, Tao and Li, Toby Jia-Jun and Jiang, Shiqi and Liu, Yunhao and Zhang, Yaqin and Liu, Yunxin},
+ journal = {ArXiv preprint},
+ title = {Empowering llm to use smartphone for intelligent task automation},
+ url = {https://arxiv.org/abs/2308.15272},
+ volume = {abs/2308.15272},
+ year = {2023}
+}
+
+@inproceedings{liu2025mobilesteward,
+  title={Mobilesteward: Integrating multiple app-oriented agents with self-evolution to automate cross-app instructions},
+  author={Liu, Yuxuan and Sun, Hongda and Liu, Wei and Luan, Jian and Du, Bo and Yan, Rui},
+  booktitle={Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V. 1},
+  pages={883--893},
+  year={2025}
+}
+
+@article{chen2025step,
+  title={STEP: Success-Rate-Aware Trajectory-Efficient Policy Optimization},
+  author={Chen, Yuhan and Liu, Yuxuan and Zhang, Long and Gao, Pengzhi and Luan, Jian and Liu, Wei},
+  journal={arXiv preprint arXiv:2511.13091},
+  year={2025}
+}
+
+@article{yang2023appagent,
+ author = {Yang, Zhao and Liu, Jiaxuan and Han, Yucheng and Chen, Xin and Huang, Zebiao and Fu, Bin and Yu, Gang},
+ journal = {ArXiv preprint},
+ title = {{AppAgent}: Multimodal agents as smartphone users},
+ url = {https://arxiv.org/abs/2312.13771},
+ volume = {abs/2312.13771},
+ year = {2023}
+}
+
+@inproceedings{zheng2024gpt,
+ author = {Boyuan Zheng and
+Boyu Gou and
+Jihyung Kil and
+Huan Sun and
+Yu Su},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/icml/ZhengGK0024.bib},
+ booktitle = {Forty-first International Conference on Machine Learning, {ICML} 2024,
+Vienna, Austria, July 21-27, 2024},
+ publisher = {OpenReview.net},
+ timestamp = {Mon, 02 Sep 2024 01:00:00 +0200},
+ title = {GPT-4V(ision) is a Generalist Web Agent, if Grounded},
+ url = {https://openreview.net/forum?id=piecKJ2DlB},
+ year = {2024}
+}
+
+@article{qin2025ui,
+ author = {Qin, Yujia and Ye, Yining and Fang, Junjie and Wang, Haoming and Liang, Shihao and Tian, Shizuo and Zhang, Junda and Li, Jiahao and Li, Yunxin and Huang, Shijue and others},
+ journal = {ArXiv preprint},
+ title = {{UI-TARS}: Pioneering Automated GUI Interaction with Native Agents},
+ url = {https://arxiv.org/abs/2501.12326},
+ volume = {abs/2501.12326},
+ year = {2025}
+}
+
+@article{teamqwen2,
+ author = {Team, Q},
+ journal = {URL https://qwenlm. github. io/blog/qwen2},
+ title = {Qwen2. 5-vl, January 2025}
+}
+
+@article{ding2024mobileagent,
+ author = {Ding, Tinghe},
+ journal = {ArXiv preprint},
+ title = {{MobileAgent}: enhancing mobile control via human-machine interaction and SOP integration},
+ url = {https://arxiv.org/abs/2401.04124},
+ volume = {abs/2401.04124},
+ year = {2024}
+}
+
+@article{li2024appagent,
+ author = {Li, Yanda and Zhang, Chi and Yang, Wanqi and Fu, Bin and Cheng, Pei and Chen, Xin and Chen, Ling and Wei, Yunchao},
+ journal = {ArXiv preprint},
+ title = {{AppAgent-V2}: Advanced Agent for Flexible Mobile Interactions},
+ url = {https://arxiv.org/abs/2408.11824},
+ volume = {abs/2408.11824},
+ year = {2024}
+}
+
+@inproceedings{wang2024mobile,
+ author = {Junyang Wang and
+Haiyang Xu and
+Haitao Jia and
+Xi Zhang and
+Ming Yan and
+Weizhou Shen and
+Ji Zhang and
+Fei Huang and
+Jitao Sang},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/nips/0001XJZYSZHS24.bib},
+ booktitle = {Advances in Neural Information Processing Systems 38: Annual Conference
+on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver,
+BC, Canada, December 10 - 15, 2024},
+ editor = {Amir Globersons and
+Lester Mackey and
+Danielle Belgrave and
+Angela Fan and
+Ulrich Paquet and
+Jakub M. Tomczak and
+Cheng Zhang},
+ timestamp = {Thu, 13 Feb 2025 00:00:00 +0100},
+ title = {Mobile-Agent-v2: Mobile Device Operation Assistant with Effective
+Navigation via Multi-Agent Collaboration},
+ url = {http://papers.nips.cc/paper\_files/paper/2024/hash/0520537ba799d375b8ff5523295c337a-Abstract-Conference.html},
+ year = {2024}
+}
+
+@inproceedings{Luoling,
+author = {Tan, Tao and Tu, Quan and Wu, Songhao and Sun, Hongda and Cheng, Chuanqi and Xu, Weikai and Yan, Rui},
+title = {Luoling: An Immersive Cross-Modal Interactive Poem Creation Factory through Multi-Agent Collaboration},
+year = {2025},
+isbn = {9798400713316},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3701716.3715184},
+doi = {10.1145/3701716.3715184},
+abstract = {Chinese poetry creation holds significant cultural and artistic value, but traditional methods are limited by attribute, text-only, or image-only inputs, often failing to capture the creator's detailed intents. Besides, the single-step generation will result in inconsistencies between the intents and the generated poem. In this work, we introduce Luoling, an immersive, cross-modal interactive poem creation factory with fine-grained, controllable attributes, driven by a multi-agent collaboration system. Luoling integrates text, image, and attribute fusion as inputs, enabling a richer, more expressive creative process. The interactive poem creation process is first introduced, where a large language model engages in proactive dialogue with the creator, guiding precise intent expression. Luoling is powered by a multi-agent collaboration system, including a poem writer, adviser, and rhythm checker, to refine the poem. Finally, the poem is delivered with the poet's tone using style-based text-to-speech technology, providing an authentic auditory experience. Luoling offers a more immersive environment, motivating creators to express their physical and spiritual feelings through compositions.},
+booktitle = {Companion Proceedings of the ACM on Web Conference 2025},
+pages = {2911–2914},
+numpages = {4},
+keywords = {cross-modal learning, multi-agent collaboration, poem creation},
+location = {Sydney NSW, Australia},
+series = {WWW '25}
+}
+
+@article{cheng2024seeclick,
+ author = {Cheng, Kanzhi and Sun, Qiushi and Chu, Yougang and Xu, Fangzhi and Li, Yantao and Zhang, Jianbing and Wu, Zhiyong},
+ journal = {ArXiv preprint},
+ title = {{SeeClick}: Harnessing gui grounding for advanced visual gui agents},
+ url = {https://arxiv.org/abs/2401.10935},
+ volume = {abs/2401.10935},
+ year = {2024}
+}
+
+@article{wu2024atlas,
+ author = {Wu, Zhiyong and Wu, Zhenyu and Xu, Fangzhi and Wang, Yian and Sun, Qiushi and Jia, Chengyou and Cheng, Kanzhi and Ding, Zichen and Chen, Liheng and Liang, Paul Pu and others},
+ journal = {ArXiv preprint},
+ title = {{Os-Atlas}: A foundation action model for generalist gui agents},
+ url = {https://arxiv.org/abs/2410.23218},
+ volume = {abs/2410.23218},
+ year = {2024}
+}
+
+@inproceedings{niu2024screenagent,
+ author = {Runliang Niu and
+Jindong Li and
+Shiqi Wang and
+Yali Fu and
+Xiyu Hu and
+Xueyuan Leng and
+He Kong and
+Yi Chang and
+Qi Wang},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/ijcai/NiuL0FHLKCW24.bib},
+ booktitle = {Proceedings of the Thirty-Third International Joint Conference on
+Artificial Intelligence, {IJCAI} 2024, Jeju, South Korea, August 3-9,
+2024},
+ pages = {6433--6441},
+ publisher = {ijcai.org},
+ timestamp = {Sun, 09 Feb 2025 00:00:00 +0100},
+ title = {ScreenAgent: {A} Vision Language Model-driven Computer Control Agent},
+ url = {https://www.ijcai.org/proceedings/2024/711},
+ year = {2024}
+}
+
+@article{lu2024gui,
+ author = {Lu, Quanfeng and Shao, Wenqi and Liu, Zitao and Meng, Fanqing and Li, Boxuan and Chen, Botong and Huang, Siyuan and Zhang, Kaipeng and Qiao, Yu and Luo, Ping},
+ journal = {ArXiv preprint},
+ title = {{GUI Odyssey}: A Comprehensive Dataset for Cross-App GUI Navigation on Mobile Devices},
+ url = {https://arxiv.org/abs/2406.08451},
+ volume = {abs/2406.08451},
+ year = {2024}
+}
+
+@article{gou2024navigating,
+ author = {Gou, Boyu and Wang, Ruohan and Zheng, Boyuan and Xie, Yanan and Chang, Cheng and Shu, Yiheng and Sun, Huan and Su, Yu},
+ journal = {ArXiv preprint},
+ title = {Navigating the digital world as humans do: Universal visual grounding for gui agents},
+ url = {https://arxiv.org/abs/2410.05243},
+ volume = {abs/2410.05243},
+ year = {2024}
+}
+
+@article{wang2025fedmobileagent,
+ author = {Wang, Wenhao and Yu, Zijie and Liu, William and Ye, Rui and Jin, Tian and Chen, Siheng and Wang, Yanfeng},
+ journal = {ArXiv preprint},
+ title = {{FedMobileAgent}: Training Mobile Agents Using Decentralized Self-Sourced Data from Diverse Users},
+ url = {https://arxiv.org/abs/2502.02982},
+ volume = {abs/2502.02982},
+ year = {2025}
+}
+
+@article{you2024ferret,
+ author = {You, Keen and Zhang, Haotian and Schoop, Eldon and Weers, Floris and Swearngin, Amanda and Nichols, Jeffrey and Yang, Yinfei and Gan, Zhe},
+ journal = {ArXiv preprint},
+ title = {{Ferret-UI}: Grounded Mobile UI Understanding with Multimodal LLMs},
+ url = {https://arxiv.org/abs/2404.05719},
+ volume = {abs/2404.05719},
+ year = {2024}
+}
+
+@inproceedings{baechler2024screenai,
+ author = {Gilles Baechler and
+Srinivas Sunkara and
+Maria Wang and
+Fedir Zubach and
+Hassan Mansoor and
+Vincent Etter and
+Victor Carbune and
+Jason Lin and
+Jindong Chen and
+Abhanshu Sharma},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/ijcai/BaechlerSWZMECL24.bib},
+ booktitle = {Proceedings of the Thirty-Third International Joint Conference on
+Artificial Intelligence, {IJCAI} 2024, Jeju, South Korea, August 3-9,
+2024},
+ pages = {3058--3068},
+ publisher = {ijcai.org},
+ timestamp = {Fri, 18 Oct 2024 01:00:00 +0200},
+ title = {ScreenAI: {A} Vision-Language Model for {UI} and Infographics Understanding},
+ url = {https://www.ijcai.org/proceedings/2024/339},
+ year = {2024}
+}
+
+@article{zhang2024llamatouch,
+ author = {Zhang, Li and Wang, Shihe and Jia, Xianqing and Zheng, Zhihan and Yan, Yunhe and Gao, Longxi and Li, Yuanchun and Xu, Mengwei},
+ journal = {ArXiv preprint},
+ title = {{LlamaTouch}: A Faithful and Scalable Testbed for Mobile UI Task Automation},
+ url = {https://arxiv.org/abs/2404.16054},
+ volume = {abs/2404.16054},
+ year = {2024}
+}
+
+@article{nong2024mobileflow,
+ author = {Nong, Songqin and Zhu, Jiali and Wu, Rui and Jin, Jiongchao and Shan, Shuo and Huang, Xiutian and Xu, Wenhao},
+ journal = {ArXiv preprint},
+ title = {{MobileFlow}: A Multimodal LLM For Mobile GUI Agent},
+ url = {https://arxiv.org/abs/2407.04346},
+ volume = {abs/2407.04346},
+ year = {2024}
+}
+
+@article{xu2024aguvis,
+ author = {Xu, Yiheng and Wang, Zekun and Wang, Junli and Lu, Dunjie and Xie, Tianbao and Saha, Amrita and Sahoo, Doyen and Yu, Tao and Xiong, Caiming},
+ journal = {ArXiv preprint},
+ title = {{Aguvis}: Unified Pure Vision Agents for Autonomous GUI Interaction},
+ url = {https://arxiv.org/abs/2412.04454},
+ volume = {abs/2412.04454},
+ year = {2024}
+}
+
+@article{qinghong2024showui,
+ author = {Qinghong Lin, Kevin and Li, Linjie and Gao, Difei and Yang, Zhengyuan and Wu, Shiwei and Bai, Zechen and Lei, Weixian and Wang, Lijuan and Shou, Mike Zheng},
+ journal = {arXiv e-prints},
+ pages = {arXiv--2411},
+ title = {{ShowUI}: One Vision-Language-Action Model for GUI Visual Agent},
+ year = {2024}
+}
+
+@article{dorka2024training,
+ author = {Dorka, Nicolai and Marecki, Janusz and Anwar, Ammar},
+ journal = {ArXiv preprint},
+ title = {Training a Vision Language Model as Smartphone Assistant},
+ url = {https://arxiv.org/abs/2404.08755},
+ volume = {abs/2404.08755},
+ year = {2024}
+}
+
+@inproceedings{rafailov2024direct,
+ author = {Rafael Rafailov and
+Archit Sharma and
+Eric Mitchell and
+Christopher D. Manning and
+Stefano Ermon and
+Chelsea Finn},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/nips/RafailovSMMEF23.bib},
+ booktitle = {Advances in Neural Information Processing Systems 36: Annual Conference
+on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans,
+LA, USA, December 10 - 16, 2023},
+ editor = {Alice Oh and
+Tristan Naumann and
+Amir Globerson and
+Kate Saenko and
+Moritz Hardt and
+Sergey Levine},
+ timestamp = {Fri, 01 Mar 2024 00:00:00 +0100},
+ title = {Direct Preference Optimization: Your Language Model is Secretly a
+Reward Model},
+ url = {http://papers.nips.cc/paper\_files/paper/2023/hash/a85b405ed65c6477a4fe8302b5e06ce7-Abstract-Conference.html},
+ year = {2023}
+}
+
+@inproceedings{azar2024general,
+ author = {Mohammad Gheshlaghi Azar and
+Zhaohan Daniel Guo and
+Bilal Piot and
+R{\'{e}}mi Munos and
+Mark Rowland and
+Michal Valko and
+Daniele Calandriello},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/aistats/AzarGPMRVC24.bib},
+ booktitle = {International Conference on Artificial Intelligence and Statistics,
+2-4 May 2024, Palau de Congressos, Valencia, Spain},
+ editor = {Sanjoy Dasgupta and
+Stephan Mandt and
+Yingzhen Li},
+ pages = {4447--4455},
+ publisher = {{PMLR}},
+ series = {Proceedings of Machine Learning Research},
+ timestamp = {Mon, 13 May 2024 01:00:00 +0200},
+ title = {A General Theoretical Paradigm to Understand Learning from Human Preferences},
+ url = {https://proceedings.mlr.press/v238/gheshlaghi-azar24a.html},
+ volume = {238},
+ year = {2024}
+}
+
+@techreport{ethayarajh2023human,
+ author = {Ethayarajh, Kawin and Xu, Winnie and Jurafsky, Dan and Kiela, Douwe},
+ institution = {Technical report, Contextual AI},
+ title = {Human-centered loss functions (halos)},
+ year = {2023}
+}
+
+@article{schulman2017proximal,
+ author = {Schulman, John and Wolski, Filip and Dhariwal, Prafulla and Radford, Alec and Klimov, Oleg},
+ journal = {ArXiv preprint},
+ title = {Proximal policy optimization algorithms},
+ url = {https://arxiv.org/abs/1707.06347},
+ volume = {abs/1707.06347},
+ year = {2017}
+}
+
+@article{luong2024reft,
+ author = {Luong, Trung Quoc and Zhang, Xinbo and Jie, Zhanming and Sun, Peng and Jin, Xiaoran and Li, Hang},
+ journal = {ArXiv preprint},
+ title = {{ReFT}: Reasoning with reinforced fine-tuning},
+ url = {https://arxiv.org/abs/2401.08967},
+ volume = {abs/2401.08967},
+ year = {2024}
+}
+
+@inproceedings{zhang2024rest,
+ author = {Dan Zhang and
+Sining Zhoubian and
+Ziniu Hu and
+Yisong Yue and
+Yuxiao Dong and
+Jie Tang},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/nips/ZhangZHYD024.bib},
+ booktitle = {Advances in Neural Information Processing Systems 38: Annual Conference
+on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver,
+BC, Canada, December 10 - 15, 2024},
+ editor = {Amir Globersons and
+Lester Mackey and
+Danielle Belgrave and
+Angela Fan and
+Ulrich Paquet and
+Jakub M. Tomczak and
+Cheng Zhang},
+ timestamp = {Thu, 13 Feb 2025 00:00:00 +0100},
+ title = {ReST-MCTS*: {LLM} Self-Training via Process Reward Guided Tree Search},
+ url = {http://papers.nips.cc/paper\_files/paper/2024/hash/76ec4dc30e9faaf0e4b6093eaa377218-Abstract-Conference.html},
+ year = {2024}
+}
+
+@article{xie2024monte,
+ author = {Xie, Yuxi and Goyal, Anirudh and Zheng, Wenyue and Kan, Min-Yen and Lillicrap, Timothy P. and Kawaguchi, Kenji and Shieh, Michael},
+ journal = {ArXiv preprint},
+ title = {Monte Carlo Tree Search Boosts Reasoning via Iterative Preference Learning},
+ url = {https://arxiv.org/abs/2405.00451},
+ volume = {abs/2405.00451},
+ year = {2024}
+}
+
+@inproceedings{bai2024digirl,
+ author = {Hao Bai and
+Yifei Zhou and
+Jiayi Pan and
+Mert Cemri and
+Alane Suhr and
+Sergey Levine and
+Aviral Kumar},
+ bibsource = {dblp computer science bibliography, https://dblp.org},
+ biburl = {https://dblp.org/rec/conf/nips/BaiZPCSLK24.bib},
+ booktitle = {Advances in Neural Information Processing Systems 38: Annual Conference
+on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver,
+BC, Canada, December 10 - 15, 2024},
+ editor = {Amir Globersons and
+Lester Mackey and
+Danielle Belgrave and
+Angela Fan and
+Ulrich Paquet and
+Jakub M. Tomczak and
+Cheng Zhang},
+ timestamp = {Thu, 13 Feb 2025 00:00:00 +0100},
+ title = {DigiRL: Training In-The-Wild Device-Control Agents with Autonomous
+Reinforcement Learning},
+ url = {http://papers.nips.cc/paper\_files/paper/2024/hash/1704ddd0bb89f159dfe609b32c889995-Abstract-Conference.html},
+ year = {2024}
+}
+
+@article{wang2024distrl,
+ author = {Wang, Taiyi and Wu, Zhihao and Liu, Jianheng and Hao, Jianye and Wang, Jun and Shao, Kun},
+ journal = {ArXiv preprint},
+ title = {{DistRL}: An asynchronous distributed reinforcement learning framework for on-device control agents},
+ url = {https://arxiv.org/abs/2410.14803},
+ volume = {abs/2410.14803},
+ year = {2024}
+}
+
+@article{wu2025reachagent,
+ author = {Wu, Qinzhuo and Liu, Wei and Luan, Jian and Wang, Bin},
+ journal = {ArXiv preprint},
+ title = {{ReachAgent}: Enhancing Mobile Agent via Page Reaching and Operation},
+ url = {https://arxiv.org/abs/2502.02955},
+ volume = {abs/2502.02955},
+ year = {2025}
+}
+
+@inproceedings{jiao2025tcpo,
+  title={TCPO: Thought-Centric Preference Optimization for Effective Embodied Decision-making},
+  author={Jiao, Kechen and Fang, Zhirui and Liu, Jiahao and Li, Bei and Wang, Qifan and Liu, Xinyu and Ruan, Junhao and Qiao, Zhongjian and Zhu, Yifan and Xu, Yaxin and others},
+  booktitle={Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing},
+  pages={9585--9599},
+  year={2025}
+}
+
+@article{li2025treepo,
+  title={Treepo: Bridging the gap of policy optimization and efficacy and inference efficiency with heuristic tree-based modeling},
+  author={Li, Yizhi and Gu, Qingshui and Wen, Zhoufutu and Li, Ziniu and Xing, Tianshun and Guo, Shuyue and Zheng, Tianyu and Zhou, Xin and Qu, Xingwei and Zhou, Wangchunshu and others},
+  journal={arXiv preprint arXiv:2508.17445},
+  year={2025}
+}
+
+@article{hou2025treerl,
+  title={TreeRL: LLM Reinforcement Learning with On-Policy Tree Search},
+  author={Hou, Zhenyu and Hu, Ziniu and Li, Yujiang and Lu, Rui and Tang, Jie and Dong, Yuxiao},
+  journal={arXiv preprint arXiv:2506.11902},
+  year={2025}
+}
+
+@article{guo2025segment,
+  title={Segment policy optimization: Effective segment-level credit assignment in rl for large language models},
+  author={Guo, Yiran and Xu, Lijie and Liu, Jie and Ye, Dan and Qiu, Shuang},
+  journal={arXiv preprint arXiv:2505.23564},
+  year={2025}
+}

benchmark_dataset/papers/ICLR2026_0004_2505.12299/source_related_work.tex

@@ -0,0 +1,19 @@
+\section{Related Work}
+\subsection{Mobile GUI Agent}
+LLMs~ are increasingly used as autonomous agents for mobile interaction~.
+With the rapid development of vision-language models (VLMs), researchers build mobile GUI agents and multi-agent frameworks based on closed-source VLMs.
+Meanwhile, some researchers focus on training agents with stronger element grounding , page navigation , GUI understanding and task planning capabilities based on open-source VLMs.
+Our method organizes trajectory data into multi-turns of dialogues based on the CoaT thinking pattern, preventing the agent becomes an action model with limited capabilities.
+\subsection{Reinforcement Learning}
+The algorithms applied in natural language processing to align with human preferences include Direct Preference Optimization (DPO) , Identity Preference Optimization (IPO) , Kahneman-Tversky Optimization (KTO) , and Proximal Policy Optimization (PPO) . Specifically, ReFT adopts reinforcement learning as a fine-tuning paradigm to improve performance on math problems.
+ReST-MCTS* focuses on the higher-quality step reward, where the process reward model is important. Xie, et al. label the preference via MCTS based on feedback from self-evaluation.
+For mobile GUI agents, Digirl and Distrl use online trajectory collection to improve the generalization of agents whose process is very slow.
+Reachagent uses DPO training to compare the quality of multiple actions.
+TCPO also optimizes thoughts, but does not explicitly enforce thought–action consistency. TreePO , TreeRL , and SPO segment long sequences into many short segments, which leads to high computational cost and low data efficiency.
+In contrast, our method models thoughts with a fixed CoaT-tree and uses T-DPO to optimize the thinking process, while step values are computed directly from rule-based rewards, without unstable PRMs. This design yields more efficient sampling and training, especially in GUI-agent settings.
+\begin{figure*}[ht]
+ \centering
+ \includegraphics[width=0.85\textwidth]{img/main.pdf}
+ \caption{Overview of iterative preference learning framework. The left part presents the process of warm-up fine-tuning a general VLM to a mobile GUI domain agent with basic capabilities. The mid and right parts represent the iterative CoaT thinking-level sampling and T-DPO training process.}
+ \label{fig:main}
+\end{figure*}

benchmark_dataset/papers/ICLR2026_0005_2510.07794/metadata.json

@@ -0,0 +1,72 @@
+{
+  "paper_id": "ICLR2026_0005_2510.07794",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "HiPRAG: Hierarchical Process Rewards for Efficient Agentic Retrieval Augmented Generation",
+  "authors": [
+    "Peilin Wu",
+    "Mian Zhang",
+    "Kun Wan",
+    "Wentian Zhao",
+    "Kaiyu He",
+    "Xinya Du",
+    "Zhiyu Chen"
+  ],
+  "domain_score": 26,
+  "domain_areas": [
+    "model_architecture",
+    "test_time_reasoning_compute",
+    "rag_agents_tools",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "Gt4v9WBPzm",
+  "openreview_forum": "Gt4v9WBPzm",
+  "openreview_url": "https://openreview.net/forum?id=Gt4v9WBPzm",
+  "arxiv_id": "2510.07794",
+  "arxiv_id_versioned": "2510.07794v2",
+  "arxiv_abs_url": "http://arxiv.org/abs/2510.07794v2",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2510.07794v2",
+  "arxiv_source_url": "https://arxiv.org/e-print/2510.07794",
+  "arxiv_title": "HiPRAG: Hierarchical Process Rewards for Efficient Agentic Retrieval Augmented Generation",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-10-09T05:13:10Z",
+  "arxiv_updated": "2026-04-11T16:18:46Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 2,
+  "status": "ok",
+  "main_tex_original_path": "iclr2026_conference.tex",
+  "expanded_inputs_count": 1,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "yao2023react",
+    "trivedi-etal-2023-interleaving",
+    "wang2025chainofretrievalaugmentedgeneration",
+    "guan2025deepragthinkingretrievalstep",
+    "singh2025agenticretrievalaugmentedgenerationsurvey",
+    "202507.2024",
+    "zhang2025landscapeagenticreinforcementlearning",
+    "huang2025ragrladvancingretrievalaugmentedgeneration",
+    "qian2025toolrlrewardtoollearning",
+    "li2025torlscalingtoolintegratedrl",
+    "mallen-etal-2023-trust",
+    "dhole2025retrieveretrieveuncertaintydetection",
+    "su-etal-2024-dragin",
+    "zubkova2025sugarleveragingcontextualconfidence",
+    "yao-etal-2025-seakr",
+    "huanshuo-etal-2025-ctrla",
+    "sha2025semreinforcementlearningsearchefficient",
+    "wu2025searchwiselymitigatingsuboptimal",
+    "song2025r1searcherincentivizingdynamicknowledge",
+    "huang2025reinforcedinternalexternalknowledgesynergistic",
+    "10.1145/3726302.3730102",
+    "qian2025smartselfawareagenttool",
+    "shen-etal-2024-smartcal",
+    "wang2025actingreasoningmoreteaching",
+    "yue2025promotingefficientreasoningverifiable",
+    "ye2025correctnessharmonizingprocessoutcome"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0005_2510.07794/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f03f43157582ef01bdff063e866a99fb4dc495aa6ef948f1bd198152584146ac
+size 889974

benchmark_dataset/papers/ICLR2026_0005_2510.07794/source.tex

@@ -0,0 +1,804 @@
+\documentclass{article}
+\usepackage{iclr2026_conference,times}
+
+
+\usepackage{amsmath,amsfonts,bm}
+
+\newcommand{\figleft}{{\em (Left)}}
+\newcommand{\figcenter}{{\em (Center)}}
+\newcommand{\figright}{{\em (Right)}}
+\newcommand{\figtop}{{\em (Top)}}
+\newcommand{\figbottom}{{\em (Bottom)}}
+\newcommand{\captiona}{{\em (a)}}
+\newcommand{\captionb}{{\em (b)}}
+\newcommand{\captionc}{{\em (c)}}
+\newcommand{\captiond}{{\em (d)}}
+
+\newcommand{\newterm}[1]{{\bf #1}}
+
+
+\def\figref#1{figure~\ref{#1}}
+\def\Figref#1{Figure~\ref{#1}}
+\def\twofigref#1#2{figures \ref{#1} and \ref{#2}}
+\def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}}
+\def\secref#1{section~\ref{#1}}
+\def\Secref#1{Section~\ref{#1}}
+\def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}}
+\def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}}
+\def\eqref#1{equation~\ref{#1}}
+\def\Eqref#1{Equation~\ref{#1}}
+\def\plaineqref#1{\ref{#1}}
+\def\chapref#1{chapter~\ref{#1}}
+\def\Chapref#1{Chapter~\ref{#1}}
+\def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}}
+\def\algref#1{algorithm~\ref{#1}}
+\def\Algref#1{Algorithm~\ref{#1}}
+\def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}}
+\def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}}
+\def\partref#1{part~\ref{#1}}
+\def\Partref#1{Part~\ref{#1}}
+\def\twopartref#1#2{parts \ref{#1} and \ref{#2}}
+
+\def\ceil#1{\lceil #1 \rceil}
+\def\floor#1{\lfloor #1 \rfloor}
+\def\1{\bm{1}}
+\newcommand{\train}{\mathcal{D}}
+\newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}}
+\newcommand{\test}{\mathcal{D_{\mathrm{test}}}}
+
+\def\eps{{\epsilon}}
+
+
+\def\reta{{\textnormal{$\eta$}}}
+\def\ra{{\textnormal{a}}}
+\def\rb{{\textnormal{b}}}
+\def\rc{{\textnormal{c}}}
+\def\rd{{\textnormal{d}}}
+\def\re{{\textnormal{e}}}
+\def\rf{{\textnormal{f}}}
+\def\rg{{\textnormal{g}}}
+\def\rh{{\textnormal{h}}}
+\def\ri{{\textnormal{i}}}
+\def\rj{{\textnormal{j}}}
+\def\rk{{\textnormal{k}}}
+\def\rl{{\textnormal{l}}}
+\def\rn{{\textnormal{n}}}
+\def\ro{{\textnormal{o}}}
+\def\rp{{\textnormal{p}}}
+\def\rq{{\textnormal{q}}}
+\def\rr{{\textnormal{r}}}
+\def\rs{{\textnormal{s}}}
+\def\rt{{\textnormal{t}}}
+\def\ru{{\textnormal{u}}}
+\def\rv{{\textnormal{v}}}
+\def\rw{{\textnormal{w}}}
+\def\rx{{\textnormal{x}}}
+\def\ry{{\textnormal{y}}}
+\def\rz{{\textnormal{z}}}
+
+\def\rvepsilon{{\mathbf{\epsilon}}}
+\def\rvtheta{{\mathbf{\theta}}}
+\def\rva{{\mathbf{a}}}
+\def\rvb{{\mathbf{b}}}
+\def\rvc{{\mathbf{c}}}
+\def\rvd{{\mathbf{d}}}
+\def\rve{{\mathbf{e}}}
+\def\rvf{{\mathbf{f}}}
+\def\rvg{{\mathbf{g}}}
+\def\rvh{{\mathbf{h}}}
+\def\rvu{{\mathbf{i}}}
+\def\rvj{{\mathbf{j}}}
+\def\rvk{{\mathbf{k}}}
+\def\rvl{{\mathbf{l}}}
+\def\rvm{{\mathbf{m}}}
+\def\rvn{{\mathbf{n}}}
+\def\rvo{{\mathbf{o}}}
+\def\rvp{{\mathbf{p}}}
+\def\rvq{{\mathbf{q}}}
+\def\rvr{{\mathbf{r}}}
+\def\rvs{{\mathbf{s}}}
+\def\rvt{{\mathbf{t}}}
+\def\rvu{{\mathbf{u}}}
+\def\rvv{{\mathbf{v}}}
+\def\rvw{{\mathbf{w}}}
+\def\rvx{{\mathbf{x}}}
+\def\rvy{{\mathbf{y}}}
+\def\rvz{{\mathbf{z}}}
+
+\def\erva{{\textnormal{a}}}
+\def\ervb{{\textnormal{b}}}
+\def\ervc{{\textnormal{c}}}
+\def\ervd{{\textnormal{d}}}
+\def\erve{{\textnormal{e}}}
+\def\ervf{{\textnormal{f}}}
+\def\ervg{{\textnormal{g}}}
+\def\ervh{{\textnormal{h}}}
+\def\ervi{{\textnormal{i}}}
+\def\ervj{{\textnormal{j}}}
+\def\ervk{{\textnormal{k}}}
+\def\ervl{{\textnormal{l}}}
+\def\ervm{{\textnormal{m}}}
+\def\ervn{{\textnormal{n}}}
+\def\ervo{{\textnormal{o}}}
+\def\ervp{{\textnormal{p}}}
+\def\ervq{{\textnormal{q}}}
+\def\ervr{{\textnormal{r}}}
+\def\ervs{{\textnormal{s}}}
+\def\ervt{{\textnormal{t}}}
+\def\ervu{{\textnormal{u}}}
+\def\ervv{{\textnormal{v}}}
+\def\ervw{{\textnormal{w}}}
+\def\ervx{{\textnormal{x}}}
+\def\ervy{{\textnormal{y}}}
+\def\ervz{{\textnormal{z}}}
+
+\def\rmA{{\mathbf{A}}}
+\def\rmB{{\mathbf{B}}}
+\def\rmC{{\mathbf{C}}}
+\def\rmD{{\mathbf{D}}}
+\def\rmE{{\mathbf{E}}}
+\def\rmF{{\mathbf{F}}}
+\def\rmG{{\mathbf{G}}}
+\def\rmH{{\mathbf{H}}}
+\def\rmI{{\mathbf{I}}}
+\def\rmJ{{\mathbf{J}}}
+\def\rmK{{\mathbf{K}}}
+\def\rmL{{\mathbf{L}}}
+\def\rmM{{\mathbf{M}}}
+\def\rmN{{\mathbf{N}}}
+\def\rmO{{\mathbf{O}}}
+\def\rmP{{\mathbf{P}}}
+\def\rmQ{{\mathbf{Q}}}
+\def\rmR{{\mathbf{R}}}
+\def\rmS{{\mathbf{S}}}
+\def\rmT{{\mathbf{T}}}
+\def\rmU{{\mathbf{U}}}
+\def\rmV{{\mathbf{V}}}
+\def\rmW{{\mathbf{W}}}
+\def\rmX{{\mathbf{X}}}
+\def\rmY{{\mathbf{Y}}}
+\def\rmZ{{\mathbf{Z}}}
+
+\def\ermA{{\textnormal{A}}}
+\def\ermB{{\textnormal{B}}}
+\def\ermC{{\textnormal{C}}}
+\def\ermD{{\textnormal{D}}}
+\def\ermE{{\textnormal{E}}}
+\def\ermF{{\textnormal{F}}}
+\def\ermG{{\textnormal{G}}}
+\def\ermH{{\textnormal{H}}}
+\def\ermI{{\textnormal{I}}}
+\def\ermJ{{\textnormal{J}}}
+\def\ermK{{\textnormal{K}}}
+\def\ermL{{\textnormal{L}}}
+\def\ermM{{\textnormal{M}}}
+\def\ermN{{\textnormal{N}}}
+\def\ermO{{\textnormal{O}}}
+\def\ermP{{\textnormal{P}}}
+\def\ermQ{{\textnormal{Q}}}
+\def\ermR{{\textnormal{R}}}
+\def\ermS{{\textnormal{S}}}
+\def\ermT{{\textnormal{T}}}
+\def\ermU{{\textnormal{U}}}
+\def\ermV{{\textnormal{V}}}
+\def\ermW{{\textnormal{W}}}
+\def\ermX{{\textnormal{X}}}
+\def\ermY{{\textnormal{Y}}}
+\def\ermZ{{\textnormal{Z}}}
+
+\def\vzero{{\bm{0}}}
+\def\vone{{\bm{1}}}
+\def\vmu{{\bm{\mu}}}
+\def\vtheta{{\bm{\theta}}}
+\def\va{{\bm{a}}}
+\def\vb{{\bm{b}}}
+\def\vc{{\bm{c}}}
+\def\vd{{\bm{d}}}
+\def\ve{{\bm{e}}}
+\def\vf{{\bm{f}}}
+\def\vg{{\bm{g}}}
+\def\vh{{\bm{h}}}
+\def\vi{{\bm{i}}}
+\def\vj{{\bm{j}}}
+\def\vk{{\bm{k}}}
+\def\vl{{\bm{l}}}
+\def\vm{{\bm{m}}}
+\def\vn{{\bm{n}}}
+\def\vo{{\bm{o}}}
+\def\vp{{\bm{p}}}
+\def\vq{{\bm{q}}}
+\def\vr{{\bm{r}}}
+\def\vs{{\bm{s}}}
+\def\vt{{\bm{t}}}
+\def\vu{{\bm{u}}}
+\def\vv{{\bm{v}}}
+\def\vw{{\bm{w}}}
+\def\vx{{\bm{x}}}
+\def\vy{{\bm{y}}}
+\def\vz{{\bm{z}}}
+
+\def\evalpha{{\alpha}}
+\def\evbeta{{\beta}}
+\def\evepsilon{{\epsilon}}
+\def\evlambda{{\lambda}}
+\def\evomega{{\omega}}
+\def\evmu{{\mu}}
+\def\evpsi{{\psi}}
+\def\evsigma{{\sigma}}
+\def\evtheta{{\theta}}
+\def\eva{{a}}
+\def\evb{{b}}
+\def\evc{{c}}
+\def\evd{{d}}
+\def\eve{{e}}
+\def\evf{{f}}
+\def\evg{{g}}
+\def\evh{{h}}
+\def\evi{{i}}
+\def\evj{{j}}
+\def\evk{{k}}
+\def\evl{{l}}
+\def\evm{{m}}
+\def\evn{{n}}
+\def\evo{{o}}
+\def\evp{{p}}
+\def\evq{{q}}
+\def\evr{{r}}
+\def\evs{{s}}
+\def\evt{{t}}
+\def\evu{{u}}
+\def\evv{{v}}
+\def\evw{{w}}
+\def\evx{{x}}
+\def\evy{{y}}
+\def\evz{{z}}
+
+\def\mA{{\bm{A}}}
+\def\mB{{\bm{B}}}
+\def\mC{{\bm{C}}}
+\def\mD{{\bm{D}}}
+\def\mE{{\bm{E}}}
+\def\mF{{\bm{F}}}
+\def\mG{{\bm{G}}}
+\def\mH{{\bm{H}}}
+\def\mI{{\bm{I}}}
+\def\mJ{{\bm{J}}}
+\def\mK{{\bm{K}}}
+\def\mL{{\bm{L}}}
+\def\mM{{\bm{M}}}
+\def\mN{{\bm{N}}}
+\def\mO{{\bm{O}}}
+\def\mP{{\bm{P}}}
+\def\mQ{{\bm{Q}}}
+\def\mR{{\bm{R}}}
+\def\mS{{\bm{S}}}
+\def\mT{{\bm{T}}}
+\def\mU{{\bm{U}}}
+\def\mV{{\bm{V}}}
+\def\mW{{\bm{W}}}
+\def\mX{{\bm{X}}}
+\def\mY{{\bm{Y}}}
+\def\mZ{{\bm{Z}}}
+\def\mBeta{{\bm{\beta}}}
+\def\mPhi{{\bm{\Phi}}}
+\def\mLambda{{\bm{\Lambda}}}
+\def\mSigma{{\bm{\Sigma}}}
+
+\DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl}
+\SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{n}
+\newcommand{\tens}[1]{\bm{\mathsfit{#1}}}
+\def\tA{{\tens{A}}}
+\def\tB{{\tens{B}}}
+\def\tC{{\tens{C}}}
+\def\tD{{\tens{D}}}
+\def\tE{{\tens{E}}}
+\def\tF{{\tens{F}}}
+\def\tG{{\tens{G}}}
+\def\tH{{\tens{H}}}
+\def\tI{{\tens{I}}}
+\def\tJ{{\tens{J}}}
+\def\tK{{\tens{K}}}
+\def\tL{{\tens{L}}}
+\def\tM{{\tens{M}}}
+\def\tN{{\tens{N}}}
+\def\tO{{\tens{O}}}
+\def\tP{{\tens{P}}}
+\def\tQ{{\tens{Q}}}
+\def\tR{{\tens{R}}}
+\def\tS{{\tens{S}}}
+\def\tT{{\tens{T}}}
+\def\tU{{\tens{U}}}
+\def\tV{{\tens{V}}}
+\def\tW{{\tens{W}}}
+\def\tX{{\tens{X}}}
+\def\tY{{\tens{Y}}}
+\def\tZ{{\tens{Z}}}
+
+
+\def\gA{{\mathcal{A}}}
+\def\gB{{\mathcal{B}}}
+\def\gC{{\mathcal{C}}}
+\def\gD{{\mathcal{D}}}
+\def\gE{{\mathcal{E}}}
+\def\gF{{\mathcal{F}}}
+\def\gG{{\mathcal{G}}}
+\def\gH{{\mathcal{H}}}
+\def\gI{{\mathcal{I}}}
+\def\gJ{{\mathcal{J}}}
+\def\gK{{\mathcal{K}}}
+\def\gL{{\mathcal{L}}}
+\def\gM{{\mathcal{M}}}
+\def\gN{{\mathcal{N}}}
+\def\gO{{\mathcal{O}}}
+\def\gP{{\mathcal{P}}}
+\def\gQ{{\mathcal{Q}}}
+\def\gR{{\mathcal{R}}}
+\def\gS{{\mathcal{S}}}
+\def\gT{{\mathcal{T}}}
+\def\gU{{\mathcal{U}}}
+\def\gV{{\mathcal{V}}}
+\def\gW{{\mathcal{W}}}
+\def\gX{{\mathcal{X}}}
+\def\gY{{\mathcal{Y}}}
+\def\gZ{{\mathcal{Z}}}
+
+\def\sA{{\mathbb{A}}}
+\def\sB{{\mathbb{B}}}
+\def\sC{{\mathbb{C}}}
+\def\sD{{\mathbb{D}}}
+\def\sF{{\mathbb{F}}}
+\def\sG{{\mathbb{G}}}
+\def\sH{{\mathbb{H}}}
+\def\sI{{\mathbb{I}}}
+\def\sJ{{\mathbb{J}}}
+\def\sK{{\mathbb{K}}}
+\def\sL{{\mathbb{L}}}
+\def\sM{{\mathbb{M}}}
+\def\sN{{\mathbb{N}}}
+\def\sO{{\mathbb{O}}}
+\def\sP{{\mathbb{P}}}
+\def\sQ{{\mathbb{Q}}}
+\def\sR{{\mathbb{R}}}
+\def\sS{{\mathbb{S}}}
+\def\sT{{\mathbb{T}}}
+\def\sU{{\mathbb{U}}}
+\def\sV{{\mathbb{V}}}
+\def\sW{{\mathbb{W}}}
+\def\sX{{\mathbb{X}}}
+\def\sY{{\mathbb{Y}}}
+\def\sZ{{\mathbb{Z}}}
+
+\def\emLambda{{\Lambda}}
+\def\emA{{A}}
+\def\emB{{B}}
+\def\emC{{C}}
+\def\emD{{D}}
+\def\emE{{E}}
+\def\emF{{F}}
+\def\emG{{G}}
+\def\emH{{H}}
+\def\emI{{I}}
+\def\emJ{{J}}
+\def\emK{{K}}
+\def\emL{{L}}
+\def\emM{{M}}
+\def\emN{{N}}
+\def\emO{{O}}
+\def\emP{{P}}
+\def\emQ{{Q}}
+\def\emR{{R}}
+\def\emS{{S}}
+\def\emT{{T}}
+\def\emU{{U}}
+\def\emV{{V}}
+\def\emW{{W}}
+\def\emX{{X}}
+\def\emY{{Y}}
+\def\emZ{{Z}}
+\def\emSigma{{\Sigma}}
+
+\newcommand{\etens}[1]{\mathsfit{#1}}
+\def\etLambda{{\etens{\Lambda}}}
+\def\etA{{\etens{A}}}
+\def\etB{{\etens{B}}}
+\def\etC{{\etens{C}}}
+\def\etD{{\etens{D}}}
+\def\etE{{\etens{E}}}
+\def\etF{{\etens{F}}}
+\def\etG{{\etens{G}}}
+\def\etH{{\etens{H}}}
+\def\etI{{\etens{I}}}
+\def\etJ{{\etens{J}}}
+\def\etK{{\etens{K}}}
+\def\etL{{\etens{L}}}
+\def\etM{{\etens{M}}}
+\def\etN{{\etens{N}}}
+\def\etO{{\etens{O}}}
+\def\etP{{\etens{P}}}
+\def\etQ{{\etens{Q}}}
+\def\etR{{\etens{R}}}
+\def\etS{{\etens{S}}}
+\def\etT{{\etens{T}}}
+\def\etU{{\etens{U}}}
+\def\etV{{\etens{V}}}
+\def\etW{{\etens{W}}}
+\def\etX{{\etens{X}}}
+\def\etY{{\etens{Y}}}
+\def\etZ{{\etens{Z}}}
+
+\newcommand{\pdata}{p_{\rm{data}}}
+\newcommand{\ptrain}{\hat{p}_{\rm{data}}}
+\newcommand{\Ptrain}{\hat{P}_{\rm{data}}}
+\newcommand{\pmodel}{p_{\rm{model}}}
+\newcommand{\Pmodel}{P_{\rm{model}}}
+\newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}}
+\newcommand{\pencode}{p_{\rm{encoder}}}
+\newcommand{\pdecode}{p_{\rm{decoder}}}
+\newcommand{\precons}{p_{\rm{reconstruct}}}
+
+\newcommand{\laplace}{\mathrm{Laplace}}
+
+\newcommand{\E}{\mathbb{E}}
+\newcommand{\Ls}{\mathcal{L}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\emp}{\tilde{p}}
+\newcommand{\lr}{\alpha}
+\newcommand{\reg}{\lambda}
+\newcommand{\rect}{\mathrm{rectifier}}
+\newcommand{\softmax}{\mathrm{softmax}}
+\newcommand{\sigmoid}{\sigma}
+\newcommand{\softplus}{\zeta}
+\newcommand{\KL}{D_{\mathrm{KL}}}
+\newcommand{\Var}{\mathrm{Var}}
+\newcommand{\standarderror}{\mathrm{SE}}
+\newcommand{\Cov}{\mathrm{Cov}}
+\newcommand{\normlzero}{L^0}
+\newcommand{\normlone}{L^1}
+\newcommand{\normltwo}{L^2}
+\newcommand{\normlp}{L^p}
+\newcommand{\normmax}{L^\infty}
+
+\newcommand{\parents}{Pa}
+
+\DeclareMathOperator*{\argmax}{arg\,max}
+\DeclareMathOperator*{\argmin}{arg\,min}
+
+\DeclareMathOperator{\sign}{sign}
+\DeclareMathOperator{\Tr}{Tr}
+\let\ab\allowbreak
+
+
+\usepackage{hyperref}
+\usepackage{url}
+
+\usepackage{amssymb}
+\usepackage{bold-extra}
+\renewcommand{\UrlFont}{\ttfamily\small}
+\usepackage{graphicx}
+\usepackage{multirow}
+\usepackage{booktabs}
+\usepackage{enumitem}
+\usepackage{subcaption}
+\usepackage{xspace}
+\newcommand{\LN}{\linebreak\noindent}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage{listings}
+\usepackage{xcolor}
+\usepackage{tcolorbox}
+\usepackage{adjustbox}
+\usepackage[inkscapelatex=false]{svg}
+
+\definecolor{step1color}{RGB}{220, 237, 255}
+\definecolor{step2color}{RGB}{255, 237, 220}
+\definecolor{step3color}{RGB}{230, 255, 220}
+\definecolor{step4color}{RGB}{255, 220, 235}
+\definecolor{answercolor}{RGB}{240, 240, 240}
+
+\tcbuselibrary{listings,skins}
+
+\newcommand{\method}{\textsc{HiPRAG}\xspace}
+
+\newcommand{\mz}[1]{\textcolor{red}{[Mian: #1]}}
+\newcommand{\zhiyu}[1]{\textcolor{blue}{[zhiyu: #1]}}
+\newcommand{\kaiyu}[1]{\textcolor{orange}{[Kaiyu: #1]}}
+
+
+\newcommand{\fix}{\marginpar{FIX}}
+\newcommand{\new}{\marginpar{NEW}}
+
+\iclrfinalcopy
+\begin{document}
+
+
+\begin{abstract}
+Agentic Retrieval-Augmented Generation (RAG) is a powerful technique for incorporating external information that Large Language Models (LLMs) lack, enabling better problem solving and question answering. However, suboptimal search behaviors exist widely, such as over-search (retrieving information already known) and under-search (failing to search when necessary), which leads to unnecessary overhead and unreliable outputs. Current training methods, which typically rely on outcome-based rewards in a Reinforcement Learning (RL) framework, lack the fine-grained control needed to address these inefficiencies. To overcome this, we introduce \textbf{Hi}erarchical \textbf{P}rocess Rewards for Efficient agentic \textbf{RAG} (HiPRAG), a novel training methodology that incorporates a fine-grained, knowledge-grounded process reward into the RL training. Our approach evaluates the necessity of each search decision on-the-fly by decomposing the agent's reasoning trajectory into discrete, parsable steps. We then apply a hierarchical reward function that provides an additional bonus based on the proportion of optimal search and non-search steps, on top of commonly used outcome and format rewards. Experiments on the Qwen2.5 and Llama-3.2 models across seven diverse QA benchmarks show that our method achieves average accuracies of 65.4\% (3B) and 67.2\% (7B), outperforming strong agentic RAG baselines. This is accomplished while dramatically improving search efficiency, reducing the over-search rate from over 27\% in baselines from previous work to just 2.3\% and concurrently lowering the under-search rate. These results demonstrate the efficacy of optimizing the reasoning process itself, not just the final outcome. Further experiments and analysis demonstrate that HiPRAG shows good generalizability across a wide range of RL algorithms, model families, sizes, and types. This work demonstrates the importance and potential of fine-grained control through RL, for improving the efficiency and optimality of reasoning for search agents. \footnote{We have released our code and model at \url{https://github.com/qualidea1217/HiPRAG}.}
+\end{abstract}
+
+\section{Introduction}
+\label{sec:introduction}
+Large Language Models (LLMs) augmented with retrieval have rapidly evolved into agentic RAG systems that can autonomously issue search queries, incorporate external knowledge, and perform multi-step reasoning .
+In particular, recent frameworks integrate reinforcement learning (RL) to empower LLMs with the ability to decide when and what to retrieve during step-by-step reasoning .
+However, along with this potential comes a critical drawback: today’s agentic RAG agents often exhibit two suboptimal search behaviors:
+over-search, where the agent issues unnecessary or redundant retrievals , and under-search, where it fails to retrieve external knowledge when it is actually needed, which undermine their accuracy and efficiency . These observations highlight that simply pairing LLMs with a search tool is not enough; the manner in which the agent uses the search tool must be optimized.
+
+Recent research has turned to RL signals to tune the search behavior of agentic RAG system or search agents. One type of work proposed length or retrieval times-based penalties
+to encourage shorter reasoning trajectory . Such heuristics can reduce redundant steps but risk oversimplifying the problem: the model may learn to avoid searches altogether even when searches are necessary , therefore exacerbating under-search. Other researchers have incorporated model confidence and knowledge awareness into the reward.
+These advances demonstrate the promise of process-level reward shaping in RAG. Yet, important limitations remain: confidence thresholds and knowledge classifiers are imperfect proxies that can misjudge when to search, and learned process reward models may introduce bias or only weakly align with true step quality. Crucially, none of these methods gives the agent explicit, step-specific feedback on each retrieval decision: whether a particular search superfluous or a missing search should have been taken is not enforced in a fine-grained way.
+
+In this work, we introduce HiPRAG, a Hierarchical Process reward framework for agentic RAG, to address the above challenges. Instead of evaluating only by the final outcome or coarse proxies, HiPRAG explicitly parses the agent’s reasoning trajectory into structured steps and constructs reward at multiple levels to optimize both correctness and efficiency. First, the agent is guided to produce a well-structured reasoning trajectory that is parsable by the rule-based method, with a correct final answer. On top of that, we design a process reward function that provides bonus reward that increases linearly as the ratio of optimal steps (not over-search or under-search) of the trajectory increases, accompanied by a set of fast and robust methods
+for detecting over-search and under-search for each step in the reasoning trajectory on-the-fly during training, achieved by directly prompting an external LLM for verification. These step-level bonus rewards are gated by the format and final answer's correctness to ensure that the agent is not over-punished for taking suboptimal steps if a correct format or answer is presented, which harms the reasoning ability. By hierarchically constructing the reward for format and outcome correctness as well as process quality, HiPRAG provides more fine-grained and accurate training signal than prior methods while avoiding the drawbacks of them.
+
+
+ We conduct experiments on seven question-answering benchmarks covering knowledge-intensive single and multi-hop queries. HiPRAG delivers significant gains in both accuracy and retrieval efficiency across diverse evaluations. Empirically, HiPRAG achieves average accuracies of 65.4\%
+ (3B) and 67.2\% (7B), computed with Cover Exact Match, significantly outperforming strong agentic RAG baselines. More importantly, it achieves unprecedented gains in efficiency, reducing the over-search rate from over 27\% in baselines from previous work to just 2.3\%, while concurrently lowering the under-search rate to as low as 29.0\%. Our method shows good generalizability across different model families (Qwen2.5 and Llama-3.2), RL algorithms (PPO and GRPO), model sizes (3B and 7B), and model types (base and instruct). Our major contributions are as follows:
+ \begin{itemize}
+ \item We propose HiPRAG, a novel Reinforcement Learning training methodology that uses a hierarchical, knowledge-aware process reward to provide fine-grained supervision on the search behavior of agentic RAG systems.
+ \item We introduce an efficient and direct method for detecting over-search and under-search behaviors on-the-fly during training, accompanied with a set of output format parsable by rule-based methods, enabling the effective application of our process-based reward.
+ \item We empirically demonstrate that our approach enhances both the accuracy and efficiency of various LLMs and RL algorithms, across multiple question-answering benchmarks, showing its strong generalizability.
+ \end{itemize}
+
+
+\section{HiPRAG}
+\label{sec:hiprag}
+Our approach, which we term HiPRAG, introduces a fine-grained process-based reward mechanism into the reinforcement learning loop for training agentic RAG systems.
+This is achieved through three key aspects:
+(1) A redesigned, explicitly structured output format that enables rule-based parsing of reasoning steps described in Section \ref{ssec:decomposing_reasoning_trajectory_into_parsable_steps}; (2) An efficient method for detecting over-search and under-search behaviors described in Section \ref{ssec:on_the_fly_detection_of_sub_optimal_searches}; and (3) A hierarchical reward function that dynamically prioritizes correctness and search efficiency described in Section \ref{ssec:hierarchical_process_reward_calculation}. An overview of the HiPRAG workflow can be found in Figure \ref{fig:hiprag}.
+
+\subsection{Decomposing Reasoning Trajectory into Parsable Steps}
+\label{ssec:decomposing_reasoning_trajectory_into_parsable_steps}
+A primary obstacle to implementing process rewards in agentic RAG is the difficulty of parsing an agent's reasoning trajectory, which includes one or more reasoning steps. For each step, the agentic RAG system resolves one sub-query by either using search tools or using its own parametric knowledge. Existing frameworks like Search-R1 often generate reasoning within a series of \texttt{<think>} XML blocks, interleaved with other blocks about search queries and retrieved information. This format, though maintaining the fluency of reasoning, makes it hard to isolate and evaluate individual steps of reasoning for the following two reasons: (1) \textbf{Ambiguous Step Boundaries}: A single \texttt{<think>} block does not map to a discrete reasoning step. It often mixes the conclusion from a previous action with the reasoning and planning for the current action, making it difficult to programmatically isolate a self-contained step. (2) \textbf{Implicit Internal Reasoning}: Non-search steps, where the agent relies on its parametric knowledge, are not explicitly tagged. They are embedded as prose within the \texttt{<think>} block, making it challenging to differentiate them from the analytical text that precedes a search query without extra natural language understanding. Therefore, this format makes it infeasible to isolate and evaluate individual steps of reasoning during RL training, as it would require slow and expensive calls to a powerful LLM for post-hoc interpretation, which significantly slows down the RL training process and introduces a high error rate.
+
+To overcome this, we enforce a structured, machine-parsable output format during RL training. We modify the agent's prompt and rollout logic to generate its entire reasoning trajectory within a single \texttt{<think>} block, which in turn contains a sequence of discrete \texttt{<step>} blocks. Each step can either be a search step or a non-search step, distinguished by the presence of a \texttt{<search>} block containing search queries and \texttt{<context>} block containing retrieved information. Formally, a complete reasoning trajectory $T$ for a given question is a sequence of $n$ steps with a final answer $a$, $T=\{s_1, s_2, ..., s_n, a\}$. Each step $s_i$, for $i \in [1, n]$ can either be a search step, which is a tuple $s^R_i=(r_i, q_i, c_i, o_i)$ if the model chooses to search, or be a non-search step, which is a tuple $s^{NR}_i=(r_i, o_i)$, where $r_i$ is the model's reasoning block containing the planning and analysis within this step, $q_i$ is the search query, $c_i$ is the retrieved context, $o_i$ is the conclusion or summary of the knowledge gained in the current step. An example of a pipeline that does the inference for this format is shown in Algorithm \ref{alg:inference_with_parsable_steps}. An example comparing format before and after for the same question with the equivalent reasoning trajectory is included in Figure \ref{fig:trajectory-comparison}.
+
+We ensure adherence to this schema through two approaches in parallel. First, the agent's system prompt is updated with explicit instructions and few-shot examples demonstrating the correct usage of all the XML tags. Figure \ref{fig:prompt_parsable_output_format} shows the prompt with parsable output format. Second, as detailed in Section \ref{ssec:hierarchical_process_reward_calculation}, our RL framework applies a positive reward for correct outputs, thus incentivizing the model to consistently produce parsable trajectories.
+
+\subsection{On-the-Fly Detection of suboptimal Searches}
+\label{ssec:on_the_fly_detection_of_sub_optimal_searches}
+With trajectories segmented into discrete steps, we can implement efficient checks for over-search and under-search during the RL training phase.
+
+\paragraph{Over-search Detection.} Previous methods for detecting over-search involved complex re-generation pipelines, where the search context was removed and a fixed instruction was appended to prompt the model to rely on its internal knowledge . This approach is brittle, as the appended instruction can conflict with the agent's original reasoning flow and produce unnatural, low-quality outputs. It is also computationally expensive to re-generate if the search appears at the end of a long reasoning trajectory. We propose a more direct and robust method. For each search step $s^R_i=(r_i, q_i, c_i, o_i)$, we take its search query $q_i$ and directly prompt the policy model with it as a standalone question. We then obtain a re-generated answer, $o'_i$. An external LLM judge is used to assess the semantic equivalence of the original step's conclusion $o_i$ and the re-generated answer $o'_i$. The prompt for external LLM judge is shown in Figure \ref{fig:prompt-oversearch}. If they are equivalent, the search was redundant, and the step is flagged as an over-search. This method is not only faster but also provides a more reliable signal by isolating the core knowledge required by the query.
+
+\paragraph{Under-search Detection.} For each non-search step $s^{NR}_i=(r_i, o_i)$, we verify the factual and logical accuracy of its reasoning $r_i$ and conclusion $o_i$ by prompting an external verifier model to assess the correctness of $r_i$ and $o_i$. The prompt for external verifier model is shown in Figure \ref{fig:prompt-undersearch}. If the content is found to be incorrect, the step is flagged as an under-search, as the agent failed to utilize the search tool to retrieve necessary information, leading to a hallucination or factual error. Some under-search cases may appear as suboptimal or incomplete but locally correct intermediate steps. We intentionally avoid penalizing these cases because step completeness often depends on the agent's global multi-step plan and is subjective to determine at the step level without expensive counterfactual supervision. Penalizing correct-but-incomplete steps tends to push agents toward over-search by discouraging reliance on parametric knowledge.
+
+In actual implementation, both of the detection methods can work concurrently to improve the detection speed. For conducting over-search detection over a batch of data during RL rollout phase, the re-generation step can be executed separately through batch generation before using the external LLM judge to further improve the training speed.
+
+
+\subsection{Hierarchical Process Reward Calculation}
+\label{ssec:hierarchical_process_reward_calculation}
+A naive length or confidence-based reward function that penalizes search can over-suppress the agent's retrieval capabilities, leading to poor performance on knowledge-intensive tasks. Our goal is to incentivize optimal search behavior to improve performance and efficiency, while maintaining the basic ability of reasoning with a search tool. In order to achieve this, the rewards need to be dynamically focused on incentivizing format and final answer correctness at the early stage of the RL training, while shifting its focus towards reasoning efficiency and optimality after the basic search ability has been established, by providing a higher reward to be differentiated from the original outcome and format reward. To this end, we design a hierarchical reward function that prioritizes correctness and format adherence before rewarding process optimality, while shift its focus towards process optimality after the reasoning ability has established, on top of the outcome + format reward version of Search-R1 reward .
+
+\paragraph{Hierarchical process reward.}
+Let $A(T)\in\{0,1\}$ indicate the final answer $a$ of the trajectory $T$'s correctness (here we use Cover Exact Match as introduced in Section \ref{ssec:datasets_and_metrics}), and $F(T)\in\{0,1\}$ indicate that the trajectory follows the required format (an example of the implementation of $F(T)$ can be found in Algorithm \ref{alg:format_checker} and \ref{alg:validate_step}). Let $N(T)$ be the number of steps in the trajectory $T$, with the number of optimal (neither over-search nor under-search) steps $N_{\text{corr}}(T)$ be
+\[
+N_{\text{corr}}(T)=\bigl|\{\,s^R\in(T): \neg\textsf{Over}(s^R)\,\}\bigr|\! + \bigl|\{\,s^{NR}\in(T): \neg\textsf{Under}(s^{NR})\,\}\bigr|\!
+\]
+where $\textsf{Over}(\cdot)$ and $\textsf{Under}(\cdot)$ are the detectors from Section \ref{ssec:on_the_fly_detection_of_sub_optimal_searches}. With a format weight $\lambda_f\!\in[0,1]$ and a process bonus coefficient $\lambda_p\!\ge0$, we define a single merged reward:
+\begin{equation}
+\label{eq:hier-proc-reward}
+R(T)
+\;=\;
+A(T)\bigl(1-\lambda_f\bigr)
+\;+\;
+\lambda_f\,F(T)
+\;+\;
+\lambda_p\,A(T)F(T)\,
+\frac{N_{\text{corr}}(T)}{N(T)}.
+\end{equation}
+
+This expression is algebraically equivalent to the standard outcome + format reward used in prior work
+when $\lambda_p{=}0$, and it adds a gated process bonus only when both the answer and the format are
+correct. In particular, the reward becomes
+\(
+R(T)=1+\lambda_p\,\frac{N_{\text{corr}}(T)}{N(T)}
+\)
+whenever $A(T){=}F(T){=}1$. A collection of all the symbols used can be found in Table \ref{tab:symbols}.
+
+This hierarchical structure ensures that the agent is first incentivized to produce well-formed reasoning trajectory with correct answers. Only once it achieves this primary goal does it receive an additional reward bonus for the efficiency and validity of its reasoning path, which avoids the pitfalls of over-suppression while directly encouraging the model to develop a more nuanced understanding of its own knowledge boundaries.
+
+\section{Experiment Setup}
+\label{sec:experiment_setup}
+This section details the experimental framework used to evaluate HiPRAG. We outline the datasets, evaluation metrics, models, and training procedures to ensure reproducibility and provide a clear context for our results.
+
+\subsection{Datasets \& Metric}
+\label{ssec:datasets_and_metrics}
+Our experimental data is composed of a wide coverage of both single and multi-hop Question Answering (QA) samples, modeled after the one used in Search-R1 to ensure a fair and direct comparison with prior work. The training set is a combination of the official training sets from NQ and HotpotQA . This creates a diverse corpus for teaching the agent both single-fact retrieval and multi-hop reasoning, which is crucial for learning efficient reasoning. To assess both in-domain and out-of-domain generalization, we evaluate our models on a comprehensive test set composed from the development or test set of seven QA datasets: NQ, PopQA , TriviaQA , 2WikiMultiHopQA , Bamboogle , HotpotQA, and MuSiQue .
+
+The primary metric for our evaluation is Cover Exact Match (CEM) . This metric determines correctness by checking if the ground-truth answer string is present in the model's generated answer. We choose CEM over a strict Exact Match because modern LLMs are optimized for generating longer, explanatory responses. Imposing a strict match would penalize valid answers embedded in more verbose text and might not accurately reflect the model's capabilities. We also assess the model's efficiency by measuring the Over-search Rate (OSR) and Under-search Rate (USR), which are defined as the ratio of over-search and under-search steps among all identifiable search steps and non-search steps, within a set of test samples. Given a set of samples $\mathcal{D}_{\text{test}}$ with their reasoning trajectory $T$, the OSR and USR can be calculated according to Equation \ref{eq:osr_usr}.
+\begin{equation}
+\label{eq:osr_usr}
+\text{OSR} = \frac{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^R \in T : \textsf{Over}(s^R) \}|}{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^R \in T \}|},
+\quad
+\text{USR} = \frac{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^{NR} \in T : \textsf{Under}(s^{NR}) \}|}{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^{NR} \in T \}|}
+\end{equation}
+
+\subsection{Baselines}
+\label{ssec:baselines}
+We compare our method against a comprehensive set of baselines that represent different paradigms in retrieval-augmented generation: (1) \textbf{Direct Inference}: Direct generation without any retrieval mechanism. (2) \textbf{Standard RAG}: A conventional RAG setup where retrieval is performed once based on the initial query . (3) \textbf{Prompt-Based Agentic RAG}: Methods that rely on sophisticated prompting to achieve multi-step reasoning and search, including IRCoT and Search-o1 . (4) \textbf{RL-Based Agentic RAG}: State-of-the-art methods that use reinforcement learning to train search agents, including Search-R1 , R1-Searcher , R1-Searcher++ , and $\beta$-GRPO . Among these, R1-Searcher++ and $\beta$-GRPO are explicitly designed to improve search efficiency, making them strong baselines focused on efficiency.
+
+\subsection{Training Details}
+\label{ssec:training_details}
+All RL-based models were trained with four NVIDIA A100 80GB GPUs. The training process was conducted for a total of 400 steps and saved the checkpoint every 50 steps. For evaluation, we adopted the following checkpointing strategy: if the training process completed without instability, the final saved checkpoint is used for testing. However, if the training reward collapsed, we use the last stable checkpoint saved before the collapse to ensure a fair evaluation of the model's best-learned state.
+
+Our experiments leverage several models for different roles within the framework. The main experiments are conducted using the Qwen2.5-(3B/7B)-Instruct models . To analyze performance across different model families and types, we also conduct experiments with Llama-3.2-3B-Instruct and Qwen2.5-3B. For the detection of suboptimal searches during training and evaluation, we utilize small-sized proprietary models that provide fast inference speed while maintaining sufficient performance. Over-search detection is performed by GPT-4.1 mini , while under-search detection relies on GPT-5 mini .
+
+For our main experiments, we use Proximal Policy Optimization (PPO) as the core RL algorithm. PPO is selected for its demonstrated training stability in complex LLM fine-tuning scenarios, especially on the previous works on search agent development using RL. To assess the impact of the RL algorithm choice, we also perform experiments using Group Relative Policy Optimization (GRPO) . For GRPO we keep the same training parameters as the PPO training with a group size of 5.
+
+For our retrieval environment of all experiments, we follow the Search-R1 setup and use the 2018 Wikipedia dump as the knowledge source, with E5-base serving as the retriever. In each search step, the top-3 relevant passages are returned.
+
+In terms of the inference parameters, we set the temperature and top p to 1 during the rollout stage of RL training to make sure a high possibility of generating desired reasoning trajectory. In testing, we set the temperature and top p to the models' default value. For hyperparameters in the reward function, we set $\lambda_f$=0.2 and $\lambda_p$=0.4 for the main experiments. We also explore the results under different $\lambda_p$ and $\lambda_f$ in Section \ref{ssec:ablation_studies} and Section \ref{ssec:analysis_on_individual_parameters}.
+
+\section{Results \& Analysis}
+This section presents a comprehensive analysis of HiPRAG. We evaluate its performance against state-of-the-art baselines and conduct detailed studies on the influence of model size, model family, and reinforcement learning algorithms. We also include ablation studies to validate our design choices and conclude with a qualitative case study.
+
+\subsection{Main Results}
+
+
+We compare HiPRAG against a suite of strong baselines on seven question-answering benchmarks. As shown in Table \ref{tab:main_cem}, our approach outperforms all baseline methods across both 3B and 7B model sizes. The HiPRAG-7B model achieves an Avg. CEM score of 67.2\%, a notable improvement over the next-best baseline, R1-Searcher++ (62.1\%). This demonstrates that our fine-grained, process-based reward mechanism effectively guides the agent to develop more robust and accurate reasoning trajectories. We also present a qualitative case study comparing the reasoning trajectory from baseline and HiPRAG-trained model in Appendix \ref{sec:case_study}, as well as a brief analysis of efficacy of our methods in Appendix \ref{sec:additional_analysis_on_efficacy}. We also report the raw average number of retrieval calls per question (Avg.~\#Searches). Under a controlled Qwen2.5-3B-Instruct + PPO setup, HiPRAG reduces Avg.~\#Searches from 2.45 (Search-R1) and 2.15 ($\beta$-GRPO) down to 1.75 on average across seven benchmarks, corresponding to a 29\% and 19\% reduction respectively (Table~\ref{tab:avg_num_searches}).
+
+\subsection{Analysis on Individual Parameters}
+\label{ssec:analysis_on_individual_parameters}
+
+
+\paragraph{Influence of Model Size}
+Larger models generally exhibit stronger reasoning capabilities with better accuracy. Our experiments confirm this trend, according to Table \ref{tab:avg_cem_osr_usr_hiprag}, as HiPRAG-trained 7B models consistently outperform their 3B counterparts. However, our process-based reward approach allows smaller models to achieve remarkable performance, closing the gap on larger models. For instance, our HiPRAG model trained based on Qwen2.5-3B-Instruct + GRPO (64.4\% Avg. CEM) not only surpasses strong external 7B baselines like R1-Searcher++ (62.1\% Avg. CEM), but it also outperforms the 7B counterpart trained with our baseline reward (61.2\% Avg. CEM). This indicates that our training methodology is a more effective path to performance gains than simply scaling the model size with conventional rewards. Furthermore, a larger model size tends to provide more efficient search decisions. This is evident with GRPO, where the 7B model, on top of its higher accuracy, exhibits better efficiency (2.3\% Avg. OSR, 32.6\% Avg. USR) than the 3B model (4.1\% Avg. OSR, 33.2\% Avg. USR).
+
+\paragraph{Influence of Model Family}
+To assess the generalizability of HiPRAG, we trained both the Qwen2.5-3B-Instruct and Llama-3.2-3B-Instruct models with HiPRAG for comparison. Although both models achieve comparable peak accuracy after training with HiPRAG, their underlying behavior and efficiency differ. As shown in Figure \ref{fig:model_family_search_ratio}, the Llama-3B model shows a higher tendency to rely on its parametric knowledge with more non-search steps initially, resulting in a higher under-search rate. After training, the Qwen-3B model achieves its high Avg. CEM of 64.1\% with lower suboptimal search rates (4.9\% Avg. OSR, 38.1\% Avg. USR) compared to the Llama-3B model's 6.0\% Avg. OSR and 49.7\% Avg. USR, based on Table \ref{tab:avg_cem_osr_usr_hiprag}. This suggests that while HiPRAG is effective across different model families, the base model's inherent tendencies can influence final search efficiency.
+
+\paragraph{Influence of RL Algorithm}
+To explore the impact of different RL algorithms on HiPRAG method, we experimented with both PPO and GRPO on Qwen2.5-3B/7B-Instruct models. PPO offers better training stability, often completing the full training run without reward collapse, whereas GRPO consistently has the potential to achieve higher final performance and converges faster. A comparison of reward curve for Qwen-3B models can be found in Figure \ref{fig:rl_algo_reward}. As seen in Table \ref{tab:avg_cem_osr_usr_hiprag}, GRPO yields a higher Avg. CEM for both 3B (64.4\% vs. 64.1\%) and 7B (67.2\% vs. 64.5\%) models and results in more efficient search behavior (e.g., 2.3\% OSR for 7B-GRPO vs. 6.2\% for 7B-PPO). This aligns with findings in related literature, where GRPO's critic-free approach often proves to be more sample-efficient for LLM training with the trade-off of less training stability.
+
+\paragraph{Influence of Format Reward Weight}
+We experimented with different format reward weights $\lambda_f\in\{0.2,0.4,0.6\}$ while keeping $\lambda_p{=}0.4$ fixed (Qwen2.5-3B-Instruct + PPO). $\lambda_f{=}0.2$, used in our main experiments, provides the best trade-off: it achieves the highest Avg. CEM (64.1\%) and the best Avg. OSR (4.9\%), while larger values over-emphasize the instrumental goal of format correctness and degrade performance (Table~\ref{tab:lambda_f_ablation_summary}).
+
+\paragraph{Influence of Instruction Tuning on Base Model}
+To understand the impact of instruction-tuning on the base model before applying HiPRAG for RL, we compared the performance of HiPRAG on a base model (Qwen2.5-3B) and its instruction-tuned counterpart (Qwen2.5-3B-Instruct). Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, the instruct-tuned model exhibited a higher initial reward, as its pre-training makes it more adept at following the structured output format required by our framework. Our hierarchical reward, which gates the process bonus until both the answer and format are correct, favors models that quickly learn this structure. However, the base model eventually caught up, converging to a similar reward level. Interestingly, the base model, once fully trained, may achieve higher Avg. CEM score (65.4\% vs. 64.1\%) and lower Avg. OSR (3.2\% vs. 4.9\%). This could be because it learns the reasoning and search behaviors from the RL objective more purely, without the potential biases introduced during the instruction-tuning phase.
+
+\subsection{Ablation Studies}
+\label{ssec:ablation_studies}
+To validate the key components of the HiPRAG methodology and systematically isolate the sources of its performance gains, we conducted a series of ablation studies. These experiments are designed to deconstruct our approach by: (1) evaluating the impact of the new parsable output format independent of the process reward, (2) determining the optimal weighting of the process bonus coefficient, $\lambda_p$, which governs the reward hierarchy, and (3) demonstrating the necessity of addressing both over-search and under-search behaviors concurrently, rather than in isolation.
+
+\paragraph{Influence on Output Format}
+To isolate the effect of the format and reward change, we trained a model variant called Search-R1-step$^*$. This model uses the same outcome + format reward as the original Search-R1 v0.3 model but is enforced to use our new parsable output format. Besides, we also adapt the format change to $\beta$-GRPO and trained $\beta$-GRPO-step$^*$. The results from both variants in Table \ref{tab:main_cem} show that our structured format maintains the performance, with slight increase in some of the datasets. This confirms that the new parsable output format is a robust foundation and that the significant performance gains of our full method are attributable to the process-based reward mechanism it enables, not merely an artifact of the format change.
+
+\paragraph{Influence of Process Bonus Coefficient}
+We tested our hierarchical reward with different values for the process bonus coefficient
+$\lambda_p$, which determines the weight of the step-correctness ratio. Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, a coefficient of 0.4 provided the optimal balance, yielding the highest performance (64.1\% Avg. CEM). A lower value of 0.2 behaved similarly to an outcome-only reward, failing to sufficiently incentivize efficiency (59.6\% Avg. CEM). This is reflected in its higher Avg. OSR of 5.5\% and Avg. USR of 44.5\%. A higher value of 0.6 over-prioritized step purity at the expense of final answer correctness, leading to a slight performance degradation (62.5\% Avg. CEM). The optimal $\lambda_p$ of 0.4 achieved the best trade-off, with a low 4.9\% Avg. OSR and 38.1\% Avg. USR. Importantly, $\lambda_p$ controls the relative reward spread among already-correct trajectories: when $\lambda_p$ is too large, the gradient becomes dominated by differences in step ratios among correct outputs, encouraging short, conservative plans and reducing the model's willingness to add corrective steps that could fix borderline errors.
+
+\paragraph{Training with Over-search or Under-search Only}
+We isolated the components of our process reward by training models with penalties for only over-search or only under-search. In these ablations, the ignored step type is \emph{excluded} from the computation of process bonus ratio. If a trajectory contains zero steps of the evaluated type, we set the process bonus to the average bonus within the current training batch for stability. Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, training to reduce only over-search proved insufficient, yielding a low Avg. CEM of 58.8\%. While this approach successfully reduced the Avg. OSR to 4.9\%, it caused the model to become too hesitant to search, resulting in a very high Avg. USR of 52.7\%. Targeting only under-search was more effective (63.3\% Avg. CEM), underscoring that preventing hallucination is more critical than improving efficiency. This method dramatically lowered the Avg. USR to just 16.9\% but made the agent overly reliant on its search tool, slightly increasing the Avg. OSR to 6.6\%. However, the best performance was achieved only when penalizing both suboptimal behaviors simultaneously (64.1\% Avg. CEM), confirming that a holistic approach to search optimization is necessary.
+
+\section{Conclusion}
+\label{sec:conclusion}
+This work tackles the pervasive inefficiencies in agentic RAG systems, which are often trained with coarse, outcome-based rewards that fail to correct suboptimal search behaviors. We introduced HiPRAG, a novel training methodology that incorporates a hierarchical, knowledge-aware process reward to instill more efficient reasoning. By decomposing agent trajectories into parsable steps and evaluating the necessity of each search action on-the-fly, HiPRAG provides the fine-grained supervision necessary to curb both over-searching and under-searching. Our experiments show that this approach not only achieves state-of-the-art performance on 3B and 7B models but also dramatically improves efficiency, reducing the over-search rate and under-search rate. This research validates that the path to creating powerful and efficient LLM search agents lies in optimizing the reasoning process itself, not just the final outcome.
+
+\section*{Ethics Statement}
+The authors of this paper have read and adhered to the ICLR Code of Ethics. This work, focuses on improving the efficiency and accuracy of AI agents, and we have considered the ethical implications of our methodology. While any capable AI system presents potential for misuse, our method aims to foster more reliable and grounded AI by explicitly penalizing factual errors (under-searching) and reducing computational waste (over-searching). We acknowledge that the system may inherit biases from its underlying data (Wikipedia) and foundation models. By improving agent efficiency, our work also contributes to more sustainable AI by reducing the energy consumption of deployed models.
+
+\section*{Reproducibility statement}
+We are committed to ensuring the reproducibility of our work. Section \ref{sec:experiment_setup} provides a comprehensive overview of our experimental framework, including the specific training and evaluation datasets, evaluation metrics (Cover Exact Match, Over-search Rate, and Under-search Rate), and baselines used for comparison. Section \ref{ssec:training_details} details our training procedure, specifying the models (Qwen2.5, Llama-3.2), RL algorithms (PPO, GRPO), hardware, retrieval environment, and key hyperparameters. The core components of our HiPRAG methodology-the structured output format, the on-the-fly detection mechanism, and the hierarchical reward function-are thoroughly described in Section \ref{sec:hiprag}. To further facilitate replication, the Appendix contains the pseudocode for our inference process (Algorithm \ref{alg:inference_with_parsable_steps}) , along with the exact prompts for enforcing the parsable output format (Figure \ref{fig:prompt_parsable_output_format}) and for detecting suboptimal searches (Figures \ref{fig:prompt-oversearch} and \ref{fig:prompt-undersearch}).
+
+
+\appendix
+\clearpage
+\section*{Appendix}
+\section{Example of Search-R1 Format vs. HiPRAG Format}
+\label{sec:example_of_search_r1_format_vs_hiprag_format}
+
+
+In this section we present an example of transforming from the original Search-R1 output format to our HiPRAG output format shown in Figure \ref{fig:trajectory-comparison}. Original format interleaves multiple \texttt{<think>} blocks with search operations, making step boundaries ambiguous. Our format uses explicit \texttt{<step>} tags within a single \texttt{<think>} block. Each colored region represents a logical reasoning step. Our format clearly delineates these with \texttt{<step>} tags, enabling deterministic parsing. Step 2 (orange) demonstrates internal reasoning without search. The original format embeds this implicitly in prose; our format explicitly marks it as a step with only \texttt{<reasoning>} and \texttt{<conclusion>} tags.
+
+\clearpage
+\section{Symbols}
+
+
+\section{Algorithms}
+
+
+\clearpage
+\section{Prompts}
+\definecolor{promptcolor3}{RGB}{180, 120, 50}
+
+
+\definecolor{promptcolor1}{RGB}{20, 150, 130}
+\definecolor{promptcolor2}{RGB}{120, 80, 170}
+
+
+\clearpage
+\section{Detailed Report for CEM, OSR, and USR}
+\label{sec:detailed_report_cem_osr_usr}
+
+
+\section{Additional Analysis on Efficacy}
+\label{sec:additional_analysis_on_efficacy}
+\subsection{Format Correctness Percentage Analysis}
+To verify the effectiveness of our prompting and reward strategy for enforcing a machine-parsable output, we analyzed the format correctness across all test samples generated by our final HiPRAG-trained models. Our analysis shows that 96.3\% of all generated trajectories successfully adhered to the required format. This high percentage confirms that the models effectively learned to produce the structured output, which is a critical prerequisite for the successful application of our on-the-fly process reward mechanism.
+
+\subsection{Efficacy of Over-search \& Under-search Detection}
+The reliability of our process-based reward hinges on the accuracy of the over-search and under-search detection methods. To validate these, we manually inspected the detection results for 200 randomly selected reasoning trajectories from our test set evaluations. The manual audit revealed a 98.3\% accuracy rate for over-search detection and a 95.6\% accuracy rate for under-search detection. These high accuracy figures confirm that our on-the-fly LLM-based judges provide a reliable and effective signal for identifying suboptimal search behaviors during RL training.
+
+\subsection{Efficacy of CEM Metric}
+To ensure our primary evaluation metric, Cover Exact Match (CEM), accurately reflects model performance, we manually inspected its judgments on 100 randomly sampled question-answer pairs from our test results. Our review found that the CEM metric’s assessment of correctness aligned with human judgment in 98\% of cases. This confirms that CEM is a robust metric for this task, appropriately handling valid answers embedded within the longer, more explanatory responses typical of modern LLMs, thus avoiding unfairly penalizing models for verbosity.
+
+\section{Additional Study on Robustness to LLM Judge Choice}
+To study sensitivity to external LLM judges used for on-the-fly detection, we conducted an experiment replacing our standard proprietary LLMs (GPT-4.1 mini and GPT-5 mini ) with open-source models of varying capabilities, specifically the Qwen3-30B-A3B-Instruct/Thinking-2507 and Qwen3-4B-Instruct/Thinking-2507 (Instruct for over-search, Thinking for under-search) . We use greedy decoding with fixed random seed for all 4 judges to ensure stability and reproducibility. For other parameters, we maintain the exact experimental setup as our main Qwen2.5-3B-Instruct + PPO experiment.
+
+
+\subsection{Analysis}
+\textbf{1. Sensitivity of Over-Search Detection (OSR):} The OSR remained nearly constant across all judge configurations. This suggests that the task of detecting semantic equivalence is robust and can be handled effectively even by smaller, non-reasoning "Instruct" models. The definition of redundancy does not require complex reasoning chains, making it less sensitive to model size.
+
+\textbf{2. Sensitivity of Under-Search Detection (USR):} The USR showed higher sensitivity. The weaker Qwen3-4B judges resulted in a USR increase from 38.1\% to 42.4\%. We hypothesize that weaker judges are less rigorous in factual/logical verification, occasionally failing to flag "hallucinated" reasoning or premature conclusions. This allows the agent to terminate the search process earlier than optimal, leading to the slight degradation in the final accuracy (CEM).
+
+\textbf{3. Performance Degradation:} Despite the increase in USR with weaker judges, the overall degradation is not catastrophic. This confirms that the hierarchical process reward framework itself provides a stable training signal even with sub-optimal judges.
+
+\subsection{Detailed Results by Dataset}
+Below we provide the detailed breakdown of performance across all seven QA benchmarks used in the paper.
+
+
+\subsection{Analysis of Judgment Errors and Robustness to Judge Selection}
+To address the reviewer's concern about the judgment errors, we performed a manual evaluation of judgment accuracy and analyzed the sensitivity of our method to these errors.
+
+\paragraph{Judge Accuracy:} Following the protocol in Appendix \ref{sec:additional_analysis_on_efficacy}, we sampled 200 trajectories from the test set and established human-labeled ground truth for step-level Over-Search and Under-Search decisions, for all the steps in those trajectories.
+
+
+As shown in Table \ref{tab:judge_accuracy}, all models maintain high agreement with human judgment.
+
+\paragraph{Impact of Judgment Errors:} We analyzed the correlation between judge accuracy and downstream agent performance to quantify the impact of mislabeling:
+\begin{itemize}
+ \item \textbf{Under-search:} The Under-search judge is the primary driver of performance variance. The main risk is a False Negative (failing to flag an under-search). This effectively disrupts the reasoning trajectory, causing the agent to stop searching prematurely, or directly leads to incorrect final results.
+ \item \textbf{Over-search:} Over-search mislabels typically result in a step being flagged as redundant (or not) without altering the information available to the agent. Consequently, these errors rarely change the final answer path, resulting in minimal impact on overall accuracy.
+\end{itemize}
+
+\section{Additional Study on Average Number of Searches}
+In addition to OSR and USR, we report the average number of search steps per question (Avg.~\#Searches) as a raw efficiency metric:
+\begin{equation}
+\label{eq:avg_searches}
+\text{Avg.~\#Searches} = \frac{\sum_{T \in \mathcal{D}_{\text{test}}} \left|\{ s^R \in T \}\right|}{|\mathcal{D}_{\text{test}}|}.
+\end{equation}
+
+For a fair comparison, this table uses the same Qwen2.5-3B-Instruct + PPO for all methods.
+
+
+HiPRAG's step-wise process reward achieves good efficiency by evaluating the necessity of each step on-the-fly, consistently using the fewest searches while maintaining higher accuracy. We also emphasize that the Over-search Rate (OSR) and Under-search Rate (USR) are critical efficiency metrics. Naive penalties on trajectory length or search frequency often cause models to avoid searching even when necessary (increasing under-search), which leads to performance degradation.
+
+\section{Computational Time Analysis During RL Training}
+We profile the RL training pipeline to quantify the overhead introduced by HiPRAG's on-the-fly reward assignment. The profiling is conducted on Qwen2.5-3B-Instruct + PPO using 8 NVIDIA A100 80GB GPUs (veRL with vLLM inference and FSDP training).
+
+
+The specific overhead introduced by HiPRAG (the batched re-generation and external API calls) accounts for only 12.95\% of the total training time. This is a small increase, especially when weighed against the significant gains in sample efficiency and final model performance.
+
+To effectively reduce overhead in the extra process of reward computation, we utilize the following methods during training.
+\begin{itemize}
+ \item \textbf{Batched Generation:} The "re-generation" check for over-search is performed via batch generation. We collect the queries from the rollout, aggregate them into several batches, and process the queries in each batch in parallel.
+ \item \textbf{Targeted Scope:} Re-generation is only triggered for search steps, not every step in the trajectory.
+ \item \textbf{Generation Length:} The re-generation prompts the model for a direct answer or relevant information to the search query, which is significantly shorter than the full reasoning chain generated during rollout even without actively limiting the generation length.
+ \item \textbf{Asynchronous API Calls:} As noted in Section \ref{ssec:on_the_fly_detection_of_sub_optimal_searches}, the external detection is executed separately. The batch processing of API calls to the external verifier occurs in parallel with the local model's batched re-generation, therefore effectively reducing the latency. Specifically, for over-search detection, the verification calls to external LLM judges start once the first batch has finished and continue concurrently in the later batches (for example, for re-generation batch $t$, execute batch $t - 1$ verifier API calls); for under-search detection, these verification calls to external LLM judges can be executed concurrently with the re-generation of over-search detection as they are independent processes.
+ \item \textbf{Cost Reduction for LLM judges:} We utilize cost-effective models for verification. On top of that, we use a non-reasoning model for over-search detection for further cost saving, because the nature of over-search detection is checking the equivalence of the conclusion of the search step and the re-generation result, which does not require complex reasoning abilities. For under-search detection, due to the need of detecting logical error in the non-search step, a reasoning model is required.
+\end{itemize}
+
+\section{Additional Study for Format Reward Weight \texorpdfstring{$\lambda_f$}{lambda f}}
+
+To address the impact of the format reward, we conducted a study varying $\lambda_f \in \{0.2, 0.4, 0.6\}$ using the Qwen2.5-3B-Instruct + PPO setup, keeping the process bonus fixed at $\lambda_p = 0.4$.
+
+The results clearly demonstrate that our chosen value of $\lambda_f = 0.2$ provides the optimal trade-off between answer accuracy (Avg. CEM) and search efficiency (Avg. OSR/USR). As shown in Table~\ref{tab:lambda_f_ablation_summary}, the $\lambda_f = 0.2$ setting achieves the highest accuracy and the best efficiency scores, while larger values over-emphasize the instrumental goal of format correctness and degrade performance.
+
+
+\subsection{Sensitivity Analysis and Discussion}
+This trend is expected, as it aligns with our core intuition that answer correctness is significantly more important than format correctness. We justify this principle as follows:
+
+\begin{itemize}
+ \item \textbf{Terminal Goal vs. Instrumental Goal:} Format correctness ($F(T)$) is an instrumental goal. Its primary purpose is to make the agent's reasoning trajectory parsable, which in turn enables our hierarchical process reward to be calculated. In contrast, answer correctness ($A(T)$) is the terminal goal of the entire agentic RAG task. The user's objective is to get the right answer; a well-formatted but incorrect trajectory is ultimately a failure. To prioritize answer correctness, the format weight $\lambda_f$ must be small.
+ \item \textbf{Preventing "Reward Hacking":} If $\lambda_f$ were set too high, the agent could "hack" the reward function by learning to produce perfectly formatted, minimal-step trajectories (e.g., a single non-search step) that are factually incorrect. This would maximize the $F(T)$ component of the reward while ignoring $A(T)$ and the process bonus. A low $\lambda_f$ (like $0.2$) ensures the reward landscape is always dominated by the incentive to get the answer right. This principle is directly reflected in our hierarchical reward function.
+\end{itemize}
+\section{Case Study}
+\label{sec:case_study}
+
+
+To illustrate the practical benefits of our HiPRAG framework, we examine a specific case where the baseline model fails due to inefficient reasoning, while our trained agent succeeds. The models here are trained based on Qwen2.5-3B-Instruct. The question posed is: "What is the place of birth of the performer of song Slow Down (Lacy J. Dalton Song)?". The baseline model overlooks the crucial parenthetical information, "(Lacy J. Dalton Song)," and initiates a broad search for the song "Slow Down." This leads to an unnecessary five-step process where it identifies three different artists who have a song by that title and then searches for the birthplace of each one individually. Furthermore, through over-search detection, the answer of the final search step's query about the birthplace of Selena Gomez is answered correctly and equivalent to the original answer "Grand Prairie, Texas" in reasoning trajectory. The final answer of the baseline is incorrect due to the interruption of unnecessary searches. This is a classic example of over-searching, where the agent performs redundant and irrelevant lookups, ultimately failing to provide a single, correct answer. In contrast, the HiPRAG-trained agent correctly parses the entire question in its first, non-search step, identifying Lacy J. Dalton as the specified performer. It then executes a single, targeted search for her place of birth. This two-step, optimal reasoning path-one internal reasoning step followed by one necessary search-avoids the inefficiencies of the baseline, leading directly to the correct answer. This case clearly demonstrates how HiPRAG's process-oriented rewards cultivate a more nuanced and efficient reasoning strategy, improving both accuracy and search economy.
+
+\clearpage
+\section{Use of Large Language Models}
+We acknowledge the use of the GPT-5 language model provided by OpenAI in the final stages of manuscript preparation. This tool was employed exclusively for identifying and correcting typographical and grammatical errors, ensuring clarity and precision in the written presentation. Its use was strictly limited to linguistic refinement and did not impact the study’s conceptual framework, research methodology, data analysis, or conclusions. All intellectual contributions and substantive content remain those of the authors. The usage of all other LLMs (GPT-4.1 mini, GPT-5 mini, Qwen2.5, and Llama-3.2) mentioned in this work is part of the experiments themselves.
+
+\end{document}

benchmark_dataset/papers/ICLR2026_0005_2510.07794/source_extracted.tex

@@ -0,0 +1,167 @@
+\begin{abstract}
+Agentic Retrieval-Augmented Generation (RAG) is a powerful technique for incorporating external information that Large Language Models (LLMs) lack, enabling better problem solving and question answering. However, suboptimal search behaviors exist widely, such as over-search (retrieving information already known) and under-search (failing to search when necessary), which leads to unnecessary overhead and unreliable outputs. Current training methods, which typically rely on outcome-based rewards in a Reinforcement Learning (RL) framework, lack the fine-grained control needed to address these inefficiencies. To overcome this, we introduce \textbf{Hi}erarchical \textbf{P}rocess Rewards for Efficient agentic \textbf{RAG} (HiPRAG), a novel training methodology that incorporates a fine-grained, knowledge-grounded process reward into the RL training. Our approach evaluates the necessity of each search decision on-the-fly by decomposing the agent's reasoning trajectory into discrete, parsable steps. We then apply a hierarchical reward function that provides an additional bonus based on the proportion of optimal search and non-search steps, on top of commonly used outcome and format rewards. Experiments on the Qwen2.5 and Llama-3.2 models across seven diverse QA benchmarks show that our method achieves average accuracies of 65.4\% (3B) and 67.2\% (7B), outperforming strong agentic RAG baselines. This is accomplished while dramatically improving search efficiency, reducing the over-search rate from over 27\% in baselines from previous work to just 2.3\% and concurrently lowering the under-search rate. These results demonstrate the efficacy of optimizing the reasoning process itself, not just the final outcome. Further experiments and analysis demonstrate that HiPRAG shows good generalizability across a wide range of RL algorithms, model families, sizes, and types. This work demonstrates the importance and potential of fine-grained control through RL, for improving the efficiency and optimality of reasoning for search agents. \footnote{We have released our code and model at \url{https://github.com/qualidea1217/HiPRAG}.}
+\end{abstract}
+
+\section{Introduction}
+\label{sec:introduction}
+Large Language Models (LLMs) augmented with retrieval have rapidly evolved into agentic RAG systems that can autonomously issue search queries, incorporate external knowledge, and perform multi-step reasoning .
+In particular, recent frameworks integrate reinforcement learning (RL) to empower LLMs with the ability to decide when and what to retrieve during step-by-step reasoning .
+However, along with this potential comes a critical drawback: today’s agentic RAG agents often exhibit two suboptimal search behaviors:
+over-search, where the agent issues unnecessary or redundant retrievals , and under-search, where it fails to retrieve external knowledge when it is actually needed, which undermine their accuracy and efficiency . These observations highlight that simply pairing LLMs with a search tool is not enough; the manner in which the agent uses the search tool must be optimized.
+
+Recent research has turned to RL signals to tune the search behavior of agentic RAG system or search agents. One type of work proposed length or retrieval times-based penalties
+to encourage shorter reasoning trajectory . Such heuristics can reduce redundant steps but risk oversimplifying the problem: the model may learn to avoid searches altogether even when searches are necessary , therefore exacerbating under-search. Other researchers have incorporated model confidence and knowledge awareness into the reward.
+These advances demonstrate the promise of process-level reward shaping in RAG. Yet, important limitations remain: confidence thresholds and knowledge classifiers are imperfect proxies that can misjudge when to search, and learned process reward models may introduce bias or only weakly align with true step quality. Crucially, none of these methods gives the agent explicit, step-specific feedback on each retrieval decision: whether a particular search superfluous or a missing search should have been taken is not enforced in a fine-grained way.
+
+In this work, we introduce HiPRAG, a Hierarchical Process reward framework for agentic RAG, to address the above challenges. Instead of evaluating only by the final outcome or coarse proxies, HiPRAG explicitly parses the agent’s reasoning trajectory into structured steps and constructs reward at multiple levels to optimize both correctness and efficiency. First, the agent is guided to produce a well-structured reasoning trajectory that is parsable by the rule-based method, with a correct final answer. On top of that, we design a process reward function that provides bonus reward that increases linearly as the ratio of optimal steps (not over-search or under-search) of the trajectory increases, accompanied by a set of fast and robust methods
+for detecting over-search and under-search for each step in the reasoning trajectory on-the-fly during training, achieved by directly prompting an external LLM for verification. These step-level bonus rewards are gated by the format and final answer's correctness to ensure that the agent is not over-punished for taking suboptimal steps if a correct format or answer is presented, which harms the reasoning ability. By hierarchically constructing the reward for format and outcome correctness as well as process quality, HiPRAG provides more fine-grained and accurate training signal than prior methods while avoiding the drawbacks of them.
+
+
+ We conduct experiments on seven question-answering benchmarks covering knowledge-intensive single and multi-hop queries. HiPRAG delivers significant gains in both accuracy and retrieval efficiency across diverse evaluations. Empirically, HiPRAG achieves average accuracies of 65.4\%
+ (3B) and 67.2\% (7B), computed with Cover Exact Match, significantly outperforming strong agentic RAG baselines. More importantly, it achieves unprecedented gains in efficiency, reducing the over-search rate from over 27\% in baselines from previous work to just 2.3\%, while concurrently lowering the under-search rate to as low as 29.0\%. Our method shows good generalizability across different model families (Qwen2.5 and Llama-3.2), RL algorithms (PPO and GRPO), model sizes (3B and 7B), and model types (base and instruct). Our major contributions are as follows:
+ \begin{itemize}
+ \item We propose HiPRAG, a novel Reinforcement Learning training methodology that uses a hierarchical, knowledge-aware process reward to provide fine-grained supervision on the search behavior of agentic RAG systems.
+ \item We introduce an efficient and direct method for detecting over-search and under-search behaviors on-the-fly during training, accompanied with a set of output format parsable by rule-based methods, enabling the effective application of our process-based reward.
+ \item We empirically demonstrate that our approach enhances both the accuracy and efficiency of various LLMs and RL algorithms, across multiple question-answering benchmarks, showing its strong generalizability.
+ \end{itemize}
+
+
+\section{HiPRAG}
+\label{sec:hiprag}
+Our approach, which we term HiPRAG, introduces a fine-grained process-based reward mechanism into the reinforcement learning loop for training agentic RAG systems.
+This is achieved through three key aspects:
+(1) A redesigned, explicitly structured output format that enables rule-based parsing of reasoning steps described in Section \ref{ssec:decomposing_reasoning_trajectory_into_parsable_steps}; (2) An efficient method for detecting over-search and under-search behaviors described in Section \ref{ssec:on_the_fly_detection_of_sub_optimal_searches}; and (3) A hierarchical reward function that dynamically prioritizes correctness and search efficiency described in Section \ref{ssec:hierarchical_process_reward_calculation}. An overview of the HiPRAG workflow can be found in Figure \ref{fig:hiprag}.
+
+\subsection{Decomposing Reasoning Trajectory into Parsable Steps}
+\label{ssec:decomposing_reasoning_trajectory_into_parsable_steps}
+A primary obstacle to implementing process rewards in agentic RAG is the difficulty of parsing an agent's reasoning trajectory, which includes one or more reasoning steps. For each step, the agentic RAG system resolves one sub-query by either using search tools or using its own parametric knowledge. Existing frameworks like Search-R1 often generate reasoning within a series of \texttt{<think>} XML blocks, interleaved with other blocks about search queries and retrieved information. This format, though maintaining the fluency of reasoning, makes it hard to isolate and evaluate individual steps of reasoning for the following two reasons: (1) \textbf{Ambiguous Step Boundaries}: A single \texttt{<think>} block does not map to a discrete reasoning step. It often mixes the conclusion from a previous action with the reasoning and planning for the current action, making it difficult to programmatically isolate a self-contained step. (2) \textbf{Implicit Internal Reasoning}: Non-search steps, where the agent relies on its parametric knowledge, are not explicitly tagged. They are embedded as prose within the \texttt{<think>} block, making it challenging to differentiate them from the analytical text that precedes a search query without extra natural language understanding. Therefore, this format makes it infeasible to isolate and evaluate individual steps of reasoning during RL training, as it would require slow and expensive calls to a powerful LLM for post-hoc interpretation, which significantly slows down the RL training process and introduces a high error rate.
+
+To overcome this, we enforce a structured, machine-parsable output format during RL training. We modify the agent's prompt and rollout logic to generate its entire reasoning trajectory within a single \texttt{<think>} block, which in turn contains a sequence of discrete \texttt{<step>} blocks. Each step can either be a search step or a non-search step, distinguished by the presence of a \texttt{<search>} block containing search queries and \texttt{<context>} block containing retrieved information. Formally, a complete reasoning trajectory $T$ for a given question is a sequence of $n$ steps with a final answer $a$, $T=\{s_1, s_2, ..., s_n, a\}$. Each step $s_i$, for $i \in [1, n]$ can either be a search step, which is a tuple $s^R_i=(r_i, q_i, c_i, o_i)$ if the model chooses to search, or be a non-search step, which is a tuple $s^{NR}_i=(r_i, o_i)$, where $r_i$ is the model's reasoning block containing the planning and analysis within this step, $q_i$ is the search query, $c_i$ is the retrieved context, $o_i$ is the conclusion or summary of the knowledge gained in the current step. An example of a pipeline that does the inference for this format is shown in Algorithm \ref{alg:inference_with_parsable_steps}. An example comparing format before and after for the same question with the equivalent reasoning trajectory is included in Figure \ref{fig:trajectory-comparison}.
+
+We ensure adherence to this schema through two approaches in parallel. First, the agent's system prompt is updated with explicit instructions and few-shot examples demonstrating the correct usage of all the XML tags. Figure \ref{fig:prompt_parsable_output_format} shows the prompt with parsable output format. Second, as detailed in Section \ref{ssec:hierarchical_process_reward_calculation}, our RL framework applies a positive reward for correct outputs, thus incentivizing the model to consistently produce parsable trajectories.
+
+\subsection{On-the-Fly Detection of suboptimal Searches}
+\label{ssec:on_the_fly_detection_of_sub_optimal_searches}
+With trajectories segmented into discrete steps, we can implement efficient checks for over-search and under-search during the RL training phase.
+
+\paragraph{Over-search Detection.} Previous methods for detecting over-search involved complex re-generation pipelines, where the search context was removed and a fixed instruction was appended to prompt the model to rely on its internal knowledge . This approach is brittle, as the appended instruction can conflict with the agent's original reasoning flow and produce unnatural, low-quality outputs. It is also computationally expensive to re-generate if the search appears at the end of a long reasoning trajectory. We propose a more direct and robust method. For each search step $s^R_i=(r_i, q_i, c_i, o_i)$, we take its search query $q_i$ and directly prompt the policy model with it as a standalone question. We then obtain a re-generated answer, $o'_i$. An external LLM judge is used to assess the semantic equivalence of the original step's conclusion $o_i$ and the re-generated answer $o'_i$. The prompt for external LLM judge is shown in Figure \ref{fig:prompt-oversearch}. If they are equivalent, the search was redundant, and the step is flagged as an over-search. This method is not only faster but also provides a more reliable signal by isolating the core knowledge required by the query.
+
+\paragraph{Under-search Detection.} For each non-search step $s^{NR}_i=(r_i, o_i)$, we verify the factual and logical accuracy of its reasoning $r_i$ and conclusion $o_i$ by prompting an external verifier model to assess the correctness of $r_i$ and $o_i$. The prompt for external verifier model is shown in Figure \ref{fig:prompt-undersearch}. If the content is found to be incorrect, the step is flagged as an under-search, as the agent failed to utilize the search tool to retrieve necessary information, leading to a hallucination or factual error. Some under-search cases may appear as suboptimal or incomplete but locally correct intermediate steps. We intentionally avoid penalizing these cases because step completeness often depends on the agent's global multi-step plan and is subjective to determine at the step level without expensive counterfactual supervision. Penalizing correct-but-incomplete steps tends to push agents toward over-search by discouraging reliance on parametric knowledge.
+
+In actual implementation, both of the detection methods can work concurrently to improve the detection speed. For conducting over-search detection over a batch of data during RL rollout phase, the re-generation step can be executed separately through batch generation before using the external LLM judge to further improve the training speed.
+
+
+\subsection{Hierarchical Process Reward Calculation}
+\label{ssec:hierarchical_process_reward_calculation}
+A naive length or confidence-based reward function that penalizes search can over-suppress the agent's retrieval capabilities, leading to poor performance on knowledge-intensive tasks. Our goal is to incentivize optimal search behavior to improve performance and efficiency, while maintaining the basic ability of reasoning with a search tool. In order to achieve this, the rewards need to be dynamically focused on incentivizing format and final answer correctness at the early stage of the RL training, while shifting its focus towards reasoning efficiency and optimality after the basic search ability has been established, by providing a higher reward to be differentiated from the original outcome and format reward. To this end, we design a hierarchical reward function that prioritizes correctness and format adherence before rewarding process optimality, while shift its focus towards process optimality after the reasoning ability has established, on top of the outcome + format reward version of Search-R1 reward .
+
+\paragraph{Hierarchical process reward.}
+Let $A(T)\in\{0,1\}$ indicate the final answer $a$ of the trajectory $T$'s correctness (here we use Cover Exact Match as introduced in Section \ref{ssec:datasets_and_metrics}), and $F(T)\in\{0,1\}$ indicate that the trajectory follows the required format (an example of the implementation of $F(T)$ can be found in Algorithm \ref{alg:format_checker} and \ref{alg:validate_step}). Let $N(T)$ be the number of steps in the trajectory $T$, with the number of optimal (neither over-search nor under-search) steps $N_{\text{corr}}(T)$ be
+\[
+N_{\text{corr}}(T)=\bigl|\{\,s^R\in(T): \neg\textsf{Over}(s^R)\,\}\bigr|\! + \bigl|\{\,s^{NR}\in(T): \neg\textsf{Under}(s^{NR})\,\}\bigr|\!
+\]
+where $\textsf{Over}(\cdot)$ and $\textsf{Under}(\cdot)$ are the detectors from Section \ref{ssec:on_the_fly_detection_of_sub_optimal_searches}. With a format weight $\lambda_f\!\in[0,1]$ and a process bonus coefficient $\lambda_p\!\ge0$, we define a single merged reward:
+\begin{equation}
+\label{eq:hier-proc-reward}
+R(T)
+\;=\;
+A(T)\bigl(1-\lambda_f\bigr)
+\;+\;
+\lambda_f\,F(T)
+\;+\;
+\lambda_p\,A(T)F(T)\,
+\frac{N_{\text{corr}}(T)}{N(T)}.
+\end{equation}
+
+This expression is algebraically equivalent to the standard outcome + format reward used in prior work
+when $\lambda_p{=}0$, and it adds a gated process bonus only when both the answer and the format are
+correct. In particular, the reward becomes
+\(
+R(T)=1+\lambda_p\,\frac{N_{\text{corr}}(T)}{N(T)}
+\)
+whenever $A(T){=}F(T){=}1$. A collection of all the symbols used can be found in Table \ref{tab:symbols}.
+
+This hierarchical structure ensures that the agent is first incentivized to produce well-formed reasoning trajectory with correct answers. Only once it achieves this primary goal does it receive an additional reward bonus for the efficiency and validity of its reasoning path, which avoids the pitfalls of over-suppression while directly encouraging the model to develop a more nuanced understanding of its own knowledge boundaries.
+
+\section{Experiment Setup}
+\label{sec:experiment_setup}
+This section details the experimental framework used to evaluate HiPRAG. We outline the datasets, evaluation metrics, models, and training procedures to ensure reproducibility and provide a clear context for our results.
+
+\subsection{Datasets \& Metric}
+\label{ssec:datasets_and_metrics}
+Our experimental data is composed of a wide coverage of both single and multi-hop Question Answering (QA) samples, modeled after the one used in Search-R1 to ensure a fair and direct comparison with prior work. The training set is a combination of the official training sets from NQ and HotpotQA . This creates a diverse corpus for teaching the agent both single-fact retrieval and multi-hop reasoning, which is crucial for learning efficient reasoning. To assess both in-domain and out-of-domain generalization, we evaluate our models on a comprehensive test set composed from the development or test set of seven QA datasets: NQ, PopQA , TriviaQA , 2WikiMultiHopQA , Bamboogle , HotpotQA, and MuSiQue .
+
+The primary metric for our evaluation is Cover Exact Match (CEM) . This metric determines correctness by checking if the ground-truth answer string is present in the model's generated answer. We choose CEM over a strict Exact Match because modern LLMs are optimized for generating longer, explanatory responses. Imposing a strict match would penalize valid answers embedded in more verbose text and might not accurately reflect the model's capabilities. We also assess the model's efficiency by measuring the Over-search Rate (OSR) and Under-search Rate (USR), which are defined as the ratio of over-search and under-search steps among all identifiable search steps and non-search steps, within a set of test samples. Given a set of samples $\mathcal{D}_{\text{test}}$ with their reasoning trajectory $T$, the OSR and USR can be calculated according to Equation \ref{eq:osr_usr}.
+\begin{equation}
+\label{eq:osr_usr}
+\text{OSR} = \frac{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^R \in T : \textsf{Over}(s^R) \}|}{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^R \in T \}|},
+\quad
+\text{USR} = \frac{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^{NR} \in T : \textsf{Under}(s^{NR}) \}|}{\sum_{T \in \mathcal{D}_{\text{test}}} |\{ s^{NR} \in T \}|}
+\end{equation}
+
+\subsection{Baselines}
+\label{ssec:baselines}
+We compare our method against a comprehensive set of baselines that represent different paradigms in retrieval-augmented generation: (1) \textbf{Direct Inference}: Direct generation without any retrieval mechanism. (2) \textbf{Standard RAG}: A conventional RAG setup where retrieval is performed once based on the initial query . (3) \textbf{Prompt-Based Agentic RAG}: Methods that rely on sophisticated prompting to achieve multi-step reasoning and search, including IRCoT and Search-o1 . (4) \textbf{RL-Based Agentic RAG}: State-of-the-art methods that use reinforcement learning to train search agents, including Search-R1 , R1-Searcher , R1-Searcher++ , and $\beta$-GRPO . Among these, R1-Searcher++ and $\beta$-GRPO are explicitly designed to improve search efficiency, making them strong baselines focused on efficiency.
+
+\subsection{Training Details}
+\label{ssec:training_details}
+All RL-based models were trained with four NVIDIA A100 80GB GPUs. The training process was conducted for a total of 400 steps and saved the checkpoint every 50 steps. For evaluation, we adopted the following checkpointing strategy: if the training process completed without instability, the final saved checkpoint is used for testing. However, if the training reward collapsed, we use the last stable checkpoint saved before the collapse to ensure a fair evaluation of the model's best-learned state.
+
+Our experiments leverage several models for different roles within the framework. The main experiments are conducted using the Qwen2.5-(3B/7B)-Instruct models . To analyze performance across different model families and types, we also conduct experiments with Llama-3.2-3B-Instruct and Qwen2.5-3B. For the detection of suboptimal searches during training and evaluation, we utilize small-sized proprietary models that provide fast inference speed while maintaining sufficient performance. Over-search detection is performed by GPT-4.1 mini , while under-search detection relies on GPT-5 mini .
+
+For our main experiments, we use Proximal Policy Optimization (PPO) as the core RL algorithm. PPO is selected for its demonstrated training stability in complex LLM fine-tuning scenarios, especially on the previous works on search agent development using RL. To assess the impact of the RL algorithm choice, we also perform experiments using Group Relative Policy Optimization (GRPO) . For GRPO we keep the same training parameters as the PPO training with a group size of 5.
+
+For our retrieval environment of all experiments, we follow the Search-R1 setup and use the 2018 Wikipedia dump as the knowledge source, with E5-base serving as the retriever. In each search step, the top-3 relevant passages are returned.
+
+In terms of the inference parameters, we set the temperature and top p to 1 during the rollout stage of RL training to make sure a high possibility of generating desired reasoning trajectory. In testing, we set the temperature and top p to the models' default value. For hyperparameters in the reward function, we set $\lambda_f$=0.2 and $\lambda_p$=0.4 for the main experiments. We also explore the results under different $\lambda_p$ and $\lambda_f$ in Section \ref{ssec:ablation_studies} and Section \ref{ssec:analysis_on_individual_parameters}.
+
+\section{Results \& Analysis}
+This section presents a comprehensive analysis of HiPRAG. We evaluate its performance against state-of-the-art baselines and conduct detailed studies on the influence of model size, model family, and reinforcement learning algorithms. We also include ablation studies to validate our design choices and conclude with a qualitative case study.
+
+\subsection{Main Results}
+
+
+We compare HiPRAG against a suite of strong baselines on seven question-answering benchmarks. As shown in Table \ref{tab:main_cem}, our approach outperforms all baseline methods across both 3B and 7B model sizes. The HiPRAG-7B model achieves an Avg. CEM score of 67.2\%, a notable improvement over the next-best baseline, R1-Searcher++ (62.1\%). This demonstrates that our fine-grained, process-based reward mechanism effectively guides the agent to develop more robust and accurate reasoning trajectories. We also present a qualitative case study comparing the reasoning trajectory from baseline and HiPRAG-trained model in Appendix \ref{sec:case_study}, as well as a brief analysis of efficacy of our methods in Appendix \ref{sec:additional_analysis_on_efficacy}. We also report the raw average number of retrieval calls per question (Avg.~\#Searches). Under a controlled Qwen2.5-3B-Instruct + PPO setup, HiPRAG reduces Avg.~\#Searches from 2.45 (Search-R1) and 2.15 ($\beta$-GRPO) down to 1.75 on average across seven benchmarks, corresponding to a 29\% and 19\% reduction respectively (Table~\ref{tab:avg_num_searches}).
+
+\subsection{Analysis on Individual Parameters}
+\label{ssec:analysis_on_individual_parameters}
+
+
+\paragraph{Influence of Model Size}
+Larger models generally exhibit stronger reasoning capabilities with better accuracy. Our experiments confirm this trend, according to Table \ref{tab:avg_cem_osr_usr_hiprag}, as HiPRAG-trained 7B models consistently outperform their 3B counterparts. However, our process-based reward approach allows smaller models to achieve remarkable performance, closing the gap on larger models. For instance, our HiPRAG model trained based on Qwen2.5-3B-Instruct + GRPO (64.4\% Avg. CEM) not only surpasses strong external 7B baselines like R1-Searcher++ (62.1\% Avg. CEM), but it also outperforms the 7B counterpart trained with our baseline reward (61.2\% Avg. CEM). This indicates that our training methodology is a more effective path to performance gains than simply scaling the model size with conventional rewards. Furthermore, a larger model size tends to provide more efficient search decisions. This is evident with GRPO, where the 7B model, on top of its higher accuracy, exhibits better efficiency (2.3\% Avg. OSR, 32.6\% Avg. USR) than the 3B model (4.1\% Avg. OSR, 33.2\% Avg. USR).
+
+\paragraph{Influence of Model Family}
+To assess the generalizability of HiPRAG, we trained both the Qwen2.5-3B-Instruct and Llama-3.2-3B-Instruct models with HiPRAG for comparison. Although both models achieve comparable peak accuracy after training with HiPRAG, their underlying behavior and efficiency differ. As shown in Figure \ref{fig:model_family_search_ratio}, the Llama-3B model shows a higher tendency to rely on its parametric knowledge with more non-search steps initially, resulting in a higher under-search rate. After training, the Qwen-3B model achieves its high Avg. CEM of 64.1\% with lower suboptimal search rates (4.9\% Avg. OSR, 38.1\% Avg. USR) compared to the Llama-3B model's 6.0\% Avg. OSR and 49.7\% Avg. USR, based on Table \ref{tab:avg_cem_osr_usr_hiprag}. This suggests that while HiPRAG is effective across different model families, the base model's inherent tendencies can influence final search efficiency.
+
+\paragraph{Influence of RL Algorithm}
+To explore the impact of different RL algorithms on HiPRAG method, we experimented with both PPO and GRPO on Qwen2.5-3B/7B-Instruct models. PPO offers better training stability, often completing the full training run without reward collapse, whereas GRPO consistently has the potential to achieve higher final performance and converges faster. A comparison of reward curve for Qwen-3B models can be found in Figure \ref{fig:rl_algo_reward}. As seen in Table \ref{tab:avg_cem_osr_usr_hiprag}, GRPO yields a higher Avg. CEM for both 3B (64.4\% vs. 64.1\%) and 7B (67.2\% vs. 64.5\%) models and results in more efficient search behavior (e.g., 2.3\% OSR for 7B-GRPO vs. 6.2\% for 7B-PPO). This aligns with findings in related literature, where GRPO's critic-free approach often proves to be more sample-efficient for LLM training with the trade-off of less training stability.
+
+\paragraph{Influence of Format Reward Weight}
+We experimented with different format reward weights $\lambda_f\in\{0.2,0.4,0.6\}$ while keeping $\lambda_p{=}0.4$ fixed (Qwen2.5-3B-Instruct + PPO). $\lambda_f{=}0.2$, used in our main experiments, provides the best trade-off: it achieves the highest Avg. CEM (64.1\%) and the best Avg. OSR (4.9\%), while larger values over-emphasize the instrumental goal of format correctness and degrade performance (Table~\ref{tab:lambda_f_ablation_summary}).
+
+\paragraph{Influence of Instruction Tuning on Base Model}
+To understand the impact of instruction-tuning on the base model before applying HiPRAG for RL, we compared the performance of HiPRAG on a base model (Qwen2.5-3B) and its instruction-tuned counterpart (Qwen2.5-3B-Instruct). Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, the instruct-tuned model exhibited a higher initial reward, as its pre-training makes it more adept at following the structured output format required by our framework. Our hierarchical reward, which gates the process bonus until both the answer and format are correct, favors models that quickly learn this structure. However, the base model eventually caught up, converging to a similar reward level. Interestingly, the base model, once fully trained, may achieve higher Avg. CEM score (65.4\% vs. 64.1\%) and lower Avg. OSR (3.2\% vs. 4.9\%). This could be because it learns the reasoning and search behaviors from the RL objective more purely, without the potential biases introduced during the instruction-tuning phase.
+
+\subsection{Ablation Studies}
+\label{ssec:ablation_studies}
+To validate the key components of the HiPRAG methodology and systematically isolate the sources of its performance gains, we conducted a series of ablation studies. These experiments are designed to deconstruct our approach by: (1) evaluating the impact of the new parsable output format independent of the process reward, (2) determining the optimal weighting of the process bonus coefficient, $\lambda_p$, which governs the reward hierarchy, and (3) demonstrating the necessity of addressing both over-search and under-search behaviors concurrently, rather than in isolation.
+
+\paragraph{Influence on Output Format}
+To isolate the effect of the format and reward change, we trained a model variant called Search-R1-step$^*$. This model uses the same outcome + format reward as the original Search-R1 v0.3 model but is enforced to use our new parsable output format. Besides, we also adapt the format change to $\beta$-GRPO and trained $\beta$-GRPO-step$^*$. The results from both variants in Table \ref{tab:main_cem} show that our structured format maintains the performance, with slight increase in some of the datasets. This confirms that the new parsable output format is a robust foundation and that the significant performance gains of our full method are attributable to the process-based reward mechanism it enables, not merely an artifact of the format change.
+
+\paragraph{Influence of Process Bonus Coefficient}
+We tested our hierarchical reward with different values for the process bonus coefficient
+$\lambda_p$, which determines the weight of the step-correctness ratio. Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, a coefficient of 0.4 provided the optimal balance, yielding the highest performance (64.1\% Avg. CEM). A lower value of 0.2 behaved similarly to an outcome-only reward, failing to sufficiently incentivize efficiency (59.6\% Avg. CEM). This is reflected in its higher Avg. OSR of 5.5\% and Avg. USR of 44.5\%. A higher value of 0.6 over-prioritized step purity at the expense of final answer correctness, leading to a slight performance degradation (62.5\% Avg. CEM). The optimal $\lambda_p$ of 0.4 achieved the best trade-off, with a low 4.9\% Avg. OSR and 38.1\% Avg. USR. Importantly, $\lambda_p$ controls the relative reward spread among already-correct trajectories: when $\lambda_p$ is too large, the gradient becomes dominated by differences in step ratios among correct outputs, encouraging short, conservative plans and reducing the model's willingness to add corrective steps that could fix borderline errors.
+
+\paragraph{Training with Over-search or Under-search Only}
+We isolated the components of our process reward by training models with penalties for only over-search or only under-search. In these ablations, the ignored step type is \emph{excluded} from the computation of process bonus ratio. If a trajectory contains zero steps of the evaluated type, we set the process bonus to the average bonus within the current training batch for stability. Based on Table \ref{tab:avg_cem_osr_usr_hiprag}, training to reduce only over-search proved insufficient, yielding a low Avg. CEM of 58.8\%. While this approach successfully reduced the Avg. OSR to 4.9\%, it caused the model to become too hesitant to search, resulting in a very high Avg. USR of 52.7\%. Targeting only under-search was more effective (63.3\% Avg. CEM), underscoring that preventing hallucination is more critical than improving efficiency. This method dramatically lowered the Avg. USR to just 16.9\% but made the agent overly reliant on its search tool, slightly increasing the Avg. OSR to 6.6\%. However, the best performance was achieved only when penalizing both suboptimal behaviors simultaneously (64.1\% Avg. CEM), confirming that a holistic approach to search optimization is necessary.
+
+\section{Conclusion}
+\label{sec:conclusion}
+This work tackles the pervasive inefficiencies in agentic RAG systems, which are often trained with coarse, outcome-based rewards that fail to correct suboptimal search behaviors. We introduced HiPRAG, a novel training methodology that incorporates a hierarchical, knowledge-aware process reward to instill more efficient reasoning. By decomposing agent trajectories into parsable steps and evaluating the necessity of each search action on-the-fly, HiPRAG provides the fine-grained supervision necessary to curb both over-searching and under-searching. Our experiments show that this approach not only achieves state-of-the-art performance on 3B and 7B models but also dramatically improves efficiency, reducing the over-search rate and under-search rate. This research validates that the path to creating powerful and efficient LLM search agents lies in optimizing the reasoning process itself, not just the final outcome.
+
+\section*{Ethics Statement}
+The authors of this paper have read and adhered to the ICLR Code of Ethics. This work, focuses on improving the efficiency and accuracy of AI agents, and we have considered the ethical implications of our methodology. While any capable AI system presents potential for misuse, our method aims to foster more reliable and grounded AI by explicitly penalizing factual errors (under-searching) and reducing computational waste (over-searching). We acknowledge that the system may inherit biases from its underlying data (Wikipedia) and foundation models. By improving agent efficiency, our work also contributes to more sustainable AI by reducing the energy consumption of deployed models.
+
+\section*{Reproducibility statement}
+We are committed to ensuring the reproducibility of our work. Section \ref{sec:experiment_setup} provides a comprehensive overview of our experimental framework, including the specific training and evaluation datasets, evaluation metrics (Cover Exact Match, Over-search Rate, and Under-search Rate), and baselines used for comparison. Section \ref{ssec:training_details} details our training procedure, specifying the models (Qwen2.5, Llama-3.2), RL algorithms (PPO, GRPO), hardware, retrieval environment, and key hyperparameters. The core components of our HiPRAG methodology-the structured output format, the on-the-fly detection mechanism, and the hierarchical reward function-are thoroughly described in Section \ref{sec:hiprag}. To further facilitate replication, the Appendix contains the pseudocode for our inference process (Algorithm \ref{alg:inference_with_parsable_steps}) , along with the exact prompts for enforcing the parsable output format (Figure \ref{fig:prompt_parsable_output_format}) and for detecting suboptimal searches (Figures \ref{fig:prompt-oversearch} and \ref{fig:prompt-undersearch}).

benchmark_dataset/papers/ICLR2026_0005_2510.07794/source_references.tex

@@ -0,0 +1,341 @@
+@inproceedings{yao2023react,
+  title = {{ReAct}: Synergizing Reasoning and Acting in Language Models},
+  author = {Yao, Shunyu and Zhao, Jeffrey and Yu, Dian and Du, Nan and Shafran, Izhak and Narasimhan, Karthik and Cao, Yuan},
+  booktitle = {International Conference on Learning Representations (ICLR) },
+  year = {2023},
+  html = {https://arxiv.org/abs/2210.03629},
+}
+
+@inproceedings{trivedi-etal-2023-interleaving,
+    title = "Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions",
+    author = "Trivedi, Harsh  and
+      Balasubramanian, Niranjan  and
+      Khot, Tushar  and
+      Sabharwal, Ashish",
+    editor = "Rogers, Anna  and
+      Boyd-Graber, Jordan  and
+      Okazaki, Naoaki",
+    booktitle = "Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = jul,
+    year = "2023",
+    address = "Toronto, Canada",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2023.acl-long.557/",
+    doi = "10.18653/v1/2023.acl-long.557",
+    pages = "10014--10037",
+    abstract = "Prompting-based large language models (LLMs) are surprisingly powerful at generating natural language reasoning steps or Chains-of-Thoughts (CoT) for multi-step question answering (QA). They struggle, however, when the necessary knowledge is either unavailable to the LLM or not up-to-date within its parameters. While using the question to retrieve relevant text from an external knowledge source helps LLMs, we observe that this one-step retrieve-and-read approach is insufficient for multi-step QA. Here, \textit{what to retrieve} depends on \textit{what has already been derived}, which in turn may depend on \textit{what was previously retrieved}. To address this, we propose IRCoT, a new approach for multi-step QA that interleaves retrieval with steps (sentences) in a CoT, guiding the retrieval with CoT and in turn using retrieved results to improve CoT. Using IRCoT with GPT3 substantially improves retrieval (up to 21 points) as well as downstream QA (up to 15 points) on four datasets: HotpotQA, 2WikiMultihopQA, MuSiQue, and IIRC. We observe similar substantial gains in out-of-distribution (OOD) settings as well as with much smaller models such as Flan-T5-large without additional training. IRCoT reduces model hallucination, resulting in factually more accurate CoT reasoning."
+}
+
+@misc{wang2025chainofretrievalaugmentedgeneration,
+      title={Chain-of-Retrieval Augmented Generation}, 
+      author={Liang Wang and Haonan Chen and Nan Yang and Xiaolong Huang and Zhicheng Dou and Furu Wei},
+      year={2025},
+      eprint={2501.14342},
+      archivePrefix={arXiv},
+      primaryClass={cs.IR},
+      url={https://arxiv.org/abs/2501.14342}, 
+}
+
+@misc{guan2025deepragthinkingretrievalstep,
+      title={DeepRAG: Thinking to Retrieval Step by Step for Large Language Models}, 
+      author={Xinyan Guan and Jiali Zeng and Fandong Meng and Chunlei Xin and Yaojie Lu and Hongyu Lin and Xianpei Han and Le Sun and Jie Zhou},
+      year={2025},
+      eprint={2502.01142},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2502.01142}, 
+}
+
+@misc{singh2025agenticretrievalaugmentedgenerationsurvey,
+      title={Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG}, 
+      author={Aditi Singh and Abul Ehtesham and Saket Kumar and Tala Talaei Khoei},
+      year={2025},
+      eprint={2501.09136},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2501.09136}, 
+}
+
+@article{202507.2024,
+	doi = {10.20944/preprints202507.2024.v1},
+	url = {https://doi.org/10.20944/preprints202507.2024.v1},
+	year = 2025,
+	month = {July},
+	publisher = {Preprints},
+	author = {Jian Li and Xiaoxi Li and Yan Zheng and Yizhang Jin and Shuo Wang and Jiafu Wu and Yabiao Wang and Chengjie Wang and Xiaotong Yuan},
+	title = {A Survey on AI Search with Large Language Models},
+	journal = {Preprints}
+}
+
+@misc{zhang2025landscapeagenticreinforcementlearning,
+      title={The Landscape of Agentic Reinforcement Learning for LLMs: A Survey}, 
+      author={Guibin Zhang and Hejia Geng and Xiaohang Yu and Zhenfei Yin and Zaibin Zhang and Zelin Tan and Heng Zhou and Zhongzhi Li and Xiangyuan Xue and Yijiang Li and Yifan Zhou and Yang Chen and Chen Zhang and Yutao Fan and Zihu Wang and Songtao Huang and Yue Liao and Hongru Wang and Mengyue Yang and Heng Ji and Michael Littman and Jun Wang and Shuicheng Yan and Philip Torr and Lei Bai},
+      year={2025},
+      eprint={2509.02547},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2509.02547}, 
+}
+
+@misc{huang2025ragrladvancingretrievalaugmentedgeneration,
+      title={RAG-RL: Advancing Retrieval-Augmented Generation via RL and Curriculum Learning}, 
+      author={Jerry Huang and Siddarth Madala and Risham Sidhu and Cheng Niu and Hao Peng and Julia Hockenmaier and Tong Zhang},
+      year={2025},
+      eprint={2503.12759},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2503.12759}, 
+}
+
+@misc{qian2025toolrlrewardtoollearning,
+      title={ToolRL: Reward is All Tool Learning Needs}, 
+      author={Cheng Qian and Emre Can Acikgoz and Qi He and Hongru Wang and Xiusi Chen and Dilek Hakkani-Tür and Gokhan Tur and Heng Ji},
+      year={2025},
+      eprint={2504.13958},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2504.13958}, 
+}
+
+@misc{li2025torlscalingtoolintegratedrl,
+      title={ToRL: Scaling Tool-Integrated RL}, 
+      author={Xuefeng Li and Haoyang Zou and Pengfei Liu},
+      year={2025},
+      eprint={2503.23383},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2503.23383}, 
+}
+
+@inproceedings{mallen-etal-2023-trust,
+    title = "When Not to Trust Language Models: Investigating Effectiveness of Parametric and Non-Parametric Memories",
+    author = "Mallen, Alex  and
+      Asai, Akari  and
+      Zhong, Victor  and
+      Das, Rajarshi  and
+      Khashabi, Daniel  and
+      Hajishirzi, Hannaneh",
+    editor = "Rogers, Anna  and
+      Boyd-Graber, Jordan  and
+      Okazaki, Naoaki",
+    booktitle = "Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = jul,
+    year = "2023",
+    address = "Toronto, Canada",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2023.acl-long.546/",
+    doi = "10.18653/v1/2023.acl-long.546",
+    pages = "9802--9822",
+    abstract = "Despite their impressive performance on diverse tasks, large language models (LMs) still struggle with tasks requiring rich world knowledge, implying the difficulty of encoding a wealth of world knowledge in their parameters. This paper aims to understand LMs' strengths and limitations in memorizing factual knowledge, by conducting large-scale knowledge probing experiments on two open-domain entity-centric QA datasets: PopQA, our new dataset with 14k questions about long-tail entities, and EntityQuestions, a widely used open-domain QA dataset. We find that LMs struggle with less popular factual knowledge, and that retrieval augmentation helps significantly in these cases. Scaling, on the other hand, mainly improves memorization of popular knowledge, and fails to appreciably improve memorization of factual knowledge in the tail. Based on those findings, we devise a new method for retrieval-augmentation that improves performance and reduces inference costs by only retrieving non-parametric memories when necessary."
+}
+
+@misc{dhole2025retrieveretrieveuncertaintydetection,
+      title={To Retrieve or Not to Retrieve? Uncertainty Detection for Dynamic Retrieval Augmented Generation}, 
+      author={Kaustubh D. Dhole},
+      year={2025},
+      eprint={2501.09292},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2501.09292}, 
+}
+
+@inproceedings{su-etal-2024-dragin,
+    title = "{DRAGIN}: Dynamic Retrieval Augmented Generation based on the Real-time Information Needs of Large Language Models",
+    author = "Su, Weihang  and
+      Tang, Yichen  and
+      Ai, Qingyao  and
+      Wu, Zhijing  and
+      Liu, Yiqun",
+    editor = "Ku, Lun-Wei  and
+      Martins, Andre  and
+      Srikumar, Vivek",
+    booktitle = "Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = aug,
+    year = "2024",
+    address = "Bangkok, Thailand",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.acl-long.702/",
+    doi = "10.18653/v1/2024.acl-long.702",
+    pages = "12991--13013",
+    abstract = "Dynamic retrieval augmented generation (RAG) paradigm actively decides when and what to retrieve during the text generation process of Large Language Models (LLMs).There are two key elements of this paradigm: identifying the optimal moment to activate the retrieval module (deciding when to retrieve) and crafting the appropriate query once retrieval is triggered (determining what to retrieve).However, current dynamic RAG methods fall short in both aspects. Firstly, the strategies for deciding when to retrieve often rely on static rules. Moreover, the strategies for deciding what to retrieve typically limit themselves to the LLM{'}s most recent sentence or the last few tokens, while the LLM{'}s information needs may span across the entire context.To overcome these limitations, we introduce a new framework, DRAGIN, i.e., Dynamic Retrieval Augmented Generation based on the Information Needs of LLMs. Our framework is specifically designed to make decisions on when and what to retrieve based on the LLM{'}s information needs during the text generation process.We evaluate DRAGIN along with existing methods comprehensively over 4 knowledge-intensive generation datasets. Experimental results show that DRAGIN achieves superior performance on all tasks, demonstrating the effectiveness of our method."
+}
+
+@misc{zubkova2025sugarleveragingcontextualconfidence,
+      title={SUGAR: Leveraging Contextual Confidence for Smarter Retrieval}, 
+      author={Hanna Zubkova and Ji-Hoon Park and Seong-Whan Lee},
+      year={2025},
+      eprint={2501.04899},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2501.04899}, 
+}
+
+@inproceedings{yao-etal-2025-seakr,
+    title = "{S}ea{KR}: Self-aware Knowledge Retrieval for Adaptive Retrieval Augmented Generation",
+    author = "Yao, Zijun  and
+      Qi, Weijian  and
+      Pan, Liangming  and
+      Cao, Shulin  and
+      Hu, Linmei  and
+      Weichuan, Liu  and
+      Hou, Lei  and
+      Li, Juanzi",
+    editor = "Che, Wanxiang  and
+      Nabende, Joyce  and
+      Shutova, Ekaterina  and
+      Pilehvar, Mohammad Taher",
+    booktitle = "Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = jul,
+    year = "2025",
+    address = "Vienna, Austria",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2025.acl-long.1312/",
+    doi = "10.18653/v1/2025.acl-long.1312",
+    pages = "27022--27043",
+    ISBN = "979-8-89176-251-0",
+    abstract = "Adaptive Retrieval-Augmented Generation (RAG) is an effective strategy to alleviate hallucination of large language models (LLMs). It dynamically determines whether LLMs need external knowledge for generation and invokes retrieval accordingly. This paper introduces Self-aware Knowledge Retrieval (SeaKR), a novel adaptive RAG model that extracts self-aware uncertainty of LLMs from their internal states. SeaKR activates retrieval when the LLMs present high self-aware uncertainty for generation. To effectively integrate retrieved knowledge snippets, SeaKR re-ranks them based on LLM{'}s self-aware uncertainty to preserve the snippet that reduces their uncertainty to the utmost. To facilitate solving complex tasks that require multiple retrievals, SeaKR utilizes their self-aware uncertainty to choose among different reasoning strategies. Our experiments on both complex and simple Question Answering datasets show that SeaKR outperforms existing adaptive RAG methods."
+}
+
+@inproceedings{huanshuo-etal-2025-ctrla,
+    title = "{C}trl{A}: Adaptive Retrieval-Augmented Generation via Inherent Control",
+    author = "Huanshuo, Liu  and
+      Zhang, Hao  and
+      Guo, Zhijiang  and
+      Wang, Jing  and
+      Dong, Kuicai  and
+      Li, Xiangyang  and
+      Lee, Yi Quan  and
+      Zhang, Cong  and
+      Liu, Yong",
+    editor = "Che, Wanxiang  and
+      Nabende, Joyce  and
+      Shutova, Ekaterina  and
+      Pilehvar, Mohammad Taher",
+    booktitle = "Findings of the Association for Computational Linguistics: ACL 2025",
+    month = jul,
+    year = "2025",
+    address = "Vienna, Austria",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2025.findings-acl.652/",
+    doi = "10.18653/v1/2025.findings-acl.652",
+    pages = "12592--12618",
+    ISBN = "979-8-89176-256-5",
+    abstract = "Retrieval-augmented generation (RAG) has emerged as a promising solution for mitigating hallucinations of large language models (LLMs) with retrieved external knowledge. Adaptive RAG enhances this approach by enabling dynamic retrieval during generation, activating retrieval only when the query exceeds LLM{'}s internal knowledge. Existing methods primarily focus on detecting LLM{'}s confidence via statistical uncertainty. Instead, we present the first attempts to solve adaptive RAG from a representation perspective and develop an inherent control-based framework, termed CtrlA. Specifically, we extract the features that represent the honesty and confidence directions of LLM and adopt them to control LLM behavior and guide retrieval timing decisions. We also design a simple yet effective query formulation strategy to support adaptive retrieval. Experiments show that CtrlA is superior to existing adaptive RAG methods on a diverse set of tasks. Honesty steering can effectively make LLMs more honest and confidence monitoring is a promising indicator of retrieval trigger."
+}
+
+@misc{sha2025semreinforcementlearningsearchefficient,
+      title={SEM: Reinforcement Learning for Search-Efficient Large Language Models}, 
+      author={Zeyang Sha and Shiwen Cui and Weiqiang Wang},
+      year={2025},
+      eprint={2505.07903},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2505.07903}, 
+}
+
+@misc{wu2025searchwiselymitigatingsuboptimal,
+      title={Search Wisely: Mitigating Sub-optimal Agentic Searches By Reducing Uncertainty}, 
+      author={Peilin Wu and Mian Zhang and Xinlu Zhang and Xinya Du and Zhiyu Zoey Chen},
+      year={2025},
+      eprint={2505.17281},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2505.17281}, 
+}
+
+@misc{song2025r1searcherincentivizingdynamicknowledge,
+      title={R1-Searcher++: Incentivizing the Dynamic Knowledge Acquisition of LLMs via Reinforcement Learning}, 
+      author={Huatong Song and Jinhao Jiang and Wenqing Tian and Zhipeng Chen and Yuhuan Wu and Jiahao Zhao and Yingqian Min and Wayne Xin Zhao and Lei Fang and Ji-Rong Wen},
+      year={2025},
+      eprint={2505.17005},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2505.17005}, 
+}
+
+@misc{huang2025reinforcedinternalexternalknowledgesynergistic,
+      title={Reinforced Internal-External Knowledge Synergistic Reasoning for Efficient Adaptive Search Agent}, 
+      author={Ziyang Huang and Xiaowei Yuan and Yiming Ju and Jun Zhao and Kang Liu},
+      year={2025},
+      eprint={2505.07596},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2505.07596}, 
+}
+
+@inproceedings{10.1145/3726302.3730102,
+author = {Sun, Zhongxiang and Wang, Qipeng and Yu, Weijie and Zang, Xiaoxue and Zheng, Kai and Xu, Jun and Zhang, Xiao and Song, Yang and Li, Han},
+title = {ReARTeR: Retrieval-Augmented Reasoning with Trustworthy Process Rewarding},
+year = {2025},
+isbn = {9798400715921},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3726302.3730102},
+doi = {10.1145/3726302.3730102},
+abstract = {Retrieval-Augmented Generation (RAG) systems for Large Language Models (LLMs) have shown promise in knowledge-intensive tasks, yet their reasoning capabilities, particularly for complex multi-step reasoning, remain limited. Although recent approaches have explored integrating RAG with chain-of-thought reasoning or incorporating test-time search with process reward model (PRM), these methods face several untrustworthy challenges, including lack of explanations, bias in PRM training data, early-step bias in PRM scores, and ignoring post-training that fails to fully optimize reasoning potential. To address these issues, we propose Retrieval-Augmented Reasoning through Trustworthy Process Rewarding (ReARTeR), a framework that enhances RAG systems' reasoning capabilities through both post-training and test-time scaling. At test time, ReARTeR introduces Trustworthy Process Rewarding via a Process Reward Model for accurate scalar scoring and a Process Explanation Model (PEM) for generating natural language explanations, enabling step refinement. During post-training, we leverage Monte Carlo Tree Search guided by Trustworthy Process Rewarding to collect high-quality step-level preference data, which is used to optimize the model through Iterative Preference Optimization. ReARTeR tackles three key challenges: (1) misalignment between PRM and PEM, addressed through off-policy preference learning; (2) bias in PRM training data, mitigated by a balanced annotation method and incorporating stronger annotations for difficult examples; and (3) early-step bias in PRM, resolved via a temporal-difference-based look-ahead search strategy. Experimental results on multi-step reasoning benchmarks demonstrate that ReARTeR significantly improves reasoning performance, highlighting its potential to advance the reasoning capability of RAG systems.},
+booktitle = {Proceedings of the 48th International ACM SIGIR Conference on Research and Development in Information Retrieval},
+pages = {1251–1261},
+numpages = {11},
+keywords = {reasoning, retrieval augment generation, trustworthy},
+location = {Padua, Italy},
+series = {SIGIR '25}
+}
+
+@misc{qian2025smartselfawareagenttool,
+      title={SMART: Self-Aware Agent for Tool Overuse Mitigation}, 
+      author={Cheng Qian and Emre Can Acikgoz and Hongru Wang and Xiusi Chen and Avirup Sil and Dilek Hakkani-Tür and Gokhan Tur and Heng Ji},
+      year={2025},
+      eprint={2502.11435},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2502.11435}, 
+}
+
+@inproceedings{shen-etal-2024-smartcal,
+    title = "{SMARTCAL}: An Approach to Self-Aware Tool-Use Evaluation and Calibration",
+    author = "Shen, Yuanhao  and
+      Zhu, Xiaodan  and
+      Chen, Lei",
+    editor = "Dernoncourt, Franck  and
+      Preo{\c{t}}iuc-Pietro, Daniel  and
+      Shimorina, Anastasia",
+    booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing: Industry Track",
+    month = nov,
+    year = "2024",
+    address = "Miami, Florida, US",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.emnlp-industry.59/",
+    doi = "10.18653/v1/2024.emnlp-industry.59",
+    pages = "774--789",
+    abstract = "The tool-use ability of Large Language Models (LLMs) has a profound impact on a wide range of applications. However, LLMs' self-awareness and self-control capability in appropriately using tools remains understudied. The problem is consequential as it alarms a potential risk of degraded performance and poses a threat to trustworthiness on the models. In this paper, we conduct a study on a family of state-of-the-art LLMs on three datasets with two mainstream tool-use frameworks. Our study reveals the tool-abuse behavior of LLMs, a tendency for models to misuse tools along with models' frequent overconfidence in tool choice. We also find that this is a common issue regardless of model capability. Accordingly, we propose a novel framework, SMARTCAL, to mitigate the observed issues, and our results show an average 8.6 percent increase in the QA performance in three testing datasets and 21.6 percent lower Expected Calibration Error (ECE) than existing methods."
+}
+
+@misc{wang2025actingreasoningmoreteaching,
+      title={Acting Less is Reasoning More! Teaching Model to Act Efficiently}, 
+      author={Hongru Wang and Cheng Qian and Wanjun Zhong and Xiusi Chen and Jiahao Qiu and Shijue Huang and Bowen Jin and Mengdi Wang and Kam-Fai Wong and Heng Ji},
+      year={2025},
+      eprint={2504.14870},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2504.14870}, 
+}
+
+@misc{yue2025promotingefficientreasoningverifiable,
+      title={Promoting Efficient Reasoning with Verifiable Stepwise Reward}, 
+      author={Chuhuai Yue and Chengqi Dong and Yinan Gao and Hang He and Jiajun Chai and Guojun Yin and Wei Lin},
+      year={2025},
+      eprint={2508.10293},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2508.10293}, 
+}
+
+@misc{ye2025correctnessharmonizingprocessoutcome,
+      title={Beyond Correctness: Harmonizing Process and Outcome Rewards through RL Training}, 
+      author={Chenlu Ye and Zhou Yu and Ziji Zhang and Hao Chen and Narayanan Sadagopan and Jing Huang and Tong Zhang and Anurag Beniwal},
+      year={2025},
+      eprint={2509.03403},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2509.03403}, 
+}

benchmark_dataset/papers/ICLR2026_0005_2510.07794/source_related_work.tex

@@ -0,0 +1,8 @@
+\section{Related Work}
+\label{sec:related_work}
+
+\paragraph{Agentic RAG \& Tool Use}
+The integration of external knowledge into LLMs has evolved into more dynamic, agentic systems. Frameworks like ReAct demonstrated that LLMs can synergize reasoning and acting, paving the way for agents that can autonomously decide when and what to retrieve. This led to a new class of agentic RAG systems that interleave retrieval with multi-step reasoning, often structured as a "chain-of-thought" process . Variations like Chain-of-Retrieval and DeepRAG further refined this by structuring the retrieval process itself into sequential steps to handle complex queries. To improve the decision-making capabilities of these agents, recent work has increasingly turned to RL . RL frameworks train agents to develop optimal policies for invoking tools, including search engines. For instance, use RL and curriculum learning to enhance RAG. This aligns with a broader trend of using RL to improve general tool use in LLMs. Works like ToolRL and ToRL have shown that RL from rewards based on task success can significantly scale and improve the tool-integration capabilities of LLMs. Our work builds on this foundation, applying RL not just to achieve a correct final outcome but to optimize the efficiency of the retrieval process itself.
+
+\paragraph{Efficient Agentic RAG \& Tool Use}
+While agentic RAG enhances reasoning, it often introduces inefficiency, such as redundant or unnecessary tool calls. A key research direction has been to make retrieval adaptive, triggering it only when the model's internal knowledge is insufficient. Early approaches relied on heuristics or classifiers to detect uncertainty and determine the need for retrieval . More sophisticated methods learn to assess the LLM's real-time information needs or self-awareness from its internal states to make dynamic retrieval decisions . Concurrently, RL has emerged as a powerful tool for optimizing the efficiency of tool use. In the context of RAG, RL has been used to create search-efficient models and to mitigate suboptimal search behaviors by reducing uncertainty . Works like R1-Searcher++ and other synergistic reasoning agents use RL to incentivize dynamic and necessary knowledge acquisition. ReARTeR introduces a framework with a trustworthy process reward model to score and refine each step in a RAG pipeline. This mirrors efforts in the broader tool-use domain to mitigate tool overuse. For example, SMART , SMARTCAL , and OTC train agents to be self-aware and make optimal tool calls, often using RL. and also use verifiable stepwise rewards to promote more efficient general reasoning paths. While these methods improve efficiency, they often rely on proxies like model confidence or separately trained reward models. HiPRAG differs by introducing a direct, on-the-fly evaluation of each search step's necessity, providing a more explicit training signal for efficiency.

benchmark_dataset/papers/ICLR2026_0006_2602.21143/metadata.json

@@ -0,0 +1,66 @@
+{
+  "paper_id": "ICLR2026_0006_2602.21143",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "A Benchmark for Deep Information Synthesis",
+  "authors": [
+    "Debjit Paul",
+    "Daniel Murphy",
+    "Milan Gritta",
+    "Ronald Cardenas",
+    "Victor Prokhorov",
+    "Lena Sophia Bolliger",
+    "Aysim Toker",
+    "Roy Miles",
+    "Andreea-Maria Oncescu",
+    "Jasivan Alex Sivakumar",
+    "Philipp Borchert",
+    "Ismail Elezi",
+    "Meiru Zhang",
+    "Ka Yiu Lee",
+    "Guchun Zhang",
+    "Jun Wang",
+    "Gerasimos Lampouras"
+  ],
+  "domain_score": 25,
+  "domain_areas": [
+    "model_architecture",
+    "test_time_reasoning_compute",
+    "rag_agents_tools",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "0Dhpt9aY3n",
+  "openreview_forum": "0Dhpt9aY3n",
+  "openreview_url": "https://openreview.net/forum?id=0Dhpt9aY3n",
+  "arxiv_id": "2602.21143",
+  "arxiv_id_versioned": "2602.21143v1",
+  "arxiv_abs_url": "http://arxiv.org/abs/2602.21143v1",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2602.21143v1",
+  "arxiv_source_url": "https://arxiv.org/e-print/2602.21143",
+  "arxiv_title": "A Benchmark for Deep Information Synthesis",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2026-02-24T17:43:32Z",
+  "arxiv_updated": "2026-02-24T17:43:32Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 12,
+  "status": "ok",
+  "main_tex_original_path": "iclr2026_conference.tex",
+  "expanded_inputs_count": 11,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "mialon2023gaia",
+    "yoran-etal-2024-assistantbench",
+    "wei2025browsecomp",
+    "phan2025humanity",
+    "wu2025mmqa",
+    "wolfson-etal-2025-monaco",
+    "jimenez2024swebench",
+    "chan2024mle",
+    "ouyang2025kernelbench",
+    "starace2025paperbench"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0006_2602.21143/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3aa42b0793e362eaa495c74252e7e6218632af4b96b4d71c50d66736afc6401f
+size 2434542

benchmark_dataset/papers/ICLR2026_0006_2602.21143/source.tex

@@ -0,0 +1,882 @@
+\documentclass{article}
+\usepackage{iclr2026_conference,times}
+
+
+\usepackage{amsmath,amsfonts,bm}
+
+\newcommand{\figleft}{{\em (Left)}}
+\newcommand{\figcenter}{{\em (Center)}}
+\newcommand{\figright}{{\em (Right)}}
+\newcommand{\figtop}{{\em (Top)}}
+\newcommand{\figbottom}{{\em (Bottom)}}
+\newcommand{\captiona}{{\em (a)}}
+\newcommand{\captionb}{{\em (b)}}
+\newcommand{\captionc}{{\em (c)}}
+\newcommand{\captiond}{{\em (d)}}
+
+\newcommand{\newterm}[1]{{\bf #1}}
+
+
+\def\figref#1{figure~\ref{#1}}
+\def\Figref#1{Figure~\ref{#1}}
+\def\twofigref#1#2{figures \ref{#1} and \ref{#2}}
+\def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}}
+\def\secref#1{section~\ref{#1}}
+\def\Secref#1{Section~\ref{#1}}
+\def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}}
+\def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}}
+\def\eqref#1{equation~\ref{#1}}
+\def\Eqref#1{Equation~\ref{#1}}
+\def\plaineqref#1{\ref{#1}}
+\def\chapref#1{chapter~\ref{#1}}
+\def\Chapref#1{Chapter~\ref{#1}}
+\def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}}
+\def\algref#1{algorithm~\ref{#1}}
+\def\Algref#1{Algorithm~\ref{#1}}
+\def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}}
+\def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}}
+\def\partref#1{part~\ref{#1}}
+\def\Partref#1{Part~\ref{#1}}
+\def\twopartref#1#2{parts \ref{#1} and \ref{#2}}
+
+\def\ceil#1{\lceil #1 \rceil}
+\def\floor#1{\lfloor #1 \rfloor}
+\def\1{\bm{1}}
+\newcommand{\train}{\mathcal{D}}
+\newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}}
+\newcommand{\test}{\mathcal{D_{\mathrm{test}}}}
+
+\def\eps{{\epsilon}}
+
+
+\def\reta{{\textnormal{$\eta$}}}
+\def\ra{{\textnormal{a}}}
+\def\rb{{\textnormal{b}}}
+\def\rc{{\textnormal{c}}}
+\def\rd{{\textnormal{d}}}
+\def\re{{\textnormal{e}}}
+\def\rf{{\textnormal{f}}}
+\def\rg{{\textnormal{g}}}
+\def\rh{{\textnormal{h}}}
+\def\ri{{\textnormal{i}}}
+\def\rj{{\textnormal{j}}}
+\def\rk{{\textnormal{k}}}
+\def\rl{{\textnormal{l}}}
+\def\rn{{\textnormal{n}}}
+\def\ro{{\textnormal{o}}}
+\def\rp{{\textnormal{p}}}
+\def\rq{{\textnormal{q}}}
+\def\rr{{\textnormal{r}}}
+\def\rs{{\textnormal{s}}}
+\def\rt{{\textnormal{t}}}
+\def\ru{{\textnormal{u}}}
+\def\rv{{\textnormal{v}}}
+\def\rw{{\textnormal{w}}}
+\def\rx{{\textnormal{x}}}
+\def\ry{{\textnormal{y}}}
+\def\rz{{\textnormal{z}}}
+
+\def\rvepsilon{{\mathbf{\epsilon}}}
+\def\rvtheta{{\mathbf{\theta}}}
+\def\rva{{\mathbf{a}}}
+\def\rvb{{\mathbf{b}}}
+\def\rvc{{\mathbf{c}}}
+\def\rvd{{\mathbf{d}}}
+\def\rve{{\mathbf{e}}}
+\def\rvf{{\mathbf{f}}}
+\def\rvg{{\mathbf{g}}}
+\def\rvh{{\mathbf{h}}}
+\def\rvu{{\mathbf{i}}}
+\def\rvj{{\mathbf{j}}}
+\def\rvk{{\mathbf{k}}}
+\def\rvl{{\mathbf{l}}}
+\def\rvm{{\mathbf{m}}}
+\def\rvn{{\mathbf{n}}}
+\def\rvo{{\mathbf{o}}}
+\def\rvp{{\mathbf{p}}}
+\def\rvq{{\mathbf{q}}}
+\def\rvr{{\mathbf{r}}}
+\def\rvs{{\mathbf{s}}}
+\def\rvt{{\mathbf{t}}}
+\def\rvu{{\mathbf{u}}}
+\def\rvv{{\mathbf{v}}}
+\def\rvw{{\mathbf{w}}}
+\def\rvx{{\mathbf{x}}}
+\def\rvy{{\mathbf{y}}}
+\def\rvz{{\mathbf{z}}}
+
+\def\erva{{\textnormal{a}}}
+\def\ervb{{\textnormal{b}}}
+\def\ervc{{\textnormal{c}}}
+\def\ervd{{\textnormal{d}}}
+\def\erve{{\textnormal{e}}}
+\def\ervf{{\textnormal{f}}}
+\def\ervg{{\textnormal{g}}}
+\def\ervh{{\textnormal{h}}}
+\def\ervi{{\textnormal{i}}}
+\def\ervj{{\textnormal{j}}}
+\def\ervk{{\textnormal{k}}}
+\def\ervl{{\textnormal{l}}}
+\def\ervm{{\textnormal{m}}}
+\def\ervn{{\textnormal{n}}}
+\def\ervo{{\textnormal{o}}}
+\def\ervp{{\textnormal{p}}}
+\def\ervq{{\textnormal{q}}}
+\def\ervr{{\textnormal{r}}}
+\def\ervs{{\textnormal{s}}}
+\def\ervt{{\textnormal{t}}}
+\def\ervu{{\textnormal{u}}}
+\def\ervv{{\textnormal{v}}}
+\def\ervw{{\textnormal{w}}}
+\def\ervx{{\textnormal{x}}}
+\def\ervy{{\textnormal{y}}}
+\def\ervz{{\textnormal{z}}}
+
+\def\rmA{{\mathbf{A}}}
+\def\rmB{{\mathbf{B}}}
+\def\rmC{{\mathbf{C}}}
+\def\rmD{{\mathbf{D}}}
+\def\rmE{{\mathbf{E}}}
+\def\rmF{{\mathbf{F}}}
+\def\rmG{{\mathbf{G}}}
+\def\rmH{{\mathbf{H}}}
+\def\rmI{{\mathbf{I}}}
+\def\rmJ{{\mathbf{J}}}
+\def\rmK{{\mathbf{K}}}
+\def\rmL{{\mathbf{L}}}
+\def\rmM{{\mathbf{M}}}
+\def\rmN{{\mathbf{N}}}
+\def\rmO{{\mathbf{O}}}
+\def\rmP{{\mathbf{P}}}
+\def\rmQ{{\mathbf{Q}}}
+\def\rmR{{\mathbf{R}}}
+\def\rmS{{\mathbf{S}}}
+\def\rmT{{\mathbf{T}}}
+\def\rmU{{\mathbf{U}}}
+\def\rmV{{\mathbf{V}}}
+\def\rmW{{\mathbf{W}}}
+\def\rmX{{\mathbf{X}}}
+\def\rmY{{\mathbf{Y}}}
+\def\rmZ{{\mathbf{Z}}}
+
+\def\ermA{{\textnormal{A}}}
+\def\ermB{{\textnormal{B}}}
+\def\ermC{{\textnormal{C}}}
+\def\ermD{{\textnormal{D}}}
+\def\ermE{{\textnormal{E}}}
+\def\ermF{{\textnormal{F}}}
+\def\ermG{{\textnormal{G}}}
+\def\ermH{{\textnormal{H}}}
+\def\ermI{{\textnormal{I}}}
+\def\ermJ{{\textnormal{J}}}
+\def\ermK{{\textnormal{K}}}
+\def\ermL{{\textnormal{L}}}
+\def\ermM{{\textnormal{M}}}
+\def\ermN{{\textnormal{N}}}
+\def\ermO{{\textnormal{O}}}
+\def\ermP{{\textnormal{P}}}
+\def\ermQ{{\textnormal{Q}}}
+\def\ermR{{\textnormal{R}}}
+\def\ermS{{\textnormal{S}}}
+\def\ermT{{\textnormal{T}}}
+\def\ermU{{\textnormal{U}}}
+\def\ermV{{\textnormal{V}}}
+\def\ermW{{\textnormal{W}}}
+\def\ermX{{\textnormal{X}}}
+\def\ermY{{\textnormal{Y}}}
+\def\ermZ{{\textnormal{Z}}}
+
+\def\vzero{{\bm{0}}}
+\def\vone{{\bm{1}}}
+\def\vmu{{\bm{\mu}}}
+\def\vtheta{{\bm{\theta}}}
+\def\va{{\bm{a}}}
+\def\vb{{\bm{b}}}
+\def\vc{{\bm{c}}}
+\def\vd{{\bm{d}}}
+\def\ve{{\bm{e}}}
+\def\vf{{\bm{f}}}
+\def\vg{{\bm{g}}}
+\def\vh{{\bm{h}}}
+\def\vi{{\bm{i}}}
+\def\vj{{\bm{j}}}
+\def\vk{{\bm{k}}}
+\def\vl{{\bm{l}}}
+\def\vm{{\bm{m}}}
+\def\vn{{\bm{n}}}
+\def\vo{{\bm{o}}}
+\def\vp{{\bm{p}}}
+\def\vq{{\bm{q}}}
+\def\vr{{\bm{r}}}
+\def\vs{{\bm{s}}}
+\def\vt{{\bm{t}}}
+\def\vu{{\bm{u}}}
+\def\vv{{\bm{v}}}
+\def\vw{{\bm{w}}}
+\def\vx{{\bm{x}}}
+\def\vy{{\bm{y}}}
+\def\vz{{\bm{z}}}
+
+\def\evalpha{{\alpha}}
+\def\evbeta{{\beta}}
+\def\evepsilon{{\epsilon}}
+\def\evlambda{{\lambda}}
+\def\evomega{{\omega}}
+\def\evmu{{\mu}}
+\def\evpsi{{\psi}}
+\def\evsigma{{\sigma}}
+\def\evtheta{{\theta}}
+\def\eva{{a}}
+\def\evb{{b}}
+\def\evc{{c}}
+\def\evd{{d}}
+\def\eve{{e}}
+\def\evf{{f}}
+\def\evg{{g}}
+\def\evh{{h}}
+\def\evi{{i}}
+\def\evj{{j}}
+\def\evk{{k}}
+\def\evl{{l}}
+\def\evm{{m}}
+\def\evn{{n}}
+\def\evo{{o}}
+\def\evp{{p}}
+\def\evq{{q}}
+\def\evr{{r}}
+\def\evs{{s}}
+\def\evt{{t}}
+\def\evu{{u}}
+\def\evv{{v}}
+\def\evw{{w}}
+\def\evx{{x}}
+\def\evy{{y}}
+\def\evz{{z}}
+
+\def\mA{{\bm{A}}}
+\def\mB{{\bm{B}}}
+\def\mC{{\bm{C}}}
+\def\mD{{\bm{D}}}
+\def\mE{{\bm{E}}}
+\def\mF{{\bm{F}}}
+\def\mG{{\bm{G}}}
+\def\mH{{\bm{H}}}
+\def\mI{{\bm{I}}}
+\def\mJ{{\bm{J}}}
+\def\mK{{\bm{K}}}
+\def\mL{{\bm{L}}}
+\def\mM{{\bm{M}}}
+\def\mN{{\bm{N}}}
+\def\mO{{\bm{O}}}
+\def\mP{{\bm{P}}}
+\def\mQ{{\bm{Q}}}
+\def\mR{{\bm{R}}}
+\def\mS{{\bm{S}}}
+\def\mT{{\bm{T}}}
+\def\mU{{\bm{U}}}
+\def\mV{{\bm{V}}}
+\def\mW{{\bm{W}}}
+\def\mX{{\bm{X}}}
+\def\mY{{\bm{Y}}}
+\def\mZ{{\bm{Z}}}
+\def\mBeta{{\bm{\beta}}}
+\def\mPhi{{\bm{\Phi}}}
+\def\mLambda{{\bm{\Lambda}}}
+\def\mSigma{{\bm{\Sigma}}}
+
+\DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl}
+\SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{n}
+\newcommand{\tens}[1]{\bm{\mathsfit{#1}}}
+\def\tA{{\tens{A}}}
+\def\tB{{\tens{B}}}
+\def\tC{{\tens{C}}}
+\def\tD{{\tens{D}}}
+\def\tE{{\tens{E}}}
+\def\tF{{\tens{F}}}
+\def\tG{{\tens{G}}}
+\def\tH{{\tens{H}}}
+\def\tI{{\tens{I}}}
+\def\tJ{{\tens{J}}}
+\def\tK{{\tens{K}}}
+\def\tL{{\tens{L}}}
+\def\tM{{\tens{M}}}
+\def\tN{{\tens{N}}}
+\def\tO{{\tens{O}}}
+\def\tP{{\tens{P}}}
+\def\tQ{{\tens{Q}}}
+\def\tR{{\tens{R}}}
+\def\tS{{\tens{S}}}
+\def\tT{{\tens{T}}}
+\def\tU{{\tens{U}}}
+\def\tV{{\tens{V}}}
+\def\tW{{\tens{W}}}
+\def\tX{{\tens{X}}}
+\def\tY{{\tens{Y}}}
+\def\tZ{{\tens{Z}}}
+
+
+\def\gA{{\mathcal{A}}}
+\def\gB{{\mathcal{B}}}
+\def\gC{{\mathcal{C}}}
+\def\gD{{\mathcal{D}}}
+\def\gE{{\mathcal{E}}}
+\def\gF{{\mathcal{F}}}
+\def\gG{{\mathcal{G}}}
+\def\gH{{\mathcal{H}}}
+\def\gI{{\mathcal{I}}}
+\def\gJ{{\mathcal{J}}}
+\def\gK{{\mathcal{K}}}
+\def\gL{{\mathcal{L}}}
+\def\gM{{\mathcal{M}}}
+\def\gN{{\mathcal{N}}}
+\def\gO{{\mathcal{O}}}
+\def\gP{{\mathcal{P}}}
+\def\gQ{{\mathcal{Q}}}
+\def\gR{{\mathcal{R}}}
+\def\gS{{\mathcal{S}}}
+\def\gT{{\mathcal{T}}}
+\def\gU{{\mathcal{U}}}
+\def\gV{{\mathcal{V}}}
+\def\gW{{\mathcal{W}}}
+\def\gX{{\mathcal{X}}}
+\def\gY{{\mathcal{Y}}}
+\def\gZ{{\mathcal{Z}}}
+
+\def\sA{{\mathbb{A}}}
+\def\sB{{\mathbb{B}}}
+\def\sC{{\mathbb{C}}}
+\def\sD{{\mathbb{D}}}
+\def\sF{{\mathbb{F}}}
+\def\sG{{\mathbb{G}}}
+\def\sH{{\mathbb{H}}}
+\def\sI{{\mathbb{I}}}
+\def\sJ{{\mathbb{J}}}
+\def\sK{{\mathbb{K}}}
+\def\sL{{\mathbb{L}}}
+\def\sM{{\mathbb{M}}}
+\def\sN{{\mathbb{N}}}
+\def\sO{{\mathbb{O}}}
+\def\sP{{\mathbb{P}}}
+\def\sQ{{\mathbb{Q}}}
+\def\sR{{\mathbb{R}}}
+\def\sS{{\mathbb{S}}}
+\def\sT{{\mathbb{T}}}
+\def\sU{{\mathbb{U}}}
+\def\sV{{\mathbb{V}}}
+\def\sW{{\mathbb{W}}}
+\def\sX{{\mathbb{X}}}
+\def\sY{{\mathbb{Y}}}
+\def\sZ{{\mathbb{Z}}}
+
+\def\emLambda{{\Lambda}}
+\def\emA{{A}}
+\def\emB{{B}}
+\def\emC{{C}}
+\def\emD{{D}}
+\def\emE{{E}}
+\def\emF{{F}}
+\def\emG{{G}}
+\def\emH{{H}}
+\def\emI{{I}}
+\def\emJ{{J}}
+\def\emK{{K}}
+\def\emL{{L}}
+\def\emM{{M}}
+\def\emN{{N}}
+\def\emO{{O}}
+\def\emP{{P}}
+\def\emQ{{Q}}
+\def\emR{{R}}
+\def\emS{{S}}
+\def\emT{{T}}
+\def\emU{{U}}
+\def\emV{{V}}
+\def\emW{{W}}
+\def\emX{{X}}
+\def\emY{{Y}}
+\def\emZ{{Z}}
+\def\emSigma{{\Sigma}}
+
+\newcommand{\etens}[1]{\mathsfit{#1}}
+\def\etLambda{{\etens{\Lambda}}}
+\def\etA{{\etens{A}}}
+\def\etB{{\etens{B}}}
+\def\etC{{\etens{C}}}
+\def\etD{{\etens{D}}}
+\def\etE{{\etens{E}}}
+\def\etF{{\etens{F}}}
+\def\etG{{\etens{G}}}
+\def\etH{{\etens{H}}}
+\def\etI{{\etens{I}}}
+\def\etJ{{\etens{J}}}
+\def\etK{{\etens{K}}}
+\def\etL{{\etens{L}}}
+\def\etM{{\etens{M}}}
+\def\etN{{\etens{N}}}
+\def\etO{{\etens{O}}}
+\def\etP{{\etens{P}}}
+\def\etQ{{\etens{Q}}}
+\def\etR{{\etens{R}}}
+\def\etS{{\etens{S}}}
+\def\etT{{\etens{T}}}
+\def\etU{{\etens{U}}}
+\def\etV{{\etens{V}}}
+\def\etW{{\etens{W}}}
+\def\etX{{\etens{X}}}
+\def\etY{{\etens{Y}}}
+\def\etZ{{\etens{Z}}}
+
+\newcommand{\pdata}{p_{\rm{data}}}
+\newcommand{\ptrain}{\hat{p}_{\rm{data}}}
+\newcommand{\Ptrain}{\hat{P}_{\rm{data}}}
+\newcommand{\pmodel}{p_{\rm{model}}}
+\newcommand{\Pmodel}{P_{\rm{model}}}
+\newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}}
+\newcommand{\pencode}{p_{\rm{encoder}}}
+\newcommand{\pdecode}{p_{\rm{decoder}}}
+\newcommand{\precons}{p_{\rm{reconstruct}}}
+
+\newcommand{\laplace}{\mathrm{Laplace}}
+
+\newcommand{\E}{\mathbb{E}}
+\newcommand{\Ls}{\mathcal{L}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\emp}{\tilde{p}}
+\newcommand{\lr}{\alpha}
+\newcommand{\reg}{\lambda}
+\newcommand{\rect}{\mathrm{rectifier}}
+\newcommand{\softmax}{\mathrm{softmax}}
+\newcommand{\sigmoid}{\sigma}
+\newcommand{\softplus}{\zeta}
+\newcommand{\KL}{D_{\mathrm{KL}}}
+\newcommand{\Var}{\mathrm{Var}}
+\newcommand{\standarderror}{\mathrm{SE}}
+\newcommand{\Cov}{\mathrm{Cov}}
+\newcommand{\normlzero}{L^0}
+\newcommand{\normlone}{L^1}
+\newcommand{\normltwo}{L^2}
+\newcommand{\normlp}{L^p}
+\newcommand{\normmax}{L^\infty}
+
+\newcommand{\parents}{Pa}
+
+\DeclareMathOperator*{\argmax}{arg\,max}
+\DeclareMathOperator*{\argmin}{arg\,min}
+
+\DeclareMathOperator{\sign}{sign}
+\DeclareMathOperator{\Tr}{Tr}
+\let\ab\allowbreak
+
+
+\usepackage{hyperref}
+\usepackage{url}
+
+\usepackage{makecell}
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{amsmath,amssymb,amsfonts}
+\usepackage{amsthm}
+\usepackage{mathrsfs}
+\usepackage[title]{appendix}
+\usepackage{textcomp}
+\usepackage{subcaption}
+\usepackage{booktabs}
+\usepackage{manyfoot}
+\usepackage{algorithm}
+\usepackage{algorithmicx}
+\usepackage{algpseudocode}
+\usepackage{listings}
+\usepackage{xspace}
+\usepackage{microtype}
+\usepackage{times}
+\usepackage{latexsym}
+\usepackage{float}
+\usepackage{footnote}
+\usepackage{tablefootnote}
+\usepackage{enumitem}
+\usepackage{bm}
+\usepackage{multicol}
+\usepackage{multirow}
+\usepackage{color}
+\usepackage{colortbl}
+\usepackage{bbding}
+\usepackage{makecell}
+\usepackage{mathtools}
+\usepackage{imakeidx}
+\makeindex
+\usepackage{listings}
+\usepackage{pifont}
+\usepackage{arydshln}
+\usepackage{lipsum}
+\usepackage[toc]{multitoc}
+\usepackage[edges]{forest}
+\usepackage[normalem]{ulem}
+\usepackage{textcomp}
+
+\usepackage{tabularx}
+\usepackage{booktabs}
+\usepackage{adjustbox}
+\usepackage{xcolor}
+\usepackage{fontawesome5}
+
+\usepackage{caption}
+\captionsetup[table]{skip=10pt}
+\usepackage{awesomebox}
+\usepackage[most]{tcolorbox}
+
+\usepackage{lineno}
+
+
+\newcommand{\ourdata}{\textsc{{DeepSynth}}\xspace}
+\newcommand{\numtask}{120\xspace}
+
+\newcommand{\ourdatalite}{\ourdata-\textbf{\textsc{Robust}}}
+\newcommand{\ourdatatiny}{\ourdata-\textbf{\textsc{Full}}}
+\newcommand{\ourdataall}{\ourdata}
+
+\newcommand{\ie}{\textit{i.e.}}
+\newcommand{\eg}{\textit{e.g.}}
+\newcommand{\indic}{\mathds{1}}
+
+
+\newcommand{\sara}[1]{\textcolor{violet}{Sara: #1}}
+
+
+\DeclarePairedDelimiterX{\infdivx}[2]{(}{)}{
+ #1\;\delimsize\|\;#2
+}
+\newcommand{\kldiv}{D_\text{KL}\infdivx}
+
+\definecolor{darkgreen2}{HTML}{009B55}
+\definecolor{myblue2}{HTML}{29abe2}
+\definecolor{myorange2}{HTML}{f7931e}
+
+
+\definecolor{mypurple2}{HTML}{9823FF}
+\newcommand{\rebuttaltext}[1]{{\color{mypurple2}{#1}}}
+\newenvironment{rebuttalenv}{\color{mypurple2}}{\ignorespacesafterend}
+
+
+\newif\ifcomments
+\commentstrue
+
+\ifcomments
+ \usepackage[normalem]{ulem}
+ \addtolength{\marginparwidth}{-0.25in}
+ \setlength{\marginparsep}{3pt}
+ \definecolor{ABpurple}{rgb}{0.8,0.0,0.8}
+ \newcommand\abi[1]{\textcolor{ABpurple}{#1}}
+ \newcommand\abm[1]{{\marginparwidth=2cm \marginpar{\raggedright\tiny\textcolor{ABpurple}{\textsf{{\bfseries AB\@:} #1}}}}}
+ \newcommand\abs{\bgroup\markoverwith{\textcolor{ABpurple}{\rule[.4ex]{2pt}{0.8pt}}}\ULon}
+\else
+ \newcommand\ab[1]{}
+ \newcommand\abi[1]{\ignorespaces}
+ \newcommand\abm[1]{}
+ \newcommand\abs[1]{#1}
+\fi
+
+\definecolor{myred}{HTML}{E11D3F}
+\definecolor{myorange}{HTML}{F04A00}
+\definecolor{myblue}{HTML}{1974D2}
+\definecolor{mypurple}{HTML}{6A0DAD}
+\ifcomments
+ \newenvironment{todoenv}{\scriptsize\color{blue!80!black}[{\bf TODO: } \textsf}{]}
+ \newenvironment{noteenv}{\scriptsize\color{mypurple!80!black}[{\bf NOTE: } \textsf}{]}
+ \newcommand{\todo}[1]{{\scriptsize\color{blue!80!black}[{\bf TODO: }\textsf{#1}]}}
+
+ \newcommand{\nf}[1]{\textcolor{myorange}{\textsf{\scriptsize[\textbf{NF\@:} #1]}}}
+ \newcommand{\nfm}[1]{{\marginparwidth=2cm \marginpar{\raggedright\tiny\textcolor{myorange}{\textsf{{\bfseries NF\@:} #1}}}}}
+\else
+ \excludecomment{todoenv}
+ \excludecomment{noteenv}
+ \newcommand{\todo}[1]{}
+ \newcommand{\db}[1]{}
+ \newcommand{\dbm}[1]{}
+ \newcommand{\nf}[1]{}
+\fi
+
+
+\iclrfinalcopy
+
+\newcommand{\fix}{\marginpar{FIX}}
+\newcommand{\new}{\marginpar{NEW}}
+
+\iclrfinalcopy
+\begin{document}
+
+
+\begin{abstract}
+
+
+Large language model (LLM)-based agents are increasingly used to solve complex tasks involving tool use, such as web browsing, code execution, and data analysis. However, current evaluation benchmarks do not adequately assess their ability to solve real-world tasks that require synthesizing information from multiple sources and inferring insights beyond simple fact retrieval. To address this, we introduce \ourdata, a novel benchmark designed to evaluate agents on realistic, time-consuming problems that combine information gathering, synthesis, and structured reasoning to produce insights. \ourdata contains $\numtask$ tasks collected across $7$ domains and data sources covering {$67$} countries. \ourdata is constructed using a multi-stage data collection pipeline that requires annotators to collect official data sources, create hypotheses, perform manual analysis, and design tasks with verifiable answers. {When evaluated on \ourdata, {$11$} state-of-the-art LLMs and deep research agents achieve a maximum F1 score of $8.97$ and $17.5$ on the LLM-judge metric, underscoring the difficulty of the benchmark}. Our analysis reveals that current agents struggle with hallucinations and reasoning over large information spaces, highlighting \ourdata as a crucial benchmark for guiding future research.
+
+
+\end{abstract}
+\section{Introduction}
+
+
+\textit{Information synthesis} involves collecting information from multiple sources and reasoning over it to form coherent insights. While this capability has been central to human decision-making and has driven advances in fields ranging from scientific discovery to policy development , it has traditionally been laborious and cognitively demanding. For example, a travel agency from Singapore might want to know ``\textit{Which non-ASEAN countries experienced a significant post-COVID recovery — reaching at least 95\% of their 2019 visitor arrival levels to Singapore by 2023, and what were the main reasons for travel (business or tourism)?''} a question that requires identifying ASEAN countries, extracting multiple arrival data from various sources, and analysing them to determine the answer (see Figure~\ref{fig:intro}).
+Recent Large Language Model (LLM)-based agents with capabilities for reasoning, tool use, and interaction across diverse environments have shown promise in complex tasks, such as for hard-to-find information , interacting with websites , and planning to navigate the web .
+However, these developments mostly improve the information-seeking capabilities of agents. It remains crucial to evaluate whether such agents can solve real-world tasks that require synthesizing information from multiple sources and inferring insights beyond simple fact retrieval.
+
+Despite the substantial promise of LLM-based agents for addressing real-world tasks, most existing benchmarks primarily emphasise shallow fact retrieval tasks , artificial information-seeking questions , or tasks that require information from a single, particularly well-known source like Wikipedia .
+Furthermore, most agentic benchmarks focus on English-language sources and overlook the diversity of regional contexts, languages, and information ecosystems, limiting their ability to evaluate agent performance in realistic, globally distributed settings.
+
+
+To resolve this gap, we introduce \ourdata benchmark, a new benchmark comprising \numtask challenging and diverse tasks, aimed to evaluate the ability of agents to browse the entire web, combine information from unstructured and structured sources (paragraphs and tables) across $67$ countries, and perform analysis to synthesize new information and insights. \ourdata tasks are annotated with a gold standard, manually annotated reasoning chain, which includes all the intermediate steps, answers and all required supporting evidence. Each task requires agents to navigate an average of $4.2$ web pages, and read between $1$ to $15$ documents and/or tables. These tasks are designed to reflect real-world analysis and insight generation, with an emphasis on the time-intensive nature of processing and integrating information (see Figure~\ref{fig:intro}).
+
+To construct \ourdata, we asked $16$ experts to first curate relevant topics and data sources targeting various countries (\S{\ref{sec:data_collection}}), and subsequently formulate possible hypotheses for each of these data sources. Based on the hypotheses, the experts conducted analyses and derived insights. Finally, drawing on their analyses, they formulated the corresponding questions, answers, and step-by-step reasoning chains.
+In our experiments, we find that state-of-the-art LLMs — including recent AI reasoning models GPT-5, DeepSeek-R1 , struggle on \ourdata. The best-performing model, Gemini-Pro-2.5, achieves only an F1 score of $6.25$, with no task attaining a perfect score under the stricter EM metric. We also analyse the performance of specialised deep research agents, i.e.\ o3-deep-research, smolagents, and OWL , and observe they successfully solve only three out of 120 tasks, further underscoring the difficulty of our benchmark. Our analysis reveals that (i) these agents frequently commit navigation and synthesis errors, and (ii) their performance drops sharply when tasks require synthesising information from under-represented sources, e.g.\ data pertaining to the African region.
+
+
+To summarize, our main contributions are:
+\begin{enumerate}
+ \item We release \ourdata, a new benchmark for agents that contains $120$ real-world and time-consuming information synthesis tasks. \footnote{Our \href{https://huggingface.co/datasets/DeepSynthesisTeam/deepsynth-bench}{data} and \href{https://github.com/agentdeepsynthesis/deepsynth-bench}{code} for \href{https://agentdeepsynthesis.github.io/deepsynth.github.io/}{DeepSythn Bench} are publicly available}.
+ \item We show that \ourdata poses a significant challenge for state-of-the-art agents, revealing key limitations in their capabilities. The best-performing agent achieves only an F1 score of $8.97$ points, leaving substantial room for improvement.
+ \item We conduct an in-depth analysis to explain how \ourdata is challenging and demonstrate why current agents cannot yet be considered reliable systems for information synthesis.
+\end{enumerate}
+
+
+\section{The \ourdata Benchmark}
+
+
+\ourdata is a benchmark designed to evaluate agents on realistic, time-consuming tasks that require planning, information gathering, and synthesis from the web. Specifically, \ourdata evaluates agents on their ability to navigate multiple websites, extract information from both structured and unstructured sources, and reason effectively to produce correct solutions. It consists of {$\numtask$} tasks that are carefully designed and annotated by experts. Each task (see Figure~\ref{fig:intro}) is formulated to yield a concise output in the form of a JSON object or dictionary, with key-value pairs organised in a tabular style, thereby enabling straightforward and reliable verification. Solving these tasks requires agents to formulate plans, decompose problems into sub-steps, select and use appropriate external tools (e.g., document processors, code interpreters), and integrate intermediate results into a final solution.
+
+
+We now describe the process of constructing \ourdata. We first outline the criteria for our tasks, then describe our data collection pipeline, and conclude with an analysis of the collected data.
+
+\subsection{Criteria for \ourdata Tasks}\label{sec:criteria}
+
+
+Motivated by prior benchmarks , the design of \ourdata tasks is driven primarily by criteria that promote the future development of Agents' information seeking and synthesis capabilities towards practical and grounded goals. Specifically, our criteria consist of:
+
+
+\begin{enumerate}[label=\alph*)]
+
+ \item \textbf{Multi-source Information Synthesis}: Tasks should require agents to identify connections across multiple data sources or to combine information from them to produce a coherent solution. More specifically, tasks are designed such that agents must not only fetch relevant information but also perform subsequent operations on it (see Table~\ref{tab:dataset_stats}).
+
+ \item{\textbf{Inspired by the Real World}}: Experts were instructed to draw inspiration from real-world situations. The tasks are designed so that any resulting insights would conceivably be able to shape the decisions and actions of an individual or a group of people, such as \textit{political scientists, policy makers, travel agents, etc.}
+
+ \item{\bf{Verifiable Answers}}: A task that has a closed-form answer, which can be automatically verified and is stable over time, making it suitable for reproducible evaluation. While the answers to our tasks may be better suited to open-form answers, properly argued and grounded in citations, we necessarily restrict them to maintain their verifiability.
+
+ \item{\bf{Diversity}}: Our benchmark is designed to span a wide range of tasks, requiring agents to gather and reason over information across $67$ countries and $7$ distinct domains. Beyond geographic and topical diversity, the tasks also encompass temporal analyses, comparative evaluations across groups or categories, and relational reasoning, ensuring that agents are tested on a variety of reasoning modes.
+
+ \item{\bf{Robustness Against Memorisation}}: Similar to , we ensured that the tasks are explicitly constructed to mitigate data contamination and prevent superficial memorisation. The gold-standard answers are intentionally built to be non-retrievable through verbatim lookup in known pre-training corpora or direct web search, compelling systems to plan and perform multi-step reasoning to derive the correct output.
+
+\end{enumerate}
+
+
+\subsection{Data Collection}\label{sec:data_collection}
+
+
+A common practice in designing deep agentic benchmarks is to start with a fact and then craft a question from it, making the answer difficult to locate . Since our goal was to ensure answers are non-retrievable, we adopted a different approach. Building \ourdata involved four key steps: (a) identifying data sources, (b) gathering hypotheses, (c) performing analyses, and (d) formulating tasks (see Figure~\ref{fig:data_collection}).
+
+
+\paragraph{Data Source Identification.} In this step (see Figure~\ref{fig:data_collection}, left), we engaged $16$ human experts\footnote{Details about the annotators are provided in Appendix~\ref{sec:Annotator_details}.} to propose a diverse set of data sources and topics, drawing on their expertise, demographic backgrounds, and interests. Given the complexity of the annotation process and the need for efficient coordination, participation was restricted to individuals with whom we maintained direct communication, along with the paper’s core authors. We collected $223$ data sources across $7$ domains (\textit{socio-economic, finance, environment, science, education, transportation, political/socio-political}).
+We excluded data sources that originated from untrustworthy or non-official websites, including those requiring user authentication, as well as sources containing information that contradicted other verified references. Our objective was to curate tasks that are useful to individuals or groups; therefore, we filtered data sources to retain only those from which useful, verifiable insights could be drawn. For example, we included official statistical reports on \textit{``the gender gap in labour force participation rates in Australia”, ``computer and digital literacy rates in Sri Lanka'',} and \textit{``air quality and pneumonia-related deaths across regions in the UK''}, since such data enables clear downstream reasoning tasks (e.g., analyzing temporal trends, comparing across regions, or correlating with policy interventions).
+
+\paragraph{Hypothesis Generation.} We then asked annotators to formulate one or two hypotheses—plausible insights that could be inferred from the selected data sources (see Figure~\ref{fig:data_collection} bottom left). The objective of this step was to elicit hypotheses that are both insightful and practically valuable, encouraging reasoning beyond surface-level fact retrieval (see \S~\ref{sec:criteria}(e)). For example, one such hypothesis was: \textit{“Is there a linear relationship between air quality and pneumonia-related deaths across regions in the UK?”}. Data sources that did not meet the criteria of \textit{usefulness} and \textit{insightfulness} (see \S~\ref{sec:criteria}(b)) were subsequently filtered out.\footnote{Please note this step involves a degree of subjectivity, and we relied on the domain knowledge and judgment of our annotators to ensure the quality of the retained data sources and hypotheses.} After this step, we retained a total of $155$ data sources, each paired with its corresponding set of hypotheses.
+
+\paragraph{Hypothesis Validation.} In this step, annotators were tasked with conducting a detailed analysis of each data source to assess the validity of the proposed hypotheses (see Figure~\ref{fig:data_collection} top right). The objective was twofold: (i) to verify whether the data supported the hypotheses, and (ii) to derive tasks with \textit{verifiable} answers (see \S~\ref{sec:criteria}(c)). Hypotheses that failed to meet the verifiability criterion were refined or discarded. Following this validation and filtering process, we retained $130$ data sources, each paired with its corresponding, verified hypothesis.
+
+\paragraph{Task Formulation.} Finally, annotators were asked to formulate task questions along with intermediate steps, supporting evidence and corresponding answers. We note that the intermediate steps indicate only one possible reasoning path or planning from question to answer, and that no model or agent necessarily needs to imitate that path. Since \ourdata tasks often rely on multiple pieces of supporting evidence and reference various documents or tables, annotators were instructed to provide the URLs where the data sources can be accessed. Additionally, they were asked to include a brief explanation of how the task can be solved, specifying any tools, code snippets, or mathematical formulas used in the solution. We provide more examples and additional statistics in \S{\ref{examples}}.
+
+\paragraph{Data Validation.} All questions went through a second annotation stage, where another annotator independently answered the question. Only tasks where the answers from both annotators were identical were retained in the dataset, leaving finally $120$ challenging information synthesis tasks.
+
+
+\subsection{Data Statistics}
+
+Table~\ref{tab:dataset_stats} summarises the key statistics of our benchmark. Tasks in \ourdata are highly detailed, with an average length of $78.49$ tokens, an average of $7.54$ intermediate reasoning steps and requiring navigation through an average of $4.2$ web pages to reach a solution. Additionally, on average, formulating each task (from data source identification to task formulation) took the annotators approximately 5.5 hours. This number highlights the challenge in creating such tasks. Overall, all these numbers underscore the inherent complexity and challenge of the benchmark. Moreover, the tasks encompass a diverse range of analytical and reasoning skills, including correlation analysis, anomaly detection, and identification of causal or linear relationships — as reflected in Table~\ref{tab:dataset_stats}. Table~\ref{tab:regional_data} presents the regions covered by our benchmark, along with the percentage of tasks corresponding to each region. Notably, the benchmark comprises a higher proportion of tasks from Europe and Asia, with some tasks spanning multiple countries and regions. Figure~\ref{fig:task_distribution} provides an overview of the capabilities required by agents to solve the benchmark and their prevalence in tasks. In particular, we observe that web search and browsing are the most critical skills for retrieving the correct information.
+
+
+\section{Evaluation Setup}\label{sec:evaluation_setup}
+
+
+\paragraph{Models.}
+We use \ourdata to benchmark five state-of-the-art models: (a) o4-mini , (b) GPT-4.1 , (c) GPT-5 , (d) Gemini-2.5-Pro and (e) DeepSeek-R1 .
+For Gemini-2.5-Pro, we use “dynamic thinking”, where the model decides how much to think. GPT-5 was evaluated using “high reasoning effort”.
+
+We also investigate the performance of three state-of-the-art (deep research) agentic frameworks:
+(a) o3-deep-research ; (b) smolagents , which is a minimalist framework focused on simplicity and rapid prototyping. It uses a standard ReAct loop and its primary distinguishing feature is that it expresses all actions, such as tool use, as code, which is parsed out of the response and executed ; (c) OWL , which employs a role-playing strategy where a planner and an executor collaboratively solve tasks, optionally augmented with smaller, more specialised 'workers'.
+Both OWL and smolagents have been open-sourced. The details of their tool capabilities are listed in Table {\ref{tab:framework_capabilities}}. All models were prompted using the same instructions, provided in Appendix \ref{sec:prompt}.
+
+\paragraph{Metrics.} All tasks require models to generate outputs in a JSON format (or lists of JSON objects). Our strictest metric is \textit{exact match}, meaning that all keys and values must be correct. For partial evaluation, we check how many \textit{key-value pairs} are correct (out of the total pairs) and report precision, recall and F1-score. As an additional 'soft' metric, we follow and leverage the LLM-as-a-judge (with an identical prompt, see Fig. \ref{fig:judge_prompt}) reporting average precision. This serves two purposes: 1) for small string differences (with semantic equivalence), this method will reward answers beyond exact match, 2) in case of numerical answers, a small margin (1\% to 5.5\% difference) can still be considered correct, hence providing more granular and permissible scores.
+
+
+\section{Results}
+
+
+\subsection{Main Results}
+Table~\ref{tab:main_results} shows the performance of SOTA models on \ourdata. We first evaluate the parametric knowledge and reasoning capabilities of LLMs. The results show that GPT-5.2-Pro achieves the highest F1 score of $8.70$, and both GPT-5.2-Pro and DeepSeek-R1-Reasoner achieve the highest LLM Judge score of $6.67$, indicating substantial room for improvement. Interestingly, the performance gap between reasoning models (e.g. Gemini-2.5-Pro, GPT-5.1, DeepSeek-R1) and general-purpose LLMs (e.g., GPT-4.1) is relatively small {on F1 score}. This finding suggests that the key bottleneck lies not in reasoning ability alone, but in the availability of the necessary information for reasoning. We investigate this observation in greater depth in Analysis; see \S{\ref{sec:analysis}}. Further, under the strict exact-match metric, we observe that almost all models obtain a score of zero, indicating that none can solve even a single task perfectly.
+The poor performance of base LLMs indicates that internal retrieval of parametric knowledge is insufficient, showing that these tasks are robust against memorisation (see criteria \S{\ref{sec:criteria}}(e)).
+This also highlights the need to augment these models with external tools.
+
+To investigate this further, we evaluated our benchmark using three agentic frameworks that integrate external tools, including simulated web browsing, web search, and a code interpreter. We find that o3–deep-research, which incorporates web search and an executable code interpreter, outperforms the base o3 model by $5.68$ F1 score and $2.50$ EM. Furthermore, smolagents and OWL achieve some gains, with improvements of $0.29$ and $1.95$ F1 points and $2.5$ and $1.67$ EM points respectively, over the base GPT-4.1. Overall, we observe that all systems perform poorly. These findings emphasise that effectively solving tasks in \ourdata requires enhanced tool-use capabilities. Interestingly, we find that low precision indicates that all models frequently produce incorrect or extraneous answers.
+
+\paragraph{DEEPSYNTH-Dev Results.} Figure ~\ref{fig:dev_results_pass1} presents results on the \textsc{DeepSynth}-Dev subset. Among standalone LLMs, GPT-5.2-Pro achieves the highest F1 score (15.6), while Gemini-Pro-3 leads on the LLM-Judge metric (15.0), suggesting it produces semantically reasonable outputs that strict matching penalizes. Among agents, o3-deep-research attains the highest LLM-Judge score (20.0), reinforcing that tool augmentation benefits synthesis-heavy tasks. We observe a consistent gap between LLM-Judge and F1 scores across all models. Our manual evaluation suggests that this discrepancy primarily arises from failures to produce numerically precise or structurally exact outputs.
+
+\paragraph{Best-of-N and Self-Consistency Analysis.}
+Figure ~\ref{fig:dev_results_best_n} examines whether multiple attempts improve task completion on \textsc{DeepSynth}-Dev. Under Best@5, Smolagents (GPT-4.1) reaches 25.0\% LLM-Judge accuracy compared to 17.5\% for GPT-4.1, suggesting that tool-use introduces beneficial variance across runs. However, self-consistency (majority voting at $N{=}5$) yields only 5\% accuracy for both systems, with low average consistency scores (0.27), indicating that correct answers rarely emerge as the majority prediction. The stark contrast between Best@5 and self-consistency (27.5\% vs.\ 5\% for Smolagents) demonstrates that current agents exhibit high output
+variance on \textsc{DeepSynth} tasks. Occasional runs succeed, but models lack the reliability needed for consistent, correct answers.
+
+
+\paragraph{Ablation Study.} To assess the role of different capabilities on \ourdata, we perform an ablation study. As shown in Table~\ref{tab:ablation_analysis} (top), performance shows consistent declines across all metrics when any capability is removed, with the largest drop ($1.81$ F1 points) observed when search is excluded. While the overall changes are modest due to the low baseline performance, these trends indicate that document processing, code execution, and search each contribute to task success, highlighting the multifaceted challenges posed by \ourdata.
+
+
+\section{Analysis}\label{sec:analysis}
+
+
+In order to understand the challenges of solving \ourdata questions, we analyse performance across different data collection strategies, followed by a qualitative analysis of model errors.
+
+\paragraph{RQ$_1$:} \textbf{How do models perform as the number of intermediate steps increases?}
+We break down the models' performance based on the number of intermediate steps entailed by \ourdata tasks. Figure~\ref{fig:intermediate_steps} presents the performance breakdown, highlighting that all models struggle as the number of intermediate steps increases, which can be considered an indicator of the task's complexity. Notably, the agentic frameworks (o3-deep research and smolagents + GPT-5) perform better for $11$-$15$ intermediate steps, while they are on par with other LLMs for smaller numbers of intermediate answers. Given that tasks in \ourdata require an average of $7.54$ intermediate steps, these results provide insights into why the benchmark is so challenging.
+
+\paragraph{RQ$_2$:} \textbf{Does providing agents with intermediate steps improve their performance?} We evaluate how agents perform when they are provided with the ground truth intermediate reasoning steps (i.e. planning) without revealing the intermediate answers. As shown in Table~\ref{tab:ablation_analysis}, model performance improves substantially under this setting, with GPT-4.1 and smolagents + GPT-4.1 showing large gains. Both EM and F1 scores increase, indicating that models appear to lack planning capabilities.
+
+
+\paragraph{RQ$_3$:} \textbf{Which synthesis operations are more challenging?}
+To further assess the models’ analytical capabilities, we examine their performance on different synthesis operations when intermediate steps are provided alongside the task questions (see Table{\ref{tab:dataset_stats}, \ref{tab:synthesize_description}}). Figure~\ref{fig:performance_task_types} presents the results across various operation types, revealing substantial variation in task-specific performance. More specifically, we observe that o3 model achieves the highest F1 score in anomaly detection ($26.51$\%), significantly outperforming the other agents, while Gemini-2.5-Pro and smolagents + GPT-4.1 exhibit moderate gains over GPT-4.1 across most task categories. Trend detection and ranking also demonstrate relatively strong performance for Gemini-2.5-Pro and o3, indicating that these models can effectively capture certain structured patterns. In contrast, none of the models exhibit measurable performance on filtering tasks, which may partly reflect the limited number of filtering tasks in the benchmark (see Table~\ref {tab:dataset_stats}). Overall, these findings suggest that, although some agents can successfully identify anomalous or structured patterns, significant improvements are required for tasks involving arithmetic, comparative reasoning, or complex multi-step analysis.
+
+
+\paragraph{RQ$_4$:} \textbf{What types of errors do models commonly make?} To better understand the challenges in solving \ourdata, we manually analysed a random subset of $32$ tasks\footnote{Subset chosen due to the time and cost of manually analysing all outputs.} in which OWL + GPT-4.1 made errors\footnote{Two annotators who were not involved in the original data annotation conducted this analysis.}.
+We focus on OWL because, as an open-source framework, it enables detailed examination of execution traces and interactions between agents and tools. We categorize errors into four types, with their frequencies summarized in Table~\ref{tab:error_stats}: (1) \textit{Navigation errors} – when the agent fails to locate or access the correct source of information, such as navigating to the wrong web page, document, or section; (2) \textit{No Answer} – when the agent does not respond or fails to generate any output; (3) \textit{Technical Issue} – errors caused by system limitations, software bugs, or tool malfunctions that prevent task completion, independent of reasoning or navigation; and (4) \textit{Synthesis Error} – when the agent reaches an incorrect conclusion despite accessing the correct information, due to flaws in logical reasoning, interpretation, or multi-step analytical processes.
+
+This analysis is multi-label, as a single instance may exhibit multiple error types. The majority of errors—15/32 due to navigation and 16/32 due to reasoning—highlight that \ourdata presents significant challenges even for state-of-the-art open-source models.
+Figure~\ref{fig:qualitative_example} illustrates a failure case of OWL,
+in which the correct URL was found, but the agent fails to interact correctly with the website and its database interface.
+
+
+\paragraph{RQ$_5$:} \textbf{How do agents perform on tasks from different regions?} We observe that o$3$-deep research exhibits the most consistent cross-regional capability, particularly in the high-volume areas such as Europe and Asia. Notably, all models fail on Africa-related tasks, achieving an F1 score of $0.0$. These findings highlight the presence of strong geographical biases in current models and suggest that their performance is not globally uniform, likely reflecting imbalances in the distribution and coverage of their training data. Since \ourdata contains a diverse set of tasks from multiple regions, it naturally increases the overall difficulty of the benchmark.
+
+
+\section{Conclusion}
+
+
+We presented \ourdata bench, a new benchmark comprising $\numtask$ challenging and diverse tasks across $67$ countries. By combining planning, tool use, and multi-step reasoning, \ourdata aims to evaluate the ability of agents to move beyond shallow retrieval and engage in goal-directed, information-rich problem solving.
+\ourdata was inspired by real-world problems, and its tasks were designed to be strictly verifiable, geopolitically diverse, and robust against memorisation.
+Our experiments demonstrated the difficulty of our benchmark, with both state-of-the-art LLMs and specialized deep research agents struggling to solve any significant number of tasks. The best of the former (Gemini-Pro-2.5) achieved an F1 score of only $6.25$ with no task reaching a perfect score, while the best of the latter (o3-deep-research) reached $8.97$.
+These results help establish that there is substantial room for improvement on multi-source information synthesis, and we hope \ourdata will inspire future work, starting with improving navigation and synthesis, and addressing the significant geopolitical biases we observed.
+
+
+\newpage
+
+\appendix
+\section{Appendix}
+
+
+\subsection{More Results and Analysis }
+
+This section collects some additional results and analysis. Specifically:
+
+Table~\ref{tab:time_results} shows how long was required for state-of-the-art LLMs and specialized deep research agents to run \ourdata bench.
+
+Table~\ref{tab:rq3_intermediate} presents the intermediate step accuracy and error propagation on the \ourdata-Dev tasks.
+
+
+Table~\ref{tab:cost} summarises the cost and output token characteristics of the models evaluated in our experiments. For models that produce structured multi-stage reasoning traces, we report both reasoning-token ranges and final completion-token ranges. Costs correspond to the total API price per full run of a \ourdata task.
+
+Table~\ref{tab:framework_capabilities} presents a brief comparison across the Agentic Framework tool capabilities of the specialized deep research agents we apply to \ourdata bench .
+
+Table~\ref{tab:synthesize_description} provides definitions and examples on the key information synthesis operations in \ourdata's tasks.
+
+
+Table~\ref{tab:ablation} collects F1-score, Precision, Recall and EM scores to highlight the role of planning intermediate steps on LLM models.
+
+
+Table~\ref{tab:dev_results} presents the performance comparison on the \textsc{DEEPSYNTH}-Dev benchmark (Pass@1).
+
+
+Finally, Figure~\ref{fig:qualitative_example} shows an example run using the OWL framework, and illustrates errors when trying to collect and reason about data.
+
+
+\paragraph{Process Evaluation}
+
+Recently, several works have shown that LLMs make mistakes in their intermediate reasoning steps and can be unfaithful to their own reasoning . argued that outcome-only metrics are insufficient for critical applications and proposed compliance checklists to verify that agents follow recommended protocols. Motivated by these findings, we evaluate intermediate step accuracy by requiring models to emit structured outputs after each decomposition sub-step. While end-to-end F1 scores capture overall performance, they obscure \textit{where} in the reasoning chain failures originate and whether errors at early stages propagate to corrupt downstream computation. We evaluate three models: GPT-4.1, DeepSeek-R1, and GPT-5.2 on 40 \textsc{DeepSynth} tasks, scoring each intermediate output against its corresponding gold answer using entity-normalized F1 with format normalization to handle structural variation between predicted and gold JSON outputs. GPT-4.1 and DeepSeek-R1 operate without web access as instruction-following models, while GPT-5.2 operates with web search enabled via the Responses API.
+
+Table~\ref{tab:rq3_intermediate} presents per-step F1 and error propagation rates. All three models exhibit a steep accuracy decay: retrieval steps (steps 1--2) achieve 2--12\% F1, indicating partial but incomplete data acquisition, while computation and reasoning steps (steps 3+) collapse to near zero. Error propagation is near-total---when a step fails (F1 $< 50$), the subsequent step also fails 91--100\% of the time, with recovery rates below 10\%. This confirms that the low end-to-end F1 scores reported in Table~\ref{tab:main_results} are driven primarily by early retrieval failures that cascade irrecoverably through the reasoning chain.
+
+A notable divergence emerges between models. Among instruction-following models, DeepSeek-R1 achieves the highest intermediate accuracy at early steps (11.2\% at step 1 vs.\ 10.0\% for GPT-4.1) and the highest final-answer F1 (20.1\%), suggesting that its extended chain-of-thought reasoning provides a modest advantage in producing more accurate intermediate data. However, GPT-5.2 presents a strikingly different profile: despite having access to web search, it achieves the \textit{lowest} intermediate step accuracy (4.1\% at step 1) while maintaining comparable final F1 (16.7\%). Qualitative analysis of GPT-5.2's intermediate outputs reveals the cause of this apparent paradox. Rather than producing approximate values, GPT-5.2 performs genuine web search: correctly identifying target databases, API endpoints, indicator codes, and download URLs, but reports structured failures when its execution environment cannot process the retrieved sources (e.g., JavaScript-rendered tables, binary \texttt{.xlsx} files, or bulk data downloads requiring interactive queries).
+
+
+\newpage
+\subsection{Datacard and Annotation Guidelines}\label{sec:Annotator_details}
+
+\ourdata currently spans 67 unique countries, including
+Afghanistan, Algeria, Australia, Austria, Belgium, Bhutan, Brazil, Brunei, Cambodia, Cameroon, Canada, Chile, China, Czech Republic, Denmark, Estonia, Fiji, Finland, France, Germany, Ghana, Greece, Greenland, Hungary, Iceland, India, Indonesia, Italy, Japan, Laos, Latvia, Lebanon, Liechtenstein, Lithuania, Luxembourg, Malaysia, Maldives, Myanmar, Nepal, Netherlands, New Zealand, Nigeria, Norway, Pakistan, Peru, Philippines, Poland, Portugal, Qatar, Singapore, Slovakia, South Africa, South Korea, Spain, Sri Lanka, Sweden, Switzerland, Taiwan, Tajikistan, Thailand, Tunisia, Turkmenistan, United Kingdom, United States, Uzbekistan, Vietnam, and Zimbabwe.
+
+
+\paragraph{Annotator Demographics.}
+We provide additional information that may be relevant for analysing this dataset. Building \ourdata required the work of expert annotators, who devised the task questions and their answers, and who independently annotated the questions to assess their non-ambiguity. We have \textbf{81.25}\% of the annotator PhD holders. Both come from the following
+population:
+\begin{enumerate}
+ \item \textbf{Age}:
+ \begin{enumerate}
+ \item 18 - 25 : 12\%
+ \item 26 - 35 : 68\%
+ \item 36 - 45 : 18\%
+ \end{enumerate}
+ \item \textbf{Gender}: 25\% Female, 75\% Male
+ \item \textbf{Nationality}: India, Greece, Luxembourg, Slovakia, UK, China, Peru, Romania, Turkey, Kosovo, Germany
+ \item \textbf{Academic Background}:
+ \begin{enumerate}
+ \item Bachelor's Degree: 6.25\%
+ \item Master's Degree: 12.5 \%
+ \item PhD : \textbf{81.25\%}
+ \end{enumerate}
+\end{enumerate}
+
+
+The guidelines that were given to the annotators are presented in Figures~\ref{fig:annotation_guid_1} and \ref{fig:annotation_guid_2}. The goal of this benchmark is to evaluate the capability of state-of-the-art LLM-based agents to perform information synthesis and web-based navigation across diverse real-world sources. Accordingly, our design focuses on capturing variation in web content across regions rather than enforcing a uniformly balanced annotator demographic. While annotators were drawn from 11 countries across three continents, the tasks themselves cover \textbf{42} countries, and the associated webpages span a broad range of regional domains. As the benchmark evaluates an agent’s ability to search, retrieve, and synthesise information from heterogeneous sources, the demographic composition of annotators does not influence the underlying skill being measured.
+
+
+\paragraph{}
+
+
+\subsection{Examples}\label{examples}
+
+
+In this section (see Table~\ref{tab:examples}), we present some representative examples from \ourdata bench. We omit some information, e.g. the reasoning trace and intermediate steps, to prevent task leakage.
+
+
+\subsection{More Details about Evaluation}
+\paragraph{F1 and LLM-Judge Metrics.} {F1 in our benchmark is computed using exact string and numeric matching across all fields of the required JSON output. This makes it very strict: even minor deviations (a missing key, a slightly different string form, or a small numerical mismatch) reduce the score sharply. In contrast, the LLM-judge is a soft metric designed to capture partial semantic correctness. It (a) rewards outputs that are semantically equivalent despite surface-level differences (e.g., ``U.S.'' vs.\ ``United States''), and (b) tolerates small numerical deviations (approximately 1\%--5.5\%), providing a more graded signal of correctness than F1.}
+
+
+\paragraph{Why EM and LLM Scores?} {Exact Match (EM) is well-suited for our benchmark because over 95\% of the answers are numeric and all keys correspond to unambiguous factual fields. In this setting, strict matching provides a reliable signal of correctness: either the model produces the correct value for each key or it does not. EM is also deterministic and stable, avoiding the variability or hallucination-related errors that can arise with LLM-based judges.}
+
+{To complement this strict measure, we additionally use an LLM-based judge that evaluates softer, semantic aspects of the output. This score captures cases where the reasoning is sound and the answers are approximately correct but differ slightly in phrasing or small numerical deviations. Together, EM and the LLM score offer a balanced evaluation: one measures exact factual accuracy, while the other captures approximate correctness and reasoning fidelity.}
+
+\paragraph{Evaluation Example}
+
+{Below we illustrate how EM, F1, and the LLM score behave under different model outputs.}
+
+\begin{itemize}
+ \item {\textbf{Ground truth:} \{``India'': 4.5, ``China'': 7.8, ``U.S.'': 10.5\}}
+\end{itemize}
+
+\noindent\textbf{Model 1 output:}\\
+{\{``India'': 3.6, ``China'': 8.7, ``U.S.'': 10.5\}\\
+\textbf{Scores:} EM = 0.0;\; F1 = 33.3;\; LLM Score = \textbf{1.0}}
+
+\vspace{0.7em}
+\noindent\textbf{Model 2 output:}\\
+{\{``India'': 3.6, ``United States'': 10.5, ``China'': 8.7\}\\
+\textbf{Scores:} EM = 0.0;\; F1 = 0.0;\; LLM Score = \textbf{1.0}}
+
+\vspace{0.7em}
+\noindent\textbf{Model 3 output:}\\
+{\{``India'': 4.5, ``U.S.'': 10.5, ``China'': 7.8\}\\
+\textbf{Scores:} EM = 1.0;\; F1 = 100;\; LLM Score = \textbf{1.0}}
+
+\vspace{0.7em}
+\noindent\textbf{Model 4 output:}\\
+{\{``India'': 100.7, ``U.S.'': 100.6, ``China'': 7.8\}\\
+\textbf{Scores:} EM = 0.0;\; F1 = 33.3;\; LLM Score = 0.0}
+
+
+\subsection{Prompts}\label{sec:prompt}
+
+In this section, we provide the instructions and prompts used across all models; see Figures~\ref{fig:judge_prompt} and \ref{fig:judge_prompt2}.
+
+
+\end{document}

benchmark_dataset/papers/ICLR2026_0006_2602.21143/source_extracted.tex

@@ -0,0 +1,151 @@
+\begin{abstract}
+
+
+Large language model (LLM)-based agents are increasingly used to solve complex tasks involving tool use, such as web browsing, code execution, and data analysis. However, current evaluation benchmarks do not adequately assess their ability to solve real-world tasks that require synthesizing information from multiple sources and inferring insights beyond simple fact retrieval. To address this, we introduce \ourdata, a novel benchmark designed to evaluate agents on realistic, time-consuming problems that combine information gathering, synthesis, and structured reasoning to produce insights. \ourdata contains $\numtask$ tasks collected across $7$ domains and data sources covering {$67$} countries. \ourdata is constructed using a multi-stage data collection pipeline that requires annotators to collect official data sources, create hypotheses, perform manual analysis, and design tasks with verifiable answers. {When evaluated on \ourdata, {$11$} state-of-the-art LLMs and deep research agents achieve a maximum F1 score of $8.97$ and $17.5$ on the LLM-judge metric, underscoring the difficulty of the benchmark}. Our analysis reveals that current agents struggle with hallucinations and reasoning over large information spaces, highlighting \ourdata as a crucial benchmark for guiding future research.
+
+
+\end{abstract}
+\section{Introduction}
+
+
+\textit{Information synthesis} involves collecting information from multiple sources and reasoning over it to form coherent insights. While this capability has been central to human decision-making and has driven advances in fields ranging from scientific discovery to policy development , it has traditionally been laborious and cognitively demanding. For example, a travel agency from Singapore might want to know ``\textit{Which non-ASEAN countries experienced a significant post-COVID recovery — reaching at least 95\% of their 2019 visitor arrival levels to Singapore by 2023, and what were the main reasons for travel (business or tourism)?''} a question that requires identifying ASEAN countries, extracting multiple arrival data from various sources, and analysing them to determine the answer (see Figure~\ref{fig:intro}).
+Recent Large Language Model (LLM)-based agents with capabilities for reasoning, tool use, and interaction across diverse environments have shown promise in complex tasks, such as for hard-to-find information , interacting with websites , and planning to navigate the web .
+However, these developments mostly improve the information-seeking capabilities of agents. It remains crucial to evaluate whether such agents can solve real-world tasks that require synthesizing information from multiple sources and inferring insights beyond simple fact retrieval.
+
+Despite the substantial promise of LLM-based agents for addressing real-world tasks, most existing benchmarks primarily emphasise shallow fact retrieval tasks , artificial information-seeking questions , or tasks that require information from a single, particularly well-known source like Wikipedia .
+Furthermore, most agentic benchmarks focus on English-language sources and overlook the diversity of regional contexts, languages, and information ecosystems, limiting their ability to evaluate agent performance in realistic, globally distributed settings.
+
+
+To resolve this gap, we introduce \ourdata benchmark, a new benchmark comprising \numtask challenging and diverse tasks, aimed to evaluate the ability of agents to browse the entire web, combine information from unstructured and structured sources (paragraphs and tables) across $67$ countries, and perform analysis to synthesize new information and insights. \ourdata tasks are annotated with a gold standard, manually annotated reasoning chain, which includes all the intermediate steps, answers and all required supporting evidence. Each task requires agents to navigate an average of $4.2$ web pages, and read between $1$ to $15$ documents and/or tables. These tasks are designed to reflect real-world analysis and insight generation, with an emphasis on the time-intensive nature of processing and integrating information (see Figure~\ref{fig:intro}).
+
+To construct \ourdata, we asked $16$ experts to first curate relevant topics and data sources targeting various countries (\S{\ref{sec:data_collection}}), and subsequently formulate possible hypotheses for each of these data sources. Based on the hypotheses, the experts conducted analyses and derived insights. Finally, drawing on their analyses, they formulated the corresponding questions, answers, and step-by-step reasoning chains.
+In our experiments, we find that state-of-the-art LLMs — including recent AI reasoning models GPT-5, DeepSeek-R1 , struggle on \ourdata. The best-performing model, Gemini-Pro-2.5, achieves only an F1 score of $6.25$, with no task attaining a perfect score under the stricter EM metric. We also analyse the performance of specialised deep research agents, i.e.\ o3-deep-research, smolagents, and OWL , and observe they successfully solve only three out of 120 tasks, further underscoring the difficulty of our benchmark. Our analysis reveals that (i) these agents frequently commit navigation and synthesis errors, and (ii) their performance drops sharply when tasks require synthesising information from under-represented sources, e.g.\ data pertaining to the African region.
+
+
+To summarize, our main contributions are:
+\begin{enumerate}
+ \item We release \ourdata, a new benchmark for agents that contains $120$ real-world and time-consuming information synthesis tasks. \footnote{Our \href{https://huggingface.co/datasets/DeepSynthesisTeam/deepsynth-bench}{data} and \href{https://github.com/agentdeepsynthesis/deepsynth-bench}{code} for \href{https://agentdeepsynthesis.github.io/deepsynth.github.io/}{DeepSythn Bench} are publicly available}.
+ \item We show that \ourdata poses a significant challenge for state-of-the-art agents, revealing key limitations in their capabilities. The best-performing agent achieves only an F1 score of $8.97$ points, leaving substantial room for improvement.
+ \item We conduct an in-depth analysis to explain how \ourdata is challenging and demonstrate why current agents cannot yet be considered reliable systems for information synthesis.
+\end{enumerate}
+
+
+\section{The \ourdata Benchmark}
+
+
+\ourdata is a benchmark designed to evaluate agents on realistic, time-consuming tasks that require planning, information gathering, and synthesis from the web. Specifically, \ourdata evaluates agents on their ability to navigate multiple websites, extract information from both structured and unstructured sources, and reason effectively to produce correct solutions. It consists of {$\numtask$} tasks that are carefully designed and annotated by experts. Each task (see Figure~\ref{fig:intro}) is formulated to yield a concise output in the form of a JSON object or dictionary, with key-value pairs organised in a tabular style, thereby enabling straightforward and reliable verification. Solving these tasks requires agents to formulate plans, decompose problems into sub-steps, select and use appropriate external tools (e.g., document processors, code interpreters), and integrate intermediate results into a final solution.
+
+
+We now describe the process of constructing \ourdata. We first outline the criteria for our tasks, then describe our data collection pipeline, and conclude with an analysis of the collected data.
+
+\subsection{Criteria for \ourdata Tasks}\label{sec:criteria}
+
+
+Motivated by prior benchmarks , the design of \ourdata tasks is driven primarily by criteria that promote the future development of Agents' information seeking and synthesis capabilities towards practical and grounded goals. Specifically, our criteria consist of:
+
+
+\begin{enumerate}[label=\alph*)]
+
+ \item \textbf{Multi-source Information Synthesis}: Tasks should require agents to identify connections across multiple data sources or to combine information from them to produce a coherent solution. More specifically, tasks are designed such that agents must not only fetch relevant information but also perform subsequent operations on it (see Table~\ref{tab:dataset_stats}).
+
+ \item{\textbf{Inspired by the Real World}}: Experts were instructed to draw inspiration from real-world situations. The tasks are designed so that any resulting insights would conceivably be able to shape the decisions and actions of an individual or a group of people, such as \textit{political scientists, policy makers, travel agents, etc.}
+
+ \item{\bf{Verifiable Answers}}: A task that has a closed-form answer, which can be automatically verified and is stable over time, making it suitable for reproducible evaluation. While the answers to our tasks may be better suited to open-form answers, properly argued and grounded in citations, we necessarily restrict them to maintain their verifiability.
+
+ \item{\bf{Diversity}}: Our benchmark is designed to span a wide range of tasks, requiring agents to gather and reason over information across $67$ countries and $7$ distinct domains. Beyond geographic and topical diversity, the tasks also encompass temporal analyses, comparative evaluations across groups or categories, and relational reasoning, ensuring that agents are tested on a variety of reasoning modes.
+
+ \item{\bf{Robustness Against Memorisation}}: Similar to , we ensured that the tasks are explicitly constructed to mitigate data contamination and prevent superficial memorisation. The gold-standard answers are intentionally built to be non-retrievable through verbatim lookup in known pre-training corpora or direct web search, compelling systems to plan and perform multi-step reasoning to derive the correct output.
+
+\end{enumerate}
+
+
+\subsection{Data Collection}\label{sec:data_collection}
+
+
+A common practice in designing deep agentic benchmarks is to start with a fact and then craft a question from it, making the answer difficult to locate . Since our goal was to ensure answers are non-retrievable, we adopted a different approach. Building \ourdata involved four key steps: (a) identifying data sources, (b) gathering hypotheses, (c) performing analyses, and (d) formulating tasks (see Figure~\ref{fig:data_collection}).
+
+
+\paragraph{Data Source Identification.} In this step (see Figure~\ref{fig:data_collection}, left), we engaged $16$ human experts\footnote{Details about the annotators are provided in Appendix~\ref{sec:Annotator_details}.} to propose a diverse set of data sources and topics, drawing on their expertise, demographic backgrounds, and interests. Given the complexity of the annotation process and the need for efficient coordination, participation was restricted to individuals with whom we maintained direct communication, along with the paper’s core authors. We collected $223$ data sources across $7$ domains (\textit{socio-economic, finance, environment, science, education, transportation, political/socio-political}).
+We excluded data sources that originated from untrustworthy or non-official websites, including those requiring user authentication, as well as sources containing information that contradicted other verified references. Our objective was to curate tasks that are useful to individuals or groups; therefore, we filtered data sources to retain only those from which useful, verifiable insights could be drawn. For example, we included official statistical reports on \textit{``the gender gap in labour force participation rates in Australia”, ``computer and digital literacy rates in Sri Lanka'',} and \textit{``air quality and pneumonia-related deaths across regions in the UK''}, since such data enables clear downstream reasoning tasks (e.g., analyzing temporal trends, comparing across regions, or correlating with policy interventions).
+
+\paragraph{Hypothesis Generation.} We then asked annotators to formulate one or two hypotheses—plausible insights that could be inferred from the selected data sources (see Figure~\ref{fig:data_collection} bottom left). The objective of this step was to elicit hypotheses that are both insightful and practically valuable, encouraging reasoning beyond surface-level fact retrieval (see \S~\ref{sec:criteria}(e)). For example, one such hypothesis was: \textit{“Is there a linear relationship between air quality and pneumonia-related deaths across regions in the UK?”}. Data sources that did not meet the criteria of \textit{usefulness} and \textit{insightfulness} (see \S~\ref{sec:criteria}(b)) were subsequently filtered out.\footnote{Please note this step involves a degree of subjectivity, and we relied on the domain knowledge and judgment of our annotators to ensure the quality of the retained data sources and hypotheses.} After this step, we retained a total of $155$ data sources, each paired with its corresponding set of hypotheses.
+
+\paragraph{Hypothesis Validation.} In this step, annotators were tasked with conducting a detailed analysis of each data source to assess the validity of the proposed hypotheses (see Figure~\ref{fig:data_collection} top right). The objective was twofold: (i) to verify whether the data supported the hypotheses, and (ii) to derive tasks with \textit{verifiable} answers (see \S~\ref{sec:criteria}(c)). Hypotheses that failed to meet the verifiability criterion were refined or discarded. Following this validation and filtering process, we retained $130$ data sources, each paired with its corresponding, verified hypothesis.
+
+\paragraph{Task Formulation.} Finally, annotators were asked to formulate task questions along with intermediate steps, supporting evidence and corresponding answers. We note that the intermediate steps indicate only one possible reasoning path or planning from question to answer, and that no model or agent necessarily needs to imitate that path. Since \ourdata tasks often rely on multiple pieces of supporting evidence and reference various documents or tables, annotators were instructed to provide the URLs where the data sources can be accessed. Additionally, they were asked to include a brief explanation of how the task can be solved, specifying any tools, code snippets, or mathematical formulas used in the solution. We provide more examples and additional statistics in \S{\ref{examples}}.
+
+\paragraph{Data Validation.} All questions went through a second annotation stage, where another annotator independently answered the question. Only tasks where the answers from both annotators were identical were retained in the dataset, leaving finally $120$ challenging information synthesis tasks.
+
+
+\subsection{Data Statistics}
+
+Table~\ref{tab:dataset_stats} summarises the key statistics of our benchmark. Tasks in \ourdata are highly detailed, with an average length of $78.49$ tokens, an average of $7.54$ intermediate reasoning steps and requiring navigation through an average of $4.2$ web pages to reach a solution. Additionally, on average, formulating each task (from data source identification to task formulation) took the annotators approximately 5.5 hours. This number highlights the challenge in creating such tasks. Overall, all these numbers underscore the inherent complexity and challenge of the benchmark. Moreover, the tasks encompass a diverse range of analytical and reasoning skills, including correlation analysis, anomaly detection, and identification of causal or linear relationships — as reflected in Table~\ref{tab:dataset_stats}. Table~\ref{tab:regional_data} presents the regions covered by our benchmark, along with the percentage of tasks corresponding to each region. Notably, the benchmark comprises a higher proportion of tasks from Europe and Asia, with some tasks spanning multiple countries and regions. Figure~\ref{fig:task_distribution} provides an overview of the capabilities required by agents to solve the benchmark and their prevalence in tasks. In particular, we observe that web search and browsing are the most critical skills for retrieving the correct information.
+
+
+\section{Evaluation Setup}\label{sec:evaluation_setup}
+
+
+\paragraph{Models.}
+We use \ourdata to benchmark five state-of-the-art models: (a) o4-mini , (b) GPT-4.1 , (c) GPT-5 , (d) Gemini-2.5-Pro and (e) DeepSeek-R1 .
+For Gemini-2.5-Pro, we use “dynamic thinking”, where the model decides how much to think. GPT-5 was evaluated using “high reasoning effort”.
+
+We also investigate the performance of three state-of-the-art (deep research) agentic frameworks:
+(a) o3-deep-research ; (b) smolagents , which is a minimalist framework focused on simplicity and rapid prototyping. It uses a standard ReAct loop and its primary distinguishing feature is that it expresses all actions, such as tool use, as code, which is parsed out of the response and executed ; (c) OWL , which employs a role-playing strategy where a planner and an executor collaboratively solve tasks, optionally augmented with smaller, more specialised 'workers'.
+Both OWL and smolagents have been open-sourced. The details of their tool capabilities are listed in Table {\ref{tab:framework_capabilities}}. All models were prompted using the same instructions, provided in Appendix \ref{sec:prompt}.
+
+\paragraph{Metrics.} All tasks require models to generate outputs in a JSON format (or lists of JSON objects). Our strictest metric is \textit{exact match}, meaning that all keys and values must be correct. For partial evaluation, we check how many \textit{key-value pairs} are correct (out of the total pairs) and report precision, recall and F1-score. As an additional 'soft' metric, we follow and leverage the LLM-as-a-judge (with an identical prompt, see Fig. \ref{fig:judge_prompt}) reporting average precision. This serves two purposes: 1) for small string differences (with semantic equivalence), this method will reward answers beyond exact match, 2) in case of numerical answers, a small margin (1\% to 5.5\% difference) can still be considered correct, hence providing more granular and permissible scores.
+
+
+\section{Results}
+
+
+\subsection{Main Results}
+Table~\ref{tab:main_results} shows the performance of SOTA models on \ourdata. We first evaluate the parametric knowledge and reasoning capabilities of LLMs. The results show that GPT-5.2-Pro achieves the highest F1 score of $8.70$, and both GPT-5.2-Pro and DeepSeek-R1-Reasoner achieve the highest LLM Judge score of $6.67$, indicating substantial room for improvement. Interestingly, the performance gap between reasoning models (e.g. Gemini-2.5-Pro, GPT-5.1, DeepSeek-R1) and general-purpose LLMs (e.g., GPT-4.1) is relatively small {on F1 score}. This finding suggests that the key bottleneck lies not in reasoning ability alone, but in the availability of the necessary information for reasoning. We investigate this observation in greater depth in Analysis; see \S{\ref{sec:analysis}}. Further, under the strict exact-match metric, we observe that almost all models obtain a score of zero, indicating that none can solve even a single task perfectly.
+The poor performance of base LLMs indicates that internal retrieval of parametric knowledge is insufficient, showing that these tasks are robust against memorisation (see criteria \S{\ref{sec:criteria}}(e)).
+This also highlights the need to augment these models with external tools.
+
+To investigate this further, we evaluated our benchmark using three agentic frameworks that integrate external tools, including simulated web browsing, web search, and a code interpreter. We find that o3–deep-research, which incorporates web search and an executable code interpreter, outperforms the base o3 model by $5.68$ F1 score and $2.50$ EM. Furthermore, smolagents and OWL achieve some gains, with improvements of $0.29$ and $1.95$ F1 points and $2.5$ and $1.67$ EM points respectively, over the base GPT-4.1. Overall, we observe that all systems perform poorly. These findings emphasise that effectively solving tasks in \ourdata requires enhanced tool-use capabilities. Interestingly, we find that low precision indicates that all models frequently produce incorrect or extraneous answers.
+
+\paragraph{DEEPSYNTH-Dev Results.} Figure ~\ref{fig:dev_results_pass1} presents results on the \textsc{DeepSynth}-Dev subset. Among standalone LLMs, GPT-5.2-Pro achieves the highest F1 score (15.6), while Gemini-Pro-3 leads on the LLM-Judge metric (15.0), suggesting it produces semantically reasonable outputs that strict matching penalizes. Among agents, o3-deep-research attains the highest LLM-Judge score (20.0), reinforcing that tool augmentation benefits synthesis-heavy tasks. We observe a consistent gap between LLM-Judge and F1 scores across all models. Our manual evaluation suggests that this discrepancy primarily arises from failures to produce numerically precise or structurally exact outputs.
+
+\paragraph{Best-of-N and Self-Consistency Analysis.}
+Figure ~\ref{fig:dev_results_best_n} examines whether multiple attempts improve task completion on \textsc{DeepSynth}-Dev. Under Best@5, Smolagents (GPT-4.1) reaches 25.0\% LLM-Judge accuracy compared to 17.5\% for GPT-4.1, suggesting that tool-use introduces beneficial variance across runs. However, self-consistency (majority voting at $N{=}5$) yields only 5\% accuracy for both systems, with low average consistency scores (0.27), indicating that correct answers rarely emerge as the majority prediction. The stark contrast between Best@5 and self-consistency (27.5\% vs.\ 5\% for Smolagents) demonstrates that current agents exhibit high output
+variance on \textsc{DeepSynth} tasks. Occasional runs succeed, but models lack the reliability needed for consistent, correct answers.
+
+
+\paragraph{Ablation Study.} To assess the role of different capabilities on \ourdata, we perform an ablation study. As shown in Table~\ref{tab:ablation_analysis} (top), performance shows consistent declines across all metrics when any capability is removed, with the largest drop ($1.81$ F1 points) observed when search is excluded. While the overall changes are modest due to the low baseline performance, these trends indicate that document processing, code execution, and search each contribute to task success, highlighting the multifaceted challenges posed by \ourdata.
+
+
+\section{Analysis}\label{sec:analysis}
+
+
+In order to understand the challenges of solving \ourdata questions, we analyse performance across different data collection strategies, followed by a qualitative analysis of model errors.
+
+\paragraph{RQ$_1$:} \textbf{How do models perform as the number of intermediate steps increases?}
+We break down the models' performance based on the number of intermediate steps entailed by \ourdata tasks. Figure~\ref{fig:intermediate_steps} presents the performance breakdown, highlighting that all models struggle as the number of intermediate steps increases, which can be considered an indicator of the task's complexity. Notably, the agentic frameworks (o3-deep research and smolagents + GPT-5) perform better for $11$-$15$ intermediate steps, while they are on par with other LLMs for smaller numbers of intermediate answers. Given that tasks in \ourdata require an average of $7.54$ intermediate steps, these results provide insights into why the benchmark is so challenging.
+
+\paragraph{RQ$_2$:} \textbf{Does providing agents with intermediate steps improve their performance?} We evaluate how agents perform when they are provided with the ground truth intermediate reasoning steps (i.e. planning) without revealing the intermediate answers. As shown in Table~\ref{tab:ablation_analysis}, model performance improves substantially under this setting, with GPT-4.1 and smolagents + GPT-4.1 showing large gains. Both EM and F1 scores increase, indicating that models appear to lack planning capabilities.
+
+
+\paragraph{RQ$_3$:} \textbf{Which synthesis operations are more challenging?}
+To further assess the models’ analytical capabilities, we examine their performance on different synthesis operations when intermediate steps are provided alongside the task questions (see Table{\ref{tab:dataset_stats}, \ref{tab:synthesize_description}}). Figure~\ref{fig:performance_task_types} presents the results across various operation types, revealing substantial variation in task-specific performance. More specifically, we observe that o3 model achieves the highest F1 score in anomaly detection ($26.51$\%), significantly outperforming the other agents, while Gemini-2.5-Pro and smolagents + GPT-4.1 exhibit moderate gains over GPT-4.1 across most task categories. Trend detection and ranking also demonstrate relatively strong performance for Gemini-2.5-Pro and o3, indicating that these models can effectively capture certain structured patterns. In contrast, none of the models exhibit measurable performance on filtering tasks, which may partly reflect the limited number of filtering tasks in the benchmark (see Table~\ref {tab:dataset_stats}). Overall, these findings suggest that, although some agents can successfully identify anomalous or structured patterns, significant improvements are required for tasks involving arithmetic, comparative reasoning, or complex multi-step analysis.
+
+
+\paragraph{RQ$_4$:} \textbf{What types of errors do models commonly make?} To better understand the challenges in solving \ourdata, we manually analysed a random subset of $32$ tasks\footnote{Subset chosen due to the time and cost of manually analysing all outputs.} in which OWL + GPT-4.1 made errors\footnote{Two annotators who were not involved in the original data annotation conducted this analysis.}.
+We focus on OWL because, as an open-source framework, it enables detailed examination of execution traces and interactions between agents and tools. We categorize errors into four types, with their frequencies summarized in Table~\ref{tab:error_stats}: (1) \textit{Navigation errors} – when the agent fails to locate or access the correct source of information, such as navigating to the wrong web page, document, or section; (2) \textit{No Answer} – when the agent does not respond or fails to generate any output; (3) \textit{Technical Issue} – errors caused by system limitations, software bugs, or tool malfunctions that prevent task completion, independent of reasoning or navigation; and (4) \textit{Synthesis Error} – when the agent reaches an incorrect conclusion despite accessing the correct information, due to flaws in logical reasoning, interpretation, or multi-step analytical processes.
+
+This analysis is multi-label, as a single instance may exhibit multiple error types. The majority of errors—15/32 due to navigation and 16/32 due to reasoning—highlight that \ourdata presents significant challenges even for state-of-the-art open-source models.
+Figure~\ref{fig:qualitative_example} illustrates a failure case of OWL,
+in which the correct URL was found, but the agent fails to interact correctly with the website and its database interface.
+
+
+\paragraph{RQ$_5$:} \textbf{How do agents perform on tasks from different regions?} We observe that o$3$-deep research exhibits the most consistent cross-regional capability, particularly in the high-volume areas such as Europe and Asia. Notably, all models fail on Africa-related tasks, achieving an F1 score of $0.0$. These findings highlight the presence of strong geographical biases in current models and suggest that their performance is not globally uniform, likely reflecting imbalances in the distribution and coverage of their training data. Since \ourdata contains a diverse set of tasks from multiple regions, it naturally increases the overall difficulty of the benchmark.
+
+
+\section{Conclusion}
+
+
+We presented \ourdata bench, a new benchmark comprising $\numtask$ challenging and diverse tasks across $67$ countries. By combining planning, tool use, and multi-step reasoning, \ourdata aims to evaluate the ability of agents to move beyond shallow retrieval and engage in goal-directed, information-rich problem solving.
+\ourdata was inspired by real-world problems, and its tasks were designed to be strictly verifiable, geopolitically diverse, and robust against memorisation.
+Our experiments demonstrated the difficulty of our benchmark, with both state-of-the-art LLMs and specialized deep research agents struggling to solve any significant number of tasks. The best of the former (Gemini-Pro-2.5) achieved an F1 score of only $6.25$ with no task reaching a perfect score, while the best of the latter (o3-deep-research) reached $8.97$.
+These results help establish that there is substantial room for improvement on multi-source information synthesis, and we hope \ourdata will inspire future work, starting with improving navigation and synthesis, and addressing the significant geopolitical biases we observed.

benchmark_dataset/papers/ICLR2026_0006_2602.21143/source_references.tex

@@ -0,0 +1,96 @@
+@inproceedings{mialon2023gaia,
+  title={{GAIA: A benchmark for General AI Assistants}},
+  author={Mialon, Gr{\'e}goire and Fourrier, Cl{\'e}mentine and Wolf, Thomas and LeCun, Yann and Scialom, Thomas},
+  booktitle={The Twelfth International Conference on Learning Representations},
+  year={2023}
+}
+
+@inproceedings{yoran-etal-2024-assistantbench,
+    title = "{A}ssistant{B}ench: Can Web Agents Solve Realistic and Time-Consuming Tasks?",
+    author = "Yoran, Ori  and
+      Amouyal, Samuel Joseph  and
+      Malaviya, Chaitanya  and
+      Bogin, Ben  and
+      Press, Ofir  and
+      Berant, Jonathan",
+    editor = "Al-Onaizan, Yaser  and
+      Bansal, Mohit  and
+      Chen, Yun-Nung",
+    booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing",
+    month = nov,
+    year = "2024",
+    address = "Miami, Florida, USA",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.emnlp-main.505/",
+    doi = "10.18653/v1/2024.emnlp-main.505",
+    pages = "8938--8968",
+    abstract = "Language agents, built on top of language models (LMs), are systems that can interact with complex environments, such as the open web. In this work, we examine whether such agents can perform realistic and time-consuming tasks on the web, e.g., monitoring real-estate markets or locating relevant nearby businesses. We introduce AssistantBench, a challenging new benchmark consisting of 214 realistic tasks that can be automatically evaluated, covering different scenarios and domains. We find that AssistantBench exposes the limitations of current systems, including language models and retrieval-augmented language models, as no model reaches an accuracy of more than 25 points. While closed-book LMs perform well in terms of accuracy, they exhibit low precision and tend to hallucinate facts. State-of-the-art web agents reach a score of near zero. Additionally, we introduce SeePlanAct (SPA), a new web agent that significantly outperforms previous agents, and an ensemble of SPA and closed-book models reaches the best overall performance. Moreover, we analyze failures of current systems and highlight that open web navigation remains a major challenge."
+}
+
+@article{wei2025browsecomp,
+  title={{Browsecomp: A simple yet challenging benchmark for browsing agents}},
+  author={Wei, Jason and Sun, Zhiqing and Papay, Spencer and McKinney, Scott and Han, Jeffrey and Fulford, Isa and Chung, Hyung Won and Passos, Alex Tachard and Fedus, William and Glaese, Amelia},
+  journal={arXiv preprint arXiv:2504.12516},
+  year={2025}
+}
+
+@article{phan2025humanity,
+  title={Humanity's last exam},
+  author={Phan, Long and Gatti, Alice and Han, Ziwen and Li, Nathaniel and Hu, Josephina and Zhang, Hugh and Zhang, Chen Bo Calvin and Shaaban, Mohamed and Ling, John and Shi, Sean and others},
+  journal={arXiv preprint arXiv:2501.14249},
+  year={2025}
+}
+
+@inproceedings{
+wu2025mmqa,
+title={{MMQA}: Evaluating {LLM}s with Multi-Table Multi-Hop Complex Questions},
+author={Jian Wu and Linyi Yang and Dongyuan Li and Yuliang Ji and Manabu Okumura and Yue Zhang},
+booktitle={The Thirteenth International Conference on Learning Representations},
+year={2025},
+url={https://openreview.net/forum?id=GGlpykXDCa}
+}
+
+@article{wolfson-etal-2025-monaco,
+    title = {{MoNaCo: More Natural and Complex Questions for Reasoning Across Dozens of Documents}},
+    author = "Wolfson, Tomer  and
+      Trivedi, Harsh  and
+      Geva, Mor  and
+      Goldberg, Yoav  and
+      Roth, Dan  and
+      Khot, Tushar  and
+      Sabharwal, Ashish  and
+      Tsarfaty, Reut",
+    journal = "Transactions of the Association for Computational Linguistics",
+    address = "Cambridge, MA",
+    publisher = "MIT Press",
+    year="2025",
+}
+
+@inproceedings{
+jimenez2024swebench,
+title={{SWE}-bench: Can Language Models Resolve Real-world Github Issues?},
+author={Carlos E Jimenez and John Yang and Alexander Wettig and Shunyu Yao and Kexin Pei and Ofir Press and Karthik R Narasimhan},
+booktitle={The Twelfth International Conference on Learning Representations},
+year={2024},
+url={https://openreview.net/forum?id=VTF8yNQM66}
+}
+
+@article{chan2024mle,
+  title={Mle-bench: Evaluating machine learning agents on machine learning engineering},
+  author={Chan, Jun Shern and Chowdhury, Neil and Jaffe, Oliver and Aung, James and Sherburn, Dane and Mays, Evan and Starace, Giulio and Liu, Kevin and Maksin, Leon and Patwardhan, Tejal and others},
+  journal={arXiv preprint arXiv:2410.07095},
+  year={2024}
+}
+
+@article{ouyang2025kernelbench,
+  title={Kernelbench: Can llms write efficient gpu kernels?},
+  author={Ouyang, Anne and Guo, Simon and Arora, Simran and Zhang, Alex L and Hu, William and R{\'e}, Christopher and Mirhoseini, Azalia},
+  journal={arXiv preprint arXiv:2502.10517},
+  year={2025}
+}
+
+@inproceedings{starace2025paperbench,
+  title={{PaperBench: Evaluating AI’s Ability to Replicate AI Research}},
+  author={Starace, Giulio and Jaffe, Oliver and Sherburn, Dane and Aung, James and Chan, Jun Shern and Maksin, Leon and Dias, Rachel and Mays, Evan and Kinsella, Benjamin and Thompson, Wyatt and others},
+  booktitle={Forty-second International Conference on Machine Learning}
+}

benchmark_dataset/papers/ICLR2026_0006_2602.21143/source_related_work.tex

@@ -0,0 +1,25 @@
+\section{Related Work}
+
+
+\begin{table}[t]
+\centering
+
+\begin{tabular}{@{}l*{6}{c}@{}}
+\toprule
+\textbf{Dataset} & \textbf{\shortstack{Real \\ World}} & \textbf{\shortstack{Multi \\ Regional}} & \textbf{\shortstack{Information \\ Synthesis}} & \textbf{\shortstack{Multi-Part \\ Answers}} \\
+\midrule
+GAIA & \textcolor{gray}{\footnotesize partial} & \texttimes & \textcolor{gray}{\footnotesize partial} & \texttimes \\
+AssistantBench & \checkmark & \texttimes & \texttimes & \textcolor{gray}{\footnotesize partial} \\
+BrowseComp & \texttimes & \texttimes & \texttimes & \texttimes \\
+HLE & \textcolor{gray}{\footnotesize partial} & \textcolor{gray}{\footnotesize partial} & \textcolor{gray}{\footnotesize partial} & \texttimes \\
+\textbf{\ourdata} & \checkmark & \checkmark & \checkmark & \checkmark \\
+\bottomrule
+\end{tabular}\caption{Comparison of datasets on various reasoning and retrieval capabilities.}
+\label{tab:dataset_comparison}
+\end{table}
+
+
+As LLM-based agents improve in reasoning, tool usage, and interaction across diverse environments, researchers have sought to evaluate LLMs on questions that require multi-hop reasoning skills , code generation , information seeking and even general assistance capabilities . Table~\ref{tab:dataset_comparison} summarises the key differences among popular agentic benchmarks; most of these correspond to the criteria we considered in \S~\ref{sec:criteria} for \ourdata tasks' design. A distinctive feature of \ourdata is its multi-part answers, where each response comprises multiple components—e.g., a JSON object containing event causes (strings), percentages (floats), dates or years (integers)—with explicit logical links (e.g., key-value pairs). This structure makes the benchmark particularly challenging, as it requires agents to retrieve, reason, and integrate heterogeneous information correctly.
+
+
+Several existing benchmarks share partial overlap with \ourdata but lack a systematic evaluation of information synthesis. For instance, GAIA requires planning and information seeking but involves limited synthesis and less realistic tasks. BrowseComp is an information-seeking benchmark comprising challenging, invertedly constructed questions that require persistent, multi-hop web navigation to uncover hard-to-find facts; in contrast, \ourdata moves beyond retrieval to systematically evaluate information synthesis through multi-part, structured answers. AssistantBench addresses real-world gaps and includes limited multi-part answers, but omits other essential aspects. Humanity’s Last Exam offers precise, unambiguous, and non-searchable questions, yet these are often obscure and detached from real-world contexts. In contrast, \ourdata is, to the best of our knowledge, the first benchmark to systematically evaluate information synthesis across realistic, multi-step tasks.

benchmark_dataset/papers/ICLR2026_0007_2504.02327/metadata.json

@@ -0,0 +1,74 @@
+{
+  "paper_id": "ICLR2026_0007_2504.02327",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "LearNAT: Learning NL2SQL with AST-guided Task Decomposition  for Large Language Models",
+  "authors": [
+    "Weibin Liao",
+    "Xin Gao",
+    "Tianyu Jia",
+    "Rihong Qiu",
+    "Yifan Zhu",
+    "Yang Lin",
+    "Xinyu Ma",
+    "Junfeng Zhao",
+    "Yasha Wang"
+  ],
+  "domain_score": 25,
+  "domain_areas": [
+    "model_architecture",
+    "pretraining_posttraining_instruction_alignment",
+    "test_time_reasoning_compute",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "q6kXd8Gpfj",
+  "openreview_forum": "q6kXd8Gpfj",
+  "openreview_url": "https://openreview.net/forum?id=q6kXd8Gpfj",
+  "arxiv_id": "2504.02327",
+  "arxiv_id_versioned": "2504.02327v1",
+  "arxiv_abs_url": "http://arxiv.org/abs/2504.02327v1",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2504.02327v1",
+  "arxiv_source_url": "https://arxiv.org/e-print/2504.02327",
+  "arxiv_title": "LearNAT: Learning NL2SQL with AST-guided Task Decomposition for Large Language Models",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-04-03T06:59:44Z",
+  "arxiv_updated": "2025-04-03T06:59:44Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 1,
+  "status": "ok",
+  "main_tex_original_path": "arxiv.tex",
+  "expanded_inputs_count": 0,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "PromptEngineering",
+    "kim2020natural",
+    "SuperSQL",
+    "DAIL-SQL",
+    "DART-SQL",
+    "C3-SQL",
+    "MCS-SQL",
+    "CHESS",
+    "CHASE-SQL",
+    "DIN-SQL",
+    "MAC-SQL",
+    "HuggingGPT",
+    "zhang2023instruction",
+    "SENSE",
+    "DataGpt-SQL-7B",
+    "CodeS",
+    "SQL-PaLM",
+    "RESDSQL",
+    "feng2023alphazero",
+    "chen2024alphamath",
+    "xie2024monte",
+    "DPO",
+    "hwang2024selfexploreavoidpitimproving",
+    "liao2024tpo",
+    "setlur2024rlincorrectsyntheticdata",
+    "lai2024stepdpo"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0007_2504.02327/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73ad7a9d5158116b880d31b4cc1e48a498e23f3c72300f1aafe8db090e90121b
+size 2591711

benchmark_dataset/papers/ICLR2026_0007_2504.02327/source.tex

@@ -0,0 +1,537 @@
+\documentclass[sigconf, nonacm]{acmart}
+
+\newcommand\vldbdoi{XX.XX/XXX.XX}
+\newcommand\vldbpages{XXX-XXX}
+\newcommand\vldbvolume{14}
+\newcommand\vldbissue{1}
+\newcommand\vldbyear{2020}
+\newcommand\vldbauthors{}
+\newcommand\vldbtitle{\shorttitle}
+\newcommand\vldbavailabilityurl{URL_TO_YOUR_ARTIFACTS}
+\newcommand\vldbpagestyle{plain}
+
+\usepackage{enumitem}
+\usepackage{multirow}
+\usepackage{colortbl}
+\usepackage{graphicx}
+\usepackage{subcaption}
+\usepackage{makecell}
+\usepackage[normalem]{ulem}
+
+\usepackage{listings}
+
+\definecolor{sqlkeyword}{RGB}{152,65,150}
+\lstdefinelanguage{SQL}{
+ keywords={SELECT, FROM, WHERE, JOIN, ON, AS, EXCEPT, DISTINCT, INNER, ORDER BY, DESC, GROUP BY, CASE, END, WHEN, THEN, ELSE},
+ keywordstyle=\color{sqlkeyword},
+ sensitive=false,
+ morestring=[b]',
+ stringstyle=\color{black},
+}
+
+\usepackage{soul}
+\setulcolor{black}
+\newcommand{\lstul}[1]{\ttfamily\ul{#1}}
+\newcommand{\keywordul}[1]{{\ttfamily\setulcolor{black}\color{sqlkeyword}\ul{#1}}}
+\makeatother
+
+\definecolor{upperformance}{RGB}{207,62,62}
+\definecolor{downperformance}{RGB}{112,173,71}
+
+\newcommand{\TheName}{\texttt{LearNAT}}
+
+\begin{document}
+\begin{abstract}
+Natural Language to SQL (NL2SQL) has emerged as a critical task for enabling seamless interaction with databases. Recent advancements in Large Language Models (LLMs) have demonstrated remarkable performance in this domain. However, existing NL2SQL methods predominantly rely on closed-source LLMs leveraging prompt engineering, while open-source models typically require fine-tuning to acquire domain-specific knowledge. Despite these efforts, open-source LLMs struggle with complex NL2SQL tasks due to the indirect expression of user query objectives and the semantic gap between user queries and database schemas.
+Inspired by the application of reinforcement learning in mathematical problem-solving to encourage step-by-step reasoning in LLMs, we propose \TheName{} (\underline{Lear}ning \underline{N}L2SQL with \underline{A}ST-guided \underline{T}ask Decomposition), a novel framework that improves the performance of open-source LLMs on complex NL2SQL tasks through task decomposition and reinforcement learning. \TheName{} introduces three key components: (1) a \textit{Decomposition Synthesis Procedure} that leverages Abstract Syntax Trees (ASTs) to guide efficient search and pruning strategies for task decomposition, (2) \textit{Margin-aware Reinforcement Learning}, which employs fine-grained step-level optimization via DPO with AST margins, and (3) \textit{Adaptive Demonstration Reasoning}, a mechanism for dynamically selecting relevant examples to enhance decomposition capabilities.
+Extensive experiments on two benchmark datasets, Spider and BIRD, demonstrate that \TheName{} enables a 7B-parameter open-source LLM to achieve performance comparable to GPT-4, while offering improved efficiency and accessibility. Our work marks a significant step toward democratizing NL2SQL capabilities, illustrating that carefully designed task decomposition strategies can narrow the performance gap between open-source and closed-source models. Furthermore, the proposed approach not only advances the state-of-the-art in NL2SQL but also provides valuable insights into enhancing LLMs' reasoning abilities for complex structured prediction tasks.
+\end{abstract}
+
+
+\section{Introduction}
+
+Natural Language to SQL (NL2SQL)~ is a task that aims to automatically translate natural language queries into executable SQL statements. This task has attracted considerable attention due to its potential to democratize database access, enabling users without SQL expertise to query and interact with databases using natural language. The accurate conversion of natural language into SQL queries is critical for a wide range of applications, including business intelligence, data analysis, and question-answering systems.
+
+Recently, large language models (LLMs), such as OpenAI's GPT-4, have achieved state-of-the-art performance on NL2SQL benchmark datasets, including Spider~ and BIRD~. These models have demonstrated significant potential in bridging the gap between natural language and structured database queries. However, existing efforts predominantly rely on closed-source LLMs, such as GPT-4~ and Gemini~, which heavily depend on prompt engineering techniques~ to achieve optimal results. The reliance on closed-source models introduces several challenges, including concerns about openness, privacy, and computational costs. In contrast, recent efforts to utilize open-source LLMs~ have faced substantial performance gaps~ compared to their closed-source counterparts.
+
+To bridge this performance disparity, prior research has explored strategies such as pre-training~ and post-training~ to equip LLMs with domain-specific knowledge. However, NL2SQL tasks present unique challenges. Natural language queries often contain multiple objectives, which may be explicit (directly corresponding to query results) or implicit (e.g., conditions for filtering results) and are not always directly mappable to the database schema. These characteristics make it exceedingly \textit{difficult for LLMs to effectively solve complex NL2SQL tasks in a single step}.
+
+A promising approach to address this complexity is task decomposition, which involves breaking down a complex NL2SQL query into simpler subtasks, as illustrated in Fig.\ref{fig:teaser}. Recent research has demonstrated that multi-step reasoning methods, such as the ``\texttt{Let's think step by step}'' strategy~, can significantly enhance LLM performance on natural language processing (NLP) tasks through task decomposition.
+
+Building on this idea, we propose a task decomposition framework to tackle complex NL2SQL queries by dividing them into multiple, simpler subtasks. Preliminary experiments (as shown in Fig.~\ref{fig:pre-experiments}) validate this approach: when subtasks are manually provided to the LLM, performance improves significantly (\textcolor{upperformance}{30.4\%$\uparrow$}), underscoring the potential of task decomposition for enhancing NL2SQL performance. However, when the LLM itself is tasked with decomposing complex queries, performance gains are marginal (\textcolor{upperformance}{3.4\%$\uparrow$}), highlighting the need to improve LLMs' task decomposition capabilities for NL2SQL.
+
+Inspired by recent advancements~ that leverage reinforcement learning (RL)~ to enhance LLM reasoning in multi-step tasks, we propose \underline{Lear}ning \underline{N}L2SQL with \underline{A}ST-guided \underline{T}ask Decomposition (\TheName{}). This novel RL-based algorithm is designed to improve LLMs' task decomposition capabilities, thereby enhancing their ability to parse complex SQL queries. Specifically, \TheName{} introduces methodologies for the three foundational RL processes—training data synthesis, model training, and inference—by incorporating the following innovations:
+
+
+\noindent \textbf{Technical challenges and Solutions.}
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textit{Decomposition Synthesis Procedure}: This component employs a search-based strategy, such as Monte Carlo Tree Search (MCTS), to generate subtasks for NL2SQL decomposition. Existing LLM-MCTS hybrid methods rely on heuristic evaluation strategies, where the LLM itself assesses node rewards to guide the search. However, even advanced models like GPT-4 achieve only 46.35\% accuracy on benchmarks such as BIRD, limiting the reliability of such self-evaluation methods. Additionally, the vast search space inherent in text-based MCTS leads to inefficiencies and computational overhead. To address these challenges, we leverage abstract syntax trees (ASTs) to guide the search and implement pruning strategies, significantly improving search efficiency and the success rate of generating valid decompositions.
+ \item \textit{Margin-Aware Reinforcement Learning}: This component enhances LLMs’ decomposition capabilities by adopting reinforcement learning techniques, such as Direct Preference Optimization (DPO)~. Standard DPO algorithms, however, struggle with fine-grained supervision in multi-step reasoning tasks, as they treat all correct and incorrect steps equivalently. To overcome this limitation, we introduce an AST-based margin-aware DPO framework that distinguishes between varying levels of correctness in steps, enabling more precise optimization.
+ \item \textit{Adaptive Demonstration Reasoning}: Prior studies~ have shown that incorporating demonstrations into prompts can significantly improve LLM performance through in-context learning. Building on this insight, we develop an adaptive demonstration selection mechanism that dynamically identifies and injects the most relevant demonstrations into prompts, further refining task decomposition capabilities.
+\end{itemize}
+
+Our contributions can be summarized as follows:
+\begin{enumerate}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item We address the critical challenge of enabling LLMs to understand users’ high-level semantics and map them to database schemas for complex NL2SQL problems. To this end, we propose \TheName{}, a novel framework that improves LLM performance on NL2SQL tasks by leveraging task decomposition and reinforcement learning.
+ \item We introduce the \textit{Decomposition Synthesis Procedure}, which utilizes AST-guided search and pruning to efficiently generate subtasks, and \textit{Margin-Aware Reinforcement Learning}, which enables fine-grained preference learning for multi-step reasoning.
+ \item Through extensive experiments on two NL2SQL benchmark datasets, we demonstrate that \TheName{} significantly outperforms existing methods, achieving GPT-4-level performance with a 7B parameter model. These results highlight the efficacy of task decomposition strategies in addressing the challenges of complex NL2SQL tasks.
+\end{enumerate}
+
+
+\section{Preliminaries}
+
+\noindent \textbf{Natural Language to SQL (NL2SQL).}
+The goal of the NL2SQL task is to translate a natural language (NL) question \( Q \) into corresponding SQL query \( Y \), based on a database schema \(S\).
+In more complex scenarios, such as those presented by BIRD~, interpreting NL questions or understanding database values may require incorporating external knowledge, denoted by \( \mathcal{K} \). The prevailing approach to the NL2SQL task adopts a cross-domain framework to assess a model's generalization ability by keeping the training, development, and test sets distinct.
+
+\noindent \textbf{Abstract Syntax Trees (AST).}~\label{ssec:AST}
+An Abstract Syntax Tree (AST) is a structured, hierarchical representation of an SQL query, where each element of the query is captured as a node and the relationships between these elements are encoded as edges.
+This tree-based structure abstracts away from the linear textual representation of SQL, focusing instead on its grammatical structure and logical organization.
+
+Formally, the AST of an SQL query \( Y \) can be defined as a directed acyclic graph (DAG) \( \mathcal{AT}(Y) = (\mathcal{N}, \mathcal{E}) \), where \( \mathcal{N} \) is the set of nodes, each representing a syntactic component of the SQL query. Specifically, every node \( n \in \mathcal{N} \) corresponds to a clause, operator, or operand. We categorize the nodes as follows:
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Clause Nodes (\( n_c \in \mathcal{N}_c \))}: Represent core SQL clauses, such as \texttt{SELECT}, \texttt{FROM}, \texttt{WHERE}, \texttt{GROUP BY}, and \texttt{ORDER BY}.
+ \item \textbf{Operator Nodes (\( n_o \in \mathcal{N}_o \))}: Represent logical or arithmetic operations, such as \texttt{AND}, \texttt{OR}, \texttt{$=$}, \texttt{$>$}, and \texttt{<}.
+ \item \textbf{Operand Nodes (\( n_v \in \mathcal{N}_v \))}: Represent terminal elements like table names, column names, literals, or values from the database schema.
+\end{itemize}
+
+\( \mathcal{E} \subseteq \mathcal{N} \times \mathcal{N} \) is the set of edges, where each directed edge \( e = (n_i, n_j) \in \mathcal{E} \) captures a syntactic dependency from a parent node \( n_i \) to a child node \( n_j \). These edges reflect the hierarchical structure of the query, where high-level clauses dominate subcomponents or conditions.
+
+The root node of \( \mathcal{AT}(Y) \) corresponds to the main clause of the query, typically the \texttt{SELECT} clause. From the root, child nodes represent subsequent clauses or expressions, forming a hierarchical decomposition of the SQL query. For example, a \texttt{WHERE} clause node may have child nodes corresponding to individual conditions, which in turn may contain operators and operands as descendants.
+
+
+\noindent \textbf{Monte Carlo Tree Search (MCTS).}
+Monte Carlo Tree Search (MCTS) is a heuristic search algorithm used for decision-making in large and complex search spaces. It combines tree-based search with stochastic sampling to balance exploration and exploitation, making it particularly effective for problems with vast or unknown state spaces.
+
+Formally, MCTS operates on a search tree \( \mathcal{T} = (\mathcal{S}, \mathcal{A}, \mathcal{M}) \), where:
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \( \mathcal{S} \) is the set of states or nodes in the search space. Each node \( s \in \mathcal{S} \) represents a specific configuration of the environment, such as a partially completed plan or a subproblem in a reasoning task.
+ \item \( \mathcal{A}(s) \) denotes the set of actions available at state \( s \). Each action leads to a child state \( s' \), expanding the search tree.
+ \item \( \mathcal{M} \subseteq \mathcal{S} \times \mathcal{S} \) represents the set of edges, where each edge corresponds to a transition between states through an action.
+\end{itemize}
+
+The MCTS algorithm proceeds iteratively through four phases:
+\begin{enumerate}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Selection}: Starting from the root node \( s_0 \), the algorithm recursively selects child nodes based on a selection policy, typically using the Upper Confidence Bound for Trees (UCT) criterion:
+ \begin{equation}\label{equ:UCT}
+ a^* = \arg\max_{a \in \mathcal{A}(s)} \left( Q(s, a) + c \cdot \sqrt{\frac{\log N(s)}{N(s, a)}} \right),
+ \end{equation}
+ where \( Q(s, a) \) is the estimated reward for taking action \( a \) from state \( s \), \( N(s) \) is the visit count of node \( s \), \( N(s, a) \) is the visit count of action \( a \) from \( s \), and \( c \) is a constant that controls the exploration-exploitation trade-off.
+ \item \textbf{Expansion}: If the selected node is not terminal and has unvisited child nodes, the algorithm expands the tree by adding a new child node corresponding to a valid action from the current state.
+ \item \textbf{Simulation (Rollout)}: From the newly expanded node, a simulation is conducted by selecting actions—often at random or based on a heuristic policy—until reaching a terminal state. The outcome of this simulation provides a reward signal, used to estimate the reward of the node.
+ \item \textbf{Backpropagation}: The reward obtained from the simulation is propagated back through the visited nodes, updating the reward estimations \( Q(s, a) \) and visit counts \( N(s, a) \) along the path from the expanded node to the root.
+\end{enumerate}
+
+The output of MCTS is a policy that selects the action with the highest visit count from the root node:
+\begin{equation}
+ \pi(s_0) = \arg\max_{a \in \mathcal{A}(s_0)} N(s_0, a).
+\end{equation}
+
+
+\noindent \textbf{Direct Preference Optimization (DPO).}
+Reinforcement Learning from Human Feedback (RLHF)~ is an effective strategy for aligning LLMs with human preference, enhancing robustness, reliability, and safety~. It relies on the Bradley-Terry (BT) model~ to define preference probability based on some reward function. Given a prompt \( x \) and two responses—\( y_w \) (preferred) and \( y_l \) (dispreferred)—the probability of preference can be expressed as:
+
+\begin{equation}
+p^{*}_{\mathcal{D}}\left(y_{w} \succ y_{l} \mid x\right) = \sigma\left( r^{*}(x, y_{w}) - r^{*}(x, y_{l}) \right),
+\end{equation}
+
+where \( \sigma(x) = \frac{1}{1+\exp(-x)} \) is the sigmoid function and \( r^* \) represents a latent reward model. RLHF optimizes the policy model \( \pi_{\theta} \) with a Kullback-Leibler (KL) constraint to limit deviation from a reference model \( \pi_{ref} \):
+
+\begin{equation}
+\max \mathbb{E}_{x \sim \mathcal{D}, y \sim \pi_{\theta}(y \mid x)} [ r^*(x, y) ] - \beta \mathbb{D}_{KL} [ \pi_{\theta}(y \mid x) \| \pi_{ref}(y \mid x) ].
+\end{equation}
+
+Here, \( \beta \) regulates the KL divergence to prevent reward hacking~. While effective, RLHF requires careful hyperparameter tuning and involves complex reward modeling and policy training.
+
+To simplify this process, Direct Preference Optimization (DPO)~ was introduced, eliminating the need for an explicit reward model. Instead, DPO directly optimizes the policy using paired preference data. Given a prompt \( x \) with responses \( (y_w, y_l) \), the DPO objective maximizes the likelihood of the preferred response while minimizing that of the dispreferred one:
+
+
+\begin{align}\label{equ:DPO}
+ \mathcal{L}_{\mathrm{DPO}}(\pi_{\theta}; \pi_{\mathrm{ref}}) &=
+ -\mathbb{E}_{(x,y_w,y_l)\sim\mathcal{D}} \notag
+ \left[ \log \sigma \left( \hat{r}_\theta(x, y_w) - \hat{r}_\theta(x, y_l) \right) \right] \\
+ \hat{r}_\theta(x, y) &= \beta \log \frac{ \pi_{\theta}(y \mid x) }{ \pi_{\mathrm{ref}}(y \mid x) }.
+\end{align}
+
+This formulation treats \( \hat{r}_\theta(x, y) \) as an ``implicit reward''~, allowing for direct alignment with human preference while bypassing the need for complex reward modeling and simplifying the overall training process.
+
+
+\section{Methodology}
+
+In this section, we present the methodology of \TheName{}. First, \TheName{} employs the \textit{Decomposition Synthesis Procedure} for generating training data in offline reinforcement learning. Then, it utilizes \textit{Margin-aware Reinforcement Learning} for model fine-tuning. Finally, it adopts \textit{Adaptive Demonstration Reasoning} for NL2SQL with task decomposition.
+
+\subsection{Decomposition Synthesis Procedure}
+
+\TheName{} employs the \textit{Decomposition Synthesis Procedure} for generating training data. The framework of the \textit{Decomposition Synthesis Procedure} is shown in Fig.~\ref{fig:Framework-Of-Data-Generation}.
+Given a natural language query \(Q\), external knowledge \(K\), database schema \(\mathcal{DB}\), and target SQL query \(Y\), \textit{Decomposition Synthesis Procedure} aims to decompose complex NL2SQL tasks into a series of simpler subtask queries, which can be easily translated into corresponding SQL statements.
+The decomposition process is guided by MCTS and AST-based evaluation, ensuring both the correctness and effectiveness of the generated subtasks.
+
+\noindent \textbf{Problem Formulation}
+Let \(\{q_1, q_2, \cdots, q_n\}\) denote a sequence of subtask queries, where $n$ represents the number of subtasks and each \(q_i\) represents a natural language query that captures a component of the original query \(Q\). For each subtask query \(q_i\), \textit{Decomposition Synthesis Procedure} generates a corresponding SQL query \(y_i\). The objective is to find a sequence of subtask queries such that their corresponding SQL queries collectively construct the target SQL query \(Y\).
+
+\noindent \textbf{MCTS-based Decomposition}
+\textit{Decomposition Synthesis Procedure} formulates the decomposition process as a tree search problem, and performs next-step prediction as action \(a\) in each state \(s\). In the Monte Carlo Tree, the root node represents the original query \(Q\), each non-root node represents the state of executing the next subtask, and each path from root node to a leaf node represents a decomposition sequence.
+
+At each state in MCTS, the \textit{Decomposition Synthesis Procedure} employs an LLM to generate the next subtask \(q_i\) and sub-SQL \(y_i\). Formally, each state \( s_i = \{q_i, y_i, \mathcal{AT}(y_i), \mathcal{AT}_{\text{sum}}(y_i), \mathcal{R}(s_i)\} \), where \(\mathcal{AT}(y_i)\) is the AST of \(y_i\), \(\mathcal{AT}_{\text{sum}}(y_i)\) is the merged AST summarizing all nodes from root to node \(s_i\) in MCTS, and \(\mathcal{R}(s_i)\) is the reward estimation of \(s_i\). The \(\mathcal{AT}_{\text{sum}}(y_i)\) is mathematically defined as follows:
+\begin{equation}
+ \mathcal{AT}_{\text{sum}}(y_i) = (\mathcal{N}_{\text{sum}}, \mathcal{E}_{\text{sum}}),
+\end{equation}
+\begin{equation}
+ \mathcal{N}_{\text{sum}} = \bigcup_{j=1}^i \mathcal{N}(\mathcal{AT}(y_j)), \mathcal{E}_{\text{sum}} = \bigcup_{j=1}^i \mathcal{E}(\mathcal{AT}(y_j)).
+\end{equation}
+
+
+\noindent \textbf{Node Classification}
+\textit{Decomposition Synthesis Procedure} classify actions into three categories based on their AST properties:
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Progressive Actions}: Actions where \(\mathcal{AT}(y_i)\) is a subtree of \(\mathcal{AT}(Y)\) and \(\mathcal{AT}(y_i)\) is not a subtree of \(\mathcal{AT}_{\text{sum}}(y_{\text{parent}(i)})\). These actions contribute new information toward the target SQL.
+ For two ASTs \(\mathcal{AT}_1 = (\mathcal{N}_1, \mathcal{E}_1)\) and \(\mathcal{AT}_2 = (\mathcal{N}_2, \mathcal{E}_2)\), We define the subtree relationship as follows:
+ \begin{equation}
+ \text{isSubtree}(\mathcal{AT}_1, \mathcal{AT}_2) = \begin{cases}
+ 1, & \text{if } \mathcal{N}_1 \subseteq \mathcal{N}_2 \text{ and } \mathcal{E}_1 \subseteq \mathcal{E}_2 \\
+ 0, & \text{otherwise}
+ \end{cases}.
+ \end{equation}
+
+ \item \textbf{Redundant Actions}: Actions where \(\mathcal{AT}(y_i)\) is a subtree of \(\mathcal{AT}(Y)\) but is also a subtree of \(\mathcal{AT}_{\text{sum}}(y_{\text{parent}(i)})\). These nodes provide no additional reward to the decomposition.
+
+ \item \textbf{Invalid Actions}: Nodes where \(\mathcal{AT}(y_i)\) is not a subtree of \(\mathcal{AT}(Y)\). These nodes represent incorrect decompositions.
+\end{itemize}
+
+\noindent \textbf{Prune Strategy}
+In traditional MCTS, since the typical scenario involves robotic task execution, \(\mathcal{A}(s)\) is generally defined as a finite action set, such as \texttt{pick up}, \texttt{put down}, etc. However, in the application of LLMs, \(\mathcal{A}(s)\) is usually an infinite action set. This is because LLMs generate actions in the form of text, meaning that even the same subSQL can be expressed as multiple different subtask (action) variations. To reduce the search space of MCTS and improve search efficiency, \textit{Decomposition Synthesis Procedure} adopts a pruning strategy.
+
+Specifically, since the subtask sequence collected by the \textit{Decomposition Synthesis Procedure} corresponds to the action sequence along the path from the root node to a leaf node in MCTS, redundant actions and invalid actions along the path do not need to be included in the subtask list. Therefore, for states containing redundant or invalid actions, the \textit{Decomposition Synthesis Procedure} terminates further action searches to perform pruning.
+
+\noindent \textbf{Reward Estimation}
+In MCTS, it is necessary to estimate $Q(s, a)$ for each state to provide state rewards, thereby guiding the direction of subsequent searches. In general mathematical domains, existing works typically employ either LLM-based self-evaluation or an additional reward model trained for state reward estimation. In this work, the \textit{Decomposition Synthesis Procedure} further leverages information from the AST and designs a rule-based approach to evaluate the state reward.
+
+Since states with redundant actions and invalid actions are pruned, to improve efficiency, reward estimation is only performed for states with progressive actions. Specifically, \textit{Decomposition Synthesis Procedure} estimates the reward of the current state based on the similarity between \(\mathcal{AT}(Y)\) and \(\mathcal{AT}_{\text{sum}}(y_i)\) at the current state.
+
+\begin{equation}
+ \mathcal{R}(s_i) = \text{sim}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)),
+\end{equation}
+
+where \(\text{sim}(\cdot,\cdot)\) denotes the AST similarity measure.
+
+\textit{Decomposition Synthesis Procedure} defines two types of AST similarity, including node-level similarity \(\text{sim}_{\text{node}}\) and structural similarity \(\text{sim}_{\text{struct}}\).
+
+\noindent \underline{Node-level Similarity (\(\text{sim}_{\text{node}}\))}
+The node-level similarity considers different types of nodes separately:
+
+\begin{equation}\label{equ:node-sim}
+ \text{sim}_{\text{node}}(\mathcal{AT}_1, \mathcal{AT}_2) = \sum_{t \in \{c,o,v\}} w_t \cdot \text{sim}_t(\mathcal{AT}_1, \mathcal{AT}_2),
+\end{equation}
+
+where \(w_t\) are weights for each node type with \(\sum_{t} w_t = 1\) and \(t \in \{c,o,v\}\) represents clause nodes, operator nodes, and operand nodes, respectively.
+
+For each node type:
+
+\begin{equation}
+ \text{sim}_t(\mathcal{AT}_1, \mathcal{AT}_2) = \frac{|\mathcal{N}_t(\mathcal{AT}_1) \cap \mathcal{N}_t(\mathcal{AT}_2)|}{|\mathcal{N}_t(\mathcal{AT}_1) \cup \mathcal{N}_t(\mathcal{AT}_2)|},
+\end{equation}
+
+where \(\mathcal{N}_t(\mathcal{AT}_i)\) is the set of nodes of type \(t\) in AST \(\mathcal{AT}_i\).
+
+\noindent \underline{Structural Similarity (\(\text{sim}_{\text{struct}}\))}
+\textit{Decomposition Synthesis Procedure} define structural similarity using the Tree Edit Distance (TED):
+
+\begin{equation}
+ \text{sim}_{\text{struct}}(\mathcal{AT}_1, \mathcal{AT}_2) = 1 - \frac{\text{TED}(\mathcal{AT}_1, \mathcal{AT}_2)}{\max(|\mathcal{AT}_1|, |\mathcal{AT}_2|)},
+\end{equation}
+
+where \(\text{TED}(\mathcal{AT}_1, \mathcal{AT}_2)\) is the minimum number of node operations (insertion, deletion, modification) required to transform \(\mathcal{AT}_1\) into \(\mathcal{AT}_2\), and \(|\mathcal{AT}_i|\) is the number of nodes in AST \(\mathcal{AT}_i\).
+
+Finally, \textit{Decomposition Synthesis Procedure} estimates the reward of the current state as follows:
+
+\begin{align}\label{equ:AST-sim}
+ \mathcal{R}(s_i) & = \alpha \cdot \text{sim}_{\text{node}}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)) \notag \\
+ & + \beta \cdot \text{sim}_{\text{struct}}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)),
+\end{align}
+
+where \(\alpha\) and \(\beta\) are adjustment factors for the two types of AST similarity, satisfying \(\alpha + \beta = 1\).
+
+
+\noindent \textbf{Self-improvement Demonstration}\label{sssec:Self-improvement-Demonstration}
+\textit{Decomposition Synthesis Procedure} employs few-shot learning to improve the success rate of task decomposition. Few-shot learning is essentially a form of in-context learning, where a few demonstrations are provided to help the LLM understand user intent, mimic the given format, and learn implicit knowledge.
+
+Initially, \textit{Decomposition Synthesis Procedure} begins with three manually provided task decomposition examples and executes the first round of decomposition. In the $i$-th round of decomposition ($i \geq 2$), to reduce resource consumption, the procedure only decomposes samples that were not successfully decomposed in the previous $i-1$ rounds. Specifically, these are cases where, after the entire MCTS execution, the SQL statement produced at any leaf node does not perfectly match the execution result of the Gold SQL.
+
+To improve the success rate of decomposition, \textit{Decomposition Synthesis Procedure} adopts adaptive demonstrations instead of using the fixed demonstrations from the first round. Specifically, it constructs a demonstration pool, which consists of samples that were successfully decomposed in the previous $i-1$ rounds.
+Given a new task decomposition query, the procedure computes the AST similarity between the query and each query in the demonstration pool. It then selects the top-3 most similar queries as demonstrations to be included in the prompt.
+
+\noindent \textbf{Data Collection}
+During the search process, \textit{Decomposition Synthesis Procedure} collect two types of data for subsequent offline reinforcement learning:
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Successful Trajectories}: Sequences of \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) that successfully decompose the target SQL, used for supervised fine-tuning.
+ \item \textbf{Contrastive Action Pairs}: Pairs of incorrect action \((q^l_i, y^l_i)\) and their corresponding correct action \((q^w_i, y^w_i)\), used for preference learning.
+\end{itemize}
+
+
+\subsection{Margin-Aware Reinforcement Learning}
+
+\TheName{} propose a \textit{Margin-aware Reinforcement Learning} framework to train the open-source LLM for decomposing complex NL2SQL tasks into manageable subtasks. The framework consists of two phases. First, \textit{Margin-aware Reinforcement Learning} fine-tunes the LLM in a supervised manner based on correct decomposition trajectories, enhancing the model's ability to perform task decomposition and generate the correct output format.
+Then, \textit{Margin-aware Reinforcement Learning} conducts direct preference optimization (DPO) with AST margin on the LLM using contrastive action pairs, suppressing incorrect subtask outputs and achieving finer-grained preference alignment.
+
+\noindent \textbf{Supervised Fine-tuning}
+Given the training data from \textit{Decomposition Synthesis Procedure}, \textit{Margin-aware Reinforcement Learning} first performs supervised fine-tuning on successful decomposition trajectories. In a training instance $(Q, \mathcal{DB}, \mathcal{K}, \{(q_1, y_1), \cdots, (q_n, y_n)\})$,
+\(Q\) is the input query, \(\mathcal{DB}\) is the database schema, \(\mathcal{K}\) is the optional external knowledge, and \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) is the sequence of correct subtask queries and corresponding subSQLs. \textit{Decomposition Synthesis Procedure} treats \([Q, \mathcal{DB}, \mathcal{K}]\) as the prompt \(x\) and \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) as the target response \(t\), so the supervised fine-tuning objective is to minimize the log-likelihood loss:
+
+\begin{equation}
+ \mathcal{L}_{\text{SFT}} = \mathbb{E}_{(\boldsymbol{x},\boldsymbol{t})}\left[\sum_{i=1}^I\log p_\theta\left(t_i\mid\boldsymbol{t}_{1:i-1},\boldsymbol{x}\right)\right],
+\end{equation}
+
+where \(\theta\) represents the fine-tuned LLM parameters, and \(p_\theta(\boldsymbol{t}\mid\boldsymbol{x})=\prod_{i=1}^Ip_\theta\left(t_i\mid\boldsymbol{t}_{<i},\boldsymbol{x}\right)\) is the conditional probability distribution of target subtask \& subSQL sequence \(t\) given prompt \(x\). \(I\) is the sequence length of \(t\), and \(i\) is the auto-aggressive decoding step.
+
+
+\noindent \textbf{DPO with AST Margin}
+A phenomenon of pessimism suggests that the positive feedback provided by SFT alone cannot prevent LLMs from generating erroneous reasoning pathways.
+Existing works~ indicates that, during the SFT phase, as the probability of preferred outputs (correct responses) increases, the probability of dispreferred outputs (incorrect responses) rises as well.
+\textit{Margin-aware Reinforcement Learning} employs DPO to suppress incorrect subtask outputs.
+
+Specifically, a training instance takes the form of $(Q, \mathcal{DB}, \mathcal{K}, \\ \{(q_1, y_1), \cdots, (q_{i-1}, y_{i-1})\}, (q^w_i, y^w_i), (q^l_i, y^l_i))$
+,where \(\{(q_1, y_1), \cdots, \\ (q_{i-1}, y_{i-1})\}\) is a verified correct subtask sequence, \((q^w_i, y^w_i)\) and \((q^l_i, y^l_i)\) represent the correct and incorrect subtasks branching from the search tree, respectively.
+\textit{Margin-aware Reinforcement Learning} treats \([Q, \mathcal{DB}, \mathcal{K}, \{(q_1, y_1), \cdots, (q_{i-1}, y_{i-1})\}]\) as the prompt \(x\), \((q^w_i, y^w_i)\) as the prefer response, \((q^l_i, y^l_i)\) as the disprefer response, and optimizes \(\theta\) using Eq.~\ref{equ:DPO}.
+
+However, DPO only optimizes the relative likelihood between positive and negative samples. In other words, the model only learns that the positive samples are better than the negative ones, but does not capture \textbf{how much better} the positive samples are compared to the negative ones.
+
+To enable finer-grained preference learning, \textit{Margin-aware Reinforcement Learning} follows the inspiration of ODPO~ by incorporating an offset into the DPO loss to measure the reward margin between positive and negative samples. In the original ODPO~, an additional reward model is trained to estimate rewards for positive and negative samples. \textit{Margin-aware Reinforcement Learning} extends this approach by directly computing the margin between positive and negative samples using reward estimation based on AST similarity.
+
+Specifically, \textit{Margin-aware Reinforcement Learning} estimates the reward margin between two samples as follows:
+
+\begin{equation}
+ \text{margin}((q^w_i, y^w_i), (q^l_i, y^l_i)) = \mathcal{R}(s^w_i) - \mathcal{R}(s^l_i).
+\end{equation}
+
+Finally, the loss of DPO with AST Margin is formulated as follows:
+
+\begin{equation}\label{equ:MDPO}
+\begin{aligned}
+ \mathcal{L}_{\mathrm{MDPO}}(\pi_{\theta}; \pi_{\mathrm{ref}}) =&
+ -\mathbb{E}_{(x,y_w,y_l)\sim\mathcal{D}} \\
+ & \left[ \log \sigma \left( \hat{r}_\theta(x, y_w) - \hat{r}_\theta(x, y_l)
+ - \triangle_r\right) \right],
+\end{aligned}
+\end{equation}
+
+where \(\triangle_r = \text{margin}((q^w_i, y^w_i), (q^l_i, y^l_i))\) is the offset, measuring the reward margin between positive and negative samples.
+
+The AST margin effectively guides the model to learn not only which decomposition steps are preferred, but also how much they are preferred, leading to more nuanced and effective multi-step reasoning capabilities.
+
+\subsection{Adaptive Demonstration Reasoning}
+
+Given the LLM trained with \textit{Margin-Aware Reinforcement Learning}, \TheName{} further employs \textit{Adaptive Demonstration Reasoning} to enhance the LLM's ability to solve NL2SQL tasks.
+
+Similar to the self-improving demonstrations proposed in Sec.~\ref{sssec:Self-improvement-Demonstration}, \textit{Adaptive Demonstration Reasoning} also aims to identify the most helpful demonstrations for solving the current NL2SQL task. However, the key difference is that self-improving demonstrations select demonstrations based on the AST similarity of SQL queries. In contrast, when the LLM infers a new query, its golden SQL is unknown. Therefore, \textit{Adaptive Demonstration Reasoning} must adopt an alternative approach to measure similarity.
+
+The \textit{Adaptive Demonstration Reasoning} framework operates in two phases: (1) embedding cache construction and (2) adaptive demonstration retrieval.
+
+\noindent \textbf{Embedding Cache Construction}
+Given a demonstration pool $\mathcal{D} = \{(Q_i, Y_i)\}_{i=1}^{N}$, where $Q_i$ represents a natural language query and $Y_i$ is the corresponding SQL translation, \textit{Adaptive Demonstration Reasoning} first construct an embedding cache as follows:
+
+\begin{equation}
+ E(Q) = \theta(Q) \in \mathbb{R}^d,
+\end{equation}
+where $E(\cdot)$ denotes the embedding function that maps natural language queries to a $d$-dimensional vector space. \textit{Adaptive Demonstration Reasoning} utilizes the tuned LLM itself to generate these embeddings through a designated embedding endpoint, ensuring the semantic representation aligns with the model's internal understanding.
+
+This pre-processing step is performed offline to reduce runtime computational overhead during inference.
+
+\noindent \textbf{Adaptive Demonstration Retrieval}
+When a new query $Q_{\text{new}}$ is presented, \textit{Adaptive Demonstration Reasoning} employ the following procedure to select the most relevant demonstrations: (1) Compute the embedding of the new query as $e_{\text{new}} = E(q_{\text{new}})$, (2) Calculate the similarity score between the new query embedding and each cached embedding as follows:
+
+\begin{equation}
+ \text{sim}(e_{\text{new}}, E(Q_i)) = \frac{e_{\text{new}} \cdot E(q=Q_i)}{||e_{\text{new}}|| \cdot ||E(Q_i)||}.
+\end{equation}
+
+(3) Select the top-$k$ most similar query-SQL pairs, denoted as
+
+\begin{equation}
+ \mathcal{T} = \text{TopK}(\{(Q_i, Y_i, \text{sim}(e_{\text{new}}, E(Q_i)))\}_{i=1}^{N}, k).
+\end{equation}
+
+where $k=3$ in our implementation.
+
+\section{Experiments}
+
+\subsection{\textbf{Experimental Setup}}
+
+\noindent \textbf{Datasets}
+We use the BIRD-train dataset~ to synthesize decomposition data for complex NL2SQL tasks within the \textit{Decomposition Synthesis Procedure}, which is subsequently employed for \textit{Margin-Aware Reinforcement Learning}. Then, we utilize BIRD-dev~ and Spider-dev~ to evaluate the effectiveness and robustness of \TheName{}. Notably, the databases and user questions in the training and test sets differ completely.
+
+
+The statistics of BIRD-train, BIRD-dev, and Spider-dev used in this study are shown in Table.~\ref{tab:dataset-statistics}. Notably, BIRD-train does not categorize queries based on difficulty levels. Additionally, although BIRD-train provides 9,428 data samples, the gold SQL statements for 425 of them cannot be executed by the SQL executor. Therefore, we filter out these samples considering BIRD-train to contain only 9,003 data samples in our subsequent analysis.
+
+
+\noindent \textbf{Evaluation Metrics.}
+Since the SQL expression styles generated by LLMs may differ from the ground truth in NL2SQL benchmarks~, traditional string-based evaluation metrics, such as Exact Match Accuracy~, are not suitable for our study. Therefore, following prior works~, we adopt the Execution Accuracy (EX) metric, which evaluates the correctness of generated SQL queries by comparing their execution results with those of the corresponding ground-truth queries retrieved from the database.
+
+\noindent \textbf{Baselines.}
+In this experiment, we compare two types of baselines, including 10 prompting-based approaches and 3 fine-tuning-based approaches, as mentioned in Sec.~\ref{ssec:nlsql-solution}. The prompting-based methods include C3-SQL~, ACT-SQL~, DIN-SQL~, MetaSQL~, DAIL-SQL~, ZeroNL2SQL~, MAG-SQL~, MAC-SQL~, SuperSQL~ and MCS-SQL~, while the fine-tuning-based methods include CatSQL~, SENSE~ and CodeS .
+
+
+\noindent \textbf{Implementation Details.}
+We employ GLM-4-Plus\footnote{\url{https://bigmodel.cn/dev/api/normal-model/glm-4}} as the primary model for synthesizing decomposition data and fine-tune the model on Qwen2.5-Coder~, including its 7B, 14B, and 32B versions.
+We used the PyTorch library to implement all the algorithms based on the open-source HuggingFace transformers~ and LLaMA-Factory~.
+The experiments are conducted on 8×A100 GPUs. During the SFT stage, we utilize the AdamW optimizer with a learning rate of 2e-5 and a cosine warmup scheduler over three epochs. For DPO training, the Adam optimizer is used with a learning rate of 2e-6, and the $\beta$ parameter is set to 0.2, in accordance with the original DPO configuration. In Eq.~\ref{equ:node-sim}, we assign equal weights to all three nodes, i.e., $w_c = w_o = w_v = 0.33$. Based on our experimental observations, we set $\alpha = 0.75$ and $\beta = 0.25$ in Eq.~\ref{equ:AST-sim}.
+
+\subsection{Results of \textit{Decomposition Synthesis Procedure}}
+
+\subsubsection{\textbf{Statistical Results}}
+
+We evaluated the decomposition performance of the \textit{Decomposition Synthesis Procedure} on BIRD-train and compared it with several baseline decomposition algorithms, including CoT and naive MCTS. The experimental results are shown in Table.~\ref{tab:dataset-generate}.
+
+The results indicate that the \textit{Decomposition Synthesis Procedure} achieved an 80.00\% decomposition success rate, outperforming CoT and naive MCTS by \textcolor{upperformance}{20.93\%$\uparrow$} and \textcolor{upperformance}{8.45\%$\uparrow$}, respectively. Additionally, it is noteworthy that MCTS generated a large number of invalid searches, leading to excessive token consumption. In contrast, our proposed \textit{Decomposition Synthesis Procedure} utilizes AST-guided pruning, enabling high-performance and low-cost (\textcolor{upperformance}{56.38\%$\downarrow$}) decomposition synthesis.
+
+We further tested the performance of self-improving demonstrations over multiple rounds. The results show that adaptive demonstrations significantly improve model performance (\textcolor{upperformance}{1.99\%$\uparrow$}). However, this strategy also has inherent limitations. Table.~\ref{tab:dataset-generate} reveals that self-improving demonstrations achieved notable performance gains in the first round (\textcolor{upperformance}{1.32\%$\uparrow$}), but in the subsequent two rounds, the decomposition performance began to diminish (only \textcolor{upperformance}{0.4\%$\uparrow$} and \textcolor{upperformance}{0.27\%$\uparrow$}). Therefore, to minimize token consumption, we did not proceed with a fourth round of decomposition.
+
+
+\subsubsection{\textbf{Error Case Analysis}}
+
+To further investigate the reasons for the failure of the \textit{Decomposition Synthesis Procedure} in certain cases, we randomly selected 50 unsuccessful cases for error analysis. The error distribution is shown in Fig.~\ref{fig:error-analysis}.
+
+The results indicate that the decomposition failures can be attributed to four distinct types of errors, including schema linking, float computation, unknown rules, and error answer.
+
+We analyze these errors one by one by presenting typical cases for each of the four error attributions.
+
+\noindent \textbf{Case for Schema Linking.}
+
+\noindent [\#Question:] \textit{What is the user avatar url for user 41579158? What is the latest movie rated by him / her?}
+
+\noindent [\#Evidence:] \textit{user avatar url refers to \texttt{user\_avatar\_image\_url}; latest movie rated refers to latest \texttt{rating\_date};}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the LLM misidentified the column, mapping ``\textit{the latest movie rated by him/her}'' to the \texttt{movie\_id} column instead of the \texttt{rating\_date\_utc} column. However, the evidence provided relevant information (although it did not explicitly specify the corresponding column).
+
+\noindent \textbf{Case for Float Computation.}
+
+\noindent [\#Question:] \textit{What is the percentage of the ratings were rated by user who was a subcriber?}
+
+\noindent [\#Evidence:] \textit{user is a subscriber refers to \texttt{user\_subscriber = 1}; percentage of \texttt{ratings = DIVIDE(SUM(user\_subscriber = 1)}, \texttt{SUM(rating\_score))} as percent;}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the LLM did not strictly follow the Gold SQL in executing multiplication before division but instead generated SQL that performed the operations in the reverse order. Although mathematically equivalent, floating-point arithmetic in SQL can introduce numerical precision variations. Since our evaluation metric is Execution Accuracy, this discrepancy led to an inconsistency in the results.
+Specifically, the Gold SQL produced an execution result of 21.648420738414252, whereas the Predicted SQL yielded 21.64842073841425.
+
+\noindent \textbf{Case for Unknown Rules.}
+
+\noindent [\#Question:] \textit{List all movies with the best rating score. State the movie title and number of Mubi user who loves the movie.}
+
+\noindent [\#Evidence:] \textit{best rating score refers to \texttt{rating\_score = 5}; number of Mubi user who loves the movie refers to \texttt{movie\_popularity}}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the Gold SQL performed an additional deduplication step (\texttt{DISTINCT}) on the query results, whereas the Predicted SQL did not. This deduplication is a default user-friendly operation, but it was not explicitly stated in the query. As a result, the execution results of the Predicted SQL and Gold SQL differed.
+
+
+\noindent \textbf{Case for Error Answer.}
+
+\noindent [\#Question:] \textit{What is the name of the longest movie title? When was it released?}
+
+\noindent [\#Evidence:] \textit{longest movie title refers to \texttt{MAX(LENGTH(movie\_title))}; when it was released refers to \texttt{movie\_release\_year}}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+Some cases in BIRD-train contain incorrect Gold SQL. For example, in this case, the query requires computing the longest movie, and the evidence explicitly states that the correct computation should be \texttt{MAX(LENGTH(movie\_title))}. However, the Gold SQL incorrectly calculates this by using \texttt{LENGTH(movie\_popularity)}, which is clearly incorrect.
+In contrast, the Predicted SQL correctly implements the intended computation. Therefore, the decomposition failure in this case is a false negative, caused by an error in the Gold SQL.
+
+
+\subsubsection{\textbf{Comparison with Competitive Literature}}
+
+We evaluate \TheName{} on Spider-dev and BIRD-dev benchmarks. To further assess \TheName{}'s robustness, we fine-tune Qwen2.5-Coder models with 7B, 14B, and 32B parameters. Additionally, we compare \TheName{} against recent competitive baselines from the past two years. The results are presented in Table.~\ref{tab:main-result}.
+
+Compared with prompting-based methods, \TheName{}—even with only a 7B model—already outperforms most approaches, although these approaches leverage larger-scale models such as GPT-3.5 or GPT-4 as backbone LLMs.
+MCS-SQL~ achieves remarkable performance, significantly surpassing other prompting-based methods on both Spider-dev and BIRD-dev, and also outperforming the 7B and 14B versions of \TheName{}. Only when \TheName{} scales the model up to 32B can it achieve performance surpassing on BIRD-dev.
+However, while MCS-SQL delivers impressive results, it relies on multiple interactions with GPT-4. According to the hyperparameter settings provided in the MCS-SQL manuscript, achieving its reported performance requires more than 60 interactions with GPT-4, making it highly resource-intensive. In contrast, all \TheName{} results require only a single interaction with the LLM.
+
+Compared to fine-tuning-based methods, \TheName{} demonstrates a more significant performance advantage. Among the prompting-based approaches mentioned, the most competitive is CodeS~, therefore we evaluate both the 7B and 15B versions of CodeS.
+Experimental results show that \TheName{} (7B) achieves a \textcolor{upperformance}{1.0\%$\uparrow$} on Spider-dev and a \textcolor{upperformance}{1.1\%$\uparrow$} on BIRD-dev over CodeS (7B). Similarly, \TheName{} (14B) outperforms CodeS (15B) by a \textcolor{upperformance}{2.0\%$\uparrow$} on Spider-dev and a \textcolor{upperformance}{2.7\%$\uparrow$} on Spider-dev. This indicates that \TheName{} maintains a performance advantage across different model sizes.
+
+
+\subsubsection{\textbf{Ablation Study}}
+
+We evaluate the necessity of each component in \TheName{} by systematically removing individual components and assessing the model’s performance. We use Qwen2.5-Coder-7B as the backbone LLM and conduct evaluations on Spider-dev and BIRD-dev. The results are summarized in Table.~\ref{tab:ablation-study}.
+
+First, we present the most naive baseline (w/o \TheName{}), which represents the basic performance of Qwen2.5-Coder-7B. Then, we remove the AST-guide, replacing it with naive MCTS for decomposition and using vanilla DPO in reinforcement learning. The results show an improvement over w/o \TheName{} (e.g., \textcolor{upperformance}{5.6\%$\uparrow$} on BIRD-dev), indicating that decomposition-based RL enhances LLM performance in complex NL2SQL tasks. However, compared to \TheName{}, the model's performance drops significantly (e.g., \textcolor{downperformance}{5.0\%$\downarrow$} on BIRD-dev), suggesting that without an appropriate reward evaluation, performance improvements are limited. \TheName{} tightly integrates reward modeling with AST, designing a rule-based reward model that significantly enhances LLM performance.
+
+Next, we remove the SFT stage, leading to a performance drop (e.g., \textcolor{downperformance}{3.6\%$\downarrow$} on BIRD-dev), indicating that SFT is necessary for initializing the LLM before applying MDPO, aligning with findings from prior work~. Similarly, removing MDPO results in a performance decline (e.g., \textcolor{downperformance}{4.4\%$\downarrow$} on BIRD-dev), showing that SFT alone teaches the LLM to generate correct outputs but fails to suppress incorrect ones~, which degrades overall model performance. Replacing MDPO with naive DPO further reduces performance, as the lack of margin awareness prevents the LLM from distinguishing critical steps during preference learning, leading to coarse-grained reward estimation and thus suboptimal performance.
+
+We also analyze the importance of few-shot learning by removing demonstrations during inference. The results show that few-shot learning helps the model better follow user intent and learn new knowledge from demonstrations, thereby improving performance. Replacing adaptive demonstration reasoning (ADR) with random demonstration selection (RDR) leads to a performance drop (e.g., \textcolor{downperformance}{1.8\%$\downarrow$} on BIRD-dev), confirming that adaptive demonstrations allow the model to find more relevant examples, further boosting performance.
+
+Finally, we conduct a simple experiment using naive Qwen2.5-Coder-7B with CoT-based decomposition, where the LLM directly decomposes the NL2SQL task and generates SQL. While this setup improves performance (e.g., \textcolor{upperformance}{1.8\%$\uparrow$} on BIRD-dev), it is far less effective than \TheName{}, highlighting the importance of AST-guide decomposition, reinforcement learning and adaptive demonstrations.
+
+
+\subsubsection{\textbf{Analysis of AST Similarity}}
+
+We evaluate the importance of node similarity and structural similarity in \TheName{} by adjusting the weight parameter \(\alpha\) in Eq.~\ref{equ:AST-sim}. Specifically, we vary \(\alpha\) between 0, 0.25, 0.5, 0.75, and 1.0, while ensuring that \(\alpha + \beta = 1\). When \(\alpha = 0\), the model relies entirely on structural similarity. When \(\alpha = 1\), the model relies entirely on node similarity.
+
+Experimental results (illustrated in Fig.~\ref{fig:alpha-figure}) show that using only node similarity or only structural similarity leads to performance degradation, indicating that both types of similarity contribute to evaluation quality.
+A balanced setting (\(\alpha = \beta = 0.5\)) does not achieve optimal performance.
+\TheName{} achieves the best performance when \(0 < \beta < 0.5 < \alpha < 1\), suggesting that node similarity is more effective than structural similarity in AST-based similarity assessment.
+This highlights that while both node and structural similarity are necessary, node similarity plays a slightly more critical role in guiding AST-based decomposition and reward estimation.
+
+
+\section{Discussion}
+
+In this section, we investigate two key research questions to further analyze the rationality of \TheName{}.
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{RQ\#1}: Is a complex MCTS necessary? Could it be replaced by directly using the subSQLs from the Gold SQL to synthesize subtasks?
+\end{itemize}
+
+The answer is \textbf{NO}.
+In the early pilot experiments, we designed a more concise approach: \textit{starting from the Gold SQL}, we extracted a sequence of subSQLs and then used a LLM to translate each subSQL into its corresponding subtask. This initially appeared to be a more effective strategy. However, a critical issue arises—\textit{how can we evaluate the correctness of these subtasks?}
+We attempted to directly use a LLM, such as Qwen2-7b-instruct, to determine whether the generated subtasks were correct. However, this approach achieved only 45.4\% accuracy, indicating that verifying the correctness of subtasks is not straightforward. The LLM often misjudged due to subtle differences; for example, if the Gold SQL query targeted a user's name, but the generated subtask query targeted the user's ID instead, the LLM frequently considered the subtask correct.
+
+In contrast, \TheName{} takes the \textit{Query as the starting point}, generates subtasks for the Query, and verifies them by validating the corresponding subSQLs. Compared to directly verifying the correctness of subtask queries, subSQLs offer a more structured and stable representation, making validation more straightforward. For instance, \TheName{} employs AST-based validation, which enhances the robustness of the verification process.
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{RQ\#2}: Is the evaluation of UCT rewards (see Eq.~\ref{equ:UCT}) in MCTS necessary? Could it be replaced with a simple depth-first search?
+\end{itemize}
+
+The answer is \textbf{NO}. In MCTS, the role of the UCT is to balance the reward of each state with its exploration count, thereby preventing the search from getting trapped in local optima. If we focus solely on the reward of a state while ignoring its exploration count, MCTS degenerates into a depth-first search strategy, which poses risks in NL2SQL task decomposition for the following reasons:
+
+First, NL2SQL task decomposition is not unique. Even though AST-based subtask evaluation can ensure the correctness of individual subtasks, it sacrifices the diversity of task decomposition. Second, NL2SQL tasks exhibit sequential dependencies, meaning that changes in the execution order of subtasks can lead to incorrect execution results. However, AST-based subtask evaluation can only guarantee the structural correctness of subtasks but cannot ensure the correctness of their execution order. Therefore, by penalizing low visitation counts, the UCT reward helps \TheName{} escape local optima and enables a broader search, thereby improving the correctness of subtask sequencing.
+
+
+\section{Conclusion and Future Works}
+
+In this work, we propose \TheName{}, a novel framework designed to enhance the performance of LLMs on NL2SQL tasks by leveraging task decomposition and reinforcement learning. Our approach addresses a critical challenge in NL2SQL: the difficulty LLMs face in deeply understanding high-level user semantics and formulating a coherent problem-solving process, particularly for complex queries.
+To effectively implement the reinforcement learning algorithm, we introduce the AST-guided \textit{Decomposition Synthesis Procedure}, which enables efficient search and pruning strategies for task decomposition. Furthermore, we propose \textit{Margin-Aware Reinforcement Learning}, a fine-grained preference learning mechanism that refines the decision-making process.
+We validate the efficacy of \TheName{} on two widely-used NL2SQL benchmarks, where experimental results demonstrate significant performance improvements of Qwen2.5-Coder models across three scales, outperforming existing state-of-the-art NL2SQL methods.
+
+Despite the promising results achieved by \TheName{}, certain limitations remain. Specifically, the framework's mandatory application of task decomposition and SQL parsing to all NL2SQL tasks introduces inefficiencies for simpler queries that could be directly resolved through ``fast tinking''. In such cases, the additional decomposition process imposes unnecessary computational overhead in terms of both reasoning complexity and token usage. As a direction for future work, we plan to explore adaptive task decomposition techniques that dynamically balance reasoning cost and performance. This adaptive approach would aim to selectively apply task decomposition only when it offers tangible benefits, thereby improving the overall efficiency and scalability of the framework.
+
+
+\balance
+\end{document}
+\endinput

benchmark_dataset/papers/ICLR2026_0007_2504.02327/source_extracted.tex

@@ -0,0 +1,489 @@
+\begin{abstract}
+Natural Language to SQL (NL2SQL) has emerged as a critical task for enabling seamless interaction with databases. Recent advancements in Large Language Models (LLMs) have demonstrated remarkable performance in this domain. However, existing NL2SQL methods predominantly rely on closed-source LLMs leveraging prompt engineering, while open-source models typically require fine-tuning to acquire domain-specific knowledge. Despite these efforts, open-source LLMs struggle with complex NL2SQL tasks due to the indirect expression of user query objectives and the semantic gap between user queries and database schemas.
+Inspired by the application of reinforcement learning in mathematical problem-solving to encourage step-by-step reasoning in LLMs, we propose \TheName{} (\underline{Lear}ning \underline{N}L2SQL with \underline{A}ST-guided \underline{T}ask Decomposition), a novel framework that improves the performance of open-source LLMs on complex NL2SQL tasks through task decomposition and reinforcement learning. \TheName{} introduces three key components: (1) a \textit{Decomposition Synthesis Procedure} that leverages Abstract Syntax Trees (ASTs) to guide efficient search and pruning strategies for task decomposition, (2) \textit{Margin-aware Reinforcement Learning}, which employs fine-grained step-level optimization via DPO with AST margins, and (3) \textit{Adaptive Demonstration Reasoning}, a mechanism for dynamically selecting relevant examples to enhance decomposition capabilities.
+Extensive experiments on two benchmark datasets, Spider and BIRD, demonstrate that \TheName{} enables a 7B-parameter open-source LLM to achieve performance comparable to GPT-4, while offering improved efficiency and accessibility. Our work marks a significant step toward democratizing NL2SQL capabilities, illustrating that carefully designed task decomposition strategies can narrow the performance gap between open-source and closed-source models. Furthermore, the proposed approach not only advances the state-of-the-art in NL2SQL but also provides valuable insights into enhancing LLMs' reasoning abilities for complex structured prediction tasks.
+\end{abstract}
+
+
+\section{Introduction}
+
+Natural Language to SQL (NL2SQL)~ is a task that aims to automatically translate natural language queries into executable SQL statements. This task has attracted considerable attention due to its potential to democratize database access, enabling users without SQL expertise to query and interact with databases using natural language. The accurate conversion of natural language into SQL queries is critical for a wide range of applications, including business intelligence, data analysis, and question-answering systems.
+
+Recently, large language models (LLMs), such as OpenAI's GPT-4, have achieved state-of-the-art performance on NL2SQL benchmark datasets, including Spider~ and BIRD~. These models have demonstrated significant potential in bridging the gap between natural language and structured database queries. However, existing efforts predominantly rely on closed-source LLMs, such as GPT-4~ and Gemini~, which heavily depend on prompt engineering techniques~ to achieve optimal results. The reliance on closed-source models introduces several challenges, including concerns about openness, privacy, and computational costs. In contrast, recent efforts to utilize open-source LLMs~ have faced substantial performance gaps~ compared to their closed-source counterparts.
+
+To bridge this performance disparity, prior research has explored strategies such as pre-training~ and post-training~ to equip LLMs with domain-specific knowledge. However, NL2SQL tasks present unique challenges. Natural language queries often contain multiple objectives, which may be explicit (directly corresponding to query results) or implicit (e.g., conditions for filtering results) and are not always directly mappable to the database schema. These characteristics make it exceedingly \textit{difficult for LLMs to effectively solve complex NL2SQL tasks in a single step}.
+
+A promising approach to address this complexity is task decomposition, which involves breaking down a complex NL2SQL query into simpler subtasks, as illustrated in Fig.\ref{fig:teaser}. Recent research has demonstrated that multi-step reasoning methods, such as the ``\texttt{Let's think step by step}'' strategy~, can significantly enhance LLM performance on natural language processing (NLP) tasks through task decomposition.
+
+Building on this idea, we propose a task decomposition framework to tackle complex NL2SQL queries by dividing them into multiple, simpler subtasks. Preliminary experiments (as shown in Fig.~\ref{fig:pre-experiments}) validate this approach: when subtasks are manually provided to the LLM, performance improves significantly (\textcolor{upperformance}{30.4\%$\uparrow$}), underscoring the potential of task decomposition for enhancing NL2SQL performance. However, when the LLM itself is tasked with decomposing complex queries, performance gains are marginal (\textcolor{upperformance}{3.4\%$\uparrow$}), highlighting the need to improve LLMs' task decomposition capabilities for NL2SQL.
+
+Inspired by recent advancements~ that leverage reinforcement learning (RL)~ to enhance LLM reasoning in multi-step tasks, we propose \underline{Lear}ning \underline{N}L2SQL with \underline{A}ST-guided \underline{T}ask Decomposition (\TheName{}). This novel RL-based algorithm is designed to improve LLMs' task decomposition capabilities, thereby enhancing their ability to parse complex SQL queries. Specifically, \TheName{} introduces methodologies for the three foundational RL processes—training data synthesis, model training, and inference—by incorporating the following innovations:
+
+
+\noindent \textbf{Technical challenges and Solutions.}
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textit{Decomposition Synthesis Procedure}: This component employs a search-based strategy, such as Monte Carlo Tree Search (MCTS), to generate subtasks for NL2SQL decomposition. Existing LLM-MCTS hybrid methods rely on heuristic evaluation strategies, where the LLM itself assesses node rewards to guide the search. However, even advanced models like GPT-4 achieve only 46.35\% accuracy on benchmarks such as BIRD, limiting the reliability of such self-evaluation methods. Additionally, the vast search space inherent in text-based MCTS leads to inefficiencies and computational overhead. To address these challenges, we leverage abstract syntax trees (ASTs) to guide the search and implement pruning strategies, significantly improving search efficiency and the success rate of generating valid decompositions.
+ \item \textit{Margin-Aware Reinforcement Learning}: This component enhances LLMs’ decomposition capabilities by adopting reinforcement learning techniques, such as Direct Preference Optimization (DPO)~. Standard DPO algorithms, however, struggle with fine-grained supervision in multi-step reasoning tasks, as they treat all correct and incorrect steps equivalently. To overcome this limitation, we introduce an AST-based margin-aware DPO framework that distinguishes between varying levels of correctness in steps, enabling more precise optimization.
+ \item \textit{Adaptive Demonstration Reasoning}: Prior studies~ have shown that incorporating demonstrations into prompts can significantly improve LLM performance through in-context learning. Building on this insight, we develop an adaptive demonstration selection mechanism that dynamically identifies and injects the most relevant demonstrations into prompts, further refining task decomposition capabilities.
+\end{itemize}
+
+Our contributions can be summarized as follows:
+\begin{enumerate}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item We address the critical challenge of enabling LLMs to understand users’ high-level semantics and map them to database schemas for complex NL2SQL problems. To this end, we propose \TheName{}, a novel framework that improves LLM performance on NL2SQL tasks by leveraging task decomposition and reinforcement learning.
+ \item We introduce the \textit{Decomposition Synthesis Procedure}, which utilizes AST-guided search and pruning to efficiently generate subtasks, and \textit{Margin-Aware Reinforcement Learning}, which enables fine-grained preference learning for multi-step reasoning.
+ \item Through extensive experiments on two NL2SQL benchmark datasets, we demonstrate that \TheName{} significantly outperforms existing methods, achieving GPT-4-level performance with a 7B parameter model. These results highlight the efficacy of task decomposition strategies in addressing the challenges of complex NL2SQL tasks.
+\end{enumerate}
+
+
+\section{Preliminaries}
+
+\noindent \textbf{Natural Language to SQL (NL2SQL).}
+The goal of the NL2SQL task is to translate a natural language (NL) question \( Q \) into corresponding SQL query \( Y \), based on a database schema \(S\).
+In more complex scenarios, such as those presented by BIRD~, interpreting NL questions or understanding database values may require incorporating external knowledge, denoted by \( \mathcal{K} \). The prevailing approach to the NL2SQL task adopts a cross-domain framework to assess a model's generalization ability by keeping the training, development, and test sets distinct.
+
+\noindent \textbf{Abstract Syntax Trees (AST).}~\label{ssec:AST}
+An Abstract Syntax Tree (AST) is a structured, hierarchical representation of an SQL query, where each element of the query is captured as a node and the relationships between these elements are encoded as edges.
+This tree-based structure abstracts away from the linear textual representation of SQL, focusing instead on its grammatical structure and logical organization.
+
+Formally, the AST of an SQL query \( Y \) can be defined as a directed acyclic graph (DAG) \( \mathcal{AT}(Y) = (\mathcal{N}, \mathcal{E}) \), where \( \mathcal{N} \) is the set of nodes, each representing a syntactic component of the SQL query. Specifically, every node \( n \in \mathcal{N} \) corresponds to a clause, operator, or operand. We categorize the nodes as follows:
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Clause Nodes (\( n_c \in \mathcal{N}_c \))}: Represent core SQL clauses, such as \texttt{SELECT}, \texttt{FROM}, \texttt{WHERE}, \texttt{GROUP BY}, and \texttt{ORDER BY}.
+ \item \textbf{Operator Nodes (\( n_o \in \mathcal{N}_o \))}: Represent logical or arithmetic operations, such as \texttt{AND}, \texttt{OR}, \texttt{$=$}, \texttt{$>$}, and \texttt{<}.
+ \item \textbf{Operand Nodes (\( n_v \in \mathcal{N}_v \))}: Represent terminal elements like table names, column names, literals, or values from the database schema.
+\end{itemize}
+
+\( \mathcal{E} \subseteq \mathcal{N} \times \mathcal{N} \) is the set of edges, where each directed edge \( e = (n_i, n_j) \in \mathcal{E} \) captures a syntactic dependency from a parent node \( n_i \) to a child node \( n_j \). These edges reflect the hierarchical structure of the query, where high-level clauses dominate subcomponents or conditions.
+
+The root node of \( \mathcal{AT}(Y) \) corresponds to the main clause of the query, typically the \texttt{SELECT} clause. From the root, child nodes represent subsequent clauses or expressions, forming a hierarchical decomposition of the SQL query. For example, a \texttt{WHERE} clause node may have child nodes corresponding to individual conditions, which in turn may contain operators and operands as descendants.
+
+
+\noindent \textbf{Monte Carlo Tree Search (MCTS).}
+Monte Carlo Tree Search (MCTS) is a heuristic search algorithm used for decision-making in large and complex search spaces. It combines tree-based search with stochastic sampling to balance exploration and exploitation, making it particularly effective for problems with vast or unknown state spaces.
+
+Formally, MCTS operates on a search tree \( \mathcal{T} = (\mathcal{S}, \mathcal{A}, \mathcal{M}) \), where:
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \( \mathcal{S} \) is the set of states or nodes in the search space. Each node \( s \in \mathcal{S} \) represents a specific configuration of the environment, such as a partially completed plan or a subproblem in a reasoning task.
+ \item \( \mathcal{A}(s) \) denotes the set of actions available at state \( s \). Each action leads to a child state \( s' \), expanding the search tree.
+ \item \( \mathcal{M} \subseteq \mathcal{S} \times \mathcal{S} \) represents the set of edges, where each edge corresponds to a transition between states through an action.
+\end{itemize}
+
+The MCTS algorithm proceeds iteratively through four phases:
+\begin{enumerate}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Selection}: Starting from the root node \( s_0 \), the algorithm recursively selects child nodes based on a selection policy, typically using the Upper Confidence Bound for Trees (UCT) criterion:
+ \begin{equation}\label{equ:UCT}
+ a^* = \arg\max_{a \in \mathcal{A}(s)} \left( Q(s, a) + c \cdot \sqrt{\frac{\log N(s)}{N(s, a)}} \right),
+ \end{equation}
+ where \( Q(s, a) \) is the estimated reward for taking action \( a \) from state \( s \), \( N(s) \) is the visit count of node \( s \), \( N(s, a) \) is the visit count of action \( a \) from \( s \), and \( c \) is a constant that controls the exploration-exploitation trade-off.
+ \item \textbf{Expansion}: If the selected node is not terminal and has unvisited child nodes, the algorithm expands the tree by adding a new child node corresponding to a valid action from the current state.
+ \item \textbf{Simulation (Rollout)}: From the newly expanded node, a simulation is conducted by selecting actions—often at random or based on a heuristic policy—until reaching a terminal state. The outcome of this simulation provides a reward signal, used to estimate the reward of the node.
+ \item \textbf{Backpropagation}: The reward obtained from the simulation is propagated back through the visited nodes, updating the reward estimations \( Q(s, a) \) and visit counts \( N(s, a) \) along the path from the expanded node to the root.
+\end{enumerate}
+
+The output of MCTS is a policy that selects the action with the highest visit count from the root node:
+\begin{equation}
+ \pi(s_0) = \arg\max_{a \in \mathcal{A}(s_0)} N(s_0, a).
+\end{equation}
+
+
+\noindent \textbf{Direct Preference Optimization (DPO).}
+Reinforcement Learning from Human Feedback (RLHF)~ is an effective strategy for aligning LLMs with human preference, enhancing robustness, reliability, and safety~. It relies on the Bradley-Terry (BT) model~ to define preference probability based on some reward function. Given a prompt \( x \) and two responses—\( y_w \) (preferred) and \( y_l \) (dispreferred)—the probability of preference can be expressed as:
+
+\begin{equation}
+p^{*}_{\mathcal{D}}\left(y_{w} \succ y_{l} \mid x\right) = \sigma\left( r^{*}(x, y_{w}) - r^{*}(x, y_{l}) \right),
+\end{equation}
+
+where \( \sigma(x) = \frac{1}{1+\exp(-x)} \) is the sigmoid function and \( r^* \) represents a latent reward model. RLHF optimizes the policy model \( \pi_{\theta} \) with a Kullback-Leibler (KL) constraint to limit deviation from a reference model \( \pi_{ref} \):
+
+\begin{equation}
+\max \mathbb{E}_{x \sim \mathcal{D}, y \sim \pi_{\theta}(y \mid x)} [ r^*(x, y) ] - \beta \mathbb{D}_{KL} [ \pi_{\theta}(y \mid x) \| \pi_{ref}(y \mid x) ].
+\end{equation}
+
+Here, \( \beta \) regulates the KL divergence to prevent reward hacking~. While effective, RLHF requires careful hyperparameter tuning and involves complex reward modeling and policy training.
+
+To simplify this process, Direct Preference Optimization (DPO)~ was introduced, eliminating the need for an explicit reward model. Instead, DPO directly optimizes the policy using paired preference data. Given a prompt \( x \) with responses \( (y_w, y_l) \), the DPO objective maximizes the likelihood of the preferred response while minimizing that of the dispreferred one:
+
+
+\begin{align}\label{equ:DPO}
+ \mathcal{L}_{\mathrm{DPO}}(\pi_{\theta}; \pi_{\mathrm{ref}}) &=
+ -\mathbb{E}_{(x,y_w,y_l)\sim\mathcal{D}} \notag
+ \left[ \log \sigma \left( \hat{r}_\theta(x, y_w) - \hat{r}_\theta(x, y_l) \right) \right] \\
+ \hat{r}_\theta(x, y) &= \beta \log \frac{ \pi_{\theta}(y \mid x) }{ \pi_{\mathrm{ref}}(y \mid x) }.
+\end{align}
+
+This formulation treats \( \hat{r}_\theta(x, y) \) as an ``implicit reward''~, allowing for direct alignment with human preference while bypassing the need for complex reward modeling and simplifying the overall training process.
+
+
+\section{Methodology}
+
+In this section, we present the methodology of \TheName{}. First, \TheName{} employs the \textit{Decomposition Synthesis Procedure} for generating training data in offline reinforcement learning. Then, it utilizes \textit{Margin-aware Reinforcement Learning} for model fine-tuning. Finally, it adopts \textit{Adaptive Demonstration Reasoning} for NL2SQL with task decomposition.
+
+\subsection{Decomposition Synthesis Procedure}
+
+\TheName{} employs the \textit{Decomposition Synthesis Procedure} for generating training data. The framework of the \textit{Decomposition Synthesis Procedure} is shown in Fig.~\ref{fig:Framework-Of-Data-Generation}.
+Given a natural language query \(Q\), external knowledge \(K\), database schema \(\mathcal{DB}\), and target SQL query \(Y\), \textit{Decomposition Synthesis Procedure} aims to decompose complex NL2SQL tasks into a series of simpler subtask queries, which can be easily translated into corresponding SQL statements.
+The decomposition process is guided by MCTS and AST-based evaluation, ensuring both the correctness and effectiveness of the generated subtasks.
+
+\noindent \textbf{Problem Formulation}
+Let \(\{q_1, q_2, \cdots, q_n\}\) denote a sequence of subtask queries, where $n$ represents the number of subtasks and each \(q_i\) represents a natural language query that captures a component of the original query \(Q\). For each subtask query \(q_i\), \textit{Decomposition Synthesis Procedure} generates a corresponding SQL query \(y_i\). The objective is to find a sequence of subtask queries such that their corresponding SQL queries collectively construct the target SQL query \(Y\).
+
+\noindent \textbf{MCTS-based Decomposition}
+\textit{Decomposition Synthesis Procedure} formulates the decomposition process as a tree search problem, and performs next-step prediction as action \(a\) in each state \(s\). In the Monte Carlo Tree, the root node represents the original query \(Q\), each non-root node represents the state of executing the next subtask, and each path from root node to a leaf node represents a decomposition sequence.
+
+At each state in MCTS, the \textit{Decomposition Synthesis Procedure} employs an LLM to generate the next subtask \(q_i\) and sub-SQL \(y_i\). Formally, each state \( s_i = \{q_i, y_i, \mathcal{AT}(y_i), \mathcal{AT}_{\text{sum}}(y_i), \mathcal{R}(s_i)\} \), where \(\mathcal{AT}(y_i)\) is the AST of \(y_i\), \(\mathcal{AT}_{\text{sum}}(y_i)\) is the merged AST summarizing all nodes from root to node \(s_i\) in MCTS, and \(\mathcal{R}(s_i)\) is the reward estimation of \(s_i\). The \(\mathcal{AT}_{\text{sum}}(y_i)\) is mathematically defined as follows:
+\begin{equation}
+ \mathcal{AT}_{\text{sum}}(y_i) = (\mathcal{N}_{\text{sum}}, \mathcal{E}_{\text{sum}}),
+\end{equation}
+\begin{equation}
+ \mathcal{N}_{\text{sum}} = \bigcup_{j=1}^i \mathcal{N}(\mathcal{AT}(y_j)), \mathcal{E}_{\text{sum}} = \bigcup_{j=1}^i \mathcal{E}(\mathcal{AT}(y_j)).
+\end{equation}
+
+
+\noindent \textbf{Node Classification}
+\textit{Decomposition Synthesis Procedure} classify actions into three categories based on their AST properties:
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Progressive Actions}: Actions where \(\mathcal{AT}(y_i)\) is a subtree of \(\mathcal{AT}(Y)\) and \(\mathcal{AT}(y_i)\) is not a subtree of \(\mathcal{AT}_{\text{sum}}(y_{\text{parent}(i)})\). These actions contribute new information toward the target SQL.
+ For two ASTs \(\mathcal{AT}_1 = (\mathcal{N}_1, \mathcal{E}_1)\) and \(\mathcal{AT}_2 = (\mathcal{N}_2, \mathcal{E}_2)\), We define the subtree relationship as follows:
+ \begin{equation}
+ \text{isSubtree}(\mathcal{AT}_1, \mathcal{AT}_2) = \begin{cases}
+ 1, & \text{if } \mathcal{N}_1 \subseteq \mathcal{N}_2 \text{ and } \mathcal{E}_1 \subseteq \mathcal{E}_2 \\
+ 0, & \text{otherwise}
+ \end{cases}.
+ \end{equation}
+
+ \item \textbf{Redundant Actions}: Actions where \(\mathcal{AT}(y_i)\) is a subtree of \(\mathcal{AT}(Y)\) but is also a subtree of \(\mathcal{AT}_{\text{sum}}(y_{\text{parent}(i)})\). These nodes provide no additional reward to the decomposition.
+
+ \item \textbf{Invalid Actions}: Nodes where \(\mathcal{AT}(y_i)\) is not a subtree of \(\mathcal{AT}(Y)\). These nodes represent incorrect decompositions.
+\end{itemize}
+
+\noindent \textbf{Prune Strategy}
+In traditional MCTS, since the typical scenario involves robotic task execution, \(\mathcal{A}(s)\) is generally defined as a finite action set, such as \texttt{pick up}, \texttt{put down}, etc. However, in the application of LLMs, \(\mathcal{A}(s)\) is usually an infinite action set. This is because LLMs generate actions in the form of text, meaning that even the same subSQL can be expressed as multiple different subtask (action) variations. To reduce the search space of MCTS and improve search efficiency, \textit{Decomposition Synthesis Procedure} adopts a pruning strategy.
+
+Specifically, since the subtask sequence collected by the \textit{Decomposition Synthesis Procedure} corresponds to the action sequence along the path from the root node to a leaf node in MCTS, redundant actions and invalid actions along the path do not need to be included in the subtask list. Therefore, for states containing redundant or invalid actions, the \textit{Decomposition Synthesis Procedure} terminates further action searches to perform pruning.
+
+\noindent \textbf{Reward Estimation}
+In MCTS, it is necessary to estimate $Q(s, a)$ for each state to provide state rewards, thereby guiding the direction of subsequent searches. In general mathematical domains, existing works typically employ either LLM-based self-evaluation or an additional reward model trained for state reward estimation. In this work, the \textit{Decomposition Synthesis Procedure} further leverages information from the AST and designs a rule-based approach to evaluate the state reward.
+
+Since states with redundant actions and invalid actions are pruned, to improve efficiency, reward estimation is only performed for states with progressive actions. Specifically, \textit{Decomposition Synthesis Procedure} estimates the reward of the current state based on the similarity between \(\mathcal{AT}(Y)\) and \(\mathcal{AT}_{\text{sum}}(y_i)\) at the current state.
+
+\begin{equation}
+ \mathcal{R}(s_i) = \text{sim}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)),
+\end{equation}
+
+where \(\text{sim}(\cdot,\cdot)\) denotes the AST similarity measure.
+
+\textit{Decomposition Synthesis Procedure} defines two types of AST similarity, including node-level similarity \(\text{sim}_{\text{node}}\) and structural similarity \(\text{sim}_{\text{struct}}\).
+
+\noindent \underline{Node-level Similarity (\(\text{sim}_{\text{node}}\))}
+The node-level similarity considers different types of nodes separately:
+
+\begin{equation}\label{equ:node-sim}
+ \text{sim}_{\text{node}}(\mathcal{AT}_1, \mathcal{AT}_2) = \sum_{t \in \{c,o,v\}} w_t \cdot \text{sim}_t(\mathcal{AT}_1, \mathcal{AT}_2),
+\end{equation}
+
+where \(w_t\) are weights for each node type with \(\sum_{t} w_t = 1\) and \(t \in \{c,o,v\}\) represents clause nodes, operator nodes, and operand nodes, respectively.
+
+For each node type:
+
+\begin{equation}
+ \text{sim}_t(\mathcal{AT}_1, \mathcal{AT}_2) = \frac{|\mathcal{N}_t(\mathcal{AT}_1) \cap \mathcal{N}_t(\mathcal{AT}_2)|}{|\mathcal{N}_t(\mathcal{AT}_1) \cup \mathcal{N}_t(\mathcal{AT}_2)|},
+\end{equation}
+
+where \(\mathcal{N}_t(\mathcal{AT}_i)\) is the set of nodes of type \(t\) in AST \(\mathcal{AT}_i\).
+
+\noindent \underline{Structural Similarity (\(\text{sim}_{\text{struct}}\))}
+\textit{Decomposition Synthesis Procedure} define structural similarity using the Tree Edit Distance (TED):
+
+\begin{equation}
+ \text{sim}_{\text{struct}}(\mathcal{AT}_1, \mathcal{AT}_2) = 1 - \frac{\text{TED}(\mathcal{AT}_1, \mathcal{AT}_2)}{\max(|\mathcal{AT}_1|, |\mathcal{AT}_2|)},
+\end{equation}
+
+where \(\text{TED}(\mathcal{AT}_1, \mathcal{AT}_2)\) is the minimum number of node operations (insertion, deletion, modification) required to transform \(\mathcal{AT}_1\) into \(\mathcal{AT}_2\), and \(|\mathcal{AT}_i|\) is the number of nodes in AST \(\mathcal{AT}_i\).
+
+Finally, \textit{Decomposition Synthesis Procedure} estimates the reward of the current state as follows:
+
+\begin{align}\label{equ:AST-sim}
+ \mathcal{R}(s_i) & = \alpha \cdot \text{sim}_{\text{node}}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)) \notag \\
+ & + \beta \cdot \text{sim}_{\text{struct}}(\mathcal{AT}_{\text{sum}}(y_i), \mathcal{AT}(Y)),
+\end{align}
+
+where \(\alpha\) and \(\beta\) are adjustment factors for the two types of AST similarity, satisfying \(\alpha + \beta = 1\).
+
+
+\noindent \textbf{Self-improvement Demonstration}\label{sssec:Self-improvement-Demonstration}
+\textit{Decomposition Synthesis Procedure} employs few-shot learning to improve the success rate of task decomposition. Few-shot learning is essentially a form of in-context learning, where a few demonstrations are provided to help the LLM understand user intent, mimic the given format, and learn implicit knowledge.
+
+Initially, \textit{Decomposition Synthesis Procedure} begins with three manually provided task decomposition examples and executes the first round of decomposition. In the $i$-th round of decomposition ($i \geq 2$), to reduce resource consumption, the procedure only decomposes samples that were not successfully decomposed in the previous $i-1$ rounds. Specifically, these are cases where, after the entire MCTS execution, the SQL statement produced at any leaf node does not perfectly match the execution result of the Gold SQL.
+
+To improve the success rate of decomposition, \textit{Decomposition Synthesis Procedure} adopts adaptive demonstrations instead of using the fixed demonstrations from the first round. Specifically, it constructs a demonstration pool, which consists of samples that were successfully decomposed in the previous $i-1$ rounds.
+Given a new task decomposition query, the procedure computes the AST similarity between the query and each query in the demonstration pool. It then selects the top-3 most similar queries as demonstrations to be included in the prompt.
+
+\noindent \textbf{Data Collection}
+During the search process, \textit{Decomposition Synthesis Procedure} collect two types of data for subsequent offline reinforcement learning:
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{Successful Trajectories}: Sequences of \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) that successfully decompose the target SQL, used for supervised fine-tuning.
+ \item \textbf{Contrastive Action Pairs}: Pairs of incorrect action \((q^l_i, y^l_i)\) and their corresponding correct action \((q^w_i, y^w_i)\), used for preference learning.
+\end{itemize}
+
+
+\subsection{Margin-Aware Reinforcement Learning}
+
+\TheName{} propose a \textit{Margin-aware Reinforcement Learning} framework to train the open-source LLM for decomposing complex NL2SQL tasks into manageable subtasks. The framework consists of two phases. First, \textit{Margin-aware Reinforcement Learning} fine-tunes the LLM in a supervised manner based on correct decomposition trajectories, enhancing the model's ability to perform task decomposition and generate the correct output format.
+Then, \textit{Margin-aware Reinforcement Learning} conducts direct preference optimization (DPO) with AST margin on the LLM using contrastive action pairs, suppressing incorrect subtask outputs and achieving finer-grained preference alignment.
+
+\noindent \textbf{Supervised Fine-tuning}
+Given the training data from \textit{Decomposition Synthesis Procedure}, \textit{Margin-aware Reinforcement Learning} first performs supervised fine-tuning on successful decomposition trajectories. In a training instance $(Q, \mathcal{DB}, \mathcal{K}, \{(q_1, y_1), \cdots, (q_n, y_n)\})$,
+\(Q\) is the input query, \(\mathcal{DB}\) is the database schema, \(\mathcal{K}\) is the optional external knowledge, and \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) is the sequence of correct subtask queries and corresponding subSQLs. \textit{Decomposition Synthesis Procedure} treats \([Q, \mathcal{DB}, \mathcal{K}]\) as the prompt \(x\) and \(\{(q_1, y_1), \cdots, (q_n, y_n)\}\) as the target response \(t\), so the supervised fine-tuning objective is to minimize the log-likelihood loss:
+
+\begin{equation}
+ \mathcal{L}_{\text{SFT}} = \mathbb{E}_{(\boldsymbol{x},\boldsymbol{t})}\left[\sum_{i=1}^I\log p_\theta\left(t_i\mid\boldsymbol{t}_{1:i-1},\boldsymbol{x}\right)\right],
+\end{equation}
+
+where \(\theta\) represents the fine-tuned LLM parameters, and \(p_\theta(\boldsymbol{t}\mid\boldsymbol{x})=\prod_{i=1}^Ip_\theta\left(t_i\mid\boldsymbol{t}_{<i},\boldsymbol{x}\right)\) is the conditional probability distribution of target subtask \& subSQL sequence \(t\) given prompt \(x\). \(I\) is the sequence length of \(t\), and \(i\) is the auto-aggressive decoding step.
+
+
+\noindent \textbf{DPO with AST Margin}
+A phenomenon of pessimism suggests that the positive feedback provided by SFT alone cannot prevent LLMs from generating erroneous reasoning pathways.
+Existing works~ indicates that, during the SFT phase, as the probability of preferred outputs (correct responses) increases, the probability of dispreferred outputs (incorrect responses) rises as well.
+\textit{Margin-aware Reinforcement Learning} employs DPO to suppress incorrect subtask outputs.
+
+Specifically, a training instance takes the form of $(Q, \mathcal{DB}, \mathcal{K}, \\ \{(q_1, y_1), \cdots, (q_{i-1}, y_{i-1})\}, (q^w_i, y^w_i), (q^l_i, y^l_i))$
+,where \(\{(q_1, y_1), \cdots, \\ (q_{i-1}, y_{i-1})\}\) is a verified correct subtask sequence, \((q^w_i, y^w_i)\) and \((q^l_i, y^l_i)\) represent the correct and incorrect subtasks branching from the search tree, respectively.
+\textit{Margin-aware Reinforcement Learning} treats \([Q, \mathcal{DB}, \mathcal{K}, \{(q_1, y_1), \cdots, (q_{i-1}, y_{i-1})\}]\) as the prompt \(x\), \((q^w_i, y^w_i)\) as the prefer response, \((q^l_i, y^l_i)\) as the disprefer response, and optimizes \(\theta\) using Eq.~\ref{equ:DPO}.
+
+However, DPO only optimizes the relative likelihood between positive and negative samples. In other words, the model only learns that the positive samples are better than the negative ones, but does not capture \textbf{how much better} the positive samples are compared to the negative ones.
+
+To enable finer-grained preference learning, \textit{Margin-aware Reinforcement Learning} follows the inspiration of ODPO~ by incorporating an offset into the DPO loss to measure the reward margin between positive and negative samples. In the original ODPO~, an additional reward model is trained to estimate rewards for positive and negative samples. \textit{Margin-aware Reinforcement Learning} extends this approach by directly computing the margin between positive and negative samples using reward estimation based on AST similarity.
+
+Specifically, \textit{Margin-aware Reinforcement Learning} estimates the reward margin between two samples as follows:
+
+\begin{equation}
+ \text{margin}((q^w_i, y^w_i), (q^l_i, y^l_i)) = \mathcal{R}(s^w_i) - \mathcal{R}(s^l_i).
+\end{equation}
+
+Finally, the loss of DPO with AST Margin is formulated as follows:
+
+\begin{equation}\label{equ:MDPO}
+\begin{aligned}
+ \mathcal{L}_{\mathrm{MDPO}}(\pi_{\theta}; \pi_{\mathrm{ref}}) =&
+ -\mathbb{E}_{(x,y_w,y_l)\sim\mathcal{D}} \\
+ & \left[ \log \sigma \left( \hat{r}_\theta(x, y_w) - \hat{r}_\theta(x, y_l)
+ - \triangle_r\right) \right],
+\end{aligned}
+\end{equation}
+
+where \(\triangle_r = \text{margin}((q^w_i, y^w_i), (q^l_i, y^l_i))\) is the offset, measuring the reward margin between positive and negative samples.
+
+The AST margin effectively guides the model to learn not only which decomposition steps are preferred, but also how much they are preferred, leading to more nuanced and effective multi-step reasoning capabilities.
+
+\subsection{Adaptive Demonstration Reasoning}
+
+Given the LLM trained with \textit{Margin-Aware Reinforcement Learning}, \TheName{} further employs \textit{Adaptive Demonstration Reasoning} to enhance the LLM's ability to solve NL2SQL tasks.
+
+Similar to the self-improving demonstrations proposed in Sec.~\ref{sssec:Self-improvement-Demonstration}, \textit{Adaptive Demonstration Reasoning} also aims to identify the most helpful demonstrations for solving the current NL2SQL task. However, the key difference is that self-improving demonstrations select demonstrations based on the AST similarity of SQL queries. In contrast, when the LLM infers a new query, its golden SQL is unknown. Therefore, \textit{Adaptive Demonstration Reasoning} must adopt an alternative approach to measure similarity.
+
+The \textit{Adaptive Demonstration Reasoning} framework operates in two phases: (1) embedding cache construction and (2) adaptive demonstration retrieval.
+
+\noindent \textbf{Embedding Cache Construction}
+Given a demonstration pool $\mathcal{D} = \{(Q_i, Y_i)\}_{i=1}^{N}$, where $Q_i$ represents a natural language query and $Y_i$ is the corresponding SQL translation, \textit{Adaptive Demonstration Reasoning} first construct an embedding cache as follows:
+
+\begin{equation}
+ E(Q) = \theta(Q) \in \mathbb{R}^d,
+\end{equation}
+where $E(\cdot)$ denotes the embedding function that maps natural language queries to a $d$-dimensional vector space. \textit{Adaptive Demonstration Reasoning} utilizes the tuned LLM itself to generate these embeddings through a designated embedding endpoint, ensuring the semantic representation aligns with the model's internal understanding.
+
+This pre-processing step is performed offline to reduce runtime computational overhead during inference.
+
+\noindent \textbf{Adaptive Demonstration Retrieval}
+When a new query $Q_{\text{new}}$ is presented, \textit{Adaptive Demonstration Reasoning} employ the following procedure to select the most relevant demonstrations: (1) Compute the embedding of the new query as $e_{\text{new}} = E(q_{\text{new}})$, (2) Calculate the similarity score between the new query embedding and each cached embedding as follows:
+
+\begin{equation}
+ \text{sim}(e_{\text{new}}, E(Q_i)) = \frac{e_{\text{new}} \cdot E(q=Q_i)}{||e_{\text{new}}|| \cdot ||E(Q_i)||}.
+\end{equation}
+
+(3) Select the top-$k$ most similar query-SQL pairs, denoted as
+
+\begin{equation}
+ \mathcal{T} = \text{TopK}(\{(Q_i, Y_i, \text{sim}(e_{\text{new}}, E(Q_i)))\}_{i=1}^{N}, k).
+\end{equation}
+
+where $k=3$ in our implementation.
+
+\section{Experiments}
+
+\subsection{\textbf{Experimental Setup}}
+
+\noindent \textbf{Datasets}
+We use the BIRD-train dataset~ to synthesize decomposition data for complex NL2SQL tasks within the \textit{Decomposition Synthesis Procedure}, which is subsequently employed for \textit{Margin-Aware Reinforcement Learning}. Then, we utilize BIRD-dev~ and Spider-dev~ to evaluate the effectiveness and robustness of \TheName{}. Notably, the databases and user questions in the training and test sets differ completely.
+
+
+The statistics of BIRD-train, BIRD-dev, and Spider-dev used in this study are shown in Table.~\ref{tab:dataset-statistics}. Notably, BIRD-train does not categorize queries based on difficulty levels. Additionally, although BIRD-train provides 9,428 data samples, the gold SQL statements for 425 of them cannot be executed by the SQL executor. Therefore, we filter out these samples considering BIRD-train to contain only 9,003 data samples in our subsequent analysis.
+
+
+\noindent \textbf{Evaluation Metrics.}
+Since the SQL expression styles generated by LLMs may differ from the ground truth in NL2SQL benchmarks~, traditional string-based evaluation metrics, such as Exact Match Accuracy~, are not suitable for our study. Therefore, following prior works~, we adopt the Execution Accuracy (EX) metric, which evaluates the correctness of generated SQL queries by comparing their execution results with those of the corresponding ground-truth queries retrieved from the database.
+
+\noindent \textbf{Baselines.}
+In this experiment, we compare two types of baselines, including 10 prompting-based approaches and 3 fine-tuning-based approaches, as mentioned in Sec.~\ref{ssec:nlsql-solution}. The prompting-based methods include C3-SQL~, ACT-SQL~, DIN-SQL~, MetaSQL~, DAIL-SQL~, ZeroNL2SQL~, MAG-SQL~, MAC-SQL~, SuperSQL~ and MCS-SQL~, while the fine-tuning-based methods include CatSQL~, SENSE~ and CodeS .
+
+
+\noindent \textbf{Implementation Details.}
+We employ GLM-4-Plus\footnote{\url{https://bigmodel.cn/dev/api/normal-model/glm-4}} as the primary model for synthesizing decomposition data and fine-tune the model on Qwen2.5-Coder~, including its 7B, 14B, and 32B versions.
+We used the PyTorch library to implement all the algorithms based on the open-source HuggingFace transformers~ and LLaMA-Factory~.
+The experiments are conducted on 8×A100 GPUs. During the SFT stage, we utilize the AdamW optimizer with a learning rate of 2e-5 and a cosine warmup scheduler over three epochs. For DPO training, the Adam optimizer is used with a learning rate of 2e-6, and the $\beta$ parameter is set to 0.2, in accordance with the original DPO configuration. In Eq.~\ref{equ:node-sim}, we assign equal weights to all three nodes, i.e., $w_c = w_o = w_v = 0.33$. Based on our experimental observations, we set $\alpha = 0.75$ and $\beta = 0.25$ in Eq.~\ref{equ:AST-sim}.
+
+\subsection{Results of \textit{Decomposition Synthesis Procedure}}
+
+\subsubsection{\textbf{Statistical Results}}
+
+We evaluated the decomposition performance of the \textit{Decomposition Synthesis Procedure} on BIRD-train and compared it with several baseline decomposition algorithms, including CoT and naive MCTS. The experimental results are shown in Table.~\ref{tab:dataset-generate}.
+
+The results indicate that the \textit{Decomposition Synthesis Procedure} achieved an 80.00\% decomposition success rate, outperforming CoT and naive MCTS by \textcolor{upperformance}{20.93\%$\uparrow$} and \textcolor{upperformance}{8.45\%$\uparrow$}, respectively. Additionally, it is noteworthy that MCTS generated a large number of invalid searches, leading to excessive token consumption. In contrast, our proposed \textit{Decomposition Synthesis Procedure} utilizes AST-guided pruning, enabling high-performance and low-cost (\textcolor{upperformance}{56.38\%$\downarrow$}) decomposition synthesis.
+
+We further tested the performance of self-improving demonstrations over multiple rounds. The results show that adaptive demonstrations significantly improve model performance (\textcolor{upperformance}{1.99\%$\uparrow$}). However, this strategy also has inherent limitations. Table.~\ref{tab:dataset-generate} reveals that self-improving demonstrations achieved notable performance gains in the first round (\textcolor{upperformance}{1.32\%$\uparrow$}), but in the subsequent two rounds, the decomposition performance began to diminish (only \textcolor{upperformance}{0.4\%$\uparrow$} and \textcolor{upperformance}{0.27\%$\uparrow$}). Therefore, to minimize token consumption, we did not proceed with a fourth round of decomposition.
+
+
+\subsubsection{\textbf{Error Case Analysis}}
+
+To further investigate the reasons for the failure of the \textit{Decomposition Synthesis Procedure} in certain cases, we randomly selected 50 unsuccessful cases for error analysis. The error distribution is shown in Fig.~\ref{fig:error-analysis}.
+
+The results indicate that the decomposition failures can be attributed to four distinct types of errors, including schema linking, float computation, unknown rules, and error answer.
+
+We analyze these errors one by one by presenting typical cases for each of the four error attributions.
+
+\noindent \textbf{Case for Schema Linking.}
+
+\noindent [\#Question:] \textit{What is the user avatar url for user 41579158? What is the latest movie rated by him / her?}
+
+\noindent [\#Evidence:] \textit{user avatar url refers to \texttt{user\_avatar\_image\_url}; latest movie rated refers to latest \texttt{rating\_date};}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the LLM misidentified the column, mapping ``\textit{the latest movie rated by him/her}'' to the \texttt{movie\_id} column instead of the \texttt{rating\_date\_utc} column. However, the evidence provided relevant information (although it did not explicitly specify the corresponding column).
+
+\noindent \textbf{Case for Float Computation.}
+
+\noindent [\#Question:] \textit{What is the percentage of the ratings were rated by user who was a subcriber?}
+
+\noindent [\#Evidence:] \textit{user is a subscriber refers to \texttt{user\_subscriber = 1}; percentage of \texttt{ratings = DIVIDE(SUM(user\_subscriber = 1)}, \texttt{SUM(rating\_score))} as percent;}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the LLM did not strictly follow the Gold SQL in executing multiplication before division but instead generated SQL that performed the operations in the reverse order. Although mathematically equivalent, floating-point arithmetic in SQL can introduce numerical precision variations. Since our evaluation metric is Execution Accuracy, this discrepancy led to an inconsistency in the results.
+Specifically, the Gold SQL produced an execution result of 21.648420738414252, whereas the Predicted SQL yielded 21.64842073841425.
+
+\noindent \textbf{Case for Unknown Rules.}
+
+\noindent [\#Question:] \textit{List all movies with the best rating score. State the movie title and number of Mubi user who loves the movie.}
+
+\noindent [\#Evidence:] \textit{best rating score refers to \texttt{rating\_score = 5}; number of Mubi user who loves the movie refers to \texttt{movie\_popularity}}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+In this case, the Gold SQL performed an additional deduplication step (\texttt{DISTINCT}) on the query results, whereas the Predicted SQL did not. This deduplication is a default user-friendly operation, but it was not explicitly stated in the query. As a result, the execution results of the Predicted SQL and Gold SQL differed.
+
+
+\noindent \textbf{Case for Error Answer.}
+
+\noindent [\#Question:] \textit{What is the name of the longest movie title? When was it released?}
+
+\noindent [\#Evidence:] \textit{longest movie title refers to \texttt{MAX(LENGTH(movie\_title))}; when it was released refers to \texttt{movie\_release\_year}}
+
+\noindent [\#Gold SQL]
+
+
+\noindent [\#Predict SQL]
+
+
+Some cases in BIRD-train contain incorrect Gold SQL. For example, in this case, the query requires computing the longest movie, and the evidence explicitly states that the correct computation should be \texttt{MAX(LENGTH(movie\_title))}. However, the Gold SQL incorrectly calculates this by using \texttt{LENGTH(movie\_popularity)}, which is clearly incorrect.
+In contrast, the Predicted SQL correctly implements the intended computation. Therefore, the decomposition failure in this case is a false negative, caused by an error in the Gold SQL.
+
+
+\subsubsection{\textbf{Comparison with Competitive Literature}}
+
+We evaluate \TheName{} on Spider-dev and BIRD-dev benchmarks. To further assess \TheName{}'s robustness, we fine-tune Qwen2.5-Coder models with 7B, 14B, and 32B parameters. Additionally, we compare \TheName{} against recent competitive baselines from the past two years. The results are presented in Table.~\ref{tab:main-result}.
+
+Compared with prompting-based methods, \TheName{}—even with only a 7B model—already outperforms most approaches, although these approaches leverage larger-scale models such as GPT-3.5 or GPT-4 as backbone LLMs.
+MCS-SQL~ achieves remarkable performance, significantly surpassing other prompting-based methods on both Spider-dev and BIRD-dev, and also outperforming the 7B and 14B versions of \TheName{}. Only when \TheName{} scales the model up to 32B can it achieve performance surpassing on BIRD-dev.
+However, while MCS-SQL delivers impressive results, it relies on multiple interactions with GPT-4. According to the hyperparameter settings provided in the MCS-SQL manuscript, achieving its reported performance requires more than 60 interactions with GPT-4, making it highly resource-intensive. In contrast, all \TheName{} results require only a single interaction with the LLM.
+
+Compared to fine-tuning-based methods, \TheName{} demonstrates a more significant performance advantage. Among the prompting-based approaches mentioned, the most competitive is CodeS~, therefore we evaluate both the 7B and 15B versions of CodeS.
+Experimental results show that \TheName{} (7B) achieves a \textcolor{upperformance}{1.0\%$\uparrow$} on Spider-dev and a \textcolor{upperformance}{1.1\%$\uparrow$} on BIRD-dev over CodeS (7B). Similarly, \TheName{} (14B) outperforms CodeS (15B) by a \textcolor{upperformance}{2.0\%$\uparrow$} on Spider-dev and a \textcolor{upperformance}{2.7\%$\uparrow$} on Spider-dev. This indicates that \TheName{} maintains a performance advantage across different model sizes.
+
+
+\subsubsection{\textbf{Ablation Study}}
+
+We evaluate the necessity of each component in \TheName{} by systematically removing individual components and assessing the model’s performance. We use Qwen2.5-Coder-7B as the backbone LLM and conduct evaluations on Spider-dev and BIRD-dev. The results are summarized in Table.~\ref{tab:ablation-study}.
+
+First, we present the most naive baseline (w/o \TheName{}), which represents the basic performance of Qwen2.5-Coder-7B. Then, we remove the AST-guide, replacing it with naive MCTS for decomposition and using vanilla DPO in reinforcement learning. The results show an improvement over w/o \TheName{} (e.g., \textcolor{upperformance}{5.6\%$\uparrow$} on BIRD-dev), indicating that decomposition-based RL enhances LLM performance in complex NL2SQL tasks. However, compared to \TheName{}, the model's performance drops significantly (e.g., \textcolor{downperformance}{5.0\%$\downarrow$} on BIRD-dev), suggesting that without an appropriate reward evaluation, performance improvements are limited. \TheName{} tightly integrates reward modeling with AST, designing a rule-based reward model that significantly enhances LLM performance.
+
+Next, we remove the SFT stage, leading to a performance drop (e.g., \textcolor{downperformance}{3.6\%$\downarrow$} on BIRD-dev), indicating that SFT is necessary for initializing the LLM before applying MDPO, aligning with findings from prior work~. Similarly, removing MDPO results in a performance decline (e.g., \textcolor{downperformance}{4.4\%$\downarrow$} on BIRD-dev), showing that SFT alone teaches the LLM to generate correct outputs but fails to suppress incorrect ones~, which degrades overall model performance. Replacing MDPO with naive DPO further reduces performance, as the lack of margin awareness prevents the LLM from distinguishing critical steps during preference learning, leading to coarse-grained reward estimation and thus suboptimal performance.
+
+We also analyze the importance of few-shot learning by removing demonstrations during inference. The results show that few-shot learning helps the model better follow user intent and learn new knowledge from demonstrations, thereby improving performance. Replacing adaptive demonstration reasoning (ADR) with random demonstration selection (RDR) leads to a performance drop (e.g., \textcolor{downperformance}{1.8\%$\downarrow$} on BIRD-dev), confirming that adaptive demonstrations allow the model to find more relevant examples, further boosting performance.
+
+Finally, we conduct a simple experiment using naive Qwen2.5-Coder-7B with CoT-based decomposition, where the LLM directly decomposes the NL2SQL task and generates SQL. While this setup improves performance (e.g., \textcolor{upperformance}{1.8\%$\uparrow$} on BIRD-dev), it is far less effective than \TheName{}, highlighting the importance of AST-guide decomposition, reinforcement learning and adaptive demonstrations.
+
+
+\subsubsection{\textbf{Analysis of AST Similarity}}
+
+We evaluate the importance of node similarity and structural similarity in \TheName{} by adjusting the weight parameter \(\alpha\) in Eq.~\ref{equ:AST-sim}. Specifically, we vary \(\alpha\) between 0, 0.25, 0.5, 0.75, and 1.0, while ensuring that \(\alpha + \beta = 1\). When \(\alpha = 0\), the model relies entirely on structural similarity. When \(\alpha = 1\), the model relies entirely on node similarity.
+
+Experimental results (illustrated in Fig.~\ref{fig:alpha-figure}) show that using only node similarity or only structural similarity leads to performance degradation, indicating that both types of similarity contribute to evaluation quality.
+A balanced setting (\(\alpha = \beta = 0.5\)) does not achieve optimal performance.
+\TheName{} achieves the best performance when \(0 < \beta < 0.5 < \alpha < 1\), suggesting that node similarity is more effective than structural similarity in AST-based similarity assessment.
+This highlights that while both node and structural similarity are necessary, node similarity plays a slightly more critical role in guiding AST-based decomposition and reward estimation.
+
+
+\section{Discussion}
+
+In this section, we investigate two key research questions to further analyze the rationality of \TheName{}.
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{RQ\#1}: Is a complex MCTS necessary? Could it be replaced by directly using the subSQLs from the Gold SQL to synthesize subtasks?
+\end{itemize}
+
+The answer is \textbf{NO}.
+In the early pilot experiments, we designed a more concise approach: \textit{starting from the Gold SQL}, we extracted a sequence of subSQLs and then used a LLM to translate each subSQL into its corresponding subtask. This initially appeared to be a more effective strategy. However, a critical issue arises—\textit{how can we evaluate the correctness of these subtasks?}
+We attempted to directly use a LLM, such as Qwen2-7b-instruct, to determine whether the generated subtasks were correct. However, this approach achieved only 45.4\% accuracy, indicating that verifying the correctness of subtasks is not straightforward. The LLM often misjudged due to subtle differences; for example, if the Gold SQL query targeted a user's name, but the generated subtask query targeted the user's ID instead, the LLM frequently considered the subtask correct.
+
+In contrast, \TheName{} takes the \textit{Query as the starting point}, generates subtasks for the Query, and verifies them by validating the corresponding subSQLs. Compared to directly verifying the correctness of subtask queries, subSQLs offer a more structured and stable representation, making validation more straightforward. For instance, \TheName{} employs AST-based validation, which enhances the robustness of the verification process.
+
+\begin{itemize}
+[leftmargin=*,itemsep=0pt,parsep=0.3em,topsep=0.2em,partopsep=0.2em]
+ \item \textbf{RQ\#2}: Is the evaluation of UCT rewards (see Eq.~\ref{equ:UCT}) in MCTS necessary? Could it be replaced with a simple depth-first search?
+\end{itemize}
+
+The answer is \textbf{NO}. In MCTS, the role of the UCT is to balance the reward of each state with its exploration count, thereby preventing the search from getting trapped in local optima. If we focus solely on the reward of a state while ignoring its exploration count, MCTS degenerates into a depth-first search strategy, which poses risks in NL2SQL task decomposition for the following reasons:
+
+First, NL2SQL task decomposition is not unique. Even though AST-based subtask evaluation can ensure the correctness of individual subtasks, it sacrifices the diversity of task decomposition. Second, NL2SQL tasks exhibit sequential dependencies, meaning that changes in the execution order of subtasks can lead to incorrect execution results. However, AST-based subtask evaluation can only guarantee the structural correctness of subtasks but cannot ensure the correctness of their execution order. Therefore, by penalizing low visitation counts, the UCT reward helps \TheName{} escape local optima and enables a broader search, thereby improving the correctness of subtask sequencing.
+
+
+\section{Conclusion and Future Works}
+
+In this work, we propose \TheName{}, a novel framework designed to enhance the performance of LLMs on NL2SQL tasks by leveraging task decomposition and reinforcement learning. Our approach addresses a critical challenge in NL2SQL: the difficulty LLMs face in deeply understanding high-level user semantics and formulating a coherent problem-solving process, particularly for complex queries.
+To effectively implement the reinforcement learning algorithm, we introduce the AST-guided \textit{Decomposition Synthesis Procedure}, which enables efficient search and pruning strategies for task decomposition. Furthermore, we propose \textit{Margin-Aware Reinforcement Learning}, a fine-grained preference learning mechanism that refines the decision-making process.
+We validate the efficacy of \TheName{} on two widely-used NL2SQL benchmarks, where experimental results demonstrate significant performance improvements of Qwen2.5-Coder models across three scales, outperforming existing state-of-the-art NL2SQL methods.
+
+Despite the promising results achieved by \TheName{}, certain limitations remain. Specifically, the framework's mandatory application of task decomposition and SQL parsing to all NL2SQL tasks introduces inefficiencies for simpler queries that could be directly resolved through ``fast tinking''. In such cases, the additional decomposition process imposes unnecessary computational overhead in terms of both reasoning complexity and token usage. As a direction for future work, we plan to explore adaptive task decomposition techniques that dynamically balance reasoning cost and performance. This adaptive approach would aim to selectively apply task decomposition only when it offers tangible benefits, thereby improving the overall efficiency and scalability of the framework.

benchmark_dataset/papers/ICLR2026_0007_2504.02327/source_references.tex

@@ -0,0 +1,240 @@
+\begin{thebibliography}{99}
+
+\bibitem[\protect\citeauthoryear{Ekin}{Ekin}{2023}]%
+        {PromptEngineering}
+\bibfield{author}{\bibinfo{person}{Sabit Ekin}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{Prompt engineering for ChatGPT: a quick guide to techniques, tips, and best practices}.
+\newblock \bibinfo{journal}{\emph{Authorea Preprints}} (\bibinfo{year}{2023}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Kim, So, Han, and Lee}{Kim et~al\mbox{.}}{2020}]%
+        {kim2020natural}
+\bibfield{author}{\bibinfo{person}{Hyeonji Kim}, \bibinfo{person}{Byeong-Hoon So}, \bibinfo{person}{Wook-Shin Han}, {and} \bibinfo{person}{Hongrae Lee}.} \bibinfo{year}{2020}\natexlab{}.
+\newblock \showarticletitle{Natural language to SQL: Where are we today?}
+\newblock \bibinfo{journal}{\emph{Proceedings of the VLDB Endowment}} \bibinfo{volume}{13}, \bibinfo{number}{10} (\bibinfo{year}{2020}), \bibinfo{pages}{1737--1750}.
+\newblock
+
+\bibitem[\protect\citeauthoryear{Li, Luo, Chai, Li, and Tang}{Li et~al\mbox{.}}{2024a}]%
+        {SuperSQL}
+\bibfield{author}{\bibinfo{person}{Boyan Li}, \bibinfo{person}{Yuyu Luo}, \bibinfo{person}{Chengliang Chai}, \bibinfo{person}{Guoliang Li}, {and} \bibinfo{person}{Nan Tang}.} \bibinfo{year}{2024}\natexlab{a}.
+\newblock \showarticletitle{The Dawn of Natural Language to SQL: Are We Fully Ready?}
+\newblock \bibinfo{journal}{\emph{Proceedings of the VLDB Endowment}} \bibinfo{volume}{17}, \bibinfo{number}{11} (\bibinfo{year}{2024}), \bibinfo{pages}{3318--3331}.
+\newblock
+
+\bibitem[\protect\citeauthoryear{Gao, Wang, Li, Sun, Qian, Ding, and Zhou}{Gao et~al\mbox{.}}{2024}]%
+        {DAIL-SQL}
+\bibfield{author}{\bibinfo{person}{Dawei Gao}, \bibinfo{person}{Haibin Wang}, \bibinfo{person}{Yaliang Li}, \bibinfo{person}{Xiuyu Sun}, \bibinfo{person}{Yichen Qian}, \bibinfo{person}{Bolin Ding}, {and} \bibinfo{person}{Jingren Zhou}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{Text-to-SQL Empowered by Large Language Models: {A} Benchmark Evaluation}.
+\newblock \bibinfo{journal}{\emph{Proc. {VLDB} Endow.}} \bibinfo{volume}{17}, \bibinfo{number}{5} (\bibinfo{year}{2024}), \bibinfo{pages}{1132--1145}.
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.14778/3641204.3641221}
+\showDOI{\tempurl}
+
+\bibitem[\protect\citeauthoryear{Mao, Wang, Guo, Zeng, Gao, Han, and Liu}{Mao et~al\mbox{.}}{2024}]%
+        {DART-SQL}
+\bibfield{author}{\bibinfo{person}{Wenxin Mao}, \bibinfo{person}{Ruiqi Wang}, \bibinfo{person}{Jiyu Guo}, \bibinfo{person}{Jichuan Zeng}, \bibinfo{person}{Cuiyun Gao}, \bibinfo{person}{Peiyi Han}, {and} \bibinfo{person}{Chuanyi Liu}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{Enhancing Text-to-SQL Parsing through Question Rewriting and Execution-Guided Refinement}. In \bibinfo{booktitle}{\emph{Findings of the Association for Computational Linguistics ACL 2024}}. \bibinfo{pages}{2009--2024}.
+\newblock
+
+\bibitem[\protect\citeauthoryear{Dong, Zhang, Ge, Mao, Gao, Chen, Lin, and Lou}{Dong et~al\mbox{.}}{2023}]%
+        {C3-SQL}
+\bibfield{author}{\bibinfo{person}{Xuemei Dong}, \bibinfo{person}{Chao Zhang}, \bibinfo{person}{Yuhang Ge}, \bibinfo{person}{Yuren Mao}, \bibinfo{person}{Yunjun Gao}, \bibinfo{person}{Lu Chen}, \bibinfo{person}{Jinshu Lin}, {and} \bibinfo{person}{Dongfang Lou}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{{C3:} Zero-shot Text-to-SQL with ChatGPT}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2307.07306} (\bibinfo{year}{2023}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2307.07306}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2307.07306}
+
+\bibitem[\protect\citeauthoryear{Lee, Park, Kim, and Park}{Lee et~al\mbox{.}}{2025}]%
+        {MCS-SQL}
+\bibfield{author}{\bibinfo{person}{Dongjun Lee}, \bibinfo{person}{Choongwon Park}, \bibinfo{person}{Jaehyuk Kim}, {and} \bibinfo{person}{Heesoo Park}.} \bibinfo{year}{2025}\natexlab{}.
+\newblock \showarticletitle{{MCS-SQL:} Leveraging Multiple Prompts and Multiple-Choice Selection For Text-to-SQL Generation}. In \bibinfo{booktitle}{\emph{Proceedings of the 31st International Conference on Computational Linguistics, {COLING} 2025, Abu Dhabi, UAE, January 19-24, 2025}}, \bibfield{editor}{\bibinfo{person}{Owen Rambow}, \bibinfo{person}{Leo Wanner}, \bibinfo{person}{Marianna Apidianaki}, \bibinfo{person}{Hend Al{-}Khalifa}, \bibinfo{person}{Barbara~Di Eugenio}, {and} \bibinfo{person}{Steven Schockaert}} (Eds.). \bibinfo{publisher}{Association for Computational Linguistics}, \bibinfo{pages}{337--353}.
+\newblock
+\urldef\tempurl%
+\url{https://aclanthology.org/2025.coling-main.24/}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Talaei, Pourreza, Chang, Mirhoseini, and Saberi}{Talaei et~al\mbox{.}}{2024}]%
+        {CHESS}
+\bibfield{author}{\bibinfo{person}{Shayan Talaei}, \bibinfo{person}{Mohammadreza Pourreza}, \bibinfo{person}{Yu{-}Chen Chang}, \bibinfo{person}{Azalia Mirhoseini}, {and} \bibinfo{person}{Amin Saberi}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{{CHESS:} Contextual Harnessing for Efficient {SQL} Synthesis}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2405.16755} (\bibinfo{year}{2024}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2405.16755}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2405.16755}
+
+\bibitem[\protect\citeauthoryear{Pourreza, Li, Sun, Chung, Talaei, Kakkar, Gan, Saberi, Ozcan, and Arik}{Pourreza et~al\mbox{.}}{2024}]%
+        {CHASE-SQL}
+\bibfield{author}{\bibinfo{person}{Mohammadreza Pourreza}, \bibinfo{person}{Hailong Li}, \bibinfo{person}{Ruoxi Sun}, \bibinfo{person}{Yeounoh Chung}, \bibinfo{person}{Shayan Talaei}, \bibinfo{person}{Gaurav~Tarlok Kakkar}, \bibinfo{person}{Yu Gan}, \bibinfo{person}{Amin Saberi}, \bibinfo{person}{Fatma Ozcan}, {and} \bibinfo{person}{Sercan~{\"{O}}. Arik}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{{CHASE-SQL:} Multi-Path Reasoning and Preference Optimized Candidate Selection in Text-to-SQL}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2410.01943} (\bibinfo{year}{2024}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2410.01943}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2410.01943}
+
+\bibitem[\protect\citeauthoryear{Pourreza and Rafiei}{Pourreza and Rafiei}{2023}]%
+        {DIN-SQL}
+\bibfield{author}{\bibinfo{person}{Mohammadreza Pourreza} {and} \bibinfo{person}{Davood Rafiei}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{{DIN-SQL:} Decomposed In-Context Learning of Text-to-SQL with Self-Correction}. In \bibinfo{booktitle}{\emph{Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023}}, \bibfield{editor}{\bibinfo{person}{Alice Oh}, \bibinfo{person}{Tristan Naumann}, \bibinfo{person}{Amir Globerson}, \bibinfo{person}{Kate Saenko}, \bibinfo{person}{Moritz Hardt}, {and} \bibinfo{person}{Sergey Levine}} (Eds.).
+\newblock
+\urldef\tempurl%
+\url{http://papers.nips.cc/paper\_files/paper/2023/hash/72223cc66f63ca1aa59edaec1b3670e6-Abstract-Conference.html}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Wang, Ren, Yang, Liang, Bai, Chai, Yan, Zhang, Yin, Sun, and Li}{Wang et~al\mbox{.}}{2025}]%
+        {MAC-SQL}
+\bibfield{author}{\bibinfo{person}{Bing Wang}, \bibinfo{person}{Changyu Ren}, \bibinfo{person}{Jian Yang}, \bibinfo{person}{Xinnian Liang}, \bibinfo{person}{Jiaqi Bai}, \bibinfo{person}{Linzheng Chai}, \bibinfo{person}{Zhao Yan}, \bibinfo{person}{Qian{-}Wen Zhang}, \bibinfo{person}{Di Yin}, \bibinfo{person}{Xing Sun}, {and} \bibinfo{person}{Zhoujun Li}.} \bibinfo{year}{2025}\natexlab{}.
+\newblock \showarticletitle{{MAC-SQL:} {A} Multi-Agent Collaborative Framework for Text-to-SQL}. In \bibinfo{booktitle}{\emph{Proceedings of the 31st International Conference on Computational Linguistics, {COLING} 2025, Abu Dhabi, UAE, January 19-24, 2025}}, \bibfield{editor}{\bibinfo{person}{Owen Rambow}, \bibinfo{person}{Leo Wanner}, \bibinfo{person}{Marianna Apidianaki}, \bibinfo{person}{Hend Al{-}Khalifa}, \bibinfo{person}{Barbara~Di Eugenio}, {and} \bibinfo{person}{Steven Schockaert}} (Eds.). \bibinfo{publisher}{Association for Computational Linguistics}, \bibinfo{pages}{540--557}.
+\newblock
+\urldef\tempurl%
+\url{https://aclanthology.org/2025.coling-main.36/}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Shen, Song, Tan, Li, Lu, and Zhuang}{Shen et~al\mbox{.}}{2023}]%
+        {HuggingGPT}
+\bibfield{author}{\bibinfo{person}{Yongliang Shen}, \bibinfo{person}{Kaitao Song}, \bibinfo{person}{Xu Tan}, \bibinfo{person}{Dongsheng Li}, \bibinfo{person}{Weiming Lu}, {and} \bibinfo{person}{Yueting Zhuang}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{HuggingGPT: Solving {AI} Tasks with ChatGPT and its Friends in Hugging Face}. In \bibinfo{booktitle}{\emph{Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023}}, \bibfield{editor}{\bibinfo{person}{Alice Oh}, \bibinfo{person}{Tristan Naumann}, \bibinfo{person}{Amir Globerson}, \bibinfo{person}{Kate Saenko}, \bibinfo{person}{Moritz Hardt}, {and} \bibinfo{person}{Sergey Levine}} (Eds.).
+\newblock
+\urldef\tempurl%
+\url{http://papers.nips.cc/paper\_files/paper/2023/hash/77c33e6a367922d003ff102ffb92b658-Abstract-Conference.html}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Zhang, Dong, Li, Zhang, Sun, Wang, Li, Hu, Zhang, Wu, et~al\mbox{.}}{Zhang et~al\mbox{.}}{2023b}]%
+        {zhang2023instruction}
+\bibfield{author}{\bibinfo{person}{Shengyu Zhang}, \bibinfo{person}{Linfeng Dong}, \bibinfo{person}{Xiaoya Li}, \bibinfo{person}{Sen Zhang}, \bibinfo{person}{Xiaofei Sun}, \bibinfo{person}{Shuhe Wang}, \bibinfo{person}{Jiwei Li}, \bibinfo{person}{Runyi Hu}, \bibinfo{person}{Tianwei Zhang}, \bibinfo{person}{Fei Wu}, {et~al\mbox{.}}} \bibinfo{year}{2023}\natexlab{b}.
+\newblock \showarticletitle{Instruction tuning for large language models: A survey}.
+\newblock \bibinfo{journal}{\emph{arXiv preprint arXiv:2308.10792}} (\bibinfo{year}{2023}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Yang, Hui, Yang, Yang, Lin, and Zhou}{Yang et~al\mbox{.}}{2024a}]%
+        {SENSE}
+\bibfield{author}{\bibinfo{person}{Jiaxi Yang}, \bibinfo{person}{Binyuan Hui}, \bibinfo{person}{Min Yang}, \bibinfo{person}{Jian Yang}, \bibinfo{person}{Junyang Lin}, {and} \bibinfo{person}{Chang Zhou}.} \bibinfo{year}{2024}\natexlab{a}.
+\newblock \showarticletitle{Synthesizing Text-to-SQL Data from Weak and Strong LLMs}. In \bibinfo{booktitle}{\emph{Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), {ACL} 2024, Bangkok, Thailand, August 11-16, 2024}}, \bibfield{editor}{\bibinfo{person}{Lun{-}Wei Ku}, \bibinfo{person}{Andre Martins}, {and} \bibinfo{person}{Vivek Srikumar}} (Eds.). \bibinfo{publisher}{Association for Computational Linguistics}, \bibinfo{pages}{7864--7875}.
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.18653/V1/2024.ACL-LONG.425}
+\showDOI{\tempurl}
+
+\bibitem[\protect\citeauthoryear{Wu, Li, Lou, and Fu}{Wu et~al\mbox{.}}{2024}]%
+        {DataGpt-SQL-7B}
+\bibfield{author}{\bibinfo{person}{Lixia Wu}, \bibinfo{person}{Peng Li}, \bibinfo{person}{Junhong Lou}, {and} \bibinfo{person}{Lei Fu}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{DataGpt-SQL-7B: An Open-Source Language Model for Text-to-SQL}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2409.15985} (\bibinfo{year}{2024}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2409.15985}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2409.15985}
+
+\bibitem[\protect\citeauthoryear{Li, Zhang, Liu, Fan, Zhang, Zhu, Wei, Pan, Li, and Chen}{Li et~al\mbox{.}}{2024b}]%
+        {CodeS}
+\bibfield{author}{\bibinfo{person}{Haoyang Li}, \bibinfo{person}{Jing Zhang}, \bibinfo{person}{Hanbing Liu}, \bibinfo{person}{Ju Fan}, \bibinfo{person}{Xiaokang Zhang}, \bibinfo{person}{Jun Zhu}, \bibinfo{person}{Renjie Wei}, \bibinfo{person}{Hongyan Pan}, \bibinfo{person}{Cuiping Li}, {and} \bibinfo{person}{Hong Chen}.} \bibinfo{year}{2024}\natexlab{b}.
+\newblock \showarticletitle{CodeS: Towards Building Open-source Language Models for Text-to-SQL}.
+\newblock \bibinfo{journal}{\emph{Proc. {ACM} Manag. Data}} \bibinfo{volume}{2}, \bibinfo{number}{3} (\bibinfo{year}{2024}), \bibinfo{pages}{127}.
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.1145/3654930}
+\showDOI{\tempurl}
+
+\bibitem[\protect\citeauthoryear{Sun, Arik, Nakhost, Dai, Sinha, Yin, and Pfister}{Sun et~al\mbox{.}}{2023}]%
+        {SQL-PaLM}
+\bibfield{author}{\bibinfo{person}{Ruoxi Sun}, \bibinfo{person}{Sercan~{\"{O}}. Arik}, \bibinfo{person}{Hootan Nakhost}, \bibinfo{person}{Hanjun Dai}, \bibinfo{person}{Rajarishi Sinha}, \bibinfo{person}{Pengcheng Yin}, {and} \bibinfo{person}{Tomas Pfister}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{SQL-PaLM: Improved Large Language Model Adaptation for Text-to-SQL}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2306.00739} (\bibinfo{year}{2023}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2306.00739}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2306.00739}
+
+\bibitem[\protect\citeauthoryear{Li, Zhang, Li, and Chen}{Li et~al\mbox{.}}{2023b}]%
+        {RESDSQL}
+\bibfield{author}{\bibinfo{person}{Haoyang Li}, \bibinfo{person}{Jing Zhang}, \bibinfo{person}{Cuiping Li}, {and} \bibinfo{person}{Hong Chen}.} \bibinfo{year}{2023}\natexlab{b}.
+\newblock \showarticletitle{{RESDSQL:} Decoupling Schema Linking and Skeleton Parsing for Text-to-SQL}. In \bibinfo{booktitle}{\emph{Thirty-Seventh {AAAI} Conference on Artificial Intelligence, {AAAI} 2023, Thirty-Fifth Conference on Innovative Applications of Artificial Intelligence, {IAAI} 2023, Thirteenth Symposium on Educational Advances in Artificial Intelligence, {EAAI} 2023, Washington, DC, USA, February 7-14, 2023}}, \bibfield{editor}{\bibinfo{person}{Brian Williams}, \bibinfo{person}{Yiling Chen}, {and} \bibinfo{person}{Jennifer Neville}} (Eds.). \bibinfo{publisher}{{AAAI} Press}, \bibinfo{pages}{13067--13075}.
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.1609/AAAI.V37I11.26535}
+\showDOI{\tempurl}
+
+\bibitem[\protect\citeauthoryear{Feng, Wan, Wen, Wen, Zhang, and Wang}{Feng et~al\mbox{.}}{2023}]%
+        {feng2023alphazero}
+\bibfield{author}{\bibinfo{person}{Xidong Feng}, \bibinfo{person}{Ziyu Wan}, \bibinfo{person}{Muning Wen}, \bibinfo{person}{Ying Wen}, \bibinfo{person}{Weinan Zhang}, {and} \bibinfo{person}{Jun Wang}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{Alphazero-like tree-search can guide large language model decoding and training}.
+\newblock \bibinfo{journal}{\emph{arXiv preprint arXiv:2309.17179}} (\bibinfo{year}{2023}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Chen, Liao, Li, and Fan}{Chen et~al\mbox{.}}{2024}]%
+        {chen2024alphamath}
+\bibfield{author}{\bibinfo{person}{Guoxin Chen}, \bibinfo{person}{Minpeng Liao}, \bibinfo{person}{Chengxi Li}, {and} \bibinfo{person}{Kai Fan}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{AlphaMath Almost Zero: process Supervision without process}.
+\newblock \bibinfo{journal}{\emph{CoRR}}  \bibinfo{volume}{abs/2405.03553} (\bibinfo{year}{2024}).
+\newblock
+\urldef\tempurl%
+\url{https://doi.org/10.48550/ARXIV.2405.03553}
+\showDOI{\tempurl}
+\showeprint[arXiv]{2405.03553}
+
+\bibitem[\protect\citeauthoryear{Xie, Goyal, Zheng, Kan, Lillicrap, Kawaguchi, and Shieh}{Xie et~al\mbox{.}}{2024a}]%
+        {xie2024monte}
+\bibfield{author}{\bibinfo{person}{Yuxi Xie}, \bibinfo{person}{Anirudh Goyal}, \bibinfo{person}{Wenyue Zheng}, \bibinfo{person}{Min-Yen Kan}, \bibinfo{person}{Timothy~P Lillicrap}, \bibinfo{person}{Kenji Kawaguchi}, {and} \bibinfo{person}{Michael Shieh}.} \bibinfo{year}{2024}\natexlab{a}.
+\newblock \showarticletitle{Monte Carlo Tree Search Boosts Reasoning via Iterative Preference Learning}.
+\newblock \bibinfo{journal}{\emph{arXiv preprint arXiv:2405.00451}} (\bibinfo{year}{2024}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Rafailov, Sharma, Mitchell, Manning, Ermon, and Finn}{Rafailov et~al\mbox{.}}{2023}]%
+        {DPO}
+\bibfield{author}{\bibinfo{person}{Rafael Rafailov}, \bibinfo{person}{Archit Sharma}, \bibinfo{person}{Eric Mitchell}, \bibinfo{person}{Christopher~D Manning}, \bibinfo{person}{Stefano Ermon}, {and} \bibinfo{person}{Chelsea Finn}.} \bibinfo{year}{2023}\natexlab{}.
+\newblock \showarticletitle{Direct preference optimization: Your language model is secretly a reward model}.
+\newblock \bibinfo{journal}{\emph{Advances in Neural Information Processing Systems}}  \bibinfo{volume}{36} (\bibinfo{year}{2023}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Hwang, Kim, Kim, Ye, and Seo}{Hwang et~al\mbox{.}}{2024}]%
+        {hwang2024selfexploreavoidpitimproving}
+\bibfield{author}{\bibinfo{person}{Hyeonbin Hwang}, \bibinfo{person}{Doyoung Kim}, \bibinfo{person}{Seungone Kim}, \bibinfo{person}{Seonghyeon Ye}, {and} \bibinfo{person}{Minjoon Seo}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \bibinfo{title}{Self-Explore to Avoid the Pit: Improving the Reasoning Capabilities of Language Models with Fine-grained Rewards}.
+\newblock
+\newblock
+\showeprint[arxiv]{2404.10346}~[cs.CL]
+\urldef\tempurl%
+\url{https://arxiv.org/abs/2404.10346}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Liao, Chu, and Wang}{Liao et~al\mbox{.}}{2024}]%
+        {liao2024tpo}
+\bibfield{author}{\bibinfo{person}{Weibin Liao}, \bibinfo{person}{Xu Chu}, {and} \bibinfo{person}{Yasha Wang}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{TPO: Aligning Large Language Models with Multi-branch \& Multi-step Preference Trees}.
+\newblock \bibinfo{journal}{\emph{arXiv preprint arXiv:2410.12854}} (\bibinfo{year}{2024}).
+\newblock
+
+\bibitem[\protect\citeauthoryear{Setlur, Garg, Geng, Garg, Smith, and Kumar}{Setlur et~al\mbox{.}}{2024}]%
+        {setlur2024rlincorrectsyntheticdata}
+\bibfield{author}{\bibinfo{person}{Amrith Setlur}, \bibinfo{person}{Saurabh Garg}, \bibinfo{person}{Xinyang Geng}, \bibinfo{person}{Naman Garg}, \bibinfo{person}{Virginia Smith}, {and} \bibinfo{person}{Aviral Kumar}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \bibinfo{title}{RL on Incorrect Synthetic Data Scales the Efficiency of LLM Math Reasoning by Eight-Fold}.
+\newblock
+\newblock
+\showeprint[arxiv]{2406.14532}~[cs.LG]
+\urldef\tempurl%
+\url{https://arxiv.org/abs/2406.14532}
+\showURL{%
+\tempurl}
+
+\bibitem[\protect\citeauthoryear{Lai, Tian, Chen, Yang, Peng, and Jia}{Lai et~al\mbox{.}}{2024}]%
+        {lai2024stepdpo}
+\bibfield{author}{\bibinfo{person}{Xin Lai}, \bibinfo{person}{Zhuotao Tian}, \bibinfo{person}{Yukang Chen}, \bibinfo{person}{Senqiao Yang}, \bibinfo{person}{Xiangru Peng}, {and} \bibinfo{person}{Jiaya Jia}.} \bibinfo{year}{2024}\natexlab{}.
+\newblock \showarticletitle{Step-DPO: Step-wise Preference Optimization for Long-chain Reasoning of LLMs}.
+\newblock \bibinfo{journal}{\emph{arXiv:2406.18629}} (\bibinfo{year}{2024}).
+\newblock
+
+\end{thebibliography}

benchmark_dataset/papers/ICLR2026_0007_2504.02327/source_related_work.tex

@@ -0,0 +1,30 @@
+\section{Related Work}\label{sec:related-work}
+
+\subsection{NL2SQL Parsing Based on LLMs}\label{ssec:nlsql-solution}
+
+\noindent \textbf{Prompt Engineering.}
+Prompt engineering~ aims to guide model outputs towards desired results through carefully designed input prompts and can be applied to both open-source and proprietary models.
+In the NL2SQL domain, prompt engineering serves as a crucial technique for enhancing the performance of LLMs~.
+Several studies~ have explored different prompt engineering strategies to enhance NL2SQL performance.
+The most relevant works are DIN-SQL~ and MAC-SQL~, which employ zero-shot prompting (\textit{Let's think step by step}) or few-shot prompting (e.g., using a small set of demonstrations) to help LLMs decompose complex NL2SQL tasks.
+While these methods have achieved significant success on publicly available NL2SQL benchmarks, \textit{open-source models, constrained by smaller parameter sizes and limited pretraining knowledge, exhibit substantially weaker performance in task decomposition compared to closed-source models~.}
+
+\noindent \textbf{Model Fine-tuning.}
+Model fine-tuning~ adapts pre-trained LLMs to specific tasks by adjusting model parameters through additional training. While promising for NL2SQL, this approach is limited to open-source models with accessible parameters.
+Due to the performance gap between open-source and closed-source models, existing research has primarily focused on prompt engineering, with relatively few studies~ dedicated to fine-tuning open-source models.
+\textit{Despite their empirical success, these studies focus solely on learning the target SQL queries while neglecting the reasoning process involved in parsing complex SQL structures. This results in mere memorization of outcomes rather than fostering a deep understanding of the underlying problems.}
+
+\subsection{Enhancing Reasoning with RL}
+
+\noindent \textbf{Search-Guided Reasoning in LLMs.}
+Recent research efforts~ aiming at advancing the reasoning capabilities of LLMs have increasingly incorporated Monte Carlo Tree Search to generate trajectories for model training, yielding significant improvements in reasoning performance. MCTS effectively balances exploration and exploitation, leveraging its forward-looking strategy to provide high-quality, step-level guidance.
+Despite these successes, MCTS-driven methods still face several challenges, such as the \textit{vast search space} inherent to language models and the \textit{difficulty of quantifying node rewards}.
+Existing research in the mathematical domain primarily relies on self-evaluation or training external evaluation models based on labeled data. In the NL2SQL domain, \textit{we introduce a novel approach that leverages abstract syntax trees to quantify node rewards, effectively guiding the model to prioritize the exploration of the most valuable nodes.}
+
+
+\noindent \textbf{Direct Preference Optimization (DPO) Algorithms.}
+Among various reinforcement learning algorithms, Direct Preference Optimization (DPO) ~ has gained popularity due to its simplicity.
+DPO relies on instance-level preference signals for model optimization. However, it faces challenges in handling multi-step reasoning tasks, as it struggles to rectify specific errors that arise during the reasoning process~.
+Additionally, relying on model-generated positive samples can reinforce misleading correlations that stem from flawed intermediate steps, thereby weakening generalization~.
+To address these challenges, recent research has introduced step-level DPO~, which offers more granular error identification and thus improves reasoning accuracy.
+\textit{However, the naive DPO algorithm struggles to capture fine-grained, step-level supervisory signals in multi-step preference learning. This uniform treatment of all correct and incorrect steps significantly limits the model's potential for optimization.}

benchmark_dataset/papers/ICLR2026_0008_2510.19060/metadata.json

@@ -0,0 +1,70 @@
+{
+  "paper_id": "ICLR2026_0008_2510.19060",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "PoSh: Using Scene Graphs to Guide LLMs-as-a-Judge for Detailed Image Descriptions",
+  "authors": [
+    "Amith Ananthram",
+    "Elias Stengel-Eskin",
+    "Lorena A. Bradford",
+    "Julia Demarest",
+    "Adam Purvis",
+    "Keith Krut",
+    "Robert Stein",
+    "Rina Elster Pantalony",
+    "Mohit Bansal",
+    "Kathleen McKeown"
+  ],
+  "domain_score": 25,
+  "domain_areas": [
+    "model_architecture",
+    "pretraining_posttraining_instruction_alignment",
+    "multimodal",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "UBhY1c4r2W",
+  "openreview_forum": "UBhY1c4r2W",
+  "openreview_url": "https://openreview.net/forum?id=UBhY1c4r2W",
+  "arxiv_id": "2510.19060",
+  "arxiv_id_versioned": "2510.19060v3",
+  "arxiv_abs_url": "http://arxiv.org/abs/2510.19060v3",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2510.19060v3",
+  "arxiv_source_url": "https://arxiv.org/e-print/2510.19060",
+  "arxiv_title": "PoSh: Using Scene Graphs To Guide LLMs-as-a-Judge For Detailed Image Descriptions",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-10-21T20:30:20Z",
+  "arxiv_updated": "2026-02-26T18:05:42Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 2,
+  "status": "ok",
+  "main_tex_original_path": "iclr_cameraready.tex",
+  "expanded_inputs_count": 1,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "kreiss2022context",
+    "deutsch2022limitations",
+    "papineni2002bleu",
+    "lin2004rouge",
+    "banerjee2005meteor",
+    "vedantam2015cider",
+    "see2017get",
+    "hessel2021clipscore",
+    "sarto2023positive",
+    "chan2023clair",
+    "cheng2025caparena",
+    "xiong2024llavacritic",
+    "anderson2016spice",
+    "dong2024benchmarking",
+    "scialom2021questeval",
+    "chodavidsonian",
+    "urbanek2024picture",
+    "onoe2024docci",
+    "garg-etal-2024-imageinwords",
+    "lu2025benchmarking",
+    "ye2025painting"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0008_2510.19060/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:545bab015e41e1581e1f2c8e1d0a204401bc4ea0849269416f6a71604be84ad6
+size 11045886

benchmark_dataset/papers/ICLR2026_0008_2510.19060/source.tex

@@ -0,0 +1,937 @@
+\documentclass{article}
+\usepackage{iclr2026_conference,times}
+
+
+\usepackage{amsmath,amsfonts,bm}
+
+\newcommand{\figleft}{{\em (Left)}}
+\newcommand{\figcenter}{{\em (Center)}}
+\newcommand{\figright}{{\em (Right)}}
+\newcommand{\figtop}{{\em (Top)}}
+\newcommand{\figbottom}{{\em (Bottom)}}
+\newcommand{\captiona}{{\em (a)}}
+\newcommand{\captionb}{{\em (b)}}
+\newcommand{\captionc}{{\em (c)}}
+\newcommand{\captiond}{{\em (d)}}
+
+\newcommand{\newterm}[1]{{\bf #1}}
+
+
+\def\figref#1{figure~\ref{#1}}
+\def\Figref#1{Figure~\ref{#1}}
+\def\twofigref#1#2{figures \ref{#1} and \ref{#2}}
+\def\quadfigref#1#2#3#4{figures \ref{#1}, \ref{#2}, \ref{#3} and \ref{#4}}
+\def\secref#1{section~\ref{#1}}
+\def\Secref#1{Section~\ref{#1}}
+\def\twosecrefs#1#2{sections \ref{#1} and \ref{#2}}
+\def\secrefs#1#2#3{sections \ref{#1}, \ref{#2} and \ref{#3}}
+\def\eqref#1{equation~\ref{#1}}
+\def\Eqref#1{Equation~\ref{#1}}
+\def\plaineqref#1{\ref{#1}}
+\def\chapref#1{chapter~\ref{#1}}
+\def\Chapref#1{Chapter~\ref{#1}}
+\def\rangechapref#1#2{chapters\ref{#1}--\ref{#2}}
+\def\algref#1{algorithm~\ref{#1}}
+\def\Algref#1{Algorithm~\ref{#1}}
+\def\twoalgref#1#2{algorithms \ref{#1} and \ref{#2}}
+\def\Twoalgref#1#2{Algorithms \ref{#1} and \ref{#2}}
+\def\partref#1{part~\ref{#1}}
+\def\Partref#1{Part~\ref{#1}}
+\def\twopartref#1#2{parts \ref{#1} and \ref{#2}}
+
+\def\ceil#1{\lceil #1 \rceil}
+\def\floor#1{\lfloor #1 \rfloor}
+\def\1{\bm{1}}
+\newcommand{\train}{\mathcal{D}}
+\newcommand{\valid}{\mathcal{D_{\mathrm{valid}}}}
+\newcommand{\test}{\mathcal{D_{\mathrm{test}}}}
+
+\def\eps{{\epsilon}}
+
+
+\def\reta{{\textnormal{$\eta$}}}
+\def\ra{{\textnormal{a}}}
+\def\rb{{\textnormal{b}}}
+\def\rc{{\textnormal{c}}}
+\def\rd{{\textnormal{d}}}
+\def\re{{\textnormal{e}}}
+\def\rf{{\textnormal{f}}}
+\def\rg{{\textnormal{g}}}
+\def\rh{{\textnormal{h}}}
+\def\ri{{\textnormal{i}}}
+\def\rj{{\textnormal{j}}}
+\def\rk{{\textnormal{k}}}
+\def\rl{{\textnormal{l}}}
+\def\rn{{\textnormal{n}}}
+\def\ro{{\textnormal{o}}}
+\def\rp{{\textnormal{p}}}
+\def\rq{{\textnormal{q}}}
+\def\rr{{\textnormal{r}}}
+\def\rs{{\textnormal{s}}}
+\def\rt{{\textnormal{t}}}
+\def\ru{{\textnormal{u}}}
+\def\rv{{\textnormal{v}}}
+\def\rw{{\textnormal{w}}}
+\def\rx{{\textnormal{x}}}
+\def\ry{{\textnormal{y}}}
+\def\rz{{\textnormal{z}}}
+
+\def\rvepsilon{{\mathbf{\epsilon}}}
+\def\rvtheta{{\mathbf{\theta}}}
+\def\rva{{\mathbf{a}}}
+\def\rvb{{\mathbf{b}}}
+\def\rvc{{\mathbf{c}}}
+\def\rvd{{\mathbf{d}}}
+\def\rve{{\mathbf{e}}}
+\def\rvf{{\mathbf{f}}}
+\def\rvg{{\mathbf{g}}}
+\def\rvh{{\mathbf{h}}}
+\def\rvu{{\mathbf{i}}}
+\def\rvj{{\mathbf{j}}}
+\def\rvk{{\mathbf{k}}}
+\def\rvl{{\mathbf{l}}}
+\def\rvm{{\mathbf{m}}}
+\def\rvn{{\mathbf{n}}}
+\def\rvo{{\mathbf{o}}}
+\def\rvp{{\mathbf{p}}}
+\def\rvq{{\mathbf{q}}}
+\def\rvr{{\mathbf{r}}}
+\def\rvs{{\mathbf{s}}}
+\def\rvt{{\mathbf{t}}}
+\def\rvu{{\mathbf{u}}}
+\def\rvv{{\mathbf{v}}}
+\def\rvw{{\mathbf{w}}}
+\def\rvx{{\mathbf{x}}}
+\def\rvy{{\mathbf{y}}}
+\def\rvz{{\mathbf{z}}}
+
+\def\erva{{\textnormal{a}}}
+\def\ervb{{\textnormal{b}}}
+\def\ervc{{\textnormal{c}}}
+\def\ervd{{\textnormal{d}}}
+\def\erve{{\textnormal{e}}}
+\def\ervf{{\textnormal{f}}}
+\def\ervg{{\textnormal{g}}}
+\def\ervh{{\textnormal{h}}}
+\def\ervi{{\textnormal{i}}}
+\def\ervj{{\textnormal{j}}}
+\def\ervk{{\textnormal{k}}}
+\def\ervl{{\textnormal{l}}}
+\def\ervm{{\textnormal{m}}}
+\def\ervn{{\textnormal{n}}}
+\def\ervo{{\textnormal{o}}}
+\def\ervp{{\textnormal{p}}}
+\def\ervq{{\textnormal{q}}}
+\def\ervr{{\textnormal{r}}}
+\def\ervs{{\textnormal{s}}}
+\def\ervt{{\textnormal{t}}}
+\def\ervu{{\textnormal{u}}}
+\def\ervv{{\textnormal{v}}}
+\def\ervw{{\textnormal{w}}}
+\def\ervx{{\textnormal{x}}}
+\def\ervy{{\textnormal{y}}}
+\def\ervz{{\textnormal{z}}}
+
+\def\rmA{{\mathbf{A}}}
+\def\rmB{{\mathbf{B}}}
+\def\rmC{{\mathbf{C}}}
+\def\rmD{{\mathbf{D}}}
+\def\rmE{{\mathbf{E}}}
+\def\rmF{{\mathbf{F}}}
+\def\rmG{{\mathbf{G}}}
+\def\rmH{{\mathbf{H}}}
+\def\rmI{{\mathbf{I}}}
+\def\rmJ{{\mathbf{J}}}
+\def\rmK{{\mathbf{K}}}
+\def\rmL{{\mathbf{L}}}
+\def\rmM{{\mathbf{M}}}
+\def\rmN{{\mathbf{N}}}
+\def\rmO{{\mathbf{O}}}
+\def\rmP{{\mathbf{P}}}
+\def\rmQ{{\mathbf{Q}}}
+\def\rmR{{\mathbf{R}}}
+\def\rmS{{\mathbf{S}}}
+\def\rmT{{\mathbf{T}}}
+\def\rmU{{\mathbf{U}}}
+\def\rmV{{\mathbf{V}}}
+\def\rmW{{\mathbf{W}}}
+\def\rmX{{\mathbf{X}}}
+\def\rmY{{\mathbf{Y}}}
+\def\rmZ{{\mathbf{Z}}}
+
+\def\ermA{{\textnormal{A}}}
+\def\ermB{{\textnormal{B}}}
+\def\ermC{{\textnormal{C}}}
+\def\ermD{{\textnormal{D}}}
+\def\ermE{{\textnormal{E}}}
+\def\ermF{{\textnormal{F}}}
+\def\ermG{{\textnormal{G}}}
+\def\ermH{{\textnormal{H}}}
+\def\ermI{{\textnormal{I}}}
+\def\ermJ{{\textnormal{J}}}
+\def\ermK{{\textnormal{K}}}
+\def\ermL{{\textnormal{L}}}
+\def\ermM{{\textnormal{M}}}
+\def\ermN{{\textnormal{N}}}
+\def\ermO{{\textnormal{O}}}
+\def\ermP{{\textnormal{P}}}
+\def\ermQ{{\textnormal{Q}}}
+\def\ermR{{\textnormal{R}}}
+\def\ermS{{\textnormal{S}}}
+\def\ermT{{\textnormal{T}}}
+\def\ermU{{\textnormal{U}}}
+\def\ermV{{\textnormal{V}}}
+\def\ermW{{\textnormal{W}}}
+\def\ermX{{\textnormal{X}}}
+\def\ermY{{\textnormal{Y}}}
+\def\ermZ{{\textnormal{Z}}}
+
+\def\vzero{{\bm{0}}}
+\def\vone{{\bm{1}}}
+\def\vmu{{\bm{\mu}}}
+\def\vtheta{{\bm{\theta}}}
+\def\va{{\bm{a}}}
+\def\vb{{\bm{b}}}
+\def\vc{{\bm{c}}}
+\def\vd{{\bm{d}}}
+\def\ve{{\bm{e}}}
+\def\vf{{\bm{f}}}
+\def\vg{{\bm{g}}}
+\def\vh{{\bm{h}}}
+\def\vi{{\bm{i}}}
+\def\vj{{\bm{j}}}
+\def\vk{{\bm{k}}}
+\def\vl{{\bm{l}}}
+\def\vm{{\bm{m}}}
+\def\vn{{\bm{n}}}
+\def\vo{{\bm{o}}}
+\def\vp{{\bm{p}}}
+\def\vq{{\bm{q}}}
+\def\vr{{\bm{r}}}
+\def\vs{{\bm{s}}}
+\def\vt{{\bm{t}}}
+\def\vu{{\bm{u}}}
+\def\vv{{\bm{v}}}
+\def\vw{{\bm{w}}}
+\def\vx{{\bm{x}}}
+\def\vy{{\bm{y}}}
+\def\vz{{\bm{z}}}
+
+\def\evalpha{{\alpha}}
+\def\evbeta{{\beta}}
+\def\evepsilon{{\epsilon}}
+\def\evlambda{{\lambda}}
+\def\evomega{{\omega}}
+\def\evmu{{\mu}}
+\def\evpsi{{\psi}}
+\def\evsigma{{\sigma}}
+\def\evtheta{{\theta}}
+\def\eva{{a}}
+\def\evb{{b}}
+\def\evc{{c}}
+\def\evd{{d}}
+\def\eve{{e}}
+\def\evf{{f}}
+\def\evg{{g}}
+\def\evh{{h}}
+\def\evi{{i}}
+\def\evj{{j}}
+\def\evk{{k}}
+\def\evl{{l}}
+\def\evm{{m}}
+\def\evn{{n}}
+\def\evo{{o}}
+\def\evp{{p}}
+\def\evq{{q}}
+\def\evr{{r}}
+\def\evs{{s}}
+\def\evt{{t}}
+\def\evu{{u}}
+\def\evv{{v}}
+\def\evw{{w}}
+\def\evx{{x}}
+\def\evy{{y}}
+\def\evz{{z}}
+
+\def\mA{{\bm{A}}}
+\def\mB{{\bm{B}}}
+\def\mC{{\bm{C}}}
+\def\mD{{\bm{D}}}
+\def\mE{{\bm{E}}}
+\def\mF{{\bm{F}}}
+\def\mG{{\bm{G}}}
+\def\mH{{\bm{H}}}
+\def\mI{{\bm{I}}}
+\def\mJ{{\bm{J}}}
+\def\mK{{\bm{K}}}
+\def\mL{{\bm{L}}}
+\def\mM{{\bm{M}}}
+\def\mN{{\bm{N}}}
+\def\mO{{\bm{O}}}
+\def\mP{{\bm{P}}}
+\def\mQ{{\bm{Q}}}
+\def\mR{{\bm{R}}}
+\def\mS{{\bm{S}}}
+\def\mT{{\bm{T}}}
+\def\mU{{\bm{U}}}
+\def\mV{{\bm{V}}}
+\def\mW{{\bm{W}}}
+\def\mX{{\bm{X}}}
+\def\mY{{\bm{Y}}}
+\def\mZ{{\bm{Z}}}
+\def\mBeta{{\bm{\beta}}}
+\def\mPhi{{\bm{\Phi}}}
+\def\mLambda{{\bm{\Lambda}}}
+\def\mSigma{{\bm{\Sigma}}}
+
+\DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl}
+\SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{n}
+\newcommand{\tens}[1]{\bm{\mathsfit{#1}}}
+\def\tA{{\tens{A}}}
+\def\tB{{\tens{B}}}
+\def\tC{{\tens{C}}}
+\def\tD{{\tens{D}}}
+\def\tE{{\tens{E}}}
+\def\tF{{\tens{F}}}
+\def\tG{{\tens{G}}}
+\def\tH{{\tens{H}}}
+\def\tI{{\tens{I}}}
+\def\tJ{{\tens{J}}}
+\def\tK{{\tens{K}}}
+\def\tL{{\tens{L}}}
+\def\tM{{\tens{M}}}
+\def\tN{{\tens{N}}}
+\def\tO{{\tens{O}}}
+\def\tP{{\tens{P}}}
+\def\tQ{{\tens{Q}}}
+\def\tR{{\tens{R}}}
+\def\tS{{\tens{S}}}
+\def\tT{{\tens{T}}}
+\def\tU{{\tens{U}}}
+\def\tV{{\tens{V}}}
+\def\tW{{\tens{W}}}
+\def\tX{{\tens{X}}}
+\def\tY{{\tens{Y}}}
+\def\tZ{{\tens{Z}}}
+
+
+\def\gA{{\mathcal{A}}}
+\def\gB{{\mathcal{B}}}
+\def\gC{{\mathcal{C}}}
+\def\gD{{\mathcal{D}}}
+\def\gE{{\mathcal{E}}}
+\def\gF{{\mathcal{F}}}
+\def\gG{{\mathcal{G}}}
+\def\gH{{\mathcal{H}}}
+\def\gI{{\mathcal{I}}}
+\def\gJ{{\mathcal{J}}}
+\def\gK{{\mathcal{K}}}
+\def\gL{{\mathcal{L}}}
+\def\gM{{\mathcal{M}}}
+\def\gN{{\mathcal{N}}}
+\def\gO{{\mathcal{O}}}
+\def\gP{{\mathcal{P}}}
+\def\gQ{{\mathcal{Q}}}
+\def\gR{{\mathcal{R}}}
+\def\gS{{\mathcal{S}}}
+\def\gT{{\mathcal{T}}}
+\def\gU{{\mathcal{U}}}
+\def\gV{{\mathcal{V}}}
+\def\gW{{\mathcal{W}}}
+\def\gX{{\mathcal{X}}}
+\def\gY{{\mathcal{Y}}}
+\def\gZ{{\mathcal{Z}}}
+
+\def\sA{{\mathbb{A}}}
+\def\sB{{\mathbb{B}}}
+\def\sC{{\mathbb{C}}}
+\def\sD{{\mathbb{D}}}
+\def\sF{{\mathbb{F}}}
+\def\sG{{\mathbb{G}}}
+\def\sH{{\mathbb{H}}}
+\def\sI{{\mathbb{I}}}
+\def\sJ{{\mathbb{J}}}
+\def\sK{{\mathbb{K}}}
+\def\sL{{\mathbb{L}}}
+\def\sM{{\mathbb{M}}}
+\def\sN{{\mathbb{N}}}
+\def\sO{{\mathbb{O}}}
+\def\sP{{\mathbb{P}}}
+\def\sQ{{\mathbb{Q}}}
+\def\sR{{\mathbb{R}}}
+\def\sS{{\mathbb{S}}}
+\def\sT{{\mathbb{T}}}
+\def\sU{{\mathbb{U}}}
+\def\sV{{\mathbb{V}}}
+\def\sW{{\mathbb{W}}}
+\def\sX{{\mathbb{X}}}
+\def\sY{{\mathbb{Y}}}
+\def\sZ{{\mathbb{Z}}}
+
+\def\emLambda{{\Lambda}}
+\def\emA{{A}}
+\def\emB{{B}}
+\def\emC{{C}}
+\def\emD{{D}}
+\def\emE{{E}}
+\def\emF{{F}}
+\def\emG{{G}}
+\def\emH{{H}}
+\def\emI{{I}}
+\def\emJ{{J}}
+\def\emK{{K}}
+\def\emL{{L}}
+\def\emM{{M}}
+\def\emN{{N}}
+\def\emO{{O}}
+\def\emP{{P}}
+\def\emQ{{Q}}
+\def\emR{{R}}
+\def\emS{{S}}
+\def\emT{{T}}
+\def\emU{{U}}
+\def\emV{{V}}
+\def\emW{{W}}
+\def\emX{{X}}
+\def\emY{{Y}}
+\def\emZ{{Z}}
+\def\emSigma{{\Sigma}}
+
+\newcommand{\etens}[1]{\mathsfit{#1}}
+\def\etLambda{{\etens{\Lambda}}}
+\def\etA{{\etens{A}}}
+\def\etB{{\etens{B}}}
+\def\etC{{\etens{C}}}
+\def\etD{{\etens{D}}}
+\def\etE{{\etens{E}}}
+\def\etF{{\etens{F}}}
+\def\etG{{\etens{G}}}
+\def\etH{{\etens{H}}}
+\def\etI{{\etens{I}}}
+\def\etJ{{\etens{J}}}
+\def\etK{{\etens{K}}}
+\def\etL{{\etens{L}}}
+\def\etM{{\etens{M}}}
+\def\etN{{\etens{N}}}
+\def\etO{{\etens{O}}}
+\def\etP{{\etens{P}}}
+\def\etQ{{\etens{Q}}}
+\def\etR{{\etens{R}}}
+\def\etS{{\etens{S}}}
+\def\etT{{\etens{T}}}
+\def\etU{{\etens{U}}}
+\def\etV{{\etens{V}}}
+\def\etW{{\etens{W}}}
+\def\etX{{\etens{X}}}
+\def\etY{{\etens{Y}}}
+\def\etZ{{\etens{Z}}}
+
+\newcommand{\pdata}{p_{\rm{data}}}
+\newcommand{\ptrain}{\hat{p}_{\rm{data}}}
+\newcommand{\Ptrain}{\hat{P}_{\rm{data}}}
+\newcommand{\pmodel}{p_{\rm{model}}}
+\newcommand{\Pmodel}{P_{\rm{model}}}
+\newcommand{\ptildemodel}{\tilde{p}_{\rm{model}}}
+\newcommand{\pencode}{p_{\rm{encoder}}}
+\newcommand{\pdecode}{p_{\rm{decoder}}}
+\newcommand{\precons}{p_{\rm{reconstruct}}}
+
+\newcommand{\laplace}{\mathrm{Laplace}}
+
+\newcommand{\E}{\mathbb{E}}
+\newcommand{\Ls}{\mathcal{L}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\emp}{\tilde{p}}
+\newcommand{\lr}{\alpha}
+\newcommand{\reg}{\lambda}
+\newcommand{\rect}{\mathrm{rectifier}}
+\newcommand{\softmax}{\mathrm{softmax}}
+\newcommand{\sigmoid}{\sigma}
+\newcommand{\softplus}{\zeta}
+\newcommand{\KL}{D_{\mathrm{KL}}}
+\newcommand{\Var}{\mathrm{Var}}
+\newcommand{\standarderror}{\mathrm{SE}}
+\newcommand{\Cov}{\mathrm{Cov}}
+\newcommand{\normlzero}{L^0}
+\newcommand{\normlone}{L^1}
+\newcommand{\normltwo}{L^2}
+\newcommand{\normlp}{L^p}
+\newcommand{\normmax}{L^\infty}
+
+\newcommand{\parents}{Pa}
+
+\DeclareMathOperator*{\argmax}{arg\,max}
+\DeclareMathOperator*{\argmin}{arg\,min}
+
+\DeclareMathOperator{\sign}{sign}
+\DeclareMathOperator{\Tr}{Tr}
+\let\ab\allowbreak
+
+
+\usepackage{hyperref}
+\usepackage{url}
+\usepackage{graphicx}
+\usepackage{multirow}
+\usepackage{booktabs}
+\usepackage{xcolor}
+\usepackage{soul}
+\usepackage{colortbl}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage{tcolorbox}
+\usepackage{listings}
+\usepackage{xspace}
+\usepackage{slantsc}
+\usepackage[capitalise]{cleveref}
+
+\tcbset{
+ llmpromptbase/.style={
+ colback=gray!10,
+ colframe=gray!50,
+ fonttitle=\bfseries,
+ }
+}
+
+\newcommand{\methodshort}{\textsc{PoSh}\xspace}
+\newcommand{\benchmark}{\textsc{DOCENT}\xspace}
+
+\newcommand{\fix}{\marginpar{FIX}}
+\newcommand{\new}{\marginpar{NEW}}
+
+\iclrfinalcopy
+\begin{document}
+
+
+\begin{abstract}
+
+While vision-language models (VLMs) have advanced into detailed image description, evaluation remains a challenge. Standard metrics (e.g. CIDEr, SPICE) were designed for short texts and tuned to recognize errors that are now uncommon, such as object misidentification. In contrast, long texts require sensitivity to attribute and relation attachments and scores that localize errors to particular text spans. In this work, we introduce \methodshort, a metric for detailed image description that uses scene graphs as \textit{structured rubrics} to guide LLMs-as-a-Judge, producing aggregate scores grounded in fine-grained errors (e.g. mistakes in compositional understanding). \methodshort is replicable, interpretable and a better proxy for human raters than existing metrics (including GPT4o-as-a-Judge). To validate \methodshort, we introduce a new dataset, \benchmark. This novel benchmark contains artwork, paired with expert-written references, and model-generated descriptions, augmented with \textit{granular} and \textit{coarse} judgments of their quality from art history students. Thus, \benchmark enables evaluating both detailed image description metrics and detailed image description itself in a challenging new domain. We show that \methodshort achieves stronger correlations (+$0.05$ Spearman $\rho$) with the human judgments in \benchmark than the best open-weight alternatives, is robust to image type (using CapArena, an existing dataset of web imagery) and is a capable reward function, outperforming standard supervised fine-tuning. Then, using \methodshort, we characterize the performance of open and closed models in describing the paintings, sketches and statues in \benchmark and find that foundation models struggle to achieve full, error-free coverage of images with rich scene dynamics, establishing a demanding new task to gauge VLM progress. Through both \methodshort and \benchmark, we hope to enable advances in important areas such as assistive text generation. We make our metric and our benchmark available at \url{https://github.com/amith-ananthram/posh}.
+\end{abstract}
+
+\section{Introduction}
+
+A picture is worth a thousand words -- can vision-language models (VLMs) capture all of them? VLMs have saturated traditional image understanding benchmarks from short captioning to question answering . New, more challenging tasks are needed to measure VLM progress. Detailed image description is of particular interest as it requires \textit{comprehensive} understanding -- e.g., in \cref{fig:teaser}, a VLM must correctly specify \textit{who} is pouring the water. This deep perception is a better proxy for the demands of the real world, where diverse user queries may not be reflected in VQA benchmarks . Moreover, it enables meaningful applications such as image assistive (``alt") text generation that could greatly expand accessibility online .
+
+However, making progress on detailed description requires cheap, reliable methods for scoring models. Human evaluation is costly, involving the painstaking comparison
+of long texts. Even so, there is often no substitute as most metrics were designed for short texts and older models . Moreover, while metrics that produce a single coarse score of overall quality allow for the ranking of models, they offer little insight into the granular issues driving performance. Granular issues include \textit{mistakes} in each generation, like the positions of the people in \cref{fig:teaser}, and \textit{omissions} in each reference, like the details of the bird's beak in \cref{fig:dataset}. Automatically localizing such errors is critical as long generations with similar coarse scores may differ in multiple dimensions of interest (e.g., facial features, body orientations, etc.). Otherwise, prompt and/or model iteration necessitates expensive manual inspection to understand which description aspects need improvement.
+
+
+In this work, we propose \methodshort\footnote{\methodshort (PrOofing Scene grapHs) can judge if your detailed descriptions are what you (really really) want.}, a metric for evaluating detailed descriptions that addresses these challenges. \methodshort extracts scene graphs from a generated description and its reference to use as \textit{structured rubrics} for an LLM to granularly identify mistakes and omissions (see \cref{fig:spicy}), pinpointing the textual spans containing errors like attribute/relation mis-attachment. Then, it aggregates these localized errors into coarse scores for mistakes, omissions and overall quality. Thus, \methodshort weds the strengths of structured methods like scene graphs , which reduce descriptions to their consequential visual components, with the strengths of LLMs/VLMs-as-a-Judge , which flexibly compare these visual components against diverse surface realizations.
+
+As \methodshort's coarse scores are grounded in its granular scores, it is interpretable, providing clear insights into the errors driving model performance. Moreover, because \methodshort is entirely open-weight, it is inexpensive to use and perfectly replicable, an important pre-requisite for both adoption by researchers and deployment by practitioners that is not afforded by closed models.
+
+Efforts to introduce metrics for longer generations have been constrained by a lack of human judgments, especially at a granular scale and for diverse imagery (see \cref{tab:benchmark_comp}). To address this, we introduce \benchmark, a novel benchmark whose focus is visual art. \benchmark contains paintings, sketches and sculptures with expert-written assistive text that exhaustively describes features like clothing, physical orientation, relative positioning and gaze, drawn from the U.S. National Gallery of Art (see \cref{fig:spicy,fig:dataset}). It includes generations from current VLMs with judgments from art history students of their mistakes, omissions and overall quality at two resolutions: granular and coarse. Thus, \benchmark enables evaluating description\footnote{AI research often uses \textit{caption} and \textit{alt-text} interchangeably. However, according to \href{https://www.w3.org/WAI/WCAG21/Understanding/non-text-content.html}{Web Content Accessibility Guidelines}, \textit{captions} are related to an image while \textit{alt-text} conveys the information in an image. As our focus is evaluating generations that could serve as \textit{alt-text}, we use the term \textit{description}.} metrics and descriptions themselves.
+
+We validate \methodshort against the human judgments in \benchmark. We show that \methodshort recovers human description rankings more often (+$3$ percentage points) and achieves stronger correlations with human-derived scores (+$0.05$ Spearman $\rho$) than existing overlap and open-weight alternatives (e.g. SPICE, CAPTURE, LLaVa-Critic), even surpassing GPT4o-as-a-Judge. Moreover, using judgments in CapArena , we show this strength is robust to image type. Then, given its calibration, we experiment with using \methodshort as a reward function for describing the images in \benchmark and find that this yields meaningfully better descriptions than supervised fine-tuning (SFT).
+
+Finally, using \methodshort, we characterize the performance of open and closed models in describing the artwork in \benchmark, establishing a difficult new task. In so doing, we extend detailed description to a technically challenging and socially impactful domain: assistive text generation for artwork, whose visual complexity and diversity stress VLMs (see \cref{fig:teaser}).
+
+In summary, our contributions are:
+
+\begin{enumerate}
+\item We propose \methodshort, a new metric for detailed description evaluation. \methodshort is interpretable, producing \textit{coarse} scores grounded in \textit{granular} scores that are localized to text spans.
+\item We present \benchmark, a new detailed description benchmark with $1,750$ expert-written art descriptions and $900$ \textit{granular} \& \textit{coarse} judgments of generations from informed raters.
+\item We show \methodshort correlates more with \benchmark's judgments than existing metrics and GPT4o while being replicable. On CapArena, we confirm \methodshort is robust to image type.
+\item We demonstrate that using \methodshort as a reward function outperforms SFT on \benchmark.
+\item Using \methodshort and \benchmark, we evaluate both open and closed models on detailed description of artwork, establishing a socially impactful new task to gauge VLM progress.
+\end{enumerate}
+
+
+\section{\methodshort: A New Metric for Detailed Image Description}
+\label{sec:posh}
+
+\methodshort is a reference-based metric for detailed image description evaluation that takes two descriptions, a generation and its reference, and then extracts scene graphs from each to use as \textit{structured rubrics} for granular and coarse evaluation of mistakes (i.e. precision) and omissions (i.e. recall).
+
+It does so in three steps (\cref{fig:spicy}): \textbf{Step 1)} It extracts scene graphs from a generation and its reference that preserve object attachments. \textbf{Step 2)} It evaluates the presence of generation scene graph components in the reference (and reference scene graph components in the generation) through question answering with an LLM to identify granular mistakes (and omissions). \textbf{Step 3)} It produces coarse scores for mistakes and omissions grounded in these granular scores. We discuss each step below.
+
+\paragraph{Scene Graph Extraction} As in SPICE , given a description $d$, a scene graph $G(d)$ is a structured representation of $d$. Specifically, $G(d) = \left< O(d), E(d), K(d) \right>$ where $O(d) \subseteq C$ is a set of objects, $E(d) \subseteq O(d) \times A$ is a set of attributes associated with each object and $K(d) \subseteq O(d) \times R \times O(d)$ are a set of relation edges between objects. $C$, $A$ and $R$ are open-world sets of all possible object, attribute and relation classes.
+
+Given a generation $\textit{gen}$ with its reference $\textit{ref}$ we extract sentence-level scene graphs $G_i(\textit{gen}), G_j(\textit{ref})$ for each using off-the-shelf dependency parsing and combine them via coreference resolution . This produces scene graphs with full coverage of each text where each component is localized to text spans, allowing for grounded, interpretable scoring. We provide pseudocode for this extraction in \cref{sec:spicy_merging}.
+
+
+\paragraph{Granular Scoring} Given a description $d$, its scene graph $G(d)$ and a different description $d^\prime$, we apply the function $\Psi$ to every component $c \in G(d)$ to produce a score reflecting its presence in $d^\prime$.
+
+We implement this function via question answering. We produce templated questions for each scene graph component (object, attribute and relation) $c \in G(d)$ and prompt an open-weight LLM to quantify the degree to which $c$ is described in $d^\prime$. This avoids forcing an alignment between the components of $G(d)$ and $G(d^\prime)$. For example, in \cref{fig:spicy}, the reference describes the figures in the image as a ``trio." Question answering ensures that a generation that refers to all three individually is not penalized for failing to include such collectives.
+
+As objects with the same class may appear many times in a scene graph (e.g., a description of multiple men), questions require the use of unique identifiers (e.g., ``woman in white" in \cref{fig:spicy}) to disambiguate such instances in $d^\prime$. As the identifier used in $d^\prime$ (if any) is not known \textit{a priori}, we test candidate identifiers in three passes, first considering only objects not part of any other objects in $G(d)$ (e.g., ``man" but not ``face of the man"), then objects that are part of other objects in $G(d)$ (e.g., ``face of the man") and finally attributes and relations of objects identified as present in $d^\prime$.
+
+When collecting unique candidate identifiers for an object $o \in O(d)$, we consider its class name (e.g. ``man"), its surface form (e.g. ``musician"), its attributes (e.g. ``tall man"), its relations (e.g. ``man on horse") and if part of a previously identified object, its ``part-of" relation (e.g. ``face of tall man"). We re-write these identifiers using our LLM to improve their fluency and then test each one in bulk for their presence in $d^\prime$. We use the simplest identifier confirmed present by our LLM (if any) to evaluate $o$'s attributes and relations. We provide pseudocode for this templating in \cref{sec:spicy_templating}.
+
+We produce granular mistake scores $\pi$ for every component of $G(\textit{gen})$ and granular omission scores $\rho$ for every component of $G(\textit{ref})$:
+\begin{equation*}
+\begin{minipage}{0.45\textwidth}
+\centering
+$\pi(c_{\textit{gen}}) = \Psi(c_{\textit{gen}}, \textit{ref}), \forall c_{\textit{gen}} \in G(\textit{gen})$
+\end{minipage}
+\hfill
+\begin{minipage}{0.45\textwidth}
+\centering
+$\rho(c_{\textit{ref}}) = \Psi(c_{\textit{ref}}, \textit{gen}), \forall c_{\textit{ref}} \in G(\textit{ref})$
+\end{minipage}
+\end{equation*}
+
+\paragraph{Coarse Scoring}
+
+To maintain interpretability, we calculate coarse scores for mistakes (i.e. precision) and omissions (i.e. recall) by averaging over our granular scores directly:
+\begin{equation*}
+\begin{minipage}{0.45\textwidth}
+\centering
+$\text{Mistakes} = \text{mean}_{c\in O(\textit{gen})}(\pi(c))$
+\end{minipage}
+\hfill
+\begin{minipage}{0.45\textwidth}
+\centering
+$\text{Omissions} = \text{mean}_{c\in O(\textit{ref})}(\rho(c))$
+\end{minipage}
+\end{equation*}
+We note this is a natural place to introduce tunable weights (as in ) to adapt \methodshort to particular datasets. As we aim to demonstrate robustness, we leave these terms unweighted.
+
+\section{\benchmark: A New Benchmark for Detailed Description of Art}
+\label{sec:docent}
+
+\benchmark is a benchmark for evaluating detailed description metrics and detailed descriptions themselves. It consists of $1,750$ works of art with expert-written references from the Open Data Program at the U.S. National Gallery of Art (NGA)\footnote{\url{https://www.nga.gov/open-access-images/open-data.html}}. For $100$ of these images, we produce four generations from current small and frontier VLMs and collect $300$ granular (for $75$ images) and $600$ coarse judgments from annotators knowledgeable in art of \textit{mistakes} and \textit{omissions}\footnote{We forgo fluency as recommended by }. On average, coarse judgments took $5$ minutes and granular judgments took $18$ minutes (six annotation days). This
+highlights both the cost of manual evaluation and the need for metrics that are reliable proxies.
+
+We include summary statistics in \cref{tab:benchmark_comp} and example judgments in \cref{fig:dataset}.
+
+\paragraph{Image / Reference Selection} While the majority of these works are paintings, they include sketches, statues and lithographs (e.g., the bird in \cref{fig:dataset}), all in the public domain. These images span a diverse set of styles (e.g., Baroque, Renaissance, Impressionism, Post-Impressionism), themes (e.g., war, courtship, still life, religion) and topics (e.g., fishing, drinking, animals, boating).
+
+The accompanying references are detailed descriptions whose purpose is accessibility -- as such, they follow guidelines\footnote{\url{www.nga.gov/visit/accessibility/collection-image-descriptions}} that include tips for describing color (e.g., ``color can be likened to temperature") and handling ambiguity (e.g, ``describe what makes something ambiguous"). These context informed requirements highlight the need for reference based metrics .
+
+Compared to existing detailed image description benchmarks, \benchmark contains considerably more visual complexity (see \cref{tab:benchmark_comp}). On average, its images contain $16\%$ more objects and nearly twice as many people\footnote{As measured by OneFormer } who require description of their orientation, features, clothing, etc. Consequently, the average length and scene graph size of its reference descriptions are nearly double.
+
+
+\paragraph{Model Selection} We generate detailed descriptions for $100$ images in \benchmark from four current VLMs that span transparency and model size (from open data/open weight to frontier models): \texttt{LLaVA-1.6-7B} , \texttt{Molmo-D-7B} , \texttt{GPT4o} and \texttt{Claude Sonnet 3.5}. A metric that discriminates among these generations similarly to their human judgments could gauge progress in detailed image description in small and large VLMs over time. Additional details (prompts, date of API access) can be found in \cref{sec:docent_generations}.
+
+\paragraph{Annotators} Given the complexity of our images and the detail of their expert descriptions, we recruit $24$ art history undergraduate majors, masters students and PhD students with domain familiarity to provide high quality judgments of generations. All annotators were sighted with full color vision and native speakers of English. They were compensated at a rate of \$$22$/hour for their time.\footnote{This study was conducted under Columbia University IRB protocol AAAV6216.}
+
+\paragraph{Granular Judgments} Half of our annotators identify \textit{mistakes} and \textit{omissions} in our model generations. For each image, an annotator is shown its reference and then its four model generations in random order. First, they look at the image, read the reference and then the current generation. Next, by selecting narrow text spans, annotators first identify \textit{mistakes} in the generation (i.e. precision errors) and then \textit{omissions} in the reference that are not in the generation (i.e. recall errors). When identifying omissions, as in , we ask annotators to mentally correct narrow mistakes in the generation first to avoid double-penalizing a model for both incorrect specificity and lack of specificity. For example, a generation that describes a \textit{woman} as a \textit{man} is an error in precision but not in recall. We include our task instructions and interface\footnotemark{} screenshots in \cref{fig:granular_annotation_instructions,fig:granular_annotation_interface}.
+
+\paragraph{Coarse Judgments}
+
+The other half of our annotators provide coarse judgments of our model generations. For a given image, an annotator is shown its reference and two generations (\texttt{\#1} and \texttt{\#2}) in random order and asked to rank the generations in terms of \texttt{mistakes} (i.e. precision), \texttt{omissions} (i.e. recall) and \texttt{overall quality}. These pairwise judgments avoid some of the inter-annotator inconsistency of Likert ratings, especially for long text .
+
+Annotators select among five choices for each dimension: \texttt{\#1 much better}, \texttt{\#1 slightly better}, \texttt{equal}, \texttt{\#2 slightly better} and \texttt{\#2 much better}. As with our granular judgments, we ask annotators to mentally correct narrow mistakes (i.e. precision errors)
+in each generation before judging omissions. To avoid favoring previously seen generations, we ensure no annotator sees the same generation more than once. We include our task instructions and screenshots of our annotation interface\footnotemark[\value{footnote}] in \cref{fig:coarse_annotation_instructions,fig:coarse_annotation_interface}. \footnotetext{Hosted on Label Studio (\url{https://labelstud.io})}
+
+\paragraph{Agreement} For a given image, each generation / pair of generations receives at least one granular and one coarse judgment respectively. For $15\%$ of our tasks, we collect additional judgments from our annotators ($2$ for coarse, $1$ for granular). Additionally, for $20$ granular tasks and $30$ coarse tasks, we collect expert judgments from a PhD in art history who authors assistive text at an art museum. We use these extra judgments to calculate agreement in two ways (among our annotators and between our annotators and our expert). We report agreement in \cref{tab:docent_granular,tab:docent_coarse} of the Appendix.
+
+For our granular judgments, as recommended by for span annotation tasks where the boundaries of negative examples (i.e. non-errors) are ill-defined, we measure agreement using the relaxed F1 (matching spans that contain 50\% overlapping tokens). Under this measure, our student annotators exhibit strong agreement among themselves and with our expert.
+
+Our coarse judgments exhibit moderate inter-annotator agreement, with Krippendorf's $\alpha=0.509$, $0.409$ and $0.459$ for mistakes, omissions and overall quality . This level of agreement is unsurprising for coarse detailed description evaluation -- judgment requires weighing the relative importance of each text's granular errors and is consequently more subjective. Nevertheless, our student annotators exhibit moderate to strong correlations with our expert, with significant Pearson $\rho$ values of $0.727$, $0.501$ and $0.492$ for mistakes, omissions and overall quality respectively.
+
+\paragraph{How well do these VLMs describe art?} When considering the performance of the four models included in \benchmark, we observe expected trends, adding to our confidence in the quality of our judgments: the smaller models make more mistakes and have more omissions than the larger models (see \cref{tab:docent_granular,tab:docent_coarse}). Though most models make few mistakes, they all struggle with omissions. The best model, \texttt{gpt4o} covers only $50.1\%$ of the visual information conveyed in \benchmark's references. Raising this requires continued prompt iteration, highlighting the need for an automated metric that can reliably measure both granular and coarse differences in mistakes and omissions.
+
+\section{Experiments}
+
+\paragraph{\methodshort} We extract sentence-level scene graphs using \texttt{en\_core\_web\_trf} from , a transformer trained to perform dependency parsing. To merge objects across these scene graphs while preserving attribute and relation attachments, we use \texttt{maverick-mes-ontonotes} from to perform co-reference resolution. Our QA scorer $\Psi$ is \texttt{qwen-3-14b} . We template evaluation questions for each scene graph component (as in \cref{fig:spicy}), re-write candidate identifiers using $\Psi$ to improve fluency and then prompt $\Psi$ to answer each templated presence question by predicting a number between $1$ and $5$. We extract scores by taking the weighted average over the token logits for each number as in . When determining object presence, we use a threshold of $2$, determined through tuning on a small hand-annotated validation set. We provide further implementation details and all prompts used in \cref{sec:posh_appendix}.
+
+\paragraph{Benchmarks}
+
+We evaluate \methodshort against the judgments in \benchmark and CapArena.
+
+\textsc{\it{DOCENT}} is our new detailed description benchmark containing judgments from knowledgeable human annotators: granular mistake and omission spans for $300$ individual generations and coarse scaled rankings of mistakes, omissions and overall quality of $600$ paired generations. We evaluate granular metrics on this benchmark using macro F1 where we credit/penalize a model for predicting each annotated/unannotated token. Our coarse judgments are in the form $(text_1, text_2, score)$ where score indicates how much better or worse $text_1$ is than $text_2$. We evaluate each coarse metric $m$ by calculating its 1) pairwise accuracy (whether it picks the better text or a tie, using a tie threshold inferred from the gold tie rate) and 2) Spearman rank $\rho$ and Kendall's $\tau$ correlations between $m(text_1) - m(text_2)$ and $score$, a common practice in machine translation metric evaluation . More details can be found in \cref{sec:eval_metrics}.
+
+\textsc{\it{CapArena}} contains $3,361$ images and $10,348$ detailed descriptions generated from $14$ current VLMs. $5,599$ pairs of these generations receive coarse judgments from human raters of the better generation (or ``tie"). We include CapArena, which contains diverse images drawn from the web, to validate metric robustness. However, we note the dramatic simplicity of its images and references compared to those in \benchmark (see \cref{tab:benchmark_comp}). $64\%$ of its images\footnote{As measured by OneFormer } contain fewer than two objects and $95\%$ depict fewer than two people (compared to $27\%$\ and $52\%$ in \benchmark).
+A metric is evaluated on CapArena at the caption-level (whether it picks the better text or a tie, using a tie threshold inferred from the gold tie rate) and at the model-level (Spearman's rank and Kendall's $\tau$ correlation between ELO rankings derived from metric predictions and gold judgments).
+
+\paragraph{Granular Baselines} Our work is the first to introduce both a metric and a benchmark for granular evaluation of detailed descriptions. As such, this limits our baselines to those able to predict \textit{localized} mistakes and omissions (i.e., the spans where errors occur). We consider two embedding-based approaches, using \texttt{Qwen/Qwen3-Embedding-8B} from : \textbf{4GramEmbed}, which embeds and compares $4$-grams from a generation and its reference, and \textbf{SGEmbed}, which embeds and compares components from the scene graphs of a generation and its reference. As these approaches (and \methodshort) produce span scores, we report the maximum F1 scores for mistakes and omissions across all alerting thresholds. More details can be found in \cref{sec:granular_eval_baselines}.
+
+\paragraph{Coarse Baselines} Though \methodshort is a text-only reference-based metric, we select a representative set of reference-free (requiring only an image) and reference-based (requiring a gold standard) pointwise metrics (i.e. produce numerical scores) as our baselines. These include n-gram overlap metrics like BLEU , ROUGE-L-Sum , METEOR and CIDER and model-based metrics like SPICE , CLIPScore and CAPTURE . Additionally, we consider several LLMs/VLMs-as-a-Judge\footnote{CLAIR/Faithscore were not included due to complications with their codebases . Due to cost (estimated at \$$1,000$), we only evaluate DCScore on \benchmark.}: FLEUR , Prometheus , LLaVA-Critic , DCScore , Qwen-3 and GPT4o/GPT5 in three settings (reference-free with image, reference-based without image and reference-based with image). More details can be found in \cref{sec:coarse_eval_baselines}.
+
+\paragraph{Reward Function} Finally, given the potential of a well-calibrated metric as a verifier in reinforcement learning (RL), we evaluate \methodshort as a reward function. We train \texttt{Qwen2.5-VL-7B} on the $1,000$ images in \benchmark's training set in two settings: 1) supervised fine-tuning (SFT), and 2) RL with DAPO using \methodshort. We collect coarse judgments (as in \cref{sec:docent}) for $40$ generation pairs from graduate students in NLP. More details can be found in \cref{sec:reinforcement_learning}.
+
+\section{Results \& Discussion}
+
+
+\paragraph{\methodshort as a Granular Metric}
+
+\cref{tab:docent_granular_results} presents the performance of \methodshort and our selected metrics on identifying the mistakes and omissions in \benchmark. Given the imbalanced nature of our data (where mistakes are infrequent and omissions are common), we report macro averages for each subtask, measuring how well each approach localizes errors within a generation and its reference respectively. First, we note that this task is difficult. The considerable room for improvement highlights the value of a benchmark like \benchmark that contains granular judgments of textual spans. Even so, \textbf{\methodshort achieves the highest F1 in mistake ($0.580$) and omission ($0.680$) localization}. As its coarse scores are aggregated from these granular scores, this demonstrates its interpretability.
+
+
+\paragraph{\methodshort as a Coarse Metric}
+
+\cref{tab:coarse_results} presents the performance of \methodshort and the best baselines on predicting the coarse judgments in \benchmark and CapArena (full results in \cref{sec:full_coarse_results}).
+
+On \benchmark, across all three dimensions, \textbf{\methodshort outperforms every existing replicable metric} (i.e., metrics not reliant on an API), yielding a $0.11$ increase in Spearman $\rho$ for mistakes ($25\%\uparrow$), a $0.07$ increase for omissions ($14\%\uparrow$) and a $0.05$ increase for overall quality ($9\%\uparrow$) over the next best. It even outperforms GPT4o (in all settings) and text-only GPT5 (on omissions and overall quality). Among all metrics, DCScore proves best at predicting mistakes. However, its reliance on GPT4o to extract and verify factoids fails to achieve full coverage of reference detail, underperforming in predicting omissions and overall quality. Despite employing a smaller LLM, \methodshort's use of dependency parsing and coreference resolution to extract scene graphs avoids this.
+
+On CapArena, \methodshort achieves higher caption-level accuracies and model-ranking correlations than nearly every existing open-weight metric and GPT4o. The sole exception is LLaVa Critic, a much larger VLM-as-a-Judge . This is driven in part by the simplicity of CapArena (see \cref{tab:benchmark_comp}). On the subset of CapArena depicting three or more people (167 judgments), each of whom requires careful description, \textbf{\methodshort outperforms LLaVa Critic with model ranking correlations of $\mathbf{\rho=0.727, \tau=0.581}$ compared to $\mathbf{\rho=0.686, \tau=0.550}$}. Thus, \methodshort is robust to image type, excelling in visually complex cases that are of particular interest in detailed image description.
+
+\paragraph{\methodshort as a Reward Function} In \cref{tab:rl_results} of the Appendix, we report annotator agreement and aggregate preferences between SFT and DAPO with \methodshort. In each dimension of interest, a \methodshort-tuned generation earns a score between $-2$ and $2$ based on how much worse or better it is than its SFT counterpart. While \methodshort-tuned generations had more mistakes (an average score of $-0.243$), these were incurred in service of \textbf{much fewer missing details ($\mathbf{+0.432}$), resulting in higher overall quality ($\mathbf{+0.135}$)}. This speaks to the strength of \methodshort when optimized directly. Given recent progress in generating synthetic detailed descriptions , \methodshort-tuning could be freely scaled in post-training. Moreover, as \methodshort produces localized granular scores, it supports token-level guidance , an exciting direction to explore in future work.
+
+\paragraph{\methodshort Subcomponent Evaluation} \methodshort relies on two subcomponents, scene graph extraction and scene graph element verification through question answering. As downstream errors may propagate from these components, we validate each through comparison against hand annotated examples from \benchmark. We find that \methodshort's scene graphs are high quality, with average element F1 of $0.892$. Similarly, in verifying these scene graph elements, \methodshort exhibits strong alignment with human raters, with an F1 of $0.852$. We provide additional details and analysis in \cref{sec:subcomponent_perf}.
+
+\paragraph{\methodshort Runtime} A core enabler of \methodshort's performance and interpretability is its thorough granular evaluation. It achieves this efficiently through inference optimizations like continuous batching and prefix caching . \methodshort scores the $400$ examples in \benchmark in $15$ minutes, or one every $2$ seconds, on a single H100 GPU. In contrast, DCScore takes upwards of $2$ hours due to its heavy use of GPT4 (one description every $25$ seconds). As manual evaluation takes $18$ minutes per description (see \cref{tab:benchmark_comp}), \methodshort effectively balances quality and cost.
+
+\section{\benchmark Leaderboard}
+
+Finally, in \cref{fig:leaderboard}, we plot the \methodshort scores of VLMs in describing the art in \benchmark. While closed models like Gemini 2.5 Pro lead, open models remain competitive. Improvements will require continued iteration, informed in part by insights gained from analyzing \methodshort's granular scores.
+
+\section{Conclusion}
+
+We present \methodshort, a novel metric for detailed image description that extracts scene graphs to use as structured rubrics for guiding LLMs-as-a-Judge, providing interpretable, replicable scores. To validate \methodshort, we introduce \benchmark, a new benchmark with expert-written descriptions of visually complex artwork along with granular and coarse judgments of generations from knowledgeable raters. We show that \methodshort correlates better than other metrics with these judgments, is robust to image type and is a capable reward function. Through \methodshort and \benchmark, we introduce a leaderboard for a new challenging task, detailed image description of artwork. It is our hope that this work will drive progress in meaningful areas such as assistive text generation for artwork and beyond.
+
+\section{Limitations}
+Recent efforts have explored using structural priors to guide generation (e.g. ). As these methods extract and describe structure from images, and as \methodshort extracts and validates structure from text, we do not expect \methodshort to be biased towards them in an evaluation setting. Nevertheless, as these models become publicly available, this requires experimental validation.
+
+\section{Ethics Statement}
+
+The judgments in \benchmark were collected under IRB protocol AAAV6216 with all annotator data anonymized and participants receiving fair compensation (at $\$22$/hour) for their time and expertise.
+
+All of the $1,750$ artwork images in \benchmark are in the public domain, and the expert-written reference descriptions were published by the U.S. National Gallery of Art under their Open Data Program\footnote{\url{https://github.com/NationalGalleryOfArt/opendata}} specifically for research purposes, ensuring appropriate use and attribution.
+
+While this work aims to benefit accessibility applications for blind and low-vision users, we acknowledge that direct community involvement in the development process would strengthen future iterations. However, we note that the expert reference descriptions were written according to the National Gallery of Art's accessibility guidelines\footnote{\url{https://www.nga.gov/visit/accessibility/collection-image-descriptions}} which lay out best practices for assistive text.
+
+Finally, as with other computer vision systems, this work could theoretically be applied to surveillance contexts, but our focus on detailed description does not introduce novel privacy risks beyond those inherent to existing image analysis technologies. The primary intended application—improving accessibility—aligns with beneficial societal outcomes.
+
+\section{Reproducibility Statement}
+
+A core motivation behind \methodshort is improving replicability in detailed image description evaluation through the introduction of a performant open-weight metric. In that spirit, we ensure full reproducibilty of our findings by:
+
+\begin{enumerate}
+ \item including comprehensive technical details in the Appendix
+ \item publishing the code for both our metric and our metric evaluations at \url{https://github.com/amith-ananthram/posh}; this implementation supports batch invariance, ensuring perfect reproducibility of our results on an H100 GPU with CUDA 12.8
+ \item publishing our benchmark at \url{https://github.com/amith-ananthram/posh/tree/main/docent}
+ \item making our models and our benchmark available to the broader research community on HuggingFace
+\end{enumerate}
+
+\subsubsection*{Acknowledgments}
+
+This research is being developed in part with funding from the National Science Foundation under Cooperative Agreement PHY-2229929 (the NSF AI Institute for Artificial and Natural Intelligence) and DRL-2112635 (the NSF AI Engage Institute), the Columbia Center for Artificial Intelligence and Technology (CAIT) and ONR Grant N00014-23-1-2356. Data and data science collaboration were provided by the National Gallery of Art in Washington, DC. We gratefully acknowledge use of the research computing resources of the Empire AI Consortium, Inc, with support from Empire State Development of the State of New York, the Simons Foundation, and the Secunda Family Foundation. The views, opinions and/or findings expressed are those of the authors and should not be interpreted as representing the official views or policies of the State of New York, the National Gallery of Art, the National Science Foundation or the U.S. Government.
+
+\appendix
+\section{Appendix}
+\label{sec:appendix}
+
+\subsection{\methodshort}
+\label{sec:posh_appendix}
+
+\subsubsection{Comparison to Davidsonian Scene Graph}
+\label{sec:posh_vs_dsg}
+
+There are several differences between the Davidsonian Scene Graph (DSG) metric and \methodshort. While the emphasis of DSG is on evaluating text-to-image models, \methodshort was designed specifically for detailed image descriptions and is tailored to the unique challenges they pose.
+
+First, the emphasis of DSG is on evaluating text-to-image models: it compares an image to scene graph elements extracted from a prompt text through visual question answering. As such, it cannot serve as a reference-based metric for evaluating detailed image descriptions. Allowing the use of references is important. Downstream tasks have context-specific requirements that can only be specified with references. This is especially true in accessibility .
+
+Additionally, DSG was designed for image generation prompts at most three sentences long (in contrast, \methodshort is able to compare generations and references that are $10$ - $20$ sentences long); DSG prompts GPT-3.5 for atomic propositions that are not localized to text spans (in contrast, \methodshort grounds its coarse scores in localized granular scores with open models, allowing error visualization, better interpretability and replicability), DSG's atomic propositions do not have special handling for entity collisions (in contrast, \methodshort tests discriminating identifiers for colliding entities to allow unique validation of their presence), and finally, DSG applied to detailed image descriptions measures only precision, validating the presence of generation elements in its source image (in contrast, \methodshort measures both precision and recall, penalizing generations for omitting important details).
+
+These differences in design and purpose become clear when evaluating DSG against the judgments in \methodshort, where its accuracies are near chance and its correlations are near zero (see \cref{tab:full_coarse_results}).
+
+\subsubsection{Scene Graph Extraction}
+\label{sec:spicy_merging}
+
+While we provide the complete implementation for our scene graph extraction in our codebase, we include simplified pseudocode below:
+
+\begin{verbatim}
+def GetGraph(text):
+ doc = ParseTextWithSpacy(text)
+ components = ExtractComponents(doc)
+ corefs = GetCorefWithMaverick(doc)
+
+ entities, relations = [], []
+ for each component:
+ if IsNoun(component):
+ if HasEarlierMention(component):
+ UpdateExistingEntity(
+ entities, component
+ )
+ else:
+ CreateNewEntity(
+ entities, component
+ )
+
+ for each component:
+ if IsAdjective(component):
+ UpdateAtributes(
+ entities, component
+ )
+ elif IsVerb(component):
+ UpdateVerbRelations(
+ relations, component
+ )
+ elif IsPrep(component):
+ UpdatePrepRelations(
+ relations, component
+ )
+
+ return (entities, relations)
+\end{verbatim}
+
+\subsubsection{Granular QA Templating}
+\label{sec:spicy_templating}
+
+While we provide the complete implementation for our question templating in our codebase, we include simplified pseudocode below:
+
+\begin{verbatim}
+def TemplateEntityQuestions(
+ text, entities
+):
+ colls = GetCollisions(
+ entities
+ )
+
+ questions = []
+ for e in entities:
+ identifiers = []
+ if IsEmpty(colls):
+ identifiers.add(e.text)
+
+ for each attr in e:
+ if IsUnique(attr, colls):
+ identifiers.add(
+ attr + e.text
+ )
+
+ if len(identifiers) > 0:
+ AddToQuestions(identifiers)
+ continue
+
+ for each rel in e:
+ if IsUnique(rel, colls)
+ identifiers.add(
+ rel.head +
+ rel.text +
+ rel.tail
+ )
+
+ AddToQuestions(identifiers)
+
+ ReWriteIdentifiers(questions)
+
+def TemplateAttrRelQuestions(
+ text, entities
+):
+ questions = []
+ for e in entities:
+ for attr in e:
+ AddToQuestions(
+ attr, e.identifier
+ )
+ for rel in e:
+ AddToQuestions(
+ rel, e.identifier
+ )
+\end{verbatim}
+
+\subsubsection{Prompts}
+
+\begin{tcolorbox}[llmpromptbase, title=Entity Identifier Rewrite Prompt (for attributes)]
+
+
+\end{tcolorbox}
+
+\begin{tcolorbox}[llmpromptbase, title=Entity Identifier Rewrite Prompt (for relations)]
+
+
+\end{tcolorbox}
+
+\begin{tcolorbox}[llmpromptbase, title=Verification Prompt]
+
+
+\end{tcolorbox}
+
+\subsection{\benchmark}
+\subsubsection{Generations}
+\label{sec:docent_generations}
+
+We produce generations from the following models:
+\begin{enumerate}
+ \item \texttt{llava-v1.6-mistral-7b-hf} on HuggingFace
+ \item \texttt{Molmo-7B-D-0924} on HuggingFace
+ \item \texttt{gpt-4o-2024-08-06}, accessed on 1/31/25
+ \item \texttt{claude-3-5-sonnet-20241022}, accessed on 1/31/25
+\end{enumerate}
+
+We use the same prompt (included below). For \texttt{LLaVA-1.5-7B} and \texttt{Molmo-D-7B}, we use nucleus sampling with $p=0.9$ and a temperature of $0.7$.
+
+\begin{tcolorbox}[llmpromptbase, title=Detailed Description Prompt]
+
+
+\end{tcolorbox}
+
+\subsubsection{Avoiding Double Penalties}
+\label{sec:precision_correction}
+
+In , after identifying an error in precision, the authors correct the error before annotating recall. This avoids doubly penalizing a description for errors in specificity which would unfairly favor more generic descriptions (which are only penalized once, for recall). We instruct our annotators to do the same.
+
+Due to the length of the generations and descriptions in \benchmark, please consult our codebase for example judgments: \url{https://github.com/amith-ananthram/posh/tree/main/docent/examples/granular}
+
+\clearpage
+
+
+\clearpage
+
+\subsubsection{\benchmark: Agreement and Judgment Summary}
+
+
+\subsubsection{\benchmark: Granular Agreement Details}
+
+We additionally calculate granular agreement using a more conservative threshold ($\geq 50\%$ token overlap). Here, relaxed F1 remains strong among our art history student annotators ($0.612$ for mistakes, $0.773$ for omissions). Though we observe drops in relaxed F1 when compared to our expert, it is driven by two factors: annotation style, with our expert favoring sparsity, and a relative strictness on the part of our student annotators. This is reflected in the expert annotation recall values in \cref{tab:docent_granular} where a majority of the spans identified by our expert were also marked by our student annotations for both mistakes ($0.652$) and omissions ($0.927$). Thus, our expert annotations are a subset of our stricter student annotations. We provide a side-by-side example of a student annotation and an expert annotation in \cref{fig:student_vs_expert}.
+
+\clearpage
+
+\subsection{Evaluation}
+
+\subsubsection{Metrics}
+\label{sec:eval_metrics}
+
+\paragraph{Spearman's Rank Correlation Coefficient ($\rho$)} assesses the monotonic relationship by calculating Pearson's correlation on the ranks of two continuous variables rather than their raw values. It ranges from $-1$ to $+1$, with $+1$ indicating perfect monotonic increasing relationship and $-1$ indicating perfect monotonic decreasing relationship. It's less sensitive to outliers than Pearson's and can detect monotonic non-linear relationships. As the coarse annotations in \benchmark specify the rank of two generated image descriptions, Spearman is well suited for evaluating
+
+\paragraph{Kendall's $\tau$} measures the ordinal association between two variables based on the ranks of the data. It ranges from $-1$ to $+1$, where $+1$ indicates perfect agreement between the two rankings, $0$ indicates no association, and $-1$ indicates perfect disagreement. Unlike Pearson's, Kendall's tau is non-parametric and robust to outliers, making it appropriate for non-linear relationships and non-normally distributed data.
+
+\subsubsection{Coarse Score Scaled Evaluation}
+
+We convert each coarse judgment of a generation pair ($\text{text}_1$, $\text{text}_2$, $\text{label}$) in \benchmark to a numerical score $s$ that reflects the relative rank of $\text{text}_1$ and $\text{text}_2$. If $\text{text}_1$ was marked as \texttt{much better} than $\text{text}_2$, $s = 2$; \texttt{slightly better} than $\text{text}_2$, $s = 1$ and \texttt{equal} to $\text{text}_2$, $s = 0$. Similarly, if $\text{text}_2$ was marked as \texttt{slightly better} than $\text{text}_1$, $s = -1$ and $s = -2$ if \texttt{much better} than $\text{text}_1$. These numerical scores reflect the relative rank of $\text{text}_1$ and $\text{text}_2$ and allow us to evaluate the correlation of different metrics $m$ with the coarse judgments in \benchmark by comparing $s$ to $m(\text{text}_1) - m(\text{text}_2)$ with appropriate measures of monotonicity like Spearman's rank correlation $\rho$.
+
+\subsubsection{Granular Baselines}
+\label{sec:granular_eval_baselines}
+
+\paragraph{4GramEmbed} We extract all of the $4$-grams from each sentence of a generation and its reference, embed them using \texttt{Qwen/Qwen3-Embedding-8B} and then calculate the maximum pairwise similarities between generation $4$-grams and reference $4$-grams. Generation text spans and reference text spans with maximum pairwise similarity scores lower than $0.7$ were predicted as mistakes and omissions respectively, a threshold chosen to maximize the macro F1 scores reported for \textbf{4GramEmbed} in \cref{tab:docent_granular_results}.
+
+\paragraph{SGEmbed} We extract all of the components (objects, attribute-object pairs, and object-relation-object triples) from the scene graphs of a generation and its reference extracted for \methodshort in \cref{sec:posh}, embed them using \texttt{Qwen/Qwen3-Embedding-8B} and then calculate the maximum pairwise similarities between the generation components and the reference components. Generation components and reference components with maximum pairwise similarity scores lower than $0.8$ were predicted as mistakes and omissions respectively, a threshold chosen to maximize the macro F1 scores reported for \textbf{SGEmbed} in \cref{tab:docent_granular_results}.
+
+\subsubsection{Coarse Baselines}
+\label{sec:coarse_eval_baselines}
+
+When prompting GPT4o and GPT5\footnote{\texttt{gpt-4o-2024-08-06} and \texttt{gpt-5-2025-08-07} (with minimal reasoning) accessed on 9/17/2025} to evaluate our generated detailed image descriptions, we use three different prompts depending on whether we are including the image (reference free) or including the reference. Additionally, we experiment with a more complicated prompt that includes a detailed scoring rubric for each score type (mistakes, omissions and overall quality) though we find that this setting underperforms the simpler prompts below.
+
+\begin{tcolorbox}[llmpromptbase, title=Image Only]
+
+
+\end{tcolorbox}
+
+\begin{tcolorbox}[llmpromptbase, title=Reference Only]
+
+
+\end{tcolorbox}
+
+\begin{tcolorbox}[llmpromptbase, title=Image \& Reference]
+
+
+\end{tcolorbox}
+
+\subsubsection{Reinforcement Learning}
+\label{sec:reinforcement_learning}
+
+We train \texttt{Qwen2.5-VL-7B} on the $1,000$ images in \benchmark's training set in two settings:
+\begin{enumerate}
+ \item supervised fine-tuning (SFT) with full parameter updates using a learning rate of $1e-5$, a linear warmup ratio of $0.1$, and an effective batch size of $64$ for $5$ epochs, choosing the checkpoint with the lowest loss on \benchmark's validation set
+ \item DAPO with full parameter updates, implemented with TRL , using a learning rate of $1e-6$, $20$ warmup steps, $8$ generations per sample (with a temperature of $1.0$ and $top_p=0.7$), $\epsilon=0.28$, $\beta=0$, and an effective batch size of $64$ for a single epoch, choosing the final checkpoint
+\end{enumerate}
+
+We ask seven graduate students in NLP to compare and evaluate our SFT and DAPO generations (greedily sampled) for $40$ images from \benchmark's test set. Additionally, we collect three annotations for five of these images to calculate agreement.
+
+\subsection{Results}
+
+\subsubsection{Coarse}
+\label{sec:full_coarse_results}
+
+
+\subsubsection{Subcomponent Performance}
+\label{sec:subcomponent_perf}
+
+To evaluate the scene graph extraction subcomponent of \methodshort, we hand annotate scene graphs for ten descriptions in \benchmark, five references and five generations. We measure precision, recall and F1 for entities, attributes and relations and, for each matched element pair (i.e. entity, attribute or relation), accuracies for coreference resolution, attribute attachment and relation head and tail attachment. The numbers reported in \cref{tab:sg_quality} are averaged across the ten descriptions.
+
+To evaluate the scene graph element verification subcomponent of \methodshort, we manually answer $620$ templated questions for two randomly sampled generation-reference pairs in \benchmark and compare them to \methodshort's presence scores. The numbers reported in \cref{tab:qa_quality} are the maximum achievable F1 scores across all alerting thresholds. The errors in this subcomponent stem from generations specifying correct details not present in the reference, relative permissiveness toward interpretive language in generations and limitations of the \methodshort's templating and unique identifier discovery logic. Nevertheless, the scores speak to the strength of the \methodshort framework and the potential of future subcomponent improvements to yield further gains in performance.
+
+
+\end{document}

benchmark_dataset/papers/ICLR2026_0008_2510.19060/source_extracted.tex

@@ -0,0 +1,195 @@
+\begin{abstract}
+
+While vision-language models (VLMs) have advanced into detailed image description, evaluation remains a challenge. Standard metrics (e.g. CIDEr, SPICE) were designed for short texts and tuned to recognize errors that are now uncommon, such as object misidentification. In contrast, long texts require sensitivity to attribute and relation attachments and scores that localize errors to particular text spans. In this work, we introduce \methodshort, a metric for detailed image description that uses scene graphs as \textit{structured rubrics} to guide LLMs-as-a-Judge, producing aggregate scores grounded in fine-grained errors (e.g. mistakes in compositional understanding). \methodshort is replicable, interpretable and a better proxy for human raters than existing metrics (including GPT4o-as-a-Judge). To validate \methodshort, we introduce a new dataset, \benchmark. This novel benchmark contains artwork, paired with expert-written references, and model-generated descriptions, augmented with \textit{granular} and \textit{coarse} judgments of their quality from art history students. Thus, \benchmark enables evaluating both detailed image description metrics and detailed image description itself in a challenging new domain. We show that \methodshort achieves stronger correlations (+$0.05$ Spearman $\rho$) with the human judgments in \benchmark than the best open-weight alternatives, is robust to image type (using CapArena, an existing dataset of web imagery) and is a capable reward function, outperforming standard supervised fine-tuning. Then, using \methodshort, we characterize the performance of open and closed models in describing the paintings, sketches and statues in \benchmark and find that foundation models struggle to achieve full, error-free coverage of images with rich scene dynamics, establishing a demanding new task to gauge VLM progress. Through both \methodshort and \benchmark, we hope to enable advances in important areas such as assistive text generation. We make our metric and our benchmark available at \url{https://github.com/amith-ananthram/posh}.
+\end{abstract}
+
+\section{Introduction}
+
+A picture is worth a thousand words -- can vision-language models (VLMs) capture all of them? VLMs have saturated traditional image understanding benchmarks from short captioning to question answering . New, more challenging tasks are needed to measure VLM progress. Detailed image description is of particular interest as it requires \textit{comprehensive} understanding -- e.g., in \cref{fig:teaser}, a VLM must correctly specify \textit{who} is pouring the water. This deep perception is a better proxy for the demands of the real world, where diverse user queries may not be reflected in VQA benchmarks . Moreover, it enables meaningful applications such as image assistive (``alt") text generation that could greatly expand accessibility online .
+
+However, making progress on detailed description requires cheap, reliable methods for scoring models. Human evaluation is costly, involving the painstaking comparison
+of long texts. Even so, there is often no substitute as most metrics were designed for short texts and older models . Moreover, while metrics that produce a single coarse score of overall quality allow for the ranking of models, they offer little insight into the granular issues driving performance. Granular issues include \textit{mistakes} in each generation, like the positions of the people in \cref{fig:teaser}, and \textit{omissions} in each reference, like the details of the bird's beak in \cref{fig:dataset}. Automatically localizing such errors is critical as long generations with similar coarse scores may differ in multiple dimensions of interest (e.g., facial features, body orientations, etc.). Otherwise, prompt and/or model iteration necessitates expensive manual inspection to understand which description aspects need improvement.
+
+
+In this work, we propose \methodshort\footnote{\methodshort (PrOofing Scene grapHs) can judge if your detailed descriptions are what you (really really) want.}, a metric for evaluating detailed descriptions that addresses these challenges. \methodshort extracts scene graphs from a generated description and its reference to use as \textit{structured rubrics} for an LLM to granularly identify mistakes and omissions (see \cref{fig:spicy}), pinpointing the textual spans containing errors like attribute/relation mis-attachment. Then, it aggregates these localized errors into coarse scores for mistakes, omissions and overall quality. Thus, \methodshort weds the strengths of structured methods like scene graphs , which reduce descriptions to their consequential visual components, with the strengths of LLMs/VLMs-as-a-Judge , which flexibly compare these visual components against diverse surface realizations.
+
+As \methodshort's coarse scores are grounded in its granular scores, it is interpretable, providing clear insights into the errors driving model performance. Moreover, because \methodshort is entirely open-weight, it is inexpensive to use and perfectly replicable, an important pre-requisite for both adoption by researchers and deployment by practitioners that is not afforded by closed models.
+
+Efforts to introduce metrics for longer generations have been constrained by a lack of human judgments, especially at a granular scale and for diverse imagery (see \cref{tab:benchmark_comp}). To address this, we introduce \benchmark, a novel benchmark whose focus is visual art. \benchmark contains paintings, sketches and sculptures with expert-written assistive text that exhaustively describes features like clothing, physical orientation, relative positioning and gaze, drawn from the U.S. National Gallery of Art (see \cref{fig:spicy,fig:dataset}). It includes generations from current VLMs with judgments from art history students of their mistakes, omissions and overall quality at two resolutions: granular and coarse. Thus, \benchmark enables evaluating description\footnote{AI research often uses \textit{caption} and \textit{alt-text} interchangeably. However, according to \href{https://www.w3.org/WAI/WCAG21/Understanding/non-text-content.html}{Web Content Accessibility Guidelines}, \textit{captions} are related to an image while \textit{alt-text} conveys the information in an image. As our focus is evaluating generations that could serve as \textit{alt-text}, we use the term \textit{description}.} metrics and descriptions themselves.
+
+We validate \methodshort against the human judgments in \benchmark. We show that \methodshort recovers human description rankings more often (+$3$ percentage points) and achieves stronger correlations with human-derived scores (+$0.05$ Spearman $\rho$) than existing overlap and open-weight alternatives (e.g. SPICE, CAPTURE, LLaVa-Critic), even surpassing GPT4o-as-a-Judge. Moreover, using judgments in CapArena , we show this strength is robust to image type. Then, given its calibration, we experiment with using \methodshort as a reward function for describing the images in \benchmark and find that this yields meaningfully better descriptions than supervised fine-tuning (SFT).
+
+Finally, using \methodshort, we characterize the performance of open and closed models in describing the artwork in \benchmark, establishing a difficult new task. In so doing, we extend detailed description to a technically challenging and socially impactful domain: assistive text generation for artwork, whose visual complexity and diversity stress VLMs (see \cref{fig:teaser}).
+
+In summary, our contributions are:
+
+\begin{enumerate}
+\item We propose \methodshort, a new metric for detailed description evaluation. \methodshort is interpretable, producing \textit{coarse} scores grounded in \textit{granular} scores that are localized to text spans.
+\item We present \benchmark, a new detailed description benchmark with $1,750$ expert-written art descriptions and $900$ \textit{granular} \& \textit{coarse} judgments of generations from informed raters.
+\item We show \methodshort correlates more with \benchmark's judgments than existing metrics and GPT4o while being replicable. On CapArena, we confirm \methodshort is robust to image type.
+\item We demonstrate that using \methodshort as a reward function outperforms SFT on \benchmark.
+\item Using \methodshort and \benchmark, we evaluate both open and closed models on detailed description of artwork, establishing a socially impactful new task to gauge VLM progress.
+\end{enumerate}
+
+
+\section{\methodshort: A New Metric for Detailed Image Description}
+\label{sec:posh}
+
+\methodshort is a reference-based metric for detailed image description evaluation that takes two descriptions, a generation and its reference, and then extracts scene graphs from each to use as \textit{structured rubrics} for granular and coarse evaluation of mistakes (i.e. precision) and omissions (i.e. recall).
+
+It does so in three steps (\cref{fig:spicy}): \textbf{Step 1)} It extracts scene graphs from a generation and its reference that preserve object attachments. \textbf{Step 2)} It evaluates the presence of generation scene graph components in the reference (and reference scene graph components in the generation) through question answering with an LLM to identify granular mistakes (and omissions). \textbf{Step 3)} It produces coarse scores for mistakes and omissions grounded in these granular scores. We discuss each step below.
+
+\paragraph{Scene Graph Extraction} As in SPICE , given a description $d$, a scene graph $G(d)$ is a structured representation of $d$. Specifically, $G(d) = \left< O(d), E(d), K(d) \right>$ where $O(d) \subseteq C$ is a set of objects, $E(d) \subseteq O(d) \times A$ is a set of attributes associated with each object and $K(d) \subseteq O(d) \times R \times O(d)$ are a set of relation edges between objects. $C$, $A$ and $R$ are open-world sets of all possible object, attribute and relation classes.
+
+Given a generation $\textit{gen}$ with its reference $\textit{ref}$ we extract sentence-level scene graphs $G_i(\textit{gen}), G_j(\textit{ref})$ for each using off-the-shelf dependency parsing and combine them via coreference resolution . This produces scene graphs with full coverage of each text where each component is localized to text spans, allowing for grounded, interpretable scoring. We provide pseudocode for this extraction in \cref{sec:spicy_merging}.
+
+
+\paragraph{Granular Scoring} Given a description $d$, its scene graph $G(d)$ and a different description $d^\prime$, we apply the function $\Psi$ to every component $c \in G(d)$ to produce a score reflecting its presence in $d^\prime$.
+
+We implement this function via question answering. We produce templated questions for each scene graph component (object, attribute and relation) $c \in G(d)$ and prompt an open-weight LLM to quantify the degree to which $c$ is described in $d^\prime$. This avoids forcing an alignment between the components of $G(d)$ and $G(d^\prime)$. For example, in \cref{fig:spicy}, the reference describes the figures in the image as a ``trio." Question answering ensures that a generation that refers to all three individually is not penalized for failing to include such collectives.
+
+As objects with the same class may appear many times in a scene graph (e.g., a description of multiple men), questions require the use of unique identifiers (e.g., ``woman in white" in \cref{fig:spicy}) to disambiguate such instances in $d^\prime$. As the identifier used in $d^\prime$ (if any) is not known \textit{a priori}, we test candidate identifiers in three passes, first considering only objects not part of any other objects in $G(d)$ (e.g., ``man" but not ``face of the man"), then objects that are part of other objects in $G(d)$ (e.g., ``face of the man") and finally attributes and relations of objects identified as present in $d^\prime$.
+
+When collecting unique candidate identifiers for an object $o \in O(d)$, we consider its class name (e.g. ``man"), its surface form (e.g. ``musician"), its attributes (e.g. ``tall man"), its relations (e.g. ``man on horse") and if part of a previously identified object, its ``part-of" relation (e.g. ``face of tall man"). We re-write these identifiers using our LLM to improve their fluency and then test each one in bulk for their presence in $d^\prime$. We use the simplest identifier confirmed present by our LLM (if any) to evaluate $o$'s attributes and relations. We provide pseudocode for this templating in \cref{sec:spicy_templating}.
+
+We produce granular mistake scores $\pi$ for every component of $G(\textit{gen})$ and granular omission scores $\rho$ for every component of $G(\textit{ref})$:
+\begin{equation*}
+\begin{minipage}{0.45\textwidth}
+\centering
+$\pi(c_{\textit{gen}}) = \Psi(c_{\textit{gen}}, \textit{ref}), \forall c_{\textit{gen}} \in G(\textit{gen})$
+\end{minipage}
+\hfill
+\begin{minipage}{0.45\textwidth}
+\centering
+$\rho(c_{\textit{ref}}) = \Psi(c_{\textit{ref}}, \textit{gen}), \forall c_{\textit{ref}} \in G(\textit{ref})$
+\end{minipage}
+\end{equation*}
+
+\paragraph{Coarse Scoring}
+
+To maintain interpretability, we calculate coarse scores for mistakes (i.e. precision) and omissions (i.e. recall) by averaging over our granular scores directly:
+\begin{equation*}
+\begin{minipage}{0.45\textwidth}
+\centering
+$\text{Mistakes} = \text{mean}_{c\in O(\textit{gen})}(\pi(c))$
+\end{minipage}
+\hfill
+\begin{minipage}{0.45\textwidth}
+\centering
+$\text{Omissions} = \text{mean}_{c\in O(\textit{ref})}(\rho(c))$
+\end{minipage}
+\end{equation*}
+We note this is a natural place to introduce tunable weights (as in ) to adapt \methodshort to particular datasets. As we aim to demonstrate robustness, we leave these terms unweighted.
+
+\section{\benchmark: A New Benchmark for Detailed Description of Art}
+\label{sec:docent}
+
+\benchmark is a benchmark for evaluating detailed description metrics and detailed descriptions themselves. It consists of $1,750$ works of art with expert-written references from the Open Data Program at the U.S. National Gallery of Art (NGA)\footnote{\url{https://www.nga.gov/open-access-images/open-data.html}}. For $100$ of these images, we produce four generations from current small and frontier VLMs and collect $300$ granular (for $75$ images) and $600$ coarse judgments from annotators knowledgeable in art of \textit{mistakes} and \textit{omissions}\footnote{We forgo fluency as recommended by }. On average, coarse judgments took $5$ minutes and granular judgments took $18$ minutes (six annotation days). This
+highlights both the cost of manual evaluation and the need for metrics that are reliable proxies.
+
+We include summary statistics in \cref{tab:benchmark_comp} and example judgments in \cref{fig:dataset}.
+
+\paragraph{Image / Reference Selection} While the majority of these works are paintings, they include sketches, statues and lithographs (e.g., the bird in \cref{fig:dataset}), all in the public domain. These images span a diverse set of styles (e.g., Baroque, Renaissance, Impressionism, Post-Impressionism), themes (e.g., war, courtship, still life, religion) and topics (e.g., fishing, drinking, animals, boating).
+
+The accompanying references are detailed descriptions whose purpose is accessibility -- as such, they follow guidelines\footnote{\url{www.nga.gov/visit/accessibility/collection-image-descriptions}} that include tips for describing color (e.g., ``color can be likened to temperature") and handling ambiguity (e.g, ``describe what makes something ambiguous"). These context informed requirements highlight the need for reference based metrics .
+
+Compared to existing detailed image description benchmarks, \benchmark contains considerably more visual complexity (see \cref{tab:benchmark_comp}). On average, its images contain $16\%$ more objects and nearly twice as many people\footnote{As measured by OneFormer } who require description of their orientation, features, clothing, etc. Consequently, the average length and scene graph size of its reference descriptions are nearly double.
+
+
+\paragraph{Model Selection} We generate detailed descriptions for $100$ images in \benchmark from four current VLMs that span transparency and model size (from open data/open weight to frontier models): \texttt{LLaVA-1.6-7B} , \texttt{Molmo-D-7B} , \texttt{GPT4o} and \texttt{Claude Sonnet 3.5}. A metric that discriminates among these generations similarly to their human judgments could gauge progress in detailed image description in small and large VLMs over time. Additional details (prompts, date of API access) can be found in \cref{sec:docent_generations}.
+
+\paragraph{Annotators} Given the complexity of our images and the detail of their expert descriptions, we recruit $24$ art history undergraduate majors, masters students and PhD students with domain familiarity to provide high quality judgments of generations. All annotators were sighted with full color vision and native speakers of English. They were compensated at a rate of \$$22$/hour for their time.\footnote{This study was conducted under Columbia University IRB protocol AAAV6216.}
+
+\paragraph{Granular Judgments} Half of our annotators identify \textit{mistakes} and \textit{omissions} in our model generations. For each image, an annotator is shown its reference and then its four model generations in random order. First, they look at the image, read the reference and then the current generation. Next, by selecting narrow text spans, annotators first identify \textit{mistakes} in the generation (i.e. precision errors) and then \textit{omissions} in the reference that are not in the generation (i.e. recall errors). When identifying omissions, as in , we ask annotators to mentally correct narrow mistakes in the generation first to avoid double-penalizing a model for both incorrect specificity and lack of specificity. For example, a generation that describes a \textit{woman} as a \textit{man} is an error in precision but not in recall. We include our task instructions and interface\footnotemark{} screenshots in \cref{fig:granular_annotation_instructions,fig:granular_annotation_interface}.
+
+\paragraph{Coarse Judgments}
+
+The other half of our annotators provide coarse judgments of our model generations. For a given image, an annotator is shown its reference and two generations (\texttt{\#1} and \texttt{\#2}) in random order and asked to rank the generations in terms of \texttt{mistakes} (i.e. precision), \texttt{omissions} (i.e. recall) and \texttt{overall quality}. These pairwise judgments avoid some of the inter-annotator inconsistency of Likert ratings, especially for long text .
+
+Annotators select among five choices for each dimension: \texttt{\#1 much better}, \texttt{\#1 slightly better}, \texttt{equal}, \texttt{\#2 slightly better} and \texttt{\#2 much better}. As with our granular judgments, we ask annotators to mentally correct narrow mistakes (i.e. precision errors)
+in each generation before judging omissions. To avoid favoring previously seen generations, we ensure no annotator sees the same generation more than once. We include our task instructions and screenshots of our annotation interface\footnotemark[\value{footnote}] in \cref{fig:coarse_annotation_instructions,fig:coarse_annotation_interface}. \footnotetext{Hosted on Label Studio (\url{https://labelstud.io})}
+
+\paragraph{Agreement} For a given image, each generation / pair of generations receives at least one granular and one coarse judgment respectively. For $15\%$ of our tasks, we collect additional judgments from our annotators ($2$ for coarse, $1$ for granular). Additionally, for $20$ granular tasks and $30$ coarse tasks, we collect expert judgments from a PhD in art history who authors assistive text at an art museum. We use these extra judgments to calculate agreement in two ways (among our annotators and between our annotators and our expert). We report agreement in \cref{tab:docent_granular,tab:docent_coarse} of the Appendix.
+
+For our granular judgments, as recommended by for span annotation tasks where the boundaries of negative examples (i.e. non-errors) are ill-defined, we measure agreement using the relaxed F1 (matching spans that contain 50\% overlapping tokens). Under this measure, our student annotators exhibit strong agreement among themselves and with our expert.
+
+Our coarse judgments exhibit moderate inter-annotator agreement, with Krippendorf's $\alpha=0.509$, $0.409$ and $0.459$ for mistakes, omissions and overall quality . This level of agreement is unsurprising for coarse detailed description evaluation -- judgment requires weighing the relative importance of each text's granular errors and is consequently more subjective. Nevertheless, our student annotators exhibit moderate to strong correlations with our expert, with significant Pearson $\rho$ values of $0.727$, $0.501$ and $0.492$ for mistakes, omissions and overall quality respectively.
+
+\paragraph{How well do these VLMs describe art?} When considering the performance of the four models included in \benchmark, we observe expected trends, adding to our confidence in the quality of our judgments: the smaller models make more mistakes and have more omissions than the larger models (see \cref{tab:docent_granular,tab:docent_coarse}). Though most models make few mistakes, they all struggle with omissions. The best model, \texttt{gpt4o} covers only $50.1\%$ of the visual information conveyed in \benchmark's references. Raising this requires continued prompt iteration, highlighting the need for an automated metric that can reliably measure both granular and coarse differences in mistakes and omissions.
+
+\section{Experiments}
+
+\paragraph{\methodshort} We extract sentence-level scene graphs using \texttt{en\_core\_web\_trf} from , a transformer trained to perform dependency parsing. To merge objects across these scene graphs while preserving attribute and relation attachments, we use \texttt{maverick-mes-ontonotes} from to perform co-reference resolution. Our QA scorer $\Psi$ is \texttt{qwen-3-14b} . We template evaluation questions for each scene graph component (as in \cref{fig:spicy}), re-write candidate identifiers using $\Psi$ to improve fluency and then prompt $\Psi$ to answer each templated presence question by predicting a number between $1$ and $5$. We extract scores by taking the weighted average over the token logits for each number as in . When determining object presence, we use a threshold of $2$, determined through tuning on a small hand-annotated validation set. We provide further implementation details and all prompts used in \cref{sec:posh_appendix}.
+
+\paragraph{Benchmarks}
+
+We evaluate \methodshort against the judgments in \benchmark and CapArena.
+
+\textsc{\it{DOCENT}} is our new detailed description benchmark containing judgments from knowledgeable human annotators: granular mistake and omission spans for $300$ individual generations and coarse scaled rankings of mistakes, omissions and overall quality of $600$ paired generations. We evaluate granular metrics on this benchmark using macro F1 where we credit/penalize a model for predicting each annotated/unannotated token. Our coarse judgments are in the form $(text_1, text_2, score)$ where score indicates how much better or worse $text_1$ is than $text_2$. We evaluate each coarse metric $m$ by calculating its 1) pairwise accuracy (whether it picks the better text or a tie, using a tie threshold inferred from the gold tie rate) and 2) Spearman rank $\rho$ and Kendall's $\tau$ correlations between $m(text_1) - m(text_2)$ and $score$, a common practice in machine translation metric evaluation . More details can be found in \cref{sec:eval_metrics}.
+
+\textsc{\it{CapArena}} contains $3,361$ images and $10,348$ detailed descriptions generated from $14$ current VLMs. $5,599$ pairs of these generations receive coarse judgments from human raters of the better generation (or ``tie"). We include CapArena, which contains diverse images drawn from the web, to validate metric robustness. However, we note the dramatic simplicity of its images and references compared to those in \benchmark (see \cref{tab:benchmark_comp}). $64\%$ of its images\footnote{As measured by OneFormer } contain fewer than two objects and $95\%$ depict fewer than two people (compared to $27\%$\ and $52\%$ in \benchmark).
+A metric is evaluated on CapArena at the caption-level (whether it picks the better text or a tie, using a tie threshold inferred from the gold tie rate) and at the model-level (Spearman's rank and Kendall's $\tau$ correlation between ELO rankings derived from metric predictions and gold judgments).
+
+\paragraph{Granular Baselines} Our work is the first to introduce both a metric and a benchmark for granular evaluation of detailed descriptions. As such, this limits our baselines to those able to predict \textit{localized} mistakes and omissions (i.e., the spans where errors occur). We consider two embedding-based approaches, using \texttt{Qwen/Qwen3-Embedding-8B} from : \textbf{4GramEmbed}, which embeds and compares $4$-grams from a generation and its reference, and \textbf{SGEmbed}, which embeds and compares components from the scene graphs of a generation and its reference. As these approaches (and \methodshort) produce span scores, we report the maximum F1 scores for mistakes and omissions across all alerting thresholds. More details can be found in \cref{sec:granular_eval_baselines}.
+
+\paragraph{Coarse Baselines} Though \methodshort is a text-only reference-based metric, we select a representative set of reference-free (requiring only an image) and reference-based (requiring a gold standard) pointwise metrics (i.e. produce numerical scores) as our baselines. These include n-gram overlap metrics like BLEU , ROUGE-L-Sum , METEOR and CIDER and model-based metrics like SPICE , CLIPScore and CAPTURE . Additionally, we consider several LLMs/VLMs-as-a-Judge\footnote{CLAIR/Faithscore were not included due to complications with their codebases . Due to cost (estimated at \$$1,000$), we only evaluate DCScore on \benchmark.}: FLEUR , Prometheus , LLaVA-Critic , DCScore , Qwen-3 and GPT4o/GPT5 in three settings (reference-free with image, reference-based without image and reference-based with image). More details can be found in \cref{sec:coarse_eval_baselines}.
+
+\paragraph{Reward Function} Finally, given the potential of a well-calibrated metric as a verifier in reinforcement learning (RL), we evaluate \methodshort as a reward function. We train \texttt{Qwen2.5-VL-7B} on the $1,000$ images in \benchmark's training set in two settings: 1) supervised fine-tuning (SFT), and 2) RL with DAPO using \methodshort. We collect coarse judgments (as in \cref{sec:docent}) for $40$ generation pairs from graduate students in NLP. More details can be found in \cref{sec:reinforcement_learning}.
+
+\section{Results \& Discussion}
+
+
+\paragraph{\methodshort as a Granular Metric}
+
+\cref{tab:docent_granular_results} presents the performance of \methodshort and our selected metrics on identifying the mistakes and omissions in \benchmark. Given the imbalanced nature of our data (where mistakes are infrequent and omissions are common), we report macro averages for each subtask, measuring how well each approach localizes errors within a generation and its reference respectively. First, we note that this task is difficult. The considerable room for improvement highlights the value of a benchmark like \benchmark that contains granular judgments of textual spans. Even so, \textbf{\methodshort achieves the highest F1 in mistake ($0.580$) and omission ($0.680$) localization}. As its coarse scores are aggregated from these granular scores, this demonstrates its interpretability.
+
+
+\paragraph{\methodshort as a Coarse Metric}
+
+\cref{tab:coarse_results} presents the performance of \methodshort and the best baselines on predicting the coarse judgments in \benchmark and CapArena (full results in \cref{sec:full_coarse_results}).
+
+On \benchmark, across all three dimensions, \textbf{\methodshort outperforms every existing replicable metric} (i.e., metrics not reliant on an API), yielding a $0.11$ increase in Spearman $\rho$ for mistakes ($25\%\uparrow$), a $0.07$ increase for omissions ($14\%\uparrow$) and a $0.05$ increase for overall quality ($9\%\uparrow$) over the next best. It even outperforms GPT4o (in all settings) and text-only GPT5 (on omissions and overall quality). Among all metrics, DCScore proves best at predicting mistakes. However, its reliance on GPT4o to extract and verify factoids fails to achieve full coverage of reference detail, underperforming in predicting omissions and overall quality. Despite employing a smaller LLM, \methodshort's use of dependency parsing and coreference resolution to extract scene graphs avoids this.
+
+On CapArena, \methodshort achieves higher caption-level accuracies and model-ranking correlations than nearly every existing open-weight metric and GPT4o. The sole exception is LLaVa Critic, a much larger VLM-as-a-Judge . This is driven in part by the simplicity of CapArena (see \cref{tab:benchmark_comp}). On the subset of CapArena depicting three or more people (167 judgments), each of whom requires careful description, \textbf{\methodshort outperforms LLaVa Critic with model ranking correlations of $\mathbf{\rho=0.727, \tau=0.581}$ compared to $\mathbf{\rho=0.686, \tau=0.550}$}. Thus, \methodshort is robust to image type, excelling in visually complex cases that are of particular interest in detailed image description.
+
+\paragraph{\methodshort as a Reward Function} In \cref{tab:rl_results} of the Appendix, we report annotator agreement and aggregate preferences between SFT and DAPO with \methodshort. In each dimension of interest, a \methodshort-tuned generation earns a score between $-2$ and $2$ based on how much worse or better it is than its SFT counterpart. While \methodshort-tuned generations had more mistakes (an average score of $-0.243$), these were incurred in service of \textbf{much fewer missing details ($\mathbf{+0.432}$), resulting in higher overall quality ($\mathbf{+0.135}$)}. This speaks to the strength of \methodshort when optimized directly. Given recent progress in generating synthetic detailed descriptions , \methodshort-tuning could be freely scaled in post-training. Moreover, as \methodshort produces localized granular scores, it supports token-level guidance , an exciting direction to explore in future work.
+
+\paragraph{\methodshort Subcomponent Evaluation} \methodshort relies on two subcomponents, scene graph extraction and scene graph element verification through question answering. As downstream errors may propagate from these components, we validate each through comparison against hand annotated examples from \benchmark. We find that \methodshort's scene graphs are high quality, with average element F1 of $0.892$. Similarly, in verifying these scene graph elements, \methodshort exhibits strong alignment with human raters, with an F1 of $0.852$. We provide additional details and analysis in \cref{sec:subcomponent_perf}.
+
+\paragraph{\methodshort Runtime} A core enabler of \methodshort's performance and interpretability is its thorough granular evaluation. It achieves this efficiently through inference optimizations like continuous batching and prefix caching . \methodshort scores the $400$ examples in \benchmark in $15$ minutes, or one every $2$ seconds, on a single H100 GPU. In contrast, DCScore takes upwards of $2$ hours due to its heavy use of GPT4 (one description every $25$ seconds). As manual evaluation takes $18$ minutes per description (see \cref{tab:benchmark_comp}), \methodshort effectively balances quality and cost.
+
+\section{\benchmark Leaderboard}
+
+Finally, in \cref{fig:leaderboard}, we plot the \methodshort scores of VLMs in describing the art in \benchmark. While closed models like Gemini 2.5 Pro lead, open models remain competitive. Improvements will require continued iteration, informed in part by insights gained from analyzing \methodshort's granular scores.
+
+\section{Conclusion}
+
+We present \methodshort, a novel metric for detailed image description that extracts scene graphs to use as structured rubrics for guiding LLMs-as-a-Judge, providing interpretable, replicable scores. To validate \methodshort, we introduce \benchmark, a new benchmark with expert-written descriptions of visually complex artwork along with granular and coarse judgments of generations from knowledgeable raters. We show that \methodshort correlates better than other metrics with these judgments, is robust to image type and is a capable reward function. Through \methodshort and \benchmark, we introduce a leaderboard for a new challenging task, detailed image description of artwork. It is our hope that this work will drive progress in meaningful areas such as assistive text generation for artwork and beyond.
+
+\section{Limitations}
+Recent efforts have explored using structural priors to guide generation (e.g. ). As these methods extract and describe structure from images, and as \methodshort extracts and validates structure from text, we do not expect \methodshort to be biased towards them in an evaluation setting. Nevertheless, as these models become publicly available, this requires experimental validation.
+
+\section{Ethics Statement}
+
+The judgments in \benchmark were collected under IRB protocol AAAV6216 with all annotator data anonymized and participants receiving fair compensation (at $\$22$/hour) for their time and expertise.
+
+All of the $1,750$ artwork images in \benchmark are in the public domain, and the expert-written reference descriptions were published by the U.S. National Gallery of Art under their Open Data Program\footnote{\url{https://github.com/NationalGalleryOfArt/opendata}} specifically for research purposes, ensuring appropriate use and attribution.
+
+While this work aims to benefit accessibility applications for blind and low-vision users, we acknowledge that direct community involvement in the development process would strengthen future iterations. However, we note that the expert reference descriptions were written according to the National Gallery of Art's accessibility guidelines\footnote{\url{https://www.nga.gov/visit/accessibility/collection-image-descriptions}} which lay out best practices for assistive text.
+
+Finally, as with other computer vision systems, this work could theoretically be applied to surveillance contexts, but our focus on detailed description does not introduce novel privacy risks beyond those inherent to existing image analysis technologies. The primary intended application—improving accessibility—aligns with beneficial societal outcomes.
+
+\section{Reproducibility Statement}
+
+A core motivation behind \methodshort is improving replicability in detailed image description evaluation through the introduction of a performant open-weight metric. In that spirit, we ensure full reproducibilty of our findings by:
+
+\begin{enumerate}
+ \item including comprehensive technical details in the Appendix
+ \item publishing the code for both our metric and our metric evaluations at \url{https://github.com/amith-ananthram/posh}; this implementation supports batch invariance, ensuring perfect reproducibility of our results on an H100 GPU with CUDA 12.8
+ \item publishing our benchmark at \url{https://github.com/amith-ananthram/posh/tree/main/docent}
+ \item making our models and our benchmark available to the broader research community on HuggingFace
+\end{enumerate}
+
+\subsubsection*{Acknowledgments}
+
+This research is being developed in part with funding from the National Science Foundation under Cooperative Agreement PHY-2229929 (the NSF AI Institute for Artificial and Natural Intelligence) and DRL-2112635 (the NSF AI Engage Institute), the Columbia Center for Artificial Intelligence and Technology (CAIT) and ONR Grant N00014-23-1-2356. Data and data science collaboration were provided by the National Gallery of Art in Washington, DC. We gratefully acknowledge use of the research computing resources of the Empire AI Consortium, Inc, with support from Empire State Development of the State of New York, the Simons Foundation, and the Secunda Family Foundation. The views, opinions and/or findings expressed are those of the authors and should not be interpreted as representing the official views or policies of the State of New York, the National Gallery of Art, the National Science Foundation or the U.S. Government.

benchmark_dataset/papers/ICLR2026_0008_2510.19060/source_references.tex

@@ -0,0 +1,183 @@
+@inproceedings{kreiss2022context,
+  title={Context Matters for Image Descriptions for Accessibility: Challenges for Referenceless Evaluation Metrics},
+  author={Kreiss, Elisa and Bennett, Cynthia and Hooshmand, Shayan and Zelikman, Eric and Morris, Meredith Ringel and Potts, Christopher},
+  booktitle={Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing},
+  pages={4685--4697},
+  year={2022}
+}
+
+@inproceedings{deutsch2022limitations,
+  title={On the Limitations of Reference-Free Evaluations of Generated Text},
+  author={Deutsch, Daniel and Dror, Rotem and Roth, Dan},
+  booktitle={Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing},
+  pages={10960--10977},
+  year={2022}
+}
+
+@inproceedings{papineni2002bleu,
+  title={Bleu: a method for automatic evaluation of machine translation},
+  author={Papineni, Kishore and Roukos, Salim and Ward, Todd and Zhu, Wei-Jing},
+  booktitle={Proceedings of the 40th annual meeting of the Association for Computational Linguistics},
+  pages={311--318},
+  year={2002}
+}
+
+@inproceedings{lin2004rouge,
+  title={Rouge: A package for automatic evaluation of summaries},
+  author={Lin, Chin-Yew},
+  booktitle={Text summarization branches out},
+  pages={74--81},
+  year={2004}
+}
+
+@inproceedings{banerjee2005meteor,
+  title={METEOR: An automatic metric for MT evaluation with improved correlation with human judgments},
+  author={Banerjee, Satanjeev and Lavie, Alon},
+  booktitle={Proceedings of the acl workshop on intrinsic and extrinsic evaluation measures for machine translation and/or summarization},
+  pages={65--72},
+  year={2005}
+}
+
+@inproceedings{vedantam2015cider,
+  title={Cider: Consensus-based image description evaluation},
+  author={Vedantam, Ramakrishna and Lawrence Zitnick, C and Parikh, Devi},
+  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
+  pages={4566--4575},
+  year={2015}
+}
+
+@inproceedings{see2017get,
+  title={Get To The Point: Summarization with Pointer-Generator Networks},
+  author={See, Abigail and Liu, Peter J and Manning, Christopher D},
+  booktitle={Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)},
+  pages={1073--1083},
+  year={2017}
+}
+
+@inproceedings{hessel2021clipscore,
+  title={CLIPScore: A Reference-free Evaluation Metric for Image Captioning},
+  author={Hessel, Jack and Holtzman, Ari and Forbes, Maxwell and Le Bras, Ronan and Choi, Yejin},
+  booktitle={Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing},
+  pages={7514--7528},
+  year={2021}
+}
+
+@inproceedings{sarto2023positive,
+  title={Positive-augmented contrastive learning for image and video captioning evaluation},
+  author={Sarto, Sara and Barraco, Manuele and Cornia, Marcella and Baraldi, Lorenzo and Cucchiara, Rita},
+  booktitle={Proceedings of the IEEE/CVF conference on computer vision and pattern recognition},
+  pages={6914--6924},
+  year={2023}
+}
+
+@inproceedings{chan2023clair,
+  title={CLAIR: Evaluating Image Captions with Large Language Models},
+  author={Chan, David and Petryk, Suzanne and Gonzalez, Joseph and Darrell, Trevor and Canny, John},
+  booktitle={Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing},
+  pages={13638--13646},
+  year={2023}
+}
+
+@article{cheng2025caparena,
+  title={Caparena: Benchmarking and analyzing detailed image captioning in the llm era},
+  author={Cheng, Kanzhi and Song, Wenpo and Fan, Jiaxin and Ma, Zheng and Sun, Qiushi and Xu, Fangzhi and Yan, Chenyang and Chen, Nuo and Zhang, Jianbing and Chen, Jiajun},
+  journal={arXiv preprint arXiv:2503.12329},
+  year={2025}
+}
+
+@inproceedings{xiong2024llavacritic,
+  title={LLaVA-Critic: Learning to Evaluate Multimodal Models},
+  author={Xiong, Tianyi and Wang, Xiyao and Guo, Dong and Ye, Qinghao and Fan, Haoqi and Gu, Quanquan and Huang, Heng and Li, Chunyuan},
+  booktitle={Proceedings of the Computer Vision and Pattern Recognition Conference},
+  pages={13618--13628},
+  year={2025}
+}
+
+@inproceedings{anderson2016spice,
+  title={Spice: Semantic propositional image caption evaluation},
+  author={Anderson, Peter and Fernando, Basura and Johnson, Mark and Gould, Stephen},
+  booktitle={Computer Vision--ECCV 2016: 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part V 14},
+  pages={382--398},
+  year={2016},
+  organization={Springer}
+}
+
+@article{dong2024benchmarking,
+  title={Benchmarking and Improving Detail Image Caption},
+  author={Dong, Hongyuan and Li, Jiawen and Wu, Bohong and Wang, Jiacong and Zhang, Yuan and Guo, Haoyuan},
+  journal={arXiv preprint arXiv:2405.19092},
+  year={2024}
+}
+
+@inproceedings{scialom2021questeval,
+  title={QuestEval: Summarization Asks for Fact-based Evaluation},
+  author={Scialom, Thomas and Dray, Paul-Alexis and Lamprier, Sylvain and Piwowarski, Benjamin and Staiano, Jacopo and Wang, Alex and Gallinari, Patrick},
+  booktitle={Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing},
+  pages={6594--6604},
+  year={2021}
+}
+
+@inproceedings{chodavidsonian,
+  title={Davidsonian Scene Graph: Improving Reliability in Fine-grained Evaluation for Text-to-Image Generation},
+  author={Cho, Jaemin and Hu, Yushi and Baldridge, Jason Michael and Garg, Roopal and Anderson, Peter and Krishna, Ranjay and Bansal, Mohit and Pont-Tuset, Jordi and Wang, Su},
+  booktitle={The Twelfth International Conference on Learning Representations},
+  year={2024}
+}
+
+@inproceedings{urbanek2024picture,
+  title={A picture is worth more than 77 text tokens: Evaluating clip-style models on dense captions},
+  author={Urbanek, Jack and Bordes, Florian and Astolfi, Pietro and Williamson, Mary and Sharma, Vasu and Romero-Soriano, Adriana},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={26700--26709},
+  year={2024}
+}
+
+@inproceedings{onoe2024docci,
+  title={Docci: Descriptions of connected and contrasting images},
+  author={Onoe, Yasumasa and Rane, Sunayana and Berger, Zachary and Bitton, Yonatan and Cho, Jaemin and Garg, Roopal and Ku, Alexander and Parekh, Zarana and Pont-Tuset, Jordi and Tanzer, Garrett and others},
+  booktitle={European Conference on Computer Vision},
+  pages={291--309},
+  year={2024},
+  organization={Springer}
+}
+
+@inproceedings{garg-etal-2024-imageinwords,
+    title = "{I}mage{I}n{W}ords: Unlocking Hyper-Detailed Image Descriptions",
+    author = "Garg, Roopal  and
+      Burns, Andrea  and
+      Karagol Ayan, Burcu  and
+      Bitton, Yonatan  and
+      Montgomery, Ceslee  and
+      Onoe, Yasumasa  and
+      Bunner, Andrew  and
+      Krishna, Ranjay  and
+      Baldridge, Jason Michael  and
+      Soricut, Radu",
+    editor = "Al-Onaizan, Yaser  and
+      Bansal, Mohit  and
+      Chen, Yun-Nung",
+    booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing",
+    month = nov,
+    year = "2024",
+    address = "Miami, Florida, USA",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.emnlp-main.6/",
+    doi = "10.18653/v1/2024.emnlp-main.6",
+    pages = "93--127",
+    abstract = "Despite the longstanding adage ``an image is worth a thousand words,'' generating accurate hyper-detailed image descriptions remains unsolved. Trained on short web-scraped image-text, vision-language models often generate incomplete descriptions with visual inconsistencies. We address this via a novel data-centric approach with ImageInWords (IIW), a carefully designed human-in-the-loop framework for curating hyper-detailed image descriptions. Human evaluations on IIW data show major gains compared to recent datasets (+66{\%}) and GPT-4V (+48{\%}) across comprehensiveness, specificity, hallucinations, and more. We also show that fine-tuning with IIW data improves these metrics by +31{\%} against models trained with prior work, even with only 9k samples. Lastly, we evaluate IIW models with text-to-image generation and vision-language reasoning tasks. Our generated descriptions result in the highest fidelity images, and boost compositional reasoning by up to 6{\%} on ARO, SVO-Probes, and Winoground datasets. We release the IIW-Eval benchmark with human judgement labels, object and image-level annotations from our framework, and existing image caption datasets enriched via IIW-model."
+}
+
+@inproceedings{lu2025benchmarking,
+  title={Benchmarking large vision-language models via directed scene graph for comprehensive image captioning},
+  author={Lu, Fan and Wu, Wei and Zheng, Kecheng and Ma, Shuailei and Gong, Biao and Liu, Jiawei and Zhai, Wei and Cao, Yang and Shen, Yujun and Zha, Zheng-Jun},
+  booktitle={Proceedings of the Computer Vision and Pattern Recognition Conference},
+  pages={19618--19627},
+  year={2025}
+}
+
+@inproceedings{ye2025painting,
+  title={Painting with Words: Elevating Detailed Image Captioning with Benchmark and Alignment Learning},
+  author={Ye, Qinghao and Zeng, Xianhan and Li, Fu and Li, Chunyuan and Fan, Haoqi},
+  booktitle={The Thirteenth International Conference on Learning Representations},
+  year={2025}
+}

benchmark_dataset/papers/ICLR2026_0008_2510.19060/source_related_work.tex

@@ -0,0 +1,56 @@
+\section{Related Work}
+\label{related_work}
+
+Image description is under-specified -- the correct way to describe an image is often task-specific. This is especially true for assistive text which has context-dependent requirements . Moreover, in such sensitive applications, correlated failures between reference-free metrics and VLMs relying on similar components could prove dangerous to end users . Thus, our focus is reference-based evaluation. Traditional metrics were not designed to evaluate long text and can involve truncation due to limited context length
+(e.g. CLIPScore) . Recent work has explored LLMs/VLMs-as-Judges though this requires potentially expensive API calls and offers limited replicability . Even when replicable, they do not provide interpretable, grounded granular scores .
+
+While prior metrics like SPICE and CAPTURE leverage scene graphs, they forgo their rich structure by ignoring object attachment . This favors generations with misattributed details (as in \cref{fig:teaser}). In summarization, use question generation and answering (QA) to compare a summary and its source. In text-to-image generation, use GPT4 to extract and verify a scene graph from a visual prompt. \methodshort extends these approaches to detailed description evaluation that is replicable and interpretable. With small models, it extracts scene graphs to use as structured rubrics for guiding an open-weight LLM-as-a-Judge.
+
+\begin{table*}[ht]
+\setlength{\tabcolsep}{4pt}
+ \centering
+ \caption{Detailed image description benchmarks with summaries of their images, reference descriptions (where detail is average \# of entities + attributes + relations) and judgments (where source is the type of annotator used and time is the average time per judgment). Most benchmarks release no human judgments. In contrast, \benchmark contains both granular and coarse judgments of long descriptions of visually complex artwork elicited from annotators knowledgeable in art.}
+ \begin{tabular}{|c|c|ccc|cccc|}
+ \hline
+ \multirow{2}{*}{\textbf{Name}} &
+ \multicolumn{1}{c|}{\textbf{Images}} &
+ \multicolumn{3}{c|}{\textbf{Reference Descriptions}} &
+ \multicolumn{4}{c|}{\textbf{Judgments}}
+ \\
+ &
+ \textbf{Source} &
+ \textbf{Source} &
+ \textbf{Words} &
+ \textbf{Detail} &
+ \textbf{Source} &
+ \textbf{Type} &
+ \textbf{Time (min)} &
+ \textbf{\#} \\
+ \hline
+ DCI & web & crowd & $133$ & $71$ & \multicolumn{4}{c|}{\multirow{4}{*}{\textit{no judgments}}} \\
+ \cline{1-5}
+ DOCCI & web & crowd & $122$ & $66$ & & & &\\
+ \cline{1-5}
+ \cline{1-5}
+ CompreCap & web & crowd & - & - & & & & \\
+ \cline{1-5}
+ DeCapBench & \multicolumn{4}{c|}{uses ImageInWords} & & & & \\
+ \hline
+ ImageInWords & web & crowd+ & $193$ & $113$ & \multicolumn{4}{c|}{\textit{no judgments with references\footnotemark}} \\
+ \hline
+ DetailCaps & web & model & $154$ & $95$ & model & coarse & - & $14.4\text{K}$ \\
+ \hline
+ CapArena &
+ \multicolumn{4}{c|}{uses DOCCI} & skilled & coarse & $2.4$ & $5.6\text{K}$ \\
+ \hline
+ \hline
+ \benchmark & \multirow{2}{*}{art} & \multirow{2}{*}{expert} & \multirow{2}{*}{$251$} & \multirow{2}{*}{$161$} & \multirow{2}{*}{skilled} & granular & $18$ & $300$ \\
+ (ours) & & & & & & coarse & $5$ & $600$ \\
+ \hline
+ \end{tabular}
+ \label{tab:benchmark_comp}
+\end{table*}
+
+\footnotetext{The judgments in IIW compare 1) paired references and 2) paired generations for images with no references. As such, they cannot be used to evaluate a reference-based metric.}
+
+Evaluating such a metric requires human judgments of model generations. Though there are many detailed image description benchmarks , most release no such judgments. One notable exception is CapArena which contains coarse rankings of descriptions for web imagery . In contrast, our new dataset, \benchmark contains both \textit{granular} and \textit{coarse} judgments, enabling the evaluation of fine-grained metrics like \methodshort. Moreover, it expands detailed description to artwork whose scene dynamics and expert-written references are considerably more complex (see \cref{tab:benchmark_comp}).

benchmark_dataset/papers/ICLR2026_0011_2510.17516/metadata.json

@@ -0,0 +1,66 @@
+{
+  "paper_id": "ICLR2026_0011_2510.17516",
+  "venue": "ICLR",
+  "year": 2026,
+  "title": "SimBench: Benchmarking the Ability of Large Language Models to Simulate Human Behaviors",
+  "authors": [
+    "Tiancheng Hu",
+    "Joachim Baumann",
+    "Lorenzo Lupo",
+    "Nigel Collier",
+    "Dirk Hovy",
+    "Paul Röttger"
+  ],
+  "domain_score": 25,
+  "domain_areas": [
+    "model_architecture",
+    "pretraining_posttraining_instruction_alignment",
+    "test_time_reasoning_compute",
+    "benchmark_evaluation"
+  ],
+  "openreview_id": "PL51SpN6ZJ",
+  "openreview_forum": "PL51SpN6ZJ",
+  "openreview_url": "https://openreview.net/forum?id=PL51SpN6ZJ",
+  "arxiv_id": "2510.17516",
+  "arxiv_id_versioned": "2510.17516v4",
+  "arxiv_abs_url": "http://arxiv.org/abs/2510.17516v4",
+  "arxiv_pdf_url": "https://arxiv.org/pdf/2510.17516v4",
+  "arxiv_source_url": "https://arxiv.org/e-print/2510.17516",
+  "arxiv_title": "SimBench: Benchmarking the Ability of Large Language Models to Simulate Human Behaviors",
+  "arxiv_title_match_score": 1.0,
+  "arxiv_published": "2025-10-20T13:14:38Z",
+  "arxiv_updated": "2026-04-13T07:04:29Z",
+  "arxiv_license": "",
+  "source_dir": "source",
+  "source_tex_file_count": 2,
+  "status": "ok",
+  "main_tex_original_path": "iclr2026_conference.tex",
+  "expanded_inputs_count": 1,
+  "removed_inputs_count": 0,
+  "related_work_title": "Related Work",
+  "related_citation_keys": [
+    "Argyle_Busby_Fulda_Gubler_Rytting_Wingate_2023",
+    "Bisbee_Clinton_Dorff_Kenkel_Larson_2024",
+    "NEURIPS2024_Dominguez",
+    "Aher2023Using",
+    "manning2024automated",
+    "hewitt2024predicting",
+    "binz2024centaur",
+    "horton2023large",
+    "10.1145/3586183.3606763",
+    "hu-collier-2024-quantifying",
+    "dong-etal-2024-llm",
+    "hu2025inews",
+    "cheng-etal-2023-compost",
+    "wang2025large",
+    "liu2025large",
+    "park2024diminished",
+    "anthis2025llm",
+    "ying2025benchmarking",
+    "ma-etal-2024-potential",
+    "kozlowski2024simulating",
+    "olteanu2025ai"
+  ],
+  "missing_related_reference_keys": [],
+  "validation_warnings": []
+}

benchmark_dataset/papers/ICLR2026_0011_2510.17516/source.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd8efa36f6a634a756c60637093f9d543665471dec3cc3da7621065372a4406c
+size 1381530

benchmark_dataset/papers/ICLR2026_0011_2510.17516/source_extracted.tex

@@ -0,0 +1,266 @@
+\begin{abstract}
+Large language model (LLM) simulations of human behavior have the potential to revolutionize the social and behavioral sciences, \textit{if and only if} they faithfully reflect real human behaviors. Current evaluations of simulation fidelity are fragmented, based on bespoke tasks and metrics, creating a patchwork of incomparable results. To address this, we introduce \textsc{SimBench}, the first large-scale, standardized benchmark for a robust, reproducible science of LLM simulation. By unifying 20 diverse datasets covering tasks from moral decision-making to economic choice across a large global participant pool, \textsc{SimBench} provides the necessary foundation to ask fundamental questions about when, how, and why LLM simulations succeed or fail. We show that the best LLMs today achieve meaningful but modest simulation fidelity (score: 40.80/100), with performance scaling log-linearly with model size but not with increased inference-time compute. We discover an alignment-simulation tradeoff: instruction tuning improves performance on low-entropy (consensus) questions but degrades it on high-entropy (diverse) ones. Models particularly struggle when simulating specific demographic groups. Finally, we demonstrate that simulation ability correlates most strongly with knowledge-intensive reasoning (MMLU-Pro, $r=0.939$). By making progress measurable, we aim to accelerate the development of more faithful LLM simulators.
+
+
+\end{abstract}
+
+
+\section{Introduction}
+\label{sec: intro}
+
+Large-scale human experiments and surveys have long been essential tools for informing public policy, commercial decisions, and academic research.
+Running experiments and surveys, however, is costly and time-consuming.
+Large language models (LLMs) may help address this challenge by simulating human behaviors quickly and at low cost, to complement or even substitute human studies.
+This prospect, alongside encouraging early evidence on the efficacy of LLMs as simulators , has motivated a large body of recent work across many disciplines investigating the ability of LLMs to simulate human behaviors .~\looseness=-1
+
+
+However, this rapid exploration has produced a fragmented body of evidence. Most studies evaluate a narrow set of LLMs on a specific task, yielding varied and sometimes contradictory results that make it difficult to draw broader conclusions (\S\ref{sec: related work}). The field lacks a unified framework to determine when, how, and why LLM simulations succeed, or how to train better simulators.
+
+
+To confront this challenge, we introduce \textsc{SimBench}:\ the first large-scale, standardized benchmark for group-level human behavior simulation.
+By harmonizing 20 diverse datasets, which span moral dilemmas, economic games, and psychological assessments across a vast global participant
+pool, \textsc{SimBench} enables rigorous measurement and comparison of simulation fidelity across models, tasks, and populations.
+
+Using \textsc{SimBench}, we move beyond isolated experiments to build a comprehensive picture of LLM simulation. We structure our investigation around six research questions. We first establish a baseline, asking \textbf{how well current LLMs perform at social simulation} (RQ1) and \textbf{how characteristics like model size and inference-time compute affect their simulation ability} (RQ2). We find that top models achieve meaningful but modest simulation fidelity (top score: 40.80/100), though performance scales log-linearly with size and, surprisingly, is not improved by scaling inference-time compute. Next, we explore the sources of this variance, asking \textbf{how task selection} (RQ3) and \textbf{human response plurality} (RQ4) affect simulation fidelity. We find that fidelity varies substantially by task, and uncover an alignment-simulation tradeoff: instruction tuning's mode-seeking objective systematically improves performance on low-entropy (consensus) questions but harms performance on high-entropy (pluralistic) questions. A causal analysis confirms this tradeoff stems from two opposing forces: a beneficial instruction-following effect and a harmful entropy-reduction effect. Finally, we ask if LLMs are \textbf{better at simulating some demographic groups than others} (RQ5) and \textbf{to what extent simulation ability correlates with other model capabilities} (RQ6). We show models struggle most with religious/ideological groups and that simulation ability correlates most strongly with deep, knowledge-intensive reasoning (MMLU-Pro, $r=0.939$).
+
+Progress in AI is only possible through rigorous evaluation, and large-scale benchmarks such as MMLU have significantly contributed to improvements in LLM capabilities. In the same spirit, \textsc{SimBench} provides the foundational infrastructure needed to move LLM simulation from a collection of ad-hoc studies to a measurable and systematic science. We note that while predicting group-level response distributions is the instrument used here for benchmarking, we view this as a foundational proxy for the broader capability of human behavior simulation. We acknowledge that full human simulation inherently includes interactive and complex dynamics not fully captured by static response distributions (see Appendix \ref{limitations}). We have a \href{http://simbench.tiancheng.hu/}{Project Website}, and all of \textsc{SimBench} is available on \href{https://github.com/pitehu/SimBench_release/}{GitHub} and \href{https://huggingface.co/datasets/pitehu/SimBench}{HuggingFace}.
+
+
+\section{Creating \textsc{SimBench}}
+\label{sec: simbench}
+
+
+\subsection{Data Curation}
+\label{subsec: simbench - selection process}
+To create \textsc{SimBench}, we combine a repository-driven approach, where we query major social and behavioral science repositories (e.g., Harvard Dataverse, ICPSR, OSF), and a literature-driven approach, where we identify key papers in relevant fields and trace back to their underlying data sources. We then apply a strict set of selection criteria to all candidate datasets: \textbf{large participant counts}, to ensure meaningful group-level distributions; \textbf{permissive licensing} to allow for redistribution; \textbf{single-turn, self-contained questions}, to establish a standardized evaluation paradigm free from multi-turn or contingent interactions; \textbf{multiple-choice or ordinal response formats}, to enable quantitative evaluation; and \textbf{English-language questions} or validated translations for consistency.
+
+
+We complement these criteria with a curation strategy that balances competing objectives. We prioritize \textbf{novelty}, favoring datasets not previously used in LLM simulation evaluation, but also ensure \textbf{backward comparability} by including well-established benchmarks (e.g., OpinionQA, ChaosNLI). Furthermore, we prioritize datasets with rich \textbf{sociodemographic data} to enable fine-grained analysis of specific subpopulations (\S\ref{subsec: simbench - splits}). However, we make targeted exceptions for datasets like Jester and Choices13k, which, despite lacking demographic data, provide unique and essential task diversity.
+
+
+This principled curation process yields the \textbf{20} datasets that comprise \textsc{SimBench}, which we list in Appendix~\ref{app:data_details}, providing details on participants and example questions. To demonstrate the rigor of our process, and as a resource for the community, we list datasets that were considered but ultimately excluded in Appendix~\ref{app:excluded_datasets}. Crucially, \textsc{SimBench} is fully modular by design, so that future work can easily add more datasets using the processing pipeline described in \S\ref{subsec: simbench - preprocessing} below.
+
+
+\subsection{Benchmark Properties}
+\label{subsec:simbench_properties}
+
+As a whole, \textsc{SimBench} is defined by two key properties: task diversity and participant diversity.
+
+1) \textbf{Task Diversity}:
+\textsc{SimBench} tasks are highly diverse in terms of the human behavior they capture.
+\textsc{SimBench} includes \textbf{decision-making} questions (e.g., in Choices13k, MoralMachine), where participants are presented with a set of actions that concern themselves, and they have to select the action they would hypothetically take.
+\textsc{SimBench} also includes \textbf{self-assessment} questions (e.g., in OpinionQA, OSPsychBig5), where participants are presented with a set of descriptions or attributes, and they have to select the one that best describes themselves.
+Further, \textsc{SimBench} includes \textbf{judgment} questions (e.g., in ChaosNLI and Jester) where participants are presented with some external object and a choice of labels, and they have to select the label they think fits best.
+Lastly, \textsc{SimBench} includes \textbf{problem-solving} questions (e.g., in WisdomOfCrowds and OSPsychMGKT), where participants are presented with a set of answers to a factual question, and they have to select the answer they think is correct.
+Consequently, LLMs have to accurately simulate several distinct types of human behavior in order to perform well on \textsc{SimBench}.
+
+2) \textbf{Participant Diversity}:
+\textsc{SimBench} captures a rich demographic landscape spanning more than 130 different countries across six continents (see Appendix~\ref{app:country_breakdown} for a full country-level breakdown). \textsc{SimBench} prioritizes international representation: samples from the Anglosphere West constitute only 27.9\% of the data.\footnote{We define the Anglosphere West as the U.S., Canada, U.K., Australia, and New Zealand. Even using a broader definition of ``the West'' that includes Western Europe, these nations account for less than half (45.9\%) of the benchmark.} This substantial global scope is driven by a diverse collection of sources:
+3 datasets (e.g., Latinobarómetro, Afrobarometer) exclusively feature participants from regions outside the US, 4 datasets (e.g., GlobalOpinionQA, TISP) draw from multi-country samples across different continents, and 2 datasets collect responses from a global pool of internet users. Importantly, 8 out of the 20 datasets employ representative sampling techniques, enhancing the ecological validity of these constituent components. To perform well on \textsc{SimBench}, LLMs must therefore demonstrate the ability to accurately simulate the behavior of human participants across diverse cultural, linguistic, and socioeconomic backgrounds.\footnote{Note that, while some constituent datasets recruit representative samples, \textsc{SimBench} as a whole is not fully representative of any single population. We discuss this limitation in Appendix~\ref{limitations}.}
+
+
+\subsection{Unifying \textsc{SimBench} Dataset Formats}
+\label{subsec: simbench - preprocessing}
+A core contribution of \textsc{SimBench} is the harmonization of 20 heterogeneous datasets into one standardized format. This process ensures that LLM simulation ability can be compared rigorously across diverse tasks and populations.
+
+\textbf{Question Normalization:} We standardize all items into a multiple-choice format, making minimal edits that primarily consist of mapping existing discrete options to standardized letter keys, each corresponding to a single token, to enable clean extraction of per-option probabilities from base models while preserving the original experimental structure. For the few datasets with continuous scales (Jester), we map responses to discrete bins. We further ensure consistency by collapsing answer options where appropriate, limiting the maximum to 26 choices (though typically fewer than 10), and using the official English-language versions of all questions.\footnote{We note that simulation ability may plausibly be correlated with prompt language, and encourage future work in this direction.} This is a deliberate choice to standardize the evaluation and avoid confounding simulation ability with multilingual performance capabilities, ensuring that differences in scores reflect simulation fidelity rather than translation quality, even for datasets originally collected in local languages.
+
+\textbf{Response Aggregation:} To evaluate group-level simulation, we standardize all data into group-level probability distributions. For the majority of our datasets, which provide raw individual-level responses, we create these distributions by aggregating the data ourselves. Post-stratification weights are applied whenever applicable (e.g., ESS). For the few datasets that are already provided in an aggregated format (e.g., GlobalOpinionQA), we process and normalize their existing statistics to conform to the \textsc{SimBench} schema.
+
+We create the simulation targets — the ground-truth response distributions that models must predict — in two ways:\ 1) \textbf{Default Grouping}. For every question in a dataset, we create a baseline target by aggregating responses from all participants. This represents the ``default'' population for that dataset (e.g., ``US-based Amazon Mechanical Turk workers'') and is used to measure general simulation ability. 2) \textbf{Specific Grouping}. For datasets with rich sociodemographic data, we create more fine-grained targets by aggregating responses from participants sharing a specific attribute (e.g., age or gender). This allows us to evaluate LLM ability to simulate narrower, more specific demographic groups. We detail the available grouping variables for each dataset in Appendix~\ref{app:data_details}.
+
+Each simulation target is paired with a prompt that describes the corresponding group. Overall, this harmonization process yields \textbf{10,930,271} unique question-group simulation targets. From this set, we curate our final benchmark splits (\S\ref{subsec: simbench - splits}) to enable robust evaluation of LLM simulation capabilities. We note that while training data contamination remains an inherent risk, our zero-shot aggregation task largely mitigates this by testing distributional prediction (see Appendix~\ref{limitations} for a full discussion).
+
+\subsection{\textsc{SimBench} Splits}
+\label{subsec: simbench - splits}
+
+The full set of over 10 million simulation targets is too vast for practical evaluation. We therefore curate two benchmark splits, each designed to probe a different facet of LLM simulation ability.
+
+1) The \textbf{SimBenchPop} split covers all questions in all 20 datasets after processing as in \S\ref{subsec: simbench - preprocessing}.
+We combine each question with the dataset-specific default grouping prompt to create one unique test case, resulting in 7,167 test cases.
+We obtain the response distribution for each test case by aggregating all individual responses to that test case over all participants in that dataset.
+Conceptually, \textbf{SimBenchPop measures the ability of LLMs to simulate responses of broad and diverse human populations}.
+
+2) The \textbf{SimBenchGrouped} split draws from the five large-scale survey datasets in \textsc{SimBench} (Afrobarometer, ESS, ISSP, Latinobarómetro, and OpinionQA), which are the only datasets with sufficient participant counts to yield reliable response distributions even when conditioning on a specific demographic attribute (e.g., age = 30-49).
+For each dataset, we select questions that exhibit significant variation across demographic groups, ensuring that the benchmark captures meaningful demographic differences in responses.
+This results in 6,343 test cases overall.
+For more details on the sampling process, see Appendix~\ref{sec: simbench_sampling_detail}.
+Conceptually, \textbf{SimBenchGrouped measures the ability of LLMs to simulate responses from narrower participant groups based on specified group characteristics}.
+\footnote{Ideally, we would also like to measure LLM simulation ability for intersectional groups that combine multiple characteristics (e.g., female + age 30-49). However, selecting on multiple characteristics substantially decreases group size, thus increasing sampling noise in the response distributions.
+Reliable evaluation of intersectional group simulation ability would require datasets with more participants than we have access to.}
+
+
+\section{Experimental Setup}
+\label{sec:experimental_setup}
+
+\textbf{Tested Models:}
+To demonstrate the utility of \textsc{SimBench} and answer our six research questions (\S\ref{sec: intro}), we evaluate 45 recent LLMs.
+This includes both commercial and open-weight, base and instruction-tuned models, with sizes ranging from 0.5B to 405B parameters.
+Table~\ref{tab:total_variation_main_expanded} lists all models.
+
+
+\textbf{Model Elicitation:}
+For each model, we collect predictions for the two main splits of \textsc{SimBench} (\S\ref{subsec: simbench - splits}).
+To obtain model response distributions, we use one of two methods, depending on model type:
+1) For base models, we directly extract \textbf{token probabilities} for each response option based on first-token logits.
+This is a natural way of eliciting a distribution out of an LLM, especially a base LLM.
+2) For instruction-tuned models, we follow recent literature on LLM calibration and distribution prediction~ and use \textbf{verbalized distributions} (e.g., ``Option A: 30\%, Option B: 70\%'') elicited through prompting. We empirically validate this methodological choice in Appendix~\ref{app:elicitation_validation}, which provides strong evidence that verbalized distributions substantially and consistently outperform direct token probabilities for instruction-tuned models. This ensures each model class is evaluated using its most suitable answer elicitation method. For implementation details and prompt formats, see Appendix~\ref{sec:implementation_details}.
+
+
+\textbf{Evaluation Metric}:
+To measure LLM simulation ability, we derive the \textsc{SimBench} score $S$ from the Total Variation Distance (TVD). Conceptually, $S$ quantifies the improvement of a model's prediction $Q$ over a uniform baseline $U$, relative to the human ground truth $P$:
+\begin{equation}
+S(P, Q) = 100 \left(1 - \frac{\operatorname{TVD}(P, Q)}{\operatorname{TVD}(P, U)}\right)
+\end{equation}
+where a score of 100 indicates perfect alignment and 0 indicates performance equivalent to random guessing. Since in practice a direct point-wise calculation is undefined when the question-level human distribution is uniform ($P=U$), to ensure numerical stability, we compute the score $S_i$ for each specific test case $i$ by normalizing against the \textit{dataset-level} mean baseline:
+\begin{equation}
+S_i = 100 \left(1 - \frac{\operatorname{TVD}(P_i, Q_i)}{\frac{1}{|D|} \sum_{j \in D} \operatorname{TVD}(P_j, U_j)}\right)
+\end{equation}
+
+
+where the denominator represents the average TVD between human responses and the uniform distribution across all test cases $j$ in the dataset $D$. This ensures the metric remains robust across datasets with varying entropy. The final reported score for a model is the average of $S_i$ across all evaluated test cases. As described in \S\ref{subsec: simbench - splits}, we cap each dataset at 500 questions to limit over-representation of larger datasets; datasets with fewer total questions naturally contribute fewer test cases and thus carry proportionally less weight in the overall score.
+
+
+\section{Results}
+\label{Results}
+
+
+\subsection{RQ1: General Simulation Ability of LLMs}
+\label{sec:overall_feasibility}
+To evaluate general simulation ability, we measure overall \textsc{SimBench} score $S$ averaged across the two main splits of \textsc{SimBench} in Table~\ref{tab:total_variation_main} and Appendix Table~\ref{tab:total_variation_main_expanded}.
+
+We find that \textbf{the best LLMs achieve meaningful but modest simulation fidelity}, as measured across the 20 datasets in \textsc{SimBench}.
+Claude-3.7-Sonnet is the best-performing model overall, achieving a score of 40.80 out of 100 on \textsc{SimBench}.
+While this score means the best model's predictions remain closer to a uniform distribution than to the human ground truth, it nonetheless closes roughly 40\% of the gap between the two, demonstrating a genuine and non-trivial simulation signal.
+The top open-weight model, DeepSeek-R1, scores 34.52.
+The majority of the 45 models we test perform substantially worse, scoring less than 20.
+Notably, ten models we test score below 0, indicating that their predicted response distributions are, on
+average, even further away from the true human response distribution than a uniform response distribution.
+Statistical analysis, detailed in Appendix~\ref{app:statistical_analysis}, confirms that the performance differences between most top-ranked models as well as within each model family are statistically significant.
+Overall, these results consolidate the mixed findings from prior work into a clearer, if somewhat sobering, picture. When evaluated across a diverse range of tasks and populations, today’s LLMs do possess genuine, non-trivial simulation abilities but are still far from being consistently reliable, general-purpose simulators. The stark performance differences between models also caution strongly against the use of smaller, less capable models for simulation, many of which perform worse than a simple uniform baseline.
+
+
+\subsection{RQ2: Impact of LLM Characteristics on Simulation Ability}
+\label{sec:llm_characteristics}
+
+While even the best models struggle to perform well on \textsc{SimBench}, Table~\ref{tab:total_variation_main} also shows clear differences across models.
+Therefore, we investigate how performance varies depending on model characteristics, specifically 1) model size, and 2) inference-time compute.
+\paragraph{1) Model Size}
+To evaluate the impact of model size on simulation ability, we plot \textsc{SimBench} Score $S$ against model parameter count for the four LLM families that we can test across multiple model sizes (Figure~\ref{fig:scaling_law_tv} and Appendix Figure~\ref{fig:scaling_law_tv_full}).
+Our results suggest that there is a log-linear scaling trend for LLM simulation ability. Across examined model families, for both base and instruction models, an increase in parameter count generally corresponds to an increase in \textsc{SimBench} score $S$, indicating better alignment between predicted and human response distributions. This relationship is robustly supported by model families with comprehensive size variants (e.g., Qwen2.5, Llama-3.1), though additional data points would be needed to fully characterize the trajectory for families with fewer models (e.g., OLMo).
+There is also an interaction between model size and the effect of instruction tuning. While instruction-tuned models consistently outperform their base counterparts at larger scales (>10B parameters), this relationship appears to invert for smaller models. For example, the OLMo-2 base models outperform their instruction-tuned variants at the 7B and 13B scale. Furthermore, the plot shows that \textbf{instruction-tuned models not only reach a higher peak performance but also appear to scale more effectively}. The steeper slope of the dashed lines (e.g., for Qwen2.5-Instruct) compared to the solid lines suggests that instruction tuning may improve a model's ability to capitalize on increases in parameter count for the simulation task. We present a more comprehensive plot including all evaluated model families in Appendix~\ref{sec:full_simbench_score}, which confirms this trend holds across models.
+
+Overall, the clear positive scaling trends across model families suggest that simulation ability is a capability that improves with scale. However, the log-linear nature of this relationship implies diminishing returns from scale alone, reinforcing the need for targeted approaches — such as distribution-preserving alignment (\S\ref{sec:response_plurality}) — to achieve substantial further gains.
+
+
+\paragraph{2) Inference-Time Compute}
+To analyze the effects of increasing inference-time compute on LLM simulation ability, we conduct two sets of experiments. First, we compare the performance of two distinct o4-mini checkpoints (``low'' vs.\ ``high'', which vary in the amount of reasoning effort), as well as Claude-3.7-Sonnet without reasoning and with a 4000-token reasoning budget. Second, we apply a zero-shot Chain-of-Thought (CoT) prompting strategy~ to GPT-4.1 and DeepSeek-V3-0324 (see Appendix~\ref{sec:implementation_details} for prompt details).
+
+Our results suggest that, across the models tested, \textbf{increasing inference-time compute provides no meaningful benefit for LLM simulation ability.} The o4-mini model shows minor improvement (\textsc{SimBench} $S$ score: 27.77 → 28.99), while Claude-3.7-Sonnet's performance slightly decreases (40.80 → 39.46). Similarly, applying CoT prompting leads to a small performance drop for GPT-4.1 (34.55 → 33.11) and a negligible change for DeepSeek-V3-0324 (32.89 → 33.16). While our analysis covers a limited number of models, this result aligns with a growing body of recent work showing that inference-time compute benefits are highly task-dependent~ and do not necessarily improve role-playing ability~. We hypothesize this is because CoT forces an overly rational deliberation that mismatches the often heuristic-driven nature of human responses in SimBench.
+
+
+\subsection{RQ3: Impact of Task Selection on Simulation Fidelity}
+\label{sec:task_selection}
+
+
+The 20 datasets in \textsc{SimBench} correspond to tasks that are highly diverse in terms of which aspects of human behavior they measure (see \S\ref{subsec: simbench - selection process}).
+Breaking down simulation fidelity by dataset (Figure~\ref{fig:total_variation_per_dataset}) reveals that \textbf{simulation fidelity varies substantially across tasks}. Models are most successful at simulating responses to standard survey questions regarding stated opinions, attitudes, and self-assessments (e.g., OpinionQA, Afrobarometer).
+However, performance degrades on tasks requiring the simulation of a \textit{behavioral choice}, whether in risky choice problems (Choices13k) or moral dilemmas (MoralMachine). This finding provides large-scale evidence for a ``value-action gap'' in LLMs, echoing recent work which suggests a misalignment exists between LLM-generated value statements and their actions.
+
+Finally, models struggle severely to capture human response distributions on datasets involving traits or beliefs that conflict with standard alignment objectives. For even the best LLMs, we observe extremely poor performance, often worse than a uniform baseline, on datasets measuring Machiavellianism (OSPsychMACH), conspiratorial beliefs (ConspiracyCorr), or humor rating (Jester).
+This aligns with a growing body of work showing that alignment filters may inhibit the simulation of ``atypical'' or counter-normative human perspectives. While most LLMs exhibit these performance patterns, GPT-4.1 is a notable outlier, scoring exceptionally high (61.9) on OSPsychRWAS.
+
+
+\subsection{RQ4: The Alignment-Simulation Tradeoff}
+\label{sec:response_plurality}
+
+Faithful simulation requires models to capture the full spectrum of human opinion, from strong consensus to widespread disagreement. We operationalize this ``response plurality'' using the normalized entropy of the human response distribution.
+
+\paragraph{An Empirical Tradeoff between Alignment and Plurality.}
+Prior work suggests that standard alignment via instruction tuning encourages confident, low-entropy outputs~, which creates a potential conflict with simulating diverse human perspectives.
+Our analysis reveals exactly this tradeoff. As detailed in Appendix~\ref{app:base_vs_instruct_heatmap}, base models consistently outperform their instruction-tuned counterparts on high-entropy questions, while the inverse is true for low-entropy questions. To precisely quantify this effect, we compute the change in \textsc{SimBench} score ($\Delta S = S_{\text{instruct}} - S_{\text{base}}$) for 13 model pairs and plot this performance gain from post-training against human response entropy.
+
+The result, shown in Figure~\ref{fig:entropy_improvement}, is a near-perfect negative linear relationship ($r = -0.942$). This plot reveals two distinct regimes. On low-entropy questions where humans agree, post-training provides a substantial benefit, improving the S-score by up to 40 points. However, as human disagreement (entropy) increases, the benefit of instruction tuning systematically erodes, crossing a point of no-improvement around an entropy of 0.8. For questions with the highest plurality, post-training becomes actively detrimental, making the aligned model a \textit{worse} simulator than its base counterpart.
+
+This empirical finding is well-explained by the theoretical framework of reinforcement learning (RL) as Bayesian inference~. The pre-training objective of a base model typically minimizes a \textit{mass-covering} KL divergence ($D_{KL}(p \Vert q)$), which encourages the model ($q$) to place probability mass wherever the true data distribution ($p$) has mass. This process naturally leads to models that represent the full, multi-modal diversity of human language and opinion seen in their training data. In contrast, alignment via KL-regularized RL (e.g., RLHF) minimizes a \textit{mode-seeking} KL divergence ($D_{KL}(q \Vert \sigma)$). This objective incentivizes the model ($q$) to find and concentrate its probability mass on a single, high-reward mode of the target preference distribution ($\sigma$), even at the cost of ignoring other valid modes. Our results provide strong empirical validation of this theoretical distinction: alignment optimizes for a single ``best'' response, effectively encouraging the model to discard the pluralistic, high-entropy distributions characteristic of genuine human populations.
+
+To formally test this mechanism, a causal mediation analysis (Appendix~\ref{sec:causal_mediation_analysis}) decomposes the effect of instruction tuning into two larger, opposing forces: a large, positive \textit{direct effect} on performance (\textbf{+6.46}), likely from improved instruction-following, and a significant, negative \textit{indirect effect} (\textbf{-1.74}) mediated by the model's reduced output entropy.
+
+
+\paragraph{Case Study: General-Purpose vs. Specialist Cognitive Tuning.}
+This formally-decomposed tradeoff is perfectly illustrated by comparing general-purpose instruction tuning with the specialist cognitive tuning of the Centaur models . Centaur models are Llama models fine-tuned on Psych-101, a large dataset of lab experiments, making our diverse \textsc{SimBench} a powerful out-of-distribution test of their generalization. Both approaches improve simulation over the Llama-3.1-70B base model, but they do so via opposing mechanisms. \textbf{General-purpose instruction tuning} ($S=16.56$) leverages the helpful direct effect of alignment, excelling on low-entropy consensus tasks. In contrast, \textbf{specialist cognitive tuning} ($S=8.54$) improves performance by avoiding the harmful indirect effect, preserving the base model's intrinsic ability to capture high-entropy pluralistic responses. The existence of these two distinct—and currently separate—paths to improving simulation underscores a key challenge and opportunity: the most faithful simulators of the future will likely need to synthesize the benefits of both general-purpose alignment and distribution-preserving cognitive modeling. Other promising directions include post-hoc weight interpolation~ and inference-time methods to amplify system prompt adherence beyond the default assistant persona~.
+
+
+\subsection{RQ5: Simulation Ability Across Participant Groups}
+\label{sec:group_variation}
+
+
+Many applications require simulating responses from specific demographic groups rather than general populations. Using SimBenchGrouped, we evaluate how LLM simulation ability changes when conditioned on specific demographic attributes.
+
+
+We measure this change as $\Delta S = S_{grouped} - S_{ungrouped}$, where $S_{ungrouped}$ is the \textsc{SimBench} score for simulating the general population and $S_{grouped}$ is the score when simulating a specific demographic group on the same question. A negative $\Delta S$ indicates that the model's simulation ability decreases relative to the uniform baseline when it is asked to simulate specific demographic groups.
+
+Importantly, for SimBenchGrouped, we specifically selected questions where human response distributions showed the highest variance across demographic groups (see \S\ref{subsec: simbench - splits}). The observed degradation in simulation performance therefore likely represents an upper bound on the challenges LLMs face when simulating specific demographic groups. Our results in Table \ref{tab:delta_tvd_combined} show that \textbf{LLMs struggle more with simulating specific demographic groups compared to general populations}. All evaluated models show negative mean $\Delta S$ values, with degradation ranging from -1.27 for DeepSeek-V3-0324 to -4.61 for Claude-3.7-Sonnet-4000. All degradations are statistically significant, with 95\% confidence intervals excluding zero in every case.
+
+
+The performance degradation varies substantially by demographic category. Models struggle most when simulating groups defined by religious attributes, with conditioning on ``Religiosity/Practice'' causing the largest decrease in simulation accuracy ($\Delta S = -9.91$), followed by ``Political Affiliation/Ideology'' ($\Delta S = -4.97$) and ``Religion (Affiliation)'' ($\Delta S = -4.83$). In contrast, models maintain relatively better performance when simulating groups defined by ``Gender'' ($\Delta S = -1.24$) and ``Age'' ($\Delta S = -1.50$).
+
+
+While these findings may not fully generalize to cases where demographic differences are less pronounced, they highlight potential limitations in how current LLMs capture the nuanced response patterns of specific demographic groups. We argue that such challenging benchmarks are crucial for identifying areas where improvements are most needed, particularly for applications that aim to model the behaviors of specific subpopulations.
+
+
+\subsection{RQ6: Simulation Ability vs.\ General Capabilities}
+\label{sec:simulation_vs_capabilities}
+
+Finally, we analyze the relationship between LLM simulation ability and more general model capabilities by correlating performance on \textsc{SimBench} with popular LLM capability benchmarks. We collect performance data for eight models on five benchmarks representing distinct capabilities and calculate the Pearson correlation with their \textsc{SimBench}\ scores (see Appendix~\ref{app:correlation_plots} for implementation details and scatter plots).
+
+We find that \textsc{SimBench}\ performance correlates most strongly with benchmarks requiring knowledge-intensive reasoning, such as \textbf{MMLU-Pro (r = 0.94)} and \textbf{GPQA Diamond (r = 0.86)}. The correlation is weaker for general helpfulness (Chatbot Arena ELO, r = 0.71) and instruction following (IF-Eval, r = 0.79). Crucially, the correlation is substantially weaker for narrow, specialized skills like advanced mathematics (\textbf{OTIS AIME, r = 0.48}). We posit that accurately simulating human behavior is a complex capability rooted in broad, knowledge-intensive reasoning, which aligns with the diverse social and behavioral topics in \textsc{SimBench}. The weaker correlations with Chatbot Arena and OTIS AIME suggest that neither general conversational ability nor narrow problem-solving skills are sufficient proxies for strong simulation performance.
+
+
+\section{Conclusion and Future Work}
+\label{sec: conclusion}
+
+For LLM simulations to become reliable tools for the social and behavioral sciences, their fidelity to real human behavior must be measurable. However, prior evaluations have been fragmented, hindering systematic progress. To address this, we introduce \textsc{SimBench}, the first large-scale, standardized benchmark for group-level human behavior simulation. By unifying 20 diverse datasets, \textsc{SimBench} provides the necessary infrastructure to robustly evaluate and compare LLM simulators.
+
+Using \textsc{SimBench}, we provide the first systematic analysis of simulation ability across 45 LLMs.
+We show that even the best LLMs have limited simulation ability, that performance scales log-linearly with model size, and that there exists a fundamental tradeoff between standard alignment and simulating diverse human opinions. We further show that models struggle more when simulating specific demographic groups, and that strong simulation ability correlates with deep, knowledge-intensive reasoning. While significant progress is needed, \textsc{SimBench} makes this progress measurable, providing an open foundation to accelerate the development of more faithful LLM simulators.
+
+We hope that future research can build on this foundation by expanding beyond standardized formats to evaluate \textbf{interactive and open-ended behavioral simulations}. Finally, addressing the observed tradeoff between alignment and simulation fidelity requires developing \textbf{distribution-preserving alignment} techniques, alongside further investigation into the \textbf{causal mechanisms} linking other model capabilities to simulation performance.
+
+\section*{Acknowledgments}
+This work was partially conducted while TH, JB, and PR were at the Data and Marketing Insights research unit of the Bocconi Institute for Data Science and Analysis. TH was supported by the Gates Cambridge Trust (grant OPP1144 from the Bill \& Melinda Gates Foundation). JB acknowledges funding from the Swiss National Science Foundation (SNSF) through project P500-2\_235328. DH was supported by the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation program (grant agreement No. 949944, INTEGRATOR). PR was supported by a MUR FARE 2020 initiative under grant agreement Prot. R20YSMBZ8S (INDOMITA).
+
+
+\newpage
+\section*{Ethics Statement}
+\label{ethics}
+
+\textsc{SimBench}'s primary purpose is to benchmark LLM ability to simulate human behavior.
+While advancements in LLM simulation capabilities can support helpful applications such as pre-testing policies, these do not come without risks of misrepresentation and dual use.
+
+\subsection*{Responsible Use and Acknowledgment of Limitations}
+First and foremost, due to the observed limited simulation ability of state-of-the-art LLMs, we caution against relying on LLM-powered simulations of human behavior for tasks where downstream harm is possible.
+Even as models improve, substituting algorithmic approximations for authentic human participation carries the risk of disadvantaging under-represented / marginalized communities by removing their opportunities to directly shape decisions that affect them.
+Furthermore, while benchmarks like \textsc{SimBench} help measure simulation capabilities, we must be careful not to mistake increasing benchmark performance for genuine understanding of complex human behavior.
+
+\subsection*{Data Provenance and Transformative Use}
+The creation of \textsc{SimBench}\ from 20 diverse sources was guided by a commitment to responsible data handling. Our curation process prioritized datasets with clear and permissive terms. As a result, 17 out of the 20 datasets are governed by explicit permissive licenses (e.g., Creative Commons, MIT). For the few remaining datasets that are publicly available for research without an explicit license, we apply a consistent framework built on the principle of transformative use.
+
+\begin{enumerate}[nosep, leftmargin=*]
+ \item \textbf{Transformative Use.} \textsc{SimBench}\ does not contain or redistribute any raw, individual-level participant data. It is a new, derivative work consisting of aggregated, non-reversible group-level distributions. This process protects the privacy of the original human subjects.
+
+ \item \textbf{Multi-Level Licensing.} Our public release includes a detailed \texttt{LICENSE} file. \textbf{The \textsc{SimBench} framework} (our code and pipeline) is permissively licensed (e.g., CC-BY-NC-SA 4.0). For each of the \textbf{20 constituent datasets}, the documentation explicitly lists the original source, its specific license or terms of use, and a clear statement clarifying its status as an aggregated, derivative work whose original terms should still be consulted.
+\end{enumerate}
+
+\subsection*{Scope of Representation and Intersectional Analysis}
+
+While \textsc{SimBench} includes diverse demographic groups, it cannot adequately support simulations of intersectional identities due to sample size limitations.
+By conditioning on one demographic variable at a time, we cannot systematically assess how well models handle the rich overlap of identities (e.g., ``older Latinx women,'' ``young Black men''). This was a deliberate methodological choice to maintain the statistical integrity of the ground-truth distributions, as small intersectional group sizes make it difficult to combine multiple characteristics simultaneously due to increasing sampling noise in response distributions.
+Yet intersectional simulation is precisely where societal biases and model limitations often emerge, making this an important direction for future work.
+Additionally, the conditional prompting approach we use conceptualizes simplistic human populations and may thus fail to appropriately account for nuances of individual behavior.
+
+\subsection*{Conclusion}
+Nevertheless, we believe \textsc{SimBench} is an important step toward making LLM simulation progress measurable and raising awareness of state-of-the-art model blind spots. Together, we hope this will ultimately create accountability for models deployed in socially sensitive contexts.
+
+\section*{Reproducibility Statement}
+\textsc{SimBench} is released on \href{https://huggingface.co/datasets/pitehu/SimBench}{HuggingFace}. Our codebase is available on \href{https://github.com/pitehu/SimBench_release/}{GitHub}. We provide detailed descriptions of our experimental setup, including the exact prompts used for both base and instruction-tuned models, in Appendix~\ref{sec:implementation_details}, and an empirical validation of our elicitation methodology in Appendix~\ref{app:elicitation_validation}.

benchmark_dataset/papers/ICLR2026_0011_2510.17516/source_references.tex

@@ -0,0 +1,132 @@
+\begin{thebibliography}{99}
+
+\bibitem[Argyle et~al.(2023)Argyle, Busby, Fulda, Gubler, Rytting, and Wingate]{Argyle_Busby_Fulda_Gubler_Rytting_Wingate_2023}
+Lisa~P. Argyle, Ethan~C. Busby, Nancy Fulda, Joshua~R. Gubler, Christopher Rytting, and David Wingate.
+\newblock Out of one, many: Using language models to simulate human samples.
+\newblock \emph{Political Analysis}, 31\penalty0 (3):\penalty0 337–351, 2023.
+\newblock \doi{10.1017/pan.2023.2}.
+
+\bibitem[Bisbee et~al.(2024)Bisbee, Clinton, Dorff, Kenkel, and Larson]{Bisbee_Clinton_Dorff_Kenkel_Larson_2024}
+James Bisbee, Joshua~D. Clinton, Cassy Dorff, Brenton Kenkel, and Jennifer~M. Larson.
+\newblock Synthetic replacements for human survey data? the perils of large language models.
+\newblock \emph{Political Analysis}, 32\penalty0 (4):\penalty0 401–416, 2024.
+\newblock \doi{10.1017/pan.2024.5}.
+
+\bibitem[Dominguez-Olmedo et~al.(2024)Dominguez-Olmedo, Hardt, and Mendler-D\"{u}nner]{NEURIPS2024_Dominguez}
+Ricardo Dominguez-Olmedo, Moritz Hardt, and Celestine Mendler-D\"{u}nner.
+\newblock Questioning the survey responses of large language models.
+\newblock In A.~Globerson, L.~Mackey, D.~Belgrave, A.~Fan, U.~Paquet, J.~Tomczak, and C.~Zhang (eds.), \emph{Advances in Neural Information Processing Systems}, volume~37, pp.\  45850--45878. Curran Associates, Inc., 2024.
+\newblock URL \url{https://proceedings.neurips.cc/paper_files/paper/2024/file/515c62809e0a29729d7eec26e2916fc0-Paper-Conference.pdf}.
+
+\bibitem[Aher et~al.(2023)Aher, Arriaga, and Kalai]{Aher2023Using}
+Gati~V Aher, Rosa~I. Arriaga, and Adam~Tauman Kalai.
+\newblock Using large language models to simulate multiple humans and replicate human subject studies.
+\newblock In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett (eds.), \emph{Proceedings of the 40th International Conference on Machine Learning}, volume 202 of \emph{Proceedings of Machine Learning Research}, pp.\  337--371. PMLR, 23--29 Jul 2023.
+\newblock URL \url{https://proceedings.mlr.press/v202/aher23a.html}.
+
+\bibitem[Manning et~al.(2024)Manning, Zhu, and Horton]{manning2024automated}
+Benjamin~S Manning, Kehang Zhu, and John~J Horton.
+\newblock Automated social science: Language models as scientist and subjects.
+\newblock Technical report, National Bureau of Economic Research, 2024.
+
+\bibitem[Hewitt et~al.(2024)Hewitt, Ashokkumar, Ghezae, and Willer]{hewitt2024predicting}
+Luke Hewitt, Ashwini Ashokkumar, Isaias Ghezae, and Robb Willer.
+\newblock Predicting results of social science experiments using large language models, August 2024.
+\newblock URL \url{https://samim.io/dl/Predicting%20results%20of%20social%20science%20experiments%20using%20large%20language%20models.pdf}.
+
+\bibitem[Binz et~al.(2025)Binz, Akata, Bethge, Br{\"a}ndle, Callaway, Coda-Forno, Dayan, Demircan, Eckstein, {\'E}ltet{\H{o}}, et~al.]{binz2024centaur}
+Marcel Binz, Elif Akata, Matthias Bethge, Franziska Br{\"a}ndle, Fred Callaway, Julian Coda-Forno, Peter Dayan, Can Demircan, Maria~K Eckstein, No{\'e}mi {\'E}ltet{\H{o}}, et~al.
+\newblock A foundation model to predict and capture human cognition.
+\newblock \emph{Nature}, pp.\  1--8, 2025.
+
+\bibitem[Horton(2023)]{horton2023large}
+John~J Horton.
+\newblock Large language models as simulated economic agents: What can we learn from homo silicus?
+\newblock Technical report, National Bureau of Economic Research, 2023.
+
+\bibitem[Park et~al.(2023)Park, O'Brien, Cai, Morris, Liang, and Bernstein]{10.1145/3586183.3606763}
+Joon~Sung Park, Joseph O'Brien, Carrie~Jun Cai, Meredith~Ringel Morris, Percy Liang, and Michael~S. Bernstein.
+\newblock Generative agents: Interactive simulacra of human behavior.
+\newblock In \emph{Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology}, UIST '23, New York, NY, USA, 2023. Association for Computing Machinery.
+\newblock ISBN 9798400701320.
+\newblock \doi{10.1145/3586183.3606763}.
+\newblock URL \url{https://doi.org/10.1145/3586183.3606763}.
+
+\bibitem[Hu \& Collier(2024)Hu and Collier]{hu-collier-2024-quantifying}
+Tiancheng Hu and Nigel Collier.
+\newblock Quantifying the persona effect in {LLM} simulations.
+\newblock In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), \emph{Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)}, pp.\  10289--10307, Bangkok, Thailand, August 2024. Association for Computational Linguistics.
+\newblock \doi{10.18653/v1/2024.acl-long.554}.
+\newblock URL \url{https://aclanthology.org/2024.acl-long.554/}.
+
+\bibitem[Dong et~al.(2024)Dong, Hu, and Collier]{dong-etal-2024-llm}
+Yijiang~River Dong, Tiancheng Hu, and Nigel Collier.
+\newblock Can {LLM} be a personalized judge?
+\newblock In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (eds.), \emph{Findings of the Association for Computational Linguistics: EMNLP 2024}, pp.\  10126--10141, Miami, Florida, USA, November 2024. Association for Computational Linguistics.
+\newblock \doi{10.18653/v1/2024.findings-emnlp.592}.
+\newblock URL \url{https://aclanthology.org/2024.findings-emnlp.592/}.
+
+\bibitem[Hu \& Collier(2025)Hu and Collier]{hu2025inews}
+Tiancheng Hu and Nigel Collier.
+\newblock i{N}ews: A multimodal dataset for modeling personalized affective responses to news.
+\newblock In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad~Taher Pilehvar (eds.), \emph{Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)}, pp.\  25000--25040, Vienna, Austria, July 2025. Association for Computational Linguistics.
+\newblock ISBN 979-8-89176-251-0.
+\newblock \doi{10.18653/v1/2025.acl-long.1217}.
+\newblock URL \url{https://aclanthology.org/2025.acl-long.1217/}.
+
+\bibitem[Cheng et~al.(2023)Cheng, Piccardi, and Yang]{cheng-etal-2023-compost}
+Myra Cheng, Tiziano Piccardi, and Diyi Yang.
+\newblock {C}o{MP}os{T}: Characterizing and evaluating caricature in {LLM} simulations.
+\newblock In Houda Bouamor, Juan Pino, and Kalika Bali (eds.), \emph{Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing}, pp.\  10853--10875, Singapore, December 2023. Association for Computational Linguistics.
+\newblock \doi{10.18653/v1/2023.emnlp-main.669}.
+\newblock URL \url{https://aclanthology.org/2023.emnlp-main.669/}.
+
+\bibitem[Wang et~al.(2025)Wang, Morgenstern, and Dickerson]{wang2025large}
+Angelina Wang, Jamie Morgenstern, and John~P Dickerson.
+\newblock Large language models that replace human participants can harmfully misportray and flatten identity groups.
+\newblock \emph{Nature Machine Intelligence}, pp.\  1--12, 2025.
+
+\bibitem[Liu et~al.(2025{\natexlab{a}})Liu, Geng, Peterson, Sucholutsky, and Griffiths]{liu2025large}
+Ryan Liu, Jiayi Geng, Joshua Peterson, Ilia Sucholutsky, and Thomas~L. Griffiths.
+\newblock Large language models assume people are more rational than we really are.
+\newblock In \emph{The Thirteenth International Conference on Learning Representations}, 2025{\natexlab{a}}.
+\newblock URL \url{https://openreview.net/forum?id=dAeET8gxqg}.
+
+\bibitem[Park et~al.(2024{\natexlab{b}})Park, Schoenegger, and Zhu]{park2024diminished}
+Peter~S. Park, Philipp Schoenegger, and Chongyang Zhu.
+\newblock Diminished diversity-of-thought in a standard large language model.
+\newblock \emph{Behavior Research Methods}, 56:\penalty0 5754--5770, 2024{\natexlab{b}}.
+\newblock \doi{10.3758/s13428-023-02307-x}.
+\newblock URL \url{https://link.springer.com/article/10.3758/s13428-023-02307-x}.
+
+\bibitem[Anthis et~al.(2025)Anthis, Liu, Richardson, Kozlowski, Koch, Brynjolfsson, Evans, and Bernstein]{anthis2025llm}
+Jacy~Reese Anthis, Ryan Liu, Sean~M Richardson, Austin~C. Kozlowski, Bernard Koch, Erik Brynjolfsson, James Evans, and Michael~S. Bernstein.
+\newblock Position: {LLM} social simulations are a promising research method.
+\newblock In \emph{Forty-second International Conference on Machine Learning Position Paper Track}, 2025.
+\newblock URL \url{https://openreview.net/forum?id=cRBg1dtj7o}.
+
+\bibitem[Ying et~al.(2025)Ying, Collins, Wong, Sucholutsky, Liu, Weller, Shu, Griffiths, and Tenenbaum]{ying2025benchmarking}
+Lance Ying, Katherine~M Collins, Lionel Wong, Ilia Sucholutsky, Ryan Liu, Adrian Weller, Tianmin Shu, Thomas~L Griffiths, and Joshua~B Tenenbaum.
+\newblock On benchmarking human-like intelligence in machines.
+\newblock \emph{arXiv preprint arXiv:2502.20502}, 2025.
+
+\bibitem[Ma et~al.(2024)Ma, Wang, Hu, Haensch, Hedderich, Plank, and Kreuter]{ma-etal-2024-potential}
+Bolei Ma, Xinpeng Wang, Tiancheng Hu, Anna-Carolina Haensch, Michael~A. Hedderich, Barbara Plank, and Frauke Kreuter.
+\newblock The potential and challenges of evaluating attitudes, opinions, and values in large language models.
+\newblock In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (eds.), \emph{Findings of the Association for Computational Linguistics: EMNLP 2024}, pp.\  8783--8805, Miami, Florida, USA, November 2024. Association for Computational Linguistics.
+\newblock \doi{10.18653/v1/2024.findings-emnlp.513}.
+\newblock URL \url{https://aclanthology.org/2024.findings-emnlp.513/}.
+
+\bibitem[Kozlowski \& Evans(2025)Kozlowski and Evans]{kozlowski2024simulating}
+Austin~C. Kozlowski and James Evans.
+\newblock Simulating subjects: The promise and peril of artificial intelligence stand-ins for social agents and interactions.
+\newblock \emph{Sociological Methods \& Research}, 54\penalty0 (3):\penalty0 1017--1073, 2025.
+\newblock \doi{10.1177/00491241251337316}.
+\newblock URL \url{https://doi.org/10.1177/00491241251337316}.
+
+\bibitem[Olteanu et~al.(2025)Olteanu, Barocas, Blodgett, Egede, DeVrio, and Cheng]{olteanu2025ai}
+Alexandra Olteanu, Solon Barocas, Su~Lin Blodgett, Lisa Egede, Alicia DeVrio, and Myra Cheng.
+\newblock Ai automatons: Ai systems intended to imitate humans.
+\newblock \emph{arXiv preprint arXiv:2503.02250}, 2025.
+
+\end{thebibliography}

benchmark_dataset/papers/ICLR2026_0011_2510.17516/source_related_work.tex

@@ -0,0 +1,10 @@
+\section{Related Work}
+\label{sec: related work}
+
+\paragraph{Human Behavior Simulation with LLMs}
+LLMs as human behavior simulators have attracted significant interdisciplinary attention. Researchers have evaluated their efficacy across political science , psychology , economics , and computer science applications . Evidence regarding LLMs' simulation fidelity remains mixed, with some studies reporting promising results while others identify critical limitations, including homogenized group representations , a tendency toward hyper-rationality rather than human-like error~, and deterministic rather than distributional predictions .
+
+Existing work has predominantly focused on individual-level simulation with minimal demographic conditioning, typically evaluating only one or two models in narrowly defined contexts. \textsc{SimBench} addresses these limitations by providing a comprehensive benchmark for group-level simulation across diverse domains with systematic demographic conditioning and standardized metrics. \textsc{SimBench}'s distributional evaluation framework, based on Total Variation Distance, captures how accurately models represent the full spectrum of human response variation. This is an approach advocated for by researchers in both simulation and general LLM evaluation studies . For broader context on this emerging field, we refer readers to recent comprehensive surveys .
+
+
+Appendix~\ref{AdditionalRelatedWork} continues our discussion of related work.