EGM: Efficient Visual Grounding Language Models¶

Conference: ECCV 2026
arXiv: 2601.13633
Paper: ECCV 2026
Code: https://github.com/NVLabs/EGM
Area: Multimodal VLM
Keywords: visual grounding, test-time compute, multimodal reasoning, GRPO, inference efficiency

TL;DR¶

EGM first distills a "how to find the target" reasoning trace for every grounding sample from a proprietary VLM for SFT, then applies GRPO with a reward mixing IoU and grounding success, letting an 8B model reach 91.4 average accuracy on RefCOCO and surpass the 235B model's 90.5 while cutting end-to-end latency from 4320ms to 737ms (5.9x).

Background & Motivation¶

Visual grounding requires a model to locate the object named by a natural-language instruction and return a bounding box; it underpins autonomous driving and robotic manipulation. The strongest open models on the RefCOCO benchmarks — InternVL-3.5 and Qwen3-VL — are tens to hundreds of billions of parameters, and their small variants degrade sharply: InternVL-3-1B scores only 81.6 and the 2B model 86.7, while the 78B sibling reaches 91.4. Reliable grounding therefore ends up tied to models that do not fit on edge devices such as Jetson Thor or DGX Spark.

The authors proceed in an unusually disciplined order: attribute the gap first, then propose a method. They observe that within the Qwen and InternVL families the visual encoder is nearly the same size across model scales, and only the language model grows, so they hypothesize that small models fall behind because of text understanding rather than visual information handling. To verify this, they feed the InternVL-3-8B failures on RefCOCO (IoU < 0.5), together with the ground-truth boxes, to several proprietary models for attribution. The dominant failure pattern, which they name COMPLEX-PROMPT, is a semantically complex expression combined with several similar candidates in the image, so the model grounds the other candidate. In "chair empty next to guy", for instance, the model correctly understands "chair" but ignores both "empty" and "next to guy". Three proprietary models attribute 62.8% (GPT-4), 48.8% (GPT-5) and 46.8% (Gemini-3-Pro) of the failures to COMPLEX-PROMPT, 52.8% on average; handing the same samples to larger models raises success monotonically with scale (InternVL-3-32B 29.9% to 78B 42.6%), confirming that this failure mode is resolvable with stronger language understanding.

The problem is thus recast as an efficiency proposition: rather than scaling to 235B to buy text understanding, let the small model spend a little more compute at inference time — first writing out how to find the target, then emitting the box. Core idea: distill grounding-specific reasoning traces from a proprietary VLM for SFT, then align that reasoning to box accuracy with a GRPO objective whose reward is measured on the box, so that a small model trades many "mid-quality" tokens for the few expensive tokens of a large model — matching 235B accuracy at 8B scale while cutting end-to-end latency by roughly 6x.

Method¶

Overall Architecture¶

EGM takes an image plus a referring expression as input and produces a reasoning process followed by four integer coordinates written into the same text sequence, of the form Answer: <think>...reasoning...</think><ref>referring expression</ref><box>[x1, y1, x2, y2]</box>. It does not modify the LLaVA-style architecture of InternVL / Qwen3-VL (ViT encoder + MLP projector + LLM) and introduces neither a detection head nor a dedicated grounding token: the grounding output is an ordinary text token sequence decoded into a box from four numbers. This matters, because it means the difference between 8B and 235B lies entirely on the LLM side.

Every mechanism follows from the diagnosis that "small models lack language understanding, not visual encoding", and the method amounts to two offline data-construction stages plus a two-stage training recipe. Offline, a proprietary VLM writes a reasoning trace for every (image, referring expression, ground-truth box) triple, forming the SFT data. Online, the model first undergoes cold-start SFT to learn the "reason first, then box" pattern; the RL stage does not train on the full dataset but first selects samples the learner fails while the reference model succeeds, mixes in an equal number of easy samples, and optimizes with GRPO under a reward weighting IoU and grounding success. Vanilla grounding and amodal grounding use two entirely separate datasets and are trained as two separate models.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["image + referring expression"] --> B["reasoning trace data construction<br/>proprietary VLM writes the CoT"]
    G["amodal segmentation annotations<br/>COCO-Amodal / TAO-Amodal"] --> H["amodal grounding task construction<br/>generate referring text + occlusion reasoning"]
    H --> B
    B --> C["SFT cold start<br/>learn to reason before boxing"]
    C --> D["learnability-driven sample selection<br/>learner fails, reference succeeds"]
    D --> E["GRPO with mixed reward<br/>IoU and success weighted"]
    E --> F["EGM: think -> ref -> box coordinates"]

Key Designs¶

1. Reasoning trace data construction: turning "how to find the target" into a supervision signal

SFT needs process supervision, but existing grounding datasets only provide (image, text, ground-truth box) triples and never say how the box was found. EGM therefore feeds each sample of an off-the-shelf vanilla grounding training set \(D_G=\{d_i\}\) (the authors use the RefCOCO training split) to a proprietary VLM \(\Phi\) together with its ground-truth box, and lets it emit a reasoning trace \(z_i=\Phi(d_i)\); the original sample is then paired with its trace to form \(D_C=\{(d_i,z_i)\}\). Note that the ground-truth box is part of the input: the teacher reasons backwards from a known answer, so what it generates is a reproducible grounding logic rather than a blind guess. For a sample whose expression is vase with handle, the generated reasoning is "focus on the distinguishing feature of a distinct handle; the vase on the right has a prominent handle, so it is the correct choice" — exactly the discrimination that the COMPLEX-PROMPT failure mode demands. The result is 575,208 samples over 24,407 images, 2.3±1.3 boxes per image (resolution 585.7±87.0 x 480.3±93.1).

For this design to work, one non-obvious premise must hold: the teacher's value lies in the process, not the answer. In the experiments GPT-5 reaches only 40.1 average accuracy on RefCOCO and Gemini-2.5-Pro only 63.8, both far below the student itself, so distilling their boxes would only hurt (the paper states plainly that it is difficult to distill a gain out of a weaker model). Their ability to organize language and decompose spatial relations, however, is strong enough — using that ability to produce reasoning traces while leaving the final coordinates to the student's own visual encoding and learning is the real lever of this data pipeline.

2. Amodal grounding task construction: completing a box for the occluded shape

For vanilla grounding the reasoning supervision can be reverse-engineered from existing data, but that breaks entirely for amodal grounding, which must predict both the visible and the occluded parts: the community has amodal segmentation annotations but no (referring expression, amodal box) pairs. The authors therefore convert segmentation annotations into a text-referring task — starting from COCO-Amodal and TAO-Amodal, they use a proprietary VLM to generate a detailed description that uniquely identifies each target object, then add a verification step that removes noisy descriptions, yielding a dataset \(D_T\) (23,698 samples, 15,798 images, at a markedly higher resolution than the vanilla data). With text referring available, the same reasoning-generation pipeline as in design 1 applies.

The real difference is in the reasoning content: amodal reasoning must explicitly answer three things beyond locating the object — which object causes the occlusion, what the complete unoccluded shape looks like, and in which directions and how far the visible part should be extended. The paper's example is "the tiger behind the fallen log on the right": the reasoning must state that "the fallen log in front is causing the occlusion", that "the complete shape of the tiger includes its full torso, legs and tail, which are hidden behind the log", and that "to recover the full object, extend downward from the visible part considerably" (with little expansion needed in other directions). These three questions effectively break amodal completion, otherwise an implicit regression, into individually supervised spatial reasoning steps, which is why it transfers so well to a small model. The same pipeline (identical prompt generation and verification) is also used to carve an 11,261-sample, 2,474-image amodal evaluation benchmark out of the COCO-Amodal val/test splits, filling the gap left by the absence of an off-the-shelf benchmark for this task.

3. Learnability-driven sample selection: training only on samples the learner fails and the reference solves

The most consequential RL decision is which data to train on. A full dataset mixes three kinds of samples: those the learner already solves, those it fails but can actually learn, and those that are too hard or simply mislabelled. The last two are indistinguishable to the model — both present as failures — so EGM borrows the notion of learnability. It first defines grounding success (1 when IoU exceeds 0.5, otherwise 0) and subtracts the learner's score from the reference's:

\[S_{\theta,i}=\begin{cases}1, & \mathrm{IoU}_{\theta,i}>0.5\\ 0, & \text{otherwise}\end{cases},\qquad l_i = S_{\mathrm{ref},i}-S_{\theta,i}\]

Here the learner \(M_\theta\) is the small VLM being trained and the reference \(M_{\mathrm{ref}}\) is the strongest grounding model available, InternVL-3.5-241B. The learnable set is \(D_{\text{learnable}}=\{d_i \mid l_i>0\}\) — the learner fails while the reference succeeds, so these samples "have not been learned yet but are learnable". Samples the reference also fails are discarded outright: they are either beyond reach or the ground truth itself is wrong, and training on them would simply reward noise. Since training only on hard samples can cause overfitting and degrade general cases, the authors additionally uniformly sample an easy set \(D_{\text{easy}}\) of the same size from samples the learner already solves, and the final training set is the union of the two. Because amodal data amounts to only some twenty thousand samples, that task skips the selection step and trains on all of \(D_T\).

This recipe — filter by learnability, back it with an equal number of easy samples — is task-agnostic and needs only a reference model stronger than the learner, so it transfers directly to other RLVR settings.

4. GRPO with a mixed reward: making the reasoning pay off in box accuracy

A reward that only takes grounding success (0/1) is sparse: moving a box from IoU 0.3 to 0.45 earns nothing, and the model faces a flat plateau near the 0.5 threshold with no direction to move in. EGM therefore defines the reward as a weighted sum of IoU and success:

\[r_i=\alpha\,\mathrm{IoU}_{\theta,i}+(1-\alpha)\,S_{\theta,i},\qquad \alpha=0.5\]

The IoU term supplies a dense, directional signal (any improvement of the box is rewarded) while the success term preserves the task objective (grounding only counts above IoU 0.5); equal weighting is the default in the experiments. This is also the decisive split from "just use a generic chain-of-thought": Qwen3-VL's own Thinking variants score 0.6/0.1/0.5 lower than the corresponding Instruct models on grounding, because a generic reasoning objective contains no term for "make the box more accurate". EGM aligns the whole reasoning process to grounding accuracy through a box-level reward, which is what turns reasoning into a working mechanism rather than extra noise.

Training then uses GRPO with a KL penalty and entropy regularization, the stated goal being "to let the model explore sufficiently during reasoning while avoiding pattern collapse". One curious detail is that the two families prefer opposite coefficients: the QwenVL series uses KL coefficient \(\beta=0.005\) and entropy coefficient \(\gamma=0\) (holding the policy back through KL), while the InternVL series uses \(\beta=0\) and \(\gamma=0.01\) (maintaining output diversity through entropy). The paper offers no explanation for this difference — ⚠️ refer to the original paper.

A Worked Example¶

Data construction. One sample in the RefCOCO training split shows several vases, with the referring expression vase with handle and the ground-truth box [730, 421, 885, 814] (⚠️ coordinates as printed in Figure 3 of the original). The proprietary VLM receives image, text and ground-truth box, and returns the reasoning "focus on the handle as the distinguishing feature: the vase on the right has a prominent handle, so it is the correct choice". That trace is paired with the original sample to form one SFT instance. At inference time the trained model sees only the image and the text and must reproduce a similar trace before emitting a box of the same format — the teacher's knowledge survives only in the how to think step.

RL sample selection. Suppose that on some sample the reference model InternVL-3.5-241B reaches IoU 0.7 (\(S_{\mathrm{ref}}=1\)) while the current learner reaches IoU 0.4 (\(S_\theta=0\)); then \(l_i=1>0\) and the sample enters \(D_{\text{learnable}}\). If on another sample the reference also reaches only 0.3, the sample is too hard or mislabelled and is discarded. An equal number of samples the learner already solves is then drawn uniformly into \(D_{\text{easy}}\), and the union forms the RL training set (the IoU values here are hypothetical, chosen to illustrate the selection rule).

Amodal reasoning. For "the tiger behind the fallen log on the right", the generated sequence is roughly: <think> the tiger is only partially visible on the right, the fallen log in front is causing the occlusion and hides the lower body; the complete shape of the tiger includes its full torso, legs and tail; extend downward from the visible part considerably, with little expansion needed in other directions </think><ref> the tiger behind the fallen log on the right </ref><box>[x1, y1, x2, y2]</box>. Compared with vanilla grounding, the reasoning simply carries three more segments: what occludes, what the full shape is, and in which direction to extend.

Loss & Training¶

The SFT stage uses the official InternVL-3 and Qwen3-VL training scripts, with learning rate \(1\times10^{-5}\), 1 epoch and batch size 128, on 8 A100 GPUs.

The RL stage is built on the VeRL framework, with all rollouts and inference served by the vLLM engine: learning rate \(3\times10^{-6}\), 5 epochs, batch size 256, and the reward weight \(\alpha\) fixed at 0.5. The QwenVL series uses KL coefficient \(\beta=0.005\) and entropy coefficient \(\gamma=0.0\); the InternVL series uses \(\beta=0.0\) and \(\gamma=0.01\). Both families share InternVL-3.5-241B as the reference model, each corresponding fine-tuned model serving as its own learner, and the final RL dataset size varies across models.

The optimization objective is GRPO with a token-level mean loss (in the style of DAPO): within each group of \(G\) sampled outputs for the same input, advantages are normalized to a sequence-level \(\hat{A}_i\), then divided by the sequence length \(|o_i|\) to obtain a token-level advantage \(\hat{A}_{i,t}\), on top of which a KL penalty and entropy regularization are added:

\[\hat{A}_i=\frac{r_i-\mathrm{mean}(\{r_j\}_{j=1}^{G})}{\mathrm{std}(\{r_j\}_{j=1}^{G})},\qquad \hat{A}_{i,t}=\hat{A}_i/|o_i|\]

⚠️ The complete GRPO objective in the paper's main text is corrupted in the PDF extraction; what is given here is its structure and the parts that can be confirmed — refer to the original paper for the exact form.

Key Experimental Results¶

Main Results¶

Table 1: Vanilla grounding on the eight RefCOCO splits (metric: [email protected]). Gains in the Qwen rows are relative to the same-size -Thinking model, those in the InternVL rows to the official baseline; entries marked * are from the official reports, all others were measured by the authors.

Model	Params	RefCOCO val	RefCOCO+ val	RefCOCOg val	8-split Avg.	Gain
Qwen3-VL-2B-Instruct	2B	88.7	80.1	84.8	84.2	—
Qwen3-VL-2B-Thinking	2B	87.5	80.2	84.4	83.6	−0.6
EGM-Qwen3-VL-2B	2B	93.0	87.8	88.6	89.6	+6.0
Qwen3-VL-4B-Thinking	4B	90.0	85.2	87.8	87.2	−0.1
EGM-Qwen3-VL-4B	4B	93.5	89.7	90.4	91.0	+3.8
Qwen3-VL-8B-Thinking	8B	91.0	86.2	87.6	87.8	−0.5
EGM-Qwen3-VL-8B w/o reasoning	8B	92.2	85.7	88.6	88.6	+0.8
EGM-Qwen3-VL-8B	8B	93.9	90.1	90.4	91.4	+3.6
Qwen3-VL-235B-A22B-Instruct	235B(A22B)	92.9	88.6	90.3	90.5	—
Qwen3-VL-235B-A22B-Thinking	235B(A22B)	92.9	89.5	90.4	90.7	—
InternVL-3-1B	1B	85.8	76.6	82.8	81.6*	—
EGM-InternVL-3-1B	1B	90.2	83.8	86.4	86.8	+5.2
InternVL-3-2B	2B	89.8	84.0	87.6	86.7*	—
EGM-InternVL-3-2B	2B	92.2	85.6	88.5	88.4	+1.7
InternVL-3-8B	8B	92.5	88.2	89.6	89.6*	—
EGM-InternVL-3-8B w/o reasoning	8B	91.3	85.7	87.3	87.7	−1.9
EGM-InternVL-3-8B	8B	93.6	89.3	89.7	90.7	+1.1
InternVL-3-78B	78B	93.4	90.1	91.5	91.4*	—
Gemini-2.5-Pro	—	66.8	58.2	65.0	63.8	—
Gemini-3-Pro	—	87.3	80.3	89.9	85.2	—
GPT-5	—	42.6	37.4	39.1	40.1	—

Table 2: Amodal grounding on the new benchmark generated from COCO-Amodal val/test (11,261 samples / 2,474 images). ⚠️ The original table does not state whether the baseline rows are Instruct or Thinking variants.

Model	Params	Original	+EGM	Gain
InternVL-3-1B	1B	56.9	64.3	+7.4
InternVL-3-2B	2B	63.8	70.2	+6.4
InternVL-3-8B	8B	62.0	73.5	+11.5
InternVL-3-78B	78B	51.0	—	—
Qwen3-VL-2B	2B	66.5	73.4	+6.9
Qwen3-VL-4B	4B	71.6	73.9	+2.3
Qwen3-VL-8B	8B	71.4	73.9	+2.5
Qwen3-VL-235B	235B	74.1	—	—
Gemini-2.5-Pro	—	52.3	—	—
Gemini-3-Pro	—	71.9	—	—
GPT-5	—	24.7	—	—

Ablation Study¶

Table 3: The necessity of the reasoning process. "w/o reasoning" means training with the same data and RL procedure but without reasoning traces in the training data.

Config	8-split Avg.	vs. baseline	Note
Qwen3-VL-8B-Instruct	88.3	—	same-size Instruct baseline
Qwen3-VL-8B-Thinking	87.8	−0.5	generic CoT brings no grounding gain
EGM-Qwen3-VL-8B w/o reasoning	88.6	+0.3 (vs Thinking)	data and RL only, no reasoning
EGM-Qwen3-VL-8B	91.4	+3.6 (vs Thinking)	full model; reasoning contributes +2.8
InternVL-3-8B	89.6*	—	official baseline
EGM-InternVL-3-8B w/o reasoning	87.7	−1.9 (vs baseline)	dropping reasoning falls below the baseline
EGM-InternVL-3-8B	90.7	+1.1 (vs baseline)	full model; reasoning contributes +3.0

Key Findings¶

Table 4: Hard-subset and efficiency analysis. The hard subset consists of the RefCOCO samples on which InternVL-3-8B fails due to COMPLEX-PROMPT (IoU < 0.5); the metric is the fraction solved again.

Dimension	Model	Metric	Result
Hard subset	InternVL-3-32B	Acc	29.9%
Hard subset	InternVL-3-78B	Acc	42.6%
Hard subset	Gemini-2.5-Flash	Acc	20.9%
Hard subset	Gemini-3-Pro	Acc	57.3%
Hard subset	EGM-InternVL-3-8B	Acc	42.7%
Efficiency	Qwen3-VL-235B-Instruct	Acc / latency	90.5 / 4320 ms
Efficiency	EGM-Qwen3-VL-8B	Acc / latency	91.4 / 737 ms (5.9x)

Reasoning is load-bearing, not decorative. Removing it drops Qwen3-VL-8B from 91.4 to 88.6 (−2.8) and InternVL-3-8B from 90.7 to 87.7 (−3.0), below the official baseline of 89.6 (−1.9). Training on the same data with the same RL procedure but without letting the model write reasoning not only fails to help, it can damage the grounding ability the model already had.
A generic chain-of-thought is not grounding reasoning. Qwen3-VL-2B/4B/8B-Thinking score −0.6/−0.1/−0.5 relative to the same-size Instruct models, so their built-in thinking yields nothing on grounding, whereas EGM scores +5.4/+3.7/+3.1 over Instruct and is faster than the Thinking variants. The difference is not whether there is reasoning, but whether that reasoning has been aligned by a box-level reward.
The gains concentrate on hard samples. On the COMPLEX-PROMPT subset built from InternVL-3-8B failures, EGM-InternVL-3-8B reaches 42.7%, level with the 78B model's 42.6% and still below Gemini-3-Pro's 57.3%; close to half of the cases it resolves (18.9% of the subset) started from IoU < 0.1, the hardest tier.
What is saved is accuracy-per-latency, not absolute latency. EGM-Qwen3-VL-8B reaches 91.4 in 737ms while 235B-Instruct needs 4320ms for 90.5, a 5.9x speedup; against 235B-Thinking the speedup is 18.9x (the absolute latency of that variant is not given in the main text, ⚠️ refer to the original). The 2B model (89.6) also beats 32B-Thinking, 8B-Instruct and 8B-Thinking. Note that against a same-size original 8B model EGM is slower, because it generates an entire reasoning trace — what it buys with that latency is accuracy close to 235B.
Amodal grounding shows an inverse scaling effect. InternVL-3-78B (51.0) is markedly worse than its 8B sibling (62.0), and Qwen3-VL-235B reaches only 74.1; EGM-Qwen3-VL-8B reaches 73.9 and EGM-InternVL-3-8B 73.5, essentially matching 235B. On a task that demands descriptive reasoning, parameter scale and grounding ability are not positively correlated, and reasoning training matters more.

Highlights & Insights¶

Diagnose first, prescribe second — turning "why are small models worse" into a verifiable empirical question. Rather than assuming "not enough parameters", the authors pin the gap to the language side with two pieces of evidence (the visual encoder is the same size across the family, plus a statistical attribution of failures), and every step of the method (SFT teaching reasoning, RL aligning it with a box-level reward) follows directly from that diagnosis. The pattern — attribute the failure mode, then target it — transfers to any "small model lags behind" setting.
Distill the process, not the answer. The teacher is worse than the student on the target benchmark (GPT-5 averages only 40.1), so distilling its outputs would only corrupt the student; using it to generate reasoning traces instead yields +5 to +6. This suggests a distillation route that works even when the teacher is weaker at the task: borrow only its language organization and relational decomposition, and let the student produce the answer.
"Many mid-quality tokens" beat "a few expensive tokens". That adding a reasoning trace to an 8B model makes end-to-end inference faster is the paper's most counter-intuitive result, and it holds because the comparison target is a 235B model whose per-token cost is far higher. For edge deployment, the conditions under which this trade-off holds (much cheaper per-token cost for the small model, plus access to process supervision) are worth remembering.
The learnability filter plus an equal-size easy set. A single quantity, \(l_i=S_{\mathrm{ref}}-S_\theta\), removes both the "too hard / mislabelled" and the "already learned" samples, and the equal-size easy set guards against overfitting. It needs nothing but a stronger reference model, so it ports directly to other RLVR data-construction pipelines such as math or code.
Validating generality on a new task setting. Instead of squeezing more points out of RefCOCO, the authors move the method to a task that previously had only segmentation annotations and no text-referring pairs (amodal grounding) and, along the way, contribute an 11,261-sample benchmark. Testing on a task with a completely different data shape is more convincing than swapping model families on the same benchmark.

Limitations & Future Work¶

No evaluation of whether general capabilities are preserved. The paper has no dedicated limitations section; the points below are the note author's. Every experiment measures grounding accuracy; nothing is reported on VQA, language understanding or general dialogue after the long-reasoning and grounding-only SFT/RL, and catastrophic forgetting is never discussed. The paper's central claim is that small models lack language understanding, yet it never goes back to check whether that understanding itself changed once grounding reasoning was added — a missing link in the argument.
Supervision depends on a proprietary VLM, limiting cost and reproducibility. All 575k vanilla reasoning traces are generated by closed models, with no reported generation cost, no specified teacher version, and no sensitivity analysis over teacher choice. The amodal branch verifies its generated descriptions, but the vanilla branch has no comparable trace-quality check.
Only the box is checked, never the reasoning. The reward consists solely of IoU and success, with no process reward, so a model can reach the right box through the wrong argument. The qualitative examples all show reasoning consistent with the box, but there is no quantitative measurement of reasoning correctness (for instance, human judgement of whether the trace actually points at the target).
The efficiency evaluation is narrow. Latency is measured only on L20 GPUs, as total GPU time from sending the prompt to receiving the complete answer, with no throughput, memory footprint or multi-concurrency numbers; the 5.9x figure is against 235B-Instruct rather than a same-size model, against which EGM is in fact slower. The amodal baselines are also not labelled Instruct/Thinking, so cross-row comparisons deserve caution.
The two datasets are very unbalanced. Vanilla has 575k samples and amodal only 24k, so amodal forgoes the RL sample selection (using the full set), and the method's advantage under data-rich conditions is never really exercised there; the modest +2.3/+2.5 gains may be capped by data volume.
Improvement directions: make reasoning length an adjustable budget (more reasoning on hard samples, direct boxes on easy ones) to cut average latency; add process rewards or reasoning-quality verification to suppress "right box, wrong reason"; add a capability-preservation evaluation, e.g. mixing general VQA data into SFT/RL or anchoring the base model with a KL constraint; and replace the reference model with a stronger open grounding model of the same family to remove the dependence on an extremely large model for data filtering.

vs the generic Thinking mode of Qwen3-VL-Thinking / InternVL: both reason before answering, but the generic thinking mode is trained on general data with a general reward that contains no term for "make the box more accurate", which is why it scores 0.1–0.6 below Instruct on RefCOCO; EGM realigns reasoning to grounding with proprietary-VLM traces and an IoU reward, gaining +3.1 to +5.4. The distinction is the source and the target of the reasoning supervision, not the presence of reasoning.
vs LISA / PaliGemma (mask output) and Molmo / Gemini Robotics-ER (point output): these works change the grounding output format, whereas this paper keeps the most common bounding-box format and focuses on the same box with a smaller model and lower latency. The contributions are therefore orthogonal — the reasoning distillation pipeline should in principle apply to masks or points as well.
vs DeepSeek-R1 / the GRPO family (DAPO, GTPO): this paper keeps the two-stage "SFT cold start + GRPO" recipe but replaces two of its defaults with task-specific versions — the reward mixes IoU with grounding success rather than a verifiable 0/1 answer, and the training samples are selected by learnability rather than used in full. The lesson for RLVR on perceptual tasks is that the algorithm is not the bottleneck; the reward and the data are.
vs conventional test-time scaling (multi-sample / self-consistency voting): those methods sample many answers in output space and aggregate them, whereas EGM has the model generate one structured reasoning trace and then a single answer, trading one forward pass for accuracy, and it couples test-time compute with small model size so the discussion moves from accuracy to accuracy-per-latency.

Rating¶

Novelty: ⭐⭐⭐⭐☆ The chain of "attribute the failure mode, then patch language understanding with reasoning" is well argued, and the method itself (SFT trace distillation plus a box-level GRPO reward) is a task-specific port of the R1 recipe — no component is wholly new, but the amodal grounding setting and the learnability recipe are genuine contributions.
Experimental Thoroughness: ⭐⭐⭐⭐☆ Coverage is broad — two model families, three sizes each, two tasks and an efficiency study — and the w/o-reasoning ablation and hard-subset analysis are to the point; it loses a star for the missing general-capability evaluation and the narrow efficiency metrics.
Writing Quality: ⭐⭐⭐⭐☆ The attribution experiment (three proprietary models' COMPLEX-PROMPT statistics plus the scaling trend) is clear and persuasive and the argument chain is complete, but the equations are badly typeset and some must be reconstructed by the reader.
Value: ⭐⭐⭐⭐⭐ An 8B model beating 235B on RefCOCO while running 5.9x faster end to end is a direct win for edge deployment and embodied scenarios, and the "small model reasons more, large model reasons less" efficiency argument has wider reference value.