WorksComputer Science
LogT: Logically Think with Images for Visual Search
Abstract
Thinking with images empowers vision-language models (VLMs) to use an external Zoom-in tool for fine-grained visual search. Recent works employ supervised fine-tuning (SFT) and reinforcement learning (RL) with tool-specific designs to enable such capabilities. However, achieving logical reasoning alongside accurate and efficient tool use remains a significant challenge. To address this, we shift the focus away from increasing RL complexity and instead identify SFT data quality as a key bottleneck. We then propose LogT (short for Logically Think with Images), a fully automated SFT data engine that explicitly enforces logic-chain-guided reasoning. LogT generates an SFT dataset featuring challenging, visually grounded questions and structured tool-use traces with human-like logic. We validate our approach by fine-tuning two base models, Qwen2.5-VL-7B and InternVL3.5-8B, on the dataset and evaluating them across seven benchmark test sets. We show that LogT-SFT based on Qwen2.5-VL-7B outperforms the state-of-the-art trained with both SFT and RL, despite using 3.1 less data and fewer GPU hours. Furthermore, applying a simple RL recipe without tool-specific design on LogT-SFT yields a model that surpasses prior methods with complex RL setups by a substantial 9.59-point margin. In addition to strong performance gains, our model exhibits higher tool-use accuracy and efficiency, as well as more structured and logically consistent reasoning traces, directly validating the effectiveness of our approach.
Introduction
Vision-Language Models (VLMs) [1, 18] integrate visual and textual information by aligning high-level visual cues with text embeddings via visual encoders and projection layers. However, this alignment process introduces irreversible information loss, causing VLMs to struggle with visually intensive tasks that require fine-grained visual search [42]. Even when augmented with text-based chain-of-thought (CoT) reasoning [39, 45], such limitations persist, as textual reasoning cannot recover missing visual details. Therefore, recent works [7, 24] introduce thinking with images, enabling VLMs to invoke external tools to extract additional visual information and interleave it with textual reasoning. In this context, we investigate how VLMs can more effectively leverage the widely studied ZOOM-IN tool [24, 31, 46, 50, 12, 17] for visual search.
Existing efforts approach this problem through post-training, typically combining supervised fine-tuning (SFT) for cold start with reinforcement learning (RL) driven by outcome-based and tool-related rewards. While these methods have shown promising results, we find that the improvement largely stems from increased familiarity with the tool format gained during post-training. In contrast, enabling VLMs to logically reason about when and how to invoke the tool for accurate region-of-interest identification and efficient inference remains a fundamental challenge [23] (see analysis in § 4.5). While RL with finer-grained step-by-step process supervision using process reward models (PRMs) [16] has shown early promise in improving reasoning aided by non-visual tools, PRMs for training VLMs to think with images and use ZOOM-IN effectively and efficiently remain underexplored, largely due to the limited scalability and high compute cost of training dedicated PRMs.
Therefore, we shift the focus from designing more complex RL to improving SFT data quality, which we identify as a key bottleneck. We propose LogT, a novel data engine that generates SFT data to teach VLMs to Logically Think with Images for visual search. Importantly, LogT is fully automated and relies solely on open-source models to enhance the quality of SFT data. Each synthesized SFT sample includes a visual search question-answer (QA) pair, and the corresponding tool-use reasoning traces. Accordingly, we design LogT to improve the quality of both QAs and reasoning traces.
For QA quality, we enrich the VLM’s input with detailed visual contexts in addition to the full image, enabling the synthesis of more challenging questions that target fine-grained visual details. We then apply rigorous filtering to retain only high-quality QA pairs. For reasoning trace quality, we first construct logic chains that mimic human problem-solving strategies (e.g., multi-hop reasoning in Figure 1). These logic chains serve as skeletons and outline the key steps needed to solve each visual search task. We then use them to guide the VLM in generating structured and coherent reasoning traces with appropriate tool calls.

Figure 1. Main idea. We generate reasoning traces based on human-like strategies including (i) direct answering for simple questions, (ii) multi-hop reasoning by focusing on different regions, and (iii) exhaustive search for more difficult cases. For easy questions where the base model’s average@8 is 1, we synthesize direct answering traces without Zoom-in. Otherwise, we first generate logic chains that specify key tool-use steps and then use them to guide the VLM in synthesizing tool-use reasoning traces.
To demonstrate the effectiveness of LogT, we train Qwen2.5-VL-7B ([3]) and InternVL3.5-8B ([36]) on our synthesized SFT dataset comprising 7.1k high-quality entries. As shown in Figure 2, using 3.1× less data and >120× fewer GPU hours, our SFT-only model (LogT-SFT based on Qwen2.5-VL-7B) outperforms the state-of-the-art (SOTA) open-source model trained by both SFT and RL across seven test sets. We further apply off-the-shelf RL with straightforward outcome-based rewards, and the resulting model outperforms prior methods by at least 9.59 points, despite their reliance on more complex, tool-specific RL strategies. In addition, both our SFT and RL checkpoints achieve better tool-call accuracy and efficiency. A human evaluation further shows that our method produces more coherent and higher-quality reasoning traces.

Figure 2. Result highlights. By applying SFT to a Qwen2.5-VL-7B model using 5.4k to 7.1k of our synthesized data, LogT-SFT surpasses the best-performing Mini-o3-RL on average across seven test sets, while using up to 3.1× less data and >120× fewer GPU hours. With a simple RL setup without any tool-specific design, LogT-RL further outperforms baselines by 9.59.
In summary, our contributions are threefold:
We identify SFT data quality as a key bottleneck and introduce LogT, a novel data synthesis strategy that generates high-quality SFT data with challenging QA pairs and coherent, human-like reasoning traces. This strategy produces a dataset with 7.1k entries.
We show that training Qwen2.5-VL-7B solely on our SFT data outperforms prior SOTA models that use both SFT and RL, while also achieving significantly higher data and training efficiency, highlighting the benefit of investing more compute and effort in SFT data quality.
We further improve LogT-SFT with a simple RL setup without any tool-specific design, underscoring the importance of SFT quality. The resulting model also achieves higher tool-call accuracy, greater tool-call efficiency, and more logically coherent reasoning traces.
Related Work
Think with images. Thinking with images extends text-only CoT reasoning by allowing VLMs to interleave textual reasoning with visual information extracted via external tools from either the input image or intermediate tool outputs. Some methods [7, 49] adopt a training-free, modular agent-based design, allowing VLMs (e.g., GPT-4o [10]) to invoke visual tools during inference. In contrast, other approaches, including OpenAI’s o3 (OpenAI, 2025c; Huang et al., 2025b,a; Wu et al., 2025), rely on post-training to incentivize VLMs with tool-use capabilities.
Among prior work, Zoom-in is one of the most widely used visual tools [24, 31, 46, 50, 12, 17, 32, 48, 19], showing consistent improvements in visual search [42]. Most methods employ a two-stage post-training pipeline of SFT followed by RL. SFT primarily teaches models to invoke Zoom-in and conform to its calling format, which is useful because current VLMs exhibit limited zero-shot tool-use ability. RL then uses outcome-based rewards to further encourage tool usage and format compliance. However, these approaches still face fundamental challenges to train VLMs to reason logically with images and to call Zoom-in both accurately [19] and efficiently [23]. Li et al. [17] improve tool-call efficiency through designing complex RL rewards and rollout strategies, but at the tradeoff of substantial RL compute overhead. RL with process supervision could potentially mitigate these limitations. However, this often requires PRMs [16]. To the best of our knowledge, PRMs tailored for thinking with images remain underexplored, and training such specialized PRMs that meet our requirements is both challenging and very intensive.
SFT data for visual reasoning. Building SFT datasets for thinking with images requires reasoning traces that interleave text with images returned by tool calls. This is challenging because most existing SFT datasets for visual reasoning [20, 21, 43, 5, 33] contain only textual reasoning, without intermediate visual evidence. A few datasets [27, 13] do provide reasoning traces that interleave texts and images using referenced bounding boxes. However, they typically use low-resolution images and include only a single bounding box per trace, making them inadequate for high-resolution and fine-grained visual search tasks requiring multi-step tool use.
Recent works on thinking with images [31, 46, 12, 48] release their own SFT datasets. These studies typically generate visual search questions by directly prompting VLMs with full input images. Consequently, the synthesized questions often center on easy-to-search objects. Furthermore, the reasoning traces are usually generated by directly prompting VLMs or agents without careful quality control, and they often lack the human-like logical structure for solving complex problems, as presented in our approach. We also note that, despite the release of datasets and checkpoints in prior work, the data generation engines themselves receive less attention. In contrast, we focus on the data generation strategy itself.
Our Data Engine: LogT
We propose a novel data synthesis framework, LogT, for generating an SFT dataset with high-quality visual search QA pairs and reasoning traces. This dataset is used to enhance VLMs’ ability to use Zoom-in for fine-grained visual search. Our goal is to train VLMs not only to invoke Zoom-in in the correct format over one or multiple turns, but also to logically think with images and to use Zoom-in accurately and efficiently to identify regions of interest.
Figure 3 illustrates the process for generating a single-object QA and its corresponding tool-use reasoning trace. Given an image and two object-centric crops that provide contextual () and focused () views of the target object, the QA generator produces candidate QA pairs, which are then filtered using automatic quality checks. We then pass the generated QAs along with a synthesized caption of to a logic chain generator, which produces a multi-hop chain and an exhaustive search chain (). One of these chains is selected and used to guide the reasoning trace generator to construct a full trace that interleaves textual reasoning with Zoom-in actions. Each Zoom-in call extracts a region from or a previous crop, resulting in crops denoted as through .
Figure 3. A detailed overview of LogT SFT data synthesis engine. Part 1 (top; § 2.1) synthesizes visual search QA pairs using the full image () along with rich visual contexts ( and , top left) related to randomly selected target objects. After generating candidate QAs, we apply a simple heuristic filter and use a VLM-as-a-Judge to ensure quality. Part 2 (bottom; § 2.2) generates reasoning traces for the selected QA. For easy questions, we directly generate traces without tool calls (omitted here). For other questions, we first create logic chains ( and ) based on two human-like strategies. A logic chain selector then chooses the more appropriate one, which is subsequently used to guide the synthesis of multi-turn reasoning traces with tool use.
While ensuring high data quality, LogT is fully automated and accessible, relying solely on open-source models without needing complex visual agents. In the following sections, we detail the key components of (i) QA pair generation (§ 2.1) and (ii) reasoning trace synthesis (§ 2.2).
Object-oriented QA Pair Synthesis.
Our QA pair synthesis strategy consists of two steps: (i) generating challenging QA pairs using a QA generator, and (ii) performing quality control through a filter and a QA quality judge. Specifically, we use Qwen2.5-VL-72B (Bai et al., [3]) as the generator and a different open-source VLM with 106B parameters as the judge.
As preparation, we source high-resolution images from the SA1B dataset (Kirillov et al., [11]), similar to Pixel Reasoner (Su et al., [31]) and Chain-of-Focus (Zhang et al., [46]). For each image, SA1B provides bounding boxes representing unnamed objects.
Enhance QA generation with object-oriented visual contexts. We generate visual search QA pairs in an object-oriented manner, with each focusing on one or two specific objects within the input image . To avoid bias toward easily identifiable objects and increase question difficulty, we first filter out bounding boxes that cover more than 1% of the image area. From the remaining boxes, we randomly select one box for single-object questions, or a pair of boxes for relation-based questions. In addition to the full image, we prepare two more crops related to each bounding box: (i) a contextual crop that is several times larger than the bounding box to capture surrounding visual context, and (ii) a focused crop that exactly matches the bounding box to capture fine-grained object details. This results in 3 images for single-object and 5 for relation-based questions. We provide the QA generator with these images, detailed generation rules, a taxonomy of permissible question types, and in-context examples to produce two candidate QA pairs. The QA generation prompt is shown in Figure 7.

Figure 7. System prompt for the QA generator. The remaining rules and in-context examples are omitted for brevity.
QA filtering and selection. We first apply a simple rule-based filter to eliminate QAs that violate output format requirements. Then we evaluate the remaining pairs using the QA quality judge to determine whether one or both conform to our quality criteria, including answer correctness, question unambiguity, etc. If neither QA candidate passes, we discard both; if both are valid, the judge selects the better one. To mitigate positional bias of the judge (Shi et al., [30]), we run the evaluation twice with the QA order reversed. We err on the side of caution by accepting a QA pair only if it is consistently validated across both evaluations.
Compared to prior work, our method produces more challenging and higher-quality questions. We define average@8 as the accuracy obtained by randomly sampling responses eight times at a temperature of 0.8. As shown in Figure 11, only 24% of our synthesized questions are perfectly answered by Qwen2.5-VL-7B without tool use, i.e., average@8 = 1, substantially fewer than in existing datasets.

Figure 11. Ratio of easy questions. We compute the ratio of questions in existing and our SFT datasets for which Qwen2.5-VL-7B achieves an average@8 = 1 without needing tools (easy questions). Our dataset synthesized by LogT contains only 24%, significantly lower than existing datasets.
Logic Chain-driven Reasoning Trace Synthesis.
In visual QA tasks, humans typically adopt one of the following reasoning strategies. We leverage these strategies to ensure the logical coherence of generated reasoning traces and to minimize unnecessary tool usage: (i) Direct answering: When the target object is prominent and the question is straightforward, humans can answer directly without intermediate reasoning. (ii) Multi-hop reasoning: For questions requiring indirect visual cues, like “What color is the backpack worn by the person?”, humans identify intermediate visual anchors (e.g., the person), then refine their focus (e.g., the backpack), reasoning through multiple “hops”. (iii) Exhaustive search: When the target is difficult to locate and the question lacks clear visual references, such as asking to find a person in a crowd, humans may divide the scene into several parts and search systematically.
For easy questions where Qwen2.5-VL-7B achieves an average@8 of 100% even without requiring tools, we adopt the direct answering strategy to generate a more tool-efficient reasoning trace, consisting of a single turn without invoking the Zoom-in tool.
Otherwise, we simulate the remaining two strategies and synthesize reasoning traces that involve one or more tool calls. This process includes: (i) abstracting these strategies into logic chains using a logic chain generator, where each chain consists of a sequence of key steps that specify where to focus and which image to zoom into, (ii) selecting the most appropriate logic chain via a logic chain selector, and (iii) leveraging the selected logic chain as structured guidance for the reasoning trace generator to produce coherent tool-use reasoning traces. While an ideal system would rely on a single VLM to perform all three parts, current open-sourced VLMs often lack the instruction-following reliability and fine-grained reasoning precision required for high-quality logic chain generation. To address this, we use GPT-OSS-120B ([22]) as the logic chain generator, and the VLM serves as the QA quality judge for both logic chain selection and reasoning trace generation.
Logic chain generation and selection. Given an image and a QA, we first supply the logic chain generator with the question and a VLM-generated image caption as necessary visual context. It then outputs two types of logic chains: one for multi-hop reasoning () and one for exhaustive search (). Each chain comprises sequential steps that identify a target object or region (e.g., “person” or “left crowd”) and determine which image to zoom into (e.g., the full image or a crop returned from a previous Zoom-in call, such as or in Figure 3). The logic chain generator must reason over spatial and contextual dependencies. For example, in Figure 3, it needs to decide whether to zoom in gradually, such as identifying the backpack from a crop of the person, or to access multiple objects in parallel, such as finding the security gate and the person.
Once both logic chains are generated, we pass them along with the full image and question to the logic chain selector. We use it to choose a more appropriate chain based on task complexity and tool call efficiency.
Reasoning trace synthesis. Next, we prompt the reasoning trace generator to follow the selected logic chain step-by-step, producing a reasoning thought and a corresponding Zoom-in action at each turn until reaching the final answer. The prompt used for reasoning trace synthesis is shown in Figure 8. Finally, we build an SFT dataset with 7.1k high-quality QAs and reasoning traces.

Figure 8. System prompt for the reasoning trace generator. Each logic-chain entry of the form short noun phrase specifies a target object or region and its source image . Here, is the original image, and for is the crop returned by the -th ZOOM-IN call. The reasoning trace generator locates the specified target in , predicts its bounding box, and invokes ZOOM-IN on that image using the predicted box. For example, “Backpack (2)” corresponds to “Backpack ()” in Figure 3 and instructs the generator to zoom in on the backpack within the person crop returned by the second tool call. The remaining rules and in-context examples are omitted for brevity.
We present example multi-hop reasoning traces in Figure 12 and an example exhaustive search reasoning trace in Figure 9. Tool-use statistics of our synthesized SFT dataset are provided in Section A.3 and visualized in Figure 10. To qualitatively demonstrate that LogT produces higher-quality reasoning traces, we present a case study comparing our traces with those from prior work in Section A.4. Finally, we analyze the computational cost of our data engine in Section A.5.

Figure 9. An example of an exhaustive search logic chain and its corresponding tool-use reasoning trace. To locate the pink sign held by a person in the crowd, the logic chain begins by instructing the trace generator (see § 2.2) to identify the crowd, then systematically search it from left to right. Since the trace generator successfully detects the target sign and the person in the crop returned by the third Zoom-in call, it stops scanning the rest of the crowd and instead zooms in on the identified region to extract the final answer.

Figure 10. Normalized distribution of Zoom-in call counts in the SFT dataset generated by LogT. The number of tool calls per trace in the dataset ranges from 0 (direct answering without tool use) to 6.

Figure 12. Qualitative case study of SFT data synthesized by Pixel Reasoner, Chain-of-Focus, Mini-o3 and LogT.
Experiments
Experiments
Experimental Setup
Baselines. We compare our method against a broad set of baselines: (i) VLMs without Zoom-in, including GPT-4o [10], and open-source models such as Qwen2.5-VL-7B and -72B [3]. (ii) VLMs with Zoom-in, including o3 [24], and several open-source models post-trained for Zoom-in, such as Pixel Reasoner [31], DeepEyes [50], Chain-of-Focus [46], Mini-o3 [12], and Li et al. [17]. All open-source baselines here use Qwen2.5-VL-7B as the base model and rely on Zoom-in as the sole image-interaction tool. They all apply SFT for cold-start training before RL, except for DeepEyes. Notably, all adopt tool-specific RL strategies. Additional baselines are evaluated in Table 2 and discussed in Section B.3.
| Data | VisualProbe | HR-Bench | MME-RW-Lite | Avg. | ||||||
| Models with Tools | ||||||||||
| Visual Sketchpad | - | - | 80.30 | - | - | - | - | - | - | - |
| PyVision | - | - | 75.90 | - | - | - | - | - | - | - |
| Open-sourced Models w/o Tools | ||||||||||
| InternVL3.5-8B | - | - | 60.73 | 29.79 | 10.07 | 13.21 | 57.38 | 49.00 | 41.12 | 37.33 |
| LLaVA-OneVision-7B | - | - | 72.25 | 41.84 | 16.42 | 14.15 | 64.62 | 58.00 | 44.71 | 44.57 |
| Open-sourced Models with Visual Search Tools | ||||||||||
| SEAL | - | - | 75.39 | - | - | - | - | - | - | - |
| DyFo | - | - | 81.15 | - | - | - | - | - | - | - |
| LogT-SFT | 7.1k | 0 | 87.43 | 60.99 | 41.04 | 39.62 | 72.00 | 70.12 | 45.96 | 59.59 |
| LogT-RL | 7.1k | 6.4k | 92.15 | 70.92 | 52.24 | 51.89 | 76.12 | 74.62 | 53.00 | 67.28 |
Table 2. Performance comparison between our models and additional baselines. We extend the main results in Table 1 by including additional open-source models (InternVL3.5-8B, LLaVA-OneVision-7B), modular-agent frameworks (Visual Sketchpad, PyVision), and visual-search-based methods (SEAL, DyFo). The green rows refer to our models. Both LogT-SFT and LogT-RL significantly outperform these baselines across all seven test sets, further demonstrating the effectiveness of our approach.
Benchmarks. We evaluate our method and baselines on the following benchmarks: (i) Fine-grained visual search on high-resolution images: This includes V* [42], VisualProbe [12], and HR-Bench [37]. VisualProbe is officially divided into three difficulty levels: easy, medium, and hard. HR-Bench consists of two resolution-based subsets: 4K and 8K. (ii) Out-of-domain visual perception and reasoning beyond visual search: We use MME-RealWorld-Lite [47], which differs substantially from the LogT SFT dataset in both the visual content and the types of tasks involved. This makes it well-suited for assessing models’ generalization to out-of-domain visual reasoning tasks beyond visual search. MME-RealWorld-Lite is a comprehensive benchmark with 1,919 questions covering 43 task types, evaluating general perception and reasoning capabilities of VLMs across diverse scenarios such as OCR, remote sensing, diagram understanding, etc. In total, our evaluation covers seven test sets, accounting for multiple official splits in VisualProbe and HR-Bench.
Evaluation details. We use greedy decoding for all evaluated models1 and report pass@1 accuracy to ensure reproducibility. For all open-sourced models without built-in tool usage, we apply CoT prompting using the instruction “Please reason step by step.” For o3, we report the V* result from its model card and evaluate VisualProbe using medium reasoning effort with the code interpreter tool. Additional evaluation details are provided in Section B.1.
Implementation Details
SFT implementation. Following prior works, we use Qwen2.5-VL-7B as the base model. We train it on the SFT dataset synthesized by LogT for 3 epochs using a learning rate of and an effective batch size of 128. The resulting model is LogT-SFT.
RL implementation. We apply off-the-shelf RL to LogT-SFT fine-tuned on 7.1k samples, to investigate how improved cold-start affects post-RL performance. The resulting model is LogT-RL. Our reward function consists of only two terms: a correctness reward () and a formatting reward (). The correctness reward assigns if the model’s predicted answer matches the ground-truth, and 0 otherwise. The formatting reward assigns if the model follows the correct format, and 0 otherwise. The total reward is .
For the RL algorithm, we slightly modify standard Group Relative Policy Optimization (GRPO) [28] to encourage exploration. Specifically, we remove KL regularization and adopt the clipping-higher strategy recommended by Yu et al. [44] for agentic RL to set the upper clipping ratio to 0.315. We sample 8 rollouts per input, and adopt a constant learning rate of 1e-6. We use veRL [29] for implementation and run RL for 100 steps.
We source RL training data from Mini-o3 [12]. Additional details on our RL implementation are provided in Section B.2.
Main SFT Results
In this section, we report SFT results using Qwen2.5-VL-7B as the base model. We also fine-tune InternVL3.5-8B (Wang et al. [36]) on our SFT dataset and present those results in Table 3 of Section B.4.
| Data SFT | Data RL | V* | VisualProbe Easy | VisualProbe Medium | VisualProbe Hard | HR-Bench 4K | HR-Bench 8K | MME-RW-Lite | Avg. | |
| InternVL3.5-8B | - | - | 60.73 | 29.79 | 10.07 | 13.21 | 57.38 | 49.00 | 41.12 | 37.33 |
| +LogT-SFT | 7.1k | 0 | 75.92 | 56.74 | 27.24 | 28.30 | 66.12 | 63.38 | 41.64 | 51.33 |
| Δ vs. Base Model | - | - | +15.19 | +26.95 | +17.17 | +15.09 | +8.74 | +14.38 | +0.52 | +14.00 |
Table 3. Performance of fine-tuning InternVL3.5-8B with LogT SFT data. We fine-tune InternVL3.5-8B using 7.1k samples synthesized by LogT. The green rows refer to our models. The resulting model outperforms the base model across all test sets, improving overall performance by 14.00 points.
LogT-SFT outperforms all baselines, including those trained with both SFT and RL, while being highly data- and training-efficient. As shown in Table 1, the LogT-SFT model trained on 7.1k synthetic samples generated by our method, surpasses all open-source baselines, including those post-trained with both SFT and RL. Compared to the strongest SFT baseline, Chain-of-Focus-SFT, our model achieves higher performance across 6 out of 7 test sets, with an average gain of 4.59 points. Against the best-performing baseline, Mini-o3-RL, LogT-SFT delivers a 1.9-point improvement.
| Models | Data SFT | Data RL | V* | VisualProbe Easy | VisualProbe Medium | VisualProbe Hard | HR-Bench 4K | HR-Bench 8K | MME-RW-Lite | Avg. |
| GPT-4o | - | - | 66.00 | 47.50 | 15.40 | 11.20 | 59.00 | 55.50 | 46.40 | 43.00 |
| o3 | - | - | 95.70 | 69.50 | 47.01 | 32.08 | - | - | - | - |
| Open-sourced Models w/o Tools | ||||||||||
| Qwen2.5-VL-7B | - | - | 79.58 | 41.81 | 23.13 | 19.81 | 72.38 | 66.25 | 48.46 | 50.20 |
| Qwen2.5-VL-72B | - | - | 79.06 | 39.72 | 32.09 | 28.30 | 76.25 | 73.00 | 50.13 | 54.08 |
| Open-sourced SFT Models with Tools | ||||||||||
| Pixel Reasoner-SFT | 4k | 0 | 74.87 | 49.65 | 18.66 | 20.75 | 64.75 | 59.88 | 47.06 | 47.95 |
| Chain-of-Focus-SFT | 5.4k | 0 | 83.77 | 53.90 | 27.61 | 34.91 | 71.50 | 65.25 | 48.05 | 55.00 |
| Mini-o3-SFT | 7.3k | 0 | 64.40 | 32.62 | 28.73 | 14.15 | 53.75 | 51.75 | 38.56 | 40.57 |
| LogT-SFT | 4k | 0 | 85.34 | 61.70 | 34.70 | 36.79 | 71.50 | 67.25 | 43.93 | 57.32 |
| LogT-SFT | 5.4k | 0 | 85.86 | 60.99 | 38.06 | 37.74 | 72.25 | 70.62 | 48.15 | 59.10 |
| LogT-SFT | 7.1k | 0 | 87.43 | 60.99 | 41.04 | 39.62 | 72.00 | 70.12 | 45.96 | 59.59 |
| Open-sourced RL Models with Tools | ||||||||||
| Pixel Reasoner-RL | 4k | 7k | 81.68 | 58.87 | 24.25 | 26.42 | 73.00 | 67.38 | 52.42 | 54.86 |
| Chain-of-Focus-RL | 5.4k | 8.9k | 83.25 | 55.32 | 28.36 | 36.79 | 72.50 | 65.88 | 48.83 | 55.85 |
| DeepEyes-RL | 0 | 47k | 83.25 | 62.41 | 27.99 | 30.19 | 74.62 | 69.50 | 53.47 | 57.35 |
| Li et al. ([17]) | 4k | 7k | 85.86 | - | - | - | 73.40 | 66.60 | - | - |
| Mini-o3-RL | 7.3k | 9.7k | 89.53 | 51.77 | 45.15 | 36.79 | 71.25 | 66.62 | 42.73 | 57.69 |
| LogT-RL | 7.1k | 6.4k | 92.15 | 70.92 | 52.24 | 51.89 | 76.12 | 74.62 | 53.00 | 67.28 |
| Δ vs. SOTA | - | - | +2.62 | +8.51 | +7.09 | +15.10 | +1.50 | +5.12 | -0.47 | +9.59 |
| Δ vs. Base Model | - | - | +12.57 | +29.11 | +29.11 | +32.08 | +3.74 | +8.37 | +4.54 | +17.08 |
Table 1. Table 1 Performance comparison between our models and baselines. We evaluate the pass@1 accuracy of various models on seven test sets across four benchmarks, and use MME-RW-Lite to denote the out-of-domain benchmark MME-RealWorld-Lite. As checkpoints from Li et al. (Li et al., [17] are not publicly available yet, we report evaluation results directly from the original paper and leave unavailable results blank. For open-sourced SFT and RL models, the best and second-best results are marked in bold and __underlined__, respectively. The green rows refer to our models. Using only 5.4k–7.1k samples from the SFT dataset synthesized by LogT, the resulting LogT-SFT outperforms existing baselines, including those trained with both SFT and RL. After applying an off-the-shelf RL recipe without any tool-specific design (see § 4.2), LogT-RL surpasses all open-sourced baselines by at least 9.59 points.
Moreover, even when the number of training samples is reduced from 7.1k to 5.4k, LogT-SFT still outperforms all baselines. In comparison, DeepEyes-RL uses 8.7× more data, and Mini-o3-RL uses 3.1× more. Training Qwen2.5-VL-7B on 5.4k SFT samples takes only 3.2 hours on 8× A100 GPUs, making it >120× more compute-efficient than the best RL baseline, Mini-o3-RL, in terms of GPU hours. These results underscore the effectiveness of our data engine in producing high-quality SFT training data.
LogT-SFT significantly outperforms SFT baselines under equal data budgets. For fair comparison, we evaluate LogT-SFT under matched or lower data budgets. Specifically, we randomly sample 4k and 5.4k subsets from our synthetic dataset, matching the sizes used by Pixel Reasoner and Chain-of-Focus, and then fine-tune Qwen2.5-VL-7B on these subsets. Under equal data constraints, Table 1 shows that LogT-SFT outperforms Pixel Reasoner-SFT by 9.37 points and Chain-of-Focus-SFT by 4.1 points. With a slightly smaller dataset with 7.1k samples, LogT-SFT surpasses Mini-o3-SFT by a large margin of 19.02 points. These results demonstrate the superior quality of our synthetic data generated by our framework.
Main RL Results
Applying off-the-shelf RL on top of LogT-SFT improves performance and generalization, outperforming all baselines by a wide margin. In Table 1, we show that applying off-the-shelf RL to the LogT-SFT model further leads to a notable improvement of 7.69 points. Remarkably, LogT-RL surpasses all RL baselines by at least 9.59 points, even though those baselines use more sophisticated and tool-specific RL designs. Moreover, it enhances the model’s generalization ability, achieving performance comparable to the current SOTA on the out-of-domain benchmark MME-RealWorld-Lite. These results highlight that the benefits of high-quality SFT data generated by our method are further amplified when combined with RL.
High-quality SFT data from our framework significantly improves the RL performance ceiling. To evaluate the impact of our SFT data engine on the RL performance ceiling, we apply the same RL recipe from § 4.2 to Qwen2.5-VL-7B and other existing SFT baselines ([31, 46, 12]). The validation accuracy dynamics in Figure 4 show that initializing RL with LogT-SFT leads to much higher performance than applying RL directly to the base model (zero-RL). In contrast, RL training on prior SFT baselines quickly plateaus after initial gains and often performs no better, or even worse, than zero-RL after 100 steps. These results indicate that SFT data produced by LogT greatly improve the initial policy and substantially raise the RL performance ceiling.
Figure 4. Training dynamics after applying our simple RL procedure to the baselines and LogT-SFT. During RL, our model’s validation accuracy steadily improves, whereas other SFT baselines perform on par with, or worse than zero-RL. LogT greatly improves the RL performance ceiling.
Analysis on Tool Use and Reasoning Quality
Beyond numerical gains, we show that our data engine enables VLMs to think logically with images and use Zoom-in accurately and efficiently. While existing works open-source their training datasets, the SFT data curation pipelines and associated metadata remain unavailable, making apples-to-apples comparisons difficult. Hence, we focus our analysis on the behavior of the post-trained models. We further show that our model can generalize to novel tools in a zero-shot manner in Section B.6.
Analysis on tool call accuracy. We evaluate the tool accuracy of a model response by assessing how well it localizes the intended region(s) of interest via Zoom-in. We first compute the Intersection over Ground-truth (IoG) ([38]) for each Zoom-in call, defined as IoG = , where is the bounding box used in the Zoom-in call and is the corresponding ground-truth box. Next, we consider a response as calling the tool accurately if at least one Zoom-in invocation achieves IoG , as multiple calls may be issued while answering a question. Finally, we define a model’s overall tool call accuracy as the percentage of tool-requiring responses that include at least one accurate Zoom-in call. We compute this metric using V*, the only benchmark that provides ground-truth bounding boxes for target regions.
Figure 5 shows that LogT-SFT achieves 72.09% tool call accuracy, outperforming both the base model and other SFT baselines. LogT-RL further achieves the highest accuracy of 94.21%. These results show that the
Figure 5. Tool call accuracy. We report tool call accuracy on V* for the base model and all post-trained models. The base model is prompted to use Zoom-in in a zero-shot setting. Our LogT-SFT and LogT-RL models achieve the highest Zoom-in accuracy.
SFT data synthesized by LogT effectively teaches VLMs to reason and invoke tools accurately. Interestingly, most SFT- and RL-trained baselines underperform the base model that invokes Zoom-in in a zero-shot manner, except for Mini-o3. Comparing SFT models and their RL-tuned counterparts, we find that while RL improves tool call accuracy, the quality of SFT is critical for achieving strong tool call accuracy after RL.
Analysis on tool call efficiency. We evaluate tool call efficiency by measuring the average number of Zoom-in calls used to solve a question across all test sets. As shown in Figure 6, the best-performing baseline, Mini-o3-RL, uses an average of 4.3 Zoom-in calls per task. In comparison, while delivering higher performance, LogT-SFT and LogT-RL achieve significantly better efficiency, requiring 2.7× and 2.3× fewer calls, respectively. Although other baselines use fewer Zoom-in calls, their performance is considerably lower. These results suggest that the SFT data synthesized by LogT enables VLMs to reason about the necessary steps for solving questions, striking a superior balance between tool call efficiency and overall performance.
Figure 6. Tool call efficiency. We report the average number of tool calls per question across the seven test sets. Despite achieving better performance compared to prior SOTA, LogT-SFT model uses 2.7× fewer tool calls, and LogT-RL uses 2.3× fewer.
Human evaluation on reasoning quality and logical coherence. To assess whether the SFT data synthesized by LogT enables VLMs to reason logically with images beyond achieving strong benchmark performance, we conduct a human evaluation comparing LogT-RL with the prior SOTA (Mini-o3-RL) based on overall benchmark scores and tool-use accuracy. We randomly sample 100 questions from and ask three human annotators to compare the responses produced by both models. For each question, annotators select the preferred response based on three criteria: (i) Faithfulness: Does the model answer the question correctly without hallucinating non-existent visual content? (ii) Logical coherence: Does the reasoning follow a consistent and logical flow? (iii) Tool efficiency: Does the model arrive at the answer using Zoom-in efficiently? On average, LogT-RL is preferred in 59% of the cases, with a tie in 14%, indicating the effectiveness of our data generation approach. Detailed instructions and per-annotator breakdowns are provided in Section B.5. Besides human study, we also present a qualitative case study in Section B.7.
Ablation Study
Ablation on question difficulty. To investigate the impact of question difficulty on SFT training, we split the 7.1k-sample dataset into an easier half and a harder half based on Qwen2.5-VL-7B’s average@8. As shown in Table 4 (Appendix), the VLM trained on the harder split achieves better performance on (+2.09) and VisualProbe-Hard (+4.72), while showing only a slight drop on the easy and medium subsets of VisualProbe. These highlight the importance of synthesizing more challenging questions, as described in § 2.1, to help the model acquire the ability to tackle more complex tasks.
Table 4 Ablation on question difficulty. Training the VLM on the harder half of our SFT dataset leads to significantly improved performance on challenging tasks like those in VisualProbe-Hard.
| Split | Easy | Medium | Hard | |
| Easier | 85.34 | 59.57 | 35.07 | 35.85 |
| Harder | 87.43 | 58.87 | 34.70 | 40.57 |
Table 4.
Ablation on logic chain-driven reasoning trace synthesis. To examine the impact of explicitly generating logic chains for each question to guide reasoning trace synthesis, we compare our method to an alternative that uses only fixed in-context examples based on multi-hop and exhaustive search strategies. As shown in Table 5 in the Appendix, incorporating logic chains improves overall performance after SFT and yields a substantial gain of 2.87 points after RL. These results suggest that logic chain-driven synthesis is essential for creating higher-quality SFT data that effectively incentivizes logical reasoning and tool-use capabilities in VLMs.
Table 5 Ablation on logic chain-driven reasoning trace synthesis. Incorporating logical chains into the data generation process of LogT improves overall SFT performance and yields substantial additional gains after subsequent RL.
| Training Recipe | Logic Chain | Easy | Medium | Hard | 4K | 8K | MME-RW-Lite | Avg. | |
| SFT | ✗ | 87.43 | 59.57 | 38.06 | 39.62 | 72.25 | 69.50 | 44.09 | 58.65 |
| ✓ | 87.43 | 60.99 | 41.04 | 39.62 | 72.00 | 70.12 | 45.96 | 59.59 | |
| SFT+RL | ✗ | 90.05 | 66.67 | 46.27 | 46.23 | 74.75 | 75.12 | 51.80 | 64.41 |
| ✓ | 92.15 | 70.92 | 52.24 | 51.89 | 76.12 | 74.62 | 53.00 | 67.28 |
Table 5.
Ablation on models used for data synthesis. To verify that our data engine’s effectiveness stems from the framework design rather than specific large models, we replace the QA generator, the VLM used for QA judging and trace synthesis, and the logic chain generator in § 2 with much smaller variants: Qwen3-VL-8B [2], Qwen2.5-VL-32B [3], and GPT-OSS-20B [22], respectively. We then re-synthesize 4k SFT samples, train the base model with SFT, and evaluate it on , VisualProbe, and HR-Bench. As shown in Table 6 in the Appendix, performance remains nearly unchanged compared with using the original models for synthesizing 4k SFT data.
Table 6 Ablation on models used for data synthesis. We replace the models used by LogT in § 2 with much smaller variants and re-synthesize 4k SFT samples. After SFT, the average performance across , VisualProbe, and HR-Bench remains nearly unchanged, indicating that our method is robust to the choice of synthesis models.
| Model Usage | Avg. |
| Original | 59.55 |
| Qwen3-VL-8B, Qwen2.5-VL-32B & GPT-OSS-20B | 59.43 |
Table 6.
Using these smaller models, generating 7.1k SFT samples requires about 120 GPU hours (30 hours on A100), making it over compute cheaper than the RL training of Mini-o3.
Discussion
Connection to Cognitive Science
The reasoning strategies in § 2.2 have close parallels in findings from cognitive science: (i) Direct answering. Feature-integration theory Treisman and Gelade [34] proposes that humans can detect simple visual features in parallel with no attention limits, enabling an immediate impression of recognizable objects. This is analogous to a VLM directly answering a visual question without invoking tools to inspect finer details. (ii) Multi-hop. Research on natural vision Rao et al. [26] suggests that visual information is acquired actively, in a task-dependent and coarse-to-fine manner: observers first attend to a promising contextual region and then inspect task-relevant details. This process closely parallels the multi-hop reasoning strategy used in our work. (iii) Exhaustive search. Guided-search models Wolfe and Horowitz [40] propose that visual search is efficient when target features, scene context, or prior knowledge prioritize a small subset of locations. When these signals are weak, attention must cover more candidates, resulting in a more systematic search. This corresponds to the exhaustive-search strategy used in our work.
Relationship to Knowledge Distillation
The model ablation (Table 6) suggests that LogT does not rely on the original large synthesizing models. Moreover, on , the 7B model trained on 4k reasoning traces synthesized using Qwen2.5-VL-32B outperforms Qwen2.5-VL-32B itself by 4.18 points. Together, these results suggest that synthesizing-model strength alone does not explain the effectiveness of our data engine, although knowledge distillation [4, 6] may still contribute to the gains.
Limitations
The centrality of Zoom-in. In this work, we focus primarily on Zoom-in for two primary reasons. (i) Practical importance. The zoom-in tool is widely used in visual reasoning tasks. For example, OpenAI’s o3 model prominently features this tool in its blog [23]. Moreover, all thinking-with-image baselines in Table 1 rely on zoom-in as their sole image interaction mechanism. (ii) Technical challenge. Despite its prevalence, enabling VLMs to accurately and efficiently decide when and how to invoke the zoom-in tool remains challenging (see analysis in § 4.5). OpenAI’s blog [23] similarly identifies “redundant or unnecessary tool calls and image manipulation steps” as a key limitation of o3.
While centered on Zoom-in, our approach demonstrates significant transferability. LogT improves performance on out-of-domain tasks (e.g., MME-RW-Lite in Table 1) and generalizes to unseen tools (Table 8 in Section B.6).
Table 8 Performance on -Rotated. We construct -Rotated by rotating images in by angles randomly sampled from to . LogT-RL uses a rotation tool at inference time that was not seen during training, improving over the base model by 21.99 points.
| Model | -Rotated |
| Qwen2.5-VL-7B | 46.07 |
| LogT-RL (with Rotation Tool) | 68.06 |
| vs. Base Model | +21.99 |
Table 8.
More broadly, LogT decouples logic chain synthesis from reasoning trace generation, making it a general and extensible framework. This design allows it to be applied to a wide range of structured reasoning tasks, and extending LogT to broader domains is a promising direction for future work.
Reliance on VLM-as-a-Judge. To ensure scalability and avoid costly human annotation, we build a fully automated data engine that uses VLM-as-a-Judge. Consequently, the synthesized SFT data may contain a small amount of noise, as VLM judges can make mistakes. We view this trade-off as acceptable for two primary reasons. (i) Annotation noise is unavoidable. Errors are not unique to automated judging; they are often inevitable even in expensive human annotations [35, 25]. (ii) Empirical results and manual verification suggest limited noise. Our method achieves the strongest empirical performance (Table 1) and the highest tool-call accuracy (Figure 5), suggesting that any remaining noise is limited and much lower than in prior work. We further randomly sample 100 examples and manually evaluate errors at each stage of the data engine. As shown in Table 7, the error rate at each stage is low despite the fully automated pipeline.
Table 7 Error rates across different stages. We randomly sampled 100 samples from each stage and manually evaluated their error rates.
| Stage | Error Rate (%) |
| QA Generation & Filtering | 12 |
| Logic Chain Generation | 2 |
| Reasoning Trace Generation | 7 |
Table 7.
Conclusion
We propose LogT, a novel data engine for synthesizing high-quality SFT data that empowers VLMs to logically think with images and use Zoom-in both effectively and efficiently. The core is to generate challenging QAs and high-quality tool-use reasoning traces, guided by logic chains that emulate human-like visual reasoning strategies. VLMs fine-tuned on our synthetic data outperform existing baselines trained with both SFT and RL. Moreover, applying off-the-shelf RL on top of LogT-SFT, without any tool-specific design, further substantially improves performance.
Acknowledgment
We would like to thank Hugo Laurençon, Jianwei Yang, Kaiwen Zha, and Xingyi Zhou for their helpful discussions during this project.
Additional Details on Our Data Engine: LogT
System Prompts for QA Generator and Reasoning Trace Generator
We detailed the QA synthesis in § 2.1 and the reasoning trace synthesis in § 2.2. Here, we show part of the system prompt for the QA generator in Figure 7 and part of the system prompt for the reasoning trace generator in Figure 8.
An Example of Exhaustive Search Reasoning Trace
We provide an additional example of an exhaustive-search logic chain and its corresponding tool-use reasoning trace in Figure 9. In this example, the target object for the given question, i.e., the pink sign held by the person, is particularly difficult to locate. Therefore, the logic chain selector (see § 2.2) chooses the exhaustive search logic chain. This logic chain instructs the reasoning trace generator to first zoom in on the crowd and then systematically search the scene from left to right. Although the logic chain specifies examining all four regions of the crowd (left, center-left, center-right, and right) because the logic chain generator does not know exactly where the target object is located, the reasoning trace generator successfully identifies the target object after zooming into the second region (center-left crowd). Consequently, it terminates the search early. This is because our prompt requires the reasoning trace generator to stop searching once the target object is found. After identifying the target, it calls Zoom-in on the object and then proceeds to generate the final answer.
Tool Use Statistics in the LogT SFT Dataset
We present the normalized distribution of Zoom-in call counts in Figure 10. The number of tool calls ranges from 0 to 6. Specifically, 94% of the questions in the LogT SFT dataset are solved using 3 or fewer Zoom-in calls.
Qualitative Case Study of Synthesized Tool-use Traces
We present a qualitative comparison of reasoning trace synthesis strategies used by Pixel Reasoner [31], Chain-of-Focus [46], Mini-o3 [12], and LogT, as shown in Figure 12.
Pixel Reasoner synthesizes multi-turn reasoning traces by deliberately inserting Zoom-in calls that focus on overly broad or incorrect regions. In Figure 12a, the first two Zoom-in calls target completely irrelevant areas. In contrast, LogT generates a logic chain that guides the reasoning trace generator to first invoke Zoom-in on the building, then refine the focus onto the target text.
In Figure 12b, the Chain-of-Focus SFT trace redundantly zooms in on the shoes for six consecutive steps, despite correctly identifying their location in the first step. In contrast, LogT first generates a logic chain that instructs the reasoning trace generator to initially zoom in on the person, then gradually focus on the shoes, and finally answer the question using only two Zoom-in calls.
A similar issue occurs with the Mini-o3 SFT trace in Figure 12c: although it initially identifies the correct target, it repeatedly invokes Zoom-in and ultimately selects an unrelated region, resulting in a total of four Zoom-in calls. By comparison, LogT guides the reasoning trace generator to directly locate the wheels, with the reasoning trace requiring only a single Zoom-in call before answering.
Computational Cost Analysis
Synthesizing 7.1k samples with LogT requires approximately 960 GPU hours (5 days on 8 A100 GPUs), making it more than compute cheaper than RL training for the Mini-o3 baseline.
As shown in § 4.6, synthesis resource use can be substantially reduced by using smaller model variants without compromising performance. With smaller models, the total resource use drops to approximately 120 GPU hours, making it more than compute cheaper than RL training for Mini-o3.
I₀
PIXEL REASONER
Turn #1 I₁: Irrelevant Region
[Reasoning] … Now I will zoom in to look clearer at the text on the building. [Zoom-in on I₀] bbox=[1575, 150, 2250, 900]
Turn #2 I₂: Irrelevant Region
[Reasoning] The cropped part doesn’t contain the target object, I will zoom in again. [Zoom-in on I₀] bbox=[1575, 525, 2250, 1275]
Turn #3 I₃: Building
[Reasoning] The cropped part doesn’t contain the target object, I will zoom in again. [Zoom-in on I₀] bbox=[675, 150, 1575, 600]
LOGT (OURS)
Turn #1 I₁: Building
[Reasoning] … I need to first locate the building in the image … [Zoom-in on I₀] bbox=[0, 0, 1506, 1175]
Turn #2 I₂: Text
[Reasoning] … I need to zoom in on this text to read it more clearly … [Zoom-in on I₁] bbox=[630, 421, 897, 519]
⭐ Logic Chain⭐
What does the text on the building say?
#1 #2
Step #1: Building (I₀) Step #2: Text (I₁)
Q: What does the text on the building say? A: MDCCCLXXIV
(a) Pixel Reasoner vs. LogT. The example trace in Pixel Reasoner SFT data randomly introduces errors when synthesizing multi-turn tool calls, and the erroneous bounding boxes are highlighted in red. In contrast, ours follows a coherent logic chain: first locating the building, and then locating the text.
I₀
CHAIN-OF-FOCUS
Turn #1 I₁: Shoes
[Reasoning] … I then narrow this box to focus specifically on the shoe area … [Zoom-in on I₀] bbox=[99, 261, 161, 313]
Turn #2 I₂: Still Shoes
[Reasoning] But the color remains unclear … adjust it to focus on the top left … [Zoom-in on I₀] bbox=[98, 260, 128, 285]
Turn #6 (Turn #3-#5 are repetitive) I₆: Person
[Reasoning] But the color details remain incomplete … enlarge the bounding box … [Zoom-in on I₀] bbox=[82, 103, 184, 319]
LOGT (OURS)
Turn #1 I₁: Person
[Reasoning] … I first locate the person kneeling in front, approximately … [Zoom-in on I₀] bbox=[71, 89, 191, 306]
Turn #2 I₂: Shoes
[Reasoning] I now focus on the shoes of the person kneeling in front, which are visible … [Zoom-in on I₁] bbox=[12, 187, 27, 212]
⭐ Logic Chain⭐
What color are the shoes worn by the person kneeling in front?
#1 #2
Step #1: Person (I₀) Step #2: Shoes (I₁)
Q: What color are the shoes worn by the person kneeling in front? A: Purple
(b) Chain-of-Focus vs. LogT. The example trace in Chain-of-Focus SFT data repeatedly zooms in on the shoes over six turns, despite correctly identifying the target region in the first turn. This redundant reasoning, highlighted in red, reflects tool call inefficiency. In contrast, LogT demonstrates a coherent reasoning chain: first locating the person, then progressively narrowing down to the shoes.
I₀
MINI-O3
Turn #1 I₁: Wheels
[Reasoning] … I will focus on the main landing gear, which is located towards … [Zoom-in on I₀] bbox=[275, 251, 375, 324]
Turn #2 I₂: Still Wheels
[Reasoning] … The image seems to be inverted, which is strange … [Zoom-in on I₀] bbox=[250, 241, 400, 324]
Turn #4 (Turn #3 is repetitive) I₄: Irrelevant Region
[Reasoning] … Perhaps a wider crop that includes both the main and nose gear … [Zoom-in on I₀] bbox=[325, 270, 360, 306]
LOGT (OURS)
Turn #1 I₁: Wheels
[Reasoning] I need to locate the wheels in the image to determine their shape and color … [Zoom-in on I₀] bbox=[283, 269, 309, 297]
⭐ Logic Chain⭐
Are the wheels round and black?
#1
Step #1: Wheels (I₀)
(c) Mini-o3 vs. LogT. The example trace in Mini-o3 SFT data correctly finds the wheels in the first turn but mistakenly claims that the crop returned by Zoom-in is inverted, leading to two redundant Zoom-in calls. Ultimately, it zooms in on an entirely irrelevant region. The redundant reasoning and the incorrect Zoom-in call are highlighted in red. In contrast, LogT makes a single Zoom-in call to locate the wheels and then directly reaches the correct answer.
Additional Experiment Setups and Results
Additional Evaluation Details
During evaluation, we adopt a maximum image resolution budget of pixels for models in the Qwen2.5-VL-7B family, where each patch represents a visual token. Images exceeding this budget are downsampled. For comparison, Mini-o3 uses a smaller default budget of approximately pixels. We observe that Mini-o3 consistently performs better under our higher budget. Therefore, we adopt our budget for all Qwen2.5-VL-7B-based evaluations.
Additional RL Implementation Details
We provide additional details on our RL implementation that are not covered in § 4.2. During RL, to reduce GPU idle time and improve training efficiency, we cap the number of Zoom-in calls at 6. Our RL training data comes from Mini-o3, and we filter out trivial cases by removing any question where Qwen2.5-VL-7B achieves an average@8 of 100%. To monitor training dynamics during RL, we use a validation set composed of samples from , VisualProbe, and HR-Bench.
Performance Comparison Between LogT and Additional Baselines
To further demonstrate the effectiveness of LogT, we evaluate our approach against a broader set of baselines. Specifically, we include two more open-source models of comparable scale (7B–8B): InternVL3.5-8B (Wang et al., [36]) and LLaVA-OneVision-7B (Li et al., 2024). We also consider modular-agent frameworks that enable proprietary models to use external tools, such as Visual Sketchpad (Hu et al., [7]) and PyVision (Zhao et al., [49]). In addition, we evaluate two visual-search-based methods that rely on external visual experts: SEAL (Wu and Xie, [42]) and DyFo (Li et al., [15]). The performance of these baselines, along with LogT-SFT and LogT-RL, is shown in Table 2. Results indicate that both LogT-SFT and LogT-RL significantly outperform the additional baselines, consistent with the findings in Table 1.
SFT Results on an Additional Base Model: InternVL3.5-8B
To evaluate whether our data engine generalizes to other base models, we fine-tune InternVL3.5-8B using 7.1k SFT samples generated by LogT. As shown in Table 3, the fine-tuned model substantially outperforms the base model, achieving a 14-point overall improvement.
Zero-Shot Generalization to Unseen Tools
Additional Human Evaluation Details
We present the instructions given to human annotators in Figure 13. For each question, the evaluation interface randomly assigns Mini-o3-RL and LogT-RL to either Model A or Model B. In addition to the overall human evaluation results reported in § 4.5, the per-annotator breakdown in Figure 14 shows that all annotators prefer responses generated by LogT-RL over those from the prior SOTA, Mini-o3-RL. This underscores that our data generation framework enables VLMs to reason more effectively using the Zoom-in tool.

Figure 13. Instructions for Human Evaluation.
Figure 14. Per-annotator breakdown of human evaluation. All three annotators preferred responses generated by LogT-RL over those from Mini-o3-RL.
Zero-Shot Generalization to Unseen Tools
To evaluate whether our method can generalize to tools unseen during training, we construct a new benchmark, -Rotated, by rotating images in by angles uniformly sampled from to . We evaluate the base model and LogT-RL on this benchmark. At inference time, LogT-RL is given access to a rotation tool that was not seen during training. As shown in Table 8, LogT-RL learns to use this tool in a zero-shot setting despite receiving no rotation-related supervision, outperforming the base model by 21.99 points. These results suggest that LogT can generalize to novel tasks and previously unseen tools.
Qualitative Case Study of Model Responses Generated By Baselines and LogT-RL
To illustrate how SFT data synthesized by LogT helps VLMs reason logically and use Zoom-in accurately, we present a qualitative case study comparing model responses to a question from the benchmark. These comparisons are shown in Figure 15. We refer to Qwen2.5-VL-7B-RL as the model obtained by directly applying our RL training procedure from § 4.2 to the base model Qwen2.5-VL-7B. For all other baselines, we use the officially released checkpoints.
Figure 15. Qualitative case study comparing model responses to a question between baseline models and LogT-RL. We show the generated reasoning traces, including Zoom-in calls, for both baseline models and LogT-RL. While Qwen2.5-VL-7B-RL, Pixel Reasoner-RL, and Chain-of-Focus-RL produce the correct final answer, their responses contain hallucinations or self-contradictions. The remaining baselines make erroneous Zoom-in calls and ultimately produce incorrect answers. In contrast, LogT-RL follows a coherent and consistent reasoning chain: it first identifies the front cabin of the truck, then locates the tissue box, and finally answers the question correctly without hallucinations.
Qwen2.5-VL-7B-RL answers the question correctly but hallucinates non-existent white text on the tissue box.
Pixel Reasoner-RL also produces the correct answer; however, its Zoom-in call targets an irrelevant region, and its final answer contradicts its own statement that “There is no tissue box.”
DeepEyes-RL focuses on white sheets of paper and incorrectly concludes that the tissue box is white.
Chain-of-Focus-RL zooms in on an irrelevant region and hallucinates, though it ultimately answers correctly.
Mini-o3-RL selects regions that include the tissue box, but still arrives at an incorrect answer.
LogT-RL first identifies the likely location of the tissue box (the truck’s front cabin), then zooms in on the tissue box itself, ultimately producing the correct answer without any hallucinations.
Among all the models, LogT-RL is the only one that reaches the correct answer and shows no hallucinations. This example further demonstrates that our data engine produces high-quality SFT data that effectively trains VLMs to reason about images in a logical and faithful manner.
References
- [1]Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katherine Millican, Malcolm Reynolds, et al. Flamingo: a visual language model for few-shot learning. In Advances in Neural Information Processing Systems, pages 23716–23736, 2022.arxiv.org/abs/2204.14198
- [2]Shuai Bai, Yuxuan Cai, Ruize Chen, Keqin Chen, Xionghui Chen, Zesen Cheng, Lianghao Deng, Wei Ding, Chang Gao, Chunjiang Ge, Wenbin Ge, et al. Qwen3-vl technical report. arXiv preprint arXiv:2511.21631, 2025a.arxiv.org/abs/2511.21631
- [3]Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, et al. Qwen2.5-vl technical report. arXiv preprint arXiv:2502.13923, 2025b.arxiv.org/abs/2502.13923
- [4]Yanjun Fu, Faisal Hamman, and Sanghamitra Dutta. T-SHIRT: Token-selective hierarchical data selection for instruction tuning. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025.arxiv.org/abs/2506.01317
- [5]Jiawei Guo, Tianyu Zheng, Yizhi Li, Yuelin Bai, Bo Li, Yubo Wang, King Zhu, Graham Neubig, Wenhu Chen, and Xiang Yue. MAmmoTH-VL: Eliciting multimodal reasoning with instruction tuning at scale. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13869–13920, 2025.arxiv.org/abs/2412.05237
- [6]Faisal Hamman, Pasan Dissanayake, Yanjun Fu, and Sanghamitra Dutta. Few-shot knowledge distillation of LLMs with counterfactual explanations. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025.
- [7]Yushi Hu, Weijia Shi, Xingyu Fu, Dan Roth, Mari Ostendorf, Luke Zettlemoyer, Noah A Smith, and Ranjay Krishna. Visual sketchpad: Sketching as a visual chain of thought for multimodal language models. In Advances in Neural Information Processing Systems, pages 139348–139379, 2024.arxiv.org/abs/2406.09403
- [10]Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276, 2024.arxiv.org/abs/2410.21276
- [11]Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C Berg, Wan-Yen Lo, et al. Segment anything. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4015–4026, 2023.arxiv.org/abs/2304.02643
- [12]Xin Lai, Junyi Li, Wei Li, Tao Liu, Tianjian Li, and Hengshuang Zhao. Mini-o3: Scaling up reasoning patterns and interaction turns for visual search. arXiv preprint arXiv:2509.07969, 2025.arxiv.org/abs/2509.07969
- [13]Ang Li, Charles Wang, Deqing Fu, Kaiyu Yue, Ziku Cai, Wang Bill Zhu, Ollie Liu, Peng Guo, Willie Neiswanger, Furong Huang, Tom Goldstein, and Micah Goldblum. Zebra-cot: A dataset for interleaved vision language reasoning. arXiv preprint arXiv:2507.16746, 2025a.arxiv.org/abs/2507.16746
- [15]Geng Li, Jinglin Xu, Yunzhen Zhao, and Yuxin Peng. Dyfo: A training-free dynamic focus visual search for enhancing lmms in fine-grained visual understanding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 9098–9108, 2025b.arxiv.org/abs/2504.14920
- [16]Renhao Li, Jianhong Tu, Yang Su, Yantao Liu, Fei Huang, Hamid Alimnaejad-Rokny, Derek F. Wong, Junyang Lin, and Min Yang. Toolrm: Towards agentic tool-use reward modeling. arXiv preprint arXiv:2510.26167, 2026.arxiv.org/abs/2510.26167
- [17]Xuchen Li, Xuzhao Li, Jiahui Gao, Renjie Pi, Shiyu Hu, and Wentao Zhang. Look less, reason more: Rollout-guided adaptive pixel-space reasoning. arXiv preprint arXiv:2510.01681, 2025c.arxiv.org/abs/2510.01681
- [18]Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. Visual instruction tuning. In Advances in Neural Information Processing Systems, pages 34892–34916, 2023.
- [19]Zujing Liu, Junwen Pan, Qi She, Yuan Gao, and Guisong Xia. On the faithfulness of visual thinking: Measurement and enhancement. arXiv preprint arXiv:2510.23482, 2025.arxiv.org/abs/2510.23482
- [20]Pan Lu, Swaroop Mishra, Tony Xia, Liang Qiu, Kai-Wei Chang, Song-Chun Zhu, Oyvind Tafjord, Peter Clark, and Ashwin Kalyan. Learn to explain: Multimodal reasoning via thought chains for science question answering. In Advances in Neural Information Processing Systems, pages 2507–2521, 2022.arxiv.org/abs/2209.09513
- [21]Yao Mu, Qinglong Zhang, Mengkang Hu, Wenhai Wang, Mingyu Ding, Jun Jin, Bin Wang, Jifeng Dai, Yu Qiao, and Ping Luo. Embodiedgpt: vision-language pre-training via embodied chain of thought. In Advances in Neural Information Processing Systems, pages 25081–25094, 2023.arxiv.org/abs/2305.15021
- [22]OpenAI. gpt-oss-120b & gpt-oss-20b model card. arXiv preprint arXiv:2508.10925, 2025a.
- [23]OpenAI. Thinking with images, 2025b. https://openai.com/index/thinking-with-images/.
- [24]OpenAI. Openai o3, 2025c. https://openai.com/index/introducing-o3-and-o4-mini/.
- [25]OpenAI. Why swe-bench verified no longer measures frontier coding capabilities, 2026. https://openai.com/index/why-we-no-longer-evaluate-swe-bench-verified/.
- [26]Rajesh P.N. Rao, Gregory J. Zelinsky, Mary M. Hayhoe, and Dana H. Ballard. Eye movements in iconic visual search. Vision Research, 42(11):1447–1463, 2002.pubmed.ncbi.nlm.nih.gov/12044751
- [27]Hao Shao, Shengju Qian, Han Xiao, Guanglu Song, Zhuofan Zong, Letian Wang, Yu Liu, and Hongsheng Li. Visual cot: Advancing multi-modal language models with a comprehensive dataset and benchmark for chain-of-thought reasoning. In Advances in Neural Information Processing Systems Datasets and Benchmarks Track, pages 8612–8642, 2024a.arxiv.org/abs/2403.16999
- [28]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. Deepskmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024b.arxiv.org/abs/2402.03300
- [29]Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. arXiv preprint arXiv: 2409.19256, 2024.DOI
- [30]Lin Shi, Chiyu Ma, Wenhua Liang, Xingjian Diao, Weicheng Ma, and Soroush Vosoughi. Judging the judges: A systematic study of position bias in llm-as-a-judge. arXiv preprint arXiv:2406.07791, 2024.arxiv.org/abs/2406.07791
- [31]Alex Su, Haozhe Wang, Weiming Ren, Fangzhen Lin, and Wenhu Chen. Pixel reasoner: Incentivizing pixel space reasoning via curiosity-driven reinforcement learning. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025a.DOI
- [32]Zhaochen Su, Linjie Li, Mingyang Song, Yunzhuo Hao, Zhengyuan Yang, Jun Zhang, Guanjie Chen, Jiawei Gu, Juntao Li, Xiaoye Qu, et al. Openthinking: Learning to think with images via visual tool reinforcement learning. arXiv preprint arXiv:2505.08617, 2025b.arxiv.org/abs/2505.08617
- [33]Linzhuang Sun, Hao Liang, Jingxuan Wei, Bihui Yu, Tianpeng Li, Fan Yang, Zenan Zhou, and Wentao Zhang. MM-verify: Enhancing multimodal reasoning with chain-of-thought verification. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 14100–14115, 2025.
- [34]Anne M. Treisman and Garry Gelade. A feature-integration theory of attention. Cognitive Psychology, 12(1):97–136, 1980.
- [35]Joshua Vendrow, Edward Vendrow, Sara Beery, and Aleksander Madry. Do large language model benchmarks test reliability? arXiv preprint arXiv:2502.03461, 2025.arxiv.org/abs/2502.03461
- [36]Weiyun Wang, Zhangwei Gao, Lixin Gu, Hengjun Pu, Long Cui, Xingguang Wei, Zhaoyang Liu, Linglin Jing, Shenglong Ye, Jie Shao, et al. Internvl3.5: Advancing open-source multimodal models in versatility, reasoning, and efficiency. arXiv preprint arXiv:2508.18265, 2025a.arxiv.org/abs/2508.18265
- [37]Wenbin Wang, Liang Ding, Minyan Zeng, Xiabin Zhou, Li Shen, Yong Luo, Wei Yu, and Dacheng Tao. Divide, conquer and combine: A training-free framework for high-resolution image perception in multimodal large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, pages 7907–7915, 2025b.arxiv.org/abs/2408.15556
- [38]Xinlong Wang, Tete Xiao, Yuning Jiang, Shuai Shao, Jian Sun, and Chunhua Shen. Repulsion loss: Detecting pedestrians in a crowd. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 7774–7783, 2018.arxiv.org/abs/1711.07752
- [39]Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed Chi, Quoc V Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems, pages 24824–24837, 2022.arxiv.org/abs/2201.11903
- [40]Jeremy M Wolfe and Todd S Horowitz. Five factors that guide attention in visual search. Nature Human Behaviour, 1 (3):0058, 2017.DOI
- [42]Penghao Wu and Saining Xie. V*: Guided visual search as a core mechanism in multimodal llms. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 13084–13094, 2024.arxiv.org/abs/2312.14135
- [43]Guowei Xu, Peng Jin, Ziang Wu, Hao Li, Yibing Song, Lichao Sun, and Li Yuan. Llava-cot: Let vision language models reason step-by-step. arXiv preprint arXiv:2411.10440, 2025.arxiv.org/abs/2411.10440
- [44]Zhaochen Yu, Ling Yang, Jiaru Zou, Shuicheng Yan, and Mengdi Wang. Demystifying reinforcement learning in agentic reasoning. arXiv preprint arXiv:2510.11701, 2025.arxiv.org/abs/2510.11701
- [45]Ruohong Zhang, Bowen Zhang, Yanghao Li, Haotian Zhang, Zhiqing Sun, Zhe Gan, Yinfei Yang, Ruoming Pang, and Yiming Yang. Improve vision language model chain-of-thought reasoning. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1631–1662, 2025a.
- [46]Xintong Zhang, Zhi Gao, Bofei Zhang, Pengxiang Li, Xiaowen Zhang, Yang Liu, Tao Yuan, Yuwei Wu, Yunde Jia, Song-Chun Zhu, and Qing Li. Adaptive chain-of-focus reasoning via dynamic visual search and zooming for efficient vlms. arXiv preprint arXiv:2505.15436, 2025b.arxiv.org/abs/2505.15436
- [47]Yi-Fan Zhang, Huanyu Zhang, Haochen Tian, Chaoyou Fu, Shuangqing Zhang, Junfei Wu, Feng Li, Kun Wang, Qingsong Wen, Zhang Zhang, et al. Mme-realworld: Could your multimodal llm challenge high-resolution real-world scenarios that are difficult for humans? arXiv preprint arXiv:2408.13257, 2024.arxiv.org/abs/2408.13257
- [48]Yi-Fan Zhang, Xingyu Lu, Shukang Yin, Chaoyou Fu, Wei Chen, Xiao Hu, Bin Wen, Kaiyu Jiang, Changyi Liu, Tianke Zhang, et al. Thyme: Think beyond images. arXiv preprint arXiv:2508.11630, 2025c.arxiv.org/abs/2508.11630
- [49]Shitian Zhao, Haoquan Zhang, Shaoheng Lin, Ming Li, Qilong Wu, Kaipeng Zhang, and Chen Wei. Pyvision: Agentic vision with dynamic tooling. arXiv preprint arXiv:2507.07998, 2025.arxiv.org/abs/2507.07998
- [50]Ziwei Zheng, Michael Yang, Jack Hong, Chenxiao Zhao, Guohai Xu, Le Yang, Chao Shen, and Xing Yu. Deepeyes: Incentivizing “thinking with images” via reinforcement learning. arXiv preprint arXiv:2505.14362, 2025.arxiv.org/abs/2505.14362





