AdaTurn: Budget-Aware Test-Time Scaling for
Active Visual Perception Agents
July 16, 2026
Abstract
Active visual agents solve fine-grained image tasks by interleaving reasoning with image-grounding actions across multiple turns. However, deployment-time rollout budgets are rarely fixed: some requests permit long rollouts, while others require the agent to act under a tight turn limit. Existing methods train the policy as if the rollout budget were hidden, so when the available budget is smaller than the trajectory the agent prefers, the interaction is often truncated before any valid answer is produced; we term this failure catastrophic truncation. To overcome this challenge, we present AdaTurn, a budget-aware framework that conditions the agent on the allowed number of turns and explicitly trains the boundary behavior induced by the budget. Our key component, Forced-Answer DAPO (FA-DAPO), converts the over-budget event from a masked or penalized failure into a trainable final-decision step, teaching the model to synthesize partial evidence when further tool use is no longer possible. We further randomize rollout budgets during both training and inference and introduce a load-balanced scheduler that makes such operations practical. AdaTurn substantially improves low-budget accuracy, for example raising VisualProbe-Medium from 36.7% to 47.6% at four turns, while preserving strong scaling at larger budgets and transferring effectively to multiple backbones and general multimodal benchmarks.
1 Introduction↩︎
Multimodal language models are increasingly used not only as one-shot image predictors [1]–[4], but also as active visual agents that interleave reasoning with image-grounding actions across multiple turns [5]–[11]. Instead of answering from a single encoded image, the model can inspect local regions, gather new observations, and refine its decision over multiple interaction turns.
This shift has made test-time scaling newly relevant for visual reasoning [12]–[15]. Recent systems such as DeepEyes [9], Pixel Reasoner [10], Chain-of-Focus [7], and Mini-o3 [11] show that “thinking with images” can outperform standard one-pass prediction on high-resolution and visually cluttered tasks. When the agent is allowed more turns, it can search more carefully, reject distractors, and verify a tentative answer before committing.
Yet this success hides an important deployment mismatch. In practical settings, the rollout budget is an external resource constraint rather than a fixed property of the model [16], [17]. One request may permit only four turns because of latency requirements, while another may permit thirty-two. Existing visual agents are typically trained for a fixed rollout regime rather than with the deployment-time budget as an explicit input [9]–[11]. As a result, when the available budget is smaller than the policy prefers, the agent may continue requesting tools until the system terminates the rollout without any valid answer. We call this failure mode catastrophic truncation. For example, Mini-o3’s performance on VisualProbe-Hard benchmark reduces from 48.0% to 26.5% after we limit the maximum rollout turns to 4. The same budget-blindness also wastes computation at the opposite extreme: when extra turns are available, the agent may stop as soon as it finds a plausible answer instead of using the remaining budget for verification.
AdaTurn addresses this mismatch by making the rollout budget part of the learning problem. The central idea is simple: a capable visual agent should not learn a single rollout style, but a family of behaviors calibrated to the available budget. This perspective yields three design requirements. First, the policy must be conditioned on the maximum allowed turns, so that short-budget and long-budget behavior can differ systematically. Second, the model must receive learning signal at the budget boundary, because this is precisely where standard training breaks down. Third, if rollout budgets vary during training and inference, the underlying infrastructure must also become budget-aware; otherwise the slowest worker dominates training throughput.
We satisfy these requirements with AdaTurn, an active visual perception agent with dynamic rollout depth. Besides the budget-conditioned visual agent, we also introduce Forced-Answer DAPO (FA-DAPO), a reinforcement learning strategy built on DAPO [18], a more robust variant of GRPO [19], that converts an over-budget tool request into a trainable final-answer decision. Instead of penalizing or masking the boundary case, AdaTurn teaches the policy how to synthesize the evidence collected so far when no further tool use is possible. We further train with dynamic rollout budgets and pair this with a load-balanced scheduler that keeps worker utilization stable despite heterogeneous rollout lengths.
The resulting system is effective across different rollout budgets and benchmarks. At four turns, AdaTurn improves VisualProbe-Medium [11] from 36.7% to 47.6% and MME-RealWorld [20] from 50.1% to 64.0% over Mini-o3 [11]. Figure 6 shows that these gains are concentrated where deployment constraints matter most, namely the low-budget regime, while the model remains strong as the budget increases. We also find that the approach transfers to Qwen3-VL 4B and 8B backbones [21] and preserves broad multimodal ability on OCR and reasoning benchmarks.
In summary, our contributions are:
We formulate budget-aware active visual perception and identify catastrophic truncation as a central failure mode of deployment-constrained visual agents.
We propose AdaTurn, a budget-conditioned visual agent, and Forced-Answer DAPO (FA-DAPO), which explicitly trains the final-answer decision at the budget boundary.
We introduce a load-balanced scheduler that reduces rollout imbalance during both training and inference and improves rollout throughput by \(1.34\times\).
We demonstrate that AdaTurn delivers large gains in the low-budget regime, remains strong at larger budgets, transfers to multiple backbones, and preserves general multimodal capability.
2 Related Work↩︎
2.1 High-Resolution Image Understanding↩︎
Early vision-language models such as LLaVA [1] relied on fixed low-resolution inputs, which discard the small details that often determine success on fine-grained visual tasks. More recent high-resolution models, including LLaVA-UHD [2], Qwen2.5-VL [3], and InternVL 2.5 [4], improve image encoding through dynamic tiling, image slicing, or stronger visual backbones. However, these approaches still perform inference largely in one pass, so they cannot adaptively allocate attention to the regions that become relevant during reasoning. This limitation has motivated active perception methods such as SEAL [5], DC\(^{2}\) [6], Chain-of-Focus [7], and ZoomEye [8], which explicitly inspect the image over multiple steps. AdaTurn operates in this active-perception regime, but focuses on a different question: how such agents should behave when the available rollout budget itself varies across requests.
2.2 Agentic Visual Perception↩︎
Recent work has shown that multi-turn visual search can be learned directly within a language-model-style action loop. DeepEyes [9] demonstrates that image-grounded tool use can emerge from reinforcement learning alone, while DeepEyesV2 [22], VISTA-R1 [23], and Agent0-VL [24] extend the tool space or the training environment. Mini-o3 [11] is particularly relevant because it shows that visual agents can benefit substantially from longer rollouts and richer interaction patterns. Our work differs in focus — we do not primarily ask how to obtain longer trajectories; we ask how the same agent should behave when the permitted trajectory length changes at deployment time. AdaTurn treats the rollout budget as an explicit conditioning variable and optimizes the final-turn decision directly, which addresses a failure mode that prior visual agents largely leave unresolved.
2.3 Reinforcement Learning and Test-Time Scaling for VLMs↩︎
Group Relative Policy Optimization (GRPO) [19] has become a standard recipe for training reasoning models, beginning with DeepSeek-R1 [25] and extending rapidly to multimodal settings such as VLM-R1 [26], R1-VL [27], and Visionary-R1 [28]. Beyond one-shot reasoning, recent sequence-level reinforcement learning formulations have also begun to study multi-turn tool-integrated reasoning more directly [29], [30]. In parallel, test-time scaling has emerged as a dominant view of reasoning systems: additional inference-time computation often improves performance, but only when the model knows how to use that extra budget effectively [12]–[15]. Prior budget-aware methods have mainly focused on token-level control within a single generation, for example via budget tokens or confidence-based early stopping [16], [17]. AdaTurn addresses a different setting, namely multi-turn agents whose action space changes at the final turn because tool execution is no longer available. Our contribution is therefore not only budget conditioning, but boundary-aware reinforcement learning and the systems support needed to train it efficiently.
3 Method↩︎
AdaTurn is built around a simple premise: for an active visual agent, the rollout budget is not a nuisance variable but part of the task specification. The policy should therefore depend not only on the image and the question, but also on how many interaction turns are available. We first formalize this budget-aware setting in Section 3.1. We then present Forced-Answer DAPO (FA-DAPO) in Section 3.2, which supplies the missing learning signal at the final-turn boundary. Finally, Section 3.3 describes dynamic-budget training and the load-balanced rollout scheduler that makes such training efficient in practice. Figure 2 gives an overview.
3.1 Problem Formulation and AdaTurn Agent Loop↩︎
Let \(Q\) denote the user question, \(I\) the input image, \(T_\mathrm{max}\) the maximum rollout budget, and \(g\) the ground-truth answer. AdaTurn solves a budget-aware decision problem with input \[x = (Q, I, T_\mathrm{max}). \label{eq:task}\tag{1}\] At turn \(t\), the agent conditions on the interaction history \[h_t = \left(Q, I, T_\mathrm{max}, (y_1, o_1), \ldots, (y_{t-1}, o_{t-1})\right), \label{eq:history}\tag{2}\] where \(y_t\) is the token sequence generated at turn \(t\) and \(o_t\) is the tool observation returned by the environment. At each turn, the policy \(\pi_\theta\) emits either a tool-calling sequence \(c_t\in \mathcal{C}\) or a final-answer sequence \(a_t \in \mathcal{A}\): \[y_t \sim \pi_\theta(\cdot \mid h_t), \qquad y_t \in \mathcal{C} \cup \mathcal{A}. \label{eq:policy}\tag{3}\] If \(y_t \in \mathcal{C}\) and \(t < T_\mathrm{max}\), the tool executor \(\mathcal{E}\) returns a new observation \[o_t = \mathcal{E}(I, y_t), \label{eq:tool}\tag{4}\] which becomes part of the next-turn history. If \(y_t \in \mathcal{A}\), the rollout terminates and the answer is scored against \(g\). The key structural constraint appears at the last turn: \[y_t \in \mathcal{Y}_t = \begin{cases} \mathcal{C} \cup \mathcal{A}, & t < T_\mathrm{max},\\ \mathcal{A}, & t = T_\mathrm{max}. \end{cases} \label{eq:feasible-actions}\tag{5}\] Before the final turn, the agent may either gather more evidence or answer. At the final turn, only answer actions are executable. Catastrophic truncation arises when the learned policy still prefers a tool action at this boundary.
Figure 2 illustrates the resulting agent loop. The left panel shows the budget-conditioned control flow: the model receives the image, the question, and the maximum budget \(T_\mathrm{max}\), then repeatedly decides whether to spend another turn on grounding or to terminate with an answer. This makes the budget visible throughout the rollout rather than leaving it as an implicit system-side constraint. The right panel shows a concrete trajectory in which successive observations narrow the search space until the policy emits a final answer at the budget boundary. The important point is not merely that AdaTurn stops at turn \(T_\mathrm{max}\), but that it is trained to make this boundary decision intelligently. Under large budgets, the policy can spend additional turns on verification; under small budgets, it learns to compress the search and commit using partial evidence.
3.2 Forced-Answer DAPO↩︎
We adopt Decoupled Clip and Dynamic Sampling Policy Optimization (DAPO) [18], a more robust variant of GRPO [19], [25]–[27], as the reinforcement learning algorithm. For each input \(x\), we sample a group of \(G\) rollouts \(\{Y^{(i)}\}_{i=1}^G\) from the current policy, score them with rewards \(\{R^{(i)}\}_{i=1}^G\), and compute normalized advantages \[\hat{A}^{(i)} = \frac{R^{(i)} - \frac{1}{G}\sum_{j=1}^{G} R^{(j)}}{\mathrm{Std}(\{R^{(j)}\}_{j=1}^{G}) + \delta}, \label{eq:adv}\tag{6}\] where \(Y^{(i)}=[y^{(i)}_1, \dots, y^{(i)}_{T_\mathrm{max}}]\) is the \(i\)-th rollout and \(\delta\) is a small constant for numerical stability. DAPO then optimizes the token-normalized clipped objective: \[\mathcal{L}_{\text{DAPO}}(\theta) = - \mathbb{E}\left[ \frac{1}{\sum_{i=1}^{G} |Y^{(i)}|}\sum_{i=1}^{G}\sum_{k} \min\!\left( \rho_{i,k}\hat{A}_{i,k}, \mathrm{clip}(\rho_{i,k}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}})\hat{A}_{i,k} \right) \right] \label{eq:grpo}\tag{7}\] where \(\hat{A}_{i,k}=\hat{A}^{(i)}\) for each token \(k\) in rollout \(Y^{(i)}\), and the token-wise importance ratio is \[\rho_{i,k} = \frac{\pi_\theta\!\left(y^{(i)}_{k}\mid x, y^{(i)}_{<k}\right)}{\pi_{\theta_{\mathrm{old}}}\!\left(y^{(i)}_{k}\mid x, y^{(i)}_{<k}\right)}. \label{eq:ratio}\tag{8}\] With different clip values (\(\epsilon_{\mathrm{low}}\) and \(\epsilon_{\mathrm{high}}\) for positive and negative advantages, respectively) and token-wise normalization, DAPO can stabilize training while still allowing the policy to learn from outlier samples with large advantages.
The central difficulty is that the final-turn boundary is qualitatively different from the rest of the rollout. At turns \(t<T_\mathrm{max}\), the policy decides between continuing to gather evidence and terminating. At turn \(t=T_\mathrm{max}\), that choice collapses: tool calls are no longer feasible. Figure 3 shows that existing strategies do not optimize this regime well. DeepEyes [9] treats the over-budget case as a wrong rollout, which discourages long-horizon exploration and effectively ties the policy to the training budget. Mini-o3 [11] avoids this penalty by masking truncated cases, but this also removes the learning signal precisely where budget-awareness matters most. In both cases, the boundary behavior is under-trained.
We address this with Forced-Answer DAPO (FA-DAPO). Suppose a rollout reaches turn \(T_\mathrm{max}\) and the policy still prefers a tool request. Instead of treating the sample as either incorrect or irrelevant, we roll back to the last executable prefix \(h_{T_\mathrm{max}}^{-}\) and append a control instruction stating that the tool budget has been exhausted and the model must provide its best final answer. Formally, we transform each sampled rollout as \[\tilde{Y}^{(i)} = \begin{cases} Y^{(i)}, & \text{if } Y^{(i)} \text{ emits an answer within } T_\mathrm{max},\\ \left(h_{T_\mathrm{max}}^{-(i)}, \tilde{a}_{T_\mathrm{max}}^{(i)}\right), & \text{if } y_{T_\mathrm{max}}^{(i)} \in \mathcal{C}, \end{cases} \label{eq:forced-answer}\tag{9}\] where \(\tilde{a}_{T_\mathrm{max}}^{(i)} \sim \pi_\theta(\cdot \mid h_{T_\mathrm{max}}^{-(i)}, b_{T_\mathrm{max}})\) and \(b_{T_\mathrm{max}}\) is the budget-exhausted control message. We then score the resulting answer with \[R^{(i)} = \lambda_{\mathrm{acc}}\, r_{\mathrm{acc}}(\tilde{Y}^{(i)} , g) + \lambda_{\mathrm{fmt}}\, r_{\mathrm{fmt}}(\tilde{Y}^{(i)} ). \label{eq:reward}\tag{10}\] Conceptually, FA-DAPO converts catastrophic truncation from an artifact of the rollout engine into a supervised decision problem for the policy. This design enables AdaTurn to operate reliably under tight budgets while still benefiting from additional turns when they are available. We examine several alternative training variants, including masked-prefix optimization, final-turn-only reinforcement learning, and format-weighted rewards, in Section 4.3.
3.3 Dynamic Rollout Budgets and Load-Balanced Scheduling↩︎
The maximum rollout budget is not fixed during either training or inference. During training, we sample \(T_\mathrm{max}\) from a predefined set of candidate budgets and inject it into the prompt as part of the agent state. The same task therefore appears under both short and long budgets, forcing the policy to learn a calibrated trade-off between further search and immediate commitment. This same mechanism carries over directly to inference: practitioners can set \(T_\mathrm{max}\) according to their latency or compute budget without switching models or retraining the policy.
Dynamic budgets, however, create a systems bottleneck. In multi-engine rollout generation, batch latency is determined by the slowest engine. If long-budget samples are assigned unevenly, fast workers idle while one overloaded worker processes a set of overlong trajectories. Figure 4 shows our solution. We assign rollout jobs by sorting requests according to their assigned budget and greedily dispatching each request to the engine with the current lowest accumulated load, which keeps the rollout cost more balanced across workers. Appendix 7 provides the full pseudocode. Each request \(r_n\) carries an assigned rollout budget \(T_n\). After sorting requests by \(T_n\) in descending order, we greedily assign each request to the engine with the current lowest accumulated load. We quantify rollout imbalance as the gap between the largest and smallest accumulated rollout budgets across engines after assignment.
Figure 5 reports the effect on real training runs. The scheduler consistently reduces both the maximum rollout time and the cross-engine load imbalance value calculated as the gap between the largest and smallest accumulated rollout budgets across engines. This leads to an average \(1.34\times\) speedup in rollout generation, which is critical for dynamic-budget training and inference.
| Model | VisualProbe | V* | HR-Bench | MME-RealWorld | |||
| hard | medium | easy | 4K | 8K | |||
| GPT-4o [31] | 11.2 | 15.4 | 47.5 | 65.2 | 62.0 | 58.3 | 45.2 |
| LLaVA-OneVision [32] | 13.4 | 12.5 | 36.2 | 70.9 | 61.2 | 54.0 | 57.4 |
| Qwen2.5-VL-Instruct [3] | 23.9 | 26.0 | 39.1 | 75.5 | 68.2 | 62.7 | 57.3 |
| SEAL [33] | - | - | - | 75.4 | - | - | - |
| DyFo [34] | - | - | - | 81.2 | - | - | - |
| Chain-of-Focus [35] | - | - | - | 88.0 | - | - | - |
| Pixel Reasoner [10] | 28.8 | 29.6 | 58.4 | 86.3 | 74.0 | 66.9 | 64.4 |
| DeepEyes [9] (6 turns) | 35.1 | 29.8 | 60.1 | 83.3 | 73.2 | 69.5 | 64.0 |
| Mini-o3 [11] (4 turns) | 26.5 | 36.7 | 42.4 | 79.2 | 68.9 | 63.2 | 50.1 |
| Mini-o3 [11] (32 turns) | 48.0 | 50.4 | 67.0 | 88.2 | 77.5 | 73.3 | 65.5 |
| Ours (4 turns) | 39.0 | 47.6 | 61.2 | 85.2 | 75.7 | 71.1 | 64.0 |
| Ours (32 turns) | 48.1 | 51.0 | 66.7 | 86.9 | 77.5 | 73.4 | 66.3 |
4 Experiments↩︎
4.1 Experimental Details↩︎
Datasets. We evaluate AdaTurn on VisualProbe [11] and V* Bench [33] for agentic visual search, HR-Bench [6] at 4K and 8K for high-resolution perception, and MME-RealWorld [20] for real-world multimodal reasoning. To assess whether the resulting policy remains broadly useful beyond the main visual-search setting, we additionally report OCRBench [36], ChartQA [37], DocVQA [38], MathVista [39], ScienceQA [40], and CV-Bench [41].
Baselines. We compare against closed and open-source multimodal models, including GPT-4o [31], LLaVA-OneVision [32], Qwen2.5-VL-7B-Instruct [3], DeepEyes [9], Mini-o3 [11], Pixel Reasoner [10], and Chain-of-Focus [35]. The most relevant baselines are DeepEyes [9] and Mini-o3 [11] because they also train multi-turn visual tool use; they therefore isolate the contribution of budget-aware learning more directly than generic VLM baselines.
Metrics. We report benchmark-standard accuracy. Following the corresponding benchmark protocols, VisualProbe and V* Bench are averaged over 32 repeated runs to reduce stochastic variation, while HR-Bench and MME-RealWorld are evaluated with 8 and 1 run, respectively.
Implementation Details. Unless otherwise specified, the main results use a Qwen2.5-VL-7B-Instruct backbone [3] and compare inference under different maximum rollout turns. For more implementation details, including the training hyperparameters and the ablation variants, please refer to Appendix 6.
![Figure 6: Performance vs. rollout budget. AdaTurn provides a more favorable trade-off than Mini-o3 [11] in the low-budget regime, particularly at four and eight turns, while remaining competitive as additional turns are available.](/article/2607.14547/figures/sota.png "fig:")
4.2 Quantitative Comparison↩︎
Table ¿tbl:tab:main? reports the main quantitative comparison. AdaTurn performs particularly well in the low-budget regime, where catastrophic truncation is most consequential. At four turns, AdaTurn improves over Mini-o3 [11] by \(+12.5\%\) on VisualProbe-Hard, \(+10.9\%\) on VisualProbe-Medium, \(+6.0\%\) on V*, \(+6.8\%\) on HR-Bench 4K, \(+7.9\%\) on HR-Bench 8K, and \(+13.9\%\) on MME-RealWorld. These improvements are consistent across VisualProbe [11], HR-Bench [6], and MME-RealWorld [20], suggesting that the benefit is not confined to a single benchmark family.
At the same time, these gains do not come at the expense of high-budget behavior. At thirty-two turns, AdaTurn matches or exceeds Mini-o3 [11] on VisualProbe-Hard, VisualProbe-Medium, HR-Bench 8K, and MME-RealWorld, while tying on HR-Bench 4K. This indicates that FA-DAPO does not simply encourage earlier termination; rather, it teaches the model to answer appropriately when the budget is limited while still making use of longer rollouts when they are available.
Figure 6 presents the same trend from a complementary perspective by plotting performance as a function of the rollout budget. AdaTurn shifts the curve upward in the low-budget region, especially at 4 and 8 turns, while preserving favorable scaling as the budget grows. Additional rollout visualizations and a failure case analysis are provided in Appendix Sections 12 and 13.
4.3 Ablation Studies↩︎
Figure 7 isolates the contribution of the reinforcement learning design. The main takeaway is that forced-answer training is the primary contributor to the improvement: every AdaTurn variant outperforms Mini-o3 at four turns, indicating that explicit supervision of the budget boundary is important for mitigating catastrophic truncation. Among these variants, the default formulation performs best overall, especially once the budget exceeds eight turns.
Appendix 8 provides the detailed ablation discussion. In brief, masking prefix turns, restricting optimization to only the final forced-answer step, and adding a format reward all underperform the default formulation.
4.4 Applicability↩︎
Table ¿tbl:tab:backbone? shows that AdaTurn transfers cleanly to other backbone scales. On both Qwen3-VL-4B-Instruct and Qwen3-VL-8B-Instruct [21], AdaTurn outperforms Mini-o3 [11] at four turns across nearly all visual-search benchmarks, and these improvements largely persist at thirty-two turns. This suggests that AdaTurn is not tied to a single base model, but reflects a more general training principle for visual agents.
| Model | VisualProbe | V* | HR-Bench | MME-RealWorld | |||
| hard | medium | easy | 4K | 8K | |||
| Qwen3-VL-4B-Instruct [21] | - | - | - | 88.0 | 81.3 | 74.4 | - |
| + Mini-o3 [11] (4 turns) | 24.7 | 44.3 | 54.9 | 87.0 | 77.2 | 72.4 | 61.2 |
| + Mini-o3 [11] (32 turns) | 46.3 | 53.9 | 69.1 | 90.2 | 80.0 | 77.3 | 66.0 |
| + Ours (4 turns) | 40.0 | 51.7 | 68.4 | 90.0 | 79.2 | 76.6 | 66.6 |
| + Ours (32 turns) | 46.4 | 54.3 | 70.6 | 90.7 | 79.8 | 78.0 | 67.1 |
| Qwen3-VL-8B-Instruct [21] | - | - | - | 90.1 | 82.3 | 78.0 | - |
| + Mini-o3 [11] (4 turns) | 24.9 | 44.6 | 58.7 | 87.6 | 78.3 | 75.8 | 60.0 |
| + Mini-o3 [11] (32 turns) | 55.4 | 55.6 | 74.7 | 91.1 | 82.8 | 81.9 | 69.3 |
| + Ours (4 turns) | 45.9 | 54.6 | 73.8 | 91.1 | 82.4 | 81.4 | 69.2 |
| + Ours (32 turns) | 56.0 | 57.0 | 74.8 | 91.6 | 83.0 | 82.3 | 69.8 |
General multimodal results are deferred to Appendix 9. They show that AdaTurn preserves broad OCR and reasoning ability relative to the underlying Qwen2.5-VL-7B-Instruct backbone [3] while remaining competitive with Mini-o3 [11].
5 Conclusion↩︎
We presented AdaTurn, a budget-aware framework for active visual agents under constrained test-time interaction. AdaTurn treats the rollout budget as part of the problem specification, introduces Forced-Answer DAPO to optimize the final-turn boundary explicitly, and combines dynamic-budget training with load-balanced rollout scheduling. Together, these components address catastrophic truncation while preserving the gains of longer rollouts. Empirically, AdaTurn performs favorably in the low-budget regime, remains competitive at larger budgets, transfers to multiple backbone sizes, and preserves broad multimodal capability. More broadly, our results suggest that the next stage of test-time scaling for visual agents is not only about allowing more computation, but about teaching the policy how to reason intelligently under the computation it is actually given. Limitations and broader impact are discussed in Appendix 14.
6 Detailed Training Setup↩︎
Following Mini-o3 [11], we first initialize AdaTurn by supervised fine-tuning Qwen2.5-VL-7B-Instruct [3] on the Mini-o3 cold-start dataset1. We then perform reinforcement learning on DeepEyes_train_4K2 and VisualProbe_train3 with dynamic rollout budgets from 4 to 12 turns. We use LLaMA-Factory [42] for supervised fine-tuning and VERL [43] for reinforcement learning, and we follow the released licenses and terms of use of the frameworks, datasets, and pretrained backbones used in our experiments.
| Configuration | Supervised fine-tuning | Reinforcement learning |
|---|---|---|
| Framework | LLaMA-Factory | VERL |
| Training data | Mini-o3 cold-start dataset | DeepEyes_train_4K + VisualProbe_train |
| Batch size | 64 | 64 |
| Group size | – | 16 |
| Mini-batch size | – | 32 |
| Learning rate | \(1\times 10^{-5}\) | \(1\times 10^{-6}\) |
| Schedule | 10% warmup + cosine decay | none |
| Epochs | 3 | 1 |
| KL loss | – | none |
| Reward weights | – | accuracy 1.0, format 0.0 |
| Minimum image pixels | 40,000 | 40,000 |
| Maximum image pixels | 2,000,000 | 2,000,000 |
| Dynamic rollout turns | – | 4 to 12 |
| Freeze vision encoder | true | false |
| Freeze projection layer | true | false |
| Freeze LLM | false | false |
| Context length | 32,768 | 32,768 |
| Compute | 1 node with 8 A100 GPUs | 2 nodes with 8 A100 GPUs per node |
| Wall-clock time | about 2 hours | about 3 days |
7 Load-Balanced Rollout Assignment Pseudocode↩︎
Algorithm 8 gives the full scheduling routine used by AdaTurn when dynamic rollout budgets are enabled. The key idea is to sort requests by assigned rollout budget and greedily place each request on the rollout engine with the smallest current accumulated load. This simple strategy reduces the idle time induced by heterogeneous rollout lengths and complements the main-text discussion in Section 3.3.
8 Detailed Ablation Discussion↩︎
Figure 7 shows that explicit supervision at the budget boundary is the main source of improvement. Masking earlier prefix turns degrades performance, which suggests that the final forced-answer decision is best learned together with the preceding search trajectory rather than in isolation. Restricting reinforcement learning to only the final forced-answer turn performs worse still, indicating that budget-aware behavior is a trajectory-level property rather than a single-step correction.
Adding an explicit format reward is also mildly harmful. In our setting, answer extraction already imposes the required structural constraint, so allocating reward mass to formatting does not improve supervision and can distract from the accuracy objective. Taken together, these results support the default full-rollout, accuracy-only FA-DAPO design.
The systems-side ablation in Figure 5 leads to a similar conclusion. The left subfigure reports the minimum and maximum rollout time across engines together with their induced range, while the right subfigure summarizes the gap between the most and least loaded engines. Dynamic rollout budgets create substantial worker imbalance under naive assignment, but the proposed scheduler reduces both statistics and yields an average \(1.34\times\) rollout speedup, making budget-aware training materially more efficient in practice.
9 General Multimodal Capability↩︎
Table 2 examines whether AdaTurn preserves general multimodal ability beyond the high-resolution visual-search benchmarks used in the main study. Relative to the base Qwen2.5-VL-7B-Instruct model [3], AdaTurn improves OCRBench [36], ChartQA [37], and CV-Bench [41] while remaining competitive on DocVQA [38], MathVista [39], and ScienceQA [40]. Relative to Mini-o3 [11], it performs better on OCRBench [36], ChartQA [37], and CV-Bench [41]. These results suggest that budget-aware agent training does not merely specialize the model to a narrow tool-use benchmark, and can be compatible with broad multimodal competence.
| OCR-Related | General | Reasoning | ||||
| Model | OCRBench | ChartQA | DocVQA (val) | CV-Bench | MathVista (testmini) | ScienceQA (img) |
| Qwen2.5-VL-7B-Instruct [3] | 81.5 | 79.6 | 94.6 | 73.9 | 68.2 | 89.0 |
| DeepEyes [9] | - | - | - | - | 70.1 | - |
| Mini-o3 [11] | 83.8 | 77.4 | 94.8 | 74.4 | 68.8 | 84.5 |
| Ours | 85.5 | 80.0 | 93.0 | 77.6 | 68.1 | 83.7 |
10 Performance Judge Prompt↩︎
To evaluate whether a model prediction matches the ground-truth answer, we use an external judge model. Specifically, we use Qwen3-32B as a binary evaluator that compares the question, the ground-truth answer, and the model prediction, then returns a score of 1 for correct and 0 for incorrect. The exact system prompt and query prompt are shown below.
System Prompt You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here’s how you can accomplish the task: —— ##INSTRUCTIONS: - Focus on the meaningful match between the predicted answer and the correct answer. - Consider synonyms or paraphrases as valid matches. - Evaluate the correctness of the prediction compared to the answer.
Query Prompt I will give you a question related to an image and the following text as inputs:
1. **Question Related to the Image**: question 2. **Ground Truth Answer**: ground_truth 3. **Model Predicted Answer**: prediction
Your task is to evaluate the model’s predicted answer against the ground truth answer, based on the context provided by the question related to the image. Consider the following criteria for evaluation: - **Relevance**: Does the predicted answer directly address the question posed, considering the information provided by the given question? - **Accuracy**: Compare the predicted answer to the ground truth answer. You need to evaluate from the following three perspectives: (1) If the ground truth answer is open-ended, consider whether the prediction accurately reflects the information given in the ground truth without introducing factual inaccuracies. If it does, the prediction should be considered correct. (2) If the ground truth answer is a definitive answer, strictly compare the model’s prediction to the actual answer. Pay attention to unit conversions such as length and angle, etc. As long as the results are consistent, the model’s prediction should be deemed correct. (3) If the model’s prediction is irrelevant string, such as punctuation, newlines, tabs, whitespace, or emptry string etc., without a meaningful answer, set the score as 0. **Output Format**: Your response should include an integer score indicating the correctness of the prediction: 1 for correct and 0 for incorrect. Note that 1 means the model’s prediction strictly aligns with the ground truth, while 0 means it does not. The format should be "Score: 0 or 1"
11 AdaTurn Agent Prompts↩︎
AdaTurn uses a small set of structured prompts to control the agent loop. We provide the exact prompts used for the initial system instruction, tool observations, tool errors, and the forced-answer stage when the tool budget is exhausted.
System Prompt You are a helpful assistant. Answer the user’s question based on the image provided. Output your thinking process within the <think> and </think> tags. Whenever you find anything unclear, you can zoom in a specific region in the given image to see more clearly by outputing <grounding>"bbox_2d": [x0, y0, x1, y1], "source": "original_image"</grounding>, where (x0, y0) and (x1, y1) are the top-left and bottom-right coordinates of the region that you want to zoom in, respectively (suppose the width and height of the image are 1.0), and ‘source’ refers to the image that you zoom in and could be either ‘original_image’ or ‘observation_i’. Once the final answer is confirmed, put it within <answer> and </answer>.
Tool Observation Response After the above Action action_turn, here is the the zoom-in image (Observation observation_turn): <|vision_start|><|image_pad|><|vision_end|>. Continue your reasoning process inside <think> and </think>. If needed, you can continue to zoom in on the original image or any of the observations, by outputting <grounding> and </grounding> as before. If the final answer is confirmed, put your final answer inside <answer> and </answer>.
Tool Error Response Please analyze the error information obtained from the function tool and adjust your response. Countinue your reasoning process inside <think> and </think>.
Force-to-Answer Prompt <think>I have exhausted my tool-calling budget and must answer the question using the information I have obtained, even though I may make mistakes due to a lack of data.
12 Visualization of AdaTurn Rollout Trajectories↩︎
Figures 9 and 10 show representative successful trajectories under a tight four-turn budget, while Figures 11 and 12 show successful trajectories under an eight-turn budget. These examples highlight two qualitative behaviors encouraged by AdaTurn. First, the model does not simply terminate at the budget boundary; instead, it uses the available observations to synthesize a final answer when further grounding is disallowed. Second, the trajectory remains adaptive under different budgets: under \(T_{\max}=4\), the model makes compressed decisions based on limited evidence, whereas under \(T_{\max}=8\), it can continue refining the crop sequence until the target detail becomes identifiable.
The examples also illustrate that AdaTurn learns a useful form of budget-aware evidence aggregation. In Figure 9, the final crop is less informative than an earlier observation, but the model still answers correctly by relying on the sharper evidence collected before the final turn. In Figure 10, the model revisits the original image, shifts attention to a previously overlooked region, and then answers correctly at the forced-answer step. Figures 11 and 12 show that with a larger budget, AdaTurn can sustain longer search trajectories to identify small traffic-light signals and fine-grained scene text, respectively.
13 Failure Analysis↩︎
Figure 13 shows a representative failure case under a four-turn budget. The question asks for the direction faced by the person wearing the plaid shirt, but the available observations do not provide sufficient evidence to isolate the correct individual with confidence. After exhausting the tool budget, the model is forced to answer using incomplete information and instead anchors on a different person in the scene, which leads to a hallucinated final answer.
This failure mode is consistent with the intended trade-off of AdaTurn. Forced-answer training mitigates catastrophic truncation by ensuring that the model produces a valid answer even when the search budget is insufficient, but it cannot guarantee correctness when the collected evidence remains ambiguous. In such cases, the model may still hallucinate by overcommitting to an imperfect hypothesis, especially in crowded scenes where small identity distinctions are difficult to resolve within a short rollout.
14 Limitations and Societal Impact↩︎
14.0.0.1 Limitations.
Our study is restricted to image-based agents and does not cover video settings, where temporal reasoning and substantially longer interaction horizons introduce additional complexity. We also focus on image crop tools and do not explore broader tool ecosystems such as web search, code execution, or bash interaction.
14.0.0.2 Societal Impact.
Turn-aware visual agents may benefit latency-sensitive assistive perception, document understanding, and high-resolution inspection systems by producing useful answers under tight compute budgets. At the same time, stronger visual search agents could be misused for surveillance or large-scale automated image inspection, so future releases should follow responsible deployment practices and existing usage restrictions.