Revisiting the Necessity of Lengthy Chain-of-Thought in Vision-centric Reasoning Generalization

🎯 Pitch

Longer and richer visual Chain-of-Thought traces may accelerate learning, but they don't improve the final reasoning ceiling—concise, minimally grounded CoT generalizes best. Stripping away verbose language and image manipulations leaves a sparse coordinate path that yields the strongest cross-size maze-solving performance, revealing a counterintuitive “short is long” effect where less supervision builds more transferable visual logic.

1. Executive Summary

This paper systematically analyzes how different Chain-of-Thought (CoT) formats affect the acquisition of generalizable visual reasoning in vision-language models, using a controlled maze-solving benchmark and an SFT-then-RL pipeline on Qwen2.5-VL-7B to compare three representative CoT designs—Language CoT (natural language reasoning traces), Grounding CoT (spatial coordinate trajectories), and Visual CoT (image manipulations such as line-drawing to externalize intermediate thoughts). The experiments reveal a “short is long” effect: concise CoT traces containing only essential grounding information (e.g., sparse coordinate paths without explicit textual explanation) consistently surpass longer, more verbose CoT formats in both final accuracy and generalization across maze sizes, while visual and longer CoT accelerate training convergence but do not raise the final performance ceiling—establishing that well-grounded but minimal supervision better encourages reusable visual reasoning patterns, with the least-grounded CoT variant (G-CoT-least) achieving the strongest cross-scale generalization (e.g., maintaining high success rates on unseen 10×10 mazes after training on 4×4–6×6 mazes in SFT and 7×7–9×9 mazes in RL).

2. Context and Motivation

The Core Problem: We Don't Know Why CoT Designs Work for Visual Reasoning

The fundamental question this paper tackles is deceptively simple: when training vision-language models to perform visual reasoning, what kind of intermediate reasoning traces actually help the model learn generalizable skills? This matters because the field has converged on a strong consensus—chain-of-thought reasoning improves performance—yet beneath that consensus lies a deep uncertainty about which specific CoT formats are responsible for the gains, and what mechanisms they operate through.

The paper identifies three distinct ways that CoT can be expressed in visual reasoning tasks (Section 2):

Language CoT (L-CoT): The model expresses its entire reasoning process in natural language—describing spatial relationships, planning next moves, reflecting on mistakes—without directly interacting with or annotating the image. This mirrors the dominant paradigm from large language models applied to vision.
Grounding CoT (G-CoT): The model explicitly links linguistic descriptions to precise spatial locations in the image by outputting coordinate sequences (e.g., absolute pixel coordinates of each step in a maze path) alongside textual reasoning. This adds a layer of spatial precision that pure language lacks.
Visual CoT (V-CoT): The model actively manipulates the image itself—drawing lines, cropping regions, marking points—and feeds the modified image back into subsequent reasoning steps, enabling interleaved image–text deliberation. This is the most recent and, by some accounts, most powerful paradigm, exemplified by OpenAI's o3 "think with image" capability.

The critical problem is that these three CoT paradigms externalize reasoning in fundamentally different ways—linguistic abstraction, spatial coordinate reference, and visual manipulation—yet the field has adopted increasingly complex and lengthy CoT formats (particularly visual CoT with extensive deliberation) without understanding whether the complexity actually improves generalization or merely accelerates convergence on training-distribution data.

Why This Distinction Matters: The Gap Between Convergence and Generalization

The paper's framing reveals a subtle but crucial distinction that prior work largely conflates: convergence speed during training versus the asymptotic performance ceiling after full training, and in-distribution accuracy versus out-of-distribution generalization.

If longer, more elaborate CoT traces primarily accelerate optimization—providing richer gradients that help the model converge faster to a solution that it would eventually reach anyway—then the practical value of complex CoT is mainly computational efficiency during training, not improved capability. But if complex CoT actually raises the final performance ceiling and enables better generalization, then it constitutes a genuine capability improvement worth the additional annotation and compute cost.

The paper explicitly sets up this tension in the introduction:

"While CoT data, especially long or visual CoT such as 'think with image', has been widely used to supervise intermediate reasoning, it remains unclear why specific CoT designs help and which ones truly support generalizable reasoning."

The phrase "truly support generalizable reasoning" is key—the paper is not questioning whether CoT helps (the baseline evidence for that is overwhelming), but rather interrogating whether the fanciest forms of CoT are actually responsible for the generalization benefits, or whether simpler forms might work equally well or better once we properly control for training convergence.

This has significant practical implications. Generating lengthy, well-structured CoT traces—especially visual CoT data that requires interleaved image manipulation—is expensive in terms of human annotation or API costs for synthetic generation. If short, grounded traces achieve the same final performance, practitioners can save substantial resources in SFT dataset construction. Conversely, if lengthy traces are genuinely necessary for generalization, then cutting corners on CoT quality during supervised fine-tuning could produce models that appear competent during training but fail catastrophically on novel problem variants.

The Prior Consensus: Longer CoT Is Better, Visual CoT Is Best

To understand why this paper's findings are surprising and important, we need to establish what the field believed before this work. The intellectual backdrop is a convergence of several influential lines of evidence:

The "scaling CoT length" literature in LLMs. Work on long chain-of-thought for large language models—particularly in math reasoning (Hendrycks et al., 2021) and code generation (Jain et al., 2024)—has consistently found that longer, more detailed reasoning traces improve performance. Models that generate multi-step deliberation, self-verification, and explicit reflection substantially outperform those that jump directly to answers. The open-source reasoning model community has operationalized this into a design principle: more thinking tokens → better answers. Papers like OpenThoughts (Guha et al., 2025) explicitly treat scaling the length of reasoning traces as a primary mechanism for improving model capability.

The emergence of visual CoT as a new paradigm. Beyond textual CoT, the most celebrated recent advance has been the ability to reason directly in visual space. OpenAI's "thinking with images" capability (2025) demonstrated that models could crop relevant regions, draw bounding boxes, trace paths, and iteratively refine their visual understanding—achieving performance that appeared to exceed what was possible with language-only reasoning. This created a powerful narrative: the future of visual reasoning involves models that can actively manipulate and annotate images during their deliberation process, not merely describe what they see in text.

The SFT-then-RL training recipe. The dominant paradigm for imbuing VLMs with reasoning capabilities follows a two-stage process: first, supervised fine-tuning on high-quality CoT data to teach the model how to reason in the desired format; then, reinforcement learning (typically GRPO or a variant) to refine the reasoning policy through trial-and-error optimization against task-specific reward functions. This recipe has produced state-of-the-art results across visual math, STEM reasoning, and spatial reasoning benchmarks (Deng et al., 2025; Wang et al., 2025; Team, 2025).

Observations of short CoT in vision-centric RL. Intriguingly, several researchers noticed a puzzling pattern: when RL is applied to vision-centric tasks (rather than language-dominant ones like math word problems), the reasoning traces that emerge from optimization tend to be surprisingly short. Models trained with RL on spatial reasoning, object recognition, and puzzle-solving tasks produce concise CoT traces, even when initialized from SFT data containing lengthy reasoning (Sarch et al., 2025; Li et al., 2025; Wu et al., 2025). This observation was noted but not systematically explained—it was an anomaly that the "longer is better" narrative couldn't account for.

Where Prior Work Falls Short: Three Unresolved Questions

The paper's motivation crystallizes around three specific gaps that prior work leaves unaddressed:

Gap 1: No controlled comparison of CoT formats. Existing work studies Language CoT, Grounding CoT, and Visual CoT in isolation, on different benchmarks, with different base models, and under different training protocols. There is no apples-to-apples comparison where the same model, same task, same training budget, and same evaluation metrics are applied across all three formats. This makes it impossible to determine whether reported performance differences come from the CoT format itself or from confounding factors (better base models, more training data, different task difficulty). The paper explicitly positions its controlled maze benchmark as a solution to this confound.

Gap 2: The mechanism behind visual CoT's benefits is unknown. When visual CoT outperforms language CoT—as it often does in prior work (e.g., DeepEyes by Zheng et al., 2025; Thyme by Zhang et al., 2025)—is the gain coming from: (a) the visual manipulation itself providing new information that language cannot capture, (b) the visual operations acting as a structured regularization that guides optimization, (c) the additional computation (more tokens, more forward passes through the vision encoder) providing more thinking capacity, or (d) simply the fact that visual CoT traces tend to be longer and more detailed, and the length alone accounts for the benefit? Without isolating these mechanisms, researchers cannot make principled decisions about which CoT format to use for a given task.

Gap 3: The relationship between CoT format and generalization is unexplored. Perhaps most critically, prior work evaluates CoT strategies primarily on in-distribution test sets—the same problem types, sizes, and distributions seen during training. But generalizable reasoning—the ability to transfer learned rules to larger mazes, more complex puzzles, or novel visual configurations—is what distinguishes true reasoning from pattern matching. The paper's central contribution is to ask: which CoT format best supports this kind of compositional generalization, and why? This question was essentially absent from prior work, which implicitly assumed that better in-distribution performance would translate to better generalization.

The Specific Problem: Conflicting Signals from Practice and Theory

The paper is motivated by a genuine tension between what the "scaling CoT" narrative predicts and what practitioners observe in vision-centric RL:

Prediction from the LLM CoT literature: Longer, more detailed reasoning traces should improve performance, and visual reasoning (adding a modality) should outperform text-only reasoning, because richer intermediate representations allow more precise deliberation.
Observation from vision-centric RL: Models trained with RL on visual reasoning tasks often converge to short, minimal CoT traces, and their performance after RL does not seem substantially better than what shorter-CoT baselines achieve.
The open question: Is the second observation just a quirk of specific implementations (insufficient training, poor hyperparameters, suboptimal reward design), or does it reveal something fundamental about how vision-centric reasoning differs from language-dominant reasoning? In other words, is the field wasting effort on elaborate CoT constructions when minimal grounding would suffice?

The paper's systematic experiments are designed to resolve this tension by providing the first controlled comparison that disentangles format, length, and generalization across a common evaluative framework.

How This Paper Positions Itself

The paper positions itself not as proposing a new CoT method (there is no novel "Du-CoT" or similar contribution), but rather as providing a rigorous empirical analysis of existing CoT paradigms to understand their mechanisms and identify which elements actually drive generalization. This is an important distinction: the paper's contribution is analytical and explanatory, not methodological.

Several design choices reflect this positioning:

Controlled synthetic benchmark (maze navigation). Rather than using existing benchmarks where models may have memorized patterns from pretraining data, the paper constructs a clean maze-solving task where: (a) the reasoning rule is purely visual and can be precisely specified, (b) difficulty is tunable by grid size, (c) intermediate steps (paths, coordinates, annotated images) can be automatically generated without human annotation, and (d) current VLMs perform poorly (~10% accuracy on 4×4 mazes for Qwen2.5-VL-7B), providing headroom to study learning dynamics without ceiling effects. This contrasts with prior work that often uses math or science benchmarks where pretrained knowledge confounds the analysis of reasoning acquisition.

SFT-then-RL paradigm on a single base model. All experiments use the same base model (Qwen2.5-VL-7B), the same training data synthesis pipeline (rule-based path generation + Gemini-2.5-Pro prompting for reasoning trace synthesis), and the same RL algorithm (GRPO with identical hyperparameters). The only variable is the CoT format. This controlled design directly addresses Gap 1 above.

Extended RL training to convergence. The paper explicitly notes that prior visual RL work "typically train models for only a few hundred—or even just tens of—steps, which often leaves the model under-trained and makes its true performance ceiling unclear" (Section 3.3). By training for up to 1000 RL steps until convergence, the paper ensures that comparisons reflect asymptotic capabilities, not transient training dynamics. This is critical for distinguishing acceleration effects from ceiling effects.

Generalization as the primary evaluation criterion. Rather than reporting only in-distribution accuracy (on the same maze sizes seen during training), the paper evaluates generalization to unseen larger mazes: single-scale generalization (training on 6×6, testing on 7×7) and cross-scale generalization (SFT on 4×4–6×6, RL on 7×7–9×9, testing on 10×10). This directly addresses Gap 3 and operationalizes "generalizable visual reasoning" in a way that prior work did not.

Connection to broader vision-centric tasks. To demonstrate that the findings are not artifacts of the maze domain, the paper extends its analysis to two visual games (FrozenLake and Jigsaw) and two real-world VQA benchmarks (V* and HR-Bench), showing that the "short CoT" advantage replicates across diverse settings. This bridges the controlled synthetic experiments to practical applications.

The Conceptual Framework: Three Axes of CoT Variation

To structure its comparison, the paper formalizes three distinct axes along which CoT formats differ (Section 2):

Externalization modality: How is intermediate reasoning represented? Pure text (Language CoT), text + spatial coordinates (Grounding CoT), or interleaved text–image–manipulation sequences (Visual CoT).
Length and verbosity: How much content is in the reasoning trace? The paper studies this both implicitly (V-CoT and G-CoT are longer than G-CoT-least by construction) and explicitly (comparing full G-CoT versus minimal G-CoT-least).
Grounding density: How tightly is each reasoning step anchored to specific visual evidence? Visual CoT grounds reasoning through direct image manipulation; Grounding CoT through coordinate references; Language CoT through spatial language without precise coordinates; G-CoT-least through the output trajectory alone.

These three axes are not independent—visual CoT tends to be long and highly grounded; G-CoT-least is short and minimally grounded above the task requirements—but the paper's experiments are designed to partially disentangle them by comparing formats that differ primarily along one axis while controlling others.

The Stakes Beyond Academic Interest

While the paper is framed as a controlled scientific study, the practical stakes are substantial. The current trend in the VLM community—driven by the success of OpenAI's visual reasoning and the broader "scaling CoT" narrative—is toward increasingly elaborate, multimodal CoT data. Models like Mini-o3 (Lai et al., 2025) and Simple-o3 (Wang et al., 2025) invest heavily in constructing interleaved visual–textual reasoning traces. DeepEyes (Zheng et al., 2025) explicitly incentives "thinking with images" via reinforcement learning. The implicit assumption across this line of work is that visual manipulation and lengthy deliberation are necessary ingredients for strong visual reasoning.

If that assumption is wrong—if minimal grounding traces achieve the same or better generalization at lower data construction cost—then the field is collectively over-investing in CoT complexity. The paper's "short is long" finding, if robust, would redirect research effort away from elaborate CoT engineering and toward understanding the minimal sufficient supervision for visual reasoning. The finding that models can "internalize and operate over their own latent spatial representations without relying on externally specified coordinate systems" (Section 4.2.2) suggests that the current focus on explicit, verbose intermediate representations may be solving a problem the model doesn't actually have once its grounding ability is properly aligned with the visual environment.

Conversely, if the paper's findings are specific to maze-like spatial reasoning tasks and don't generalize to more complex visual reasoning (multi-step visual search, abstract diagram comprehension, open-ended visual question answering), then the "short is long" effect may be a domain-specific curiosity rather than a general principle. The paper's extension to additional tasks (Section 4.3) provides initial evidence for broader applicability, but the scope is still limited, and the authors explicitly acknowledge this as a direction for future work.

Summary of the Papers' Motivational Arc

The VLM field has converged on CoT as essential for visual reasoning, but uses three distinct CoT formats (Language, Grounding, Visual) without understanding their relative strengths.
Prior work, influenced by LLM scaling results, assumes that longer and more elaborate CoT (especially visual manipulation) is better, but this assumption rests on confounded comparisons across different models, tasks, and training protocols.
Puzzling observations from vision-centric RL—where models trained with GRPO converge to short CoT traces—hint that the relationship between CoT complexity and reasoning capability may be different for vision-dominant tasks than for language-dominant ones.
No prior work has systematically studied which CoT elements (modality, length, grounding density) actually support generalization versus merely accelerating convergence, leaving practitioners without principled guidance for constructing SFT data.
The paper addresses these gaps through a controlled maze-solving benchmark with an SFT-then-RL pipeline that compares CoT formats on identical footing, training to convergence, and evaluating on held-out difficulty levels to isolate generalization from in-distribution performance.

tags) followed by the final path sequence (in\boxed{}`). The reasoning trace can take any of the four formats described below, but the output format constraint is identical across conditions: the final answer must be a list of coordinate tuples representing the complete path.

3.4.2 Language CoT (L-CoT) Synthesis

Language CoT expresses the entire reasoning process in natural language without any explicit coordinate references or image manipulations. The model describes its movement decisions using directional terms ("North," "South," "East," "West"), reflects on dead ends, plans alternative routes, and narrates backtracking—all in text.

Data construction pipeline. The paper uses a three-step synthesis process:

Step 1: Path-to-directions conversion. A rule-based function takes the ground-truth path $P = [(i_s, j_s), (i_2, j_2), \ldots, (i_e, j_e)]$ and converts each consecutive pair of grid coordinates into a cardinal direction. For example, moving from cell $(0, 4)$ to cell $(0, 3)$ produces the direction "West" (since the column index decreases while the row index stays constant). This yields a direction sequence that encodes the same information as the coordinate path but in a linguistically natural format for maze walking.

Step 2: Depth-first search path generation. The paper generates multiple DFS paths through the maze—including both incorrect paths that hit dead ends (with recorded backtrack points) and the single correct path. These serve as the raw material for the CoT narrative: the language CoT describes exploring promising routes, reaching dead ends, reflecting on mistakes, backtracking to previous decision points, and eventually finding the correct path.

Step 3: Gemini-2.5-Pro narrative synthesis. The direction sequences, maze structure metadata (start/end positions), and DFS path information are fed to Gemini-2.5-Pro with a detailed prompt (reproduced in Appendix, Figure 6). The prompt instructs the model to "simulate the process of an intelligent person walking through a maze: observe the maze, analyze possible actions, and narrate your reasoning step-by-step." Critical constraints in the prompt: (a) the model must NOT reference the successful path or visual cues directly—it must simulate decisions "as if made naturally based on the maze structure alone," (b) it should use only directional language (North/South/East/West) and not output coordinates, and (c) it should be "verbose and thorough in reflecting and planning" at decision points while being concise when simply following corridors.

What the resulting L-CoT data looks like. Each example contains: an image of the maze with S and E markers, the instruction text, and a lengthy textual reasoning trace (enclosed in thinking tags) where the model walks through the maze step-by-step, describes available moves, makes decisions, occasionally hits dead ends and backtracks, and finally outputs the correct path in \boxed{}. The reasoning trace contains no pixel coordinates, no [x,y] annotations, and no image modifications—it is pure natural language spatial reasoning.

Why this format for Language CoT: Language CoT represents the conventional LLM-style reasoning paradigm applied to visual tasks. The model must internally map visual observations ("I see a fork ahead") to linguistic descriptions and then plan subsequent moves using only textual representations. This format tests whether linguistic abstraction alone—without explicit spatial anchoring—is sufficient for learning generalizable maze-solving rules. If the model can learn internal spatial representations from language-only supervision, then elaborate grounding annotations may be unnecessary. If it cannot, then some form of spatial anchoring (coordinates, visual marks) is required.

3.4.3 Grounding CoT (G-CoT) Synthesis

Grounding CoT extends Language CoT by explicitly anchoring each reasoning step to precise spatial coordinates in the image. Every movement decision or reflection is accompanied by the absolute pixel coordinate $[x_k, y_k]$ of the current grid cell, creating a tight coupling between linguistic reasoning and spatial reference.

Data construction pipeline. The synthesis follows the same three-step structure as L-CoT but with two key differences:

Step 1: Grid-to-coordinate conversion. Instead of converting paths to directions, a rule-based function converts each grid cell $(i_k, j_k)$ to its absolute pixel coordinate $[x_k, y_k]$ in the rendered maze image. The mapping from grid indices to pixel positions depends on the image rendering parameters (cell size, margins, image dimensions), but since the paper controls the rendering pipeline, this is a deterministic, known mapping.

Step 2: DFS path generation with reflection patterns. Beyond the standard DFS paths used in L-CoT, the G-CoT synthesis introduces explicit "reflection patterns"—synthesizing several incorrect paths (paths that lead to walls or dead ends) along with corresponding correction reasoning where the model acknowledges the mistake and plans an alternative route. These reflection patterns add an element of self-correction to the reasoning trace, making it more elaborate than simple forward path-tracing.

Step 3: Gemini-2.5-Pro synthesis with coordinate grounding. The prompt (Appendix, Figure 7) instructs the model to simulate an intelligent person "first try the first DFS path, then reflect and plan for the next DFS path; try the second DFS path, then reflect and plan for the next DFS path, etc." Crucially, at each step the model outputs both a textual reasoning segment $r^{(g)}_t$ and a spatial grounding $g_t = (\text{point}, [x_k, y_k])$ that marks the current position. The model is instructed to "pretend to make this mistake and pretend to explain why this move is correct" when describing failed paths—it should sound confident at the time of the decision even though the subsequent step will reveal the dead end and trigger reflection.

Formal structure of G-CoT. As defined in Section 2.2, the grounding CoT trajectory is $R^{\text{grd}}_T = ((r^{(g)}_1, g_1), (r^{(g)}_2, g_2), \ldots, (r^{(g)}_T, g_T))$ , where each grounded element $g_k = (G_k, C_k)$ consists of a grounding type $G_k \in \{\text{point}, \text{line}, \text{region}\}$ and spatial coordinates $C_k \subset [0,1]^2$ (normalized image coordinates). In the maze task specifically, all groundings are points at grid cell centers, so $G_k = \text{point}$ and $C_k = (x_k, y_k)$ . The model generates these grounded steps sequentially: $(r^{(g)}_t, g_t) \sim \pi_\theta(\cdot \mid Q, I, R^{\text{grd}}_{t-1})$ .

What the resulting G-CoT data looks like. Compared to L-CoT, G-CoT traces are: (a) longer, because they include both the textual narration and explicit coordinate annotations at every step, (b) more spatially precise, because coordinates provide exact locations that language cannot convey with the same fidelity, and (c) include explicit reflection cycles where the model describes trying a path, hitting a dead end (with coordinate evidence), backtracking to a previous junction (with coordinate reference), and trying a different route—providing richer supervision for error recovery strategies.

Why this format matters for the comparison: G-CoT sits between Language CoT and Visual CoT on the spectrum of spatial anchoring. It provides precise spatial references (unlike L-CoT's vague directional language) but does not modify the image (unlike V-CoT's drawing operations). This allows the paper to isolate whether the benefit of spatial precision comes from the grounding annotations themselves or from the active visual manipulation that Visual CoT adds on top. If G-CoT performs similarly to V-CoT, then visual manipulation is unnecessary—coordinate annotations suffice. If G-CoT underperforms V-CoT, then the image-level feedback loop in V-CoT provides unique value.

3.4.4 Grounding CoT Least (G-CoT-least) Construction

G-CoT-least is the paper's most interesting and counterintuitive variant. It is not synthesized via Gemini-2.5-Pro at all—instead, it is simply the ground-truth path sequence $P = [(i_s, j_s), (i_2, j_2), \ldots, (i_e, j_e)]$ with all intermediate reasoning stripped away. There is no thinking block, no directional narration, no coordinate annotations, and no reflection. The model is given the maze image and the instruction, and the training target is the raw path sequence in \boxed{}.

Why this is still "CoT": The paper argues that the path sequence itself implicitly encodes the reasoning process, because: (a) the path represents the sequence of visited grid positions, which is equivalent to the spatial trajectory that the model would need to internally trace, and (b) the path structure (which cells are adjacent, where the path turns, where backtracking would have been necessary if the path were generated step-by-step) contains compressed information about the navigation decisions. In effect, G-CoT-least provides the "answer" in a form that is isomorphic to the reasoning trace—the coordinates are both the intermediate steps and the final output.

Construction process. No Gemini-2.5-Pro prompting is needed. The rule-based path-to-coordinate conversion described for G-CoT directly produces the sequence of grid coordinates. These are formatted as the model's output target, wrapped in \boxed{}. Since "the answers in G-CoT-least inherently contain the reasoning process, we do not separate them" (Section 3.2)—there is no thinking response separation because the answer format already encodes the full trajectory.

What G-CoT-least removes compared to full G-CoT: The full G-CoT trace contains: (1) textual narration describing decisions, (2) explicit coordinate references at every step, (3) reflection cycles describing dead ends and backtracking, (4) explanations of why certain moves are chosen, and (5) the final path. G-CoT-least removes elements (1)–(4) entirely, retaining only the minimal grounding necessary to specify the answer: the ordered list of visited coordinates. This represents an extreme compression of the CoT—from thousands of tokens (for V-CoT with interleaved images) to potentially tens of tokens (for a short path on a small maze).

Why this variant is the linchpin of the analysis: If G-CoT-least matches or exceeds the performance of full G-CoT, L-CoT, and V-CoT after RL training (as the paper's results will show), then the entire apparatus of elaborate CoT construction—textual narration, explicit coordinate annotation, visual manipulation, reflection cycles—may be superfluous for learning generalizable maze-solving once the model's grounding ability is properly aligned. This would imply that SFT's primary role in the SFT-then-RL pipeline is not to teach the model what to think (the content of the reasoning) but rather to establish the output format and grounding alignment that RL can then refine into an efficient internal policy. It would also suggest that the field's investment in constructing elaborate CoT data may be solving a problem (insufficient grounding alignment) that could be addressed more directly and cheaply.

3.4.5 Visual CoT (V-CoT) Synthesis

Visual CoT represents the most elaborate CoT format: at each reasoning step, the model selects a grounding target (a pixel coordinate on the image), applies a line-drawing operation to visualize the partial path explored so far, and then the modified image is fed back as input for the next reasoning step. This creates an interleaved image–text reasoning loop where the model can visually track its own progress.

Formal structure. As defined in Section 2.2, the visual CoT trajectory is $R^{\text{vis}}_T = ((r^{(v)}_1, g_1, I_1), (r^{(v)}_2, g_2, I_2), \ldots, (r^{(v)}_T, g_T, I_T))$ , where $I_t$ is the updated image after applying operation $\phi_t$ to the previous image conditioned on grounding $g_t$ : $I_{t+1} = \phi_t(I_t, g_t)$ . The operation function $\phi_t$ can perform point marking, line drawing, or region cropping—in the maze task specifically, $\phi_t$ draws lines connecting consecutive visited coordinates, gradually building up a visual trace of the explored path.

Data construction pipeline. The synthesis is more complex than the other formats because it requires generating a sequence of intermediate images:

Step 1: Grid-to-coordinate conversion. Same as G-CoT: convert each grid cell $(i_k, j_k)$ in the path to its absolute pixel coordinate $[x_k, y_k]$ .

Step 2: Progressive image rendering. The paper defines $\phi_t$ as a line-drawing operation: for each step $t$ , draw lines connecting the sequence of coordinates $[x_1, y_1], [x_2, y_2], \ldots, [x_t, y_t]$ on the maze image, producing image $I_t$ that shows the partial path from the start point $s$ to step $t$ . This generates a sequence of intermediate images $\{I_1, I_2, \ldots, I_T\}$ , where each $I_t$ adds one more line segment to the previous image.

Step 3: Gemini-2.5-Pro multimodal synthesis. The prompt (Appendix, Figure 8) instructs Gemini-2.5-Pro to synthesize reasoning trajectories that interleave textual narration, coordinate annotations, and calls to a fictional image_draw_points_tool function. The model is told to: (a) describe each exploration attempt in text, (b) call the drawing tool when it finishes a try using the format "Let's use the image_draw_points_tool to visualize this try: <path>[[x1,y1], [x2,y2], ...]</path>", (c) check the drawn image from the previous step for analysis of the current path, and (d) reflect on wrong explorations only after visualizing them (not before). This creates a narrative where the model explores, visualizes, observes the visualization, realizes the dead end, backtracks, and tries again—exactly the pattern that "think with image" systems like o3 are designed to support.

Step 4: Image-text interleaving for training. The synthesized trajectories are formatted as interleaved sequences: a textual reasoning segment, followed by a coordinate list representing the path to draw, followed by the corresponding intermediate image showing that path rendered. During training, the vision encoder processes each intermediate image $I_t$ separately, and the language model attends to the sequence of image embeddings and text tokens in order.

What the resulting V-CoT data looks like. A typical V-CoT example for a 6×6 maze might contain: (1) an initial description of the maze and goal, with a call to visualize the first attempted path, (2) image $I_1$ showing a partial path hitting a dead end, (3) textual reflection observing the dead end and planning a new route from the last junction, (4) a call to visualize the new attempt, (5) image $I_2$ showing a different partial path, and so on, iterating through several failed attempts until (6) the final successful path is visualized and output in \boxed{}. The entire trace is substantially longer than L-CoT or G-CoT because it includes multiple images and the textual narration around each visualization step.

Training loss computation for V-CoT. A crucial implementation detail: during SFT, "the cross-entropy loss is computed only over textual tokens" (Section 3.2). The images $I_t$ are fed through the frozen vision encoder and the resulting embeddings are attended to by the language model, but the model is not trained to predict or reconstruct images—it only learns to produce the textual reasoning and coordinate annotations conditioned on the visual context. The vision encoder itself is frozen throughout all training stages (both SFT and RL), so the visual representations do not adapt to the maze domain.

Why this format represents the "state of the art" in CoT design: Visual CoT embodies three design principles that the field currently considers best practice: (a) externalized visual memory—drawing paths on the image offloads the burden of tracking spatial state from the model's internal representations to the pixel space, (b) iterative visual refinement—each new image provides visual feedback on the previous actions, enabling the model to observe dead ends and backtrack visually rather than needing to reconstruct them from memory, and (c) multimodal deliberation—reasoning alternates between linguistic planning and visual verification, which should theoretically be more robust than either modality alone.

3.4.6 Supervised Fine-Tuning Stage

The SFT stage serves a specific purpose in this paper's experimental design: it teaches the base model the output format associated with each CoT type and provides an initial policy that makes RL training feasible. The authors explicitly note that "an SFT initialization is essential for stable and progressive RL training: models trained from scratch tend to collapse, whereas all SFT-initialized models steadily improve" (Section 4.2.1). This is consistent with the standard SFT-then-RL paradigm, but the paper's framing emphasizes that SFT's role is primarily to shape the policy space and mitigate reward sparsity, not necessarily to impart the optimal reasoning strategy.

Data formatting for SFT. For L-CoT, G-CoT, and V-CoT, each training example is formatted to include: the maze image, the task instruction text, a thinking block containing the synthesized CoT reasoning trace, a response block containing the final answer (the path in \boxed{}). For G-CoT-least, there is no separation between thinking and response—the entire output is the path sequence in \boxed{}, and the model is trained to directly produce this from the image and instruction, with no intermediate reasoning tags.

Dataset size. For each CoT type, the paper synthesizes 8,000 reasoning trajectories (Section 3.2). This is a relatively small dataset by modern VLM SFT standards, but sufficient because the maze domain is narrow (only one task type with controlled variation in grid size and wall configuration) and the model needs to learn a specific reasoning format rather than a broad set of skills.

Training configuration. The SFT uses the LLaMAFactory framework with the following hyperparameters: three epochs of training, learning rate $1 \times 10^{-5}$ , warm-up ratio of 0.1 (meaning the learning rate linearly increases from zero to $1 \times 10^{-5}$ over the first 10% of training steps), and a batch size of 64 (Section 3.3). Three epochs over 8K examples means the model sees each training example three times—a deliberate choice to avoid overfitting to the synthesized CoT style before RL begins.

Frozen vision encoder. "Throughout all training stages, we freeze the vision encoder and only update the parameters of the LLM" (Section 3.3). This is a critical design choice with important implications: the model cannot learn new visual features specialized for maze walls, grid structures, or path rendering. All visual understanding must be accomplished through the frozen, pretrained vision encoder's existing feature space. The language model portion (which includes the cross-attention layers that map visual features to the LLM's representational space) must learn to extract maze-relevant information from generic visual features. This constraint makes the task harder but more realistic—it simulates a scenario where a practitioner fine-tunes a pretrained VLM on a new visual reasoning task without retraining the vision backbone.

Output from SFT. The SFT stage produces four separate policy models, each fine-tuned from the same Qwen2.5-VL-7B base checkpoint but trained on different CoT data. These models have learned different output formatting conventions (language narration, coordinate annotation, tool-use calls, or direct path output) but have not yet been optimized for maze-solving accuracy—SFT teaches them how to express reasoning in a particular style, not necessarily how to reason correctly. The models likely overfit somewhat to the Gemini-synthesized CoT patterns, which is why RL is needed to refine their actual decision-making.

3.4.7 Reinforcement Learning Stage

The RL stage is where the paper's most important empirical contributions emerge, because it is here—under extended training to convergence—that the differences between CoT formats in terms of final capability ceiling and generalization become visible.

Why RL after SFT? The SFT models have learned the output format but may produce incorrect reasoning traces that happen to look plausible (because Gemini-2.5-Pro generated fluent but occasionally wrong CoT patterns). RL optimizes directly for the outcome that matters—whether the final path is correct—using a sparse reward signal that does not depend on the intermediate reasoning quality. This allows the model to potentially discover reasoning strategies that differ from the SFT supervision, including shorter or more efficient internal representations, while still being constrained to the output format learned during SFT.

Algorithm: Group Relative Policy Optimization (GRPO). GRPO is a variant of policy gradient methods that computes advantages relative to the mean reward within a group of rollouts from the same prompt. Given a batch of prompts, the model generates multiple responses per prompt, computes a reward for each, and uses the relative advantage (how much better or worse each response is compared to the group average) as the optimization signal. This is in contrast to PPO, which requires a learned value function (critic) to estimate advantages, and is particularly suitable for tasks where a value function would be difficult to learn (sparse rewards, complex visual inputs). The GRPO formulation used here follows Shao et al. (2024).

Reward function structure. The reward is defined as:

$r = \alpha \cdot r_{\text{acc}} + (1 - \alpha) \cdot r_{\text{format}}$

where $\alpha$ is a mixing coefficient (set to 0.1), $r_{\text{acc}}$ is a binary correctness reward, and $r_{\text{format}}$ is a binary format compliance reward.

What each term computes:

$r_{\text{acc}} \in \{0, 1\}$ : Determined by a rule-based function that checks whether the predicted path (extracted from the \boxed{} tags) connects the start and end points without crossing any walls, using the known maze structure. This is a sparse, all-or-nothing reward—partial credit for almost-correct paths is not provided. The reward is 1 if and only if the complete path is valid from start to end.
$r_{\text{format}} \in \{0, 1\}$ : Checks whether the model's output follows the required structure: the reasoning process enclosed in thinking response tags (for L-CoT, G-CoT, V-CoT) or the answer directly in \boxed{} (for G-CoT-least). This reward is 1 if the output is correctly formatted, 0 otherwise.
$\alpha = 0.1$ : The mixing coefficient heavily weights format compliance (0.9) over task correctness (0.1). A successful output that follows the format gets $r = 0.1 \cdot 1 + 0.9 \cdot 1 = 1.0$ . An output with a correct path but broken formatting gets $r = 0.1 \cdot 1 + 0.9 \cdot 0 = 0.1$ . An output with correct formatting but wrong path gets $r = 0.1 \cdot 0 + 0.9 \cdot 1 = 0.9$ . A complete failure gets $r = 0$ .

Why this reward structure and why $\alpha = 0.1$ ? The heavily format-weighted reward reveals an important practical concern: during RL, without a strong format incentive, models tend to collapse to degenerate outputs that achieve high task reward by exploiting reward-function quirks or simply outputting short, repetitive sequences. The format reward acts as a regularizer that keeps the model within the desired output template. The $\alpha = 0.1$ setting means that even a perfectly correct but malformed answer receives a reward (0.1) that is lower than a perfectly formatted but wrong answer (0.9). This prioritizes maintaining the CoT structure during RL optimization, ensuring that the model continues to produce outputs in the format learned during SFT rather than devolving into gibberish that happens to satisfy the path checker.

A subtle consequence: this reward design means the model is not being trained to maximize path accuracy in isolation—it is being trained to maintain format while gradually improving accuracy. The RL signal for task improvement is relatively weak (accounting for only 10% of the reward magnitude), which may explain why all models converge to similar final accuracy ceilings (the correctness signal is simply not strong enough to drive substantial differences once format compliance is achieved).

RL training configuration. The RL stage uses the verl framework with the following hyperparameters: rollout batch size of 128 (number of distinct prompts per training step), mini-batch size of 32, and 8 rollouts per prompt (generating 8 candidate responses for each prompt to compute GRPO advantages within each group). Training continues for up to 1000 RL steps—substantially longer than the "few hundred—or even just tens of—steps" that the authors note is typical in prior visual RL work (Section 3.3). This extended training is methodologically important: it ensures that comparisons between CoT formats reflect asymptotic performance rather than transient training dynamics, allowing the paper to distinguish between acceleration effects (faster convergence) and ceiling effects (higher final performance).

Additional RL data. The RL stage uses 20K additional maze samples beyond the 8K used for SFT (Section 3.2). These samples are drawn from the same maze-size distribution as the SFT data (e.g., 4×4 to 6×6 in the standard setup, or larger sizes in the generalization experiments). The larger dataset prevents the RL from simply memorizing the SFT examples and forces it to learn generalizable maze-solving strategies that work across varied wall configurations.

3.4.8 Format Compliance Constraint and Its Implications

The format reward $r_{\text{format}}$ deserves further analysis because it creates a constraint that interacts differently with each CoT format during RL. Understanding this interaction is essential for interpreting the paper's results.

For L-CoT, G-CoT, and V-CoT: The format requires explicit thinking and response tags with the reasoning trace inside thinking and the final answer (in \boxed{}) inside response. This means the model must generate potentially thousands of reasoning tokens before reaching the answer tokens that determine $r_{\text{acc}}$ . During RL, gradient updates flow through the entire sequence—if the final answer is correct, the model receives positive reinforcement for the entire reasoning chain that preceded it, even if portions of that chain were irrelevant or suboptimal. This creates a credit assignment problem: which reasoning steps actually contributed to the correct answer versus were superfluous? The format reward forces the model to continue generating reasoning tokens, but the correctness reward cannot distinguish between useful and useless reasoning—it only sees the final output.

For G-CoT-least: The format is simpler—the model outputs only the coordinate sequence in \boxed{}. There is no thinking response separation. The format reward is satisfied by the presence of \boxed{} tags, and the correctness reward directly evaluates the token sequence inside. Every token in the output pathway is directly relevant to the correctness evaluation—there is no separation between "reasoning" and "answer" tokens. This means the RL signal is denser and more directly coupled to the task objective: tokens that move the path toward the goal are reinforced, and tokens that lead in wrong directions are penalized via the relative advantage comparison.

Implication: This structural difference—not any inherent superiority of "short CoT" as a reasoning strategy—could partially explain G-CoT-least's better generalization. With G-CoT-least, RL receives a cleaner, less-noisy gradient signal because every output token has direct task relevance. With longer CoT formats, the model must learn to produce fluent reasoning and correct answers simultaneously, and the RL signal for reasoning quality is diluted across thousands of tokens with no per-token feedback. This is not a flaw in the experimental design—it reflects a genuine tradeoff in CoT design—but it means the paper's findings about "short is long" should be understood as partly about credit assignment during RL rather than purely about what the model needs for reasoning.

3.4.9 Generalization Evaluation Protocol

The paper operationalizes "generalizable visual reasoning" through two evaluation protocols that test whether learned maze-solving strategies transfer to maze sizes not seen during training.

Training size configurations. The paper uses several training-set configurations across different experiments:

Standard setup (Sections 4.2.1, 4.2.2): SFT on mazes sized 4×4 to 6×6, RL on the same size range, evaluation on unseen 7×7 mazes. This tests whether models can generalize to moderately larger mazes (7×7 has roughly 2× more cells than 6×6: 49 vs. 36 cells).
Single-scale generalization (Section 4.2.3, first part): SFT and RL both on 6×6 mazes only, evaluation on 7×7 mazes. This tests whether models trained on a single maze size can extrapolate to slightly larger mazes without having seen any size variation during training. This is a stricter test than the standard setup because the model never encounters the concept that "mazes can come in different sizes."
Cross-scale generalization (Section 4.2.3, second part): SFT on mazes sized 4×4 to 6×6 (exposing the model to small mazes), RL on mazes sized 7×7 to 9×9 (reinforcing maze-solving on medium mazes), evaluation on unseen 10×10 mazes. This tests whether the model can extrapolate to a maze size (10×10) that is substantially larger than any seen during RL (9×9) and dramatically larger than any seen during SFT (6×6). A 10×10 maze has 100 cells—nearly 3× more than the largest SFT maze—and the optimal path length can be proportionally longer. This is the paper's most demanding generalization test.

Evaluation metric. Test accuracy is the fraction of evaluation mazes for which the model's predicted path is correct according to the same rule-based checker used for $r_{\text{acc}}$ during RL. The checker verifies that the path starts at S, ends at E, every step moves between adjacent cells, and no step crosses a wall. This is a strict binary metric—near-correct paths with a single wrong turn receive zero credit.

What "generalization" means operationally. If a model achieves high accuracy on 10×10 mazes after never seeing a 10×10 maze during training, it has learned something more than pattern matching to specific grid configurations. Successful generalization implies the model has internalized abstract rules such as: (1) "walls block movement, so I must route around them," (2) "dead ends require backtracking to the most recent junction," (3) "the start and end markers define a goal-directed search problem," and (4) "the visual appearance of walls, paths, and markers is invariant to grid size." These are compositional rules that apply regardless of maze dimensions—they are exactly the kind of "abstract reasoning skills and reusable patterns that transfer across tasks" that the paper defines as generalizable reasoning in its introduction.

Why maze size tests generalization specifically. The relationship between grid size and problem difficulty is nonlinear: a 10×10 maze has approximately $(10/4)^2 = 6.25$ times more cells than a 4×4 maze, but the search space of possible paths grows combinatorially. A model that has memorized specific path patterns for 4×4 mazes will fail on 10×10 mazes because the spatial layout is fundamentally different. Only a model that has learned general navigation heuristics (follow corridors, avoid walls, backtrack from dead ends) can succeed on unseen sizes. This makes maze-size generalization a strong test of abstraction versus memorization.

3.4.10 Summary of Design Choices and Their Justifications

The paper's experimental design reflects several deliberate choices that collectively enable the central "short is long" finding:

Controlled synthetic maze domain over existing visual reasoning benchmarks: avoids pretrained priors and data contamination, enables clean difficulty manipulation via grid size, and allows automatic ground-truth generation, ensuring that all CoT format differences are attributable to the supervision signal rather than confounding factors.
Identical base model, training data, and RL algorithm across all CoT conditions: isolates CoT format as the single independent variable, enabling causal claims about format effects on generalization.
Frozen vision encoder throughout all training: ensures that performance differences come from the language model learning to interpret and reason over the visual input, not from the vision encoder adapting to maze-specific features—a more realistic and challenging setting.
Gemini-2.5-Pro for CoT synthesis rather than human annotation: enables large-scale, consistent data generation across formats while controlling for content (all formats describe the same underlying paths). The use of a single teacher model ensures that CoT quality differences are due to format structure, not annotator skill variation.
Extended RL training to 1000 steps (vs. typical ~100–200 steps): critical for distinguishing convergence acceleration from performance ceiling effects. Without this, the paper might have incorrectly concluded that V-CoT improves final performance when it actually only converges faster.
Sparse correctness reward with dominant format term ( $\alpha = 0.1$ ): prevents RL from causing format collapse (a known failure mode in GRPO-trained models) while evaluating whether the correctness signal alone can drive discovery of efficient internal reasoning strategies.
Generalization to unseen maze sizes as the primary evaluation: shifts the focus from in-distribution accuracy (which all formats eventually achieve) to transfer capability, which the paper argues is the true measure of generalizable visual reasoning.
G-CoT-least as the minimal-intervention baseline: provides a lower bound on how much CoT information is necessary—if this stripped-down format works best, then more elaborate formats are adding complexity without adding value for generalization.

4. Key Insights and Innovations

Innovation 1: The "Short is Long" Effect Reframes CoT Design from "More Is Better" to "Minimal Sufficient Grounding"

The paper's most fundamental conceptual contribution is not a new method but a reframing of what makes supervised CoT data effective for visual reasoning generalization. The dominant assumption across the VLM reasoning literature—inherited from LLM scaling results (Hendrycks et al., 2021; Guha et al., 2025) and reinforced by the success of visual CoT systems like OpenAI's "think with image" (2025)—is that longer, more detailed, and more richly multimodal CoT traces are strictly better for both in-distribution accuracy and out-of-distribution generalization. The reasoning is intuitive: more intermediate computation = more thorough deliberation = more robust answers. This assumption has driven substantial investment in constructing elaborate CoT datasets with interleaved images, reflection cycles, and step-by-step spatial annotations (Lai et al., 2025; Wang et al., 2025; Zheng et al., 2025).

This paper presents empirical evidence that directly contradicts that assumption for vision-centric tasks. The compressed, minimal G-CoT-least format—which strips away all textual narration, explicit coordinate annotations, reflection cycles, and visual manipulations, retaining only the bare path sequence in \boxed{}—matches or exceeds the performance of elaborate V-CoT after full RL training to convergence (Figures 2–5), and decisively outperforms it on cross-scale generalization (Figure 5: G-CoT-least maintains high success rates on unseen 10×10 mazes while V-CoT saturates). This is not a marginal refinement that slightly reduces annotation costs—it is a fundamental challenge to the theoretical basis for elaborate CoT construction.

What makes this finding conceptually distinctive is that it forces a reevaluation of why CoT works in the SFT-then-RL paradigm. The field has implicitly assumed that the reasoning content in CoT traces—the step-by-step explanations, the reflection patterns, the explicit spatial references—is what drives generalization, because the model internalizes these reasoning patterns during SFT and refines them during RL. The "short is long" effect suggests an alternative interpretation: once a VLM's grounding ability is properly aligned with the visual environment (which SFT accomplishes even with minimal traces), the RL stage is capable of discovering efficient internal reasoning strategies that are more generalizable than the explicit, verbose strategies provided in SFT supervision. In this view, elaborate CoT is not harmful per se, but it adds complexity without adding value for the particular learning dynamics of vision-centric RL.

This is not merely a "simpler is better" empirical finding—it is a diagnostic discovery that separates the format-learning function of SFT from the reasoning-optimization function of RL. The paper's evidence shows that SFT's primary role is teaching the model the output modality and establishing grounding alignment, not providing the optimal reasoning strategy. The optimal strategy emerges from RL's direct optimization against the sparse correctness reward, and this emergent strategy tends to be more compact and more generalizable than the explicitly supervised CoT patterns. This reframing has substantial practical implications: if minimal grounding suffices for SFT, then the expensive pipeline of Gemini-2.5-Pro CoT synthesis (with its elaborate prompts, DFS path generation, and interleaved image rendering) may be unnecessary for many vision-centric tasks. Practitioners could substitute automatically extracted answer-format trajectories (like G-CoT-least) and achieve equal or better results at dramatically lower data construction cost.

[Thick around evidence: The "short is long" claim rests primarily on Figures 3–5. In Figure 3, the G-CoT-least policy model starts from a higher SFT accuracy than full G-CoT or V-CoT, converges faster, and reaches the same 100% training accuracy ceiling—but the payoff is in generalization. Figure 4 shows that in single-scale generalization (train 6×6, test 7×7), V-CoT saturates around 800 RL steps while G-CoT-least continues to improve; Figure 5 shows cross-scale generalization (SFT 4×4–6×6, RL 7×7–9×9, test 10×10) where G-CoT-least's test accuracy substantially exceeds V-CoT's, which plateaus early. These results are consistent across all generalization conditions tested.]

Innovation 2: Disentangling Convergence Acceleration from Performance Ceiling Effects in Test-Time Strategy Learning

The paper introduces a methodological innovation that is conceptually simple but rarely executed in the CoT literature: training all model variants to full RL convergence (up to 1000 GRPO steps) to distinguish between strategies that accelerate optimization and strategies that raise the asymptotic capability ceiling. This may sound like an implementation detail, but it addresses a pervasive confound in prior work that the authors explicitly identify and rectify.

Prior work on visual RL for VLMs typically trains for "only a few hundred—or even just tens of—steps" (Section 3.3). This creates a systematic bias in reported results: strategies that provide stronger optimization signals (richer gradients, more structured supervision, better-shaped reward landscapes) will appear superior when training is truncated early, even if they would converge to the same final performance as simpler strategies given sufficient training. This confound is particularly acute for CoT comparisons because longer, more elaborate CoT traces—by their very structure—provide denser supervision. Visual CoT, with its interleaved images and explicit coordinate annotations, gives the model more tokens to learn from and more structured feedback at each step, which naturally accelerates early learning. But acceleration is not the same as capability improvement, and prior work largely failed to distinguish between the two.

The paper's extended training protocol reveals this distinction cleanly. Figure 2 shows that V-CoT indeed converges fastest during RL—"requiring roughly half the training steps of language CoT" (Section 4.2.1)—and maintains higher training accuracy in the early-to-mid stages of training. This is exactly what the "longer CoT is better" narrative would predict, and it is what prior work that stopped training early would have reported as a V-CoT advantage. But the paper's key move is to continue training beyond the point where V-CoT saturates. All three formats (L-CoT, G-CoT, V-CoT) eventually reach 100% training accuracy on the in-distribution mazes, and their test accuracy on unseen 7×7 mazes converges to similar levels (Figure 2c). The initial V-CoT advantage was purely about convergence speed, not final capability.

This finding is conceptually significant because it recasts the interpretation of the entire visual CoT literature. When DeepEyes (Zheng et al., 2025) or Thyme (Zhang et al., 2025) report that visual CoT outperforms baselines, is that advantage coming from better asymptotic reasoning capability, or from faster convergence within a fixed training budget? This paper cannot answer that question definitively for those specific systems, but it provides a methodological template for how to ask it: train to convergence, compare ceilings, not mid-training snapshots. The fact that the paper's own V-CoT advantage evaporates under this protocol suggests that at least some reported visual CoT benefits in the literature may be acceleration artifacts rather than genuine capability improvements.

There is a deeper implication for how the field should evaluate CoT strategies. If the goal of SFT+RL is to produce the most capable model (regardless of training cost), then convergence acceleration is a second-order concern—what matters is the final performance ceiling. If the goal is to produce a capable model with minimum training compute, then acceleration matters but must be weighed against the cost of constructing the CoT data itself. The paper's framework enables this nuanced evaluation, while prior work's truncated-training approach conflates the two objectives.

[Evidence anchor: The convergence-vs-ceiling distinction is visible in Figure 2: V-CoT (red curve) leads in training accuracy through ~400 steps but G-CoT (blue) and L-CoT (orange) catch up by step 600–800. In Figure 2c (test accuracy on 7×7), all three curves cluster together at the final evaluation point. The abstract explicitly states "visual and longer CoT mainly accelerate convergence but do not lift the final performance ceiling."]

Innovation 3: Grounding Alignment as the Core Mechanism, with CoT Format as an Interchangeable Scaffold

Perhaps the paper's most theoretically significant contribution is the identification of grounding alignment as the fundamental capability that enables vision-centric CoT reasoning, with the specific CoT format (language, coordinate, visual manipulation) acting as a scaffold that can be discarded once the alignment is established. This insight emerges from two connected findings: (1) G-CoT-least (no explicit coordinates) matches the performance of full G-CoT (explicit coordinate annotations at every step), and (2) after RL training, all CoT formats converge to similar performance despite receiving qualitatively different SFT supervision.

The standard narrative in the grounding literature (Shao et al., 2024; Wang et al., 2025) treats grounding annotations as necessary content for visual reasoning—the model needs to learn to associate linguistic concepts with visual referents, and explicit coordinate outputs during CoT are how it demonstrates and refines that ability. Under this view, removing grounding annotations (as G-CoT-least does) should degrade performance because the model loses the training signal for learning spatial associations.

The paper's results suggest a different mechanism. What matters is not that the model outputs grounding annotations during reasoning, but that it has established an internal alignment between its linguistic reasoning module and its visual perception module—what the paper calls "grounding ability." This alignment is presumably established during the base model's pretraining on massive image-text corpora and is merely activated (not created) by the maze SFT data. The different CoT formats serve as different scaffolds for activating this pre-existing alignment: L-CoT activates it through directional language, G-CoT through coordinate annotations, V-CoT through visual manipulation, and G-CoT-least through the implicit spatial structure of the path output itself. But once activated, the underlying capability is the same, and the specific scaffold becomes irrelevant—the model can "internalize and operate over its own latent spatial representations without relying on externally specified coordinate systems" (Section 4.2.2).

This is a reframing of what CoT does for visual reasoning. In the LLM paradigm, CoT teaches the model how to reason—the intermediate steps provide a template for decomposition and reflection that the model internalizes. In the VLM paradigm that this paper reveals, CoT primarily teaches the model that it already knows how to reason visually—it activates and aligns pre-existing visual understanding capabilities that just need to be connected to the task-specific output format. The reasoning strategy itself is discovered by RL, not taught by SFT.

This reframing has direct practical consequences. If grounding alignment is the key capability, then SFT data construction should focus on establishing strong visual-textual alignment for the task domain rather than on constructing elaborate step-by-step reasoning traces. This could mean simpler, cheaper SFT datasets (e.g., image–path pairs for maze navigation, image–action sequences for visual games) combined with more extensive RL to let the model discover optimal reasoning strategies. It also suggests that the field's current focus on CoT quality (well-structured reasoning, reflection patterns, multi-step verification) should shift toward CoT alignment (ensuring the model can reliably map between visual inputs and task-relevant outputs) as the primary SFT objective.

[Evidence anchor: Section 4.2.2 and Figure 3 are the key anchors. Figure 3a shows G-CoT-least starting from higher SFT accuracy and converging faster than both G-CoT and V-CoT, despite never seeing explicit coordinates during training. The paper's statement that "once the model's grounding ability is properly aligned with the visual environment, it can internalize and operate over its own latent spatial representations" directly follows from this result. The generalization results in Figures 4–5 reinforce the mechanism: G-CoT-least's superior generalization suggests that minimal grounding supervision produces more fundamental, transferable spatial representations.]

Innovation 4: Vision-Centric Reasoning as a Distinct Regime Where RL Induces Compression, Not Expansion

The paper identifies a phenomenon that distinguishes vision-centric RL from the language-dominant RL more commonly studied in the VLM reasoning literature: in vision-centric tasks, RL tends to compress CoT traces rather than expand them, and this compression is associated with improved generalization rather than capability collapse. This observation systematizes scattered prior reports (Sarch et al., 2025; Li et al., 2025; Wu et al., 2025) into a coherent principle with a proposed mechanism.

In language-dominant visual reasoning tasks—math word problems with diagrams, chart question answering, physics reasoning—RL typically produces models that generate longer, more elaborate reasoning traces than their SFT starting points (Deng et al., 2025; Wang et al., 2025). The model learns that more thinking steps → higher probability of correct answer, and the RL process reinforces verbose deliberation. This has created an implicit assumption that RL's effect on CoT is expansive: it makes models more deliberative.

The paper shows that the opposite occurs for vision-centric maze navigation. Even models initialized from SFT with verbose CoT (L-CoT, G-CoT, V-CoT) tend to produce shorter reasoning traces after RL training, and the model initialized from the minimal G-CoT-least—with no reasoning trace at all—achieves the best generalization. The paper's explanation is that "in vision-centric environments, RL primarily strengthens the model's established grounding capability. Once grounding is sufficiently reinforced, the model can perform effective reasoning with very brief CoT traces" (Section 5). The RL process discovers that verbose deliberation is unnecessary—indeed, potentially harmful for generalization—because the spatial reasoning can be performed implicitly through the model's internal representations once the vision-language interface is well-calibrated.

This is a regime discovery with significant implications for how RL should be applied to different types of visual reasoning tasks. It suggests that the relationship between CoT length and RL optimization is not universal but depends on the reasoning modality: language-dominant tasks benefit from explicit step-by-step deliberation because reasoning operates in the discrete, compositional space of natural language; vision-dominant tasks may not benefit because reasoning operates in the continuous, holistic space of visual representations that are better processed implicitly by the model's internal visual processing pipeline. Adding explicit intermediate steps in such tasks may actually interfere with the model's natural visual reasoning capabilities by forcing it to translate between visual representations and linguistic/symbolic intermediates that lose information.

This insight also explains the previously puzzling observation from the related work section that "unlike language-dominant tasks, the CoT trajectories induced by RL in vision-centric settings tend to be short." Prior work noted this pattern but treated it as a curiosity; the paper elevates it to a diagnostic principle that predicts when elaborate CoT will help (language-dominant reasoning) versus when it may be superfluous or counterproductive (vision-dominant reasoning). The practical guideline is clear: for tasks where the core reasoning operates on visual/spatial representations, invest in grounding alignment (SFT on minimal answer-format data) and let RL discover efficient internal strategies, rather than constructing elaborate CoT SFT data that may teach the model to reason in a suboptimal modality.

[Evidence anchor: The compression phenomenon is visible across all experiments but most clearly in the G-CoT-least condition, which has zero reasoning tokens yet achieves the best generalization (Figures 3–5). The observation that "CoT trajectories induced by RL in vision-centric settings tend to be short" is discussed in Section 5 (Related Work) and explained through the grounding-alignment mechanism. The contrast with language-dominant RL—where CoT tends to expand—is drawn from the paper's discussion of prior work like OpenVLThinker (Deng et al., 2025) and VL-Rethinker (Wang et al., 2025).]

While the maze benchmark itself is an experimental design choice (covered in Section 3), its conceptual role in the paper's contribution architecture deserves recognition as an innovation in how to study CoT generalization. The paper does not simply adopt an existing benchmark and compare CoT formats—it constructs a controlled reasoning environment specifically designed to answer causal questions about CoT that cannot be answered on standard benchmarks.

The standard approach in the VLM reasoning literature is to evaluate on established benchmarks like MathVerse (Zhang et al., 2024), ChartQA (Masry et al., 2022), or V* (Tong et al., 2024). These benchmarks have well-defined tasks and metrics, but they suffer from two confounds for studying CoT format effects: (1) models may have memorized answers or reasoning patterns from benchmark data in their pretraining corpora, making it impossible to distinguish genuine reasoning from retrieval, and (2) task difficulty is fixed and not smoothly tunable, making it impossible to study how CoT effectiveness varies with problem complexity. The maze benchmark addresses both confounds: it is procedurally generated with no risk of pretraining contamination (Qwen2.5-VL-7B achieves <10% accuracy on 4×4 mazes before training), and difficulty can be precisely controlled via grid size, enabling the cross-scale generalization experiments that are the paper's primary contribution.

This is more than a convenience for the experimenters—it represents a methodological argument about what kind of evidence is needed to make causal claims about CoT. If the paper had simply shown that G-CoT-least outperforms V-CoT on MathVerse or V*, skeptics could argue that the result is benchmark-specific, or that the base model had uneven pretraining exposure to different reasoning patterns, or that the difficulty distribution happened to favor short CoT. By constructing a clean synthetic testbed where all these confounds are eliminated, the paper makes a stronger causal claim: the "short is long" effect is a genuine property of how CoT format interacts with vision-centric RL learning dynamics, not an artifact of particular benchmarks or pretraining data.

The maze domain also enables a specific type of generalization analysis—scaling to larger grid sizes—that has no natural analog in most existing benchmarks. MathVerse problems don't come in "larger" and "smaller" versions that test the same underlying reasoning rules. The maze's parametrized difficulty makes it possible to operationally define generalization as "accuracy on larger mazes" and to test whether different CoT formats produce different generalization gradients. This operationalization is what enables the paper to move beyond the vague claim that "CoT helps generalization" to the specific claim that "minimal grounding CoT generalizes better than visual CoT across scale."

The conceptual innovation here is not the maze task itself—maze-solving has a long history in AI—but the framing of synthetic, parametrically controllable environments as the right tool for answering mechanistic questions about CoT. This contrasts with the field's dominant approach of evaluating on naturalistic benchmarks and making post-hoc inferences about why certain methods work. The paper implicitly argues that progress on understanding CoT mechanisms requires the kind of controlled experimentation that synthetic environments enable, and that naturalistic benchmarks—while essential for measuring real-world performance—are fundamentally limited in their ability to answer why questions.

[Evidence anchor: The paper's argument for the maze domain is laid out in Section 3: "Minimal interference from pretrained priors: existing VLMs perform poorly on maze-related tasks, reducing confounding effects of strong pretrained capabilities; Pure visual reasoning: maze solving mainly requires spatial reasoning and does not rely on external domain knowledge; Controlled difficulty: task complexity can be precisely tuned by adjusting maze size or path length." The <10% base model accuracy on 4×4 mazes is the empirical anchor for the "minimal pretrained priors" claim. The cross-scale generalization protocol (Section 4.2.3) is the operationalization that makes this framing productive.]

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper constructs a procedurally generated maze dataset with 8K samples for SFT and an additional 20K samples for RL (Section 3.2). For the standard setup, mazes are sized 4×4 to 6×6; for single-scale generalization, only 6×6; for cross-scale generalization, SFT uses 4×4–6×6, RL uses 7×7–9×9, and evaluation uses unseen sizes (7×7 or 10×10). Additionally, real-world tasks are evaluated on V* (Tong et al., 2024) training set for RL and test set for evaluation, HR-Bench (Wang et al., 2025) for spatial and attribute subtasks, FrozenLake (Towers et al., 2024) on 4×4 grids with zero slippage probability, and Jigsaw (Wu et al., 2025) in 3×3 configuration. All synthetic maze data is procedurally generated with rule-based functions ensuring no overlap with evaluation mazes.
Base model. Qwen2.5-VL-7B (Bai et al., 2025) serves as the foundation for all experiments. The authors justify this choice on two grounds: the model performs poorly on maze tasks out of the box (below 10% success on 4×4 mazes, Section 3), providing headroom to study reasoning acquisition, and its scale (7B parameters) makes it representative of practical deployment scenarios while being computationally feasible for extensive RL training (up to 1000 steps, Section 3.3). The vision encoder is frozen throughout all training stages; only the language model parameters are updated during both SFT and RL.
Metrics. The primary metric is test accuracy — the fraction of evaluation mazes for which the model's predicted path is correct, verified by a rule-based checker that confirms the path starts at S, ends at E, every consecutive pair of coordinates represents adjacent cells, and no step crosses a wall (Section 3.2). For RL training dynamics, training accuracy is computed on the same size distribution used for RL (e.g., 4×4–6×6 in the standard setup). The paper also reports Pass@K training accuracy — the fraction of prompts where at least one of K sampled responses from the model is correct — to distinguish between the model's capability (what it can sometimes produce) and its consistency (what it typically produces). For real-world VQA tasks, standard benchmark metrics are used (accuracy on V* and HR-Bench subtasks).
Baselines. The paper's primary comparison is among four CoT format variants derived from the same base model:
- L-CoT (Language CoT): SFT on Gemini-2.5-Pro-synthesized textual reasoning traces using directional language, no coordinates.
- G-CoT (Grounding CoT): SFT on Gemini-2.5-Pro-synthesized reasoning traces with explicit pixel coordinate annotations at each step.
- V-CoT (Visual CoT): SFT on Gemini-2.5-Pro-synthesized multimodal reasoning traces with interleaved line-drawing operations on intermediate images.
- G-CoT-least (least Grounding CoT): SFT directly on path coordinate sequences without any textual reasoning trace — the output is only the path in \boxed{}.
Additionally, a "Zero RL" baseline (Section 4.2.1, Figure 2) tests RL from scratch without SFT initialization, serving to demonstrate the necessity of cold-start SFT. For real-world VQA tasks, V-CoT RL uses the DeepEyes (Zheng et al., 2025) approach of cropping regions of interest and appending them to context, while G-CoT-least RL directly answers without explicit visual CoT steps.
Generation budget. The paper does not use a fixed generation budget per evaluation — each evaluation samples a single response from the model (greedy decoding or single-sample, Section 4.2). The primary "compute" axis in the experimental analysis is RL training steps (up to 1000 steps), with models evaluated periodically to generate training curves. One "generation" for V-CoT involves multiple forward passes (one per intermediate image), but the paper accounts for this implicitly through the training dynamics: V-CoT's faster convergence (Figure 2a) occurs despite higher per-step computational cost, making the convergence speed comparison conservative for V-CoT. The SFT stage uses a fixed budget of 8K examples across all conditions.
Cross-validation / statistical protocol. No formal cross-validation or statistical testing is reported. The test sets appear to be fixed evaluation splits: for maze experiments, unseen maze configurations and sizes distinct from training data; for V* and HR-Bench, standard test splits; for FrozenLake and Jigsaw, held-out environments. The paper does not report confidence intervals, error bars, or significance tests. The RL training curves (Figures 2–5) show training dynamics across steps but do not report variance across random seeds. This is a notable limitation: all claims about relative performance differences rest on point estimates without statistical characterization of uncertainty.

Main Quantitative Results

4.2.1 Headline Comparison: V-CoT Accelerates but Does Not Raise the Ceiling

The paper's central quantitative comparison (Figure 2) evaluates L-CoT, G-CoT, and V-CoT under the standard setup: SFT on mazes sized 4×4 to 6×6, RL on the same size range, evaluation on unseen 7×7 mazes.

Training dynamics (Figure 2a). All three SFT-initialized models eventually reach 100% training accuracy on in-distribution mazes, but at substantially different rates:

V-CoT converges fastest, reaching near-100% accuracy by approximately step 200.
G-CoT follows, converging around step 400.
L-CoT converges slowest, requiring roughly 600–800 steps to reach the same level.

The "Zero RL" baseline (no SFT initialization) collapses immediately to near-zero accuracy, confirming that "an SFT initialization is essential for stable and progressive RL training" (Section 4.2.1).

Pass@8 training accuracy (Figure 2b). This metric — the fraction of prompts where at least one of eight sampled responses is correct — reveals that models achieve high pass@8 rates earlier than high pass@1 rates (since eight attempts provide more opportunities to succeed). V-CoT reaches near-100% pass@8 by step ~100; G-CoT by step ~200; L-CoT by step ~400. The ordering mirrors the single-sample accuracy curves.

Test accuracy on unseen 7×7 mazes (Figure 2c). This is the critical comparison for generalization. Despite V-CoT's faster training convergence:

All three models plateau at similar test accuracy by the end of 1000 RL steps (approximately 0.60–0.65, read from Figure 2c).
V-CoT's early advantage (higher test accuracy through ~400 steps) largely disappears by the final evaluation.
The curves converge rather than diverge, confirming that visual CoT "mainly accelerates optimization rather than expanding the model's ultimate reasoning capacity" (Section 4.2.1).

Takeaway quantified. The paper's claim that V-CoT accelerates convergence by "roughly half the training steps of language CoT" is visible in Figure 2a (V-CoT at step 200 ≈ L-CoT at step 400–600). However, the final test accuracy ceiling is approximately equal across conditions, validating the "accelerates but does not lift the ceiling" finding.

4.2.2 Short CoT Surpasses Longer Ones: G-CoT-least vs. Full G-CoT and V-CoT

Figure 3 compares G-CoT-least against G-CoT and V-CoT under the same standard setup (SFT on 4×4–6×6, RL on same, test on 7×7).

SFT initialization advantage. G-CoT-least starts from a higher post-SFT training accuracy than either G-CoT or V-CoT (Figure 3a, step 0: approximately 0.2–0.3 for G-CoT-least vs. near 0.0 for the other two, read from the y-axis intercept). This is striking because G-CoT-least was trained on the sparsest supervision (only path sequences), yet it produces the strongest initial policy. The paper attributes this to the alignment between the output format and the task: the path is the answer, so no additional format translation is needed.

Convergence speed. G-CoT-least converges to 100% training accuracy fastest (by approximately step 200), followed by V-CoT (step 300–400), followed by G-CoT (step 400–500). The ordering G-CoT-least > V-CoT > G-CoT is visible across all three training metrics (Figures 3a–3b).

Test accuracy on 7×7 mazes (Figure 3c). After RL, G-CoT-least achieves approximately 0.65–0.70 test accuracy on unseen 7×7 mazes, matching or slightly exceeding V-CoT (which reaches approximately 0.60–0.65). The G-CoT curve is slightly lower (approximately 0.55–0.60). The key finding is that the shortest CoT format — with no explicit reasoning traces, no coordinate annotations, no visual operations — achieves the best or equal-best generalization performance despite providing the least supervision.

What this demonstrates. The results in Figure 3 establish that the grounding annotations in full G-CoT (explicit coordinates at every step) and the visual manipulation in V-CoT (line-drawing on intermediate images) are not necessary for the model to learn maze-solving — and may actually be slightly detrimental to generalization compared to simply providing the answer trajectory.

4.2.3 Generalization Across Maze Scales: Single-Scale and Cross-Scale

The paper's most important quantitative findings come from the generalization experiments in Figures 4 and 5, which test whether different CoT formats produce models that can transfer to unseen maze sizes.

Single-scale generalization (Figure 4). Models are trained (SFT + RL) exclusively on 6×6 mazes and evaluated on unseen 7×7 mazes. This tests whether a model that has never seen size variation can extrapolate spatial reasoning to a slightly larger grid.

G-CoT-least: Training accuracy reaches 100% by approximately step 300. Test accuracy on 7×7 mazes starts around 0.25 at early RL steps and rises to approximately 0.65 by step 1000, showing consistent improvement throughout training (Figure 4c, blue curve).
V-CoT: Training accuracy also reaches 100% (by approximately step 400). Test accuracy on 7×7 starts similarly but saturates around step 800 at approximately 0.55–0.60, and then plateaus or slightly declines (Figure 4c, red curve).
The gap between G-CoT-least and V-CoT on test accuracy widens throughout the later stages of RL training (steps 600–1000), suggesting that continuing to optimize V-CoT on 6×6 mazes does not improve — and may slightly harm — its generalization to 7×7 mazes, while G-CoT-least continues to benefit.

Cross-scale generalization (Figure 5). This is the paper's most demanding test: SFT on 4×4–6×6 mazes, RL on 7×7–9×9 mazes, evaluation on unseen 10×10 mazes. The model never sees a 10×10 maze during training and must generalize its spatial reasoning to a grid with 100 cells — 3× more than the largest SFT maze.

G-CoT-least: Training accuracy on 7×7–9×9 reaches near 100% (Figure 5a). Pass@8 training accuracy reaches near 100% even faster (Figure 5b). Test accuracy on 10×10 mazes (Figure 5c) starts around 0.1–0.15 at early RL steps, rises to approximately 0.50–0.55 by step 400, and continues improving to approximately 0.60 by step 800. The test accuracy curve shows no sign of plateauing.
V-CoT: Training accuracy also reaches near 100%, but test accuracy on 10×10 starts lower (approximately 0.05–0.10 at early steps), rises more slowly, and saturates around 0.35–0.40 by step 500–600, after which it remains flat or slightly declines through step 800 (Figure 5c).
The final test accuracy gap is substantial: G-CoT-least achieves roughly 0.60 versus V-CoT's roughly 0.35–0.40 — a ~50% relative improvement for the minimal CoT format.

What these numbers mean for the "generalizable reasoning" claim. The cross-scale generalization results (Figure 5c) provide the strongest evidence for the paper's central thesis. On 10×10 mazes — which are qualitatively harder (longer paths, more junctions, more opportunities for dead ends) and quantitatively larger (~3× more cells than SFT mazes, ~1.5× more cells than RL mazes) — G-CoT-least demonstrates substantially better transfer than V-CoT. The V-CoT model's saturation at ~0.35–0.40 suggests that the elaborate visual reasoning patterns it learned during training (line-drawing, intermediate image inspection, multi-step visual reflection) do not transfer effectively to mazes of different sizes, possibly because the model overfits to specific visual layouts or operation patterns rather than learning size-invariant navigation heuristics. The G-CoT-least model's continued improvement through step 800, without the saturation seen in V-CoT, suggests that minimal grounding supervision encourages the internalization of generalizable spatial rules (follow corridors, backtrack from dead ends) rather than reliance on training-distribution-specific visual features.

4.3 Extension to Other Vision-Centric Tasks

Table 1 reports results on two visual games (FrozenLake, Jigsaw) and real-world VQA benchmarks (V*, HR-Bench).

FrozenLake (4×4 grids). The base Qwen2.5-VL-7B achieves 20% accuracy (essentially random, since a valid path must avoid holes and reach the gift). G-CoT-least RL raises this to 90.33% — a 4.5× improvement, demonstrating that the minimal CoT approach transfers to a different spatial navigation task with a different visual appearance (FrozenLake uses a grid-world with holes and a gift, whereas mazes use walls and S/E markers).

Jigsaw (3×3 puzzle assembly). The base model achieves 0% accuracy — it cannot correctly order the nine puzzle pieces. G-CoT-least RL improves this to 75.60%, a dramatic gain that demonstrates the approach works not just for path-finding but for a fundamentally different type of visual reasoning (spatial arrangement and assembly). The jigsaw task operates on tile indices rather than grid coordinates, suggesting the "least grounding" principle generalizes beyond coordinate-based spatial tasks to other structured visual outputs.

V and HR-Bench (real-world VQA).* On V*, G-CoT-least RL achieves 87.83 on Attr and 82.89 on Spatial subtasks, for an overall of 85.86, compared to V-CoT RL's 86.09 / 78.95 / 83.25. The improvement is particularly notable on Spatial (82.89 vs. 78.95), where visual grounding is most critical. On HR-Bench 4K, G-CoT-least RL achieves 90.75 overall (FSP 57.50, FCP 74.12) vs. V-CoT RL's 87.00 and 72.00. Across all six comparisons (two benchmarks × three subtask breakdowns), G-CoT-least RL outperforms V-CoT RL in five and ties in one (FSP at 57.00 vs. 57.50, essentially equal). The largest gaps are in Spatial on V* (82.89 vs. 78.95) and Overall on HR-Bench 4K (90.75 vs. 87.00).

Significance of these extensions. The real-world VQA results are particularly important because they test whether the "short is long" effect is specific to synthetic maze environments or generalizes to naturalistic visual reasoning tasks with pretrained visual features. The consistent advantage of G-CoT-least over V-CoT on V* and HR-Bench (Table 1) suggests the finding is not an artifact of the maze domain. However, the paper reports these results without training curves (only final accuracy), making it impossible to determine whether V-CoT would catch up with extended training (as it did in the maze ceiling experiments) or whether the gap persists at convergence — the same confound the paper criticizes in prior work.

Ablation Studies and Robustness Checks

Necessity of SFT cold-start (Zero RL baseline, Figure 2). The Zero RL condition trains the base Qwen2.5-VL-7B directly with GRPO on maze data without any SFT initialization. Figure 2a shows this model collapses immediately to near-zero training accuracy and never recovers. This confirms that "an SFT initialization is essential for stable and progressive RL training" (Section 4.2.1) and eliminates the possibility that RL alone could teach the model maze-solving from scratch. The mechanism is presumably reward sparsity: without an initial policy that sometimes produces correct paths, the GRPO advantage estimates provide no useful gradient signal, and the model never escapes random behavior.

Format reward weight (α = 0.1 choice, Section 3.2). The paper does not ablate the α parameter controlling the mix of correctness and format rewards (Equation 3). This means the finding that G-CoT-least outperforms other formats could be partially attributable to reward structure: G-CoT-least has a simpler format requirement (just \boxed{} tags), so the 0.9 format reward is easier to satisfy, potentially providing a smoother optimization landscape. A lower α (e.g., 0.5) that weights correctness more heavily might reduce or eliminate G-CoT-least's advantage if the simpler format's benefit comes primarily from easier format compliance rather than better generalization. This is a notable missing ablation.

Gemini-2.5-Pro teacher model quality. The paper uses Gemini-2.5-Pro as the sole teacher for synthesizing CoT data, but does not ablate teacher quality (e.g., comparing with a weaker teacher like Gemini-1.5-Flash or a stronger one like human annotation). This means the relative performance of L-CoT, G-CoT, and V-CoT could be teacher-dependent: a better teacher might produce higher-quality reasoning traces that change the convergence-vs-ceiling dynamics. The paper's claim that "shorter CoT surpasses longer ones" might not hold if the longer CoT were synthesized by a genuinely expert teacher rather than Gemini-2.5-Pro.

Frozen vision encoder (Section 3.3). The paper freezes the vision encoder for all experiments. No ablation is reported where the vision encoder is fine-tuned during SFT or RL. This is a significant gap because the vision encoder's frozen state means the model must perform all spatial reasoning using pretrained visual features that were not optimized for maze walls, grid cells, or path traces. Fine-tuning the vision encoder might change the relative effectiveness of different CoT formats — for example, V-CoT's interleaved image processing might benefit more from an adapted vision encoder than G-CoT-least's minimal visual demands. The paper's findings are therefore conditional on the vision encoder being frozen; they may not transfer to settings where end-to-end fine-tuning is employed.

SFT data quantity (fixed at 8K per format). The paper uses a fixed 8K SFT examples for all CoT formats. No ablation varies this quantity to test whether the advantage of G-CoT-least persists at different dataset sizes. It is possible that with much larger SFT datasets (e.g., 64K or 128K examples), the elaborate CoT formats would eventually catch up to or surpass G-CoT-least because the model would have more opportunity to learn from detailed reasoning patterns. Conversely, G-CoT-least's advantage might grow with smaller SFT datasets, because minimal supervision is more data-efficient. The fixed 8K setting cannot distinguish these scenarios.

RL training horizon (1000 steps vs. typical shorter training, Section 3.3). The paper implicitly ablates training horizon by comparing its results (trained to 1000 steps) with prior work that trains for "only a few hundred—or even just tens of—steps." The finding that V-CoT's advantage disappears with extended training is itself an ablation on training horizon: had the paper stopped at 200–400 steps (within the typical range for prior work), the conclusion would have been "V-CoT outperforms L-CoT and G-CoT," which is exactly what the shorter-training literature reports. This is less a formal ablation and more a methodological demonstration, but it serves the same function — showing that a key experimental design choice (training duration) determines the qualitative conclusion.

Generalization scale gap (training vs. evaluation maze sizes, Figures 4–5). The paper tests two generalization gaps: 6×6 → 7×7 (single-scale) and SFT 4×4–6×6 + RL 7×7–9×9 → 10×10 (cross-scale). No intermediate gaps are tested, so the shape of the generalization gradient is unknown. It is unclear whether V-CoT's disadvantage grows monotonically with the generalization gap (e.g., would V-CoT match G-CoT-least on 7×7 if trained on 6×6, but fall behind on 8×8?) or whether there is a threshold effect (e.g., both formats work for +1 size, but V-CoT collapses at +2 or larger). The paper also does not test generalization to smaller mazes (e.g., train on 6×6, test on 4×4), which would test whether the effect is about scale generalization specifically or distribution shift generally.

Real-world task training protocol (Table 1). For real-world VQA, the paper uses "zero-shot RL" on V* (no SFT before RL), which differs from the two-stage SFT-then-RL protocol used for mazes. This makes the comparison between V-CoT RL and G-CoT-least RL on V*/HR-Bench not directly comparable to the maze experiments: the maze results show RL after SFT cold-start, while the VQA results show RL from scratch. The G-CoT-least advantage on VQA might be partly attributable to the absence of SFT (where elaborate CoT formats might have been beneficial), rather than the inherent superiority of minimal CoT. A proper comparison would include both conditions (zero RL and cold-start RL) for both formats on VQA.

Single prompt template and instruction format. The paper uses a single instruction template for all maze experiments (shown in Figure 1). No ablation varies the instruction wording or format to test whether the "short is long" effect is sensitive to prompt engineering. If G-CoT-least's advantage depends on the specific instruction — for example, whether the instruction explicitly mentions that the output should be a coordinate list — then the finding may not generalize to tasks with different instruction structures.

Critical Assessment

Does the paper demonstrate that "visual and longer CoT accelerates but does not lift the ceiling"?

The evidence for this claim is strong within the experimental parameters tested. Figure 2 clearly shows V-CoT converging faster than L-CoT and G-CoT on training accuracy (Figure 2a: V-CoT reaches near-100% by step 200; L-CoT requires step 600+) while all three plateau at similar test accuracy on 7×7 mazes (Figure 2c: all approximately 0.60–0.65 at step 1000). The acceleration-vs-ceiling distinction is well-supported.

However, the claim's scope must be carefully bounded. The experiment tests only one model family (Qwen2.5-VL-7B), one task (maze navigation), one RL algorithm (GRPO with α=0.1), and one training budget (1000 steps, 8K SFT examples). A different model with a stronger pretrained visual understanding (e.g., a 70B+ parameter VLM) might show different dynamics — perhaps V-CoT would raise the ceiling for a more capable base model by enabling it to leverage richer visual processing. A different RL algorithm with better exploration properties might allow V-CoT to surpass G-CoT-least by discovering reasoning strategies that require visual manipulation. The claim as stated is "visual and longer CoT accelerates but does not lift the ceiling," but what is demonstrated is "under one specific training configuration, on one specific task, with one specific base model, the ceiling is not lifted." The generalization of this finding to other settings is plausible but unverified.

A specific limitation: the V-CoT condition uses only line-drawing as the visual operation. More sophisticated visual CoT implementations — region cropping, zooming, point marking, image differencing — might provide qualitatively different benefits that line-drawing alone does not capture. The paper's V-CoT is a specific instantiation of visual CoT, not visual CoT in general.

Does the paper demonstrate that "Grounded short CoT surpasses verbose ones"?

This claim is strongly supported by Figure 3, where G-CoT-least outperforms full G-CoT on both training convergence speed (Figure 3a: G-CoT-least reaches 100% by step 200; G-CoT by step 400+) and test accuracy on 7×7 (Figure 3c: G-CoT-least approximately 0.65–0.70; G-CoT approximately 0.55–0.60). The comparison is clean: the only difference between G-CoT and G-CoT-least is the presence or absence of explicit coordinate annotations and textual narration in the SFT data, with identical RL protocol and evaluation. The result is robust and the direction is clear.

However, an important mechanistic question is left unanswered: why does shorter CoT surpass longer ones? The paper proposes that "once the model's grounding ability is properly aligned, it can internalize and operate over its own latent spatial representations without relying on externally specified coordinate systems" (Section 4.2.2). This is an interpretation, not a demonstrated mechanism. An alternative explanation is that the format reward (0.9 weight, Section 3.2) is harder to satisfy for G-CoT than for G-CoT-least: G-CoT must produce thinking tags with coordinate annotations AND response with the final path, while G-CoT-least only needs to produce the final path in \boxed{}. The format compliance burden is substantially higher for G-CoT, and the 0.9 weight on format reward means the model spends most of its RL optimization budget maintaining format rather than improving correctness. If this alternative explanation is correct, the "short is long" effect is partly an artifact of the reward design — a format-weight ablation would be needed to rule this out.

A second concern: the G-CoT SFT data was synthesized by Gemini-2.5-Pro with a specific prompt (Appendix, Figure 7) that instructs the model to simulate exploration, backtracking, and reflection. If Gemini-2.5-Pro's synthesized reasoning contains errors or unnatural patterns that confuse the learner, then G-CoT-least's advantage might reflect Gemini's limitations as a teacher rather than the inherent superiority of short CoT. An ablation with human-written G-CoT traces (or traces from a more capable teacher model) would address this, but is not performed.

Does the paper demonstrate that "CoT with the least grounded results generalizes the best"?

This claim is the paper's headline finding and rests primarily on Figures 4 and 5. The evidence is quite strong for the specific generalization conditions tested.

Single-scale generalization (Figure 4): G-CoT-least achieves approximately 0.65 test accuracy on 7×7 vs. V-CoT's approximately 0.55–0.60 at step 1000, with G-CoT-least still improving while V-CoT saturates. The gap is moderate but consistent.

Cross-scale generalization (Figure 5): G-CoT-least achieves approximately 0.60 on 10×10 vs. V-CoT's approximately 0.35–0.40 at step 800, with G-CoT-least still improving and V-CoT plateaued. The gap is large (~50% relative improvement) and clearly visible.

The cross-scale result is the paper's strongest single piece of evidence, because: (a) the generalization gap is substantial (trained on up to 9×9, tested on 10×10), (b) the performance difference is large and not merely a training-speed artifact (since both models are trained well past convergence on training accuracy), and (c) the V-CoT model saturates while G-CoT-least continues to improve, suggesting a qualitative difference in generalization dynamics rather than merely a horizontal shift in the training curve.

However, several qualifications are necessary:

Generalization is tested only one step beyond training. For single-scale, the generalization gap is 6×6 to 7×7 (+1 grid size). For cross-scale, the RL training includes up to 9×9 and tests on 10×10 (+1 beyond RL, though farther from SFT). The paper does not test more extreme generalization gaps (e.g., train on 4×4, test on 20×20; or train on 6×6, test on 12×12), so it is unknown whether G-CoT-least's generalization advantage holds at larger scale gaps or whether both formats would eventually fail. The "generalizes best" claim is supported for the tested gaps but extrapolation to arbitrary gaps is speculative.

Only G-CoT-least and V-CoT are compared in the generalization experiments. L-CoT and G-CoT are not included in Figures 4 and 5. This means the claim is specifically "G-CoT-least generalizes better than V-CoT," not "G-CoT-least generalizes better than ALL CoT formats." It is possible that L-CoT or G-CoT would show generalization performance intermediate between the two extremes, which would nuance the "short is long" narrative (e.g., perhaps there is an optimal amount of grounding, not simply "least is best").

The evaluation uses a single test set per size. The paper does not report how many 7×7 or 10×10 mazes were used for evaluation, nor does it report variance across different maze instances. With a small test set (which is plausible given the paper's scale), the reported differences could be affected by sampling noise. Confidence intervals are not provided, so the statistical reliability of the generalization gap is unknown.

The frozen vision encoder may limit V-CoT's generalization in ways specific to this setup. V-CoT's interleaved image reasoning relies on the vision encoder's ability to process line-drawn paths on maze images. If the frozen pretrained vision encoder is not well-suited to this task (because it was trained on natural images, not mazes with overlaid lines), V-CoT's poor generalization might reflect an implementation limitation rather than an inherent weakness of visual CoT. Fine-tuning the vision encoder might substantially improve V-CoT's ability to leverage its visual operations, potentially narrowing or reversing the generalization gap. This is a critical missing ablation.

Do the real-world VQA results (Table 1) support the generalization of "short is long" beyond mazes?

Table 1 shows G-CoT-least RL outperforming V-CoT RL on V* and HR-Bench, with consistent advantages across subtasks. This provides initial evidence that the finding is not maze-specific. However, several issues limit the strength of this evidence:

Training protocol differs from maze experiments. The VQA results use zero-shot RL (no SFT), while maze results use SFT-then-RL. The paper's central finding is that SFT cold-start data format affects RL generalization; the VQA experiments don't test this because there is no SFT stage to vary. The comparison on VQA is between zero-RL with V-CoT cropping operations and zero-RL without them — a different experimental question than "which SFT CoT format produces better generalization after RL."

No training convergence data is reported for VQA. Table 1 reports only final accuracy numbers. Without training curves, it is impossible to determine whether V-CoT would catch up to G-CoT-least with extended RL training (as it did in the maze ceiling experiments, Figure 2c) or whether the gap persists at convergence. Given that the paper's primary methodological contribution is training to convergence to distinguish acceleration from ceiling effects, the absence of convergence data for the real-world extensions is a significant omission — the paper fails to apply its own methodological standard to its generalization experiments.

The V-CoT implementation for VQA is a specific instantiation (cropping regions). Cropping is only one visual CoT operation; other operations (zooming, point marking, contrast adjustment) might yield different results. The finding is specific to cropping-based visual CoT vs. no visual operations, not visual CoT in general.

What experiments would strengthen the paper?

Format reward weight ablation (α sweep): Testing α values of 0.1, 0.5, and 0.9 would determine whether the "short is long" effect depends on the heavily format-weighted reward. If G-CoT-least's advantage diminishes or reverses with higher correctness weight (α=0.5 or 0.9), the effect is partly attributable to reward design rather than CoT format per se.

Vision encoder fine-tuning: Training a condition where the vision encoder is unfrozen during SFT or RL would test whether V-CoT's poor generalization reflects an inherent limitation of visual CoT or an artifact of using frozen generic visual features for a specialized visual reasoning task.

SFT data scale ablation: Testing SFT dataset sizes of 1K, 8K, 64K, and 256K examples would reveal whether G-CoT-least's advantage is robust to data scale or whether elaborate CoT catches up with more data.

Human-written CoT baselines: Replacing Gemini-2.5-Pro synthesis with human-written reasoning traces for a subset of experiments would control for teacher model quality and test whether the "short is long" effect is an artifact of synthetic data artifacts.

Larger generalization gaps: Testing generalization from 4×4 SFT + 5×5–6×6 RL to 8×8 or 12×12 mazes would characterize how the generalization advantage scales with the distribution shift magnitude. A finding that the G-CoT-least advantage grows with the gap would strengthen the paper's claim about generalizable reasoning; a finding that both formats eventually fail would bound the claim.

Statistical characterization: Reporting confidence intervals or standard deviations for test accuracy, ideally across multiple random seeds, would allow assessment of whether the reported gaps are statistically reliable or consistent with sampling noise.

Convergence data for real-world VQA: Extending the VQA experiments to show training curves (analogous to Figures 2–5) would determine whether the G-CoT-least advantage on V* and HR-Bench is a convergence-speed effect (which might disappear with extended training) or a persistent ceiling effect.

What claims are well-supported vs. overstated?

Well-supported: "Visual and longer CoT accelerates convergence but does not lift the final performance ceiling" — for the specific model, task, and training protocol tested. The convergence curves in Figure 2 clearly show this pattern.

Well-supported: "G-CoT-least generalizes better than V-CoT across the tested maze sizes" — Figures 4 and 5 provide clear, consistent evidence for the tested generalization gaps (+1 size beyond training). The cross-scale result (Figure 5) is particularly convincing because the gap is large and V-CoT clearly saturates while G-CoT-least continues improving.

Overstated: "Short CoT containing essential grounding information achieves higher and more stable performance than longer, step-by-step CoT, suggesting that excessive intermediate explanation may not be useful for generalization" (Section 1). The phrase "may not be useful" is appropriately cautious, but the claim implies a generality that is not demonstrated: the finding is demonstrated for G-CoT-least vs. G-CoT on maze navigation with a specific training recipe. Whether "excessive intermediate explanation" is useless for other tasks, other model families, or other training protocols is unknown.

Overstated: "These findings highlight a 'short is long' effect and provide practical guidance for constructing more generalizable SFT datasets for visual reasoning" (Abstract). The "practical guidance" claim requires that the finding generalizes beyond the specific experimental setup. The real-world VQA results (Table 1) provide initial support but lack convergence data and use a different training protocol (zero RL vs. SFT-then-RL). The guidance may be valid, but the evidence base for practical recommendation is thinner than the paper suggests.

Conditionally supported: "CoT formats that retain only the least amount of grounding results (e.g., sparse coordinate paths or final trajectories) achieve the strongest generalization across maze sizes." This is supported for the specific comparison of G-CoT-least vs. V-CoT (Figures 4–5) and G-CoT-least vs. G-CoT (Figure 3). However, the claim uses the plural "formats" but only one minimal format is tested across multiple generalization conditions. L-CoT and G-CoT are not evaluated in the cross-scale generalization setting, so the claim that "least grounding generalizes best" is demonstrated primarily for one format (G-CoT-least) against one comparator (V-CoT) in the cross-scale setting.

6. Limitations and Trade-offs

6.1 The "Short is Long" Effect Is Demonstrated Only for One Model Family and One Task Paradigm

The assumption or constraint. All maze experiments use Qwen2.5-VL-7B as the base model (Section 3.3), with a frozen vision encoder throughout all training stages. The paper implicitly assumes that the observed dynamics—G-CoT-least outperforming elaborate CoT formats on generalization—will transfer to other VLMs, other model scales, and other visual reasoning tasks. The authors acknowledge this scope limitation in the conclusion: "we plan to extend this analysis to richer task families beyond mazes and VLMs" (Section 6), but the core "short is long" claim is presented as a general finding about CoT design for visual reasoning, not as a finding contingent on specific model properties.

The consequence. The practical guidance that practitioners should prefer minimal CoT SFT data over elaborate CoT is not safe to apply without knowing whether the result depends on properties of Qwen2.5-VL-7B specifically. Several model-specific factors could be responsible: (1) Qwen2.5-VL-7B's pretrained grounding ability may be unusually strong, allowing minimal SFT to activate it—a model with weaker pretrained visual grounding (e.g., a smaller or earlier-generation VLM) might genuinely need elaborate coordinate annotations or visual manipulation to learn spatial reasoning; (2) the 7B parameter scale may sit in a regime where the model's internal representations are rich enough for implicit spatial reasoning but limited enough that elaborate CoT introduces optimization noise—larger models might benefit differently from visual CoT; (3) the frozen vision encoder constraint means the model cannot adapt its visual features to maze-specific patterns, which may handicap V-CoT more than G-CoT-least since V-CoT relies on iterative visual processing of intermediate images with overlaid paths.

What evidence exists in the paper. The real-world VQA results (Table 1) provide initial evidence of transfer beyond mazes but do not address model-family generalizability since they use the same Qwen2.5-VL-7B base model. No experiment varies the base model (e.g., comparing Qwen2.5-VL-7B to Qwen2.5-VL-3B, Qwen2.5-VL-72B, Llama-3.2-Vision, or InternVL2). The paper's argument that Qwen2.5-VL-7B is "representative of the capabilities of many contemporary VLMs" (Section 4 framing) is asserted but never tested.

Mitigation status. Not addressed experimentally. The conclusion suggests future work on "richer task families beyond mazes and VLMs" but does not commit to multi-model replication. A practitioner deploying these findings would need to verify them on their specific model and task.

6.2 Difficulty Estimation for Real-World Tasks Is Not Provided—The Method Has No Mechanism to Know When Minimal CoT Will Work

The assumption or constraint. The paper demonstrates that short CoT outperforms long CoT for maze navigation (a pure visual reasoning task) and for the specific real-world benchmarks tested (V*, HR-Bench, FrozenLake, Jigsaw). The authors frame this as a general principle: "vision-centric reasoning" tasks benefit from minimal CoT while "language-dominant reasoning" tasks benefit from verbose CoT (Section 5). However, the paper provides no operational method for a practitioner to determine whether a new, arbitrary task falls into the "vision-centric" category where minimal CoT helps or the "language-dominant" category where it might hurt.

The consequence. A practitioner with a new visual reasoning task—say, diagrammatic physics reasoning, satellite image analysis, or medical image interpretation—cannot use this paper's framework to decide how much CoT to include in their SFT data. The paper shows that the "short is long" effect exists for certain tasks but does not equip practitioners to predict which tasks it applies to. There is a risk that practitioners overgeneralize the finding and strip CoT supervision from tasks where it genuinely helps, or conversely, invest in elaborate CoT for vision-centric tasks where it is unnecessary.

The paper's taxonomy—vision-centric vs. language-dominant—is defined post-hoc based on whether reasoning operates "in the continuous, holistic space of visual representations" (Section 4, Innovation 4 discussion) versus "the discrete, compositional space of natural language," but this is a conceptual distinction with no measurable boundary. The maze task is clearly vision-centric; V* and HR-Bench require visual search but also involve linguistic question answering—they are arguably mixed-modality rather than purely vision-centric. The paper does not characterize where the transition occurs.

What evidence exists in the paper. The results in Table 1 show G-CoT-least outperforming V-CoT on all tested benchmarks, but these tasks were selected by the authors, not sampled from a broader task distribution. There is no systematic sweep across tasks with varying degrees of vision-centricity to identify the boundary where "short is long" stops holding. The FrozenLake and Jigsaw results are obtained with a different training protocol (SFT-then-RL rather than zero-RL) and different data, making them case studies rather than points on a controlled continuum.

Mitigation status. Not addressed. The paper does not propose a difficulty-estimation or task-classification mechanism. A practitioner would need to run their own comparison of CoT formats on each new task to determine which works best—exactly the kind of expensive comparison that the paper's findings are meant to help practitioners avoid. This is a significant gap between the paper's analytical contribution and its practical deployability.

6.3 The Reward Design (Heavy Format Weight, α = 0.1) May Create the "Short is Long" Effect Rather Than Reveal It

The assumption or constraint. The RL reward function (Equation 3, Section 3.2) assigns only 10% weight to task correctness (r_acc) and 90% weight to format compliance (r_format). This design choice is justified as necessary to prevent format collapse during RL (Section 3.2), but it introduces a structural advantage for simpler CoT formats: G-CoT-least's format requirement (producing \boxed{} tags around the path) is substantially easier to satisfy than V-CoT's format requirement (producing thinking tags with interleaved image_draw_points_tool calls, then response tags with the final path). The 90% format reward means that models evaluated under G-CoT-least can achieve near-maximum reward simply by formatting correctly, while models evaluated under V-CoT must simultaneously maintain a much more complex output structure to avoid the format penalty.

The consequence. The observed advantage of G-CoT-least over V-CoT and G-CoT in RL training dynamics and final generalization may be partly—or substantially—attributable to the reward design rather than to any inherent superiority of minimal CoT. The effect could be driven by two interacting mechanisms: (1) Easier format optimization: G-CoT-least's simpler format requirement means the model spends less optimization budget on maintaining output structure and more on improving path accuracy; the 0.9 format reward is essentially "free" for G-CoT-least once the model learns to output \boxed{} tags, while V-CoT must continuously satisfy a complex multi-tag format. (2) Cleaner correctness gradient: Because G-CoT-least's entire output is the path sequence in \boxed{}, every output token has direct relevance to the correctness reward—there is no separation between "reasoning" and "answer" tokens. In V-CoT and G-CoT, the model generates hundreds or thousands of reasoning tokens before reaching the answer, and the RL gradient must propagate through this entire chain with no per-token feedback on which reasoning steps contributed to correctness. This creates a credit assignment problem where useful and useless reasoning steps receive identical reinforcement if the final answer is correct, potentially leading to noisier optimization and worse generalization.

If this interpretation is correct, the "short is long" effect is not a discovery about what CoT format teaches the model during SFT, but rather about what reward structure produces the most efficient RL fine-tuning. The SFT format still matters because it shapes the initial policy that RL starts from, but the primary driver of G-CoT-least's advantage would be the simpler optimization landscape during RL, not the quality of the SFT supervision per se.

What evidence exists in the paper. The paper does not ablate α (Section 5, ablation discussion). No experiment tests whether G-CoT-least's advantage persists, diminishes, or reverses under different reward weightings (e.g., α = 0.5 or α = 0.9). The format reward's structure is described (Section 3.2) but its interaction with different CoT formats' output complexity is not analyzed. This is a significant missing control because it means the paper's headline finding is confounded with reward design: we cannot distinguish whether G-CoT-least is a better CoT strategy for learning or merely a better output format for RL optimization under this specific reward function.

An additional subtlety: the paper introduces G-CoT-least as having no thinking/ response separation ("we do not separate them," Section 3.2), which means the format reward evaluates only the presence of \boxed{} tags, not the presence of properly tagged reasoning. This is a qualitatively different format requirement than the one applied to L-CoT, G-CoT, and V-CoT. The reward functions are therefore not strictly comparable across conditions—G-CoT-least is being optimized under a fundamentally easier format constraint.

Mitigation status. Not addressed. The paper treats the reward function as a fixed experimental parameter rather than a variable to be interrogated. The authors do not discuss the potential confound between reward weight and output format complexity.

6.4 The Training and Evaluation Set Size (500 Test Questions, No Reported Variance) Leaves Statistical Reliability Uncertain

The assumption or constraint. The paper reports all quantitative results as point estimates without confidence intervals, error bars, or significance tests. The maze RL experiments use an additional 20K training samples beyond the 8K SFT samples (Section 3.2), but the evaluation set size for maze experiments is never explicitly stated. For the real-world VQA experiments, Table 1 reports final accuracy numbers on the V* test set (size unspecified in the paper; the original V* benchmark has ~200 test samples across attribute and spatial splits) and HR-Bench 4K (4000 samples, but the paper reports accuracy to two decimal places, implying a test set of reasonable size). The FrozenLake and Jigsaw evaluation sizes are not reported.

The consequence. Without statistical characterization, it is impossible to determine whether the reported G-CoT-least vs. V-CoT differences—particularly the 0.60 vs. 0.35–0.40 gap in cross-scale generalization (Figure 5c) and the 2–3 percentage point advantages in Table 1—are statistically reliable or consistent with sampling noise. This matters particularly for the real-world VQA results, where the advantages are moderate (e.g., V* Spatial: 82.89 vs. 78.95, a 3.94 percentage point difference) and could plausibly arise from variance in test set composition or random seed variation in RL training. The cross-scale generalization gap shown in Figure 5 is larger and visually clearer, but without knowing the number of 10×10 test mazes or the variance across maze configurations, a reader cannot assess whether the gap would replicate on a different set of 10×10 mazes.

A specific concern: the paper's test sets are generated procedurally (mazes) or drawn from standard benchmarks (V*, HR-Bench). For the maze experiments, if the 10×10 test set contains, say, 50 mazes, then the accuracy difference between 0.60 and 0.35 corresponds to 30 correct vs. 17–18 correct mazes—a gap of ~12–13 mazes. With 50 test samples, the 95% confidence interval for a 0.60 accuracy is approximately ±0.14 (using normal approximation), meaning the two conditions' confidence intervals (0.46–0.74 for G-CoT-least and 0.21–0.49 for V-CoT) would barely overlap at the boundary. This suggests statistical significance at the 0.05 level, but the exact confidence depends on test set size and variance, neither of which is reported. For the real-world VQA results with smaller gaps (2–4 percentage points), the same confidence-interval analysis would likely show overlapping intervals unless test sets are very large, making those results less statistically convincing.

What evidence exists in the paper. The paper provides no statistical characterization beyond point estimates. The training curves in Figures 2–5 show trends over RL steps (1000+ data points for training accuracy) but report no variance bands or multiple-seed replication. The paper does not state the number of evaluation mazes used for any experiment, nor does it report the standard error of the reported accuracies. This is a departure from standard practice in empirical ML, where confidence intervals or at minimum test-set sizes are typically reported for headline results.

Mitigation status. Not addressed. The paper does not discuss test set size, variance, or statistical significance. A practitioner evaluating whether to adopt G-CoT-least based on these results has no way to assess whether the reported improvements would generalize to their own test distribution or whether they fall within the noise floor of the evaluation protocol.

6.5 V-CoT's Poor Generalization May Reflect Implementation Constraints (Frozen Vision Encoder, Line-Drawing Only) Rather Than an Inherent Weakness of Visual CoT

The assumption or constraint. The paper's V-CoT condition uses only one visual operation (line-drawing) and freezes the vision encoder throughout all training (Section 3.3: "Throughout all training stages, we freeze the vision encoder and only update the parameters of LLM"). These are reasonable choices for a controlled experiment, but they mean that V-CoT is evaluated under constraints that may specifically handicap it relative to G-CoT-least, creating a potentially unfair comparison that the paper does not acknowledge as a limitation of V-CoT generalizability rather than of the experimental setup.

The consequence. Three specific ways the frozen vision encoder may disproportionately hurt V-CoT:

Processing intermediate images with overlaid paths. V-CoT iteratively draws lines on maze images and feeds the modified images back through the frozen vision encoder. The vision encoder was pretrained on natural images—photographs, diagrams, charts—not on mazes with overlaid colored lines. The frozen encoder may produce suboptimal or noisy embeddings for these intermediate images, making it difficult for the LLM to extract useful information from the visual feedback loop that V-CoT is designed to provide. If the vision encoder were fine-tuned to recognize the significance of overlaid path lines, V-CoT's iterative visual reasoning might become substantially more effective. G-CoT-least, by contrast, processes only the original maze image (which is closer to the vision encoder's pretraining distribution), potentially benefiting from cleaner visual features.

No adaptation to maze-specific visual features. The frozen vision encoder cannot learn that maze walls, grid lines, and S/E markers are task-relevant features. All visual processing must rely on the encoder's generic feature detectors. If V-CoT's benefit comes partly from being able to focus attention on relevant image regions (the drawn path, the wall boundaries around junctions), this focusing is limited by the encoder's frozen, unadapted feature space.

V-CoT's per-step image processing amplifies encoder noise. Each V-CoT forward pass processes an intermediate image through the frozen encoder. If the encoder produces noisy or uninformative embeddings for these intermediate images, the noise accumulates across reasoning steps, potentially causing the LLM to make worse decisions than if it had relied purely on its internal spatial representations (as G-CoT-least does). This would make V-CoT's reasoning less reliable per step, even though each step has access to more explicit visual information. G-CoT-least avoids this noise entirely by generating the path in one shot.

Additionally, the paper uses only line-drawing as the visual operation. Visual CoT systems in practice (e.g., OpenAI's "thinking with images") support multiple operations—region cropping to zoom in on details, point marking to track specific locations, image differencing to detect changes. Line-drawing alone may not capture the full value of visual manipulation, and different operations might produce different generalization dynamics.

What evidence exists in the paper. The paper does not ablate vision encoder fine-tuning (Section 5, ablation discussion). No experiment tests whether V-CoT's generalization improves when the vision encoder is trained alongside the LLM, or when different/additional visual operations are available. The paper's V-CoT results should therefore be interpreted as an upper bound on the weakness of V-CoT—it is the worst-case performance for V-CoT under frozen-encoder constraints, not necessarily the capability of V-CoT as a paradigm.

Mitigation status. The paper does not discuss vision encoder fine-tuning as a potential confound in the V-CoT vs. G-CoT-least comparison. The finding that "visual CoT does not lift the ceiling" is presented without the caveat that the ceiling was measured with a frozen vision encoder that was never adapted to process V-CoT's intermediate images. A reader might incorrectly conclude that V-CoT is inherently limited for generalization, when the limitation may be specific to this experimental configuration.

6.6 The Findings Are Limited to Tasks with Deterministic, Verifiable Correctness—Extending to Open-Ended or Subjective Visual Reasoning Is Untested

The assumption or constraint. The entire experimental framework depends on the availability of a rule-based correctness checker: the maze path validator (which verifies start-to-end connectivity without wall crossings), the FrozenLake environment's target-cell checker, the Jigsaw assembly validator, and the V*/HR-Bench ground-truth answers. This enables both the sparse r_acc reward signal during RL and the accuracy-based evaluation metric. The paper's training paradigm (GRPO with a binary correctness reward) and its evaluation framework (binary accuracy) both require tasks where correctness is unambiguously defined and automatically verifiable.

The consequence. Many important visual reasoning tasks lack clean, automatically verifiable correctness signals. Examples include: open-ended visual question answering ("What is happening in this image?"), visual storytelling, diagram explanation, creative visual design, subjective visual assessment ("Is this image aesthetically pleasing?"), and multi-step visual planning where multiple valid solutions exist. For these tasks, the paper's SFT-then-RL pipeline with sparse binary rewards cannot be directly applied—there is no r_acc signal to drive RL, and accuracy cannot be measured as a binary metric.

The paper's findings about CoT format effectiveness are therefore bounded to the class of verifiable visual reasoning tasks: problems where the output can be automatically checked against a ground-truth answer. This is a large and important class (math with diagrams, spatial reasoning puzzles, visual search with deterministic answers, code generation from visual specifications), but it excludes a substantial portion of real-world VLM use cases. A practitioner working on an open-ended visual reasoning task cannot use this paper's framework to decide between CoT formats, because the framework's key mechanism—RL discovering efficient reasoning strategies through correctness-based optimization—does not apply in the absence of a verifier.

Moreover, it is plausible that the relationship between CoT format and generalization reverses for open-ended tasks. On tasks where there is no single correct answer, verbose CoT (with explicit reasoning, exploration of alternatives, justification of decisions) might be essential for producing coherent, justifiable outputs, while minimal CoT (just outputting an answer) could produce answers that are correct in format but uninterpretable or ungrounded. The paper's finding that "short is long" may be specific to tasks where the answer format (e.g., a coordinate path) is a sufficient representation of the solution, which is true for maze-solving but not for "describe the emotions in this photograph."

What evidence exists in the paper. All tasks evaluated—maze navigation, FrozenLake, Jigsaw, V*, HR-Bench—have deterministic, verifiable correct answers. The paper does not test any open-ended or subjective visual reasoning task. The reward function (Equation 3, Section 3.2) explicitly requires a binary r_acc based on path correctness; there is no partial-credit or learned-reward variant tested. The extension to "richer task families" mentioned in the conclusion (Section 6) does not specify whether these will include open-ended tasks.

Mitigation status. Not addressed. The paper does not discuss the verifiability requirement as a scope limitation, nor does it speculate on how findings might differ for tasks without automatic correctness verification. A practitioner would need to independently determine whether their task falls into the "verifiable visual reasoning" category where the paper's framework applies.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not propose a new reasoning method, a new training algorithm, or a new model architecture. Its contribution is diagnostic rather than inventive, and the diagnosis it delivers challenges a widespread but largely unexamined assumption: that longer, more elaborate, and more richly multimodal Chain-of-Thought traces are strictly better for teaching vision-language models to reason. This assumption—inherited from the success of lengthy CoT in language-only reasoning benchmarks and amplified by the excitement around visual CoT systems like OpenAI's "think with image"—has driven substantial investment in constructing increasingly complex CoT datasets with interleaved images, reflection cycles, and step-by-step spatial annotations. The paper's central finding—that minimal grounding traces (G-CoT-least, a bare coordinate sequence with no textual narration, no coordinate annotations, and no visual manipulation) match or outperform elaborate visual CoT after full RL training, and decisively outperform it on cross-scale generalization (Figure 5c: ~0.60 vs. ~0.35–0.40 accuracy on unseen 10×10 mazes)—forces a reevaluation of why SFT CoT data helps in the first place.

The magnitude of the shift is best characterized as a reframing with diagnostic force, not a paradigm overthrow. The paper does not claim that CoT is useless, nor does it argue against the SFT-then-RL training paradigm. Rather, it provides a mechanistic reinterpretation of what the SFT stage accomplishes in vision-centric tasks. Under the prevailing view, SFT CoT data teaches the model how to reason—the intermediate steps provide a template for decomposition, spatial reference, and self-correction that the model internalizes and refines during RL. The paper's evidence suggests an alternative: SFT's primary function is to activate and align the model's pre-existing grounding ability with the task-specific output format, and the actual reasoning strategy is discovered by RL through direct optimization against the sparse correctness reward. The reasoning strategy that RL discovers tends to be more compact and more generalizable than the explicitly supervised CoT patterns, which explains why models initialized from verbose CoT SFT converge to shorter reasoning traces after RL, and why the model initialized from no reasoning trace at all (G-CoT-least) achieves the best generalization.

This reframing resolves a specific tension in the prior literature. Several groups observed that vision-centric RL produces surprisingly short CoT traces (Sarch et al., 2025; Li et al., 2025; Wu et al., 2025), but had no explanation for why this occurred or whether it was a bug (insufficient training) or a feature (efficient strategy discovery). The dominant "longer is better" narrative from the language CoT literature treated these short traces as anomalous, perhaps indicating that the models were under-trained or the RL was poorly tuned. The paper's systematic convergence analysis (training to 1000 GRPO steps, well past the typical 100–200 steps in prior work) demonstrates that the short traces are not a training artifact—they persist at convergence and are associated with better generalization, not worse. The anomaly becomes the discovery: vision-centric tasks induce a compression dynamic under RL, where explicit intermediate reasoning is replaced by implicit spatial computation, and this compression improves transfer to unseen problem sizes because the model learns size-invariant spatial rules rather than training-distribution-specific visual patterns.

Which research directions become more attractive as a result?

Making SFT data construction cheaper becomes a high-priority goal. If minimal grounding traces are sufficient for vision-centric tasks, the elaborate CoT synthesis pipelines that dominate current practice (Gemini-2.5-Pro prompting, interleaved image rendering, multi-step reflection generation) are unnecessarily expensive. The paper shows that for maze navigation, simply providing the answer trajectory as the SFT target (with no reasoning trace at all) achieves the best results. Extending this finding to more tasks could dramatically reduce the cost of building SFT datasets for visual reasoning, redirecting effort from CoT design to task alignment.

RL algorithm design for vision-centric tasks becomes more nuanced. The paper's evidence that RL converges to compact internal strategies regardless of SFT initialization suggests that the RL algorithm, not the SFT data, is the primary driver of final reasoning capability for these tasks. This redirects attention from CoT engineering toward RL improvements: better exploration, more efficient credit assignment, reward shaping that distinguishes useful from useless reasoning steps, and optimization methods that explicitly encourage the discovery of compressed, generalizable policies.

The difficulty of the "vision-centric vs. language-dominant" boundary becomes a pressing research question. The paper's findings create a new taxonomy—tasks where reasoning operates primarily on visual representations (maze navigation, visual search, spatial puzzles) benefit from minimal CoT, while tasks where reasoning operates primarily on linguistic abstractions (math word problems, logical deduction) may still benefit from verbose CoT—but provides no operational method for classifying a new task into one category or the other. Until this boundary is characterized, practitioners cannot safely apply the "short is long" principle to arbitrary visual reasoning tasks.

Visual CoT research becomes conditional rather than presumptively valuable. The paper does not demonstrate that visual CoT is useless—it demonstrates that visual CoT, as implemented with line-drawing and a frozen vision encoder, does not improve and may harm generalization relative to minimal grounding for this specific class of tasks. This shifts the burden of proof: new visual CoT methods should demonstrate not just that they outperform language-only baselines (which may be an acceleration artifact), but that they raise the asymptotic generalization ceiling when trained to convergence. The field should be more skeptical of visual CoT claims that compare mid-training snapshots rather than converged models.

Which research directions become less attractive?

Incremental improvements to CoT prompt engineering for SFT data synthesis. If the specific wording, reflection patterns, and step-by-step structure of synthesized CoT traces are largely irrelevant once RL converges (as the paper's ceiling results suggest), then marginal refinements to Gemini-2.5-Pro prompting templates—making reflections more "natural," adding more detailed spatial descriptions, improving the balance of exploration and exploitation in the narrative—are unlikely to yield meaningful capability improvements. The effort is better spent on understanding the RL dynamics that actually determine final performance.

Scaling CoT length as a primary mechanism for improving visual reasoning. The paper directly contradicts the assumption that longer CoT traces (more thinking tokens) produce better reasoning. For the maze task, the shortest CoT (zero reasoning tokens beyond the answer itself) achieves the best generalization. While this finding may not extend to language-dominant visual reasoning tasks, it establishes that CoT length scaling is not a universal principle—its effectiveness depends on the reasoning modality, and for vision-centric tasks, it may be actively counterproductive for generalization. Work that assumes "longer = better" without characterizing the task's vision-centricity is building on a potentially false premise.

Treating visual CoT as a necessary ingredient for strong visual reasoning. The paper's G-CoT-least results show that a model can achieve strong maze-solving and generalization with no visual operations at all—it processes the static maze image once and outputs the path in a single forward pass. This challenges the narrative that active visual manipulation (cropping, drawing, zooming) is essential for complex visual reasoning, at least for tasks where the answer format intrinsically encodes the spatial trajectory. Visual CoT may still be valuable for tasks where the answer is not a spatial sequence (e.g., "describe the relationship between objects A and B"), but its presumed necessity for spatial reasoning tasks is not supported.

Follow-Up Research This Work Enables

Ablating the format reward weight (α) to disentangle CoT format effects from RL optimization dynamics. The paper's RL reward function assigns 90% weight to format compliance and only 10% to task correctness (α = 0.1, Equation 3). This creates a structural advantage for G-CoT-least, whose format requirement (producing \boxed{} tags around the path) is substantially simpler than V-CoT's (producing thinking tags with interleaved tool calls and response tags with the answer). A systematic sweep of α values—say, 0.1, 0.3, 0.5, 0.7, 0.9—across all four CoT formats would determine whether the "short is long" effect persists, diminishes, or reverses when the correctness reward dominates. If G-CoT-least's advantage vanishes at α = 0.5 or higher, the effect is largely a reward-design artifact rather than a discovery about CoT format, and the practical recommendation becomes "use simple output formats with heavily format-weighted RL" rather than "use minimal CoT SFT data." Conversely, if the advantage persists at high α, the finding is robust to reward design and indicates a genuine benefit of minimal supervision. This experiment would run on the maze benchmark with the standard setup (SFT on 4×4–6×6, RL on same, test on 7×7) and would require approximately 5 (α values) × 4 (CoT formats) × 1000 (RL steps) training runs—feasible with the paper's infrastructure.

Fine-tuning the vision encoder during V-CoT training to test whether frozen visual features cause V-CoT's poor generalization. The paper freezes the vision encoder throughout all training, meaning V-CoT must process intermediate images (mazes with overlaid line-drawn paths) through a visual feature space optimized for natural images. This may disproportionately handicap V-CoT: the encoder cannot learn to recognize the significance of overlaid paths, and noise from suboptimal intermediate-image embeddings may accumulate across reasoning steps, making V-CoT's iterative visual feedback counterproductive. An experiment that unfreezes the vision encoder during SFT and/or RL—or, more cheaply, that adds a lightweight adapter or LoRA module to the vision encoder—would test whether V-CoT's generalization ceiling rises when the visual features can adapt to the task. The prediction: if V-CoT with an adapted vision encoder matches or exceeds G-CoT-least on cross-scale generalization (10×10 mazes, Figure 5 protocol), then V-CoT's poor showing in this paper is an implementation artifact rather than an inherent limitation, and the practical implication shifts to "visual CoT requires vision-encoder adaptation, not just LLM training." If V-CoT with an adapted encoder still underperforms G-CoT-least, the finding that visual manipulation is unnecessary for spatial reasoning generalization is strengthened. This experiment would use the cross-scale generalization protocol (SFT 4×4–6×6, RL 7×7–9×9, test 10×10) with the same CoT data but varying vision-encoder trainability.

Characterizing the generalization gradient by testing progressively larger scale gaps. The paper tests two generalization gaps: +1 size (6×6 → 7×7, Figure 4) and +1 beyond the RL maximum (trained up to 9×9, tested on 10×10, Figure 5). It does not characterize how the G-CoT-least advantage scales with the generalization gap. A systematic experiment that trains on a fixed size range (e.g., SFT on 4×4–5×5, RL on 6×6–7×7) and evaluates on 8×8, 10×10, 12×12, 15×15, and 20×20 mazes would reveal the shape of the generalization curve for each CoT format. Key questions this would answer: Does G-CoT-least's advantage relative to V-CoT grow, shrink, or plateau as the test size diverges from the training distribution? Is there a threshold size beyond which all formats collapse, or does G-CoT-least maintain non-trivial accuracy on arbitrarily large mazes? Does V-CoT ever catch up if the generalization gap is small enough (e.g., train on 8×8, test on 9×9)? The answers would refine the "short is long" claim from a binary comparison to a quantitative scaling relationship, enabling practitioners to predict how much generalization to expect for a given training–testing size gap.

Replicating the core comparison (G-CoT-least vs. V-CoT vs. L-CoT vs. G-CoT) on a different base VLM to test model-family generalizability. The paper's findings are derived entirely from Qwen2.5-VL-7B with a frozen vision encoder. To test whether the "short is long" effect depends on specific properties of this model—its pretrained grounding ability, its architecture (Qwen2.5's particular vision-language interface), its scale (7B parameters)—a replication on at least one substantially different VLM is needed. Candidates include: a larger model from the same family (Qwen2.5-VL-72B) to test scale dependence; a model with a different architecture (LLaVA-OneVision, which uses a different visual-language connector); or a model with weaker pretrained spatial reasoning (perhaps an earlier-generation VLM). The experiment would use the identical maze dataset, CoT synthesis pipeline, and SFT-then-RL protocol, varying only the base model. If the G-CoT-least advantage replicates across models, the finding is a robust property of vision-centric RL dynamics, not a quirk of Qwen2.5-VL-7B. If it fails to replicate, the practical guidance must be model-specific, and the paper's claim of representativeness for Qwen2.5-VL-7B is called into question.

Training a task-classification model to predict whether a given visual reasoning task will benefit from minimal vs. elaborate CoT. The paper identifies "vision-centric" tasks as the regime where minimal CoT excels, but provides no operational definition beyond post-hoc characterization. A systematic study that constructs a diverse set of visual reasoning tasks (varying along dimensions like: degree of spatial reasoning required, whether the answer format intrinsically encodes the reasoning trajectory, whether multiple valid solutions exist, whether external knowledge is needed, whether the task requires object recognition or pure spatial inference) and runs the full SFT-then-RL protocol with both G-CoT-least and V-CoT for each task could identify the task features that predict which CoT format works best. The output would be a classifier or decision tree—not a conceptual taxonomy but an empirically validated predictive model—that takes task metadata as input and outputs the recommended CoT format. This would close the gap between the paper's diagnostic contribution and its practical deployability, giving practitioners a concrete tool rather than a general principle they must validate on each new task.

Combining G-CoT-least SFT with explicit exploration incentives during RL to test whether minimal supervision + structured exploration outperforms verbose supervision. The paper shows that RL discovers compact reasoning strategies from minimal SFT data, but RL is limited to the strategies it can discover through random exploration guided by sparse reward. An experiment that augments the GRPO objective with an exploration bonus—intrinsic motivation for visiting novel states, an entropy bonus encouraging diverse path choices, or a curriculum that progressively increases maze difficulty during RL—could test whether the combination of minimal SFT and incentivized exploration produces even better generalization than either minimal SFT + standard RL (the current G-CoT-least condition) or verbose SFT + standard RL (the current V-CoT condition). The prediction: if G-CoT-least provides a flexible initial policy that RL can shape through exploration, and verbose CoT provides a more constrained initial policy that RL refines within a narrower basin, then exploration incentives should widen the gap in favor of G-CoT-least, because the minimal-supervision model has more room to discover novel strategies.

Practical Applications and Downstream Use Cases

Cost-efficient SFT data construction for visual spatial reasoning tasks. The paper's finding that G-CoT-least (bare path sequences with no textual reasoning, no coordinate annotations, and no interleaved images) achieves the best generalization has immediate implications for teams building SFT datasets for spatial reasoning applications. The typical pipeline—synthesizing elaborate CoT traces via Gemini-2.5-Pro or similar teacher models, with detailed prompts that generate reflection patterns, spatial narration, and step-by-step reasoning—is expensive in API costs and engineering effort. For a maze-like task with 8K training examples, the paper's CoT synthesis requires: generating DFS paths, rendering intermediate images for V-CoT, and running Gemini-2.5-Pro inference with long, detailed prompts for each example. G-CoT-least eliminates all of this: the training target is simply the ground-truth path sequence, which can be generated by a rule-based function with zero API calls. For a team building a spatial reasoning application—robot navigation from floor plans, path planning in warehouse layouts, circuit tracing in schematic diagrams—this finding suggests that investing in high-quality task output formatting (ensuring the answer format naturally encodes the trajectory) and extensive RL may yield better results than investing in elaborate SFT CoT data. The 4× efficiency gain the paper reports in search vs. best-of-N does not directly apply, but the cost reduction in SFT data construction is analogous and potentially larger—eliminating the teacher model API calls entirely for tasks where the answer format is naturally a spatial sequence.

On-device deployment of visual reasoning with smaller models using RL post-training. The paper's demonstration that a 7B-parameter model with frozen vision encoder can achieve ~60% accuracy on unseen 10×10 mazes (after SFT on mazes up to 6×6 and RL up to 9×9) is notable because it shows that substantial spatial reasoning can be extracted from a relatively small model through the right training protocol—without scaling model size and without adapting the vision encoder. For applications requiring on-device spatial reasoning (e.g., a mobile app that helps users navigate building floor plans, an augmented reality system that traces paths through physical spaces, a drone that plans routes from camera input), the finding that minimal SFT + extensive RL produces generalizable policies suggests a deployment strategy: train a small VLM (7B or smaller) with rule-generated answer-format SFT data, then apply RL with environment-specific reward functions (which are often available for spatial tasks—path validity checkers, collision detectors, goal-reached verifiers) to optimize for the deployment distribution. The model can run entirely on-device because it requires only a single forward pass (no iterative visual operations, no external tool calls), and the generalization results (Figure 5c: 0.60 on 10×10 mazes after training up to 9×9) suggest that the trained policy will transfer to novel spatial configurations within the same task family. This contrasts with the alternative approach of deploying a larger cloud-based model with verbose CoT, which would incur latency, connectivity, and cost penalties.

Data generation for self-improvement in visual reasoning. The paper's SFT-then-RL framework, combined with the finding that minimal CoT SFT data is sufficient, has implications for automated self-improvement pipelines where models generate their own training data. In a typical self-improvement loop (e.g., STaR, ReST^EM), a model generates solutions to training problems, correct solutions are filtered and used for further fine-tuning, and the cycle repeats. For spatial reasoning tasks, the question is: what format should the generated solutions take? The paper's results suggest that the model should generate solutions in the minimal answer format (G-CoT-least) rather than attempting to generate elaborate reasoning traces. Generating elaborate CoT (V-CoT with interleaved images) is computationally expensive and, per the paper's findings, produces models that generalize worse. Generating minimal-format solutions (coordinate paths, action sequences) is cheaper and—when combined with RL optimization on those solutions—produces policies that generalize better. This suggests a self-improvement pipeline where: (1) the current model generates G-CoT-least-format solutions for training problems, (2) a rule-based verifier filters correct solutions, (3) the model is fine-tuned on these solutions (or RL is run with these as on-policy data), and (4) the cycle repeats with the improved model generating higher-quality solutions. The paper's results predict that this pipeline would be both cheaper (no elaborate CoT generation) and more generalizable (converging to compact, transferable spatial strategies) than a pipeline that generates verbose CoT.

When to Prefer This Method

The paper does not articulate an explicit decision rule or tradeoff matrix for choosing among CoT formats—it is a diagnostic study that reveals an empirical pattern rather than a methods paper that proposes a technique to be adopted. The "short is long" finding is a discovery about how different CoT formats interact with RL training dynamics, not a recommendation to always use G-CoT-least. A forced decision matrix would be the author's extrapolation and risks overstating the paper's prescriptive content beyond what the evidence supports. The paper's practical contribution is the observation that for vision-centric tasks with deterministic, verifiable outputs and an answer format that intrinsically encodes the spatial trajectory, minimal grounding SFT data combined with convergence-level RL training may outperform elaborate CoT SFT data on generalization—but the conditions under which this holds (model family, task type, reward design, vision encoder trainability) are not sufficiently characterized to support a deployment-guiding decision rule.