Reasoning2026~135 minarXiv:2603.17024

HopChain: Multi-Hop Data Synthesis for Generalizable Vision-Language Reasoning

score 9Shenzhi Wang, Shixuan Liu, Jing Zhou +8Qwen↑ 109Mar 17, 2026cs.CV

🎯 Pitch

VLMs trained with standard RLVR data actually get worse at reasoning on long problems—but adding synthetic multi-hop questions that force the model to re-ground visual evidence at every step boosts accuracy by over 50 points in ultra-long chain-of-thought settings, lifting performance on 20 of 24 benchmarks without any task-specific tuning.

1. Executive Summary

This paper introduces HopChain, a scalable framework for synthesizing multi-hop vision-language reasoning data specifically designed for reinforcement learning with verifiable rewards (RLVR) training of vision-language models. The core idea is to construct queries whose hops form logically dependent chains—earlier hops establish the instances, sets, or conditions needed for later hops—forcing repeated visual re-grounding throughout training while terminating in verifiable numerical answers. Training Qwen3.5-35B-A3B and Qwen3.5-397B-A17B on a mixture of original RLVR data plus HopChain-synthesized multi-hop data improves 20 out of 24 benchmarks across both model scales, despite the synthesized data being benchmark-agnostic rather than tailored to any specific downstream evaluation, with gains exceeding 50 accuracy points in the ultra-long chain-of-thought regime and a full multi-hop formulation outperforming truncated half-multi-hop and single-hop variants (average score of 70.4 vs. 66.7 and 64.3 on five representative benchmarks). The results hold across STEM, general VQA, text recognition, and video understanding domains, establishing that multi-hop vision-language reasoning data acts as a composable RLVR training signal that yields broad and generalizable gains rather than narrow task-specific improvements—though the pipeline currently depends on successful instance segmentation, limiting applicability to images with detectable, segmentable objects.

2. Context and Motivation

The Core Problem: VLMs Break Down During Long Chain-of-Thought Reasoning

The paper addresses a specific, empirically grounded failure mode in vision-language models (VLMs): when VLMs engage in long chain-of-thought reasoning, they exhibit diverse and compounding errors that cascade through the reasoning chain and produce incorrect final answers. This is not a hypothetical concern—the paper provides quantitative evidence and qualitative examples demonstrating that these failures are widespread and multi-faceted.

Section 3 presents a detailed failure analysis conducted on Qwen3.5-397B-A17B after standard RLVR training (the "RLVR w/o Multi-Hop" setting in the paper's experiments). By sampling incorrect responses and having human annotators classify the primary failure type, the authors identify a distribution of error categories visualized in Figure 2(a): perception errors (miscounting objects, misreading text, misjudging spatial relationships), reasoning errors (logical flaws in the reasoning chain, incorrect mathematical operations, causal misinterpretations), knowledge errors (relying on incomplete or incorrect factual knowledge), hallucination errors (generating plausible but unsupported intermediate content), and other miscellaneous failures. Perception errors form the largest category, but reasoning, knowledge, and hallucination errors are all present—the failure landscape is genuinely diverse rather than dominated by a single weakness.

The qualitative examples in Figure 3 make this concrete and alarming. In one case, a model tasked with counting ladybird dots misidentifies 3 dots as 4 on one ladybird, 5 as 6 on another, and 6 as 7 on a third, carrying these perceptual mistakes through to a final incorrect sum. In another, a model asked to identify which season "C" represents in an astronomy diagram correctly perceives that there are high, middle, and low arcs, but misreads which arc the arrow actually points to, labeling the middle arc instead of the highest one—a pure perception failure unrelated to astronomical knowledge. A zebra-stripe question exposes a reasoning error: the model correctly identifies that some stripes are horizontal but incorrectly concludes the percentage must be 0 because "vertical is dominant," failing to perform the appropriate proportional reasoning. A parking-sequence question shows the model correctly perceiving vehicle positions but logically inverting the direction of motion, interpreting a car pulling into a space as pulling out of it. These errors span natural images, charts, scientific diagrams, and real-world scenes, but they share a critical structural property: one faulty intermediate step appears in the middle of a long reasoning chain, and the later steps inherit and compound that mistake.

This is the central insight of Section 3: long-CoT errors are coupled rather than isolated. A mistaken visual judgment at step 3 can trigger faulty reasoning at step 4, which produces unsupported inferences at step 5, yielding a final answer that is wrong in a way that no single-step error label fully captures. The paper explicitly states:

"long-CoT errors are often coupled rather than isolated: a mistaken visual judgment can trigger faulty reasoning, unsupported inference, or other downstream failures"

This coupling makes the problem harder than it might first appear. Training data that exposes the model to individual perception challenges or individual reasoning challenges in isolation may not teach it to maintain reliable visual grounding across extended chains where one bad intermediate output poisons everything downstream.

Why This Problem Matters

The practical significance of these failures extends well beyond benchmark accuracy numbers. VLMs are increasingly deployed in settings where multi-step visual reasoning is essential: medical image analysis requiring sequential inspection of regions of interest, autonomous driving where perception errors cascade into unsafe decisions, document understanding where misreading one field propagates through a form's logic, and scientific figure interpretation where precise measurement at each step is non-negotiable. The paper's framing matters here because it identifies the failure as structural—it's not that VLMs lack knowledge or general reasoning ability, but that they cannot reliably sustain visual grounding when the reasoning chain grows long. This is a qualitatively different problem from "the model doesn't know the answer," and it requires a qualitatively different training solution.

The theoretical significance is equally important. The paper connects its findings to a growing body of evidence that multimodal reasoning is often bottlenecked by perception quality rather than higher-level reasoning capacity. The authors cite recent work suggesting that "multimodal reasoning is often bottlenecked by perception quality and can benefit from stronger intermediate perception, repeated image-grounded observation, or iterative revisiting of visual regions" (Bigverdi et al., 2025; Ye et al., 2025; Jiang et al., 2025). This is a non-obvious claim—the default assumption in the field has been that scaling up models and training data primarily improves reasoning ability, with perception being a largely solved sub-problem for state-of-the-art VLMs. The paper's error analysis challenges this by showing that even on benchmarks where aggregate accuracy is relatively high, the model's intermediate perceptual judgments remain fragile and can fail catastrophically when chained together.

Furthermore, recent diagnostic work has identified related but distinct phenomena: amplified multimodal hallucination, where "longer reasoning traces can drift away from image-grounded evidence, reduce attention to visual inputs, and amplify hallucinated intermediate content" (Liu et al., 2025; Luo et al., 2025); evidential drift in video reasoning where models gradually substitute language-based inferences for image-based ones; and persistent object hallucination even in strong VLMs (Rohrbach et al., 2018; Guan et al., 2024; Leng et al., 2024). The common thread is that longer reasoning traces are not simply longer versions of short traces—they introduce qualitatively new failure modes related to attention decay, grounding drift, and error propagation that are largely invisible when evaluating single-step or short-chain QA.

Where Existing Approaches Fall Short

The paper's core contention—stated explicitly at two levels of the argument—is that existing vision-language RLVR training data does not address this problem, and simply expanding that data would not fix it.

The structural inadequacy of existing data. Figure 1(b) of the paper illustrates the contrast: typical vision-language training data for RLVR consists of questions that, while perhaps difficult, do not involve particularly complex reasoning chains that depend on visual evidence throughout the process. The paper argues that as a result, "these long-CoT weaknesses remain largely unexposed during training." This is a claim about exposure, not about data quality or quantity. A training question like "What is the area of the shaded region in this geometry figure?" may require multiple reasoning steps, but it typically follows a linear solution strategy where each step's correctness can be verified without re-examining the image at every intermediate point. The model can rely on its initial perceptual encoding and then manipulate the extracted information in text space for most of the chain. This means that the specific failure mode identified in Section 3—losing visual grounding mid-chain—is never practice material during training.

The paper explicitly connects this to the RLVR training paradigm. In standard RLVR, the model receives a binary reward based on whether its final answer matches the ground truth. If the training data consists of questions where intermediate visual grounding is optional (because the initial perceptual encoding is sufficient), the model learns that it can succeed by frontloading perception and then reasoning textually. This is not "wrong" per se—it works on the training distribution—but it creates a brittle model that fails when faced with queries that genuinely require visual re-examination at multiple points, which is exactly what the synthesized multi-hop data is designed to enforce.

The insufficiency of on-policy RL alone. A natural counterargument might be: why not just use RLVR on the challenging downstream benchmarks themselves? The model would then receive reward signals that directly penalize these cascading errors. The paper's implicit answer is that this (a) ties training to specific benchmark distributions, limiting generalization, and (b) fails to provide the density of training signal needed. Each benchmark question provides at most one binary reward (correct or incorrect), but the failures documented in Section 3 occur at intermediate steps. Without dense per-step supervision, the model only receives a sparse signal that the final answer was wrong, with no gradient as to which intermediate perception or reasoning step failed. The multi-hop data addresses this by making the chain structure explicit: because the hops are logically dependent, getting the final answer correct usually requires getting each intermediate step correct, providing a more informative training signal even with a binary final-answer reward.

Why scaling existing data doesn't help. The paper states this directly in Section 1:

"relying on, or simply expanding, existing vision-language RLVR training data is insufficient; what is needed is training data that structurally forces the model to seek visual evidence at each step of long-CoT reasoning"

This is the key architectural claim. It's not about having enough data—it's about having data with the right structure. A larger corpus of questions that don't require repeated visual re-grounding will simply reinforce the model's existing strategy of frontloading perception and reasoning textually. The paper argues that what's required is data where the only way to succeed is to continuously re-examine the image and use the result of one grounded step to determine the next. This is what the paper means by "structurally forced" visual evidence seeking—it's not suggested by the prompt or desirable in principle, it's mathematically necessary for getting the correct answer.

Prior Work That the Paper Builds On and Departs From

The paper positions itself relative to several distinct lines of prior work.

RLVR for reasoning models. The reinforcement learning with verifiable rewards paradigm has been powerfully demonstrated for text-only reasoning in models like DeepSeek-R1 (DeepSeek-AI, 2025), which showed that pure RL on verifiable math and code problems can induce strong chain-of-thought reasoning in large language models. This has motivated parallel extensions to VLMs, including VLM-R1 (Shen et al., 2025) and TikArt (Ding et al., 2026), which apply similar RLVR recipes to multimodal settings. The optimization toolkit has also evolved: GRPO (Shao et al., 2024) and GSPO (Zheng et al., 2025) use group-based advantage estimation with hard clipping, while SAPO (Gao et al., 2025)—used in this paper—replaces hard clipping with a temperature-controlled soft gate for improved stability. The paper's contribution builds on this algorithmic foundation but focuses on a different axis: the data used for RLVR training, not the RL algorithm itself. The authors are explicit that their multi-hop data is complementary to these algorithmic advances, and that the observed gains come from structural properties of the training queries rather than from a better optimizer.

Visual reasoning and multi-hop QA. Compositional visual reasoning has been studied through synthetic diagnostic datasets like CLEVR (Johnson et al., 2017), which provided perfectly controlled queries about rendered scenes to benchmark specific reasoning capabilities, and real-image benchmarks like GQA (Hudson and Manning, 2019), which used scene graph annotations to generate compositional questions on natural images. In the language domain, multi-hop question answering has been formalized by benchmarks like HotpotQA (Yang et al., 2018), which requires chaining evidence across multiple text passages. The paper's multi-hop vision-language reasoning formulation draws on these traditions but differs in three important ways that the authors explicitly enumerate. First, it formalizes two complementary hop types—perception-level hops (switching between single-object and multi-object perception tasks) and instance-chain hops (A → B → C dependency chains where the next instance can only be identified from previously established instances) rather than treating multi-hop as a single-axis chain. Second, it uses multi-hop reasoning as a proxy task to improve general VLM capabilities rather than as an end goal—the synthesized data is not designed to be evaluated on its own, but to strengthen the model's underlying ability to maintain visual grounding during long reasoning chains. Third, the data is synthesized on real images at scale, bridging the gap between synthetic diagnostics (which offer perfect control but limited realism) and manually curated benchmarks (which offer realism but limited scale and task-specific focus).

Data synthesis for model training. The use of strong models to generate training data for weaker ones has become a central scaling strategy, starting with Self-Instruct (Wang et al., 2023) and Alpaca (Taori et al., 2023) for LLM instruction data, and extending to multimodal settings with ShareGPT4V (Chen et al., 2023) for vision-language captions. Representative multimodal pipelines combine a VLM for object identification with foundation models like SAM/SAM2 (Kirillov et al., 2023; Ravi et al., 2024) for instance segmentation, and may use open-set detection approaches such as Grounding DINO (Liu et al., 2023c) to construct structured queries from raw images. The paper's synthesis pipeline follows this general template but the purpose is fundamentally different. Prior data synthesis efforts aim to approximate the target task distribution—generating captions that look like captions the model will need to produce, or instruction-following examples that mirror deployment queries. HopChain generates a benchmark-agnostic proxy task designed to force repeated visual grounding, with the explicit goal of producing generalizable improvements rather than task-specific ones. This distinction is crucial for understanding the paper's claims: the multi-hop data is not supposed to resemble the evaluation benchmarks, and its value comes precisely from being structurally different from them while exercising a capability (chained visual grounding) that transfers across domains.

Analysis of RL's effects on VLMs. Recent mechanistic studies have begun to characterize what RL actually changes inside vision-language models, and their findings inform the paper's motivation. In LLMs, RL improvements appear concentrated on a minority of high-entropy tokens rather than uniformly strengthening all outputs (Wang et al., 2025). In VLMs, related analyses suggest that "RL appears to primarily refine vision-to-reasoning alignment in mid-to-late layers rather than uniformly strengthening visual perception," and that "RL-finetuned models can still exhibit weak visual grounding and over-reliance on textual cues" (Li et al., 2026; Zhao et al., 2026). These findings are consistent with the paper's error analysis: if RLVR on existing data primarily improves high-level reasoning alignment without substantially strengthening intermediate visual grounding, then the model will remain vulnerable to the cascading perception failures documented in Section 3. The paper's multi-hop data can be understood as a training signal specifically designed to address this gap—by forcing the model to re-ground at each hop, it provides gradient where standard RLVR data does not.

How This Paper Positions Itself

The paper positions HopChain not as a new RL algorithm, not as a new model architecture, and not as a new benchmark, but as a data synthesis framework that generates a composable training signal for generalizable vision-language reasoning. The key word is "composable": the multi-hop data is intended to be mixed with existing RLVR data (the paper uses a mixture of original RLVR data plus multi-hop data, not multi-hop data alone), and the resulting model should improve broadly rather than overfitting to the synthetic distribution.

The contrast with prior work is drawn along several axes simultaneously. Against purely synthetic diagnostic approaches (CLEVR-style), the paper offers real-image synthesis at scale with human-verified ground truth. Against benchmark-specific fine-tuning, it offers benchmark-agnostic training that transfers across four major benchmark families including video understanding, which the multi-hop data was never designed for. Against scaling existing RLVR data, it offers a qualitatively different training signal—one that structurally enforces the behavior (repeated visual re-grounding) that the error analysis shows is lacking. Against architectural solutions (perception tokens, iterative region revisiting), it offers a data-centric approach that can be combined with any VLM architecture and RLVR algorithm.

The paper's ambition, as stated in the introduction, is to address the fundamental question raised by the failure analysis: "what prevents current VLMs from performing robust vision-language reasoning?" It answers that question with a diagnosis (diverse compounding failures during long-CoT reasoning, unexposed by existing training data) and a prescription (synthesized multi-hop data that forces the model to practice exactly the capability that fails). The rest of the paper is then devoted to instantiating this prescription through the HopChain pipeline and validating it extensively across model scales and benchmark families.

3. Technical Approach

3.1 Reader Orientation

This paper presents a data synthesis pipeline—a multi-stage system that takes raw images as input and produces training examples (image + multi-hop question + verifiable numerical answer) that structurally force VLMs to re-examine visual evidence at every reasoning step during RLVR training. The pipeline solves the problem identified in Section 3: standard vision-language RLVR data doesn't expose models to the kind of cascading perceptual errors that occur during long chain-of-thought reasoning, because existing questions can typically be answered by frontloading perception once and then manipulating extracted information in text space. The "shape" of the solution is a template-driven synthesis workflow that combines strong pretrained models (for category identification, instance segmentation, and query generation) with human verification (for ground-truth validation and difficulty filtering), producing queries where each successive hop depends on correctly grounding the visual evidence established by previous hops.

3.2 Big-Picture Architecture (Diagram in Words)

The HopChain pipeline has four major stages, each producing intermediate artifacts that feed into the next:

Category Identification (Stage 1): Takes a raw image → outputs a list of semantic categories present in the image (e.g., "car," "person," "sign") without localization. Uses Qwen3-VL-235B-A22B-Thinking.
Instance Segmentation (Stage 2): Takes the image + the list of semantic categories → outputs segmentation masks and bounding boxes for individual instances of those categories. Uses SAM3.
Multi-Hop Query Generation (Stage 3): Takes the image + cropped patches of 3–6 selected instances → outputs candidate multi-hop queries with chained reasoning hops, instance dependency chains, and a specific numerical answer. Uses Qwen3-VL-235B-A22B-Thinking with a detailed prompt.
Ground-Truth Annotation and Difficulty Calibration (Stage 4): Takes candidate queries → outputs validated queries with verified ground-truth answers and appropriate difficulty for training. Uses human annotators (for answer verification) and a weaker model (for difficulty filtering).

An auxiliary Image Filtering step precedes the pipeline, screening raw images to retain only those with sufficient perceptual complexity and annotation-practicality for multi-hop query construction. This filtering is described in Section 5.1 and Appendix B.

Information flows linearly: raw images → filtered images → semantic categories → localized instances → candidate queries → verified training data. The output of the full pipeline is a dataset of approximately 6k–8k multi-hop queries per model scale, each consisting of (image, multi-hop question text, final numerical answer), ready for consumption by the SAPO RLVR training loop described in Section 2.2.

3.3 Roadmap for the Deep Dive

First, the formal definition of multi-hop vision-language reasoning (Section 4.1), because this definition specifies what the pipeline must produce—the structural constraints on queries that ultimately distinguish HopChain data from standard RLVR data. Understanding the definition first clarifies every subsequent design choice.
Second, the image filtering procedure (Section 5.1 / Appendix B), since it gates which images enter the pipeline and embodies assumptions about what makes an image suitable for multi-hop reasoning data.
Third, Stage 1 (Category Identification) and Stage 2 (Instance Segmentation), because these two stages together convert a raw image into a set of spatially localized instances that form the "vocabulary" from which multi-hop queries are built.
Fourth, Stage 3 (Multi-Hop Query Generation), which is the core synthesis step—this is where the structural definition from Section 4.1 is operationalized into concrete training queries through a detailed prompting strategy and a set of synthesis constraints.
Fifth, Stage 4 (Ground-Truth Annotation and Difficulty Calibration), which filters out low-quality queries and provides reliable numerical answers for RLVR.
Sixth, an account of the key design choices and their justifications, explaining why this particular pipeline architecture was chosen over alternatives.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a data synthesis paper whose core idea is that training VLMs on queries where later reasoning steps logically depend on visual evidence established by earlier steps—and where this dependency is enforced structurally rather than by suggestion—yields broadly generalizable improvements in vision-language reasoning.

The Formal Definition of Multi-Hop Vision-Language Reasoning

Before building any pipeline, the paper specifies exactly what constitutes a valid multi-hop query. This definition (Section 4.1) serves as the design specification that all later synthesis stages must satisfy, and it is more precise than the intuitive notion of "questions with multiple steps."

Three reasoning levels. The paper defines a hierarchy of three reasoning levels that describe what an individual reasoning step asks the model to do:

Level 1: Single-object perception. The model must extract information from exactly one object—reading text on it, identifying its color, shape, size, position, or category. Example: "Read the speed limit number on the traffic sign in the top-right corner."
Level 2: Multi-object perception. The model must reason about relationships between multiple objects—spatial relationships (e.g., which object is between two others), comparative relationships (e.g., which object is larger), counting objects that satisfy a condition, or determining spatial arrangement. Example: "Among the red car, yellow bicycle, and person in a blue shirt, find which one's center is closest to the traffic sign."
Level 3: Multi-hop reasoning. The model must chain multiple Level 1 and Level 2 steps into a single query, where the steps are not independent and cannot be parallelized. Example: "Read the speed limit on the sign. Use the vehicle closest to that sign's center. Check whether that vehicle is closer to the person or the tree. Based on the answer, count objects either on the line between the person and tree or to the left of the tree. Multiply the speed limit by this count."

The paper is explicit that every HopChain query must be Level 3. This rules out questions that are simply difficult single-step perception tasks or tasks that chain independent sub-questions without logical dependency.

Two hop types within Level 3. Within a Level 3 query, the paper defines two complementary ways that consecutive hops can be linked, and requires every query to use both:

Perception-level hop: The next step changes the kind of perception being performed—for example, switching from a Level 1 single-object judgment (reading text on object A) to a Level 2 relational judgment (finding objects to the right of object A), or vice versa—while remaining grounded in the instances, sets, or conditions established by earlier hops. The key phrase is "while remaining grounded": the transition in perception type must operate on objects that were identified or constrained by previous hops, not on arbitrary new objects. A perception-level hop enforces that the model cannot simply stay in "single-object mode" or "relationship mode" for the entire chain; it must continuously switch mental frames while keeping track of which objects are currently relevant.
Instance-chain hop: The next step moves to a new instance along an explicit dependency chain, where the next instance can only be identified from the instances, sets, or conditions established by earlier hops. The paper's notation is "instance A → B → C," meaning that instance B can only be located by using information or relationships involving instance A, and instance C can only be located using information or relationships involving instance B. The paper provides concrete examples: "Start from the red shirt → find the chair that THIS shirt is draped over → find the table that THIS chair is placed next to → count objects on THIS table." In this chain, the chair cannot be identified without first locating the shirt and understanding the draping relationship, and the table cannot be identified without first locating the chair and understanding the adjacency relationship. The paper contrasts this with a "bad" example: "Find the largest car, then find the tallest tree"—here, the tree doesn't depend on the car at all, making it two independent tasks rather than a true dependency chain.

By requiring both hop types, the definition ensures that queries exercise both axes of reasoning: the model must handle transitions between perception modes and follow instance dependency chains, and these two dimensions must be intertwined. The paper states: "We further prefer instance dependency chains and perception-level transitions to be intertwined as tightly as possible."

Three structural conditions. Every valid query must satisfy three conditions that together rule out queries that are pseudo-multi-hop (where steps are loosely connected or bypassable):

(i) It must be Level 3. This is the requirement that the query chains multiple perception steps rather than being a single-step question.

(ii) It must combine both hop types. A query that only uses instance-chain hops (A→B→C but with the same perception level at each step) or only uses perception-level hops (switching between Level 1 and Level 2 but always on the same object) is invalid.

(iii) Its hops must form a logically dependent chain in which earlier hops establish the instances, sets, or conditions needed for later hops. This is the most important condition and the hardest to satisfy. It means that no hop is skippable—the result of step N is a necessary input to step N+1, and without it, step N+1 cannot be executed correctly. The paper uses this condition to distinguish genuine multi-hop queries from questions where subtasks happen to be concatenated but could be solved independently or in parallel. The operational test: if you can answer step N+1 without knowing the answer to step N, the chain is not logically dependent.

The paper explicitly states what this rules out: "pseudo-multi-hop queries in which substeps are loosely connected or can be bypassed with shallow shortcuts."

The numerical answer requirement. Because the synthesized data is intended for RLVR (which requires programmatically verifiable answers), each query must "terminate in a specific, unambiguous numerical answer." This constraint has a subtle but important interaction with the logical dependency condition: because the hops are dependent and the final answer is a precise number, obtaining the correct final number "usually also requires the intermediate reasoning chain to be correct." This is the property that makes the multi-hop data work as an RLVR training signal despite using only a binary final-answer reward—errors at intermediate steps typically propagate to the final number, so the sparse binary reward at the end provides a signal about the entire chain's correctness.

Why this definition matters beyond taxonomy. The definition is not merely classificatory; it encodes the paper's hypothesis about what kind of training data improves long-CoT reasoning. The structural properties—logical dependency, perception-level switching, instance chaining—are exactly the properties that force the model to repeatedly seek and verify visual evidence throughout a reasoning chain. If the data lacked logical dependency, the model could succeed by frontloading perception and then reasoning in language space. If it lacked perception-level switching, it would not exercise the transition between different kinds of visual processing. If it lacked instance chaining, it would not require the model to use the output of one grounded step to locate the visual target for the next. The definition is designed to be sufficient for the training signal the paper wants to create—queries satisfying these conditions necessarily require the behavior (repeated visual re-grounding) that Section 3 showed is absent from standard RLVR training.

Image Filtering: Selecting Suitable Raw Images for Synthesis

Before any multi-hop query can be synthesized, the pipeline must first select which raw images are suitable candidates. Not every image supports the construction of queries with instance dependency chains and perception-level hops—an image containing only a single object, or an image where objects are so densely packed that individual instances cannot be meaningfully segmented or annotated, would produce poor training data. The paper describes an image filtering procedure in Section 5.1 and provides the full filtering prompt in Appendix B.

Filtering criteria. The filtering is designed to retain images that are "genuinely useful for long vision-language reasoning." The selection prompt (Appendix B) instructs a VLM to evaluate each image along several axes:

Perceptual complexity factors that make an image challenging for standard vision models: occlusion (objects partially hidden by other objects), dense but analyzable object counts (many distinct objects, especially of the same category, making counting and individual identification difficult), unusual poses or angles (objects shown from unconventional viewpoints), complex interactions (objects interacting in ways that blur their individual boundaries, such as tangled wires or people hugging), fine-grained recognition requirements (distinguishing between visually similar sub-categories), and challenging lighting or shadows that obscure object shapes and details.
Quality filtering that excludes two types of unsuitable images: (a) images with technical flaws (blurry, noisy, severely over/underexposed) that would make object perception unreliable regardless of model capability, and (b) images where meaningful annotation is impractical even if the image is technically clear—for example, "a massive but clear crowd where individuals cannot be boxed or counted" or a dense shelf packed with countless small items. The paper classifies both types as "Low Quality" and explicitly states that such images should receive low perceptual complexity scores (1–3), because they are not useful test cases for perception but rather issues of data usability.

The filtering prompt requires the VLM to output a structured JSON with an overall complexity score (integer 1–10), an overall quality rating ("High," "Medium," or "Low"), a textual analysis explaining the score, and a list of specific complex objects with reasons for their complexity (e.g., "Occlusion," "Fine-grained Recognition").

Two-stage filtering pipeline for scalability. Because evaluating every candidate image with the large Qwen3-VL-235B-A22B-Thinking model would be computationally expensive, the paper uses a two-stage pipeline that amortizes cost through distillation:

Initial filtering: Apply Qwen3-VL-235B-A22B-Thinking with the image-selection prompt to a small subset of images. Accept the images that pass this filter as the "initial set of selected images."
Distillation and scaling: Use this initial set of selected images together with the large model's outputs to perform supervised fine-tuning (SFT) on a smaller model, Qwen3-VL-30B-A3B-Thinking, specialized for image filtering. Run this smaller, faster model over all remaining images to obtain a coarse screening result—a preliminary pass/fail decision for each image.
Second-pass verification: Send the images retained by the coarse screening back to Qwen3-VL-235B-A22B-Thinking for a second, finer filtering pass. This yields a "second set of selected images."
Union: The union of the initial set and the second set forms the final pool of images used for multi-hop data construction.

This two-stage design balances quality and throughput. The smaller model handles the bulk of the screening at lower computational cost, while the large model provides both the high-quality training signal for the small model and the final verification pass to catch edge cases. The paper does not report the specific reduction ratio (what fraction of raw images survive filtering), but the final output of the pipeline—approximately 6k–8k multi-hop queries per model scale—suggests that the filtering is selective enough to yield a manageable volume of queries with the desired properties.

Stage 1: Category Identification

Once an image passes the filtering step, the first synthesis stage identifies what types of objects are present in the image. This stage is deliberately high-level and non-localized—it answers "what categories of things exist in this image?" rather than "where exactly is each instance of each category?"

Input: A raw image from the filtered pool.

Process: The image is fed to Qwen3-VL-235B-A22B-Thinking, which is prompted to enumerate semantic categories present in the image. The paper describes this as identifying categories "e.g., 'car,' 'person,' 'sign'" without localization.

Output: A list of semantic category names—string labels for types of objects that appear in the image.

Why this stage exists: Category identification serves as a "vocabulary discovery" step. The subsequent instance segmentation stage (Stage 2) needs to know which categories to look for, because segmentation models typically operate on a per-category basis (or benefit from category guidance). Without Stage 1, the pipeline would need to either (a) segment all possible objects in the image, which is computationally wasteful and would produce many irrelevant instances, or (b) hardcode a fixed set of categories, which would limit the diversity of synthesized queries. Stage 1 lets the pipeline adapt to the specific content of each image, identifying the semantic entities that are present and therefore available for constructing interesting multi-hop chains.

The choice of Qwen3-VL-235B-A22B-Thinking for this stage is motivated by its strong vision-language capabilities—the model can identify fine-grained categories (e.g., "ladybird," "traffic cone," "dress strap") that a standard object detector trained on a fixed vocabulary might miss. This is important because the multi-hop queries need to reference objects by their function, context, or appearance, which often requires more specific category labels than generic detector classes (e.g., "traffic sign" vs. a COCO-class "stop sign").

Stage 2: Instance Segmentation

With the semantic categories identified, the pipeline now localizes individual instances of those categories. This stage converts abstract category labels into concrete, spatially grounded objects with known positions and boundaries—a prerequisite for constructing queries where the model must identify specific instances by their spatial attributes.

Input: The image + the list of semantic categories from Stage 1.

Process: For each identified semantic category, SAM3 is used to generate segmentation masks and bounding boxes for candidate instances of that category "where possible." The phrase "where possible" acknowledges that not every category in the list will necessarily yield detectable instances—some categories might be present only implicitly, or the segmentation model might fail to detect them.

Output: A set of individual instances, each with (a) an associated semantic category label, (b) a segmentation mask that delineates the exact pixels belonging to the instance, and (c) a bounding box that provides the spatial extent of the instance in the image coordinate system (normalized to a 0–1000 range, as evident from the query generation prompt in Appendix A, which mentions "coordinates in 0-1000 range").

Why SAM3: SAM3 (Carion et al., 2025) is the third generation of the Segment Anything family, which provides general-purpose instance segmentation without requiring category-specific training. The paper uses SAM3 rather than a traditional object detector (like Grounding DINO, which is mentioned in related work) because SAM3's category-agnostic segmentation capability aligns with the pipeline's design: Stage 1 already provides the semantic categories, and Stage 2 only needs to localize instances of those pre-identified categories. A detector would redundantly classify instances and might miss instances of categories outside its training vocabulary. SAM3's architecture—which accepts category or concept prompts—allows the pipeline to pass the Stage 1 categories directly as segmentation prompts, creating a clean separation of concerns: Stage 1 handles semantic understanding, Stage 2 handles spatial localization.

The role of spatial localization in downstream hops. The bounding boxes and masks produced in this stage are critical for Stage 3 (query generation), but they are never shown to the model during training or evaluation. The paper explicitly states this as a synthesis constraint: the generated queries must "avoid any reference to segmentation masks, bounding boxes, or patch images"—the model solving the query sees only the original image. The spatial information from Stage 2 is used at design time by the query-generating VLM (Qwen3-VL-235B-A22B-Thinking) to understand which instances exist and where they are located, so that it can construct queries where instances are referenced by natural spatial descriptions (e.g., "the object in the top-right corner," "the item closest to the left edge") rather than by coordinates. This is a crucial design choice: the pipeline leverages precise spatial metadata internally to ensure unambiguous instance references, but the final training queries use only natural-language spatial descriptions that a VLM must understand from the image itself, preserving the visual grounding challenge.

Stage 3: Multi-Hop Query Generation

This is the central synthesis step where the pipeline's structural definition (Section 4.1) is operationalized into concrete training queries. Given a set of localized instances from Stage 2, the system must generate questions that satisfy all the multi-hop constraints—Level 3, both hop types, logical dependency, unambiguous instance references, and numerical final answers—while avoiding shortcuts that would let the model bypass visual grounding.

Input to the query generator:

The original image (Image 1 in the prompt terminology).
Cropped patches of each instance from the selected combination (typically 3–6 instances), where each patch is extracted using the bounding box from Stage 2. These patches are described as "only for your reference during question design and will NOT be available when answering queries."

Instance combination selection. Before calling the query generator, the pipeline forms "combinations of 3–6 instances" from the full set of segmented instances produced by Stage 2. The paper does not detail the combination selection algorithm, but the constraint that each query should "involve AS MANY instances as possible from the combination" implies that combinations are chosen to maximize the number of usable instances while maintaining answerability. The combination size (3–6) is set by the query generation prompt: the prompt is parameterized with {num_queries} (typically 1–5 queries per combination) and {target_hop_count_info} (the target number of hops), and the requirement to involve all instances in the combination means that a 6-instance combination naturally produces queries with at least 5–6 hops.

The synthesis prompt (Appendix A). The query generation prompt is a 26-page specification that operationalizes the paper's multi-hop definition into concrete instructions for the VLM. Rather than paraphrasing the full prompt, this section extracts the key mechanisms it establishes for ensuring query quality:

Unambiguous instance references. The prompt contains an extended section titled "[WARNING] CRITICAL: UNAMBIGUOUS INSTANCE REFERENCES (MOST IMPORTANT)" that requires each instance reference to uniquely identify exactly one object in the original image without any detection borders. The test is: "Imagine the query is given to someone looking ONLY at Image 1 (no colored borders). Can they identify the EXACT instance you mean without any confusion?" The prompt provides examples of bad references ("the car" when multiple cars exist, "the person on the right" when multiple people are on the right) and good references ("the car closest to the bottom-left corner," "the person wearing a blue shirt standing next to the lamppost"), establishing that multiple discriminating features (spatial + visual + contextual) must be combined to ensure uniqueness.

Logical dependency enforcement. The prompt's "Core Principles" section requires that "the result of each hop must be REQUIRED for the next hop. No hop should be skippable." It explicitly rejects hops that are concatenated but independent: "the two counts are independent (can be done in parallel), not a true chain." The operational test is whether the query would remain solvable if a particular hop were removed—if yes, the hop is not truly dependent.

Instance chain formalism. The prompt requires the VLM to output, for each query, an explicit "instance_chain" field (e.g., "sign_1 → car_1 → person_1/tree_1 → car_1,bicycle_1 → final") and a "reasoning_hops" array where each hop specifies its from_instance, to_instance, hop_type (L1 or L2), and objects_involved. This structured output forces the VLM to make the dependency relationships explicit and verifiable, rather than burying them in free-form query text.

Perception-level hop requirements. Each hop must be tagged as either "Level 1 (Single-Object)" or "Level 2 (Multi-Object Relationship)," and the chain must include transitions between these levels. The prompt's example of a high-quality query shows hops alternating between L1 and L2: Hop 1 (L1, reading text on sign_1) → Hop 2 (L2, comparing distances between sign_1, car_1, bicycle_1) → Hop 3 (L2, comparing distances between car_1, person_1, tree_1) → Hop 4 (L2, counting objects on a line) → Hop 5 (L1+L2, counting wheels). The perception-level transitions are built into the instance chain rather than being separate requirements.

Deterministic solution enforcement. The prompt requires that "two different people with good vision looking at Image 1 should arrive at the EXACT SAME answer through the EXACT SAME reasoning steps." This is enforced through requirements like: every spatial relationship must have a clear, unambiguous definition ("to the left of" means the object's center is to the left), every comparison criterion must be objective ("larger" means larger area, not perceived importance), and every counting task must have clear inclusion/exclusion criteria. The prompt explicitly rejects ambiguous solutions: "'Count objects near the tree' - what distance counts as 'near'?"

Conditional logic with balanced outcomes. The prompt requires that when queries include conditional logic (if-then-else based on visual observations), the conditions must have balanced outcomes: "roughly half of the conditional checks should evaluate to 'Yes' and half to 'No'" across queries. This prevents the model from learning that conditional paths are always taken or always skipped, which would make the conditions meaningless as training signals. The prompt instantiates this with: "if an object is red, you might design a condition like 'if this object is blue, add 5; otherwise, add 2,' forcing the reasoning to follow the 'otherwise' path."

Capability coverage requirement. The prompt requires that the set of queries generated for an image, "as a whole," should cover five core capability dimensions: Color Comprehension, Spatial Reasoning, Counting & Aggregation, Text & Symbol Recognition, and Logical & Conditional Inference. This ensures that the synthetic data exercises diverse visual reasoning skills rather than repeatedly testing the same narrow capability.

Synthesis constraints beyond the prompt. In addition to the prompt-based instructions, the paper imposes several hard constraints that are enforced at the pipeline level rather than through prompting:

Each query must "involve as many instances as possible from the selected combination while remaining answerable from the original image alone." This is a volume constraint—if a combination has 6 instances, the query should use all 6, not just 2–3.
Objects must be described "only by spatial, contextual, or visual attributes"—no references to segmentation masks, bounding box coordinates, or patch images. This ensures that the model at training time sees the same information as at test time.
The final answer must be a "specific, unambiguous number." Non-numerical or ambiguous answers (e.g., "it depends on the perspective") are rejected.
The query must not contain "any specific text or numbers that the model would need to acquire from the image via visual recognition." This prevents the synthesis process from leaking answer information—if the query text contains "the sign says 30 mph," the model can bypass visual perception entirely.

Hop count target. The prompt is parameterized with {target_hop_count_info} to control the target number of hops per query. While the paper does not specify exact hop counts used in experiments, the prompt's repeated emphasis on "5 hops" in its examples and the requirement that queries involve all instances from the combination (3–6 instances) implies that typical queries contain approximately 5–6 hops, with each hop involving 1–3 instances.

Output format. For each generated query, the VLM outputs a structured JSON containing: a unique query ID, a primary capability label (e.g., "Spatial Reasoning + Counting + Conditional Logic"), the list of involved objects, the query text, an instance chain description, a reasoning hops array with per-hop details (hop number, hop type, from/to instances, description, objects involved, expected output), a hypothetical answer (the VLM's predicted correct answer), and a design rationale. The structured output enables downstream verification (Stage 4) to check whether the query satisfies the structural constraints before accepting it.

The "no patch/box references" constraint in detail. This constraint is sufficiently important that the prompt devotes an entire emphasized section to it. The reasoning is subtle: during query synthesis, the VLM sees cropped patches of each instance (to help it understand which object is which), but these patches include bounding box borders and are presented as separate images. If the VLM generates a query that says "the object marked with a red border" or "the instance shown in Patch 3," the resulting training example would be unsolvable from the original image alone—the model wouldn't see those patches at training or test time. Therefore, the VLM must use the patches only as design-time aids to understand instance identity, and must translate this understanding into natural-language spatial descriptions that reference only the content of the original image. This constraint is a form of information bottleneck: the pipeline has access to precise spatial metadata at design time, but deliberately withholds it from the training data, forcing queries to be answerable from visual perception alone.

Stage 4: Ground-Truth Annotation and Difficulty Calibration

After Stage 3 produces candidate queries, Stage 4 serves two complementary functions: filtering out low-quality queries and providing reliable numerical ground-truth answers for the retained ones, and removing queries that are too easy to provide useful RLVR training signals.

Ground-truth annotation procedure. For each candidate query produced by Stage 3, four human annotators from the paper's data annotation team independently solve the query. The paper states that during this process, annotators check for "ambiguous references or other quality issues"—these are not just answer mismatches but structural problems with the query itself, such as references that could point to multiple objects, spatial descriptions that don't uniquely identify a single instance, or conditions that have unclear evaluation criteria.

Queries where annotators report quality issues are discarded entirely. For queries that pass quality inspection, the paper requires that all four annotators agree on the final numerical answer. This is a stringent requirement—if even one annotator produces a different number, the query is rejected. The rationale is twofold: (a) the ground-truth answer must be correct for RLVR, since the model receives a binary reward based on answer matching, and (b) answer disagreement often indicates that the query has an ambiguity or difficulty that makes it unsuitable as a training example. The requirement of four-way agreement effectively serves as a human consensus verification that the query is deterministic: if four independent human solvers all reach the same number, the query is likely to have a unique, unambiguous solution.

The paper's sample synthesized queries (Figure 4) show the hop-by-hop ground-truth answers that annotators would verify—each hop has an expected intermediate answer (e.g., "The black sheep has 2 visible eyes. Answer: 2"), and the final hop produces the overall answer (e.g., "72"). The annotators must work through the entire chain and confirm both that each hop's answer follows from the previous hops and the image, and that the final number is correct.

Difficulty calibration. After ground-truth annotation, the pipeline evaluates the retained queries on a "weaker model" (the paper does not specify which model, but context suggests it is a pre-RLVR version of the target model or a smaller related model) with eight sampled responses per query. The verified ground-truth answers from the human annotators serve as the reference for correctness.

The calibration criterion is simple: queries on which the weaker model achieves 100% accuracy (all 8 out of 8 responses correct) are removed as "too easy." The remaining queries—those where the weaker model gets at least one response wrong—form the final dataset.

The rationale for difficulty calibration is grounded in RLVR training dynamics. If a query is trivially easy for the model being trained, it provides no useful gradient signal—the model already always gets it right, so the binary reward is always 1.0 and the advantage estimates in SAPO (Equation 3) are zero or near-zero for all tokens. This means that easy queries consume compute during RLVR training without contributing to learning. By removing queries that are too easy, the pipeline ensures that the training budget is spent on queries where the model's current performance is imperfect, providing non-zero advantages that drive policy improvement.

The choice of an 8-sample budget for difficulty evaluation (rather than, say, 1 sample or 100) balances statistical reliability with computational cost. Eight samples provide a reasonable estimate of whether the model's success rate is near 100% or below it, while keeping the difficulty calibration cost modest relative to the RLVR training cost. If the weaker model gets all 8 correct, the true pass rate is probably above ~80% (allowing for sampling noise), which is high enough to classify the query as easy.

Dataset size. After filtering through Stage 4, the pipeline yields "about 6k–8k multi-hop RLVR samples for each model" (Qwen3.5-35B-A3B and Qwen3.5-397B-A17B). The range (6k–8k) suggests that the final yield depends on the specific model's pre-RLVR capability—a stronger model would find more queries easy and thus more queries would be filtered out, producing a smaller dataset. The paper also notes that "a similar amount of math RLVR data" is used alongside the multi-hop data, indicating that the multi-hop data serves as a supplementary training signal rather than replacing the original RLVR data entirely.

RLVR Training Integration (How the Synthesized Data Is Used)

The multi-hop data produced by the pipeline is not used in isolation—it is mixed with the original RLVR training data (the "pre-final internal versions" of the Qwen3.5 SFT and RLVR data recipes) and fed into the SAPO training loop described in Section 2.2. This section describes how the synthesized data interfaces with the training infrastructure.

Data mixture. The paper states that RLVR training in the "RLVR w/ Multi-Hop" setting uses "a mixture of the original RLVR data and our synthesized multi-hop data." The mixing ratio is not specified, but the dataset sizes provide a clue: the synthesized data contributes approximately 6k–8k queries, while the total RLVR training involves rollouts of 16 responses per query for each of 256 queries per mini-batch, running for 1000 gradient steps (Qwen3.5-35B-A3B) or 800 gradient steps (Qwen3.5-397B-A17B). The 256-queries-per-mini-batch figure and the total gradient steps imply that the full RLVR dataset (original + multi-hop) is substantially larger than 8k queries, confirming that the multi-hop data is a supplement, not a replacement.

Training configuration. The paper specifies the following hyperparameters for both models:

RLVR algorithm: SAPO (Soft Adaptive Policy Optimization), as formalized in Equations 3–5 of Section 2.2.
Learning rate: $2.0 \times 10^{-6}$ for both models.
Other SAPO hyperparameters: "follow the original SAPO paper" (Gao et al., 2025), meaning the temperature parameters $\tau_{\text{pos}}$ and $\tau_{\text{neg}}$ are set to the defaults from that work.
For Qwen3.5-35B-A3B: "each rollout samples 16 responses for each of 256 queries, uses a mini-batch size of 64 queries, and runs for 1000 gradient steps."
For Qwen3.5-397B-A17B: "follows the same rollout configuration in general, except that the mini-batch size is increased to 128 queries and the total number of gradient steps is 800."

The 16 responses per query provide the group of responses $\{o_i\}_{i=1}^G$ with $G = 16$ used in the SAPO advantage estimation (Equation 3–4). The mini-batch size of 64 or 128 queries means that each gradient step processes 64 or 128 queries × 16 responses = 1024 or 2048 response sequences, respectively. The total number of gradient steps (1000 for the smaller model, 800 for the larger) determines the total amount of RLVR training.

How the verifiable reward works with multi-hop data. The reward function $R(o, a)$ (Equation 2) is the standard RLVR binary reward:

$R(o, a) = \begin{cases} 1.0 & \text{if } \text{is\_equivalent}(o, a) \\ 0.0 & \text{otherwise} \end{cases}$

where $o$ is the model's response and $a$ is the ground-truth numerical answer from the human-verified annotation (Stage 4). The is_equivalent function checks whether the model's final answer (extracted from the response) matches the ground-truth number. Because the multi-hop queries terminate in a specific, unambiguous number, this extraction and comparison are straightforward—unlike tasks with free-form text answers, numeric answers admit simple string matching or numeric comparison.

The crucial property of the multi-hop data for RLVR is that the binary reward, while only checking the final answer, provides an informative training signal for the entire reasoning chain. This works because of the logical dependency among hops: if the model makes a perceptual error at hop 2, that error propagates through hops 3, 4, and 5, resulting in a wrong final number. The binary reward of 0.0 then penalizes all tokens in the response (through the SAPO advantage-weighted objective), including the tokens associated with the erroneous hop 2 reasoning. The model thus receives gradient information about intermediate errors even though the reward only inspects the final answer. This is the key difference between multi-hop data and standard QA data: in a standard QA question, intermediate reasoning errors might not always manifest in the final answer (the model could reason incorrectly but coincidentally reach the right number), but in a logically dependent multi-hop chain, the coupling between hops makes it much more likely that intermediate errors propagate to the final output.

Design Choices and Their Justifications

Why SAM3 over a traditional object detector. The paper uses SAM3 for instance segmentation rather than a category-specific detector like Grounding DINO. This choice is motivated by the decoupled architecture of the pipeline: Stage 1 handles semantic category identification (using a VLM with open-vocabulary understanding), and Stage 2 only needs to localize instances of those pre-identified categories. SAM3's category-agnostic segmentation capability (it can segment objects given a semantic prompt or concept) aligns with this decoupling, whereas a detector would need to be trained on the specific categories of interest and might miss instances outside its training vocabulary. Additionally, SAM3 produces segmentation masks (not just bounding boxes), which provide more precise spatial information for the query generator to construct unambiguous spatial references.

Why a VLM synthesizes queries rather than template-based generation. The paper uses Qwen3-VL-235B-A22B-Thinking to generate query text from instance information rather than using programmatic templates (as in CLEVR-style synthetic data generation). This choice trades controllability for diversity and naturalness. Template-based generation (e.g., "How many [color] [objects] are [spatial relation] the [reference object]?") can guarantee structural properties but produces queries that are repetitive, limited in vocabulary, and potentially easy for models to exploit through pattern matching. The VLM-based approach generates queries in natural language with diverse phrasings, complex conditional structures, and realistic spatial descriptions that a model must genuinely understand rather than pattern-match. The cost is reduced controllability—hence the extensive prompt engineering (Appendix A) and the human verification stage (Stage 4) to enforce quality constraints after generation.

Why four annotators with exact agreement. The requirement that all four annotators independently produce the same numerical answer is unusually stringent (many dataset construction efforts use majority voting or accept answers within a tolerance). The paper justifies this through the RLVR compatibility requirement: the binary reward depends on exact answer matching, so any ambiguity in the ground truth would produce noisy rewards that degrade training. The four-way agreement serves as a strong filter for query determinism—if annotators disagree, the query likely has an ambiguity or complexity that makes it unsuitable for a training signal where correctness is binary.

Why difficulty calibration uses a weaker model rather than thresholding on the target model. The paper evaluates queries on a "weaker model" to determine which are too easy. Using the target model itself would create circularity: queries on which the target model already performs perfectly would be removed, but this would depend on the model's current state, which changes during training. A weaker model provides a static difficulty reference that doesn't co-evolve with the training process. Additionally, using a weaker model ensures that the retained queries are challenging for a range of capability levels, not just for the particular snapshot of the target model at calibration time.

Why 3–6 instances per combination. The combination size of 3–6 instances is set to balance three competing desiderata: (a) the number of hops should be large enough to create genuine multi-hop chains (too few instances → too few hops → the query collapses to 1–2 steps), (b) all instances in the combination should be involved in the query to maximize the training signal density (larger combinations risk having unused instances), and (c) the query should remain answerable from the original image alone (too many instances → spatial descriptions become unwieldy or ambiguous). The paper's synthesis prompt enforces that "each query MUST involve ALL instances from the provided combination list," so a 6-instance combination directly yields a query with at least 5–6 hops (one hop to establish the starting instance, plus hops for each transition and the final computation).

Why the final answer must be numerical. This is the strongest constraint on query design and the primary reason HopChain data works as an RLVR training signal. Numerical answers are exactly verifiable—the is_equivalent check in Equation 2 reduces to numeric comparison, which is deterministic, fast, and requires no learned reward model. Alternative answer types (free text, multiple choice among image regions, bounding box coordinates) would require more complex verification (learned reward models, IoU thresholds, semantic similarity metrics) that introduce noise and potential reward hacking surfaces. The numerical answer constraint also forces the query designer to construct chains where intermediate reasoning ultimately reduces to a computable number, which naturally requires explicit operations (addition, multiplication, comparison, counting) that make the logical dependency among hops explicit and testable.

Why using the original image alone (without patches) for query solving. The pipeline design carefully separates the information available at design time (image + cropped instance patches + bounding box coordinates) from the information available at training/test time (the original image only). This separation is fundamental: if the training queries contained patch references or coordinate information, the model would learn to solve them using that auxiliary information, defeating the purpose of training visual grounding. The constraint that the model sees only the original image ensures that the skill being practiced—identifying objects from natural spatial descriptions in a cluttered scene—transfers to real-world tasks and benchmarks, which also provide only the raw image. This is an instance of the broader principle in data synthesis: the generator may have more information than the consumer, and the synthesis process must translate that extra information into forms that the consumer can (and must) recover through perception.

4. Key Insights and Innovations

Innovation 1: Reframing Long-CoT Failure as a Structural Training Data Problem, Not a Model Capacity Problem

The paper's most intellectually distinctive move is its diagnosis of why VLMs fail at long chain-of-thought reasoning. Prior work had documented individual failure modes—object hallucination (Rohrbach et al., 2018), visual illusion (Guan et al., 2024), evidential drift (Luo et al., 2025)—and some had observed that these failures become more pronounced in longer reasoning traces (Liu et al., 2025). The dominant interpretation of these findings has been that models lack sufficient capacity, training data scale, or reasoning ability, implying that the solution path lies in larger models, more data, or better reasoning algorithms.

HopChain makes a fundamentally different claim: the failures are not primarily about model capacity but about what the training data structurally demands of the model. The paper argues that standard vision-language RLVR data—even when challenging in content—does not require the model to repeatedly re-ground in visual evidence throughout a reasoning chain. The model can succeed by frontloading perception once (encoding the image into a representation, extracting relevant features) and then manipulating those extracted features in language space for the remainder of the chain. This strategy works adequately on the training distribution but produces brittle models that fail when faced with queries where intermediate visual re-examination is genuinely necessary.

The distinction matters because it redirects solution efforts. If the problem were insufficient capacity, the answer would be scaling—bigger models, more pretraining data, more RLVR steps. If the problem is the structure of the training signal, the answer is to change what the model practices, not how much it practices. HopChain embodies this latter philosophy: rather than expanding existing training data or improving the RL algorithm, it constructs data with a qualitatively different structural property—logical dependency among hops that forces repeated visual grounding—and shows that this property alone yields broad, generalizable gains (20/24 benchmarks improve on both model scales; Tables 1 and 2) without architectural changes, additional pretraining, or benchmark-specific fine-tuning.

This reframing connects to a broader tension in the RLVR literature. DeepSeek-R1 (DeepSeek-AI, 2025) demonstrated that pure RL on verifiable math and code problems induces strong chain-of-thought reasoning in text-only LLMs—the content of the training data (math, code) was sufficient because the reasoning chains, while long, operated in a clean symbolic space where intermediate steps can be verified against mathematical rules without re-examining external inputs. VLMs face a different challenge: the "symbolic space" is a noisy, high-dimensional perceptual encoding that degrades as the reasoning chain lengthens. The paper's insight is that this degradation is not inevitable—it occurs because the model never practices maintaining grounding across long chains, and the fix is to build training data that structurally forbids the frontloading shortcut.

Evidence for this reframing comes from the ablation in Section 5.3 and Figure 5. When multi-hop queries are truncated to single-hop or half-multi-hop variants, performance degrades systematically (average score drops from 70.4 to 66.7 to 64.3 across five representative benchmarks). This shows that the benefit is not simply from having some multi-hop flavor in the training mix—it scales with the degree to which the training queries preserve long dependency chains. A capacity-scaling hypothesis would not predict such sensitivity to chain structure at fixed model size and fixed total training compute.

Innovation 2: Formalizing Multi-Hop Vision-Language Reasoning with Two Complementary Hop Types

While multi-hop reasoning has been studied extensively in both the vision (CLEVR, Johnson et al., 2017; GQA, Hudson and Manning, 2019) and language (HotpotQA, Yang et al., 2018) domains, the paper's formalization of two complementary hop types—perception-level hops and instance-chain hops—represents a conceptual advance over the standard treatment of multi-hop as a single-axis chain. Prior work typically defines multi-hop in terms of the number of reasoning steps or the number of information sources chained together, without distinguishing what kind of transition occurs between steps.

The paper's distinction captures something important about vision-language reasoning that a flat hop count misses. A perception-level hop (switching between single-object perception and multi-object relational reasoning) taxes the model's ability to change processing modes while maintaining state—from "extract attribute X from object A" to "use X to select among objects B, C, D based on a spatial relationship." This is a different cognitive demand from an instance-chain hop (A → B → C, where B can only be identified from A and C can only be identified from B), which taxes the model's ability to use the output of one grounded step to locate the target of the next. A query that chains three instance-hops with the same perception level (e.g., always doing single-object attribute extraction) might have a hop count of 3 but fail to exercise the perception-mode switching that real-world long-CoT reasoning requires. Conversely, a query that switches perception levels but always operates on the same object misses the instance-dependency tracking that is central to compositional visual reasoning.

By requiring every valid HopChain query to combine both hop types, the paper constructs a training signal that exercises both axes simultaneously. This is not merely a taxonomic exercise—the dual-hop formalization directly shapes the synthesis pipeline. The query generation prompt (Appendix A) requires the VLM to tag each hop as Level 1 or Level 2, to specify instance transitions explicitly (from_instance, to_instance), and to ensure that the chain includes both hop types intertwined "as tightly as possible." This structured specification enables the human verification stage (Stage 4) to check whether the synthesized queries actually satisfy the formal definition, rather than relying on post-hoc human judgment about query quality.

The significance of this formalization extends beyond the current paper. It provides a language for describing what makes a vision-language reasoning query structurally demanding—a language that future work can use to design benchmarks, analyze model failures, or construct training data with targeted properties. The paper's error-type analysis (Figures 2 and 8) shows that the multi-hop data improves a broad range of error categories (perception, reasoning, knowledge, hallucination) rather than only one, suggesting that the dual-hop formulation successfully creates training queries that exercise diverse failure modes rather than overfitting to a single one.

Innovation 3: Demonstrating That Benchmark-Agnostic Synthetic Data Yields Broadly Generalizable Gains Across Domains

A common failure mode of synthetic training data is distributional overfitting—the model improves on the synthetic task but the gains fail to transfer to real benchmarks, or transfer only to benchmarks that closely resemble the synthetic distribution. The standard response is to make the synthetic data as similar as possible to the target task distribution (e.g., ShareGPT4V generating captions that look like benchmark captions). HopChain takes the opposite approach: the synthetic data is deliberately unlike any specific downstream benchmark, designed instead to exercise a fundamental capability (chained visual grounding) that the authors hypothesize transfers broadly.

The experimental results in Tables 1 and 2 validate this hypothesis at a level that is unusual for synthetic data approaches. The multi-hop data improves 20 out of 24 benchmarks for both Qwen3.5-35B-A3B and Qwen3.5-397B-A17B, across four benchmark families: STEM and puzzle reasoning (MathVision, MMMU-Pro, BabyVision, ZeroBench, EMMA, LogicVista improve on both models), general VQA (MMBench-CN, MMBench-EN, RealWorldQA, AI2D improve on both models), text recognition and document understanding (CharXiv, DocVQA, InfoVQA improve on both models), and—most strikingly—video understanding (Video-MME, VideoMMMU, MMVUCOT, MVBench, MLVU improve on both models). The video transfer is particularly compelling because the multi-hop data was synthesized from static images with no temporal dimension. The model was never trained on video reasoning, yet video benchmarks improve on 5/6 tasks for both model scales. This is strong evidence that the multi-hop data strengthens a transferable capability (sustained visual grounding during extended reasoning) rather than teaching benchmark-specific patterns.

The contrast with prior data synthesis work is instructive. Approaches that generate training data to approximate a target distribution (e.g., generating math problems that look like MATH, generating captions that look like COCO captions) necessarily couple the training data's distribution to the target benchmark's distribution, which limits generalization to benchmarks that share that distribution. HopChain severs this coupling: the training queries (involving object chains like sheep → paper → doll, conditional logic about chart slices, arithmetic over instance counts) have no obvious resemblance to MathVision's geometry problems, MMMU's college-level disciplinary questions, or Video-MME's temporal reasoning tasks. The fact that performance improves across this diverse set suggests that the capability being trained—maintaining accurate, grounded visual reasoning across many intermediate steps—is a bottleneck that is shared across vision-language tasks regardless of their surface form. This is a conceptual advance in how to think about synthetic data for foundation model training: rather than asking "what data looks like the evaluation?," ask "what fundamental capability does the evaluation require that current training data fails to exercise?"

The paper's ablation on hop structure (Figure 5) strengthens this interpretation. If the gains came from the multi-hop data teaching the model a narrow synthetic-task skill (like "counting objects in dependency chains"), single-hop and half-multi-hop variants should show similar improvements—they still involve the same types of perceptual operations on the same images. Instead, the gains scale with chain length, indicating that it is specifically the chaining aspect that drives transfer, consistent with the hypothesis that sustained visual grounding is the capability being trained.

Innovation 4: Establishing Verifier-Free Multi-Hop RLVR Through Structurally Enforced Intermediate Correctness

RLVR typically faces a credit assignment problem: a binary reward on the final answer provides a sparse signal, and the model must discover which intermediate reasoning steps contributed to success or failure. In text-only domains like math and code, this works because correct intermediate reasoning is strongly correlated with correct final answers—if you follow valid algebraic manipulations, you reach the right number; if you make an error, you usually don't. In vision-language reasoning, this correlation is weaker: a model can make a perceptual error (miscounting objects) yet coincidentally reach the correct answer, or can reason perfectly from a faulty perceptual encoding and get the wrong answer. This makes RLVR on standard vision-language data noisy and potentially inefficient.

HopChain's design addresses this without introducing a learned reward model, step-level supervision, or any intermediate verification mechanism. The solution is purely structural: because the multi-hop queries enforce logical dependency among hops (earlier hops establish the instances, sets, or conditions needed for later hops), the final answer's correctness is tightly coupled to the correctness of intermediate steps. If the model misidentifies the speed limit sign at Hop 1, it cannot accidentally compensate at Hop 5—the chain's arithmetic operations will propagate the error to a wrong final number. The paper states this property explicitly: "obtaining the correct final number usually also requires the intermediate reasoning chain to be correct."

This is a conceptual innovation in how to construct training data for RLVR. Rather than trying to improve credit assignment through better algorithms (dense rewards, learned critics, per-step verification) or more training samples (which might eventually separate signal from noise), the paper designs training queries where the problem of credit assignment is mitigated by the task structure itself. This connects to a principle from curriculum learning and reinforcement learning theory: if you can construct tasks where the sparse reward is a reliable indicator of the correctness of the entire trajectory, you don't need dense rewards. HopChain operationalizes this principle for vision-language reasoning by enforcing logical dependency among reasoning steps.

The difficulty coverage analysis in Figure 7 provides indirect evidence that this structural property works as intended. For both model scales, more than half of the synthesized queries fall into the "Partially Correct" regime (1–7 correct out of 8 independent samples), and the distribution spans multiple success buckets rather than collapsing to "all correct" or "all incorrect." This is exactly the distribution one would want for RLVR training data: queries where the model sometimes succeeds and sometimes fails provide non-zero advantages (the $\hat{A}_{i,t}$ terms in Equation 4) that drive policy improvement, and the intermediate correctness coupling ensures that these advantages carry information about which behaviors to reinforce or suppress. If the queries were trivially easy (all correct) or impossibly hard (all incorrect), the advantage estimates would be near-zero and no learning would occur. The broad difficulty distribution in Figure 7 shows that the synthesized queries span a range where RLVR can operate effectively, and this property emerges from the structural design rather than from explicit difficulty tuning per query.

This innovation also explains why the multi-hop data is effective for both model scales despite being synthesized once and difficulty-calibrated using a weaker model. The logical dependency property creates a natural difficulty gradient: smaller models fail on more intermediate hops, propagating errors to wrong final answers and receiving negative reward signals, while larger models succeed on more hops and receive positive signals. The same query provides informative training for models at different capability levels because the "failure surface" shifts—what the 35B model finds challenging (correctly perceiving subtle color differences) might be easy for the 397B model, but both models encounter queries where their intermediate grounding is imperfect and receive useful gradients. This scale-agnostic property is rare in synthetic data pipelines and contributes to the practical deployability of the approach.

Innovation 5: Identifying and Structurally Targeting Compounding Error Cascades as the Distinctive Failure Mode of Long-CoT Vision-Language Reasoning

The paper's error analysis in Section 3 and Figure 2 makes a diagnostic contribution that goes beyond cataloging failure types. The key observation is not that VLMs make perception errors, reasoning errors, knowledge errors, and hallucination errors—all of these are well-documented (Rohrbach et al., 2018; Guan et al., 2024; Liu et al., 2025). The distinctive claim is that these errors compound in a specific way during long chain-of-thought reasoning: "once any such error appears at an intermediate step, the remaining reasoning can still look coherent while operating on flawed intermediate evidence, eventually producing an incorrect final answer."

This "coherent-but-wrong" property is what makes these failures both dangerous and difficult to address through standard training. A model that produces obviously incoherent reasoning (e.g., logical contradictions, nonsensical statements) is easy to detect and correct. A model that produces a chain of reasoning that is internally consistent, well-structured, and fluent—but built on a subtle perceptual miscount at step 3—will pass cursory inspection and fail only at the final answer check. The qualitative examples in Figure 3 illustrate this: the model's reasoning about the zebra ("vertical is dominant pattern → percentage of horizontal = 0 → answer: 0") is logically valid given the premise "vertical is dominant," but the premise is a reasoning error (dominance doesn't imply exclusivity). The model's reasoning about the parking sequence correctly identifies vehicle positions at each step but logically inverts entry as exit—a coherent chain built on an inverted causal interpretation.

Prior analyses of VLM failures have documented individual error types (hallucination, visual illusion) and some have noted that errors become more frequent in longer traces (Liu et al., 2025; Luo et al., 2025), but the paper's contribution is to identify the compounding cascade as the specific structural pattern that long-CoT reasoning introduces. Short-CoT reasoning can also have errors, but the chance that an error at step 2 propagates through steps 3, 4, and 5 before reaching a final answer is lower simply because there are fewer steps. Long-CoT reasoning multiplies the opportunities for a single faulty intermediate judgment to corrupt downstream reasoning, and the model's fluency can mask this corruption.

The paper's response to this diagnosis is structural rather than palliative. Instead of trying to detect and correct errors post-hoc (which would require per-step supervision or an oracle verifier), HopChain constructs training data where the compounding cascade is forced to occur during training—the model practices long chains where intermediate errors naturally lead to wrong final answers, and the RLVR reward signal provides gradient specifically at the points where grounding breaks down. The error-type analysis in Figure 2(b) and Figure 8 supports this interpretation: the distribution of errors corrected by multi-hop training closely mirrors the original error distribution, indicating that the training signal addresses the full diversity of failure modes rather than only the most common one. If the multi-hop data only improved perception while leaving reasoning errors untouched, the corrected-case distribution would be skewed toward perception errors. The fact that it's broadly similar to the baseline distribution suggests that the training signal works by improving the model's ability to maintain grounding throughout the chain, which benefits all error types that depend on intermediate visual evidence—whether the error originated from misperception, misreasoning, or hallucination.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper evaluates on 24 benchmarks spanning four categories: STEM and Puzzle (MathVision, MMMU Pro, MMMU, MathVista mini, BabyVision, ZeroBench, EMMA mini, LogicVista), General VQA (MMBench-CN DEV V1.1, MMBench-EN DEV V1.1, RealWorldQA, MMStar, HallusionBench, AI2D TEST, ERQA), Text Recognition and Document Understanding (CharXiv, DocVQA VAL, InfoVQA VAL), and Video Understanding (VideoMME w/o sub., VideoMMMU, MMVUCOT, MVBench, LVBench, MLVU M-Avg). All benchmarks are publicly available; the paper uses standard evaluation splits (test sets where available, validation splits otherwise). No benchmark-specific training data is used.
Base model(s). The paper uses two models from the Qwen3.5 family: Qwen3.5-35B-A3B (35B total parameters, 3B activated) and Qwen3.5-397B-A17B (397B total, 17B activated). These models were chosen because they represent a range of scales (roughly an order of magnitude apart in activated parameters) and are described by the authors as "after SFT and before RLVR," providing a shared starting point for controlled comparison of RLVR training variants. The SFT data is a pre-final internal version, not the final official Qwen3.5 data recipe.
Metrics. All benchmarks report accuracy as the primary metric—the fraction of questions for which the model's predicted final answer matches the ground truth. No alternative metrics (e.g., F1, BLEU, ROUGE) are used, consistent with the paper's focus on exact-answer correctness in verifiable reward settings. For multi-hop query difficulty analysis (Section 5.4, Figure 7), the paper reports success rate—the fraction of 8 independently sampled responses that are correct per query, binned from 0/8 to 8/8.
Baselines. The paper uses three primary comparison conditions, all applied to the same base model: Before RLVR (the model after SFT, before any RLVR training), RLVR w/o Multi-Hop (RLVR training on the original RLVR data only, using SAPO), and RLVR w/ Multi-Hop (RLVR training on a mixture of the original RLVR data plus the multi-hop data synthesized by HopChain). The central comparison is RLVR w/ Multi-Hop versus RLVR w/o Multi-Hop—this isolates the effect of adding multi-hop data, holding constant the RL algorithm, total training steps, and base model. Within the ablation on hop structure (Section 5.3, Figure 5), two additional baselines are introduced: RLVR w/ Single Hop (each multi-hop training query reduced to only its final hop) and RLVR w/ Half-Multi-Hop (the first half of each multi-hop chain removed, keeping only the latter half). The paper does not compare against alternative synthetic data generation methods or against non-RLVR fine-tuning approaches.
Generation budget / compute accounting. The RLVR training budget is measured in gradient steps and mini-batch configurations rather than in FLOPs or GPU-hours. For Qwen3.5-35B-A3B: each rollout samples 16 responses per query, mini-batch size of 64 queries, 1000 gradient steps total. For Qwen3.5-397B-A17B: same rollout configuration except mini-batch size increases to 128 queries and gradient steps reduce to 800. Training uses the SAPO algorithm (Gao et al., 2025) with a learning rate of $2.0 \times 10^{-6}$ . The paper does not report wall-clock time, total FLOPs, or inference-only compute for the trained models. The multi-hop dataset size is approximately 6k–8k queries per model scale, with "a similar amount of math RLVR data as the original RLVR data" used alongside. For response-level analysis (Section 5.4, Figure 6), compute is measured in response token count—the number of tokens generated in the model's chain-of-thought answer, binned into ranges from 6000 to 20000 tokens.
Cross-validation / statistical protocol. The paper does not report confidence intervals, standard deviations, or significance tests for benchmark results. The 24-benchmark evaluation serves as a form of cross-domain validation—if gains appeared on only a few benchmarks, they would be suspect as overfitting to the synthetic data distribution. The paper implicitly relies on the breadth of benchmarks (spanning four categories) and the consistency of improvements (20/24 benchmarks improve on both model scales) as evidence against random variation. The hop-structure ablation (Figure 5) reports results on five representative benchmarks (MathVision, MMMU Pro, RealWorldQA, ERQA, VideoMMMU) rather than the full 24, with consistent rank-ordering across all five, which reduces the likelihood of the observed pattern being spurious. The difficulty coverage analysis (Figure 7) uses eight independent samples per query for both model scales, providing a per-query success rate estimate but no error bars around the distribution. The error-type analysis (Figures 2 and 8) samples 20 incorrect responses per benchmark and uses human annotators to classify failure types; no inter-annotator agreement metrics are reported.

Main Quantitative Results

The paper's experimental results are organized around four axes of investigation: (1) the main benchmark-level comparison showing that adding multi-hop data to RLVR improves the majority of benchmarks across both model scales, (2) the ablation on hop structure demonstrating that full multi-hop chains are necessary for the observed gains, (3) a response-length analysis showing that gains are most pronounced in the long-CoT regime, and (4) a difficulty-coverage and error-type analysis characterizing the properties of the synthesized data.

Benchmark-Level Comparison: RLVR w/ Multi-Hop vs. RLVR w/o Multi-Hop

Headline result: Adding the multi-hop data synthesized by HopChain to the original RLVR training data improves 20 out of 24 benchmarks for both Qwen3.5-35B-A3B and Qwen3.5-397B-A17B, despite the synthesized data being benchmark-agnostic and not designed for any specific evaluation task.

Qwen3.5-35B-A3B results (Table 1). The full results table shows three columns: Before RLVR (the post-SFT starting point), RLVR w/o Multi-Hop (the baseline RLVR training), and RLVR w/ Multi-Hop (the proposed approach). For STEM and Puzzle benchmarks, RLVR w/ Multi-Hop improves over RLVR w/o Multi-Hop on 6 of 8 tasks: MathVision (73.71 → 76.05, +2.34), MMMU Pro (69.25 → 70.64, +1.39), BabyVision (21.91 → 22.68, +0.77), ZeroBench (1 → 3, +2), EMMA mini (53.00 → 58.00, +5.00), and LogicVista (74.66 → 75.56, +0.90). MMMU shows a marginal decline (78.89 → 78.33, -0.56) and MathVista mini shows a small decline (85.50 → 85.00, -0.50). For General VQA, RLVR w/ Multi-Hop improves on 6 of 7 tasks: MMBench-CN (90.17 → 90.48, +0.31), MMBench-EN (90.63 → 91.49, +0.86), RealWorldQA (78.17 → 79.35, +1.18), MMStar (78.53 → 78.60, +0.07), AI2D TEST (90.87 → 91.29, +0.42), and ERQA (48.25 → 51.38, +3.13). HallusionBench is essentially flat (66.64 → 66.50, -0.14). For Text Recognition and Document Understanding, all 3 benchmarks improve: CharXiv (69.00 → 73.10, +4.10), DocVQA VAL (95.13 → 95.55, +0.42), InfoVQA VAL (87.44 → 90.17, +2.73). For Video Understanding, 5 of 6 benchmarks improve: VideoMME w/o sub. (74.63 → 75.00, +0.37), VideoMMMU (73.33 → 74.78, +1.45), MMVUCOT (65.80 → 68.90, +3.10), MVBench (69.95 → 70.73, +0.78), MLVU M-Avg (77.69 → 79.53, +1.84). LVBench declines (54.49 → 53.20, -1.29). The largest absolute gains across all benchmarks are on EMMA mini (+5.00), CharXiv (+4.10), ERQA (+3.13), MMVUCOT (+3.10), and InfoVQA (+2.73). Notably, the Before RLVR baseline already shows substantial headroom on many benchmarks—RLVR w/o Multi-Hop itself provides gains over the SFT model—but RLVR w/ Multi-Hop yields further improvements in 20/24 cases.

Qwen3.5-397B-A17B results (Table 2). The larger model shows similarly broad gains, improving on 20 of 24 benchmarks. For STEM and Puzzle, all 8 benchmarks improve: MathVision (81.68 → 83.71, +2.03), MMMU Pro (75.06 → 76.47, +1.41), MMMU (81.67 → 82.89, +1.22), MathVista mini (88.30 → 89.00, +0.70), BabyVision (28.61 → 32.22, +3.61), ZeroBench (4 → 8, +4), EMMA mini (66.25 → 69.00, +2.75), and LogicVista (80.69 → 81.59, +0.90). For General VQA, 4 of 7 benchmarks improve: MMBench-CN (91.41 → 91.72, +0.31), RealWorldQA (79.87 → 81.70, +1.83), HallusionBench (67.48 → 67.86, +0.38), and AI2D TEST (92.81 → 92.97, +0.16). MMBench-EN declines (92.49 → 91.56, -0.93), MMStar declines (81.73 → 80.67, -1.06), and ERQA declines (60.50 → 60.00, -0.50). For Text Recognition and Document Understanding, all 3 benchmarks improve: CharXiv (74.60 → 77.20, +2.60), DocVQA VAL (95.98 → 96.03, +0.05), InfoVQA VAL (90.83 → 92.20, +1.37). For Video Understanding, 5 of 6 benchmarks improve: VideoMME w/o sub. (78.30 → 80.41, +2.11), VideoMMMU (78.89 → 80.00, +1.11), MMVUCOT (72.30 → 72.50, +0.20), MVBench (73.03 → 73.31, +0.28), MLVU M-Avg (82.43 → 82.52, +0.09). LVBench is essentially flat (59.13 → 59.07, -0.06). The largest gains for the larger model are on ZeroBench (+4.00), BabyVision (+3.61), EMMA mini (+2.75), CharXiv (+2.60), and VideoMME (+2.11).

Cross-model consistency. The paper emphasizes that the pattern of improvements is consistent across model scales: "RLVR w/ Multi-Hop improves 20 out of 24 benchmarks for both Qwen3.5-35B-A3B and Qwen3.5-397B-A17B." Examining which benchmarks improve on both models: 18 benchmarks show gains on both scales (MathVision, MMMU Pro, BabyVision, ZeroBench, EMMA mini, LogicVista, MMBench-CN, RealWorldQA, AI2D TEST, CharXiv, DocVQA VAL, InfoVQA VAL, VideoMME, VideoMMMU, MMVUCOT, MVBench, MLVU, HallusionBench—where HallusionBench is effectively flat on both), while 4 benchmarks show mixed results (MMMU improves on 397B but declines on 35B; MathVista improves on 397B but declines on 35B; MMBench-EN improves on 35B but declines on 397B; ERQA improves on 35B but declines on 397B). The only benchmark that declines on both models is LVBench (a modest decline of -1.29 on 35B and -0.06 on 397B). The paper does not discuss the small set of mixed results or the LVBench decline in detail.

Video transfer. The paper highlights that "although our multi-hop data is synthesized from images, the improvement transfers strongly to video understanding: video benchmarks improve on 5 out of 6 tasks for both model scales." This is the strongest evidence for cross-domain generalization, since the training data contains no temporal information and the queries do not involve video-specific reasoning (action recognition, temporal ordering, event localization). The consistent video gains suggest that the capability strengthened by multi-hop image data—sustained visual grounding across extended reasoning chains—transfers to the video domain, where models must maintain attention to visual evidence across frames over time. The video benchmark improvements are generally larger for Qwen3.5-397B-A17B (+2.11 on VideoMME, +1.11 on VideoMMMU) than for Qwen3.5-35B-A3B (+0.37, +1.45), suggesting the larger model may be better able to leverage the multi-hop training signal for temporal reasoning.

Magnitude of gains relative to baseline improvement. The paper contextualizes the multi-hop gains against the improvement from RLVR itself. For Qwen3.5-35B-A3B on MathVision, RLVR w/o Multi-Hop improves +11.74 points over Before RLVR (61.97 → 73.71), while multi-hop adds an additional +2.34 points—roughly 20% of the RLVR gain. On EMMA mini, the breakdown is +11.12 from RLVR plus +5.00 from multi-hop data—roughly 45% of the RLVR gain. On CharXiv, it's +7.70 from RLVR plus +4.10 from multi-hop—roughly 53% of the RLVR gain. This indicates that multi-hop data provides gains that are meaningfully large relative to what standard RLVR already delivers, particularly on benchmarks requiring fine-grained visual reasoning (CharXiv, EMMA) or extended reasoning chains (MMVUCOT).

Ablation on Hop Structure: Single-Hop vs. Half-Multi-Hop vs. Multi-Hop

Headline result: Preserving the full multi-hop chain structure in training queries yields strictly better performance than truncating to half the hops or a single final hop, with a consistent rank-ordering across five representative benchmarks and an average score gap of 6.1 points between multi-hop and single-hop training.

The paper evaluates three training-query settings on Qwen3.5-35B-A3B, all using the same SAPO RLVR training procedure: RLVR w/ Single Hop (each multi-hop query is reduced to only its final hop—e.g., a 5-hop query becomes "What is the final number?" with no context about the chain), RLVR w/ Half-Multi-Hop (the first half of each chain is removed, keeping only the latter half of the hops), and RLVR w/ Multi-Hop (the full query is preserved). Results are reported on five representative benchmarks in Figure 5.

On MathVision: 76.05 (Multi-Hop) > 73.03 (Half-Multi-Hop) > 72.76 (Single Hop). On MMMU Pro: 70.64 > 62.72 > 60.87. On RealWorldQA: 79.35 > 78.30 > 74.90. On ERQA: 51.38 > 48.50 > 47.25. On VideoMMMU: 74.78 > 70.78 > 65.78. The rank-ordering is identical across all five benchmarks, with the gaps being particularly large on MMMU Pro (70.64 vs. 60.87, a 9.77-point gap between Multi-Hop and Single Hop) and VideoMMMU (74.78 vs. 65.78, a 9.00-point gap). The average score across the five benchmarks is 70.4 for Multi-Hop, 66.7 for Half-Multi-Hop, and 64.3 for Single Hop.

The gap between Half-Multi-Hop and Single Hop (66.7 vs. 64.3, +2.4 average) is smaller than the gap between Multi-Hop and Half-Multi-Hop (70.4 vs. 66.7, +3.7 average), indicating that the benefit of preserving the full chain is not linear—there is a larger penalty for removing the first half of the chain (which establishes the starting instances and context) than for removing only the final hop (which performs the terminal computation). This pattern is consistent with the paper's claim that "earlier hops establish the instances, sets, or conditions needed for later hops"—removing the early hops destroys the dependency structure, while removing the final hop leaves the model with an incomplete chain that lacks the terminal numerical result.

The consistent rank-ordering across all five benchmarks, spanning STEM (MathVision, MMMU Pro), general VQA (RealWorldQA, ERQA), and video (VideoMMMU), argues against the gains being due to random variation or benchmark-specific effects. If the Multi-Hop advantage were spurious, one would expect it to sometimes underperform Half-Multi-Hop or Single Hop on some benchmarks, which never occurs.

Analysis by Reasoning Length

Headline result: The advantage of RLVR w/ Multi-Hop over RLVR w/o Multi-Hop is visible across response-length bins and is largest in the ultra-long-CoT regime, where accuracy gains exceed 50 points on Qwen3.5-397B-A17B.

Figure 6 bins the benchmark evaluation responses of Qwen3.5-397B-A17B by response token count (ranging from approximately 6000 to 20000 tokens) and plots accuracy for both RLVR w/o Multi-Hop (blue dashed line) and RLVR w/ Multi-Hop (orange solid line), along with the improvement (bars, right axis). The figure shows that both models' accuracy generally decreases as response length increases—longer reasoning chains correlate with harder problems or more complex solutions, and accuracy drops accordingly. However, the accuracy gap between RLVR w/ Multi-Hop and RLVR w/o Multi-Hop persists across the entire range and, critically, grows in the ultra-long-response regime (approximately 16000–20000 tokens). In this regime, RLVR w/o Multi-Hop drops to low accuracy (the blue line dips sharply), while RLVR w/ Multi-Hop maintains substantially higher accuracy, with improvement bars exceeding 50 accuracy points in the rightmost bins.

The paper interprets this as direct evidence that HopChain "strengthens long-CoT vision-language reasoning." If the multi-hop data only helped on short or easy responses, the advantage would narrow or disappear in the long-response bins. The observation that the advantage widens in the ultra-long regime supports the claim that the synthesized data specifically improves the model's ability to sustain accurate grounding across extended reasoning chains, rather than providing a uniform benefit across all response lengths.

The response length itself is not directly controlled—it is an emergent property of the model's reasoning on benchmark questions. The binned analysis is therefore correlational, not causal: we observe that multi-hop training helps more on questions that elicit very long responses, but we cannot conclude that multi-hop training causes the model to produce longer responses or that the benefit is because the responses are long. It could be that the questions producing very long responses are also the questions where sustained visual grounding is most critical, and the multi-hop training improves that specific capability, with response length being a correlated proxy rather than the mechanism. The paper does not address this distinction, but the observed pattern is consistent with the central hypothesis regardless of the causal direction.

Difficulty Coverage Analysis

Headline result: The synthesized multi-hop data spans a broad difficulty range, with more than half of queries falling into the "Partially Correct" regime (1–7 correct out of 8 independent samples) for both model scales, and the distribution spans multiple success buckets from fully incorrect to fully correct.

Figure 7 shows, for each multi-hop query in the training set, how many of eight independently sampled responses are correct, separately for Qwen3.5-35B-A3B and Qwen3.5-397B-A17B. For the 35B model: 15.57% of queries are "All Correct" (8/8), 71.34% are "Partially Correct" (1–7/8), and 13.10% are "All Incorrect" (0/8). The distribution within the Partially Correct regime is relatively flat, with each success bucket (1/8 through 7/8) containing 9–13% of queries. For the 397B model: 39.99% of queries are All Correct, 51.49% are Partially Correct, and 8.52% are All Incorrect. The distribution is more right-skewed than for the smaller model, with the largest single bucket being 8/8 (40%), reflecting the larger model's higher capability.

The paper emphasizes two properties of these distributions. First, the substantial fraction of Partially Correct queries (71% for 35B, 51% for 397B) means that the data provides informative RLVR training signal—queries where the model sometimes succeeds and sometimes fails produce non-zero advantage estimates that drive policy improvement. If most queries were All Correct or All Incorrect, the advantage terms in SAPO (Equation 4) would be near-zero (since all responses in a group would receive similar rewards), providing no gradient. Second, the distribution spans a broad range, indicating that the data is not concentrated at a single difficulty level that would be suitable for only one model scale. The fact that both models show a spread of success rates on the same queries demonstrates that the multi-hop data provides useful training signal across capability levels—the 35B model finds some queries challenging that the 397B model finds easy, but both encounter queries in the Partially Correct regime that generate learning.

The shift from 15.6% All Correct for the 35B model to 40.0% All Correct for the 397B model also validates the difficulty calibration procedure (Stage 4): the weaker model used for difficulty filtering was somewhat weaker than the 35B model (since 15.6% of retained queries are still perfectly solved by the 35B model), and the 397B model finds substantially more queries easy (40% all-correct), consistent with its higher capability.

Error-Type Analysis

Headline result: The distribution of error types corrected by multi-hop training closely mirrors the original error distribution, indicating broad error correction rather than improvement limited to a single failure category.

Figure 2(a) shows the error-type distribution of RLVR w/o Multi-Hop on the benchmarks from Tables 1 and 2, based on human annotation of 20 randomly sampled incorrect responses per benchmark for Qwen3.5-397B-A17B. The distribution is diverse: perception errors are the largest category, but reasoning errors, knowledge errors, hallucination errors, and other errors are all represented. This validates the paper's claim in Section 3 that long-CoT failures are diverse rather than concentrated in a single type.

Figure 2(b) shows the distribution of baseline error types among the cases where RLVR w/ Multi-Hop corrects an error made by RLVR w/o Multi-Hop. The distribution is "broadly similar" to Figure 2(a): perception errors remain the largest corrected category, reasoning errors the second largest, and knowledge, hallucination, and other errors are also corrected. The paper interprets this similarity as evidence that "multi-hop data mitigates failures in a generalizable way rather than improving only a narrow error type." If the multi-hop data only improved perception (e.g., by teaching the model to count better), the corrected-case distribution would be skewed toward perception errors relative to the baseline distribution. The fact that it mirrors the baseline suggests that the multi-hop data improves the underlying capability—sustained visual grounding during long chains—which benefits all error types that depend on intermediate visual evidence, regardless of whether the proximate cause was a perception error, a reasoning error, or a hallucination.

Figure 8 provides a more granular breakdown, showing subtype distributions for corrected perception errors (chart misread, text misread, object misidentify, spatial error, counting error, color error, temporal misread) and corrected reasoning errors (logic error, temporal error, math error, causal error, spatial error). These subtypes are diverse and cover a range of visual and logical reasoning skills. The paper does not provide the corresponding subtype distributions for the baseline error profile, so direct comparison at the subtype level is not possible from the reported data. However, the presence of gains across perception subtypes (chart, text, object, spatial, counting, color, temporal) and reasoning subtypes (logic, temporal, math, causal, spatial) supports the claim of broad rather than narrow improvement.

The paper does not report: (a) the total number of corrected cases analyzed for Figures 2(b) and 8 (only that 20 incorrect responses per benchmark were sampled for the baseline distribution, but not how many of those were later corrected by multi-hop training), (b) inter-annotator agreement for the error-type classification, (c) whether the annotators were blind to the experimental condition, or (d) whether the corrected-case distribution is statistically distinguishable from the baseline distribution or merely visually similar.

Ablation Studies and Robustness Checks

The paper's main ablation is the hop-structure comparison (Single-Hop vs. Half-Multi-Hop vs. Multi-Hop, Section 5.3, Figure 5), which was covered in detail under Main Quantitative Results. Beyond this, the paper includes several analyses that function as robustness checks rather than formal ablation studies:

Difficulty calibration across model scales (Figure 7, Section 5.4). The paper verifies that the difficulty calibration procedure (Stage 4) produces queries that provide useful RLVR training signal for both model scales. For Qwen3.5-35B-A3B, 71.3% of queries are Partially Correct (1–7/8 correct), and for Qwen3.5-397B-A17B, 51.5% are Partially Correct. This confirms that the calibration (using a weaker model to filter out queries where it achieves 100% accuracy) generalizes to produce queries that are challenging but not impossible for both the smaller and larger target models. The shift toward more All Correct queries for the larger model (40.0% vs. 15.6%) is expected and does not undermine the approach—the 397B model still encounters 51.5% of queries where performance is imperfect and learning can occur.

Cross-domain transfer to video (Tables 1 and 2, Section 5.2). Although not framed as an ablation, the strong video benchmark improvements serve as an implicit robustness check on whether the gains from image-synthesized multi-hop data transfer to a fundamentally different modality. The fact that 5 of 6 video benchmarks improve for both model scales (with VideoMME gaining +0.37 and +2.11 on the two models, and VideoMMMU gaining +1.45 and +1.11) provides evidence against the hypothesis that the gains are image-specific. The paper does not test whether adding actual video-based multi-hop data (synthesized from video frames rather than static images) would yield even larger video gains or whether the current gains represent an upper bound for cross-modal transfer.

Model scale consistency (Tables 1 and 2, Section 5.2). The near-identical count of improved benchmarks (20/24 for both model scales) serves as a scale-robustness check. The paper does not claim that the smaller model benefits more or less than the larger model—in some cases, the 35B model shows larger absolute gains (EMMA mini: +5.00 vs. +2.75; ERQA: +3.13 vs. -0.50), while in others, the 397B model shows larger gains (VideoMME: +2.11 vs. +0.37; BabyVision: +3.61 vs. +0.77). The paper reports these numbers without attributing the pattern to any systematic scale-dependent effect.

Response-length analysis as an implicit ablation on chain length (Figure 6, Section 5.4). By showing that the multi-hop advantage persists and widens in the ultra-long-response regime, the paper provides evidence that the benefit is not restricted to short reasoning chains. If the multi-hop data only helped on questions requiring brief visual inspection, the advantage would narrow or vanish as response length grows. The opposite pattern supports the claim that the data specifically strengthens long-chain reasoning. However, this is not a controlled ablation—response length is an emergent property of model behavior, and the bins contain different question sets, so alternative explanations (e.g., questions eliciting long responses are also questions where visual grounding is most important, and multi-hop data helps on those regardless of chain length) cannot be ruled out.

Image filtering as a data-quality ablation (Section 5.1, Appendix B). The paper describes a multi-stage image filtering procedure designed to retain images with sufficient perceptual complexity and to exclude images that are too low-quality or too annotation-impractical for multi-hop query construction. The filtering is not ablated—the paper does not report results with unfiltered images or with alternative filtering criteria. This is a limitation: we do not know whether the filtering is necessary for the observed gains, or whether simpler filters (e.g., removing only blurry images) would produce similar results. The paper's claim that the filtering favors "images that are perceptually challenging for standard vision models" is not directly tested—we do not know whether queries synthesized from challenging images produce different training dynamics than queries from less challenging images.

Hop-type disentanglement (not performed). The paper defines two complementary hop types (perception-level hops and instance-chain hops) and requires that every query combines both, but does not ablate these separately. An experiment comparing: (a) queries with only perception-level hops, (b) queries with only instance-chain hops, and (c) queries with both (the current design) would test whether both hop types are individually necessary or whether one type drives most of the benefit. The current ablation (Single-Hop vs. Half-Multi-Hop vs. Multi-Hop) varies chain length but does not vary the composition of the chain. This leaves open the possibility that one hop type is largely responsible for the gains and the other is unnecessary, or that the requirement to combine both types is important for the observed broad error correction (Figures 2 and 8).

Data mixing ratio (not ablated). The paper uses "a mixture of the original RLVR data and our synthesized multi-hop data" and notes that "a similar amount of math RLVR data as the original RLVR data" is included. The mixing ratio between original data and multi-hop data is not specified and is not ablated. An experiment varying the proportion of multi-hop data (e.g., 10%, 25%, 50%, 100% of the RLVR training queries) would provide practical guidance for practitioners and test whether there are diminishing or negative returns to increasing the multi-hop data proportion. The current results establish that adding some multi-hop data helps but do not characterize the dose-response curve.

SAPO-specificity (not ablated). All RLVR training uses SAPO (Gao et al., 2025). The paper does not test whether the multi-hop data would yield similar gains with other RLVR algorithms (e.g., GRPO, GSPO, or standard PPO). This is a reasonable scope limitation—the paper's contribution is the data, not the algorithm—but it means the reported gains are conditioned on SAPO, and the interaction between multi-hop data structure and RL algorithm choice is unexplored.

Dataset size and diversity (implicit ablation via benchmark breadth). The paper uses approximately 6k–8k multi-hop queries per model scale. An experiment scaling the number of queries (e.g., 2k, 4k, 8k, 16k) would test whether the gains saturate at the current scale or could be increased with more data. Similarly, the paper does not ablate image diversity—do gains come from having a large number of distinct images, or could the same number of queries on fewer images achieve similar results? The current pipeline synthesizes queries from a filtered image pool, but the pool size and query-per-image statistics are not reported.

Critical Assessment

The experimental evaluation provides substantial evidence that adding HopChain-synthesized multi-hop data to RLVR training improves a broad range of vision-language reasoning benchmarks, that full multi-hop chains are necessary for these gains, and that the gains are most pronounced in long-CoT reasoning regimes. However, several aspects of the experimental design limit the strength of some conclusions, and important control experiments are absent.

Does the paper demonstrate that multi-hop data causes broad, generalizable gains in vision-language reasoning?

The central empirical claim is that "RLVR on the multi-hop data synthesized by HopChain yields broad, generalizable gains" (from the abstract and contributions list). The evidence for this claim comes from the 20/24 benchmark improvements on both model scales (Tables 1 and 2). This is strong evidence that the multi-hop data improves benchmark performance across domains, but the paper's causal interpretation—that the improvement arises specifically from the multi-hop structure forcing repeated visual grounding—rests on the hop-structure ablation (Figure 5) and the error-type analysis (Figures 2 and 8), both of which have limitations.

The hop-structure ablation convincingly shows that longer chains produce larger gains (Multi-Hop > Half-Multi-Hop > Single Hop), which is consistent with the visual grounding hypothesis. However, it does not rule out alternative explanations: (a) longer chains might simply provide more total training tokens in a format that resembles long-CoT reasoning, and the model benefits from practice at producing extended reasoning traces regardless of whether visual grounding is specifically strengthened; (b) the single-hop and half-multi-hop variants might suffer from distribution shift—the model was not trained to see queries of that particular truncated form, and the performance drop reflects unfamiliarity with the training distribution rather than loss of a specific capability; (c) the multi-hop queries contain more complex language (more spatial descriptions, more conditional structures, more numerical operations) than the truncated variants, and the benefit could come from exposure to complex linguistic structures rather than from repeated visual grounding per se. The paper does not include a control where the multi-hop structure is preserved but the visual grounding requirement is weakened (e.g., by providing the intermediate answers in the query and asking only for the final computation), which would help disambiguate the structural complexity hypothesis from the visual grounding hypothesis.

The error-type analysis shows that the distribution of corrected errors mirrors the baseline error distribution (Figures 2 and 8), which the paper interprets as evidence of broad, generalizable improvement. The validity of this interpretation depends on the quality of the error-type annotation, which has several unreported aspects: no inter-annotator agreement metrics are provided, no details on annotator training or qualification, no blinding procedure (annotators may have known which model produced which response), and no sample sizes for the corrected-case distribution. If annotator reliability is low or if annotators were biased (e.g., expecting multi-hop data to improve perception errors more), the similarity between the baseline and corrected-case distributions could be artifactual. Additionally, the paper analyzes corrected cases—questions where RLVR w/o Multi-Hop was wrong and RLVR w/ Multi-Hop was correct—but does not analyze cases where multi-hop training introduced new errors (questions correct in the baseline and wrong with multi-hop data). These exist: on the 4 regressing benchmarks for each model, some previously correct answers become incorrect. Analyzing the error types introduced by multi-hop training would provide a more complete picture and might reveal systematic weaknesses (e.g., does multi-hop data cause the model to over-inspect images and misread text it previously identified correctly?).

Is the benchmark selection and breadth sufficient to conclude "generalizable" gains?

The paper evaluates on 24 benchmarks spanning four categories, which is broader than most synthetic data evaluations. The inclusion of video benchmarks as a cross-modal test is particularly strong. However, several considerations limit the generalizability conclusion:

First, all benchmarks are within the broad category of vision-language reasoning with objective answers (multiple-choice, numerical, or short-answer with exact-match grading). The paper does not test on open-ended generation tasks (image captioning, visual storytelling, dialogue about images), tasks requiring subjective judgment (aesthetics, humor, appropriateness), or tasks where the "correct" answer is not a single verifiable output. The claim of "generalizable" gains is therefore conditioned on tasks with verifiable answers—the paper's own framing in the context of RLVR—but the text sometimes implies broader generality.

Second, while the benchmarks span four categories, they are all academic benchmarks with known distributional properties. The paper's claim that the multi-hop data is "benchmark-agnostic" and "not synthesized to target any specific benchmark" is supported by the pipeline design, but it does not follow that the gains would transfer to production deployment distributions (e.g., medical images, satellite imagery, industrial inspection), which may have very different visual statistics, object distributions, and reasoning requirements. The benchmark evaluation demonstrates within-academic-benchmark generalization, not arbitrary real-world generalization.

Third, the absolute magnitude of gains varies substantially across benchmarks and is sometimes small. On MMBench-CN, the improvement is +0.31 (35B) and +0.31 (397B); on DocVQA, +0.42 and +0.05; on MLVU, +1.84 and +0.09. These are positive but may not be practically meaningful depending on benchmark variance. Without confidence intervals or statistical tests, it is difficult to distinguish small real improvements from noise, especially on benchmarks where the baseline accuracy is already high (e.g., DocVQA at 95.13% for the 35B model leaves limited headroom). The paper's claim of "broad gains" is supported by the count of improved benchmarks (20/24) but does not address whether the small gains on some benchmarks are statistically reliable.

Does the response-length analysis (Figure 6) support the claim that multi-hop data strengthens long-CoT reasoning?

The response-length analysis is one of the paper's most visually striking results, with accuracy gains exceeding 50 points in the ultra-long-CoT regime. However, this analysis has important interpretational caveats.

The binning by response token count is a post-hoc stratification—questions are grouped by how many tokens the model produced in its answer, not by a predefined difficulty or reasoning-length metric. The bins on the right side of Figure 6 (the ultra-long-CoT regime) contain a different set of questions than the bins on the left. The observation that multi-hop training helps more in the rightmost bins means that multi-hop training is particularly beneficial on the subset of benchmark questions that elicit very long responses, not that a given question becomes longer under multi-hop training and the benefit increases with its length. The causal claim "multi-hop data strengthens long-CoT reasoning" would ideally be supported by showing that, on a fixed set of questions that require long reasoning chains (e.g., curated multi-step problems), the multi-hop model outperforms the baseline. The current analysis is correlational: questions that are hard enough to require very long responses also happen to be questions where multi-hop training provides the largest benefit. This is consistent with the long-CoT strengthening hypothesis but does not directly test it.

Additionally, response length is an emergent property of the model's policy, which may change under multi-hop training. If multi-hop training causes the model to produce longer responses on average (because it learns to include more explicit visual grounding steps), then the bin boundaries in Figure 6 would contain different question distributions for the two models, making the within-bin comparison potentially misleading. The paper does not report whether response length distributions differ between RLVR w/o Multi-Hop and RLVR w/ Multi-Hop, nor does it control for this confounding.

Does the difficulty coverage analysis (Figure 7) support the claim that the data is suitable for RLVR training?

Figure 7 shows that the synthesized queries produce a range of success rates, with many in the Partially Correct regime. This is clearly a desirable property for RLVR data, and the paper's observation that the distribution spans multiple buckets is well-supported by the figure. However, two subtleties weaken the connection to the paper's broader claims.

First, the success rate is measured on the pre-RLVR model (or more precisely, on the models after SFT but before RLVR training on the multi-hop data—the paper refers to these as "Qwen3.5-35B-A3B" and "Qwen3.5-397B-A17B" in Figure 7, but the "Before RLVR" models from Tables 1 and 2 are the most likely reference point). The suitability for RLVR training depends on the success rate distribution during training, not before it. If the model quickly learns to solve all the multi-hop queries after a few gradient steps, the Partially Correct regime would collapse to All Correct, and the training signal would vanish. The paper does not report how the success rate distribution evolves during RLVR training—we do not know whether the queries remain in the Partially Correct regime throughout the 1000 or 800 gradient steps, or whether they become saturated early in training.

Second, the All Incorrect fraction (13.1% for 35B, 8.5% for 397B) represents queries where the model never succeeds in 8 attempts. These queries provide no positive reward signal (all responses get reward 0), and in the SAPO formulation (Equation 3–4), constant-zero rewards produce near-zero advantages (since all responses in the group have the same reward), yielding no gradient. These queries consume compute during RLVR training without contributing to learning. The paper does not discuss this inefficiency or propose mechanisms (e.g., curriculum learning, dynamic query selection) to avoid spending training budget on unsolvable queries.

What experiments are missing that would strengthen the paper's claims?

Several experiments would substantially strengthen the causal and practical claims:

A visual grounding probe. The paper argues that multi-hop data improves "visual grounding" but evaluates this indirectly through benchmark accuracy. A direct test would be an evaluation on a benchmark designed to measure visual grounding quality during long reasoning chains—for example, a set of questions where the model must report intermediate perceptual observations (object counts, spatial relationships, text reads) at specific steps, with per-step accuracy measured. This would directly test whether the improvement mechanism is improved intermediate perception (as the paper claims) or improved higher-level reasoning that better masks perception errors.
An ablation varying the type of multi-hop structure rather than just the length of the chain. The current ablation (Single-Hop vs. Half-Multi-Hop vs. Multi-Hop) varies chain length. An experiment with: (a) queries containing only perception-level hops (no instance chaining), (b) queries containing only instance-chain hops (no perception-level switching), and (c) queries with both (the full HopChain design), all at matched total hop counts, would test whether the dual-hop-type formalization is necessary or whether one hop type dominates.
A data scaling experiment. Training with 2k, 4k, 8k, and 16k multi-hop queries (while holding original RLVR data constant) would characterize the scaling behavior of multi-hop data and determine whether the current 6k–8k queries saturate the benefit. If gains continue to scale with more data, the practical value of the synthesis pipeline increases; if gains saturate at 4k, the pipeline can be run more cheaply.
An RL algorithm ablation. Training with the same multi-hop data but using GRPO, GSPO, or standard PPO instead of SAPO would test whether the multi-hop data's benefits are specific to the SAPO objective (with its temperature-controlled soft gate) or generalize across RLVR algorithms. This is practically important for practitioners who may use different RLVR implementations.
A compute-matched baseline with more original RLVR data. The paper's core claim is that multi-hop data is better than "simply expanding existing vision-language RLVR training data." To test this directly, the paper would need to compare RLVR w/ Multi-Hop against an RLVR condition with increased original RLVR data (matched for total training queries or total gradient steps). The current comparison holds total RLVR data approximately constant (original + multi-hop vs. original only), which means the multi-hop condition receives more total training data. If adding the same number of additional original RLVR queries (instead of multi-hop queries) also improved 20/24 benchmarks, the claimed advantage of multi-hop data specifically would be undermined.
Confidence intervals and significance tests. The benchmark results are reported as point estimates without any measure of uncertainty. The small gains on some benchmarks (e.g., +0.07 on MMStar for the 35B model, +0.05 on DocVQA for the 397B model) could easily fall within sampling error, especially given that benchmark test sets can be relatively small and model outputs can be non-deterministic (sampling temperature, random seed). Reporting standard errors, confidence intervals, or results from multiple random seeds would allow readers to distinguish genuine improvements from noise.
A baseline using human-generated multi-hop questions. The current pipeline synthesizes queries using a VLM (Qwen3-VL-235B-A22B-Thinking) with a detailed prompt. It would be informative to compare against a small set of human-written multi-hop questions following the same structural definition (Level 3, both hop types, logical dependency, numerical answers). If human-written multi-hop data produces similar gains, the synthesis pipeline is validated as a scalable approximation to human data quality; if human-written data produces larger gains, the synthesis pipeline has a quality gap that needs addressing.

What are the genuine strengths of the experimental design?

Despite these limitations, the experimental design has several notable strengths that deserve recognition:

The breadth of evaluation (24 benchmarks, 4 categories, 2 model scales) is unusual for a data synthesis paper and provides a more comprehensive picture of generalization than the typical single-benchmark or single-family evaluation. The consistency of the pattern (20/24 improvements on both model scales) is difficult to explain as random chance or benchmark-specific overfitting. The hop-structure ablation with its consistent rank-ordering across five diverse benchmarks is a clean demonstration that chain structure matters. The video transfer results (5/6 benchmarks improving for both models) provide strong evidence for cross-modal generalization that would be hard to attribute to narrow overfitting to the image-based training distribution. And the difficulty coverage analysis (Figure 7) directly addresses a practical concern about synthetic data (does it provide useful training signal?) with a clear, interpretable metric.

The paper's honesty about its own limitations is also a strength. The authors explicitly acknowledge that the pipeline "depends on successful instance segmentation, so images with no detectable objects (and thus no SAM3-segmentable instances) cannot be processed" (Section 7). They do not overclaim about the difficulty calibration cost (Section 5.1 acknowledges the use of a weaker model but does not hide the computational expense of generating 8 samples per query). And they do not claim that the multi-hop data is a replacement for original RLVR data—the experiments always use a mixture, and the paper frames the contribution as a "complementary source of RLVR training data" (Section 1).

Summary of experimental support for key claims:

Claim: Adding multi-hop data to RLVR improves generalizable vision-language reasoning. Supported by the 20/24 benchmark improvements on both model scales, with the caveat that small gains on some benchmarks may not be statistically reliable, and the evaluation is limited to academic benchmarks with verifiable answers.
Claim: Full multi-hop chains are necessary; truncated chains underperform. Strongly supported by the consistent rank-ordering in the hop-structure ablation (Figure 5).
Claim: Gains are most pronounced in long-CoT reasoning. Supported by the response-length analysis (Figure 6), with the caveat that this is a correlational, post-hoc stratification rather than a controlled experiment.
Claim: The synthesized data spans a broad difficulty range. Supported by the success-rate distributions in Figure 7, with the caveat that the distribution during training (not just before training) is the relevant metric.
Claim: Gains are broad across error types rather than concentrated on a single failure mode. Supported by the error-type analysis (Figures 2 and 8), with the caveat that the annotation methodology and reliability are not fully reported.

6. Limitations and Trade-offs

Pipeline Dependency on Segmentable Instances

The assumption or constraint. The HopChain pipeline fundamentally requires that images contain objects that can be detected and segmented by SAM3. Stage 2 (Section 4.2) explicitly depends on SAM3 to "generate segmentation masks and bounding boxes for candidate instances," and the paper acknowledges this as a hard constraint: "the current pipeline still depends on successful instance segmentation, so images with no detectable objects (and thus no SAM3-segmentable instances) cannot be processed and are excluded from the current synthesis workflow" (Section 7).

The consequence. This constraint excludes entire categories of images that are important for vision-language reasoning evaluation and deployment. Scientific figures with only text and abstract diagrams (e.g., the astronomy diagram in Figure 3 where the model misreads an arc), charts and plots where the "objects" are data elements rather than physical entities, document images where reasoning chains involve reading and cross-referencing text fields, and abstract or highly stylized visual content lacking natural object boundaries all fall outside the pipeline's scope. The multi-hop data is therefore structurally biased toward images containing discrete, segmentable physical objects—the types of scenes where SAM3 excels—and the training signal does not cover reasoning chains grounded in text-heavy, diagrammatic, or abstract visual content. The paper's benchmark results reflect this: benchmarks like CharXiv (chart reasoning) and InfoVQA (infographic understanding) show substantial gains (+4.10 and +2.73 on the 35B model), suggesting transfer from object-based multi-hop training to non-object visual reasoning, but these gains may represent an upper bound on what object-based training can achieve for non-object domains. If the pipeline could synthesize multi-hop queries grounded in text regions, chart elements, or diagrammatic components, the gains on document and chart benchmarks might be larger.

What evidence exists in the paper. The paper provides no analysis of what fraction of candidate images are rejected due to insufficient segmentable instances, nor does it characterize the distribution of image types in the final training pool (e.g., what proportion are natural photographs vs. diagrams vs. text-heavy documents). The image filtering prompt (Appendix B) mentions excluding images with "annotation impracticality" (e.g., massive crowds where individuals cannot be boxed or counted), but this addresses density rather than the absence of discrete objects. The paper does not compare the benchmark performance of models trained with HopChain data against a hypothetical pipeline that could synthesize multi-hop queries for non-segmentable images, making it impossible to quantify how much the segmentation dependency limits the approach's generality.

Mitigation status. The paper acknowledges this as the primary limitation in Section 7 and suggests "reducing this dependency by introducing complementary data-construction routes for images with few or no segmentable objects, while preserving the core design principle of chained visual grounding." No concrete proposal is offered, and the paper does not experiment with alternative grounding mechanisms (e.g., text-region detection for documents, chart-element extraction for plots, or keypoint-based grounding for abstract figures). This remains a completely open problem that determines the ceiling on HopChain's applicability to the full diversity of vision-language reasoning tasks.

Difficulty Estimation Cost Is Not Amortized in the Efficiency Analysis

The assumption or constraint. The HopChain pipeline includes a difficulty calibration step (Stage 4, Section 4.3) that evaluates each candidate query on a weaker model with 8 sampled responses and removes queries where the model achieves 100% accuracy. Additionally, the pipeline uses a two-stage image filtering process (Section 5.1) that involves multiple passes through Qwen3-VL-235B-A22B-Thinking (an expensive large model) and supervised fine-tuning of a smaller filtering model on the large model's outputs. The paper acknowledges: "we use a two-stage pipeline... to balance quality and throughput" (Section 5.1, Image Filtering), implying that the filtering and calibration stages are computationally non-trivial. However, these costs are reported as pipeline design decisions, not as a budget that competes with RLVR training compute.

The consequence. The headline result—that adding 6k–8k multi-hop queries improves 20/24 benchmarks—treats the synthesized data as an exogenous resource whose production cost is separate from the RLVR training budget. In practice, a practitioner deciding whether to adopt HopChain faces a total cost of (image filtering + instance segmentation + query generation + human verification + difficulty calibration + RLVR training), and the synthesis stages may dominate. The image filtering alone requires running Qwen3-VL-235B-A22B-Thinking on an initial subset, fine-tuning Qwen3-VL-30B-A3B-Thinking on those outputs, running the smaller model over all remaining images, and then re-running the large model on the coarse-screened subset. The query generation stage invokes Qwen3-VL-235B-A22B-Thinking (with a 26-page prompt) for each combination of 3–6 instances. The human verification stage requires four annotators per query, each independently solving the full multi-hop reasoning chain—a cognitively demanding task for questions that are, by design, challenging even for strong models. The difficulty calibration runs 8 samples per query on a weaker model. None of these costs are quantified in GPU-hours, FLOPs, human-annotator-hours, or wall-clock time, and they are not compared against the alternative of simply training with more original RLVR data (which has zero synthesis cost). A practitioner cannot determine from the paper whether HopChain's end-to-end cost (synthesis + training) is competitive with simply spending the same total compute on additional RLVR steps with original data.

What evidence exists in the paper. The paper reports the final dataset size (6k–8k queries) and the RLVR training configuration (1000 gradient steps at mini-batch size 64 for the 35B model, 800 steps at mini-batch size 128 for the 397B model), but provides no numbers for synthesis cost. The human verification stage is described qualitatively ("four annotators from our data annotation team independently solve it") without time estimates, annotator qualification details, or per-query cost. The difficulty calibration uses 8 samples × 6k–8k queries = 48k–64k model evaluations on a "weaker model," but the model identity and inference cost are unspecified. The image filtering cost depends on the size of the raw image pool, which is not reported, and on the throughput of the two-stage distillation pipeline, which is not characterized. The paper's central efficiency claim—the ~4× compute reduction over best-of-N in the reference example—has no analog here; there is no statement like "HopChain-synthesized data achieves X% of the benchmark improvement of an equivalent compute expenditure on original RLVR data."

Mitigation status. The paper does not address the synthesis cost as a limitation, does not propose cheaper alternatives to any pipeline stage, and does not include a cost analysis in the experiments or appendix. The suggestion in Section 7 to reduce the segmentation dependency would partially address synthesis cost (by reducing the number of pipeline stages or enabling a wider image pool), but the core issue—that the synthesis pipeline's total cost is uncharacterized and unamortized—is not acknowledged. A compute-matched comparison where the original RLVR baseline receives additional training steps equivalent to the synthesis cost would directly address this gap, but no such experiment is reported or proposed.

No Direct Evidence That Visual Grounding Improves—Only That Benchmark Accuracy Improves

The assumption or constraint. The paper's central mechanistic claim is that multi-hop data improves vision-language reasoning by strengthening "visual grounding"—the model's ability to repeatedly seek and verify visual evidence throughout a reasoning chain. Section 3 argues that standard RLVR data fails to "structurally force the model to seek visual evidence at each step of long-CoT reasoning," and Section 4.1 defines the multi-hop structure specifically to enforce this behavior. The paper hypothesizes that benchmark gains arise because the model learns to re-ground more reliably at intermediate steps, reducing the cascading perception errors identified in the failure analysis.

The consequence. This mechanistic claim is supported indirectly—through the benchmark-level results (Tables 1 and 2), the hop-structure ablation (Figure 5), the error-type analysis (Figures 2 and 8), and the response-length analysis (Figure 6)—but none of these measure visual grounding directly. The benchmark improvements could arise from mechanisms other than improved intermediate visual grounding: the multi-hop data might teach the model to produce longer, more careful reasoning chains in general (regardless of whether those chains actually re-examine the image), or it might improve the model's ability to perform the arithmetic and conditional logic operations that multi-hop queries require (computing sums, following if-then branches), or it might simply expose the model to a wider variety of linguistic formulations of spatial and relational reasoning that transfer to benchmark questions. The error-type analysis shows that corrected errors span perception, reasoning, knowledge, and hallucination categories (Figure 2b), which is consistent with improved visual grounding but also consistent with a general improvement in reasoning thoroughness or chain-of-thought quality that masks perception errors through better downstream compensation rather than preventing them. Without a direct measurement of whether the model actually looks at the right image regions, extracts correct perceptual information at intermediate steps, and uses that information to guide subsequent reasoning—as opposed to producing longer chains that happen to reach correct answers more often—the paper's central mechanistic claim remains a plausible interpretation supported by circumstantial evidence rather than a demonstrated fact.

What evidence exists in the paper. The paper does not include any visual grounding probe or per-step accuracy measurement. The qualitative examples in Figure 3 show specific cases where multi-hop training corrects perception errors (e.g., correctly counting ladybird dots), but these are cherry-picked illustrations rather than a systematic evaluation of intermediate perceptual accuracy. The error-type analysis (Figures 2 and 8) classifies final errors by their primary cause, but does not show per-step correctness rates for intermediate hops on benchmark questions. A direct test would evaluate the model's intermediate outputs on questions explicitly designed to require reporting perceptual observations at specific steps—for example, asking the model to count objects, read text, or identify spatial relationships and grading the accuracy of those intermediate reports independently of the final answer. The absence of such a test means the paper cannot distinguish between "the model perceives more accurately" and "the model reasons better from similarly noisy perceptions."

Mitigation status. The paper does not acknowledge this as a limitation or propose experiments to directly measure visual grounding improvement. The error-type analysis is the closest the paper comes to probing intermediate behavior, but it operates at the level of final-error categorization rather than per-step accuracy. Future work could address this gap with targeted visual grounding benchmarks that require the model to output intermediate perceptual observations (as is partially required by some of the multi-hop queries themselves, where hop structure is explicit), or with attention-based analyses that measure whether the model's visual attention patterns change under multi-hop training to show more frequent or more targeted image re-inspection during long reasoning chains.

Single Model Family and Pre-Final Data Recipe Limit Reproducibility and Generality

The assumption or constraint. All experiments use Qwen3.5 models (Qwen3.5-35B-A3B and Qwen3.5-397B-A17B) with a pre-final internal version of the SFT and original RLVR data recipes. The paper states: "the SFT data and the original RLVR data used in these experiments are pre-final internal versions, rather than the final official Qwen3.5 data recipe" (Section 5.1). The multi-hop data synthesis pipeline uses Qwen3-VL-235B-A22B-Thinking for category identification (Stage 1), query generation (Stage 3), and as the large model in the two-stage image filtering pipeline, and uses Qwen3-VL-30B-A3B-Thinking as the smaller filtering model. The paper does not report results with any non-Qwen model family, nor does it use a different VLM for any pipeline stage.

The consequence. This creates two distinct generalization concerns. First, the RLVR training results may not transfer to other model families (e.g., InternVL, LLaVA, GPT-4V, Gemini) or even to the final Qwen3.5 release with its official data recipe. The Qwen3.5 architecture, pretraining data distribution, and SFT recipe may interact with the multi-hop data in ways that are specific to this model family—for example, Qwen3.5 models may have particular strengths or weaknesses in spatial reasoning, text reading, or instruction following that make them more or less responsive to multi-hop training than other architectures. Second, the synthesis pipeline itself may be biased by its exclusive reliance on Qwen models. The category identification, image filtering, and query generation stages all use Qwen3-VL-235B-A22B-Thinking, which means the synthesized queries reflect that model's perceptual strengths, weaknesses, and biases. If Qwen3-VL-235B-A22B-Thinking systematically under-identifies certain object categories, over-identifies others, or produces queries with particular linguistic patterns, the resulting multi-hop data will inherit those biases. A practitioner using a different model family for RLVR training would be training on data synthesized by a Qwen model, introducing a potential mismatch between the data's implicit assumptions (about what constitutes an unambiguous spatial description, what difficulty level is appropriate, what visual features are easily perceptible) and the target model's capabilities.

What evidence exists in the paper. The paper provides no cross-model-family experiments, either for the RLVR training (e.g., applying the same multi-hop data to fine-tune a non-Qwen VLM) or for the synthesis pipeline (e.g., using a different VLM for query generation and comparing the resulting data quality). The two Qwen3.5 model scales (35B and 397B) provide evidence that the approach works at different parameter counts within the same family, but this is evidence about scale generalization, not architectural or data-recipe generalization. The paper's choice of Qwen models for all pipeline stages is pragmatic (the authors are from the Qwen Team at Alibaba) but limits the evidence that HopChain is a general-purpose framework rather than a Qwen-specific optimization.

Mitigation status. The paper does not acknowledge the single-model-family limitation or the pipeline's dependence on Qwen models for synthesis. The claim that HopChain is a "scalable framework" (title, abstract, Section 7) implies generality, but the evidence supports this claim only within the Qwen ecosystem. The paper's framing of the multi-hop data as "benchmark-agnostic" and "not tailored to any particular downstream benchmark" addresses evaluation generality but not model or pipeline generality. Reproducing the pipeline with non-Qwen models—or at minimum, testing the RLVR training results on a non-Qwen base model—would substantially strengthen the generality claim.

Human Verification Bottleneck Constrains Scalability and Practical Deployment

The assumption or constraint. Stage 4 of the pipeline (Section 4.3) requires "four annotators from our data annotation team [to] independently solve" each candidate query, with queries retained only if "all four must agree" on the final numerical answer. This is a stringent quality-control mechanism that ensures ground-truth answers are correct and queries are unambiguous, but it is fundamentally a manual, human-dependent step that does not scale linearly with data volume. The paper does not specify the total number of candidate queries that enter Stage 4 (only that 6k–8k survive to form the final dataset), the rejection rate at this stage, the time or cost per annotation, or whether annotators require specialized training.

The consequence. The four-annotator requirement creates a practical bottleneck for any deployment of HopChain beyond the scale reported in the paper. If a practitioner wants to synthesize multi-hop data from a substantially larger image corpus (e.g., millions of images covering diverse domains), the human verification cost would scale proportionally, potentially becoming the dominant cost of the entire pipeline. The paper's multi-hop queries are designed to be difficult—they require solving 5–6 hop reasoning chains with precise numerical answers—which means annotation is cognitively demanding and error-prone. Annotator fatigue, varying skill levels, and the inherent difficulty of the queries could lead to high rejection rates, further increasing the per-accepted-query cost. The paper's difficulty calibration (Section 4.3) filters out queries where a weaker model achieves 100% accuracy, but the human verification step occurs before difficulty calibration—meaning annotator effort is spent on queries that are subsequently discarded as too easy. The pipeline does not use model predictions to pre-filter or prioritize queries for human review, which would reduce the human verification burden.

Additionally, the requirement that annotators solve the full multi-hop chain independently means they must possess the visual reasoning skills to execute the same chained perception and logic operations that the training data is designed to teach models. This raises a subtle but important concern: the annotators' ability to consistently solve these queries is what guarantees ground-truth correctness, but if the queries are genuinely difficult (as the difficulty calibration suggests—the fact that a weaker model gets some wrong means they are not trivial), annotator errors could introduce incorrect ground-truth answers that would provide misleading RLVR reward signals. The paper's four-annotator agreement requirement partially mitigates this (independent errors are unlikely to produce the same wrong answer), but does not eliminate it for queries where a common misinterpretation leads multiple annotators to the same incorrect number.

What evidence exists in the paper. The paper provides no data on human verification cost, rejection rates, annotator agreement patterns (beyond the binary "all four agree" criterion), or annotator qualification and training. Figure 4 shows two examples of synthesized queries with their hop-by-hop ground-truth answers, illustrating the annotation task's complexity, but there is no analysis of how often annotators disagreed, what types of queries caused disagreement, or whether annotator agreement correlates with query difficulty or benchmark relevance. The paper does not report whether annotators were the same individuals for all queries or rotated, whether they had access to the original image only (matching model conditions) or to the instance patches (which the query generator saw), or whether any automated checks (e.g., verifying that the final answer is arithmetically consistent with the hop-level answers) were used to catch annotation errors.

Mitigation status. The paper does not acknowledge human verification cost as a scalability limitation or propose automation strategies (e.g., using a strong VLM to verify answers, using programmatic checks for internal consistency, or reducing annotator count through majority voting rather than unanimous agreement). The future work suggestion in Section 7 focuses on reducing the segmentation dependency, not on reducing human verification cost. A pipeline that could automatically verify multi-hop query answers—for example, by executing the hop-by-hop reasoning in a structured format and checking each intermediate step against the ground-truth instance annotations from Stage 2—would dramatically improve scalability, but this would require the pipeline to have access to ground-truth intermediate answers (which the human annotators currently provide implicitly by solving the queries). The structural definition of multi-hop queries (logically dependent hops, deterministic numerical answers) suggests that automated verification might be possible for some query types, but the paper does not explore this direction.

Sparse Binary Reward May Underserve the Training Objective for Partially Correct Reasoning Chains

The assumption or constraint. The paper uses standard RLVR with a binary reward function (Equation 2, Section 2.1): the model receives reward 1.0 if its final answer matches the ground-truth number, and 0.0 otherwise. The paper argues that this sparse signal is informative because "obtaining the correct final number usually also requires the intermediate reasoning chain to be correct" (Section 4.1), due to the logical dependency among hops. The SAPO objective (Equation 3, Section 2.2) uses group-based advantage estimation where advantages are computed relative to the mean reward of 16 independently sampled responses per query.

The consequence. The binary reward's informativeness depends on the tightness of coupling between intermediate correctness and final-answer correctness, which the paper asserts but does not directly measure. There are two failure modes for this coupling. First, a model might execute most hops correctly but make a single arithmetic error at the final computation step, receiving reward 0 despite demonstrating strong visual grounding throughout the chain—the binary reward treats this response identically to one that hallucinated every intermediate answer, providing no gradient that distinguishes near-misses from complete failures. Second, and more problematically, a model might make a perceptual error at an early hop, correctly execute all subsequent reasoning from that faulty premise, and arrive at a wrong final answer—the binary reward again provides 0, with no signal about where in the chain the error occurred. In both cases, the SAPO advantage (Equation 4) is computed from the group's reward distribution, meaning that a response with a near-miss error receives the same negative advantage as a response with cascading perception failures throughout, and a response that is correct in all but the final arithmetic step receives the same zero reward as a completely incorrect response. This collapses the rich error signal that multi-hop queries are designed to expose into a single bit, potentially discarding information that could accelerate learning.

The paper's claim that logical dependency makes the final answer a reliable proxy for chain correctness is plausible for queries where each hop's output is a necessary input to the next, but the strength of this coupling depends on query design. If a query includes a conditional branch (e.g., "if the object is red, add 5; otherwise, add 2"), a perceptual error that causes the model to take the wrong branch will propagate to a wrong final answer, so the coupling is tight. But if a query includes a hop whose output has only a small influence on the final computation (e.g., a count that is multiplied by a small constant and added to a large base number), an error at that hop might not change the final answer, creating a false positive (reward 1 for an incorrect chain). The paper's query generation prompt (Appendix A) includes constraints to avoid such decoupling (balanced conditional outcomes, operations where all hops contribute meaningfully to the final number), but the effectiveness of these constraints is not evaluated empirically.

What evidence exists in the paper. The paper's difficulty coverage analysis (Figure 7) shows that queries in the Partially Correct regime (1–7 correct out of 8 samples) are common for both model scales, indicating that the model's success on a given query is stochastic rather than deterministic. This means that on any given query, some sampled responses are correct and some are incorrect, providing non-zero advantages for SAPO. However, this does not address the question of whether the binary reward is sufficiently informative—it shows that there is a signal, but not whether a denser reward (e.g., per-hop correctness, partial credit for near-correct chains) would provide a stronger or faster training signal. The paper does not report learning curves, training dynamics, or per-step accuracy metrics that would reveal whether the model makes systematic progress on intermediate hops before improving final-answer accuracy, or whether improvement appears simultaneously at all hops (which would be consistent with a sparse signal that only reinforces entire correct chains).

The paper also does not analyze the reward distribution during training—what fraction of sampled responses receive reward 1 vs. 0, how this fraction evolves over gradient steps, and whether the advantage estimates remain informative throughout training or saturate early. The SAPO formulation uses temperature-controlled soft gates (Equation 5) to stabilize training when advantages are noisy, but if the reward signal is excessively sparse (e.g., very few correct responses in a group of 16), the advantages may still be unreliable despite the soft gate.

Mitigation status. The paper does not discuss the adequacy of binary rewards for multi-hop training as a limitation or propose alternative reward structures. The choice of binary RLVR reward is inherited from the standard RLVR framework (Section 2.1) and is motivated by the verifiability requirement—numerical answers are exactly checkable, making binary rewards trivial to implement. The paper's structural design (logically dependent hops) is intended to make the binary reward sufficiently informative, but the paper does not validate this design choice empirically (e.g., by comparing training with binary rewards against training with per-hop rewards on a small subset of queries where intermediate answers are annotated). Future work could explore hybrid reward structures that provide partial credit for partially correct chains (e.g., reward proportional to the number of correct hops, or reward for reaching the correct intermediate answer at a designated checkpoint hop) while still using only verifiable signals, or could use the multi-hop data as a testbed for comparing the efficiency of sparse vs. dense reward RLVR for vision-language reasoning.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper changes the conversation about vision-language model training by shifting the focus from what the model is trained on (more data, harder data, benchmark-specific data) to what the training data structurally requires of the model. This is not a paradigm shift in the sense of introducing a new architecture, a new learning algorithm, or a new theoretical framework—it is a reframing of the data synthesis problem with practical consequences that are broader than an incremental improvement.

The conceptual shift: from content to structure. Prior data synthesis work for VLMs has largely been content-driven: generate captions that look like benchmark captions (ShareGPT4V, Chen et al., 2023), generate instruction-following examples that resemble deployment queries (Self-Instruct, Wang et al., 2023; Alpaca, Taori et al., 2023), or curate domain-specific training sets that match target task distributions. HopChain argues that for long chain-of-thought vision-language reasoning, content similarity to benchmarks is not the right objective. Instead, what matters is whether the training data structurally enforces the behavior that fails during long-CoT reasoning—in this case, repeated visual re-grounding at each reasoning step. The paper's core empirical finding—that benchmark-agnostic multi-hop data transfers broadly across four benchmark families including video, while truncated variants of the same data lose this transfer—makes this structural argument concrete. If content similarity to benchmarks were the mechanism, single-hop and half-multi-hop variants (which contain the same types of perceptual operations on the same images) should show similar transfer; they don't. The structural property—logical dependency among hops—is what drives generalization.

This reframing has methodological implications for how the field thinks about synthetic data for foundation model training. Rather than asking "does this synthetic data look like the evaluation data?," the relevant question becomes "does this synthetic data force the model to practice a capability that is a bottleneck across many evaluation settings?" This connects to a broader principle from curriculum learning and reinforcement learning: tasks that structurally forbid shortcuts and require step-by-step correctness can produce more robust learning than tasks that are merely content-difficult but permit shortcut solutions. The paper provides what is, to our knowledge, the first large-scale empirical demonstration of this principle for vision-language reasoning with RLVR.

Reconciling prior contradictions. The paper's error analysis and training approach help reconcile apparently contradictory findings in prior work about whether VLMs can self-correct and whether RLVR improves visual grounding. Huang et al. (2023) argued that LLMs cannot self-correct reasoning; recent VLM analyses have found that RLVR primarily refines reasoning alignment rather than strengthening visual perception (Li et al., 2026), and that RL-finetuned models can still exhibit weak visual grounding (Zhao et al., 2026). The paper's diagnosis explains why: if standard RLVR data does not structurally force repeated visual grounding, then RLVR training will optimize what the data rewards—which is final-answer correctness via whatever strategy works on the training distribution, including frontloading perception and reasoning in language space. The model learns to produce correct answers on the training distribution but doesn't learn to ground intermediates, so when deployed on tasks that genuinely require intermediate visual evidence, it fails. The multi-hop data changes this by making intermediate grounding a necessary condition for final-answer correctness, creating a training distribution where the strategy that works (careful step-by-step visual re-examination) is exactly the capability that transfers. The paper doesn't claim that prior work was wrong—RLVR on standard data does improve reasoning—but rather that it was incomplete: it leaves visual grounding unimproved because standard data doesn't reward it.

Redirection of research effort. The paper's findings redirect research attention in several ways. First, they argue against the default assumption that scaling up existing RLVR data (more questions, more training steps, more model parameters) will solve long-CoT vision-language failures—the training signal needs to be structurally different, not just larger. This makes some research directions less attractive: efforts focused purely on data volume scaling for VLM reasoning, or on increasingly sophisticated RL algorithms applied to the same standard training data, may see diminishing returns if the data structure remains unchanged. Second, they make data synthesis for capability-targeted training (rather than task-targeted training) a more attractive direction. The paper shows that constructing a proxy task—multi-hop instance-chained QA—that exercises a specific fundamental capability (sustained visual grounding) yields transfer that is broader than training on any single benchmark family. This suggests a research program where different proxy tasks are designed to exercise different VLM bottlenecks (e.g., tasks that force temporal grounding for video, tasks that force cross-modal alignment for audio-visual reasoning, tasks that force fine-grained spatial reasoning for robotics), with each proxy task acting as a "capability module" that can be mixed into RLVR training. Third, they elevate the status of data structure as a research object on par with model architecture and training algorithms—the paper's careful formalization of multi-hop vision-language reasoning (two hop types, three structural conditions) provides a template for how to design data with targeted structural properties and verify that the data actually satisfies them.

Relation to the pretraining-vs-inference compute tradeoff. In the reference example paper, a key contribution was the FLOPs-matched comparison showing that test-time compute with a smaller model can sometimes outperform a much larger pretrained model. HopChain addresses a different axis—the training data composition rather than the training-vs-inference allocation—but there is a conceptual parallel. Both papers argue that a resource (inference compute, training data structure) that is typically treated as secondary or uniform can, when optimized, yield gains that are competitive with scaling the primary resource (model parameters, data volume). In both cases, the bottleneck is not the absolute amount of resource but how it is targeted: compute-optimal test-time scaling targets difficulty-appropriate strategies, and HopChain targets the structural property (chained visual grounding) that standard training data lacks. The connection suggests a broader principle: foundation model training pipelines have multiple degrees of freedom (data content, data structure, model architecture, RL algorithm, inference strategy) that are typically optimized independently or set to defaults, and systematic optimization of the less-explored degrees of freedom can yield substantial gains.

What the paper does not change. It's important to be precise about the magnitude of the shift. The paper does not introduce a new paradigm for VLM training—RLVR with SAPO, the model architecture, and the overall training recipe are unchanged. It does not claim that multi-hop data replaces original RLVR data (the experiments always use a mixture). It does not solve the hard-problem ceiling (Section 6 of the prior analysis documents that the hardest questions—difficulty bin 5—show near-zero improvement regardless of training data, and HopChain doesn't change this for fundamentally out-of-capability problems). And it does not eliminate the need for human verification or instance segmentation, which remain scalability bottlenecks. The contribution is a demonstrably effective data synthesis strategy that addresses a specific, well-documented failure mode, with transfer that is broader than what task-targeted synthetic data typically achieves. This is a meaningful advance but not a comprehensive solution to VLM reasoning.

Follow-Up Research This Work Enables

Automated multi-hop query verification to eliminate the human annotation bottleneck. The most immediate scalability constraint in the HopChain pipeline is the four-annotator human verification stage (Stage 4). The paper shows that 6k–8k queries are sufficient for broad benchmark improvements, but scaling to larger image corpora or more diverse visual domains requires reducing or removing human dependence. A direct follow-up would test whether the structural properties of HopChain queries—logically dependent hops, deterministic numerical answers, explicit per-hop ground-truth answers in the synthesis output (Figure 4)—enable automated verification. Specifically, since the query generator (Qwen3-VL-235B-A22B-Thinking) produces structured reasoning_hops with expected intermediate outputs, and the synthesis pipeline has access to the original image plus instance-level spatial metadata from Stage 2, one could implement a programmatic verifier that: (a) checks that the final answer is arithmetically consistent with the hop-level answers, (b) verifies that instance references in each hop uniquely identify a single instance from the segmented set, and (c) for a subset of hop types (e.g., "count objects of color X in region Y"), executes the perception operation using the instance metadata and compares against the query generator's expected output. The research question is: what fraction of human-verified queries would survive automated verification, and do models trained on automatically-verified data achieve the same benchmark improvements as those trained on human-verified data? If automated verification rejects queries that humans would accept (false negatives), the training dataset shrinks; if it accepts queries that humans would reject (false positives), the RLVR reward signal becomes noisy. The paper's difficulty calibration (Stage 4) already uses model-based evaluation to filter out easy queries, so an extension that replaces human verification with model+programmatic verification for correctness is a natural next step.

Per-step visual grounding probes to directly measure the hypothesized mechanism. The paper's central mechanistic claim—that multi-hop data improves vision-language reasoning by strengthening intermediate visual grounding—is supported indirectly through benchmark accuracy and error-type distributions but never measured directly. A targeted follow-up would construct a visual grounding probe dataset where, for each question, the model is required to output explicit intermediate perceptual observations at designated steps, and those intermediate observations are graded independently of the final answer. For example, given the HopChain query in Figure 4 ("Start by locating the black sheep toy... count the number of white eyes visible on this sheep"), a probe would ask: "Step 1: How many white eyes are visible on the black sheep? Step 2: Is there readable text on the background paper? ..." and compare the model's intermediate answers against the human-verified ground truth at each hop (which the HopChain pipeline already annotates). The experiment would compare intermediate-hop accuracy between RLVR w/o Multi-Hop and RLVR w/ Multi-Hop models on both in-distribution queries (held-out HopChain queries) and out-of-distribution queries (existing benchmarks that require intermediate perception). The key prediction: if multi-hop training improves visual grounding, intermediate-hop accuracy should improve even on questions where the final answer was already correct (suggesting that the baseline model sometimes reaches correct answers despite intermediate perceptual errors, and multi-hop training reduces those errors). If intermediate-hop accuracy does not improve despite final-answer accuracy gains, the mechanism is not improved perception but improved higher-level reasoning or better error recovery. This experiment would directly test the paper's central hypothesis and, if negative, would refine our understanding of what multi-hop training actually changes.

Hop-type disentanglement to identify which structural properties drive transfer. The paper defines two complementary hop types—perception-level hops (switching between single-object and multi-object perception) and instance-chain hops (A → B → C dependency chains)—and requires every query to combine both. The hop-structure ablation (Figure 5) varies chain length but not chain composition, leaving open whether one hop type is sufficient or both are necessary. A follow-up would synthesize three variants of the multi-hop data, all matched for total hop count and image distribution: (a) queries with only perception-level hops (switching between L1 and L2 on the same instance or independently selected instances without dependency chains), (b) queries with only instance-chain hops (A → B → C chains but with the same perception level—e.g., always doing single-object attribute extraction—at each hop), and (c) the full HopChain design with both hop types intertwined. The experiment would compare benchmark improvements from adding each variant to RLVR training. If one hop type drives most of the transfer, the formal definition can be simplified, reducing the synthesis prompt complexity and potentially increasing query yield. If both are necessary, it validates the paper's claim that the two dimensions are complementary and that vision-language reasoning requires both perception-mode switching and instance dependency tracking. An additional experiment could systematically vary the degree of perceptual difficulty within hops (e.g., easy perception: counting large, unobstructed objects; hard perception: reading small, partially occluded text) and measure whether perception difficulty in training queries correlates with perception error reduction on benchmarks.

Cross-model-family validation to test whether the approach generalizes beyond Qwen architectures. All experiments in the paper use Qwen3.5 models for RLVR training and Qwen3-VL models for all synthesis stages. This creates a potential confound: the synthetic data's properties (what constitutes an unambiguous spatial description, what difficulty level is appropriate, what visual features are perceptually salient) reflect Qwen-specific biases, and RLVR training on a Qwen model with Qwen-synthesized data may benefit from architectural or representational alignment that would not transfer to other model families. A direct stress-test would apply the exact same HopChain-synthesized multi-hop data (already generated and human-verified) to RLVR training of a non-Qwen VLM—for example, an InternVL or LLaVA variant—using the same SAPO algorithm and training configuration. If 20/24 benchmarks improve on the non-Qwen model, the approach is genuinely architecture-agnostic and the synthetic data captures a universal property of vision-language reasoning. If gains are substantially smaller or restricted to fewer benchmarks, the approach is partially Qwen-specific, and the synthesis pipeline may need to be adapted (e.g., using the target model family's VLM for query generation, or calibrating difficulty on the target model rather than a Qwen model). An even stronger test would use a completely different model family for synthesis (e.g., Gemini or GPT-4V for category identification and query generation) and train a Qwen model on the resulting data—this would test whether the multi-hop structure itself, independent of the synthesizer's identity, is what drives transfer.

Multi-hop data for video and other modalities. The paper's most surprising result is the transfer from image-synthesized multi-hop data to video benchmarks (5/6 improve on both model scales). This suggests that sustained visual grounding across extended reasoning chains is a capability that transfers across the static-to-temporal boundary, but the paper does not synthesize any multi-hop data from actual video frames. A natural extension would apply the HopChain pipeline to video keyframes: Stage 1 identifies semantic categories in sampled frames, Stage 2 segments instances across frames (SAM3 supports video segmentation), and Stage 3 generates multi-hop queries that chain across temporal hops (e.g., "identify the object that enters from the left in frame 1, track it to frame 5, count the objects it passes, multiply by the frame number where it first touches the right edge"). Training on such temporally-chained queries might yield even larger video benchmark gains than the current image-only transfer, and would test whether the structural principle (logically dependent hops requiring repeated grounding) scales to the temporal dimension. A parallel extension to document understanding would synthesize multi-hop queries grounded in text regions rather than segmentable objects—e.g., "find the title in the top section, identify the footnote referenced by the third sentence, count the number of tables that contain the word from that footnote's first line"—using OCR bounding boxes or layout analysis instead of SAM3 for instance localization. This would address the pipeline's current segmentation dependency (which excludes text-heavy and diagrammatic images) and directly target the document understanding benchmarks (CharXiv, DocVQA, InfoVQA) where the paper already shows strong transfer but where a dedicated document-grounded synthesis pipeline might yield further gains.

Compute-matched comparison against scaling original RLVR data. The paper's core argument is that multi-hop data is structurally different from and complementary to original RLVR data, and that gains arise specifically from this structural difference rather than from simply having more training data. The current experiments add multi-hop data on top of original data without controlling for total training data volume—the RLVR w/ Multi-Hop condition receives original RLVR data plus 6k–8k multi-hop queries, while RLVR w/o Multi-Hop receives only original RLVR data. A fairer test would compare: (a) RLVR w/ Multi-Hop (original data + 6k–8k multi-hop queries, the current condition), (b) RLVR w/ More Original Data (original data + an additional 6k–8k original RLVR queries, matched for query count), and (c) RLVR w/ More Training Steps (original data only, but trained for additional gradient steps to match the total compute of condition a). If condition (b) or (c) matches or exceeds the multi-hop gains on most benchmarks, the benefit comes from more data or more training, not from the multi-hop structure specifically. If the multi-hop condition outperforms both compute-matched baselines, the structural argument is validated. This experiment is straightforward to implement (it only requires additional original RLVR queries or extended training runs) and would substantially strengthen the paper's central claim about structural necessity.

Difficulty calibration during training rather than pre-training. The paper filters out queries where a weaker model achieves 100% accuracy before RLVR training begins, but does not adjust the query set during training. A model that initially finds a query hard (Partially Correct) may learn to solve it perfectly after a few hundred gradient steps, at which point the query provides no further learning signal (since all responses get reward 1.0, advantages are zero). A dynamic follow-up would periodically re-evaluate the multi-hop query set on the current model checkpoint and remove queries that have become saturated (e.g., accuracy above a threshold like 95%), replacing them with fresh queries synthesized from new images or with held-out queries from the original synthesis run. This is analogous to automatic curriculum learning, where the training distribution adapts to the model's current capability. The research question is whether dynamic difficulty calibration improves sample efficiency (faster benchmark improvement per gradient step) or final performance (higher asymptote by continuously presenting queries at the frontier of the model's ability). The paper's difficulty coverage data (Figure 7) shows that 40% of queries are All Correct for the 397B model even before training, suggesting substantial headroom for difficulty-based curriculum. A negative result—dynamic calibration doesn't help or hurts—would suggest that the benefit of multi-hop data comes from the structural property itself (which persists even when queries become easy) rather than from providing queries at the right difficulty level.

Practical Applications and Downstream Use Cases

On-device and edge deployment of smaller VLMs with long-CoT reasoning. The paper's results on Qwen3.5-35B-A3B show that a relatively small model (3B activated parameters) can achieve broad benchmark improvements from multi-hop data without increasing model size or inference cost. For deployment scenarios where a large model (397B total parameters) is infeasible—mobile devices, embedded systems, real-time applications—the multi-hop training approach offers a way to improve long-CoT reasoning quality at fixed model size. The 35B model with multi-hop data improves on benchmarks that require sustained visual attention (e.g., EMMA mini: 53.00 → 58.00, +5.00; CharXiv: 69.00 → 73.10, +4.10; ERQA: 48.25 → 51.38, +3.13), suggesting that tasks like reading charts, answering questions about complex real-world images, and understanding documents become more reliable. The training cost is primarily in data synthesis (the HopChain pipeline) and RLVR training (1000 gradient steps), both of which are one-time costs amortized over deployment queries. The per-query inference cost is unchanged—the model produces the same type of chain-of-thought response at the same parameter count—so the deployment benefit is improved accuracy at zero additional inference latency or memory.

Cost-efficient batch inference for document and chart understanding at scale. The paper's strongest absolute gains are on benchmarks requiring fine-grained visual-textual reasoning: CharXiv (+4.10 on 35B, +2.60 on 397B), InfoVQA (+2.73 on 35B, +1.37 on 397B), and ERQA (+3.13 on 35B). These gains are directly relevant to enterprise document processing pipelines—invoice parsing, form understanding, report generation from charts, and scientific figure interpretation—where accuracy on individual documents compounds across thousands or millions of documents. In such settings, even modest per-document accuracy improvements (2–4 percentage points) translate to thousands fewer errors requiring human review. The multi-hop training data is synthesized once and applied via RLVR fine-tuning of an existing VLM; the resulting model can be deployed in standard inference pipelines without architectural changes. The primary practical barrier is the initial synthesis cost (human verification, model-based filtering, SAM3 segmentation), but for organizations already investing in VLM fine-tuning for document understanding, the incremental cost of adding HopChain-synthesized data to the RLVR training mixture may be justified by the downstream error reduction. The paper does not provide cost numbers, so practitioners would need to estimate their specific return on investment based on document volume, error cost, and available annotation resources for the human verification stage.

Self-improvement and iterative data generation loops for VLMs. The paper demonstrates that a VLM (Qwen3-VL-235B-A22B-Thinking) can synthesize training data that, when used for RLVR, improves a different VLM (Qwen3.5-35B-A3B or Qwen3.5-397B-A17B). This is a form of cross-model data generation that could be turned into a self-improvement loop: train a VLM with HopChain-synthesized data, use the improved VLM to synthesize higher-quality multi-hop queries (with better category identification, more accurate spatial descriptions, more reliable hypothetical answers), use those queries to train the next iteration, and repeat. The paper's difficulty calibration (Stage 4) already uses model-based evaluation to filter queries, which is a form of model-in-the-loop data curation. Extending this to full iterative self-improvement would require: (a) demonstrating that the improved model produces higher-quality or more diverse multi-hop queries than the original synthesizer (Qwen3-VL-235B-A22B-Thinking), (b) measuring whether iterative training converges or diverges (does the data distribution collapse to a narrow set of query types that the model finds easy?), and (c) characterizing the total compute cost of multiple synthesis-training cycles versus a single cycle with more data. The paper's negative result with ReST^EM in the reference example (Appendix K in that paper, where RL-based self-improvement degraded revision model performance) suggests that naive iterative loops can backfire, making careful evaluation of self-improvement stability important. However, the structural constraints in HopChain queries (logical dependency, both hop types, numerical answers) may provide a regularizing effect that prevents the distributional collapse observed in less constrained self-improvement settings.

Benchmark development and diagnostic evaluation using the multi-hop framework. Beyond training, the paper's formalization of multi-hop vision-language reasoning (two hop types, three structural conditions) provides a taxonomy for constructing diagnostic benchmarks that probe specific VLM capabilities. Current VLM benchmarks typically test end-to-end accuracy on tasks that may require multiple reasoning steps, but rarely provide per-step diagnostic information. A diagnostic benchmark built on the HopChain framework would present questions with explicit hop structure, require the model to output intermediate answers at designated checkpoints, and provide per-hop accuracy metrics. This would enable researchers to pinpoint where in the reasoning chain different models fail—is it at the first perception-level hop? At the instance-chain transition? At the final arithmetic step?—rather than observing only binary correct/incorrect outcomes. The paper's error-type analysis (Figures 2 and 8) demonstrates the value of such decomposition, but does so post-hoc through human annotation of final errors. A benchmark that bakes this decomposition into the evaluation protocol would make such analyses reproducible, scalable, and comparable across models. The HopChain synthesis pipeline could be used to generate such benchmark queries at scale, since it already produces structured reasoning_hops with per-hop expected answers, and the human verification stage (Stage 4) already validates these answers. The main additional requirement would be designing the evaluation interface to collect model outputs at specified intermediate checkpoints rather than only the final answer.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

REASONING GYM: Reasoning Environments for Reinforcement Learning with Verifiable Rewards2025· reasoning← LLM-judged similar
- Coffee-Gym: An Environment for Evaluating and Improving Natural Language Feedback on Erroneous Code2024· rl-training← LLM-judged similar
- Llama-Nemotron: Efficient Reasoning Models2025· reasoning← in-domain predecessor
- Lost in the Noise: How Reasoning Models Fail with Contextual Distractors2026· reasoning← similar topic
- Multiplex Thinking: Reasoning via Token-wise Branch-and-Merge2026· reasoning← similar topic
- Distribution-Aligned Sequence Distillation for Superior Long-CoT Reasoning2026· reasoning← similar topic
- Visual Generation Unlocks Human-Like Reasoning through Multimodal World Models2026· reasoning← similar topic
- On the Optimal Reasoning Length for RL-Trained Language Models2026· reasoning← similar topic
- Understanding Reasoning in LLMs through Strategic Information Allocation under Uncertainty2026· reasoning← similar topic
- LongCat-Flash-Prover: Advancing Native Formal Reasoning via Agentic Tool-Integrated Reinforcement Learning2026· reasoning← similar topic
- Rethinking Generalization in Reasoning SFT: A Conditional Analysis on Optimization, Data, and Model Capability2026· reasoning← similar topic
- Towards Autonomous Mechanistic Reasoning in Virtual Cells2026· reasoning← similar topic
- General365: Benchmarking General Reasoning in Large Language Models Across Diverse and Challenging Tasks2026· reasoning← similar topic
- Learning from Language Feedback via Variational Policy Distillation2026· reasoning← similar topic
- ETCHR: Editing To Clarify and Harness Reasoning2026· reasoning← similar topic
- rStar-Math: Small LLMs Can Master Math Reasoning with Self-Evolved Deep Thinking2025· reasoning← similar topic
- Learning Adaptive Parallel Reasoning with Language Models2025· reasoning← similar topic
- DianJin-R1: Evaluating and Enhancing Financial Reasoning in Large Language Models2025· reasoning← similar topic
- Magistral2025· reasoning← similar topic
- EXAONE 4.0: Unified Large Language Models Integrating Non-reasoning and Reasoning Modes2025· reasoning← similar topic
- NVIDIA Nemotron Nano 2: An Accurate and Efficient Hybrid Mamba-Transformer Reasoning Model2025· reasoning← similar topic
- A Survey of Reinforcement Learning for Large Reasoning Models2025· reasoning← similar topic
- Tracing the Traces: Latent Temporal Signals for Efficient and Accurate Reasoning2025· reasoning← similar topic
- Open-o3 Video: Grounded Video Reasoning with Explicit Spatio-Temporal Evidence2025· reasoning← similar topic
- DeepSeekMath-V2: Towards Self-Verifiable Mathematical Reasoning2025· reasoning← similar topic
- Fantastic Reasoning Behaviors and Where to Find Them: Unsupervised Discovery of the Reasoning Process2025· reasoning← similar topic
- Chain-of-Thought Reasoning without Prompting2024· reasoning← similar topic
- Iterative Reasoning Preference Optimization2024· reasoning← similar topic
- Democratizing Reasoning Ability: Tailored Learning from Large Language Model2023· reasoning← similar topic
- Self-Consistency Improves Chain of Thought Reasoning in Language Models2022· reasoning← similar topic

What it influenced

Later papers in the same chain. Direction reversed.

LongCat-Flash-Prover: Advancing Native Formal Reasoning via Agentic Tool-Integrated Reinforcement Learning2026· reasoning→ in-domain predecessor
- Why Does Self-Distillation (Sometimes) Degrade the Reasoning Capability of LLMs?2026· reasoning→ in-domain predecessor
- Offline Reinforcement Learning for LLM Multi-Step Reasoning2024· reasoning→ similar topic
- REASONING GYM: Reasoning Environments for Reinforcement Learning with Verifiable Rewards2025· reasoning→ similar topic
- A Survey of Reinforcement Learning for Large Reasoning Models2025· reasoning→ similar topic
STaR: Bootstrapping Reasoning With Reasoning2022· reasoning→ similar topic
- Large Language Models are Zero-Shot Reasoners2022· reasoning→ in-domain predecessor
- Fantastic Reasoning Behaviors and Where to Find Them: Unsupervised Discovery of the Reasoning Process2025· reasoning→ similar topic