💻 computer science

Beacon: Knowing When and How to Perform Agentic Visual Reasoning

The paper introduces Beacon, a novel agentic visual reasoning model that improves overall performance by addressing the limitations of existing models in Mode Adaptiveness and Tool Effect through a reinforcement learning framework featuring Necessity-Aware Adaptive Rewards and Hint-Guided Capability Expansion.

Original authors: Qixun Wang, Yang Shi, Letian Cheng, Zhuoran Zhang, Yan He, Yuqi Tang, Qi Zhang, Xinlei Yu, Ruizhe Chen, Tianrun Xu, Yuanxing Zhang, Pengfei Wan, Haotian Wang, Xianghua Ying

Published 2026-07-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Qixun Wang, Yang Shi, Letian Cheng, Zhuoran Zhang, Yan He, Yuqi Tang, Qi Zhang, Xinlei Yu, Ruizhe Chen, Tianrun Xu, Yuanxing Zhang, Pengfei Wan, Haotian Wang, Xianghua Ying

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a super-smart robot friend who can look at pictures and answer questions about them. This robot is part of a field called "multimodal AI," where computers learn to understand both text and images. Usually, when this robot sees a tricky picture, it tries to solve the puzzle using only its brain (text reasoning). But sometimes, the puzzle is too hard for just thinking; it needs a pair of "tools," like a magnifying glass to zoom in, a calculator to count things, or a pair of scissors to crop a section of the image. This is called "agentic visual reasoning." The big question scientists are asking isn't just "Can the robot use tools?" but "Does the robot know when to use them?" If the robot grabs a hammer to crack a nut, it wastes time and might break the nut. If it tries to count a thousand tiny dots with its eyes instead of a counter, it might get the answer wrong. We care about this because we want our AI helpers to be efficient and accurate, not just busy.

Enter Beacon, a new kind of AI model created by researchers who realized that many current "tool-using" robots are a bit clumsy. They tend to use their tools on everything, even simple tasks they could solve with their eyes closed, and they often fail to use them when the task is actually impossible without help. The authors of this paper, a team from universities and the Kling team, decided to build a smarter robot that knows exactly when to put down the tools and when to pick them up.

They found that existing models are like a student who keeps using a calculator for simple addition like $2+2$ , wasting time and sometimes making silly mistakes because they rely on the machine too much. Meanwhile, when faced with a truly hard math problem, these same students often forget to use the calculator at all. The researchers measured this behavior and discovered that for many current models, the "help" the tools provide on hard problems is almost completely canceled out by the "harm" they cause on easy problems.

To fix this, they built Beacon using a special training method called Reinforcement Learning. Think of this like training a dog with a very specific set of rules. First, they taught the model how to use tools (like writing Python code to crop an image or count pixels) through a lot of practice. Then, they introduced two clever tricks to teach it when to use them:

The "Necessity-Aware" Reward: Imagine a teacher who gives a gold star if you solve a problem without a calculator, but still gives a silver star if you use the calculator correctly only when the problem is too hard to do in your head. If you use the calculator on an easy problem, you get no star. This teaches the model to save its tools for the tough jobs.
The "Hint-Guided" Expansion: Sometimes, a problem is so hard that the model gets stuck and gives up. Instead of just giving up, the researchers had a super-smart "expert" model (like a genius tutor) write a hint that guides the robot on how to use a tool to solve it, without giving away the answer. The robot then practices solving the problem with this hint, learning the strategy, and eventually learns to do it on its own without the hint.

The results are impressive. When tested on 13 different challenging benchmarks (ranging from counting marbles on a track to figuring out badminton scores), Beacon became the best-performing open-source model. It didn't just get better at using tools; it got better at choosing them. The data shows that Beacon improved its overall score by an average of 6.07 points compared to its base version. More importantly, it showed a "Tool Gain" of +3.14%, meaning the tools it used actually helped it solve problems it couldn't solve before, without messing up the easy ones.

In short, the paper suggests that the future of smart AI isn't just about having more tools or being smarter in general; it's about having the wisdom to know when to reach for a tool and when to trust your own judgment. Beacon proves that with the right training, AI can learn to be a thoughtful partner rather than a frantic tool-wielder.

Technical Summary: BEACON – Knowing When and How to Perform Agentic Visual Reasoning

1. Problem Statement

Agentic visual reasoning aims to enhance Multimodal Large Language Models (MLLMs) by leveraging external tools (e.g., code execution for image manipulation or numerical computation) to solve complex tasks. However, current approaches suffer from two critical deficiencies:

Lack of Mode Adaptiveness: Existing models often fail to determine when tools are necessary. They tend to either indiscriminately invoke tools (introducing unnecessary computational overhead and errors on simple tasks) or never use them (missing opportunities to solve hard problems).
Ineffective Tool Use (Tool Effect): While tools are intended to extend model capabilities on unsolvable problems, current models often introduce errors on problems they could already solve without tools. Consequently, the performance gains on "hard" examples are frequently offset by the degradation on "easy" examples, resulting in negligible net improvement over tool-free reasoning.

The paper argues that the fundamental goal should not merely be equipping models with tools, but ensuring they use them adaptively and effectively to achieve genuine capability expansion.

2. Methodology: The Beacon Framework

The authors propose Beacon, a novel agentic visual reasoning model trained via a Supervised Fine-Tuning (SFT) followed by Reinforcement Learning (RL) paradigm. The core innovations lie in the data construction and the RL framework.

2.1 Training Data Construction

Source Selection: Data is curated from 16 diverse benchmarks covering real-world perception, charts, OCR, STEM, and spatial reasoning.
SFT Data Synthesis: The base model (Qwen3-VL-8B-Instruct) is evaluated on source data. Hard examples (answered correctly ≤2 times out of 5) are selected. A strong teacher model (Gemini 3.1 Pro) generates code-assisted reasoning trajectories for these hard examples, which are then refined to ensure correctness.
RL Data Curation: The SFT model is evaluated on the same pool. Examples that remain unsolved (answered correctly ≤3 times out of 5) are selected for the RL stage to focus on expanding capability boundaries.

2.2 Reinforcement Learning Framework

Beacon employs a custom RL framework based on GRPO (Group Relative Policy Optimization) with two novel mechanisms:

A. Necessity-Aware Adaptive Reward (NAAR)

This reward function addresses Mode Adaptiveness. It aims to encourage tool use only when necessary without suppressing the model's ability to solve problems.

Logic: For a group of rollouts, if at least one correct text-only response exists, the reward for a correct text-only response is 1.0, while a correct code-based response receives a reduced reward (0.25). If no text-only response is correct, a correct code-based response receives the full reward (1.0).
Goal: This creates a "soft preference" for text-only reasoning when sufficient, penalizing unnecessary tool calls while preserving the incentive to use tools for difficult problems.

B. Hint-Guided Capability Expansion (HCE)

This mechanism addresses Tool Effect by recovering learning signals from "all-wrong" groups that are typically discarded in standard RL.

Process: When a group of rollouts fails to solve a hard problem, a strong expert model (Gemini 3.1 Pro) generates a "hint." This hint consists of intermediate reasoning steps and subgoals (but not the final answer) derived from a verified correct trajectory.
Re-rollout: The policy model is prompted with the original question plus the hint to generate new trajectories.
Optimization: During the policy update, the hint is removed from the input prompt, but the successful trajectory generated with the hint is retained. This transfers the capability to solve the problem without relying on the hint at inference time.

2.3 Inference Behavior

During inference, Beacon autonomously decides whether to generate Python code (enclosed in <tool_call>...</tool_call>) for operations like cropping, annotation, or calculation. The output is returned as an observation (<observation>...</observation>) to guide further reasoning or final answer generation.

3. Key Contributions

Systematic Analysis of Tool Use: The authors define and quantify two metrics: Mode Adaptiveness (MA) (the ability to choose the right reasoning mode) and Tool Effect (TE) (the net gain of tool use, calculated as Tool-Gain minus Tool-Harm). Their analysis reveals that existing models lack adaptiveness and that tool-induced gains are often negated by harms on easy tasks.
Novel Training Framework: The introduction of NAAR and HCE within an RL framework to specifically target adaptive invocation and genuine capability expansion.
High-Quality Data Pipeline: A synthesis pipeline that leverages a strong teacher model to generate and refine code-assisted trajectories for hard examples, ensuring high-quality supervision.
State-of-the-Art Performance: Beacon achieves the best average performance across 13 diverse benchmarks among open-source models, significantly narrowing the gap with closed-source models.

4. Experimental Results

The model was evaluated on 13 benchmarks, including high-resolution visual search (V*, HRBench), spatial reasoning (BLINK, BabyVision), and agentic reasoning (TIRBench, GameQA).

Overall Performance: Beacon-8B achieved the highest average score among all open-source models, ranking first on 11 of 13 benchmarks. It outperformed its base model (Qwen3-VL-8B-Instruct) by an average of 6.07 points.
Mode Adaptiveness: Beacon demonstrated the highest MAmean (average adaptiveness score), showing it can effectively switch between text-only and tool-assisted modes based on problem difficulty. Unlike other models that favor a single mode, Beacon adapts its strategy.
Tool Effect: Beacon exhibited the largest positive gap between Tool-Gain and Tool-Harm ( $\Delta$ TE = +3.14%). This indicates that Beacon successfully uses tools to solve hard problems while minimizing the performance degradation on easy problems. Other models often showed $\Delta$ TE near zero or negative.
Ablation Studies: Removing NAAR reduced Mode Adaptiveness, while removing HCE reduced the Tool Effect ( $\Delta$ TE). The full model combined both to achieve optimal results.

5. Significance and Claims

The paper claims that the progress of agentic visual reasoning should not be measured merely by the frequency of tool usage or aggregate accuracy, but by whether models know when tools are necessary and how to use them to produce genuine capability gains.

Beacon demonstrates that by explicitly optimizing for adaptiveness and the net benefit of tool use, it is possible to create models that:

Avoid unnecessary computational overhead on solvable tasks.
Successfully extend their capabilities to solve previously intractable problems.
Achieve a robust balance where tool-induced gains are not offset by tool-induced harms.

The authors conclude that their approach provides a more effective paradigm for agentic visual reasoning, moving beyond the "indiscriminate tool invocation" seen in prior works to a more intelligent, necessity-driven agent.