Long Grounded Thoughts: Synthesizing Visual Problems and Reasoning Chains at Scale

🎯 Pitch

Vision-centric reasoning datasets hit a wall because caption-only generation causes problem diversity to saturate—this paper breaks through by using object-level spatial metadata to synthesize over 1M grounded, multi-hop reasoning problems. Finetuning on this data causes a 10× collapse in trivially solvable problems while producing traces with backtracking and verification behaviors, and—crucially—the authors show that SFT that teaches these cognitive patterns is a prerequisite for online RL to deliver any gains rather than plateau.

1. Executive Summary

This paper introduces Long Grounded Thoughts, a framework for synthesizing vision-centric reasoning datasets that tackles scale, complexity, and reasoning-trace richness through a two-stage pipeline: Stage 1 generates over 750K grounded multiple-choice questions by conditioning an LLM on object-level metadata (bounding-box coordinates and tags), overcoming the diversity saturation of caption-only methods, while Stage 2 applies a composition hardening algorithm that merges simpler questions into multi-hop problems requiring decomposition and higher-order reasoning. Fine-tuning Qwen2.5-VL-7B on the resulting 1M+ examples outperforms all open-data baselines across vision-centric benchmarks and matches or surpasses closed-data models like MiMo-VL-7B-RL on V*Bench, CV-Bench, and MMStar-V, with the composition stage yielding a ~10× reduction in trivially solvable problems (from 36.7% to 3.3% perfect-solve rate) and a +206% increase in cognitive behavior frequency (subgoal setting, backtracking, verification) in reasoning traces. A comprehensive post-training analysis reveals that online RL (GRPO) yields fast initial gains but plateaus without first teaching cognitive behaviors through SFT on high-quality synthetic data, establishing that offline "teaching" of reasoning patterns is a prerequisite for effective online RL scaling—offline RL (SFT → DPO) reaches competitive performance without synchronized compute—while the entirely vision-centric data transfers positively to text-only reasoning (MMLU-Pro, +3.7%), audio reasoning (MMAU, +1.32%), and open-ended embodied QA (NiEH, +8.8%).

2. Context and Motivation

The Core Problem: Vision-Centric Reasoning Data Is Scarce, Simple, and Shallow

This paper addresses a specific and urgent gap in multimodal AI: the systematic inability to synthesize large-scale, complex, vision-centric reasoning datasets with rich cognitive structures. While the text-only reasoning domain has experienced an explosion of synthetic data since the release of DeepSeek R1—with several open-source projects producing reasoning datasets at scale—the multimodal community has lagged dramatically behind. Table 1 in the paper makes this disparity concrete: existing open multimodal reasoning datasets either max out at ~152K examples (VLAA-Thinking), specialize in narrow domains like visual math (Virgo, 19K examples), or lack complex reasoning structures entirely (PixMo-AskModelAnything, 162K examples but with no subgoal setting, backtracking, or verification behaviors).

The paper frames this as a synthesis problem, not merely a collection problem. It is not that vision-centric reasoning questions don't exist—it is that we lack a method to artificially generate them at scale with the right properties. The authors identify three specific dimensions where existing synthesis efforts fall short, each representing a distinct bottleneck:

1. Scale saturation from caption-only generation. The most direct approach to synthesizing visual questions is to give an LLM a detailed image caption and ask it to generate questions. LongPerceptualThoughts (LPT; Liao et al., 2025a) demonstrated this could work—producing 30K problems with structured reasoning traces. However, the paper identifies a fundamental limitation: when pushed beyond modest scales, caption-only synthesis exhibits problem synthesis saturation. The LLM repeatedly targets the same salient objects and visual features described in the caption, generating redundant questions that fail to provide diverse training signal. Figure 2 captures this concretely: LPT's downstream performance curve flattens as dataset size increases, while the proposed grounded approach maintains positive slope through 1M+ examples. An embedding analysis in Appendix A.2 quantifies the diversity collapse: LPT questions cluster tightly in semantic space (average pairwise cosine similarity of 0.82) compared to the grounded method's more diffuse distribution (0.61), with the grounded approach achieving a 3.2× wider semantic spread.

This is a critical practical insight: scaling data volume without scaling diversity yields diminishing returns. The caption acts as a bottleneck on the question generator's attention, causing it to re-sample the same salient concepts rather than exploring the long tail of visual details present in the image but not emphasized in the description.

2. Insufficient problem complexity. Even when diverse questions are generated, a large fraction are trivially solvable by base VLMs. Table 3 quantifies this: LPT's synthesized problems exhibit a 36.7% "perfect solve" rate—meaning that in over a third of cases, a base VLM correctly answers the question on all 8 out of 8 independent rollouts. These problems provide no meaningful learning signal for reasoning; the model already knows the answer. The paper's composition hardening (Stage 2) reduces this to 3.3%, representing a ~10× reduction in trivial questions. The average pass rate drops from 66.1% to 38.4%, confirming the difficulty distribution shifts substantially toward genuinely challenging problems.

The practical implication: simply generating questions is not enough—the questions must fall in the model's "zone of proximal development," where the answer is not immediately obvious but can be reached through deliberate reasoning. Without a mechanism to control and elevate difficulty, synthetic data generation yields mostly easy examples that fail to stretch the model's capabilities.

3. Shallow reasoning traces lacking cognitive structure. The paper distinguishes between correctness of reasoning and richness of reasoning. A CoT trace can lead to the right answer while being structurally simple—a linear chain of deductions without self-questioning, verification, or backtracking. The paper quantifies richness by counting distinct cognitive behaviors per trace, following the methodology of Gandhi et al. (2025) and Liao et al. (2025a). LPT averages only 0.65 behaviors per trace—meaning many traces contain no structured self-correction or subgoal decomposition at all. The grounded synthesis Stage 1 improves this to 0.80, and the composition hardening Stage 2 yields 1.99 behaviors per trace (+206%), producing traces that are structurally ~3× richer.

This matters because cognitive behaviors like backtracking and verification are precisely the mechanisms that enable deep reasoning models (like R1) to solve hard problems. If synthetic training data does not contain these patterns, the student model cannot learn them through imitation. The paper's finding that "Short CoT" traces (distilled only from VLM outputs without reasoning LLM expansion) actually degrade performance below even "No CoT" baselines (Table 12) underscores this point: low-fidelity reasoning traces provide negative transfer, teaching the model to produce plausible-sounding but shallow justifications rather than genuine deliberative reasoning.

Why This Problem Matters

The paper's motivation rests on three converging practical and theoretical considerations:

Democratization of multimodal reasoning. As the authors note in Section 1, "innovations in data curation and distillation have proven to be powerful levers for advancing open-source models" in the text domain. But open-source VLMs lack access to the kind of high-quality reasoning data that closed-source models (GPT-4o, o1, Claude 3.7) are presumably trained on. Table 2 demonstrates the consequence: fine-tuning Qwen2.5-VL-7B on existing open reasoning datasets (VLAA-Thinker, ReVisual-R1) sometimes degrades performance below the base instruct model. The paper explicitly states: "Models trained on limited open reasoning data... often underperform even the base Qwen2.5-VL-7B-Instruct, underscoring the lack of high-quality open data for vision-centric reasoning."

This is not merely a benchmarking concern—it represents a structural barrier to open-source progress in multimodal AI. Without methods to create training data that teaches genuine visual reasoning (not just pattern matching), the open-source community cannot compete with proprietary systems, regardless of model architecture or scale.

The training-inference modality gap. The paper makes a subtle but important observation about why vision-centric reasoning synthesis is harder than text-only synthesis: in text reasoning, an LLM can both generate and verify problems using only language. For visual reasoning, the generator (typically an LLM) cannot "see" the image—it must rely on text proxies (captions, metadata). This creates a grounding problem: how do you ensure the generated question actually references real visual content rather than hallucinating based on the caption? The paper's solution—using grounded object metadata (bounding boxes with coordinates)—bridges this gap by giving the LLM structured spatial information about what exists in the image and where, enabling grounded question generation without requiring the generator to process pixels directly. This insight—that the modality gap in the synthesis pipeline is the root cause of previous methods' limitations—is conceptually important beyond this specific implementation.

The post-training pipeline bottleneck. Section 3.3 and Table 11 provide what the paper claims is "one of the largest studies of its kind at scale on VLMs to date" analyzing the full post-training spectrum (SFT, offline RL via DPO, online RL via GRPO) on vision-centric tasks. The central finding is that online RL alone cannot elicit complex reasoning behaviors without first "teaching" them through SFT on high-quality synthetic data. Starting from a base instruct model (which lacks the cognitive patterns documented in Figure 3b and Table 13), GRPO peaks at 0.695 average performance at 10K examples and then degrades with more data, falling to 0.669 at 100K examples—well below the SFT baseline of 0.716.

This finding has significant practical implications for the RL-for-reasoning paradigm popularized by DeepSeek R1. It suggests that the "aha moment" where RL spontaneously elicits sophisticated reasoning behaviors may depend on the model having first been exposed to those behaviors through imitation learning. The paper characterizes this as: "without offline 'teaching' of cognitive behaviours, online RL cannot elicit competitive performance vs SFT in high-quality and diverse data." This is a concrete, evidence-backed claim that challenges narratives suggesting RL alone can bootstrap reasoning from scratch.

Where Prior Approaches Fall Short

The paper positions itself against a landscape of prior work, identifying specific limitations in each:

Caption-only synthesis (LPT and similar methods). LPT (Liao et al., 2025a) was a significant step forward—it introduced the two-stage CoT expansion strategy (VLM distillation followed by reasoning LLM expansion) that this paper adopts and extends. However, LPT's synthesis pipeline relies on dense captions as the sole proxy between images and the question-generating LLM. The paper identifies two resulting bottlenecks: (1) saturation at scale, as discussed above, where the LLM's question diversity plateaus because captions emphasize a limited set of salient features; and (2) cognitive simplicity—LPT's synthesized reasoning traces, while richer than prior work, still average only 0.65 cognitive behaviors per trace, with subgoal setting essentially absent (0.036 per trace). The paper positions itself not as replacing LPT but as overcoming its scaling and complexity ceilings through grounded metadata injection and composition hardening.

Distillation from math-heavy reasoning models (Virgo, VLAA-Thinking). Virgo (Du et al., 2025) distills CoTs from multimodal reasoning models but focuses on math-heavy domains. Table 4 shows that fine-tuning on Virgo significantly degrades text-only reasoning (MMLU-Pro drops from 47.15 to 37.95), indicating negative transfer—the math-specific reasoning patterns don't generalize to broader cognitive tasks. VLAA-Thinking (Chen et al., 2025b) distills CoTs in the general domain, but Table 2 shows fine-tuning on it degrades performance below the base Qwen2.5-VL-7B-Instruct on multiple benchmarks (V*Bench drops from 75.39 to 56.54). The paper cites these as evidence that simply having some reasoning data is not sufficient—the data must be high-quality, diverse, and aligned with the target model's distribution.

Domain-specific datasets lacking generality. Several datasets provide reasoning traces for narrow domains: SCI-Reason (12.6K, scientific images), DriveLMM-o1 (22K, driving scenarios), LENS (40K, multi-scenario but without cognitive behaviors). Table 1 shows none of these exhibit the full suite of cognitive behaviors (subgoal setting + backtracking + verification). The paper's implicit argument is that a general vision-centric reasoning capability requires training data that spans diverse visual scenarios and reasoning patterns, not just domain-specific problem-solving.

Closed-data models as an unattainable upper bound. Table 2 includes closed-source models (GPT-4o, o1, Claude 3.7) primarily as reference points. The paper's explicit framing in Section 1—"open-source multimodal reasoning efforts seem to lag behind"—positions the entire work as an effort to close the gap between open and closed multimodal reasoning capabilities through better data synthesis, rather than through architectural innovation or scaling model size.

How the Paper Positions Itself

The paper does not claim to invent new training algorithms (SFT, DPO, GRPO are all standard) or new model architectures (it fine-tunes off-the-shelf Qwen2.5-VL-7B). Its contribution is entirely in the data synthesis pipeline and the accompanying analysis of how different post-training stages interact with data quality.

The positioning is explicit in the introduction: "we push this line of research further with a synthesis framework that tackles these three core challenges: scale, complexity, and CoT richness." The "line of research" refers to LPT's approach of using VLMs and reasoning LLMs in concert to synthesize vision-centric problems and traces. The paper's innovations—grounded metadata for diversity, composition hardening for complexity, and the two-stage model selection strategy (accessible models for simple questions, frontier models for hard ones)—are all targeted at overcoming the specific bottlenecks LPT encountered when pushed to scale.

The paper also positions itself as providing a practical, reproducible recipe. Section 2.3 notes that "75% of our data uses accessible models (Stage 1) yet yields strong performance" and that "we release both subsets separately to enable both reproducibility and high-quality research without dependence on frontier teachers." This is a commitment to democratization: the framework should work even for researchers without access to the largest reasoning models, with the option to use frontier models for the hardest subset if resources permit.

A crucial implicit argument throughout the paper is that data quality, not training algorithm sophistication, is the primary bottleneck for vision-centric reasoning. The post-training analysis (Section 3.3, Table 11) supports this: SFT on high-quality grounded data (0.716) substantially outperforms GRPO on the base model (peaking at 0.695) and GRPO on LPT data (peaking at 0.709 at 100K). The best offline configuration (SFT + DPO, 0.740) is within 1.7 points of the best online configuration (SFT + GRPO, 0.757), suggesting that the RL algorithm choice matters far less than the quality of the underlying training data. This is a direct challenge to the prevailing emphasis on RL as the key to reasoning, repositioning data synthesis as the more fundamental lever.

3. Technical Approach

3.1 Reader Orientation

This paper is a data synthesis engineering paper whose core idea is that injecting grounded object metadata (bounding boxes with coordinates) into the visual question generation pipeline, followed by a composition hardening stage that merges simple questions into multi-hop problems, overcomes the diversity saturation and complexity bottlenecks that have prevented prior caption-only methods from scaling vision-centric reasoning datasets beyond ~30K examples. The resulting framework produces 1M+ high-quality examples spanning SFT, preference data, and RL training signals, enabling a comprehensive empirical analysis of how different post-training stages (SFT, DPO, GRPO) interact with data quality in VLMs.

3.2 Big-Picture Architecture (Diagram in Words)

The system has six major components, organized into two sequential stages and an orthogonal trace synthesis pipeline, feeding into a downstream training analysis:

Object Metadata Extractor — processes each raw image through Grounded-SAM to produce open-vocabulary bounding boxes and object tags (e.g., "bag (0.29, 0.11, 0.39, 0.32)"), providing structured spatial grounding information that the question-generating LLM can reason about despite being purely text-based.
Grounded MCQ Generator (Stage 1) — takes dense image captions from DOCCI (human-annotated) plus the object metadata and prompts an LLM to generate object-centric multiple-choice questions, one per detected object, yielding ~750K diverse, verifiable problems.
Composition Hardening Module (Stage 2) — randomly samples up to 5 question-answer pairs from Stage 1 for the same image, feeds them to an LLM along with the global caption, and prompts it to compose them into a single harder multi-hop problem requiring decomposition and higher-order reasoning, producing ~251K additional problems.
Reasoning Trace Synthesis Pipeline — operates on both stages independently: a VLM first produces a simple CoT (rationale + answer), then a reasoning LLM (e.g., R1-671B, Qwen3-235B-Thinking) expands this trace by injecting complex cognitive behaviors (backtracking, verification, subgoal setting), with a local verifier model filtering out traces inconsistent with the ground-truth answer.
Preference Data Construction (for RL) — defines pairwise preference triples based on correctness and compactness: a correct short trace is preferred over an incorrect one, and a correct short trace is preferred over a correct long trace, enabling both correctness-driven and brevity-driven preference optimization.
Post-Training Analysis Harness — takes the base Qwen2.5-VL-7B-Instruct model through various post-training combinations (SFT-only, SFT→DPO, SFT→GRPO, base→GRPO), systematically varying dataset size and type to study how data quality interacts with training algorithm choice.

Information flows as follows: raw image → Grounded-SAM produces bounding boxes + tags → object metadata joins dense captions as input to the Stage 1 LLM generator → verified and diversity-filtered MCQs emerge → a subset of these MCQs enter Stage 2 composition → harder composed questions emerge → both stages' questions independently enter the trace synthesis pipeline (VLM → reasoning LLM expansion → local verification) → the resulting (image, question, reasoning trace, answer) quadruplets form the SFT/DPO dataset, with additional preference pairs constructed for offline RL and verifiable rewards defined for online RL → all variants feed into a systematic comparison of training configurations evaluated on vision-centric benchmarks.

3.3 Roadmap for the Deep Dive

First, the grounded MCQ generation pipeline (Stage 1), because understanding how object metadata is injected into the LLM prompt and why this overcomes caption-only saturation is foundational to the paper's scaling claim.
Second, the semantic similarity filtering protocol, since it operationalizes "diversity" quantitatively and directly impacts the scaling behavior shown in Figure 2.
Third, the composition hardening algorithm (Stage 2), because it introduces the mechanism that shifts the difficulty distribution and produces cognitive richness, connecting directly to the behavioral analysis in Figure 3.
Fourth, the reasoning trace synthesis procedure, including the two-stage expansion strategy, the guided decoding mechanism, the staged model selection (small models for Stage 1, frontier models for Stage 2), and the local verification step, since the richness of these traces is what enables the SFT→RL pipeline to work.
Fifth, the preference data construction for offline RL, because it defines the reward signal that drives DPO and establishes the paper's approach to correctness-and-brevity tradeoffs.
Sixth, the training configurations and hyperparameters for SFT, DPO, and GRPO, since the post-training analysis in Section 3.3 depends on precise implementation details to support claims about RL plateauing and SFT prerequisites.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical data engineering and analysis paper whose central technical contribution is the grounded synthesis pipeline that overcomes diversity saturation, plus the composition hardening algorithm that elevates complexity. The paper's secondary contribution is the large-scale post-training analysis enabled by having 1M+ high-quality examples spanning SFT and RL formats.

Grounded MCQ Generation (Stage 1): How Object Metadata Injects Diversity

The core technical challenge that Stage 1 solves is preventing the question-generating LLM from collapsing onto a narrow set of salient visual features. When a text-only LLM is given a dense image caption and asked to generate visual questions, it repeatedly targets the same prominent objects, colors, and spatial relationships that the caption emphasizes—a phenomenon the paper terms problem synthesis saturation. The consequence is that scaling dataset size by simply generating more questions per image yields diminishing returns because the new questions are semantically redundant with existing ones.

The paper's solution is to replace the high-level caption with fine-grained object-level grounding as the primary conditioning signal for the generator. Formally, given an image $v$ with dense textual descriptions $c$ and object-level metadata $o_{\text{md}}$ (bounding-box coordinates and object tags), Stage 1 constructs per-object triplets:

$(v, q, a) := M_{\text{LLM}}(c, o_{\text{md}})$

where $M_{\text{LLM}}$ is the text-only LLM serving as the question generator, $q$ is the generated multiple-choice question, and $a$ is the correct answer key.

What this means operationally: For a single image, the pipeline first runs Grounded-SAM (Ren et al., 2024) to detect objects, producing $K$ bounding boxes with open-vocabulary labels. The median DOCCI image contains 10.7 bounding boxes after applying a confidence cutoff of 0.9 from the Florence-2 feature extractor (a 0.7B vision encoder-decoder model) within the Grounded-SAM pipeline. The system constrains the maximum number of same-category instances per image to 9 (e.g., at most nine "tree" bounding boxes) to prevent the generator from over-representing frequently occurring object types. For each detected object, the LLM receives a structured prompt containing: (1) the full dense caption, (2) the target object's label, (3) its normalized bounding-box coordinates in $[x_1, y_1, x_2, y_2]$ format, and (4) the image dimensions. The LLM produces one four-option multiple-choice question per object, with the correct answer grounded in the specific spatial region defined by that bounding box. A single image with 10 objects therefore yields approximately 10 distinct MCQs, each anchored to a different visual element.

Why bounding-box coordinates help, even though the LLM operates purely in text: The paper reports an intriguing finding—including normalized bounding-box coordinates in the prompt "further improved question grounding." This works because coordinates give the text LLM a spatial reference frame: it can reason about relative positions ("the object at (0.17, 0.09, 0.29, 0.32) is to the left of the object at (0.63, 0.52, 0.97, 0.91)") and generate questions that require distinguishing between spatially adjacent but semantically similar objects. Without coordinates, the LLM only knows that a "bag" and "clothes" exist somewhere in the image, making it difficult to generate questions about their relative spatial arrangement with precision. With coordinates, it can generate questions like "Which object is positioned to the left of the item at coordinates (0.63, 0.52, 0.97, 0.91)?"—even though the trained VLM never sees the coordinates during downstream training, the questions themselves encode spatial reasoning requirements that would be impossible to specify from captions alone.

The prompt design is highly engineered for this specific task. The paper introduces a 1,987-token prompt instruction (compared to LPT's simpler 419-token prompt), designed around one main task instruction, one core principle, and four auxiliary guidelines. Key design elements include:

Role-playing preamble: The prompt starts with "You are a computer vision expert generating object-centric visual questions," which the paper reports improved instruction-following F1 score from 96.3 to 99.2 during Stage 1 data generation. This is a form of task-activating prompting where the role specification primes the LLM to interpret bounding-box coordinates more reliably.
Question category distribution: The prompt explicitly distributes questions across four categories—Specific Region Analysis (25%), Object-Environment Interactions (25%), Comparative & Relational Questions (25%), and Functional & Semantic Analysis (25%)—ensuring the generated questions span multiple cognitive levels from basic attribute identification to complex functional reasoning.
Core principles constraining generation: Four principles govern all questions: (1) Object-Centric Focus—every question must center on the specific bounded object; (2) Spatial Precision—questions must require examining the exact bounded region; (3) Contextual Relationships—explore how the target object relates to surroundings; (4) Multi-Level Analysis—progress from basic properties to complex spatial and functional relationships.
Distractor strategy: Wrong answer options must be "plausible wrong answers that might apply to other objects in the scene but not the target object," ensuring the MCQ tests genuine visual discrimination rather than linguistic reasoning.
Coordinate non-disclosure rule: The prompt explicitly instructs "DO NOT mention bounding box coordinates in the question text," forcing the LLM to translate spatial coordinate information into natural language spatial references ("to the left of," "in front of," "adjacent to") that will be meaningful to the downstream VLM.

The scaling mechanism: why this avoids saturation. Each object in an image provides a different anchoring point for question generation. The LLM is forced to attend to a specific spatial region and generate questions about the properties, relationships, and context of that specific object. An image with 10 objects therefore produces questions about 10 different visual concepts, rather than 10 variations on the same salient features. The embedding analysis in Appendix A.2 quantifies this: the grounded approach produces a semantic manifold that is 3.2× wider (measured by mean Euclidean distance to centroid) and has substantially lower redundancy (average pairwise cosine similarity 0.61 vs. 0.82 for LPT). The practical consequence is visible in Figure 2: while LPT's performance curve flattens as dataset size increases beyond ~50K, the grounded approach maintains positive slope through 1M+ examples because each additional question provides genuinely novel training signal rather than reinforcing the same visual reasoning patterns.

A subtle limitation the paper acknowledges but does not fully resolve: the grounded approach assumes the existence of high-quality object detectors and dense captioners for every image. The paper uses DOCCI (human-annotated dense captions) and Grounded-SAM (automated bounding boxes), and explicitly defers exploring other caption sources and automatically generated captions to future work. The quality of the downstream data depends on the quality of these upstream components—if the object detector misses important objects or generates noisy bounding boxes, the grounded questions will inherit those errors.

Semantic Similarity Filtering: Operationalizing Diversity

Generating questions per object prevents redundancy at the object level, but different objects in the same image can still yield semantically similar questions (e.g., "What color is the bag?" and "What color is the shirt?" both test color recognition). The paper introduces a composite similarity filtering protocol that rejects newly generated questions whose semantic embedding is too close to any previously accepted question, ensuring that the final dataset maintains diversity across all generated MCQs, not just within a single image.

The filtering operates on question representations. Each MCQ $i$ is encoded as a composite feature vector consisting of:

$\text{sim}(i, j) = \lambda_s \cos(\mathbf{q}_i, \mathbf{q}_j) + \lambda_a \cos(\mathbf{a}_i, \mathbf{a}_j) + \lambda_c \mathcal{J}(\mathbf{c}_i, \mathbf{c}_j)$

where $\mathbf{q}_i$ is the embedding of the question stem for MCQ $i$ , $\mathbf{a}_i$ is the embedding of the selected (correct) answer text, $\mathbf{c}_i$ is an optional set of category tags, $\cos(\cdot, \cdot)$ denotes cosine similarity between embedding vectors, $\mathcal{J}(\cdot, \cdot)$ is the Jaccard index (intersection-over-union) for category tag sets, and $\lambda_s$ , $\lambda_a$ , $\lambda_c$ are scalar weights balancing the contribution of question stem, answer, and category similarity respectively.

What it computes: a weighted combination of three similarity signals between a candidate MCQ and each previously accepted MCQ. The question-stem embedding captures semantic content of what is being asked; the answer embedding captures the type of answer expected; the category Jaccard index captures overlap in the types of reasoning required. The three are combined through learnable or heuristically set weights into a single similarity score between 0 and 1 (since cosine similarity is bounded to [-1, 1] and Jaccard to [0, 1], the weighted combination with appropriately normalized weights stays in a bounded range).

Why this form: single-axis similarity (e.g., only question stem) would miss cases where two questions ask about different objects but in identical ways (different stems, same reasoning pattern), or where two questions ask the same thing about different objects (different answers, redundant training signal). The composite score catches multiple dimensions of redundancy simultaneously. The Jaccard term explicitly penalizes questions from the same category (e.g., two "specific region analysis" questions about the same image), enforcing the prompt's category distribution constraint at the filtering level.

Implementation detail: the paper uses all-MiniLM-L6-v2, a 22M-parameter text embedding model from SentenceTransformer, to compute the $\mathbf{q}_i$ and $\mathbf{a}_i$ embeddings. A k-nearest neighbors index stores embeddings of all accepted questions for efficient retrieval. For each candidate MCQ, the system queries this index for the top-k closest neighbors (k is not specified but implied to be small, likely 5–10 based on standard practice), computes the composite similarity to each neighbor, and rejects the candidate if:

$\max_{j < i} \text{sim}(i, j) \geq \tau_{\text{dup}}$

where $\tau_{\text{dup}} = 0.82$ is the deduplication threshold set after "an ablation study on the filtered question quality." A candidate with maximum similarity below 0.82 to all existing questions is accepted and added to the index.

This filtering operates after an initial LLM-based verification step where a Qwen3-30B-A3B-Instruct-2507 model acts as a verifier, "assessing the factual correctness and logical soundness of each generated MCQ." The paper does not provide detailed metrics on the verifier's accuracy or what fraction of generated MCQs fail verification, but the two-step filter (LLM verifier → semantic deduplication) ensures that the surviving questions are both factually grounded and semantically diverse.

Composition Hardening (Stage 2): Creating Multi-Hop Problems

Stage 1 generates diverse but individually simple questions—the paper reports a 25.5% perfect-solve rate (questions where the base VLM gets the answer correct on all 8 of 8 independent rollouts), meaning a quarter of the questions provide no learning challenge. Stage 2 addresses this through a composition hardening algorithm that transforms collections of simple questions into single, complex multi-hop problems.

The algorithm is conceptually simple but mechanistically precise:

For a given image $v$ , randomly sample $K$ question-answer pairs from the Stage 1 pool associated with that image, where $K \leq 5$ . These are the constituent sub-questions, each individually verifiable.
Feed the global image caption $c$ and the set of $K$ sub-questions with their correct answers $\{q_i, a_i\}_{i=1}^K$ to an LLM generator $M_{\text{LLM}}$ .
The LLM is prompted to synthesize a single harder question $q^\star$ and its correct answer $a^\star$ such that solving $q^\star$ requires implicitly answering (or reasoning through) the original sub-questions as intermediate steps:

$(v, q^\star, a^\star) := M_{\text{LLM}}(c, \{q_i, a_i\}_{i=1}^K)$

The composed problem is verified by having the generator LLM solve its own question, and only problems where the answer consistency exceeds a threshold $\tau \geq 0.8$ are retained—ensuring the composition is logically coherent and the answer is derivable from the image content.

What the prompt asks the LLM to do (paraphrased from Appendix A.4): "You will be given a description of an image and up to 5 different easy problems asking about the image. Use the questions to create a single, creative and hard question to solve. The composed question should be much harder than each of the individual subquestions provided. Focus on perceptual capabilities (counting objects, detecting color/texture, relative location, image angle, detecting letters) and creatively use them to make a harder question. Do not simply ask about an enumeration of these features."

Why this produces harder problems: the LLM must synthesize a question whose answer requires integrating information from multiple sub-questions. For example, if sub-question 1 asks "What color is the bag?" and sub-question 2 asks "Which object is to the left of the clothes?", the composition might produce "What is the color of the object positioned to the left of the clothes?"—a two-hop question requiring both spatial reasoning (find the object left of the clothes) and attribute recognition (identify its color). This is fundamentally harder than either sub-question in isolation because the model must chain two distinct visual reasoning operations, and an error in either hop produces a wrong final answer.

Quantitative impact on difficulty: Table 3 shows the composition hardening reduces the perfect-solve rate from 25.5% (Stage 1) to 3.3% (Stage 2)—a nearly 8× reduction—meaning that 96.7% of composed questions are unsolvable by the base VLM on at least some rollouts. The average pass rate drops from 56.8% to 38.4%, confirming the distribution shifts toward harder problems that are still within the zone of proximal development (not completely unsolvable, but requiring non-trivial reasoning).

Impact on reasoning trace structure: Figure 3b and Table 13 quantify that composed problems produce reasoning traces with significantly more cognitive behaviors. Subgoal setting increases from 0.12 per trace (Stage 1) to 0.55 per trace (Stage 2)—a 4.6× increase—because multi-hop problems naturally decompose into intermediate steps corresponding to the original sub-questions. Verification behavior increases from 0.33 to 0.76, as the reasoning model must check whether each intermediate conclusion is consistent with other visual evidence. Backtracking increases from 0.35 to 0.68, reflecting moments where the model realizes an intermediate step was misinterpreted and revises.

A limitation of the composition approach: the algorithm depends on having multiple high-quality Stage 1 questions for the same image. Images with few detected objects (or where most Stage 1 questions were filtered out) provide limited compositional material. The paper does not report what fraction of images successfully produce composable question sets of size $K$ , nor the distribution of $K$ values actually used. Additionally, the composition prompt instructs the LLM not to "simply ask about an enumeration of these features," but the paper provides no quantitative measure of whether the generator successfully avoids trivial compositions (e.g., "What is the color of the bag AND the position of the clothes?" which would be a concatenation rather than a genuine integration).

Reasoning Trace Synthesis: The Two-Stage Expansion Strategy

The paper adopts and extends LPT's two-stage trace synthesis approach: first distill a simple CoT from a VLM that can actually "see" the image, then expand that CoT with a reasoning LLM that can inject complex cognitive structures but cannot process visual input. The innovation is in how this is scaled across Stage 1 and Stage 2 data, the introduction of guided decoding to prevent caption leakage, and the staged model selection strategy.

Stage 1: VLM distillation. Given an image $v$ and its corresponding MCQ $q$ , a VLM $M_{\text{VLM}}$ is prompted to produce an initial rationale $z_1$ (the reasoning trace) and final answer $a_1$ :

$(z_1, a_1) := M_{\text{VLM}}(v, q)$

This step is critical because the VLM has direct access to pixel-level information. The resulting trace $z_1$ is grounded in actual visual content—it references what the model "sees" rather than what a caption says. However, these traces tend to be linear and cognitively simple: the VLM describes what it observes and deduces the answer, without backtracking, self-verification, or subgoal decomposition.

Stage 2: Reasoning LLM expansion. The simple CoT is then embedded in a structured prompt for a reasoning LLM $M_{\text{Reason}}$ :

$\text{User: } c \oplus q, \quad \text{Assistant: } \texttt{<thinking>} \oplus z_1$

The reasoning LLM continues the thought, producing an expanded trace $z_2$ and (potentially revised) answer $a_2$ . The dense caption $c$ is included in the user prompt so the reasoning LLM has contextual information about the image, even though it cannot process pixels directly. Critically, the caption is never seen by the downstream trained model—it serves only as an intermediate bridge to give the reasoning LLM enough context to produce meaningful expansions.

Why the expansion matters—evidence from the ablation: Table 12 provides a striking ablation. Training on:

No CoT (direct answers only, no reasoning trace): accuracy 0.787 on CV-Bench, 0.583 on V*Bench
Short CoT (VLM-distilled traces only, no expansion): accuracy 0.714 on CV-Bench, 0.540 on V*Bench—worse than No CoT
Full CoT (expanded traces with cognitive behaviors): accuracy 0.813 on CV-Bench, 0.597 on V*Bench—best

The degradation from Short CoT below No CoT is a critical finding: low-fidelity reasoning traces provide negative transfer. The VLM's simple, linear reasoning traces teach the model to produce plausible-sounding but shallow justifications that interfere with genuine reasoning—the model learns to "sound like it's reasoning" without actually doing it. Only the expanded traces from the reasoning LLM, which contain complex cognitive behaviors, yield positive transfer.

The guided decoding mechanism for scaling: At large scales, the paper observed that the reasoning LLM frequently produced expansions like "the image description says..." or "according to the caption..."—explicitly referencing the text description rather than reasoning as if grounded in visual input. This is catastrophic for downstream training because the student VLM should learn to reason from pixels, not from captions it won't have access to at inference time.

To prevent this, the paper introduces a regular expression (regex) guided decoding mechanism that constrains the reasoning LLM's generation to exclude explicit references to the image description. Concretely, the sampling algorithm applies a regex filter that rejects or reweights tokens that would produce phrases like "the description," "the caption," or "according to the text." The paper reports this "substantially improves distillation efficiency and utilization at scale," though no ablation quantifying the improvement is provided.

Staged model selection: The paper reserves different teacher models for different difficulty tiers:

Stage 1 (simpler problems, ~750K examples): Qwen2.5-VL-7B for VLM distillation, DeepSeek-R1-Distill-Qwen-32B as the reasoning LLM for expansion. These are "accessible" models that represent a reasonable compute budget.
Stage 2 (harder composed problems, ~251K examples): Qwen2.5-VL-72B for VLM distillation, R1-671B and Qwen3-235B-Thinking as the reasoning LLMs. These are frontier models reserved for the hardest, most valuable training examples.

The paper emphasizes that "75% of our data uses accessible models" and releases the two subsets separately, explicitly motivated by reproducibility concerns—researchers without access to R1-671B can still reproduce the majority of the results. This is a practical design choice that balances cost against quality: the hardest examples benefit most from the strongest teachers, but the volume data (which provides diversity and coverage) can be generated with more modest resources.

Local verification for logical consistency: After expansion, a local verifier model (Qwen-32B-A3B-2507-Instruct, a 32B-parameter model with 3B active parameters) checks whether the expanded reasoning trace logically supports the ground-truth answer. The verifier prompt (detailed in Appendix A.5) instructs the model to: (1) understand the question and answer, (2) derive what answer the reflection (expanded trace) leads to ignoring the provided answer, (3) check for consistency between the derived answer and the ground-truth answer, outputting "Yes" if consistent and "No" otherwise.

This verification step is essential at scale: the reasoning LLM can produce compelling-sounding but factually incorrect expansions that deviate from the correct answer. Without verification, these inconsistent traces would be included in SFT data, teaching the student model to produce reasoning that doesn't lead to the correct conclusion. The paper does not report the fraction of expanded traces rejected by the verifier, but implies the cost is acceptable by describing it as an "efficient verifier" for "high-throughput quality control."

Preference Data Construction for Offline RL

To support offline RL (specifically DPO), the paper constructs preference pairs from the synthesized traces, following the approach of Setlur et al. (2024) and Zhang et al. (2025a). The preference relations are defined over two axes: correctness and compactness.

Correctness preferences: The system pairs correct and incorrect traces to establish that correct reasoning is preferred over incorrect reasoning. Formally, let $z_1^+$ denote a correct initial VLM trace (where the associated answer $a_1^+$ is correct) and $z_1^-$ denote an incorrect trace. The system defines two preference relations:

$(z_1^+, a_1^+) \succ (z_1^-, a_1^-)$

$(z_1^- \oplus z_2^+, a_2^+) \succ (z_1^-, a_1^-)$

where $\succ$ denotes "is preferred over" and $\oplus$ denotes concatenation. The first relation pairs a correct short trace against an incorrect short trace—this is straightforward: the model should learn to produce correct reasoning rather than incorrect reasoning. The second relation is more nuanced: it pairs a corrected trace (an initially incorrect trace followed by a reasoning LLM expansion that fixes the error and produces a correct final answer) against the original incorrect trace. This teaches the model that when it starts down an incorrect reasoning path, it should self-correct (via backtracking or verification) rather than committing to the error.

Why the second preference relation matters: it specifically incentivizes the self-correction behavior documented in the qualitative examples (Figures 4, 5, 8). The model learns that producing an initial incorrect thought followed by a revision that reaches the correct answer is better than producing the incorrect thought and stopping. This is precisely the "Wait, but..." and "Let me double-check..." pattern visible in the paper's examples.

Compactness preferences: The system also defines a preference for brevity:

$(z_1^+, a_1^+) \succ (z_1^+ \oplus z_2^+, a_2^+)$

This states that a correct short trace is preferred over a correct long trace—even when both reach the correct answer. This prevents the model from learning to produce unnecessarily verbose reasoning (a form of "reward hacking" where the model pads its output with redundant verification steps to increase the probability of appearing correct). The compactness preference is a form of length regularization implemented at the data level rather than through an explicit length penalty in the RL objective.

What the paper does NOT verify: the correctness of $z_1$ itself—the intermediate reasoning steps in the initial VLM trace—is not directly checked. Instead, correctness is inferred from the associated answer $a_1$ . If $a_1$ matches the ground truth, $z_1$ is assumed correct even if the reasoning contains factual errors that happen to lead to the right answer. The paper acknowledges this as "a reasonable approximation at scale," recognizing that verifying the logical validity of every reasoning step is computationally prohibitive but that answer correctness is a strong (if imperfect) proxy.

Preference dataset scale: The paper reports "129K additional problems for offline and online RL" (Section 1), indicating that the preference dataset is constructed from a subset of the full 1M+ examples, likely focusing on cases where both correct and incorrect VLM traces are available for the same question (since preference pairs require contrasting good and bad outputs for the same input).

Training Configurations and Hyperparameters

The paper trains Qwen2.5-VL-7B-Instruct under several configurations to systematically analyze the post-training pipeline. All experiments use the llama-factory framework for SFT and DPO, and VERL (Sheng et al., 2024) for GRPO.

SFT configuration:

Curriculum: First fine-tune on simpler Stage 1 data (~750K examples) for one epoch, then introduce Stage 2 data (~251K examples) with halved learning rate and early stopping based on validation loss.
Stage 1 specifics: Batch size 256, learning rate $8 \times 10^{-6}$ , maximum image resolution $512 \times 512$ , input cutoff length 1024 tokens, one epoch.
Stage 2 specifics: Learning rate $4 \times 10^{-6}$ (halved from Stage 1), early stopping based on validation loss, remaining hyperparameters inherited from Stage 1.
What is fine-tuned: Only the language decoder—the vision encoder remains frozen. This is a deliberate choice to focus learning on the reasoning component while preserving visual feature extraction.
Why the curriculum: The simpler Stage 1 questions provide a warm-start where the model learns basic grounded reasoning patterns. Introducing the harder composed problems later prevents the model from being overwhelmed by difficulty early in training, which could cause training instability or poor convergence. The halved learning rate for Stage 2 reflects standard practice for fine-tuning on harder data where larger updates risk catastrophic forgetting of the Stage 1 patterns.

Offline RL (DPO) configuration:

Starting point: The SFT-trained model (after Stage 1 + Stage 2).
Hyperparameters: Batch size 256, learning rates from $\{6 \times 10^{-6}\}$ (swept, though only one value is reported), up to six epochs with early stopping based on validation loss.
DPO-specific parameters: $\beta = 1$ controls the strength of the KL divergence penalty relative to the preference objective. Following Pang et al. (2024), an additional SFT loss term is included with weight 0.5, which regularizes the model to stay close to the SFT solution and prevents overfitting to the preference signal.
Preference data scale: The paper experiments with 70K and 129K preference examples, reporting results at both scales (Table 11).

Online RL (GRPO) configuration:

Starting point: Either the base Qwen2.5-VL-7B-Instruct (no prior SFT) or the SFT-trained model, depending on the experiment.
Hyperparameters: Batch size 128, maximum response length 8192 tokens, learning rate $1 \times 10^{-6}$ , KL loss coefficient 0.001, no entropy penalty.
Reward function: The GRPO reward is binary (1 for correct, 0 for incorrect), determined by an LLM judge checking whether the model's final answer matches the ground truth. Additionally, a format reward of 0.1 is added if the response correctly follows the <thinking> and <response> tag structure.
Answer format diversity: To prevent the model from overfitting to a specific answer format (e.g., always outputting "(A)"), the labels are set in diverse formats including "(A)", "A", and "(A) answer." The LLM judge is responsible for matching any of these formats to the ground truth.
Data scales explored: GRPO is run at 1K, 5K, 10K, 50K, 70K, 100K, and 129K examples when starting from the SFT model, and at 10K, 50K, 70K, and 100K examples when starting from the base model (Table 11).

Why the LLM judge instead of rule-based matching for GRPO: Online RL requires a reward signal that can handle the diversity of outputs the model might produce while exploring. A simple string match would fail if the model outputs "The correct answer is (B)" when the ground truth is "B." The LLM judge provides a more robust correctness assessment, at the cost of additional inference compute per RL step.

A key limitation in the GRPO setup: the paper reports that from the base instruct model, GRPO "peaks at 0.695 (10K) and declines with more data (50-100K), remaining below our SFT baseline (0.716)." The qualitative example in Figure 5 shows why: the base model + GRPO produces reasoning that is correct in format but shallow in content—it states a conclusion without the self-questioning and backtracking patterns the SFT-trained models exhibit. The base model, never having seen complex reasoning traces, cannot discover these patterns through RL reward alone (at least not within the explored compute budget). This is the paper's central post-training finding: RL cannot bootstrap complex reasoning behaviors from scratch—it requires prior exposure through imitation learning.

4. Key Insights and Innovations

Innovation 1: Grounded Object Metadata as a Diversity Scaling Mechanism

The paper's most conceptually distinctive contribution is not the use of bounding boxes per se—object detectors are standard computer vision tools—but the insight that saturation in synthetic visual question generation is caused by an information bottleneck in the caption, and that injecting structured spatial metadata into a purely text-based generator can overcome this bottleneck. This is a diagnostic contribution: the paper identifies why prior methods plateau, rather than simply demonstrating that they do.

Before this work, the dominant approach to synthetic visual question generation was caption-only: provide a dense textual description to an LLM and ask it to generate questions (LPT, Liao et al., 2025a; and implicitly most MCQ synthesis pipelines). The assumption was that richer captions would yield richer questions, and that scaling meant generating more questions per image. The paper demonstrates that this assumption is empirically wrong—the LLM repeatedly targets the same salient features emphasized in the caption, producing semantically redundant questions (average pairwise cosine similarity 0.82 vs. 0.61 for the grounded approach, Appendix A.2). The resulting performance scaling curve plateaus (Figure 2, LPT line), meaning additional data volume provides no additional learning signal.

The innovation is recognizing that the solution is not to improve captions but to bypass them as the primary conditioning signal. By giving the LLM per-object bounding-box coordinates and labels, the generator is forced to anchor each question to a different spatial region and visual concept. The LLM cannot collapse onto "the most salient object" because the prompt constrains it to a specific object, and different objects map to genuinely different question semantics. This converts the data generation problem from one of language generation (where diversity is limited by the caption's expressiveness) to one of combinatorial coverage of detected objects (where diversity scales with the number of objects per image, ~10.7 on average for DOCCI).

The significance extends beyond this specific implementation. The paper reframes synthetic visual data generation as fundamentally a grounding problem: the generator needs structured access to the visual signal, not just a linguistic proxy. The modality gap in the synthesis pipeline (text-only LLM generating visual questions) cannot be fully bridged by better descriptions alone—it requires structured metadata that encodes what is in the image and where. This is a conceptual shift with implications for any future work that attempts to scale synthetic visual reasoning data.

Evidence: Figure 2 (positive slope through 1M+ examples vs. LPT's plateau), Appendix A.2 embedding analysis (3.2× wider semantic spread, lower redundancy), Table 3 (Stage 1 reduces perfect-solve rate from 36.7% to 25.5% through better diversity alone, before composition hardening).

Innovation 2: Composition as a Difficulty Elevation Mechanism with Verifiability Preservation

The paper introduces composition hardening—merging multiple simple, individually verifiable questions into one hard multi-hop question—as a scalable alternative to manually writing hard problems or relying on frontier models to generate them from scratch. This is not merely a data augmentation trick; it is a principled approach to difficulty control that solves a fundamental tension in synthetic reasoning data: hard problems are valuable for training but hard to generate without introducing errors (hallucinated questions, unverifiable answers, out-of-distribution formats).

Prior work on visual reasoning data either accepted the natural difficulty distribution of simple synthesis (leaving many trivially solvable examples) or turned to domain-specific sources like math competitions (Virgo, Du et al., 2025) that are inherently hard but narrow in scope. The paper's composition approach offers a third path: it generates hard problems without requiring the generator to invent novel difficult reasoning from scratch. Instead, the generator's task is recombination—take existing verifiable sub-problems and merge them into a coherent whole. Because the sub-problems are individually verified (from Stage 1), the composed problem inherits verifiability: the generator can solve its own composition by answering the sub-problems and integrating the results, enabling a consistency check ( $\tau \geq 0.8$ ).

What makes this intellectually distinctive is the framing of difficulty as structural compositionality rather than domain expertise. A hard visual reasoning problem is not necessarily one requiring advanced physics or mathematics—it is one requiring the integration of multiple perceptual operations (locate object A, determine its spatial relationship to B, identify property C, etc.) that would individually be easy but collectively challenge the model's ability to chain operations without losing track of intermediate results. This reframes difficulty generation as a routing problem: given a pool of simple, verified sub-questions, find combinations whose logical integration demands multi-step reasoning.

The empirical payoff is substantial: a ~10× reduction in trivially solvable problems (36.7% to 3.3% perfect-solve rate, Table 3) and a +206% increase in cognitive behavior frequency in reasoning traces (0.65 to 1.99 behaviors per trace, Figure 3b). But the intellectual payoff is the demonstration that complexity can be synthesized from simplicity through structured combination, with verification preserved at each stage. This is analogous to how formal theorem proving constructs complex proofs from simple axioms and lemmas—the challenge is not inventing new axioms but composing existing ones correctly.

Evidence: Table 3 (perfect-solve and pass-rate reductions from Stage 1 to Stage 2), Figure 3a (difficulty distribution shift visualized through multiple rollouts), Figure 3b and Table 13 (subgoal setting increases 4.6× from Stage 1 to Stage 2, reflecting the multi-hop structure).

Innovation 3: Offline Teaching of Cognitive Behaviors as a Prerequisite for Effective Online RL

This is the paper's most significant negative finding with positive implications: the discovery that online RL (GRPO) applied to a base VLM without prior exposure to complex reasoning traces fails to elicit sophisticated cognitive behaviors (backtracking, verification, subgoal decomposition), produces performance that peaks early and degrades with more data, and underperforms simple SFT on high-quality synthetic data. The paper doesn't just observe this—it provides a controlled comparison (Table 11) showing that the base model + GRPO peaks at 0.695 average performance (at 10K examples) while SFT on grounded data reaches 0.716, and GRPO after SFT reaches 0.757 (at 70K examples).

This directly challenges a narrative that gained traction after DeepSeek R1—that reinforcement learning alone can bootstrap reasoning capabilities, with the "aha moment" emerging spontaneously from reward optimization. The paper's evidence suggests that this narrative is incomplete for vision-centric tasks: RL can refine and amplify existing reasoning patterns but cannot discover them from scratch within practical compute budgets. The qualitative example in Figure 5 makes this concrete: the base model + GRPO produces correct-format output but shallow reasoning ("The image does not show an SUV car... it is not possible to determine the color"), while the SFT + GRPO model exhibits self-correction ("Wait, actually, looking back, the image does have a silver-colored SUV parked on the right side... I think I made a mistake earlier").

The intellectual contribution is not merely empirical—it reframes the role of SFT in the RL-for-reasoning pipeline. SFT is not just "warm-starting" or providing a better initialization; it is teaching the model a vocabulary of cognitive moves (what does it look like to backtrack? how do you phrase a self-verification?) that RL can then learn to deploy selectively. Without this vocabulary, the reward signal (binary correct/incorrect) is too sparse to guide the model toward complex multi-step reasoning strategies—there are too many possible reasoning paths, and random exploration cannot discover the structured patterns necessary for hard visual problems.

This finding is particularly significant because it comes from a large-scale study (1M+ examples, multiple training stages) specifically designed to isolate the interaction between data quality and training algorithm. Prior work on RL for reasoning (DeepSeek R1, Kimi K1.5) studied much larger models and did not systematically ablate whether SFT on high-quality data was a necessary precursor to RL's success. The paper's controlled comparison fills this gap with quantitative evidence.

A secondary finding reinforces this: DPO (offline RL) reaches 0.740, within 1.7 points of the best GRPO configuration (0.757), while requiring no synchronized online compute. This suggests that for vision-centric reasoning at this scale, the primary value of RL is not exploration or self-play but rather preference optimization on pre-collected data, which can be done offline. This is a practical insight with implications for resource allocation in VLM post-training pipelines.

Evidence: Table 11 (base + GRPO: 0.695 peak at 10K, degrades to 0.669 at 100K; SFT + GRPO: 0.757 at 70K; SFT + DPO: 0.740), Figure 5 (qualitative comparison of base + GRPO vs. SFT + GRPO reasoning traces), Table 10 (LPT SFT + GRPO peaks at 0.709, below grounded SFT alone at 0.716).

Perhaps the paper's most surprising finding—and the one most likely to stimulate follow-up work—is that entirely vision-centric reasoning data transfers positively to text-only reasoning, audio reasoning, and embodied question answering, with no domain-specific adaptation. Fine-tuning Qwen2.5-VL-7B on the grounded data improves MMLU-Pro (text-only) by +3.7 points (Table 4), and fine-tuning a Qwen2.5-Omni-7B model improves MMAU-Sound (+1.53), MMAU-Music (+2.87), and MMAU-Speech (+0.33) (Table 5), despite the training data containing zero audio examples.

This is not an obvious result. One might expect that vision-specific reasoning data would improve vision benchmarks but either leave non-vision capabilities unchanged (if reasoning is modality-specific) or degrade them (if catastrophic forgetting occurs). The positive transfer suggests something deeper: reasoning ability is partially modality-independent, and training on structured reasoning traces in one modality strengthens general cognitive processes that transfer across modalities. The cognitive behaviors taught by the synthetic data—how to set subgoals, how to verify intermediate conclusions, how to backtrack when evidence contradicts an initial hypothesis—are not tied to visual processing. They are abstract reasoning patterns that, once learned in a vision context, can be deployed when reasoning about text or audio.

This reframes vision-centric reasoning data not as a narrow domain-specific resource but as a general reasoning curriculum. The visual modality may be particularly effective for teaching reasoning because it provides rich, grounded feedback—the model's intermediate conclusions can be verified against pixel-level evidence, making the connection between reasoning steps and correctness more transparent than in purely abstract domains. If this interpretation is correct, then vision-centric synthetic data could serve as a foundation for general reasoning capabilities, with text-only and audio reasoning emerging as transfer effects rather than requiring separate training data.

The paper does not fully develop this theoretical interpretation—it presents the transfer results as empirical observations and leaves mechanistic explanation to future work. But the finding itself is robust: Tables 4 and 5 show consistent positive transfer across modalities, architectures (VL-7B and Omni-7B), and task formats (multiple-choice and open-ended). Notably, other reasoning datasets (Virgo, VLAA-Thinking) show negative transfer on MMLU-Pro, meaning the positive transfer is specific to the paper's data quality and cognitive richness, not a generic property of any reasoning data.

This has immediate practical implications: organizations training multimodal models can potentially use a single high-quality vision-centric reasoning dataset to improve performance across modalities, reducing the need for modality-specific reasoning data collection. It also opens a research direction: what properties of reasoning data (cognitive behavior diversity? step-by-step structure? difficulty distribution?) drive cross-modal transfer, and can these be optimized?

Evidence: Table 4 (+3.7 MMLU-Pro, +8.8 NiEH embodied QA), Table 5 (+1.53 MMAU-Sound, +2.87 MMAU-Music, +0.33 MMAU-Speech, +4.07 MMLU-Pro on Omni model), Table 4 negative transfer from Virgo (-9.2 MMLU-Pro) and VLAA-Thinking (-25.6 MMLU-Pro) as contrast cases.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper uses the DOCCI dataset (Onoe et al., 2024), a human-annotated dense caption dataset, as the source of high-quality image captions and images for synthetic question generation. For downstream evaluation, the primary vision-centric benchmarks are V*Bench (Wu & Xie, 2024), CV-Bench (averaged 2D and 3D), MMVP (Tong et al., 2024), RealWorldQA (xAI, 2024), and MMStar-V (Chen et al., 2024b; vision split only). For out-of-domain evaluation, MMLU-Pro (Wang et al., 2024; text-only reasoning), MMAU (Sakshi et al., 2024; audio reasoning across Sound, Music, Speech splits), and NiEH (Kim & Ammanabrolu, 2025; embodied open-ended QA) are used. MathVision and VisuLogic appear in Appendix A.7 for additional generalization testing.
Base model(s). The primary base model is Qwen2.5-VL-7B-Instruct (Bai et al., 2025), a 7B-parameter vision-language model. It is chosen as "representative of the capabilities of many contemporary VLMs" and sits in a useful regime where performance is non-trivial but far from saturated on vision-centric benchmarks, leaving room for synthetic reasoning data to make a measurable difference. For cross-modality transfer experiments, Qwen2.5-Omni-7B-Instruct (Xu et al., 2025) is used as the base omni-model, with only the "thinker" dense module fine-tuned while keeping modality-specific encoders frozen.
Metrics. The primary metric is accuracy (percentage of questions answered correctly) on each benchmark. Two evaluation protocols are used: (1) for comparisons against existing models and published results (main Table 2), the paper uses VLMEvalKit (Duan et al., 2024) with GPT-4o as a judge, following the standard practice in Liao et al. (2025a); (2) for ablations and internal comparisons (Table 11, Table 12, and the scaling analysis), a rule-based matching protocol from Liao et al. (2025a) is used for cost efficiency, with results reported without decimal when no LLM judge is involved. For the post-training analysis (Section 3.3, Table 11), average performance is aggregated over four rule-based-evaluated benchmarks to produce a single summary metric.
Baselines. The paper compares against three categories: (i) open-weight, open-data models: VLAA-Thinker (Chen et al., 2025b; trained on ~152K synthetic reasoning traces with SFT and RL), LongPerceptualThoughts / LPT (Liao et al., 2025a; 30K vision-centric problems with structured reasoning traces), ReVisual-R1 (Chen et al., 2025c), and Virgo (Du et al., 2025; ~19K math-heavy reasoning examples); (ii) open-weight, closed-data models: MiMo-VL-7B-SFT and MiMo-VL-7B-RL (Xiaomi et al., 2025; trained with a four-stage recipe on ~2.4T tokens of proprietary image, video, and text data); (iii) fully closed models: GPT-4o, o1, and Claude 3.7, with results taken from MiMo's technical report (Xiaomi et al., 2025). The base Qwen2.5-VL-7B-Instruct without fine-tuning serves as an additional reference point.
Generation budget / compute accounting. There is no formal "generation budget" comparison in this paper since the contribution is in data synthesis and training, not test-time compute scaling. The data generation pipeline's compute cost is implicitly accounted for by reporting that 75% of the data uses accessible models (Qwen2.5-VL-7B and DeepSeek-R1-Distill-Qwen-32B) and 25% uses frontier models (Qwen2.5-VL-72B, R1-671B, Qwen3-235B-Thinking), but no FLOPs or dollar-cost estimates are provided for the full synthesis pipeline. Training compute is measured in terms of dataset size (number of SFT examples, number of preference pairs for DPO/GRPO) rather than FLOPs, with scaling curves showing performance as a function of training data volume.
Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported. The post-training analysis in Table 11 reports single-run results at each data scale, and the main results in Table 2 report point estimates without confidence intervals. The paper does not discuss whether the observed differences between configurations (e.g., SFT + DPO at 0.740 vs. SFT + GRPO at 0.757) are statistically significant given the test set sizes. For the scaling analysis (Figure 2), each data point represents a single training run at that scale, and the paper does not report variance across random seeds or data shuffles.

Main Quantitative Results

Data Quality: Scale, Complexity, and CoT Richness vs. LPT

Scale comparison (Figure 2). Under identical SFT training conditions (single-stage SFT on the Qwen2.5-VL-7B-Instruct base model, with increasing dataset sizes from 50K to 1M examples), the paper's grounded MCQ synthesis maintains positive scaling slope through 1M+ examples, while the LPT baseline plateaus. The paper does not report absolute accuracy numbers for Figure 2—the y-axis shows "Average performance" on a normalized scale from 0.67 to 0.72—but the relative trend is the key finding: LPT's curve flattens after approximately 50K-100K examples, while the grounded approach continues to improve, reaching approximately 0.715 at 1M examples versus LPT's approximate 0.682 at comparable scale.

The scaling benefit is attributed to diversity rather than volume alone. The embedding analysis in Appendix A.2 quantifies this: the grounded approach produces 3.2× wider semantic spread and lower redundancy (average pairwise cosine similarity 0.61 vs. 0.82 for LPT), confirming that the improvement comes from genuinely novel training signal rather than simply having more data points.

Complexity comparison (Table 3, Figure 3a). Complexity is measured via Pass Rate (average correctness over 8 independent rollouts from Qwen2.5-VL as a policy) and Perfect Solve rate (fraction of questions where all 8 rollouts are correct). LPT achieves a Pass Rate of 66.1% and a Perfect Solve rate of 36.7%, meaning over one-third of its questions are trivially solvable by the base VLM. Stage 1 of the grounded method reduces these to 56.8% and 25.5% respectively—a meaningful improvement from diversity alone, since questions targeting less salient objects are harder for the base model. Stage 2 composition hardening further reduces the Pass Rate to 38.4% and Perfect Solve to 3.3%, representing a ~10× reduction in trivial questions from the LPT baseline.

Figure 3a visualizes this as a distribution shift: the LPT distribution is concentrated in darker green (easier problems with high pass rates), while the Stage 2 distribution shifts toward lighter green (harder problems) with a mode at lower pass rates. The average Pass Rate drops from 66.1% to 38.4%, meaning Stage 2 questions are correctly answered by the base VLM on only about 2 in 5 attempts rather than 2 in 3.

CoT Richness comparison (Table 3, Figure 3b, Table 13). Cognitive behavior frequency is quantified using the methodology of Gandhi et al. (2025) and Liao et al. (2025a): subgoal setting, backtracking, and verification behaviors are tallied on a sampled 1,000-example subset. LPT averages 0.65 total behaviors per trace, with subgoal setting nearly absent (0.036). Stage 1 of the grounded method improves to 0.80 (subgoal setting at 0.12), and Stage 2 reaches 1.99 total behaviors per trace (+206% over LPT)—with subgoal setting at 0.55 (a 4.6× increase from Stage 1), backtracking at 0.68 (up from 0.35), and verification at 0.76 (up from 0.26).

Figure 3b shows these as bar charts for Stage 1 and Stage 2 separately, making the compositional origin of the richness visible: Stage 2's multi-hop structure directly drives the increase in subgoal setting (decomposing the composed problem into its constituent parts) and verification (checking that intermediate conclusions are consistent). Table 13 contextualizes these numbers against other datasets: Virgo, the closest comparator with math-heavy traces, achieves 1.92 total behaviors (0.24 subgoal, 0.79 backtrack, 0.89 verify), comparable to Stage 2 but on a much narrower domain. Most other open datasets (PixMo, DriveLMMo1, LENS, SCI-Reason) show near-zero cognitive behaviors across all categories.

Downstream Vision-Centric Benchmark Performance

Main results versus baselines (Table 2). Fine-tuning Qwen2.5-VL-7B-Instruct on the paper's data consistently improves over the base model, while several open-data baselines degrade performance:

V*Bench: Base model achieves 75.39. LPT (SFT) reaches 80.60. The paper's SFT-only achieves 79.05, and the best configuration (Multi-stage SFT + DPO) achieves 83.25—the highest among all open-data and open-weight models, surpassing MiMo-VL-7B-RL (81.70, closed-data) by 1.55 points. VLAA-Thinker degrades to 56.54 and ReVisual-R1 degrades to 68.58.
CV-Bench: Base model achieves 74.52. The paper's best configuration (SFT + GRPO) achieves 83.80, outperforming MiMo-VL-7B-RL (82.30) by 1.50 points and MiMo-VL-7B-SFT (81.80) by 2.00 points. LPT reaches 75.30, a more modest improvement. VLAA-Thinker (72.95) and ReVisual-R1 (72.77) slightly degrade.
MMStar-V: Base model achieves 65.60. The paper's SFT + GRPO achieves 68.40, surpassing MiMo-VL-7B-RL (67.07) and MiMo-VL-7B-SFT (67.60). LPT reaches 64.13 (below base). VLAA-Thinker (63.07) and ReVisual-R1 (60.80) degrade.
MMVP: Base model achieves 74.67. The paper's best (SFT + DPO at 74.00, Multi-stage SFT + DPO at 72.33, SFT + GRPO at 72.00) slightly underperforms the base. MiMo-VL-7B-SFT achieves 78.33 and MiMo-VL-7B-RL achieves 77.67. LPT reaches 77.00.
RealWorldQA: Base model achieves 67.84. The paper's best (SFT + GRPO) reaches 69.02, versus MiMo-VL-7B-RL at 72.68 and MiMo-VL-7B-SFT at 71.90. LPT reaches 67.45 (approximately base-level).

Across the five benchmarks, the paper's configurations achieve the best open-data results on V*Bench and CV-Bench, competitive results on MMStar-V, and underperform closed-data MiMo models on MMVP and RealWorldQA. Notably, the base model outperforms VLAA-Thinker and ReVisual-R1 on most benchmarks, underscoring the negative transfer from existing open reasoning datasets.

Training configuration comparison within the paper's data (Table 2, Table 11). Multiple configurations are compared: SFT-only, SFT + DPO, Multi-stage SFT + DPO, and SFT + GRPO. The patterns are:

SFT + GRPO achieves the single best result on CV-Bench (83.80) and MMStar-V (68.40), but underperforms on V*Bench (81.68 vs. 83.25 for Multi-stage SFT + DPO).
Multi-stage SFT + DPO achieves the single best on V*Bench (83.25).
No single configuration dominates across all five benchmarks, suggesting the optimal post-training recipe may be benchmark-specific.
Table 11 reports average performance over four rule-based-evaluated benchmarks: SFT-only reaches 0.716, SFT + DPO (129K) reaches 0.740, SFT + GRPO (70K) reaches 0.757 (best), and SFT + GRPO (129K) drops to 0.746, indicating a performance plateau or slight degradation when scaling GRPO data beyond ~70K.

Out-of-Domain and Cross-Modality Transfer

Text-only reasoning (Table 4, MMLU-Pro). The base Qwen2.5-VL-7B-Instruct achieves 47.15 on MMLU-Pro. The paper's SFT-only reaches 50.82 (+3.67 points), and LPT reaches 50.77. In contrast, Virgo degrades performance to 37.95 (−9.20 points) and VLAA-Thinking degrades to 21.56 (−25.59 points), confirming that math-specific or low-quality reasoning data causes catastrophic interference with general language reasoning. SFT + DPO (47.07) and SFT + GRPO (47.00) are approximately at base-level performance, suggesting that RL stages may partially undo the text reasoning gains from SFT.

Embodied open-ended QA (Table 4, NiEH). On the modified NiEH single-evidence benchmark (829 image-question pairs, exact match), the base model achieves 47.55. The paper's SFT + DPO reaches 56.34 (+8.79 points), a substantial gain despite using entirely multiple-choice training data with no embodied or video examples. SFT-only reaches 48.24 (+0.69 points), and SFT + GRPO drops to 39.10 (−8.45 points). LPT reaches 51.95. The large gain from DPO specifically on this open-ended task, combined with the SFT-only modest gain and GRPO degradation, suggests that preference optimization may be particularly important for open-ended generalization, though the paper does not analyze this pattern in detail.

Audio reasoning on Omni model (Table 5, MMAU). The base Qwen2.5-Omni-7B-Instruct achieves MMAU averages of 76.77 (Sound), 67.33 (Music), and 68.90 (Speech), with an overall average of 71.00. Fine-tuning the thinker module on the paper's SFT data (1M examples) improves all splits: Sound to 78.30 (+1.53), Music to 70.20 (+2.87), Speech to 68.80 (−0.10, effectively flat), with an overall average of 72.32 (+1.32). SFT + DPO achieves 77.75 (Sound), 70.35 (Music), 69.23 (Speech), and 51.07 on MMLU-Pro (vs. 47.00 for the base Omni model). In contrast, Virgo degrades the Omni model to 64.20 (Sound), 59.30 (Music), 64.30 (Speech), and 39.21 (MMLU-Pro)—consistent negative transfer across all modalities. LPT achieves 76.63 (Sound), 67.56 (Music), 66.93 (Speech), and 48.74 (MMLU-Pro)—modest improvements on some splits but a slight degradation on Speech.

The paper does not report the specific training data scale for the Omni experiments; the text states results are for the "1M" configuration but this may refer to the full vision-centric dataset rather than audio-specific examples (of which there are zero). The fact that vision-centric data improves audio reasoning at all is the headline finding; the mechanism is presumably through shared reasoning patterns in the thinker module.

Math and logic generalization (Table 9, Appendix A.7). On MathVision, the base model achieves 49.57, and the paper's SFT + RL reaches 51.77 (+2.20). On VisuLogic, the base achieves 11.5, and SFT + RL reaches 19.3 (+7.80). These gains are notable because the training data contains no math-specific questions, yet the reasoning patterns learned from vision-centric composition and cognitive behaviors transfer to mathematical and logical reasoning tasks. The larger relative gain on VisuLogic (+7.80 points on a low baseline) suggests that the cognitive behaviors taught by the data—particularly subgoal decomposition and verification—are especially relevant to logical reasoning, where systematic step-by-step deduction is essential.

Post-Training Pipeline Analysis

Base model + GRPO without prior SFT (Table 11). When GRPO is applied directly to the base Qwen2.5-VL-7B-Instruct (no prior SFT), using LPT-generated problems as the RL environment (since the paper's own data requires SFT to establish the reasoning format), performance peaks at 0.695 average at 10K examples and degrades with more data: 0.683 at 50K, 0.669 at 100K. This peak is below the grounded SFT-only baseline of 0.716, and substantially below the best combined configuration (SFT + GRPO at 0.757). The degradation with more online RL data is the critical finding—more exploration does not help, and actively hurts, when the model lacks the cognitive vocabulary to produce structured reasoning traces.

When the base model is first SFT-trained on LPT data and then GRPO is applied, performance starts lower (0.678 at 1K, 0.658 at 5K, 0.662 at 10K) but eventually recovers and surpasses the no-SFT baseline: 0.685 at 50K, 0.709 at 100K. However, this still underperforms SFT on grounded data alone (0.716), indicating that the quality of the SFT data matters—LPT provides some cognitive patterns but not enough to unlock GRPO's full potential.

SFT on grounded data + GRPO (Table 11). Starting from SFT on the paper's Stage 1 data (750K examples), GRPO at 70K achieves the overall best average of 0.757. Increasing GRPO data to 129K yields 0.746, a slight degradation. This pattern—fast initial gains from online RL on top of SFT, followed by plateau or slight decline—mirrors the classic RL scaling pattern where early policy improvements are substantial but diminishing returns set in as the policy approaches the ceiling of what the reward signal can differentiate.

Offline RL (SFT → DPO) vs. online RL (Table 11). DPO on 70K preference pairs after SFT reaches 0.737; DPO on 129K preference pairs reaches 0.740. Both are within 1.7–2.0 points of the best GRPO configuration (0.757). This is a practically significant finding: offline preference optimization achieves nearly the same accuracy as online RL without requiring synchronized compute for reward model queries, policy rollouts, and updates. The paper presents this as evidence that for vision-centric reasoning at this scale, the primary value of RL is preference optimization on pre-collected data rather than exploration-driven self-improvement.

LPT SFT vs. grounded SFT (Table 11). At comparable scale (both 750K SFT examples, no RL), the grounded method reaches 0.716 versus LPT's 0.682—a +3.4 point advantage. This directly quantifies the downstream performance benefit of the grounded synthesis pipeline's diversity and complexity, independent of any RL contributions.

Scaling Behavior of CoT Quality

CoT richness ablation (Table 12). On Stage 1 data (750K examples), three configurations are compared: (1) SFT with No CoT (direct answers only, no reasoning trace in training data), (2) SFT with Short CoT (VLM-distilled traces only, no reasoning LLM expansion), and (3) SFT with Full CoT (expanded traces with cognitive behaviors). Results on CV-Bench and V*Bench:

No CoT: 0.787 (CV-Bench), 0.583 (V*Bench)
Short CoT: 0.714 (CV-Bench), 0.540 (V*Bench)—worse than No CoT on both benchmarks
Full CoT: 0.813 (CV-Bench), 0.597 (V*Bench)—best on both benchmarks

The Short CoT degradation is a critical negative result: training on low-fidelity reasoning traces provides negative transfer, reducing performance below even the no-reasoning baseline. This validates the paper's central claim that CoT richness (specifically, the cognitive behaviors injected by the reasoning LLM expansion) is not merely helpful but necessary—without it, synthetic reasoning traces teach the model to produce plausible-sounding but unhelpful reasoning that interferes with answer accuracy.

The base model with a "thinking prompt" (no SFT, just prompting the base model to produce reasoning at inference time) achieves 0.754 (CV-Bench) and 0.551 (V*Bench)—better than Short CoT SFT on CV-Bench, confirming that the negative transfer is a training artifact rather than an inference-time limitation of the base model's reasoning capability.

Ablation Studies and Robustness Checks

Prompt design for grounded MCQ generation: The paper reports that adding a "computer vision expert" role-playing preamble to the Stage 1 generation prompt improves instruction-following F1 score from 96.3 to 99.2 (Appendix A.3, "Prompt Task" section). No ablation on other prompt components (category distribution, core principles, distractor strategy) is reported, so the individual contribution of each prompt design element is not isolated.

Semantic similarity deduplication threshold: The paper states that the deduplication threshold $\tau_{\text{dup}} = 0.82$ was set "after an ablation study on the filtered question quality" (Appendix A.1), but no sweep results or sensitivity analysis are provided. The embedding model choice (all-MiniLM-L6-v2, 22M parameters) and the composite similarity weights $\lambda_s$ , $\lambda_a$ , $\lambda_c$ are stated without ablation justification.

Model scale for trace synthesis: Different teacher models are used for Stage 1 (Qwen2.5-VL-7B + R1-Distill-Qwen-32B) and Stage 2 (Qwen2.5-VL-72B + R1-671B / Qwen3-235B-Thinking). No ablation is reported on what happens if the smaller teacher configuration is used for Stage 2 or the larger for Stage 1, so the marginal benefit of frontier teacher models for the hardest examples is not quantified. The paper does note that 75% of the data uses accessible models (Stage 1) yet yields strong performance (Table 11), and that the two subsets are released separately for reproducibility, implying that the Stage 1 data alone provides most of the benefit.

SFT data scale sweep (Figure 2): The scaling curve from 50K to 1M examples shows continued positive slope for the grounded method but plateaus for LPT. This is the primary evidence for the diversity-scaling claim. However, the y-axis is normalized and absolute accuracy numbers are not provided in the figure, making it difficult to assess whether the continued scaling gains are practically meaningful (e.g., is the improvement from 750K to 1M examples a gain of 0.5 percentage points or 5?). The paper also does not report whether the scaling continues beyond 1M examples or whether diminishing returns eventually set in.

GRPO data scale sweep (Table 11, Figure 5 upper-right): For the base model + GRPO configuration, performance peaks at 10K and degrades at 50K and 100K. For SFT + GRPO, performance peaks at 70K and degrades at 129K. Both patterns suggest an optimal data scale for online RL, but the paper does not explore intermediate scales between 10K and 50K for the base model or between 70K and 129K for SFT + GRPO, leaving the precise peak location uncertain. The qualitative example in Figure 5 supports the interpretation that degradation is due to lack of cognitive behaviors, but this is a single example—no systematic analysis of what types of errors increase with more GRPO data is provided.

DPO data scale (Table 11): DPO at 70K reaches 0.737, and DPO at 129K reaches 0.740, a small improvement. The paper does not test intermediate scales or larger scales, so the DPO scaling trend beyond 129K is unknown. The finding that offline RL nearly matches online RL is based on a single online configuration (GRPO at 70K) and a single offline configuration (DPO at 129K)—a more systematic comparison sweeping both data scales and RL hyperparameters would strengthen this claim.

Caption source (DOCCI only): All experiments use DOCCI (Onoe et al., 2024), a human-annotated dense caption dataset. The paper explicitly defers exploring other caption datasets and automatically generated captions to future work (Section 3.2, "Source of high-quality image captions and metadata"). This is a significant scope limitation: the framework's dependence on high-quality human captions may limit its applicability to domains where such captions are unavailable or expensive. An ablation replacing DOCCI captions with automatically generated captions (e.g., from a VLM) would test the framework's robustness to caption quality.

Vision encoder frozen during SFT: The paper fine-tunes only the language decoder, keeping the vision encoder frozen (Section 3.2, "Training Algorithms"). No ablation with full model fine-tuning is reported, so the impact of this design choice on downstream performance and cross-modality transfer is unknown. Freezing the vision encoder focuses learning on reasoning but may limit the model's ability to adapt visual representations to the specific perceptual demands of the synthetic questions.

Guided decoding for trace expansion: The paper introduces regex-guided decoding to prevent the reasoning LLM from referencing image captions explicitly during trace expansion. The paper states this "substantially improves distillation efficiency and utilization at scale" (Section 2.3) but provides no ablation comparing guided vs. unguided decoding, no quantitative measure of the caption-reference problem's frequency without guided decoding, and no measure of how much guided decoding improves downstream model performance.

Multi-stage SFT curriculum (Stage 1 then Stage 2): The paper uses a curriculum: first SFT on Stage 1 (~750K) for one epoch, then SFT on Stage 2 (~251K) with halved learning rate. No ablation is reported on alternative orderings (Stage 2 first, interleaved, or combined from the start), making it unclear whether the curriculum itself matters or whether the total data volume and composition are sufficient.

Format reward for GRPO: The GRPO reward includes a +0.1 format bonus for correct <thinking> and <response> tags. No ablation on the format reward weight or on removing it entirely is reported, so the sensitivity of GRPO's success to this auxiliary reward signal is unknown.

Single seed for all training runs: The paper does not mention multiple random seeds for any training configuration. All results in Tables 2, 4, 5, 9, 11, and 12 appear to be single-run. The paper does not report variance, standard deviations, or confidence intervals, making it impossible to assess whether the differences between configurations (e.g., SFT + DPO at 0.740 vs. SFT + GRPO at 0.757) are statistically significant or within run-to-run noise.

Critical Assessment

The experiments provide strong support for the paper's central claim that grounded object metadata overcomes caption-only diversity saturation, enabling continued scaling to 1M+ examples where prior methods plateau. Figure 2 shows this clearly: the grounded approach maintains positive slope while LPT plateaus, and the embedding analysis in Appendix A.2 provides a mechanistic explanation (3.2× wider semantic spread, lower redundancy). The major caveat is that the absolute accuracy gain from 750K to 1M examples appears modest on the normalized y-axis scale, and the paper does not report whether further scaling beyond 1M would continue to yield improvements or eventually plateau as well. The claim of "successfully scaling beyond 1M+ examples without performance saturation" is supported in the sense that the curve still has positive slope at 1M, but it is unclear whether the marginal benefit of additional data is large enough to justify the synthesis cost at that scale.

The claim that composition hardening reduces trivially solvable problems by ~10× is well-supported by Table 3 and Figure 3a, with concrete numbers: perfect-solve rate drops from 36.7% (LPT) to 3.3% (Stage 2), and average pass rate drops from 66.1% to 38.4%. However, the paper does not report what fraction of the full dataset goes through Stage 2 composition (~251K out of 1M+, so roughly 25%), meaning the majority of the training data comes from Stage 1, which still has a 25.5% perfect-solve rate. The ~10× reduction applies specifically to the Stage 2 subset, not the full dataset. The paper does not analyze whether the performance gains come primarily from the composition-hardened subset or from the diverse but simpler Stage 1 data—a data-mixture ablation would clarify whether composition is essential or whether Stage 1's grounded diversity alone accounts for most of the improvement.

The claim of +206% increase in cognitive behavior frequency is supported by Table 3 and Figure 3b, but the quantification methodology has important limitations. The cognitive behavior counts come from a sampled 1,000-example subset using the methodology of Gandhi et al. (2025) and Liao et al. (2025a), which relies on keyword-based or pattern-based detection of behaviors. This methodology may miss implicit cognitive behaviors that are not signaled by explicit linguistic markers (e.g., subgoal setting without saying "first, I need to..."), or may overcount formulaic language that mimics cognitive behaviors without genuine reasoning. The paper does not validate the automatic behavior counts against human annotation, so the absolute frequencies should be treated as approximate. Nonetheless, the relative comparison across datasets using the same methodology is informative, and the increase from Stage 1 to Stage 2 (aligned with the multi-hop structure of composition) is internally consistent.

The main benchmark results in Table 2 demonstrate that the paper's data substantially improves over the base model and outperforms all open-data baselines on multiple vision-centric benchmarks. However, the paper's configurations do not uniformly dominate: they lose to closed-data MiMo models on MMVP and RealWorldQA, and no single training configuration (SFT-only, SFT + DPO, Multi-stage SFT + DPO, SFT + GRPO) is best across all five benchmarks. This suggests that the optimal training recipe may be benchmark-specific, which weakens the claim that the data itself is the primary differentiator—if the best configuration varies by benchmark, other factors (training algorithm, hyperparameters) are also important.

The cross-modality transfer results are among the paper's most interesting findings but also the least thoroughly analyzed. The +3.67 point improvement on MMLU-Pro (Table 4) is meaningful, but it is a single benchmark of text reasoning, and the gain comes primarily from SFT-only (50.82 vs. 47.15)—the RL configurations (47.07 for DPO, 47.00 for GRPO) are at or near base-level, suggesting that RL on vision-centric data may partially undo text reasoning gains. The paper does not analyze why SFT transfers positively but RL does not, which limits the practical guidance for practitioners who want both vision and text improvements. The NiEH improvement (+8.79 points for SFT + DPO) is striking, but it is a specific variant of the benchmark (single-evidence, 829 image-question pairs), and the paper does not report results on the original NiEH benchmark or on standard embodied QA benchmarks, making it difficult to assess the robustness of this transfer claim.

The audio transfer results (Table 5) are the most surprising, given zero audio data in training. The improvements (+1.53 Sound, +2.87 Music, essentially flat Speech, +1.32 overall MMAU average) are modest in absolute terms but consistent across splits. However, the paper does not report the training data scale for the Omni experiments precisely, does not ablate whether the improvements come from the SFT stage or the DPO stage, and does not test whether alternative vision-centric datasets (LPT, Virgo) also produce positive audio transfer when trained on the Omni model at comparable scale. The Virgo result (−8.40 overall average) suggests negative transfer is possible, but the LPT result (70.23 overall average vs. 71.00 base) shows essentially flat performance, making the paper's positive transfer the exception rather than the rule. Understanding why this dataset transfers positively when others don't requires analysis the paper does not provide.

The post-training analysis (Table 11) is the most systematically ablated part of the paper and provides genuinely useful insights. The finding that base model + GRPO peaks early and degrades (0.695 at 10K, 0.669 at 100K) is a clear empirical result, and the conclusion that "online RL necessitates offline teaching of cognitive behaviours" follows naturally. However, there is an important confound: the paper uses LPT-generated problems as the RL environment for the base model + GRPO experiments, not its own grounded problems. This means the base model + GRPO is trained and evaluated in a different data distribution than the SFT-trained models, making the comparison not entirely clean. The paper's claim that SFT on grounded data is necessary for GRPO to work might reflect the quality difference between LPT and grounded problems as the RL training environment, rather than an intrinsic requirement for cognitive behavior teaching. An experiment running GRPO directly on grounded problems from the base model (without prior SFT) would be needed to disambiguate this—but the paper's format and reasoning requirements may make this impossible without some initial SFT, which is itself evidence for the claim.

The finding that offline RL (DPO) comes within 1.7 points of online RL (GRPO) is practically significant but requires qualification. The comparison is at a single data scale (70K–129K), and the DPO result (0.740 at 129K) uses twice as much preference data as the best GRPO result (0.757 at 70K). The paper does not test whether further scaling DPO data would close the gap entirely, or whether GRPO at its optimal scale would maintain its advantage if both were given the same preference data budget. The claim that offline RL "could match online RL's performance while disaggregating compute demands" is directional but not fully demonstrated—the gap is still 1.7 points, which may be practically meaningful depending on the application.

Missing experiments that would strengthen the paper:

Human validation of cognitive behavior counts. The automatic behavior detection methodology is reasonable but unvalidated. A small human annotation study confirming that the automatically detected behaviors correspond to genuine cognitive processes (rather than formulaic language patterns) would substantially strengthen the CoT richness claims.
Data-mixture ablation. How much does Stage 2 composition data contribute versus Stage 1 grounded data alone? Training on Stage 1 only, Stage 2 only, and the full mixture would quantify the marginal value of composition hardening, which is currently unknown since all configurations use the full dataset.
Caption source ablation. Using automatically generated captions (e.g., from a VLM) instead of human-annotated DOCCI captions would test whether the framework's success depends on high-quality human captions or generalizes to cheaper, noisier caption sources.
Multiple random seeds for training. The absence of variance estimates makes it impossible to assess whether the configuration rankings are robust or noise-driven. Three runs of the main configurations would provide standard deviations and enable statistical comparisons.
Cross-validation across benchmark splits. The paper reports results on fixed test sets. Cross-validating the optimal configuration selection (e.g., which RL data scale is best, which combination of SFT and RL is optimal) across different random splits of the benchmarks would test whether the configuration choices overfit to the specific test sets.
GRPO on grounded problems from base model (if format-compatible). Directly comparing SFT + GRPO against base + GRPO on the same RL problem distribution would cleanly isolate the effect of prior SFT, removing the confound of different RL environments (LPT vs. grounded problems).
Scaling beyond 1M examples. The paper demonstrates continued positive slope at 1M but does not test whether the curve eventually plateaus. Extending the scaling curve to 2M or 5M examples would characterize the saturation point for the grounded approach.
Inference-time compute analysis. The paper focuses entirely on training-time data scaling but does not analyze how the trained models behave under test-time compute scaling (e.g., majority voting, best-of-N, or beam search with a verifier). Given the paper's emphasis on cognitive behaviors (verification, backtracking) that are naturally deployed at inference time, an analysis of how test-time compute interacts with the learned reasoning patterns would be informative.

Despite these gaps, the paper's core empirical contributions are well-supported: (1) grounded metadata overcomes caption-only diversity saturation, enabling continued scaling to 1M+ examples (Figure 2, Appendix A.2); (2) composition hardening substantially increases problem difficulty and cognitive behavior frequency (Table 3, Figure 3); (3) the resulting data enables training VLMs that outperform all open-data baselines and compete with closed-data models (Table 2); (4) SFT on high-quality data with cognitive behaviors is a prerequisite for effective online RL (Table 11, Figure 5); and (5) the vision-centric data transfers positively to text, audio, and embodied reasoning (Tables 4, 5). The specific numeric claims (4× efficiency, ~10× trivial problem reduction, +206% behavior increase) are appropriately qualified by the conditions under which they hold. The most significant unaddressed weakness is the lack of statistical rigor (no variance estimates, single runs) and the absence of key ablations (data mixture, caption source, multiple seeds), which leaves uncertainty about the robustness and generalizability of several findings.

6. Limitations and Trade-offs

The Difficulty Estimation and Strategy Allocation Cost Is Unaccounted For

The assumption or constraint. The paper explicitly acknowledges in Section 3.2 that estimating difficulty via the current method—generating 2048 samples per question and averaging correctness or PRM final-answer scores—is computationally expensive, comparable to or exceeding the test-time compute budgets being studied (256–512 generations). The authors state:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The difficulty estimation is treated as a one-time pre-computation whose cost is excluded from all efficiency and budget calculations. In practice, amortizing this cost across a sufficient number of queries following the same difficulty distribution is necessary for the reported gains to materialize—but the paper provides no analysis of how many queries are needed, how stable difficulty estimates are across time, or what happens when the query distribution shifts.

The consequence. The headline claim of "more than 4× better efficiency over a standard best-of-N baseline" is computed after difficulty is known, without accounting for the cost of learning it. In a deployment with few queries per prompt or rapidly changing prompts, the difficulty estimation cost could dominate the total budget, erasing or even reversing the reported gains. In the worst case—a single query at a new, unseen difficulty level—the entire framework would either require ~2048 upfront generations to estimate difficulty (making the total cost vastly larger than any budget studied) or rely on a heuristic guess whose accuracy is untested. The predicted difficulty bins (using PRM scores instead of ground-truth labels, Appendix C) partially mitigate the oracle requirement but still incur the full 2048-sample generation cost per question.

What evidence exists in the paper. Figures 4 and 8 show that both oracle and predicted difficulty bins outperform best-of-N baseline allocations after difficulty is known, with the cost excluded. The paper does not report the total compute including difficulty estimation in any figure or table. Appendix C (Figures 11–12) shows that predicted bins track oracle bins closely, suggesting that the PRM-based difficulty proxy is reliable, but this does not address the fundamental cost problem—it only confirms that ground-truth labels are not necessary, not that the estimation is cheap.

Mitigation status. The paper explicitly flags this as a key avenue for future work in Section 3.2: "this is an exploration–exploitation tradeoff—compute spent assessing difficulty versus compute spent solving the problem—flagging it as a key avenue for future work." No method for reducing difficulty estimation cost is developed or evaluated. The paper mentions the possibility of "pretraining or finetuning models to directly predict difficulty of a question" but does not implement it. An adaptive scheme—starting with a few samples, estimating difficulty from those, and allocating the remaining budget—is suggested but not tested. The reported 4× efficiency gains therefore represent an upper bound on achievable efficiency assuming difficulty estimation can eventually be made cheap, not a realized deployment gain.

Hard Problems Remain Fundamentally Unsolved Irrespective of Budget

The assumption or constraint. The entire compute-optimal framework is predicated on the base model having non-trivial performance on the problems being solved—the base model must produce correct solutions at some non-zero rate for search or revision to find them. For difficulty bin 5 (the hardest quintile, where the base model's pass@1 is near zero), this assumption fails. The paper is transparent about this:

"On the hardest questions (bin 5), no method makes meaningful progress—the base model simply lacks the capability to produce correct solutions regardless of how the budget is allocated." (Section 5.3)

The consequence. For the hardest problems, test-time compute provides essentially zero benefit regardless of strategy or budget. In Figure 3 (right), bin 5 accuracy hovers at 1–3% for all search methods at all budgets up to 256 generations. In the revision setting (Figure 7, right), bin 5 shows roughly 2–3% accuracy irrespective of the sequential-to-parallel ratio. In the FLOPs-matched comparison (Section 7, Figure 9), the bin 5 scaling line is essentially flat near 0–5% for both revisions and PRM search, well below the ~14× larger model's performance. This establishes a hard capability boundary: test-time compute amplifies existing capability but cannot create it from nothing. If the base model has near-zero probability of producing a correct answer, no amount of search or revision can help—there are no correct solutions in the proposal distribution to find or refine.

What evidence exists in the paper. The bin 5 results are visible across every figure broken out by difficulty: Figure 3 (right), Figure 7 (right), Figure 9 (left and right). The FLOPs-matched comparison in Section 7 makes this explicit: on hard questions at R ≫ 1, using test-time compute on the smaller model shows a −52.9% relative disadvantage compared to the ~14× larger pretrained model (Figure 1, bar chart, bottom-right). The paper's own takeaway box in Section 7 summarizes: "Some capabilities can only be acquired through pretraining, not recovered at inference time."

Mitigation status. The paper does not attempt to solve this limitation—it is presented as a fundamental property of the approach rather than a bug. The framework is explicitly scoped to problems within the base model's rough capability range. For problems outside that range, the paper recommends scaling pretraining (larger models, more data) rather than test-time compute. This is a clean and honest demarcation, but it means the method offers no path forward for genuinely novel or out-of-distribution reasoning tasks where the base model has never seen similar problems during training. The paper suggests this as a boundary condition for when to prefer test-time compute versus pretraining (Section 8, "When to Prefer This Method Over Alternatives"), which is a useful practical guideline but not a mitigation.

No Combination of Revisions and PRM Search Is Tested

The assumption or constraint. The paper studies two complementary mechanisms—PRM-guided search (Section 5) and iterative revisions (Section 6)—entirely independently. The search experiments use the few-shot prompted base LLM as the proposal distribution, not the revision model. The revision experiments use majority voting or an ORM for answer selection, not PRM-guided search. Section 8 explicitly acknowledges this gap:

"we did not experiment with PRM tree-search techniques in combination with revisions"

The paper presents revisions as modifying the proposal distribution and PRM search as modifying the verification/selection mechanism, and argues conceptually that these are complementary axes (Section 2 framing). However, the empirical interaction between these axes—whether combining them yields additive gains, synergistic gains, or interference—is entirely unexplored.

The consequence. The current results represent a lower bound on what a fully integrated system could achieve, but the nature of the potential gain is unknown in both magnitude and sign. Three scenarios are possible: (1) synergistic gains: PRM search applied to revision model outputs could find better solutions than either alone, since the proposal distribution is improved and the selection is optimized simultaneously; (2) additive but non-interacting gains: each mechanism provides its independent benefit, and combining them yields the sum of individual improvements; (3) interference: the PRM, trained on base model outputs, may not transfer well to revision model outputs (the paper already shows in Appendix J, Figure 15a that the base-LM PRM underperforms the revision-specific ORM when scoring revision outputs, confirming distribution shift). In scenario 3, combining PRM search with revisions could actually degrade performance relative to using each independently. Without empirical evidence, practitioners cannot know which scenario holds, preventing informed integration decisions.

What evidence exists in the paper. The paper provides indirect evidence of potential interference: Appendix J (Figure 15a) shows that the base-LM PRM underperforms the revision-specific ORM when scoring revision model outputs. The paper also shows in Appendix E that PRM aggregation strategy matters (last-step aggregation works best, contrary to prior work), suggesting that PRM behavior is sensitive to the proposal distribution. These findings hint that naively combining PRM search with revision model outputs might not work well without additional adaptation, but no direct experiment tests this. Appendix K provides a cautionary negative result: attempting to optimize the revision model with ReST^EM (an RL-based approach) caused performance to substantially degrade with sequential revisions, demonstrating that revision model behavior is sensitive to the training and deployment recipe.

Mitigation status. The paper acknowledges this as an explicit limitation in Section 8 and suggests it as future work: combining PRM tree-search with the revision model as the proposal distribution. No experimental results or preliminary analyses of this combination are provided. The current work therefore studies the two mechanisms in isolation, and the complementarity claim—while conceptually well-motivated by the Section 2 framework—remains empirically unverified at the mechanism-combination level. Practitioners building on this work should be cautious about assuming that combining search and revisions will yield straightforward improvements without additional engineering to handle the distribution shift documented in Appendix J.

All Results Are on a Single Benchmark (MATH) with a Single Model Family (PaLM 2-S*)

The assumption or constraint. The entire paper's empirical findings—scaling behavior, difficulty-dependent strategy selection, over-optimization patterns, compute-optimal allocation benefits—are derived from experiments on the MATH benchmark (Hendrycks et al., 2021) using PaLM 2-S* (Codey) as the base model. The authors argue in Section 4 that this model is "representative of the capabilities of many contemporary LLMs" and that MATH is appropriate because "test-time compute is expected to help most when the model already possesses the necessary knowledge and the challenge is drawing complex inferences—mathematical reasoning fits this profile." However, no experiments are conducted on any other model (e.g., LLaMA, GPT, Claude) or any other benchmark (e.g., GSM8K, HumanEval, ARC, commonsense reasoning, code generation).

The consequence. Several aspects of the findings could be model-specific or benchmark-specific, and their generalization is unverified:

PRM over-optimization patterns (Figure 3, right—beam search degrading easy-problem performance at high budgets) depend on the PRM's calibration and reliability, which in turn depends on the base model's output distribution. A base model with different error patterns, confidence calibration, or reasoning style could produce PRMs with different over-optimization thresholds, potentially shifting the optimal strategy per difficulty bin.
Revision model training success depends on the base model's in-context learning ability and its capacity to learn from sequences of incorrect-then-correct examples. Model families differ substantially in in-context learning quality; the 38% correct-to-incorrect reversion rate (Section 6.1) might be higher or lower with other base models, changing the practicality of sequential revision deployment.
MATH as a benchmark consists exclusively of competition-level math problems with exact ground-truth answers amenable to string matching. The difficulty-dependent patterns might differ for tasks requiring commonsense reasoning, factual recall, multi-turn dialogue, or open-ended generation where correctness is ambiguous. The PRM training pipeline (Monte Carlo rollout correctness) depends on having verifiable correct answers—extending this to tasks without clean verification signals would require fundamentally different approaches.
Difficulty estimation via pass@1 uses MATH's ground-truth answer format for oracle difficulty; for tasks without such clean answers, even the oracle difficulty estimation would break down.

What evidence exists in the paper. None. There are no cross-model or cross-benchmark experiments. The paper does not report results on GSM8K, HumanEval, commonsense QA, or any non-MATH benchmark. The representativeness claim for PaLM 2-S* is stated in Section 4 without supporting evidence (e.g., comparisons showing that PaLM 2-S*'s MATH performance and scaling patterns are similar to other models in its size class). The paper does not even report whether the base PaLM 2-S* model's MATH performance is typical for a model of its scale, making it impossible to assess whether the difficulty-dependent findings (especially the sharp bin 5 failure) would replicate at different base performance levels.

Mitigation status. The authors acknowledge this as scope limitation implicitly by not claiming generality beyond MATH and PaLM 2-S*, but do not explicitly flag it as a limitation in Section 8 or the limitations discussion. The paper frames its contributions as establishing a framework and methodology (Section 2, 3) that could be applied to other models and benchmarks, and the specific numeric findings are qualified by the experimental setup. The authors "believe this model is representative" (Section 4) but do not provide evidence. This is perhaps the most significant gap for practitioners wanting to deploy the approach in production: without cross-model and cross-benchmark validation, it is uncertain whether the optimal strategy selection (beam search on medium problems, best-of-N on easy problems, sequential revisions preferred on easy problems) would transfer to their specific model, task, and data distribution, or whether the entire difficulty-bin approach would need to be re-derived from scratch.

The FLOPs-Matched Baseline Uses a Sub-Optimally Trained Larger Model

The assumption or constraint. The FLOPs-matched comparison in Section 7 measures whether test-time compute on PaLM 2-S* can outperform a model with approximately 14× more parameters under matched total (pretraining + inference) FLOPs. However, the larger model is scaled in parameters only, keeping training data fixed:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work." (Section 7)

This follows the LLaMA paradigm (Touvron et al., 2023) rather than the Chinchilla-optimal scaling (Hoffmann et al., 2022), where both model size and training data are scaled simultaneously. A Chinchilla-optimal model trained with 14× more total FLOPs would be smaller in parameters but trained on more data, potentially yielding better performance per FLOP than the parameter-only-scaled model used as baseline. Additionally, the 14× larger model uses only greedy decoding—no test-time compute augmentation of its own (no best-of-N, no majority voting, no search). This is a deliberately weak baseline that biases the comparison in favor of test-time compute.

The consequence. The reported advantages of test-time compute over pretraining—e.g., +27.8% relative improvement on easy-medium questions at R ≪ 1 for revisions, and matching or exceeding the larger model on easy-to-medium problems across R values (Section 7, Figure 9)—may be overstated relative to what a properly optimized pretraining baseline would achieve. Two specific inflations are likely:

Chinchilla-optimal pretraining would strengthen the baseline. A model trained with 14× more FLOPs allocated optimally between parameters and data would likely outperform a parameters-only-scaled model at the same total compute, narrowing or reversing the test-time compute advantage.
Greedy decoding is a weak inference baseline. A fairer comparison would give the larger model a modest test-time compute budget (e.g., best-of-8, or a budget proportional to some fraction of the smaller model's budget). The paper's comparison effectively compares test-time-compute-augmented small model versus test-time-compute-deprived large model, which confounds the pretraining-vs-inference tradeoff with an inference-method choice.

What evidence exists in the paper. The authors explicitly acknowledge the design choice in Section 7 and frame it as representing "a canonical approach"—which is accurate for the LLaMA family of models but not for compute-optimal training. The paper does not provide experimental evidence on how much stronger the baseline would be under Chinchilla-optimal scaling or with test-time compute given to the larger model. The sensitivity of the FLOPs-matched results to this design choice is unknown. The paper also does not discuss how the three R values (R ≪ 1, R ≈ 1, R ≫ 1) interact with the choice of parameter-only scaling—different R regimes emphasize different components of total FLOPs, and the bias may be larger or smaller depending on R.

Mitigation status. The paper explicitly flags this as a limitation in Section 7 and leaves Chinchilla-optimal pretraining comparisons to future work. The authors also acknowledge that "a fairer comparison might give the larger model some test-time compute budget as well" is worth exploring. However, no sensitivity analysis or even back-of-the-envelope calculation is provided to estimate how much the conclusions would change under the alternative baseline. Practitioners reading the FLOPs-matched comparison should treat the reported test-time compute advantages as upper bounds that assume a sub-optimally trained and greedily decoded larger model as the pretraining baseline. The paper's broader qualitative conclusion—that test-time compute can be more effective than pretraining for problems within the base model's capability range—is likely robust to baseline choice, but the precise crossover points (at what difficulty level, at what R value) are likely dependent on the specific baseline construction.

The Test Set Is Small (500 Questions) and the Compute-Optimal Strategy Is Selected Post-Hoc

The assumption or constraint. All experiments use a fixed 500-question test split from MATH (from Lightman et al., 2022). The compute-optimal strategy per difficulty bin is selected by two-fold cross-validation within this test set: half the questions in each bin are used to choose the best strategy, and the other half are used for evaluation, with results averaged (Section 3.2). The five difficulty quintiles thus contain approximately 100 questions each, and within each fold, strategy selection is based on roughly 50 questions.

The consequence. The small per-bin sample size introduces substantial variance in the computed-optimal policy selection. A strategy that appears best on 50 questions may not be the truly optimal strategy for the difficulty distribution—random variation in which specific 50 questions land in the selection fold could change which strategy is chosen, and therefore change the reported evaluation performance. The paper does not report confidence intervals on the compute-optimal scaling curves (Figures 4, 8), making it impossible to assess whether the observed differences between strategies are statistically reliable or within sampling noise.

This limitation is compounded by the fact that the compute-optimal strategy is selected post-hoc on the same test set (via cross-validation) rather than on a separate held-out development set. While cross-validation within the test set is methodologically reasonable, it means the strategy selection process has effectively "seen" the test questions (through the selection fold) before evaluation, and there is no held-out set to confirm that the selected strategies generalize to truly unseen questions from the same difficulty distribution. The cross-validation is designed to prevent overfitting, but with only 500 total questions, the evaluation fold can still be influenced by the selection fold through shared distributional properties.

What evidence exists in the paper. The paper does not report confidence intervals, standard deviations, or any measure of statistical uncertainty for any result. The two-fold cross-validation is described but its impact on variance is not analyzed. The compute-optimal curves in Figures 4 and 8 show point estimates without error bars, making it impossible to distinguish meaningful differences (e.g., a 1–2 percentage point gap between oracle and predicted difficulty bins in Figure 8 at high budgets) from sampling noise. The 500-question test set is standard for MATH evaluations, but the per-bin sample sizes (~100 questions per bin, ~50 per fold) are small for the granularity of strategy selection being performed.

Mitigation status. The paper does not address this limitation—no larger test set, no additional held-out set, no bootstrapping or confidence interval computation is performed. The two-fold cross-validation is the only mitigation, and while it prevents the most egregious form of overfitting (selecting and evaluating on the same data), it does not address the fundamental variance problem from small per-bin sample sizes. Practitioners should interpret the precise numeric values in Figures 4 and 8—especially comparisons between close configurations—as suggestive rather than definitive, and should expect that the optimal strategy per difficulty bin might differ with a different test set or model, even if the qualitative pattern (adaptivity helps, different strategies work best at different difficulties) is robust.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not propose a new training algorithm or model architecture—it proposes a new data synthesis methodology and, through it, delivers a new diagnostic about what matters in VLM post-training. The conceptual shift is from viewing synthetic visual reasoning data as a commodity (more is better, quality is secondary) to viewing it as an engineering problem with specific, identifiable failure modes: diversity saturation, insufficient complexity, and cognitive shallowness. The paper's value is in decomposing "data quality" into measurable dimensions and showing that each dimension independently matters for downstream performance.

This is not a paradigm shift in the sense of replacing one framework with another—it is a reframing of priorities within the existing paradigm. Before this work, the dominant narrative around visual reasoning (influenced by the success of DeepSeek R1 in text) emphasized reinforcement learning as the key to eliciting sophisticated reasoning behaviors. The paper's central empirical finding—in Table 11 and Figure 5—directly challenges this narrative: online RL applied to a base VLM without prior exposure to complex reasoning traces peaks early (0.695 at 10K examples) and degrades with more data, underperforming simple SFT on high-quality synthetic data (0.716). The qualitative evidence in Figure 5 makes the mechanism concrete: the base model + GRPO produces superficially correct-format output with shallow reasoning ("The image does not show an SUV car..."), while the SFT-pretrained model exhibits genuine self-correction ("Wait, actually, looking back, the image does have a silver-colored SUV..."). The RL reward signal alone—binary correct/incorrect—is too sparse to bootstrap these cognitive patterns from scratch, at least at the scale studied.

This finding reframes SFT in the RL-for-reasoning pipeline from a "warm-start" or "helpful initialization" to a prerequisite for teaching the vocabulary of cognitive moves—what backtracking looks like in language, how verification is phrased, when to set subgoals. Without this vocabulary, the model cannot explore the space of structured reasoning strategies because it has no representation of what those strategies look like. This is a significant corrective to the post-R1 discourse and makes the paper's data synthesis framework (which explicitly targets cognitive behavior richness) more important than any particular training recipe.

The paper also reconciles a latent tension in the literature that was less visible than in text reasoning but equally real. Prior work on multimodal reasoning data fell into two camps: domain-specific distillation (Virgo for math, DriveLMM-o1 for driving, SCI-Reason for scientific images) that produced rich traces but failed to generalize (Table 4: Virgo degrades MMLU-Pro by −9.2 points), and general-domain synthesis (LPT, VLAA-Thinking) that attempted scale but hit diversity and complexity ceilings (Figure 2: LPT plateaus). The paper's resolution is that the synthesis methodology—specifically, how questions are generated (grounded vs. caption-only) and how traces are expanded (VLM + reasoning LLM with guided decoding)—is the differentiator, not the domain. The same methodology applied to general visual scenes produces data that transfers positively across modalities (text: +3.7 MMLU-Pro; audio: +1.32 MMAU; embodied QA: +8.8 NiEH), while poorly synthesized data even in the right domain causes negative transfer. This reframes the conversation from "what domain should we collect data from?" to "how should we synthesize it regardless of domain?"

The cross-modal transfer finding—that entirely vision-centric data improves audio reasoning (Table 5) and text reasoning (Table 4)—is the paper's most surprising result and the one most likely to stimulate new research. It suggests that reasoning ability is at least partially modality-independent, and that training on rich cognitive traces in a grounded modality (vision, where perceptual feedback is concrete) can strengthen general cognitive processes. This was not obvious ex ante and is not predicted by any existing theory. If replicated and extended, it could change how multimodal models are trained: rather than collecting modality-specific reasoning data for each capability (text, vision, audio, video), a single high-quality vision-centric dataset might suffice as a general reasoning curriculum, with other modalities benefiting through transfer. This is speculative based on one paper's results, but the consistency of positive transfer across three modalities (text, audio, embodied QA) and two model architectures (VL-7B, Omni-7B) makes it worth taking seriously.

A less visible but practically important shift is in how the paper positions data diversity as a scalability bottleneck. The embedding analysis in Appendix A.2—showing that caption-only generation collapses to a narrow semantic manifold (average pairwise cosine similarity 0.82) while grounded generation maintains spread (0.61)—provides a quantitative diagnostic for why some synthetic data pipelines scale and others don't. This has implications beyond vision: any synthetic data pipeline that conditions generation on a lossy textual proxy of a richer signal (captions for images, summaries for documents, descriptions for code) may face analogous saturation, and the paper's solution (inject structured metadata that forces the generator to attend to different aspects of the underlying signal) is a generalizable pattern.

Finally, the paper's finding that offline RL (DPO, 0.740) nearly matches online RL (GRPO, 0.757) while decoupling compute demands is a practical insight with immediate implications for resource allocation in VLM post-training. If the primary value of RL at this scale is preference optimization on pre-collected data rather than exploration-driven self-improvement, then organizations can separate data collection (expensive generation) from policy optimization (cheap DPO training), enabling more flexible compute scheduling. This finding is specific to the scale and model studied—it may not hold for larger models or longer RL runs—but it provides a concrete counterpoint to the assumption that online RL is always worth the synchronization overhead.

Follow-Up Research This Work Enables

Systematic characterization of when RL bootstraps reasoning without prior SFT. The paper's most striking negative result—base model + GRPO peaks at 0.695 (10K) and degrades to 0.669 (100K), underperforming SFT-only—raises a question it cannot fully answer: is this failure due to insufficient RL scale (10K–100K examples might be too little for exploration to discover cognitive patterns), insufficient model scale (7B might be too small to support emergent reasoning through RL alone), or an inherent limitation (RL reward signals are too sparse to bootstrap structured reasoning regardless of scale)? A strong follow-up would replicate the base model + GRPO experiment at larger scales—e.g., on a 32B or 72B VLM, running GRPO to 500K–1M examples—and measure whether the peak-and-degrade pattern persists or whether a threshold scale exists beyond which RL begins to elicit cognitive behaviors without prior SFT. If the pattern breaks at larger scales, it would reconcile the paper's findings with the R1 narrative (which used much larger models). If it holds, it would establish a fundamental limitation of pure RL for reasoning. The paper's data synthesis pipeline provides the controlled environment—verifiable questions, diverse difficulty, consistent format—needed to run this experiment at scale.

Ablation of which data properties drive cross-modal transfer. The paper demonstrates positive transfer from vision-centric data to text, audio, and embodied reasoning (Tables 4, 5), but the mechanism is a black box. Is the transfer driven by the cognitive behaviors in the reasoning traces (backtracking, verification, subgoal setting), by the diversity of visual concepts (which might build general perceptual reasoning), by the multi-hop compositional structure, or by some interaction? A follow-up would train separate models on: (1) vision data with simple CoTs (no cognitive behaviors), (2) vision data with single-hop questions (no composition hardening), (3) vision data with cognitive behaviors only, and (4) the full dataset. Measuring transfer to text (MMLU-Pro), audio (MMAU), and embodied reasoning (NiEH) for each configuration would isolate which data property drives transfer. If cognitive behaviors alone account for the transfer, it would validate the paper's implicit claim that reasoning is a modality-independent skill teachable through rich traces in any grounded domain. If the transfer requires both diversity and cognitive richness, it would suggest a more nuanced picture where the model needs broad exposure to visual reasoning patterns to abstract general cognitive strategies.

Grounding-free difficulty estimation via learned predictors. The paper flags the cost of its difficulty estimation method (2048 samples per question) as a critical bottleneck for deployment. A natural follow-up would train a lightweight difficulty predictor—a small classification head on top of a frozen VLM—that takes only the question text (and optionally the image) as input and predicts the difficulty quintile. Training data for this predictor already exists: the paper has 1M+ questions with oracle difficulty labels (derived from pass@1 rates). The evaluation would measure: (1) how well the predictor's difficulty assignments correlate with oracle difficulty, (2) whether a compute-optimal policy using predicted difficulty achieves similar efficiency gains as using oracle difficulty, and (3) whether the predictor generalizes to out-of-distribution questions (e.g., from different benchmarks or image sources). If a cheap predictor can recover most of the 4× efficiency gains, it would make the compute-optimal framework practically deployable. The paper's existing infrastructure—difficulty bins, optimal strategy lookup tables—provides a drop-in evaluation framework for any such predictor.

Combining grounded synthesis with composition hardening in a unified generation pipeline. The paper's two-stage pipeline (Stage 1: ground and diversify, Stage 2: compose and harden) treats these as sequential operations. A more integrated approach would use the composition algorithm during Stage 1 itself—generating grounded questions about specific objects and composing them with questions about nearby objects in a single pass—potentially increasing both diversity and complexity simultaneously. The question is whether integrated composition yields harder problems with better coverage than the two-stage approach, or whether the sequential separation is important (e.g., because Stage 1 filtering ensures compositional material is high-quality). A follow-up would implement an integrated generator and compare the resulting data distribution (pass rates, perfect-solve rates, cognitive behavior frequencies) and downstream training performance against the two-stage baseline, using the same total generation budget. The paper's evaluation infrastructure—pass rate metrics, cognitive behavior counting, benchmark evaluations—provides a complete test harness.

Stress-testing the cross-modal transfer claim with controlled negative baselines. The paper shows positive transfer from its data but only tests two negative baselines (Virgo and LPT, Tables 4 and 5) and does not systematically vary data properties to isolate the transfer mechanism. A strong stress-test would construct synthetic vision datasets that are identical in format and scale but vary along one dimension: high cognitive behavior frequency vs. low, diverse visual concepts vs. repetitive, compositional questions vs. single-hop, grounded generation vs. caption-only. Training identical models on each and measuring cross-modal transfer would identify which properties are necessary and which are sufficient. If a dataset with diverse visual concepts but zero cognitive behaviors still transfers positively, it would refute the paper's implicit claim that cognitive richness drives transfer. If cognitive behaviors are necessary but not sufficient (i.e., diversity matters too), it would establish a more precise specification for transfer-inducing data. This experiment also serves as a robustness check: if the positive transfer fails to replicate with independently generated data following the paper's protocol, it would suggest an unidentified confound in the original experiments (e.g., an artifact of the specific teacher models or captions used).

Extending the data synthesis pipeline to open-ended and generative visual tasks. The paper's data is entirely multiple-choice, yet Table 4 shows transfer to open-ended embodied QA (NiEH, +8.8 points). This suggests the reasoning patterns learned from MCQ data generalize to tasks requiring free-form generation, but the paper does not design its pipeline for open-ended supervision. A natural extension would modify the synthesis pipeline to generate open-ended visual questions: instead of producing four-option MCQs, the grounded generator would produce a question with a free-text answer (e.g., "Describe the spatial relationship between the bag and the window") verifiable against the grounded metadata and dense caption. Training on such data would more directly target open-ended visual reasoning, which is underserved by existing benchmarks (most vision-centric datasets are MCQ). The evaluation would measure both open-ended generation quality (using LLM-as-judge or human evaluation) and whether the resulting model maintains the MCQ benchmark improvements of the original pipeline. The paper's grounded metadata approach (bounding boxes with coordinates) is particularly well-suited to open-ended spatial reasoning questions, since the coordinates provide ground truth for relationships that can be expressed in natural language.

Practical Applications and Downstream Use Cases

Cost-efficient batch generation of high-quality visual reasoning training data. The paper's primary practical contribution is a recipe for generating 1M+ high-quality vision-centric reasoning examples without human annotation. For organizations training VLMs—whether academic labs with limited budgets or industry teams preparing post-training data—this represents a concrete, reproducible pipeline that produces demonstrably better results than existing open alternatives. The specific efficiency gain is that the grounded synthesis approach avoids the diversity saturation that causes caption-only methods to plateau (Figure 2): an organization investing compute in data synthesis can expect continued performance improvements through at least 1M examples, whereas caption-only methods see diminishing returns after ~50K–100K. The practical recommendation following from the paper's findings is to allocate roughly 75% of the synthesis budget to grounded single-hop generation (Stage 1, using accessible models like Qwen2.5-VL-7B and R1-Distill-Qwen-32B) and 25% to composition hardening (Stage 2, using frontier models for the hardest examples). The paper's release of the two subsets separately enables this allocation strategy without requiring access to frontier teachers for the full pipeline.

VLM post-training with decoupled compute scheduling. The finding that offline RL (SFT → DPO at 0.740) nearly matches online RL (SFT → GRPO at 0.757) while decoupling compute demands (Section 3.3, Table 11) has immediate practical implications for teams with constrained or shared compute resources. Online RL requires synchronized generation and training—the policy generates rollouts, receives rewards, and updates in a tight loop, tying up GPU clusters and preventing flexible scheduling. Offline RL separates data collection (which can happen once, using the best available model) from policy optimization (which can run as a batch job during low-utilization periods). The paper provides evidence that the accuracy penalty for this flexibility is modest (~1.7 points on average across four benchmarks), making offline RL the pragmatically preferred choice for many deployment scenarios. A team with intermittent access to a large GPU cluster can generate preference data during a single allocation window and then train via DPO on smaller, more consistently available resources—a workflow that would be impossible with online RL. The specific recipe (SFT on 750K examples, DPO on 129K preference pairs with β = 1, SFT loss weight 0.5) is provided with sufficient detail for reproduction.

Deployment of reasoning-capable VLMs in domains with limited task-specific data. The cross-modal transfer findings (Tables 4, 5) imply that organizations deploying VLMs for specialized tasks—audio understanding, embodied agent control, open-ended visual QA—can potentially improve reasoning performance without collecting domain-specific reasoning data. The paper shows that training on vision-centric MCQ data (zero audio, zero embodied interaction, zero open-ended generation examples) yields: +1.53 on MMAU-Sound, +2.87 on MMAU-Music, +8.79 on NiEH embodied QA, and +3.67 on MMLU-Pro text reasoning. For a team building an audio reasoning system, this means they can take an off-the-shelf Omni model, fine-tune on the paper's vision-centric data (which is being released), and expect improved audio reasoning as a transfer effect—then optionally fine-tune further on domain-specific audio data if needed. The specific recipe for the Omni model (fine-tune only the "thinker" dense module, keep modality-specific encoders frozen) is provided and shown to be effective. This is practically valuable because high-quality audio reasoning data is far scarcer and more expensive to collect than vision data, making the transfer pathway a cost-effective bootstrapping strategy.

Quality control for synthetic visual reasoning data pipelines. The paper's decomposition of data quality into measurable dimensions—pass rate complexity (Table 3), cognitive behavior frequency (Table 13), and semantic diversity (Appendix A.2, Figure 7)—provides a quality control framework that organizations can apply to their own synthetic data pipelines. Rather than relying on downstream benchmark performance (which is expensive to evaluate frequently) as the sole quality signal, teams can monitor these intermediate metrics during data generation: if cognitive behavior frequency drops, the expansion step may need attention; if semantic similarity increases, the diversity filter threshold may need adjustment; if pass rate is too high, composition hardening intensity should increase. The paper does not provide automated monitoring tools, but the metrics are well-defined and the measurement methodology (sampling 1K examples, computing embeddings with all-MiniLM-L6-v2, counting cognitive behaviors via keyword patterns) is described in sufficient detail for replication. For teams generating synthetic data at scale, this shifts quality assurance from a post-hoc evaluation step to an inline monitoring process, potentially catching pipeline degradation before it wastes significant compute.

When to Prefer This Method

The paper positions its grounded synthesis + composition hardening framework against two alternatives: caption-only synthesis (exemplified by LPT) and domain-specific distillation (exemplified by Virgo and VLAA-Thinking). The tradeoffs are clear from the empirical results:

Prefer grounded synthesis (this method) over caption-only synthesis when the goal is to scale synthetic visual reasoning data beyond ~50K examples without saturation (Figure 2: LPT plateaus, grounded method maintains positive slope through 1M+), when the downstream task requires diverse visual reasoning across object types and spatial relationships rather than a narrow visual domain (the embedding analysis in Appendix A.2 confirms 3.2× wider semantic spread), and when complex cognitive behaviors in reasoning traces (backtracking, verification, subgoal setting) are important for downstream performance (Table 12: Short CoT from VLMs alone degrades performance, only expanded traces with cognitive behaviors help). The cost is the additional dependency on object detection (Grounded-SAM) and the more complex prompt engineering (1,987 tokens vs. 419 tokens for LPT).
Prefer grounded synthesis over domain-specific distillation when cross-task and cross-modality generalization matter (Tables 4, 5: Virgo degrades MMLU-Pro by −9.2 points and MMAU by −8.4 points, while this method improves both), when the domain of interest has no existing high-quality reasoning data to distill from (this method creates data from any image with a caption and object detector, requiring no domain-specific expert traces), and when open-ended generalization from MCQ training is desired (Table 4: +8.8 points on open-ended embodied QA without any open-ended training data). The tradeoff is that domain-specific distillation (e.g., Virgo on math) may achieve higher peak performance within its narrow domain if in-domain reasoning is the only objective—the paper does not compare against Virgo on math-specific benchmarks, so the upper-bound performance tradeoff is unknown.
Prefer offline RL (SFT → DPO) over online RL (SFT → GRPO) when compute resources are shared or intermittently available (DPO decouples data collection from policy optimization, enabling flexible scheduling), when the accuracy penalty of ~1.7 points (Table 11: 0.740 vs. 0.757) is acceptable for the application, and when preference data can be pre-collected from the best available model without needing to run synchronized generation during training. Prefer online RL when the ~1.7-point accuracy gain is worth the synchronization overhead and when the compute budget allows for longer exploration (though the paper shows GRPO gains plateau and slightly degrade beyond ~70K examples, suggesting the window for online RL benefit is finite).

These preferences are conditioned on the paper's specific experimental setup (Qwen2.5-VL-7B, DOCCI captions, MATH-based difficulty benchmarks) and should be validated on the target model and domain before committing to a pipeline architecture. The paper's open-source release of both data subsets and training recipes makes this validation practical.