Visual-ERM: Reward Modeling for Visual Equivalence

ArXiv: 2603.13224

🎯 Pitch

Teaching vision-language models to reproduce charts and tables via RL stumbles because existing rewards—text-based rules or coarse visual similarity—blindly miss fine-grained rendering errors. Visual-ERM solves this by training an 8B model to critique rendered outputs directly, boosting chart-to-code accuracy by +8.4 points while its interpretable feedback unlocks further gains through iterative self-correction.

---

1. Executive Summary

This paper proposes the Visual Equivalence Reward Model (Visual-ERM), a multimodal generative reward model that evaluates vision-to-code outputs by reasoning directly over rendered images rather than over text tokens or coarse embedding similarities, providing fine-grained, interpretable, and task-agnostic supervision across chart-to-code, table-to-markdown, and SVG-to-code tasks. Integrating Visual-ERM into GRPO-based reinforcement learning improves Qwen3-VL-8B-Instruct by +8.4 points on chart-to-code and yields consistent gains on table-to-markdown (+2.7) and SVG-to-code (+4.1), while its structured discrepancy descriptions further enable test-time scaling via iterative reflection and revision, adding an additional +3.1 on chart-to-code on top of the RL-tuned policy. On VisualCritic-RewardBench (a new benchmark of 1,335 instances for fine-grained image-to-image discrepancy judgment), Visual-ERM at 8B decisively outperforms Qwen3-VL-235B-Instruct (by +36.8 F1_ℎ) and approaches leading proprietary models, establishing that fine-grained visual reward supervision is both necessary and sufficient for vision-to-code RL, regardless of task specificity, and that reward-model specialization of a general-purpose LVLM can substitute for raw model scale.

2. Context and Motivation

The Core Problem: We Don't Have Reliable Reward Signals for Vision-to-Code RL

The fundamental question this paper tackles is deceptively simple: how do you teach a language model to reproduce structured visual inputs faithfully when supervised data is scarce, and you want to use reinforcement learning instead? This matters because vision-to-code tasks — converting charts into executable plotting code, tables into structured markdown, and vector graphics into SVG representations — are among the most practically important capabilities of modern LVLMs. They underpin document digitization, scientific figure reproduction, UI prototyping, and data extraction pipelines. Yet the standard approach to improving these capabilities, supervised fine-tuning (SFT), is data-intensive and generalizes poorly across tasks.

RL offers a natural alternative: let the model generate candidates, score them with a reward signal, and optimize toward higher-quality outputs. But RL is only as reliable as its reward. The central challenge this paper identifies is that existing reward paradigms for vision-to-code are fundamentally misaligned with what it means for a rendered output to be "correct." They either operate in the wrong modality (text), lack the granularity to detect element-level errors (coarse vision embeddings), or collapse all evidence into an opaque scalar that invites reward hacking. The paper frames this as a reward design problem: without a reward that is visual, fine-grained, interpretable, and task-agnostic, RL cannot reliably improve vision-to-code policies.

Why This Problem Matters

The importance of this gap extends beyond any single benchmark number. Vision-to-code is a compositional primitive: if a model can faithfully reproduce a chart from an image, it demonstrates joint capabilities in visual perception (detecting axes, legends, data encodings), structural reasoning (inferring the plotting commands needed to produce that visualization), and cross-modal translation (mapping pixels to code tokens). These capabilities transfer to related tasks such as scientific figure extraction, automated report generation from dashboards, and accessibility tools that convert visual data into structured text for screen readers.

More broadly, the reward misalignment problem the paper identifies is an instance of a deeper challenge in multimodal RL: correctness is often defined in the output modality, but rewards are computed in a different one. For vision-to-code, correctness lives in the rendered image (does the chart look right?), but the natural temptation is to score the generated code text directly — comparing token sequences with edit distance or tree-edit-distance similarity (TEDS). This is fast and easy, but as Section 2 demonstrates, it creates a dangerous proxy: the policy learns to maximize the text-based reward without improving visual fidelity, a classic case of reward hacking. The paper's analysis of this phenomenon is one of its most valuable contributions, because it articulates a failure mode that likely affects many multimodal generation tasks beyond vision-to-code.

Where Existing Approaches Fall Short

The paper presents a detailed analysis of two dominant reward families and shows that each violates at least two of the four properties a vision-to-code reward must satisfy.

Text-Based Rules Are Blind to Rendering

Metrics like TEDS (Tree-Edit-Distance Similarity), edit distance, F1 on extracted cell content, and attribute matching all operate exclusively on the predicted code or markup tokens, comparing them against a reference sequence. They never inspect the rendered image. The paper identifies two critical consequences of this blindness:

• Textually close predictions that render incorrectly receive near-perfect scores. Section 2 provides a concrete example (Figure 2, top-left): a table-to-markdown output achieves TEDS = 0.92 (indicating high structural similarity to the reference markup) but its rendered version exhibits both header-hierarchy errors (column relationships are wrong) and numeric-cell errors (cell values are mismatched). The reward signal is high, but the visual output is wrong. This is not a corner case — it is a predictable failure of any reward computed in the text modality when correctness is defined visually.

• Correct renderings achieved via different but equivalent code are penalized. Two different Matplotlib scripts can produce pixel-identical charts (e.g., using different APIs, different ordering of plotting commands, different parameterizations). Text-based rewards penalize these as errors, creating a perverse incentive for the policy to match the reference code style rather than the rendered output. This makes RL optimization inefficient: the policy wastes capacity learning irrelevant coding conventions instead of visual fidelity.

The deeper issue is that rendering is not injective — many code sequences map to the same visual output, and small code changes can produce large visual differences (e.g., swapping two arguments in a plotting call). Text-based rewards operate in a space where distance is poorly correlated with visual distance, making them unreliable supervisors for RL.

Vision-Encoder Similarities Are Coarse, Uninterpretable, and Invariant to the Wrong Things

The second family uses vision foundation models — DINO, CLIP, and similar architectures — to embed both the reference and rendered images and compute cosine similarity as the reward. This approach at least operates in the visual modality, but the paper identifies three fatal limitations:

• Wrong invariance for the task. DINO and CLIP are pre-trained to be invariant to transformations that preserve semantic content: translation, scaling, mild rotation, and local deformation. This invariance is desirable for object recognition (a dog is still a dog if it moves left) but catastrophic for vision-to-code, where a small spatial shift, a permuted bar order, or a swapped color mapping changes the underlying data being communicated. The paper's Figure 2 (bottom-left) illustrates this starkly: a chart with colorbar errors, incorrect bubble positioning, and y-axis labeling mistakes receives a DINO similarity score above 0.99 — near-perfect by the reward's standard, yet visually wrong. The model's semantic-level features are too coarse to respond to the element-level differences that matter for chart fidelity.

• No interpretability. Cosine similarity collapses all evidence about visual discrepancy into a single scalar. This gives the policy no signal about what to fix. If a chart has three errors (wrong axis label, missing legend entry, and incorrect bar height), both a version with all three errors and a version with only one error receive different scalars, but the policy cannot infer which aspects of its generation caused the improvement or degradation. This opacity makes RL optimization extremely sample-inefficient because the gradient through the reward model is diffuse — the policy has to guess which tokens to change, reinforcing spurious correlations rather than learning targeted improvements.

• Coarse granularity. DINO embeddings capture global appearance and semantic category but are insensitive to fine-grained structural details like axis tick mark alignment, legend bounding box placement, or font size consistency. These details are exactly what distinguishes a professional-quality figure from a sloppy one, and they matter enormously in downstream applications (scientific publishing, automated reporting, accessibility tools).

Consequences in RL: Reward Hacking and Performance Degradation

The paper doesn't just critique these rewards theoretically — it demonstrates their failure under actual RL training. Figure 2(a) shows RL training curves where the proxy reward score is plotted over training steps:

"The text-based and vision-based curves rise quickly and saturate, consistent with reward hacking: the policy maximizes the proxy without improving the rendered output. Optimizing against Visual-ERM keeps improving throughout training, suggesting that its supervision remains aligned with rendered-image fidelity."

The downstream impact is even more concerning (Figure 2b, c). When the resulting policies are evaluated on actual Chart-to-Code and Table-to-Markdown benchmarks:

"Policies trained with text-based or vision-based rewards do not consistently improve over the SFT baseline, and underperform it on Table-to-Markdown, indicating that the proxy gains in Fig. 2(a) are illusory."

This is the smoking gun: the RL training appears to work (reward increases), but the policy gets worse at the actual task. This is a classic Goodhart's Law scenario — when a measure becomes a target, it ceases to be a good measure. The text-based and vision-based rewards become targets that the policy optimizes through superficial or adversarial strategies (e.g., generating code that is syntactically similar to the reference but renders differently, or producing images that maximize DINO similarity while ignoring element-level errors).

The Four Properties That Any Vision-to-Code Reward Must Satisfy

The paper synthesizes its analysis into four necessary properties, drawn directly from the failure cases above:

1. Visual: the reward must operate in the rendered image space, not the text space. Text-only rewards are blind to rendering and create a modality gap between what is scored and what matters.

2. Fine-grained and locally sensitive: the reward must detect element-level errors (layout, axes, labels, numeric content) rather than relying on coarse global similarity that averages away critical differences. This is why DINO fails — it's tuned for semantic invariance, not local precision.

3. Interpretable: the reward must expose what went wrong and where, not just emit an opaque scalar. This is critical for two reasons: it prevents reward hacking (the policy can't easily exploit a transparent supervisor) and it enables downstream uses like test-time refinement (the policy can act on specific feedback).

4. Task-agnostic: the same reward model must work across charts, tables, and SVGs. These tasks share fundamental failure patterns (layout misalignment, text recognition errors, structural composition mistakes) that should be captured by a single model, avoiding the need to train and maintain task-specific verifiers.

Section 3 then instantiates these four properties in Visual-ERM, making the jump from diagnosis to solution.

How This Paper Positions Itself Relative to Existing Work

The paper enters a landscape where vision-to-code RL is an active but fragmented research area. Prior work falls into three categories, each with limitations that Visual-ERM aims to address:

Supervised fine-tuning approaches (ChartCoder, VinciCoder) train on large paired datasets of images and ground-truth code. These achieve strong in-domain performance but are data-hungry and generalize poorly to new chart styles, table formats, or SVG domains. The paper acknowledges SFT as the dominant paradigm but positions RL as a more scalable alternative if the reward problem can be solved.

Text-based RL for structured parsing (Table2LaTeX-RL, ChartMaster) attempts to use TEDS, edit distance, or related textual metrics as RL rewards. The paper directly engages with this work, showing through the analysis in Section 2 that text-based rewards are fundamentally unreliable because they operate in the wrong modality. The RL training curves and downstream performance drops in Figure 2 provide empirical evidence that prior text-based RL approaches are likely limited by reward misalignment rather than RL methodology.

Vision-encoder similarity rewards (DINO-based approaches in VinciCoder, ChartMaster, and other concurrent work) use visual foundation model embeddings as a reward signal. The paper's critique is nuanced: this approach is on the right track (operating in the visual modality) but uses the wrong tool (encoders trained for semantic invariance rather than reconstruction fidelity) and provides insufficient granularity (scalar output without localization). The experiments in Figure 2(a) and Table 1 show that DINO-based RL produces weaker policies than Visual-ERM-guided RL, and can even degrade performance on tasks where visual-textual alignment is critical (e.g., tables, where DINO features ignore precise text content).

Generative reward models for text generation (Arm-Thinker, InternLM-XComposer2.5-Reward) use LLMs to produce natural language critiques and judgments. These demonstrate the value of interpretable, fine-grained feedback but are developed for text-centric tasks and do not support visual-to-code evaluation. Visual-ERM extends this paradigm to the multimodal, vision-to-code setting, with the critical distinction that its judgments are grounded in rendered images rather than text alone.

The paper's positioning is that all prior reward paradigms for vision-to-code miss the mark because they fail to directly optimize what matters — visual equivalence in the rendered output space. By training a specialized reward model on discrepancy-annotated image pairs, Visual-ERM bridges the gap between text-based rules (which are blind to rendering) and vision-encoder similarities (which are semantically invariant and uninterpretable), providing a reward that is simultaneously visual, fine-grained, interpretable, and task-agnostic.

The Connection to Test-Time Scaling

A secondary motivation — one that the paper explores in Section 4.3 rather than foregrounding in the problem statement — is that interpretable reward signals unlock test-time scaling via iterative reflection and revision. If a reward model can localize what went wrong (not just how wrong it is), the policy can condition on that feedback and revise its output, creating an inference-time improvement loop that compounds the gains from RL training alone. This connects to broader trends in the field (Self-Refine, Reflexion) where models critique and improve their own outputs, but with the crucial difference that Visual-ERM provides a dedicated, trained critic rather than relying on the policy's own unreliable self-assessment. The paper shows (Table 4) that this reflection loop adds +3.1 points on top of the already RL-tuned policy, demonstrating that interpretable rewards have value beyond the training phase.

The Broader Significance: Rewards as a Bottleneck in Multimodal RL

At the highest level, the paper is making a case about what holds back RL for multimodal generation tasks. The bottleneck is not the policy architecture (standard LVLMs suffice), the RL algorithm (GRPO works), or the training data (moderate amounts of task data are enough). The bottleneck is the reward model — its modality alignment, its granularity, and its interpretability. By carefully analyzing why existing rewards fail and designing a reward model that addresses each failure mode, the paper demonstrates that RL can unlock substantial gains over SFT baselines even without additional task-specific data. This is a transferable insight: for any multimodal task where correctness is defined in one modality but rewards are usually computed in another, the methodology of training a cross-modal generative reward model on discrepancy-annotated pairs could apply. The paper's release of VC-RewardBench, a benchmark for evaluating image-to-image discrepancy judgment, provides a concrete foundation for this broader research direction.

3. Technical Approach

3.1 Reader orientation

Visual-ERM is a single multimodal language model that has been fine-tuned to serve as a visual critic — given a reference image and a rendered prediction, it outputs a structured, fine-grained list of everything that is visually wrong, along with severity scores for each error. The paper builds a complete training and deployment pipeline around this critic, converting its structured judgments into a scalar reward for reinforcement learning and reusing its natural-language discrepancy descriptions as feedback for test-time refinement, solving the problem that existing rewards either operate in the wrong modality (text), lack the granularity to detect element-level errors, or collapse all evidence into an opaque scalar that invites reward hacking.

3.2 Big-picture architecture (diagram in words)

The system has five major components connected in a pipeline:

1. Training data generator — takes in reference images and ground-truth structured outputs (code or markup) from public vision-to-code datasets, then synthesizes realistic prediction errors through two complementary routes (targeted perturbation by strong LVLMs, and natural inference from a weaker policy model), renders the erroneous predictions back to images, and obtains fine-grained discrepancy annotations from a strong proprietary teacher (GPT-5-mini), producing a supervised training set $`\mathcal{D}_{\text{reward}}`$ of $`514\text{K}`$ image-pair-and-annotation triples.

2. Visual-ERM (the reward model proper) — a Qwen3-VL-8B-Instruct backbone fine-tuned via next-token prediction on $`\mathcal{D}_{\text{reward}}`$ to take an image pair $`(x, \hat{y}_{\text{img}})`$ as input and autoregressively generate a structured JSON discrepancy list $`a = \{(\text{category}, \text{severity}, \text{location}, \text{description})_k\}_{k=1}^K`$, encoding exactly what is visually different between the reference and the prediction.

3. RL reward pipeline — at deployment during RL training, each rollout from the policy renders its prediction $`\hat{y}_{\text{img}}`$, queries Visual-ERM to obtain the discrepancy set $`\mathcal{E}`$ with per-error severities $`s_k`$, sums the severities into $`S_{\text{verm}}`$, normalizes within the training batch, converts to a bounded reward $`r_{\text{verm}} \in [0, 1]`$, adds a render-success term $`r_{\text{rsr}}`$, and feeds the combined reward into the GRPO policy gradient.

4. Test-time scaling loop — at inference (without weight updates), the policy generates a candidate $`y^{(0)}`$, Visual-ERM scores and critiques it with a structured discrepancy description $`f^{(0)}`$, and if the reward is below a threshold, the policy conditions on its previous output and the critique to produce a revised candidate $`y^{(t+1)}`$, repeating for up to $`T`$ rounds.

5. VC-RewardBench — a separate evaluation-only benchmark of $`1{,}335`$ carefully curated image pairs with ground-truth discrepancy annotations, used to evaluate the reward model's judging accuracy independent of downstream RL performance, with an LLM-as-Judge protocol for computing precision, recall, F1 scores, and Pearson correlation for severity scoring.

Information flows as follows: public datasets → error synthesis → GPT-5-mini annotation → $`\mathcal{D}_{\text{reward}}`$ → supervised fine-tuning → Visual-ERM. Then, during RL: policy generates code → renderer produces image → Visual-ERM produces discrepancy list → severity aggregation + normalization → scalar reward → GRPO update. During test-time scaling: the same Visual-ERM output is additionally used as natural-language feedback fed back into the policy's context for iterative revision.

3.3 Roadmap for the deep dive

• First, the training data construction pipeline (Section 3.1 in the paper), because the quality and coverage of $`\mathcal{D}_{\text{reward}}`$ determines everything downstream — we need to understand how error-injected and naturally-inferred image pairs are created, why two complementary sources are necessary, and how the structured discrepancy annotations are obtained.
• Second, the supervised fine-tuning objective for Visual-ERM, explaining the autoregressive generation formulation, why a single model is trained on all tasks jointly, and the specific token-level loss.
• Third, the RL reward pipeline (Section 3.2), walking through exactly how a structured discrepancy list becomes a scalar reward suitable for policy gradient methods — the severity sum, batch normalization, clipping, and combination with the render-success term — and why these specific transformations are chosen.
• Fourth, the GRPO optimization objective (Equation 6), which combines the Visual-ERM-derived reward with a KL anchor to prevent policy collapse — this is where the reward is actually consumed.
• Fifth, the test-time scaling mechanism (Section 3.3), showing how the same Visual-ERM outputs are repurposed as interpretable natural-language feedback for iterative self-refinement without additional training.
• Sixth, the VC-RewardBench construction and evaluation protocol (Section 3.4), since this benchmark is the diagnostic tool that validates Visual-ERM's judging capability independently of downstream RL performance.

3.4 Detailed, sentence-based technical breakdown

This is primarily a systems and methods paper whose core idea is that a specialized generative reward model trained on discrepancy-annotated image pairs can provide aligned, fine-grained, and interpretable supervision for vision-to-code RL, outperforming both text-based rules and vision-encoder similarities that each violate essential properties of a good reward.

---

3.4.1 Training Data Construction: Image-Pair Generation and Discrepancy Annotation

The training data for Visual-ERM is the linchpin of the entire approach, because the reward model can only learn to detect and describe the kinds of discrepancies it has been trained on. The paper constructs $`\mathcal{D}_{\text{reward}}`$ in three stages: sourcing base images and ground-truth structured outputs, synthesizing realistic erroneous predictions through two complementary strategies, and annotating each reference–prediction pair with fine-grained structured discrepancy descriptions distilled from a stronger proprietary model.

Why existing datasets are not directly usable. Public vision-to-code datasets (such as ChartCoder, ChartMimic, UniSVG, and various table-parsing benchmarks; see Appendix A.2) provide paired sets of $`(x, y^\star)`$ where $`x`$ is a rendered reference image and $`y^\star`$ is the corresponding ground-truth code or markup. However, these pairs do not directly provide supervision for a reward model, because Visual-ERM needs to learn from image-to-image comparisons with known discrepancies, not from input-output examples. That is, the training signal must come from pairs $`(x, \hat{y}_{\text{img}})`$ where $`\hat{y}_{\text{img}}`$ is a rendered prediction that deviates from $`x`$ in known ways, accompanied by a structured description of those deviations. The paper therefore builds such pairs from scratch, using the ground-truth $`y^\star`$ as a starting point for error synthesis.

Image-pair construction via two complementary routes. The central design choice in the data generation pipeline is that errors must be produced through two different mechanisms to ensure the training distribution matches what a downstream policy actually emits during RL rollouts:

• Targeted Edit (systematic coverage): starting from the ground-truth structured output $`y^\star`$, a strong but cost-effective LVLM perturbs $`y^\star`$ to inject errors according to a pre-defined taxonomy of failure modes. For charts, this taxonomy includes structure_error (wrong chart type, wrong number of subplots, incorrect subplot arrangement), data_error (geometry mismatches, value distortions, scale/axis limit errors, missing or extra data series), text_error (missing or incorrect titles, axis labels, tick labels, legend entries, text positioning and readability issues), and style_error (color palette mismatches, line style and marker differences, grid and background inconsistencies). The full taxonomy and prompting instructions are shown in Figures 7 and 8 of the paper. This route provides systematic coverage — the reward model sees the full space of possible failure types, including edge cases that may occur rarely but are catastrophic when they do.

• Natural Inference (empirical realism): a weaker LVLM (specifically Qwen3-VL-8B-Instruct, the same base model that will later serve as the RL policy) directly predicts $`y`$ from the reference image $`x`$ without any ground-truth conditioning. The resulting errors therefore match the distribution of mistakes that the RL policy actually produces during rollout — they are not designed or injected, but arise organically from the model's limitations. The paper argues this is critical because the reward model must be calibrated to evaluate the outputs the policy generates in practice, not just synthetically perturbed versions.

Each candidate prediction $`y`$ from either route is rendered using the appropriate task-specific renderer $`\mathcal{R}_m(\cdot)`$, where $`m \in \{\text{Chart}, \text{Table}, \text{SVG}\}`$, to produce $`\hat{y}_{\text{img}}`$. The pair $`(x, \hat{y}_{\text{img}})`$ becomes the visual input to the annotation stage. For charts, the renderer executes the generated Matplotlib code and saves the resulting figure; for tables, the renderer converts the generated Markdown into a rendered table image; for SVGs, the renderer rasterizes the vector graphics to a pixel image.

The paper emphasizes that both routes are necessary and complementary. Targeted edits ensure the training set includes rare but severe structural errors that a weak model might never produce naturally (yet are possible in principle). Natural inferences ensure the training set is not dominated by the particular error patterns of the perturbation model, which could create a distribution shift between training and deployment.

Scale of the training corpus. The resulting reward-modeling datasets contain:

• $`104\text{K}`$ instances for Chart-to-Code,
• $`125\text{K}`$ instances for Table-to-Markdown,
• $`111\text{K}`$ instances for SVG-to-Code.

The total of $`514\text{K}`$ annotated image pairs is reported in Appendix A.1 and represents a substantial but not extraordinary training set — the key insight is that the annotations, not the raw data volume, provide the value, since each instance carries detailed structured feedback rather than just a scalar score or binary label.

Fine-grained discrepancy annotation via teacher distillation. For every image pair $`(x, \hat{y}_{\text{img}})`$, the paper needs a structured annotation $`a = \{(\text{category}, \text{severity}, \text{location}, \text{description})_k\}_{k=1}^K`$ that localizes each visual discrepancy and grades its impact. A critical empirical finding is that even large open-source LVLMs cannot produce such annotations reliably out of the box. Specifically, Appendix A.1 notes that Qwen3-VL-8B-Instruct (the base model) "is not a reliable image-to-image discrepancy judge... especially for structured visuals where the key differences are often text- and layout-centric." Section 4.2 quantifies this: Qwen3-VL-235B-Instruct — a model roughly $`29\times`$ larger — achieves only $`\text{F1}_h = 29.5`$ on VC-RewardBench, confirming that scale alone does not confer fine-grained discrepancy detection ability.

The paper therefore uses GPT-5-mini as a bootstrap teacher that proposes candidate discrepancies for each image pair. The distillation prompt (provided in full in Figures 7 and 8, Appendix C.1) is extensive and task-specific. For charts (Figures 7–8), it:

• Frames the model as an "experienced specialist for data visualization,"
• Instructs it to compare the Generated Image against the Original Image purely visually (not by inspecting code),
• Defines four error categories with detailed typical case descriptions,
• Defines three severity levels (1 = Minor: purely aesthetic or very small differences; 2 = Moderate: affects readability or requires correction for confident use; 3 = Critical: factually wrong, structurally broken, or seriously misleading),
• Requires strict JSON output with per-category error counts and per-error structured fields,
• Specifies that zero errors must be reported when images are visually consistent.

Analogous prompts exist for tables (Figure 10, Appendix C.2) with layout_error, text_error, and numeric_error categories, and for SVGs (Figure 11, Appendix C.2) with structure_error, shape_error, style_error, and text_symbol_error categories.

Quality control on teacher annotations. The paper implements two filtering mechanisms to ensure annotation reliability:

• Rendering-consistency checks: any proposed discrepancy that refers to regions, elements, or features absent in $`\hat{y}_{\text{img}}`$ is discarded. This prevents the teacher from hallucinating errors that are not actually visible in the rendered prediction.

• Structural agreement with ground-truth code $`y^\star`$: proposed discrepancies are cross-referenced against the structural properties of the ground-truth code. For instance, if a teacher claims a particular axis label is missing but $`y^\star`$ does not contain that label either (the reference chart doesn't have it), the proposed error is discarded as a false positive introduced by the annotation process.

The filtered annotations form the supervised targets for Visual-ERM training. The paper explicitly notes that "GPT-5-mini is used only to label the training set $`\mathcal{D}_{\text{reward}}`$ and plays no role at evaluation time," and that "any residual annotator bias in $`\mathcal{D}_{\text{reward}}`$ is bounded by Visual-ERM's downstream RL gains (Sec. 4.1), which are measured on benchmarks independent of the training labels." This is an important methodological point: the teacher is a tool for scalable data creation, not an evaluation oracle, and the ultimate validation comes from whether the resulting reward model improves downstream task performance on held-out benchmarks.

What the annotations look like in practice. Appendix D provides concrete examples from VC-RewardBench (which follows the same annotation format). Figure 13 shows chart cases where annotations capture multiple error types simultaneously: a high-severity data_error for mismatched bar magnitudes, a style_error for incorrect color mapping, and a text_error for unexpected axis labels. Figure 14 shows table cases with OCR-style text_errors on header strings, numeric_errors for punctuation or symbol substitutions (comma vs. dot, letter O vs. digit 0), and a high-severity layout_error for a swapped column. Figure 15 shows SVG cases with structure_errors for extra inner borders and hallucinated protrusions, and shape_errors for altered glyph geometry and spacing. Across all examples, each error includes a specific location field (e.g., "Left subplot title," "Legend," "Train Wheel," "Canvas Background") and a severity score that captures the functional impact, not just the visual magnitude.

---

3.4.2 Visual-ERM Training: Objective and Model

Given the training dataset $`\mathcal{D}_{\text{reward}} = \{(m, x, \hat{y}_{\text{img}}, a)\}`$ constructed above, the paper trains Visual-ERM as an autoregressive conditional generator that maps from the concatenation of the reference image and the rendered prediction image to the structured discrepancy annotation.

Model architecture. Visual-ERM is built on top of Qwen3-VL-8B-Instruct, a general-purpose multimodal LVLM with 8 billion parameters. The choice of base model is pragmatic: Qwen3-VL-8B-Instruct already possesses strong multimodal perception and reasoning abilities (as demonstrated by its performance on general VQA benchmarks in Table 7), and the 8B scale provides a favorable tradeoff between judging capability and inference cost during RL training (see Appendix A.5 for computational efficiency analysis, where Visual-ERM at 8B achieves lower per-step latency than a 0.3B DINO-based reward model).

Autoregressive generation formulation. Visual-ERM is formulated as a conditional generator $`f_{\theta_{\text{ERM}}}(a \mid x, \hat{y}_{\text{img}})`$ that takes the reference image $`x`$ and the rendered prediction $`\hat{y}_{\text{img}}`$ as visual inputs and produces the structured discrepancy list $`a`$ as a sequence of tokens. The training objective is the standard negative log-likelihood:

$\mathcal{L}(\theta_{\text{ERM}}) = \mathbb{E}_{(m, x, \hat{y}_{\text{img}}, a) \sim \mathcal{D}_{\text{reward}}} \left[ -\log f_{\theta_{\text{ERM}}}(a \mid x, \hat{y}_{\text{img}}) \right]$

where $`(m, x, \hat{y}_{\text{img}}, a)`$ is a training triple from the reward dataset (with $`m`$ being the task identifier), $`f_{\theta_{\text{ERM}}}`$ is the Visual-ERM model parameterized by $`\theta_{\text{ERM}}`$, and the expectation is taken over the training distribution.

What it computes: the model receives two images — the reference $`x`$ and the rendered prediction $`\hat{y}_{\text{img}}`$ — and must autoregressively generate the structured annotation $`a`$. The loss is the negative log-probability assigned by the model to the ground-truth annotation token sequence, averaged over the training corpus. Lower loss means the model is more likely to produce annotations that match the teacher's labels.

Why this form: negative log-likelihood is the standard objective for supervised fine-tuning of autoregressive language models. It directly trains the model to reproduce the teacher's annotation style and content. The paper does not use reinforcement learning or preference-based training for the reward model itself — the annotation quality from GPT-5-mini (after filtering) is treated as ground truth, and the task is pure imitation.

Token-level expansion. For an annotation sequence $`a = (a_1, a_2, \ldots, a_T)`$ consisting of $`T`$ tokens, the objective expands to the standard autoregressive form:

$\mathcal{L}(\theta_{\text{ERM}}) = \mathbb{E}_{(m, x, \hat{y}_{\text{img}}, a)} \left[ -\sum_{t=1}^{T} \log f_{\theta_{\text{ERM}}}(a_t \mid x, \hat{y}_{\text{img}}, a_{<t}) \right]$

where $`a_{<t} = (a_1, \ldots, a_{t-1})`$ is the prefix of already-generated tokens, and $`f_{\theta_{\text{ERM}}}(a_t \mid x, \hat{y}_{\text{img}}, a_{<t})`$ is the model's predicted probability for token $`a_t`$ given the two images and the preceding context.

What it computes: at each token position $`t`$, the model predicts the next token in the annotation sequence conditioned on both images and all previously generated tokens. The total loss is the sum (across all positions $`t`$) of the negative log-probability of the correct token $`a_t`$, averaged over training examples.

Why this form: autoregressive decomposition is universal for transformer-based language models and allows the model to learn the structured JSON output format through standard next-token prediction. The conditioning on both images means the model learns to attend to visual differences between the two inputs while generating the text description — this is the cross-modal grounding that the paper argues is essential for detecting fine-grained aesthetic and textual errors (in contrast to DINO-based rewards that collapse visual evidence into a single embedding before comparison).

Training hyperparameters. Appendix A.4 reports:

• Learning rate: $`1 \times 10^{-5}`$,
• Batch size: 32,
• Training epochs: 3 over the entire $`514\text{K}`$-instance reward-modeling dataset,
• Implementation framework: LLaMA-Factory.

The paper does not report a learning rate schedule, warmup, weight decay, or optimizer choice (presumably AdamW following LLM fine-tuning conventions, but this is not explicitly stated).

Multi-task joint training. A single $`f_{\theta_{\text{ERM}}}`$ is trained on all three tasks ($`m \in \{\text{Chart}, \text{Table}, \text{SVG}\}`$) simultaneously. The paper argues this supports the "task-agnostic" property because the model learns to detect shared failure patterns (e.g., layout misalignment, text recognition errors) that recur across domains. This choice is empirically validated in Section B.2.1 (Table 8): the mixed-data reward model achieves an average $`\text{F1}_h = 42.1`$ across all tasks, while single-task models (e.g., Chart-Data-Only) perform well on their own domain ($`\text{F1}_h = 40.1`$ on Chart) but generalize poorly to others ($`\text{F1}_h = 17.2`$ on Table, $`11.3`$ on SVG), indicating that joint training provides positive transfer rather than negative interference.

What the trained model produces at inference. When deployed, Visual-ERM takes in the pair $`(x, \hat{y}_{\text{img}})`$ and generates a structured JSON object containing:

• Per-category error counts (e.g., "structure_error_count": 1, "data_error_count": 2),
• A list of error objects, each with:
  • category: one of the task-specific error types,
  • severity: an integer $`s_k \in \{1, 2, 3\}`$,
  • location: a human-readable string localizing the error (e.g., "Left subplot title", "Legend", "Row 'Landau'"),
  • description: a concise natural-language explanation of what is wrong.

The full inference prompts for each task are provided in Figures 9, 10, and 11 of Appendix C.2. These prompts are deliberately lightweight because Visual-ERM has been fine-tuned to produce the structured output without extensive in-context instruction — they primarily specify the comparison setup and enforce the JSON schema, relying on the model's learned behavior to produce the actual judgments.

---

3.4.3 From Structured Discrepancies to Scalar Reward

The core engineering challenge in this section is mapping Visual-ERM's rich structured output (a list of errors with categories, severities, locations, and descriptions) into a single scalar reward that is suitable for policy gradient methods like GRPO, while preserving the alignment between reward magnitude and visual fidelity that the paper's analysis in Section 2 showed is missing from existing approaches.

Step 1: Querying Visual-ERM at each rollout. During RL training, the policy $`\pi_\theta`$ takes the reference image $`x`$ as input and generates a structured text prediction $`y \sim \pi_\theta(\cdot \mid x)`$. This prediction is rendered:

$\hat{y}_{\text{img}} = \mathcal{R}_m(y)$

where $`\mathcal{R}_m`$ is the task-specific renderer (Matplotlib execution for charts, Markdown-to-image conversion for tables, SVG rasterization for vector graphics). Visual-ERM is then queried on the pair $`(x, \hat{y}_{\text{img}})`$ to obtain:

$\mathcal{E} = \{e_k\}_{k=1}^K$

where each $`e_k`$ contains a severity score $`s_k \geq 0`$ (the integer values 1, 2, or 3 from the annotation taxonomy).

Step 2: Severity aggregation into a total penalty score. The paper first sums the individual severities across all detected errors:

$S_{\text{verm}} = \sum_{k=1}^{K} s_k$

where $`S_{\text{verm}} \geq 0`$ is the raw total severity for this rollout, $`K`$ is the number of errors detected, and $`s_k \in \{1, 2, 3\}`$ is the severity of the $`k`$-th error.

What it computes: $`S_{\text{verm}}`$ is an unnormalized penalty — a higher value means more and/or more severe visual discrepancies. If the rendered prediction perfectly matches the reference image, $`K = 0`$ and $`S_{\text{verm}} = 0`$. If there are many critical errors, $`S_{\text{verm}}`$ can be large (theoretically unbounded, though in practice limited by the finite number of detectable errors in a single image pair).

Why sum rather than mean or max: the sum preserves the additive nature of errors — two critical errors should produce a larger penalty than one, and a combination of minor and critical errors should produce a penalty that reflects both their number and their individual severities. Using the mean would make the reward insensitive to the total number of errors (ten minor errors and one critical error could have the same mean severity), while using the max would ignore additional errors beyond the worst one (a prediction with one critical error and nine moderate errors would receive the same max-based penalty as a prediction with only the one critical error).

Step 3: Batch-relative normalization. The raw sum $`S_{\text{verm}}`$ is not directly usable as a reward because its absolute magnitude varies significantly across different questions — an easy chart may have a maximum possible severity of 3 (one minor text error), while a complex multi-subplot figure could accumulate dozens of errors. The paper normalizes within each training batch:

$\tilde{S}_{\text{verm}} = \frac{S_{\text{verm}}}{\max_{j \in \mathcal{T}} S_{\text{verm}}^{(j)} + \epsilon}$

where $`\mathcal{T}`$ is the set of rollouts in the current training batch, $`S_{\text{verm}}^{(j)}`$ is the severity sum for the $`j`$-th rollout in the batch, and $`\epsilon > 0`$ is a small constant preventing division by zero.

What it computes: $`\tilde{S}_{\text{verm}} \in [0, 1]`$ is the normalized penalty, where $`\tilde{S}_{\text{verm}} = 0`$ corresponds to a perfect prediction (zero errors) and $`\tilde{S}_{\text{verm}} \approx 1`$ corresponds to the worst prediction in the batch.

Why batch-relative normalization over global normalization: RL training batches typically contain rollouts for different questions. Within a single batch, relative normalization ensures that the reward signal has good contrast — the best rollout gets low penalty and the worst gets high penalty, regardless of how inherently difficult the questions in that batch are. Global normalization (e.g., dividing by a fixed maximum severity) would make the reward signal for easy questions very compressed (most rollouts would be near-perfect) and the reward for hard questions very compressed (most would be near the maximum), reducing the policy gradient's ability to discriminate between good and bad rollouts within each batch.

Step 4: Conversion to a bounded reward. The normalized penalty is inverted and clipped to produce a reward in the standard $`[0, 1]`$ range:

$r_{\text{verm}} = \text{clip}(1 - \tilde{S}_{\text{verm}}, 0, 1)$

where $`\text{clip}(\cdot, 0, 1)`$ ensures the reward stays within $`[0, 1]`$ even if $`\tilde{S}_{\text{verm}} > 1`$ (which could happen if a rollout has severity exceeding the batch maximum due to the $`\epsilon`$ term).

What it computes: $`r_{\text{verm}} \in [0, 1]`$ is the visual fidelity reward, where $`r_{\text{verm}} = 1`$ means perfect visual equivalence (no detected errors) and $`r_{\text{verm}} = 0`$ means the worst visual fidelity in the batch (or worse). Intermediate values reflect proportional visual quality relative to the batch's best and worst outputs.

Why the $`1 - \tilde{S}_{\text{verm}}`$ inversion: reward maximization frameworks (like GRPO) expect higher rewards to be better, but $`S_{\text{verm}}`$ is a penalty (higher is worse). The inversion converts the penalty into a reward while preserving relative ordering.

Step 5: Combining with a render-success reward. The paper introduces an auxiliary reward term to handle a practical failure mode: during early RL training, the policy may generate code or markup that cannot be rendered at all (e.g., Matplotlib code with syntax errors, or malformed Markdown that the renderer cannot process). Such outputs would produce no rendered image, making $`S_{\text{verm}}`$ undefined. The paper addresses this with a binary render-success reward:

$r_{\text{rsr}} = \begin{cases} 1 & \text{if } \mathcal{R}_m(y) \text{ succeeds} \\ 0 & \text{otherwise} \end{cases}$

and the overall RL reward is:

$r = r_{\text{rsr}} + r_{\text{verm}}$

where $`r \in [0, 2]`$ is the combined reward for a single rollout.

What it computes: $`r`$ is the total reward. A perfectly faithful renderable output receives $`r = 1 + 1 = 2`$. An unrenderable output receives $`r = 0 + 0 = 0`$ (assuming $`r_{\text{verm}}`$ defaults to 0 when no image is available — the paper is not explicit about this edge case but the implication is clear from the ablation in Section B.4). A renderable but imperfect output receives $`r = 1 + r_{\text{verm}}`$, where $`r_{\text{verm}} \in [0, 1]`$.

Why the additive combination: the render-success term acts as a hard gate. The paper notes in Appendix B.4 (Table 11) that "during the initial stages of training, the model occasionally produces code that cannot be successfully rendered, leading to intermittent zero rewards. However, the policy rapidly learns to navigate these formatting constraints, allowing the optimization focus to transition quickly from basic renderability to the primary objective of preserving fine-grained visual characteristics." The additive design means that renderability provides a base reward of 1, with visual fidelity providing an additional 0–1 on top, ensuring that the policy is never punished for producing a renderable output (even if imperfect) compared to an unrenderable one — it always receives at least 1 for renderability. Table 11 shows that including $`r_{\text{rsr}}`$ yields slightly better downstream performance than omitting it, which the paper attributes to improved training stability rather than changes in the optimal policy.

---

3.4.4 GRPO Policy Optimization with the Visual-ERM Reward

The reward $`r`$ from the previous section is consumed by a Group Relative Policy Optimization (GRPO) algorithm, a variant of policy gradient methods that uses within-group relative comparisons rather than absolute value estimates.

The full optimization objective from Equation 6 in the paper:

$\max_\theta \mathbb{E}_{x \sim \mathcal{D}} \left[ \mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)} \left[ r_{\text{rsr}}(\mathcal{R}_m(y)) + \text{clip}\left(1 - \tilde{S}_{\text{verm}}(x, \mathcal{R}_m(y)), 0, 1\right) \right] - \beta \cdot \text{KL}(\pi_\theta(\cdot \mid x) \parallel \pi_{\text{ref}}(\cdot \mid x)) \right]$

where $`x \sim \mathcal{D}`$ are reference images sampled from the RL training distribution, $`y \sim \pi_\theta(\cdot \mid x)`$ is a generated output from the current policy, $`\mathcal{R}_m(y)`$ renders the output, $`r_{\text{rsr}}`$ is the binary render-success indicator, $`\tilde{S}_{\text{verm}}`$ is the batch-normalized Visual-ERM severity as defined in Equation 3, $`\pi_{\text{ref}}`$ is a frozen reference policy (typically the SFT starting point), $`\text{KL}(\cdot \parallel \cdot)`$ is the Kullback-Leibler divergence measuring how much the current policy has drifted from the reference, and $`\beta > 0`$ controls the strength of KL regularization.

What it computes: this is a constrained policy optimization problem. The outer expectation is over the training distribution of reference images. For each image, the policy samples outputs $`y`$. The reward term inside the expectation is exactly the combined reward $`r = r_{\text{rsr}} + r_{\text{verm}}`$ from Section 3.4.3. The KL penalty term $`\beta \cdot \text{KL}(\pi_\theta \parallel \pi_{\text{ref}})`$ is subtracted, meaning the policy is penalized for deviating too far from the reference policy's output distribution. The optimization maximizes the expected reward minus the KL penalty.

Why this form: this is a standard GRPO-style objective adapted for the Visual-ERM reward. The key elements are:

• Group-relative comparison: GRPO compares rollouts within the same batch (the $`\max_{j \in \mathcal{T}} S_{\text{verm}}^{(j)}`$ in the $`\tilde{S}_{\text{verm}}`$ normalization implicitly performs this comparison), which provides a natural baseline without needing a separately estimated value function. This is why $`\tilde{S}_{\text{verm}}`$ is batch-normalized rather than globally normalized — the relative comparison within the batch is what drives the policy gradient.

• KL regularization: the $`\beta \cdot \text{KL}(\pi_\theta \parallel \pi_{\text{ref}})`$ term prevents policy collapse, a common failure mode in RL fine-tuning where the policy overfits to the reward signal and loses its general language capabilities. By anchoring the policy to a frozen reference (the SFT checkpoint), the KL penalty ensures that optimization improves visual fidelity without catastrophically degrading the model's base capabilities. The paper validates this in Appendix B.1 (Table 7), showing that Visual-ERM-guided RL does not degrade general VQA performance (average score remains 78.3 → 78.4 for Chart RL, 78.3 → 78.1 for Table RL, 78.3 → 78.5 for SVG RL).

• Render-success gating: the $`r_{\text{rsr}}`$ term ensures the policy first learns to produce syntactically valid code/markup before optimizing visual fidelity. Without this term, the Visual-ERM reward would be undefined for unrenderable outputs, causing dead gradients.

RL training hyperparameters. Appendix A.4 reports:

• Learning rate: $`1 \times 10^{-6}`$,
• Batch size: 256 prompts,
• Rollouts per prompt per GRPO update: 8,
• Implementation framework: VERL.

The paper does not report the KL penalty coefficient $`\beta`$, the number of training steps, or the exact GRPO algorithm variant (e.g., whether it uses PPO-style clipping), but these are implied to follow standard practice by the citation to Shao et al. (2024) for the GRPO reference.

RL training data. Appendix A.2 reports that RL training uses only reference images (ground-truth code/markup is not needed during training, since Visual-ERM scores the rendered prediction directly against the reference image):

• $`11\text{K}`$ images for Chart-to-Code RL,
• $`40\text{K}`$ images for Table-to-Markdown RL,
• $`10\text{K}`$ images for SVG-to-Code RL.

This is notably smaller than the reward-model training set ($`514\text{K}`$ annotated pairs), which reflects the fact that RL policy optimization requires rollouts from the current policy (expensive) rather than pre-computed annotations, and that moderate amounts of prompt data can suffice when the reward signal is reliable.

Computational efficiency. Appendix A.5 provides a systematic benchmarking of training latency for different reward paradigms. Under identical experimental configurations:

• Text-based rewards (e.g., TEDS): 0.15 hours per training step,
• DINOv2-large (0.3B parameters): 0.24 hours per step,
• Visual-ERM (8B parameters): 0.17 hours per step.

The counterintuitive result — that an 8B generative model is faster than a 0.3B vision encoder — is attributed to DINO-based approaches requiring "segmenting high-resolution images into multiple sub-patches to ensure scoring precision," which introduces significant pre-processing overhead. Visual-ERM's unified multimodal architecture processes structured visuals natively without such segmentation, demonstrating that the approach is not just more accurate but also more computationally efficient than vision-encoder similarity rewards.

---

3.4.5 Test-Time Scaling via Reflection and Revision

Beyond its role as an RL reward, Visual-ERM provides interpretable feedback that enables iterative self-refinement at inference time — a capability that scalar-only rewards (from DINO, TEDS, or even a discriminative reward model) cannot support.

The reflection loop. The algorithm, following the notation of Section 3.3 in the paper:

Step 0 (initial generation): The policy produces an initial candidate:

$y^{(0)} \sim \pi_\theta(\cdot \mid x)$

where $`y^{(0)}`$ is the first-attempt structured output (code or markup) for reference image $`x`$.

Step 1 (rendering and evaluation): The initial candidate is rendered:

$\hat{y}_{\text{img}}^{(0)} = \mathcal{R}_m(y^{(0)})$

and evaluated by Visual-ERM, which produces both a scalar reward and a structured discrepancy description:

$(r^{(0)}, f^{(0)}) = f_{\theta_{\text{ERM}}}(x, \hat{y}_{\text{img}}^{(0)})$

where $`r^{(0)} \in [0, 1]`$ is the bounded reward (computed via the pipeline in Section 3.4.3 but without batch normalization — the paper is not explicit about this, but the reflection loop operates on single samples, so normalization would be across a batch of 1, which is equivalent to using the raw reward after clipping), and $`f^{(0)}`$ is the structured discrepancy description (the natural-language error list with categories, severities, locations, and descriptions — i.e., the full JSON output from Visual-ERM).

Step 2 (conditional revision): If $`r^{(0)}`$ falls below a threshold (the paper does not specify the threshold value, but the mechanism is threshold-gated), the policy revises its solution by conditioning on the previous draft and the critique:

$y^{(t+1)} \sim \pi_\theta\left(\cdot \mid x, y^{(t)}, f^{(t)}\right)$

where the policy sees the reference image $`x`$, the previous output $`y^{(t)}`$, and the structured feedback $`f^{(t)}`$ as context. The paper notes that "the interpretability of $`f^{(t)}`$, rather than $`r^{(t)}`$ alone, is what enables this revision step; a scalar-only reward could not localize what to fix."

Step 3 (iteration): The loop repeats: render the revised output, evaluate with Visual-ERM, and either accept (if the reward is above threshold) or revise again, up to a maximum of $`T`$ rounds.

What this loop achieves: at inference time, without any weight updates, the policy uses Visual-ERM as an external critic to iteratively improve its own output. The key insight is that Visual-ERM's output is both a verdict (via the scalar reward) and a debugging guide (via the localized discrepancy descriptions). The scalar alone tells the policy "this is wrong" but not what to change; the discrepancy descriptions tell it specifically "the y-axis label is missing," "the legend colors don't match," or "the bar heights are incorrect," enabling targeted revision.

Why this works without training: the policy $`\pi_\theta`$ is a general-purpose LVLM that has been fine-tuned for vision-to-code tasks. It already has the capability to generate code — the reflection loop simply gives it a second (and third) chance, with explicit feedback about what went wrong. The paper notes (Section 3.3) that "gains are bounded by the policy's editing ability, since TTS reuses $`\pi_\theta`$ without weight updates." This means test-time scaling amplifies capabilities the policy already possesses; it cannot teach the model fundamentally new skills.

Empirical behavior. Table 4 shows that applying Visual-ERM-guided reflection to the base Qwen3-VL-8B-Instruct (without RL) improves ChartMimic average from 69.6 to 77.6 (+8.0), with the majority of gains on the Direct setting (67.7 → 75.6, +7.9) and the Customized setting seeing a comparable boost (71.6 → 79.5, +7.9). Applying reflection on top of the already RL-tuned policy yields further gains: 78.0 → 81.1 (+3.1). The paper notes that increasing reflection rounds yields consistent improvements with diminishing returns beyond three rounds (Table 6): two rounds give 79.2 average, three rounds give 81.1, and four rounds give 80.7 (a slight regression, possibly due to the policy degrading correct outputs through unnecessary revision — the "correct-to-incorrect reversion" problem acknowledged in the limitations discussion).

Comparison with self-reflection (without Visual-ERM). Table 4 also reports an ablation where the policy attempts self-reflection without Visual-ERM's critiques (labelled "Reflection (self)"). For the base model, self-reflection actually degrades performance (69.6 → 65.7), and for the RL-tuned model, self-reflection also degrades (78.0 → 76.1). This confirms that an external trained critic is necessary — the policy's own self-assessment is unreliable for vision-to-code, echoing the broader finding in LLM research that self-critique without external verification tends to be ineffective for precise tasks. The $`+8.0`$ gain from Visual-ERM-guided reflection versus the $`-3.9`$ loss from self-reflection quantifies the value of the reward model's interpretable feedback.

---

3.4.6 VC-RewardBench: Benchmark Construction and Evaluation Protocol

While the RL experiments in Section 4.1 evaluate whether Visual-ERM is a good supervisor (by measuring downstream policy performance), they do not directly measure whether Visual-ERM is a good judge — a policy could improve under Visual-ERM's supervision even if Visual-ERM's judgments are imperfect (the improvements would just be slower or noisier). VC-RewardBench provides a direct, task-level evaluation of image-to-image discrepancy judgment ability, independent of downstream RL.

Benchmark construction (multi-model consensus protocol). The construction pipeline is shown in Figure 4 and described in Section 3.4:

1. Candidate pool: $`4{,}500`$ image pairs are assembled, following the same philosophy as the reward-model training data construction — reference images paired with re-rendered predictions containing realistic discrepancies.

2. Independent annotation by three proprietary models: each pair is annotated by GPT-5-mini, Gemini-2.5-Pro, and Gemini-3-Pro, producing three independent structured discrepancy lists per image pair.

3. PhD-level human consolidation: human reviewers "consolidate the labels into a single expert-vetted set" by resolving inconsistencies and removing ambiguous or low-quality cases. The paper reports this filtering reduces the candidate pool from $`4{,}500`$ to the final $`1{,}335`$ instances.

4. Final composition (Appendix A.3):

   • 595 chart instances, with error annotations including 231 text_error, 619 style_error, 462 data_error, and 62 structure_error.
   • 298 table instances, with 884 text_error, 284 numeric_error, and 185 layout_error.
   • 442 SVG instances, with 151 style_error, 218 structure_error, 360 shape_error, and 12 text_symbol_error.

The distribution of error types across domains is informative: charts are dominated by style and data errors, tables by text recognition errors, and SVGs by shape and structure errors. This diversity makes VC-RewardBench a diagnostic that probes different aspects of visual judgment across tasks.

The evaluation challenge: structured fields + free-form descriptions. Unlike metrics that compare scalar predictions to scalar ground truth (where mean squared error or correlation suffices), VC-RewardBench requires matching structured lists of error descriptions between a model's prediction $`\hat{A}`$ and the ground truth $`A^\star`$. Exact string matching fails because two descriptions of the same underlying error can use different wording (e.g., "Y-axis label missing" vs. "The vertical axis does not have a title"). The paper therefore uses an LLM-as-Judge protocol.

LLM-assisted matching protocol. The evaluation judge (GPT-5-mini by default, with ablations using other judges in Appendix B.3) receives:

• The task category (Chart, Table, or SVG) and its allowed error types,
• Matching rules: (i) pred.category == gt.category is required; (ii) descriptions must point to the same specific error point; (iii) partially matching descriptions can be accepted as match_level = "partial"; (iv) matching is 1-to-1 (each predicted error matches at most one ground-truth error, and vice versa); (v) conservative decisions are preferred (leave unmatched rather than force incorrect matches),
• The model's predicted error list and the ground-truth error list.

The judge outputs a JSON object containing matched pairs (with match levels "yes" or "partial"), unmatched predictions (hallucinations or false positives), and unmatched ground-truth errors (missed detections or false negatives).

Metrics. From the match results, the paper computes:

• Precision = $`\frac{\text{TP}}{\text{TP} + \text{FP}}`$, where TP includes "yes" and "partial" matches, and FP are unmatched predictions.
• Recall = $`\frac{\text{TP}}{\text{TP} + \text{FN}}`$, where FN are unmatched ground-truth errors.
• $`\text{F1}_h`$ (hard F1): the harmonic mean of precision and recall using only "yes" matches (strict criterion, requiring close semantic and attribute-level agreement).
• $`\text{F1}_s`$ (soft F1): the harmonic mean using both "yes" and "partial" matches (relaxed criterion, tolerating minor paraphrases).

Additionally, since both predictions and ground truth include per-error severities, the paper computes:

• $`S_c`$ (correlation score): the Pearson correlation coefficient between the summed predicted severities per instance and the summed ground-truth severities per instance, measuring overall scoring consistency.

$S_c = \text{Pearson}\left(\left\{\sum_{k} s_k^{\text{pred}}\right\}_{\text{instances}}, \left\{\sum_{k} s_k^{\text{gt}}\right\}_{\text{instances}}\right)$

where the outer correlation is computed over all instances in the benchmark, and each instance's sum aggregates severities across all errors detected/annotated for that instance.

What $`S_c`$ computes: how well the model's overall severity assessment (the total penalty it assigns to an image pair) correlates with the ground-truth total severity. A high $`S_c`$ means the model consistently assigns higher total severity to image pairs that human annotators judged as more severely wrong, even if the specific error enumeration has false positives or false negatives.

Why $`S_c`$ complements F1: F1 measures detection accuracy (can the model find the right errors?), while $`S_c`$ measures calibration (does the model's overall harshness match human judgment?). A model could achieve perfect F1 but have $`S_c = 0`$ if it assigns maximum severity to all detected errors regardless of their actual impact. Conversely, a model with mediocre F1 could have high $`S_c`$ if it consistently under- or over-estimates severity in a way that correlates with ground truth. The combination of both metrics provides a more complete picture of judging quality.

LLM-as-Judge robustness (Appendix B.3). The paper validates the evaluation protocol by rerunning the same Visual-ERM predictions on VC-RewardBench with four different judge models: GPT-5-mini, GPT-5.2, Gemini-2.5-Pro, and Gemini-3-Flash. Table 10 reports that $`\text{F1}_h`$ ranges from 40.8 to 43.0 (span of 2.2 points) and $`\text{F1}_s`$ ranges from 42.4 to 45.1 (span of 2.7 points) across judges. $`S_c`$ is identical (e.g., Chart: 61.2) because it is computed deterministically from severity values without LLM matching. The paper interprets this stability as evidence that the LLM-as-Judge protocol is well-constrained and does not introduce significant judge-dependent bias.

What the benchmark evaluates (and doesn't). VC-RewardBench evaluates the quality of the reward signal itself — whether a model can detect and describe visual discrepancies. It does not evaluate whether that signal produces good RL policies (that is Section 4.1), whether it enables effective test-time scaling (Section 4.3), or whether the model's judgments are free of the biases present in its training data (the GPT-5-mini teacher bias the paper flags in Section 3.1). The paper's implicit validation strategy is triangulation: strong performance on VC-RewardBench (Section 4.2) plus strong downstream RL gains (Section 4.1) plus interpretable test-time scaling improvements (Section 4.3) jointly support the claim that Visual-ERM provides reliable, aligned supervision.

Summary of the training and evaluation ecosystem. The three evaluation axes — RL utility, reward-model judging accuracy, and test-time scaling effectiveness — form a mutually reinforcing validation strategy. RL utility (Section 4.1) tests whether the reward provides useful gradients for policy improvement; VC-RewardBench (Section 4.2) tests whether the reward model's internal judgments are accurate in an absolute sense; test-time scaling (Section 4.3) tests whether the reward model's interpretability enables use cases beyond training-time supervision. Each axis probes a different aspect of the four desired properties (visual, fine-grained, interpretable, task-agnostic), and strong results on all three axes (Tables 1–5) provide convergent evidence for the paper's central claim: that fine-grained visual reward supervision is both necessary and sufficient for vision-to-code RL.

4. Key Insights and Innovations

Innovation 1: Diagnosing Reward Misalignment as a Property Violation Problem, Not Just a Metric Problem

The paper's most distinctive intellectual move occurs in Section 2, before any new method is proposed. Rather than treating existing reward approaches as competing metrics to be benchmarked against each other, the paper reframes the entire reward design problem in terms of four necessary properties a vision-to-code reward must satisfy: visual, fine-grained, interpretable, and task-agnostic. Each existing approach is then diagnosed not as "imperfect" or "noisy" but as fundamentally misaligned — it violates specific properties by design.

This is a conceptual advance over prior work, which treated reward design as an empirical optimization problem. ChartMaster (Tan et al., 2025) uses DINO similarity as a reward without analyzing why DINO's invariance properties might make it unreliable for chart fidelity. VinciCoder (Zhao et al., 2025) combines DINO-based visual rewards with text-based rules as a pragmatic ensemble, implicitly treating the weaknesses of each as orthogonal noise to be averaged out. Table2LaTeX-RL (Ling et al., 2025) uses TEDS as if textual structural similarity were a valid proxy for visual correctness. None of these works articulated the property-based diagnostic framework that the paper introduces.

What makes this diagnostic move genuinely novel — rather than a standard "prior work is flawed" literature review — is that it is predictive, not just descriptive. The four properties are derived from first-principles reasoning about what vision-to-code correctness means (it lives in the rendered image space, operates at element-level granularity, requires localization for debugging, and shares failure modes across tasks), and then used to predict exactly how each existing reward will fail under RL optimization. The predictions are empirically validated in Figure 2: text-based rewards produce proxy gains that don't translate to downstream performance (violating the "visual" property), and DINO-based rewards saturate and can even degrade table performance (violating "fine-grained" and "interpretable"). The property violation framework explains not just that existing rewards are suboptimal, but why they produce the specific failure patterns observed.

This contribution is more a reframing than a metric gain — it changes how researchers should think about reward design for multimodal generation tasks. Rather than asking "which reward metric works best?" (a benchmarking mindset), the framework asks "which properties must a reward satisfy for this task, and which existing approaches violate them?" (a diagnostic mindset). The paper's success in building Visual-ERM by directly instantiating all four properties validates that this diagnostic approach is actionable, not just analytical. The release of VC-RewardBench — which explicitly measures fine-grained discrepancy detection (F1) and severity calibration (Pearson correlation) — provides a concrete tool for evaluating reward models against these properties, making the framework operational for future work.

Innovation 2: Teacher-Distilled Discrepancy Annotations as Scalable Reward Supervision

The second major innovation is the training data construction pipeline that produces fine-grained, structured discrepancy annotations without requiring human labeling. While using stronger models as teachers for weaker ones is not new (it's the standard distillation paradigm), the paper's specific instantiation for reward modeling introduces several non-obvious design choices that address a fundamental scalability bottleneck.

Prior work on reward models for multimodal tasks either used human-annotated preference data (expensive and slow to scale, as in RLHF pipelines) or relied on simple scalar similarity metrics (cheap but uninterpretable, as in DINO- or CLIP-based rewards). The paper sidesteps both limitations by training a generative reward model on structured critiques distilled from a proprietary teacher, with the critical insight that the teacher's output format — a JSON list of categorized, localized, severity-weighted errors — is itself the supervision signal. This converts the annotation problem from "get humans to judge image pairs" (unscalable) to "get a strong model to describe discrepancies, then filter for consistency" (scalable to 514K instances).

What makes this innovation distinctive is the dual-route error synthesis strategy that feeds the teacher. The combination of Targeted Edit (systematic perturbation of ground-truth code to inject pre-defined error types) and Natural Inference (outputs from a weak policy model that reflect real error distributions) ensures that the training distribution has both coverage (all possible failure modes, including rare structural errors) and realism (the messy, unpredictable errors the RL policy actually emits during rollout). The paper argues explicitly that either route alone would be insufficient: Targeted Edits would create a distributional mismatch between training and deployment if the perturbation model's error patterns don't match the policy's natural mistakes, and Natural Inference alone would miss edge cases that occur rarely in practice but are catastrophic when they do (e.g., entirely wrong chart types). This is a nuanced data engineering insight that goes beyond "more data is better" — it's about complementary data sources covering different regions of the error distribution.

The teacher choice itself (GPT-5-mini rather than a stronger or open-source model) is a pragmatic innovation. The paper demonstrates empirically that even Qwen3-VL-235B-Instruct — a model roughly 29× larger than the Visual-ERM backbone — is an unreliable discrepancy judge (F1_h = 29.5 on VC-RewardBench, Table 5), meaning that scale alone does not confer fine-grained visual comparison ability. Using a proprietary model as a one-time labeling oracle (not as an online judge) sidesteps the cost of running a 235B+ model at RL training time while still producing high-quality supervision. The quality-control mechanisms (rendering-consistency checks, structural agreement with ground-truth code) add a layer of robustness that filters teacher hallucinations, addressing the standard weakness of distillation approaches.

The significance of this innovation extends beyond the paper's specific implementation. It demonstrates that reward model training for precise multimodal tasks can be bootstrapped from proprietary teacher models, creating a scalable alternative to both human annotation (too expensive) and simple metric-based rewards (too unreliable). The approach is likely transferable to other tasks where "correctness" is visually defined but training signals are scarce — scientific figure reproduction, UI screenshot-to-code, CAD drawing reconstruction, and any domain where a strong proprietary model can critique outputs more reliably than a simple similarity metric but cannot be deployed at scale for online RL.

Innovation 3: The Generative Reward Model as a Unified Supervisor for Both RL Training and Test-Time Refinement

The third innovation is the dual-use deployment of a single reward model for two distinct purposes: providing scalar rewards for policy-gradient RL training, and providing interpretable natural-language feedback for test-time scaling via iterative reflection and revision. While prior work has used reward models for training (RLHF pipelines) and separate critique models for test-time refinement (Self-Refine, Reflexion), the paper's contribution is the recognition that a generative reward model with structured output can serve both roles without modification, because the same discrepancy descriptions that are aggregated into a scalar for RL can be passed directly to the policy as actionable feedback.

This is more than a convenient engineering choice. It addresses a fundamental tension in reward model design: scalar rewards are necessary for RL optimization (policy gradient methods need differentiable or at least scalar signals), but opaque scalars invite reward hacking because they give the policy no signal about what to fix. The paper's resolution is to have the reward model produce rich structured output, then post-process that output into a scalar for RL while preserving the structure for test-time refinement. This decouples the reward model's representational capacity (it can express fine-grained, localized, categorized feedback) from the RL algorithm's input requirements (it consumes scalars), creating a system where the same model serves as both a training supervisor and an inference-time critic.

The empirical results strongly support this design. Table 4 shows that Visual-ERM-guided reflection on the base model (without RL) yields +8.0 on ChartMimic average, while self-reflection (where the policy critiques its own output without Visual-ERM) degrades performance by -3.9 points. This gap quantifies the value of an external, trained critic over self-assessment — a finding that echoes broader results in the LLM literature (Huang et al., 2023) but is demonstrated here for vision-to-code specifically. More importantly, the +3.1 gain from applying reflection on top of the already RL-tuned policy (78.0 → 81.1) shows that the benefits of interpretable feedback are additive to RL training gains, not subsumed by them. This suggests that RL training and test-time refinement optimize complementary aspects of the policy — RL improves the model's first-attempt quality, while reflection enables error correction that RL alone cannot achieve because it doesn't provide instance-specific, localized feedback during deployment.

The innovation's significance extends to how we think about the relationship between training-time and inference-time compute. Prior work on test-time scaling (Snell et al., 2024 studying process reward models for math reasoning) treats inference-time refinement as a separate mechanism from training-time optimization. Visual-ERM demonstrates that the same reward model can bridge both phases, suggesting a more unified view where "RL training" and "test-time scaling" are two consumption modes for a shared critic rather than separate systems with separate components. This has practical implications for deployment: an organization that trains a policy with Visual-ERM-guided RL gets test-time refinement "for free" from the same reward model, creating a virtuous cycle where the policy improves through both weight updates and inference-time revision loops.

Innovation 4: VC-RewardBench as a Diagnostic for Image-to-Image Discrepancy Judgment

The fourth contribution is VC-RewardBench, a benchmark that directly evaluates a model's ability to detect and describe fine-grained visual discrepancies between image pairs, independent of downstream task performance. While the paper frames this as an evaluation tool, it represents an intellectual innovation in how we assess reward models for multimodal generation: rather than evaluating reward models by measuring the downstream performance of policies trained with them (the standard approach in RLHF research, where reward model quality is proxied by policy win rates), VC-RewardBench provides direct, task-level diagnostics of the reward signal itself.

This is significant because downstream policy performance confounds reward quality with many other factors — the policy architecture, the RL algorithm, the training data distribution, the KL regularization strength. A weak reward model might produce strong policies if the policy architecture is robust to noisy supervision, or a strong reward model might produce weak policies if the RL optimization is poorly tuned. By measuring reward quality directly (F1 on error detection, Pearson correlation on severity calibration), VC-RewardBench enables ablation of the reward signal in isolation, which is essential for the kind of property-based analysis the paper advocates in Innovation 1.

The benchmark's construction methodology introduces another conceptual contribution: the multi-model consensus protocol. By having three independent proprietary models annotate each image pair and then having PhD-level reviewers consolidate the labels, the benchmark reduces architecture-specific bias that would be present if a single model (e.g., only GPT-5-mini) served as both teacher (for Visual-ERM training) and evaluator (for VC-RewardBench). This avoids the circularity problem where a reward model trained on GPT-5-mini's judgments is then evaluated against GPT-5-mini's judgments — the consensus labels from multiple models provide a more objective ground truth. The paper reports (Table 5) that even GPT-5-mini (the teacher used for training) achieves only F1_h = 39.9 on the chart subset of VC-RewardBench — substantially below the consensus-based annotation quality, confirming that the benchmark is harder than the teacher's own outputs.

The diagnostic value of VC-RewardBench is demonstrated by its ability to reveal capability boundaries that downstream RL metrics obscure. Table 5 shows that Qwen3-VL-235B-Instruct achieves F1_h = 29.5 — better than the 8B base model (F1_h = 5.3) but far below Visual-ERM at 8B (F1_h = 42.1). This quantifies the finding that scale alone does not confer fine-grained visual discrepancy detection — the specialized training of Visual-ERM provides capabilities that a 29× larger general-purpose model lacks. The per-domain breakdown (Chart, Table, SVG) further reveals that different models have different strengths: proprietary models tend to perform best on tables (where text recognition dominates), while Visual-ERM's advantage is largest on SVG and Chart domains (where visual geometry and style matter more). These patterns would be invisible in aggregate downstream RL metrics, making VC-RewardBench a valuable diagnostic for understanding why a reward model works well or poorly for specific tasks.

The benchmark also introduces a novel evaluation methodology: the LLM-as-Judge matching protocol for structured error lists with free-form descriptions. This addresses a genuine evaluation challenge — comparing two lists of natural-language error descriptions where the same underlying discrepancy can be described with different wording — in a way that is both scalable (automated via LLM judging) and robust (validated across four different judge models showing only 2–3 point F1 variation, Table 10). The dual F1 metrics (hard and soft) and the severity correlation score (S_c) provide a multi-faceted assessment that captures both detection accuracy and calibration, setting a methodological precedent for evaluating generative reward models that produce structured natural-language output. This contrasts with standard reward model benchmarks (like RewardBench) that evaluate preference ranking accuracy, or vision-language benchmarks (like VL-RewardBench) that focus on alignment rather than reconstruction fidelity.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on three vision-to-code tasks with separate benchmarks: Chart-to-Code uses ChartMimic [41] under both direct (reproduce the input chart) and customized (generate a new chart under given style and data constraints) settings; Table-to-Markdown uses OmniDocBench-v1/v1.5 [26] and olmOCRBench [28] with table-level metrics; SVG-to-Code uses UniSVG [15] on its ISVGEN subset. For reward model evaluation, the paper introduces VC-RewardBench, a new benchmark of 1,335 curated image pairs (595 chart, 298 table, 442 SVG) with human-consolidated fine-grained discrepancy annotations (Section 4.2, Appendix A.3). For RL training data, the paper uses 11K chart images, 40K table images, and 10K SVG images (Appendix A.2).

• Base model(s). The policy model for RL is Qwen3-VL-8B-Instruct [3], a general-purpose 8B-parameter LVLM. For stronger baselines, the paper also uses VinciCoder-8B-SFT [47] (a specialized vision-to-code model) on Chart-to-Code and SVG-to-Code. The reward model, Visual-ERM, is built by fine-tuning Qwen3-VL-8B-Instruct on the discrepancy-annotated training set. For VC-RewardBench evaluation, the paper additionally tests Qwen3-VL-235B-Instruct [3] (a ~29× larger variant of the same model family) and several proprietary models (GPT-4o, GPT-5.2, Gemini-2.5-Pro, Gemini-3-Flash) as baselines. The choice of Qwen3-VL-8B-Instruct as the primary backbone is pragmatic: it provides strong but not state-of-the-art vision-to-code baselines (ChartMimic average 69.6, Table-to-Markdown composite average 76.8, SVG Score 64.2), leaving substantial room for RL improvement — a saturated model would not demonstrate the reward model's value.

• Metrics. Chart-to-Code uses ChartMimic's multi-dimensional scoring: Exec_rate (execution success rate of generated code), Low (low-level visual similarity), High (high-level semantic similarity), Overall (combined score), and Avg (average across Direct and Customized settings). Table-to-Markdown uses TEDS (Tree-Edit-Distance Similarity), TEDS-S (TEDS-Structure-Only, measuring layout correctness independent of text content), Edit-Dist (character-level edit distance between predicted and ground-truth markup), and TA (table accuracy on olmOCRBench). For Edit-Dist, where lower values mean better, the paper reports (100 − Edit-Dist) when computing averages to align directionality with other metrics. SVG-to-Code uses SSIM (pixel-level structural similarity), LPIPS (perceptual similarity, lower is better), CLIP (semantic alignment score), and Score (an aggregate metric). VC-RewardBench uses F1_h (hard F1 — harmonic mean of precision and recall using only strict "yes" error matches), F1_s (soft F1 — including both "yes" and "partial" matches), and S_c (Pearson correlation between predicted and ground-truth summed severities per instance).

• Baselines. For RL comparisons, the paper compares against: (a) SFT-only baselines — Qwen3-VL-8B-Instruct, InternVL3.5-8B [38], Qwen2.5-VL-7B [4], VinciCoder-8B-SFT [47], JanusCoderV-8B [36], and ChartMaster-7B [37]; (b) DINO-based RL — GRPO using a DINOv2-large feature similarity reward, following the approach in VinciCoder [47]; (c) TEDS-based RL — GRPO using Tree-Edit-Distance Similarity as the reward for Table-to-Markdown; (d) Self-reflection — the policy critiquing and revising its own outputs without Visual-ERM's feedback, serving as a test-time scaling baseline. For VC-RewardBench, baselines include proprietary models (GPT-4o, GPT-5.2, Gemini-2.5-Pro, Gemini-3-Flash) and open-source models (Qwen2.5-VL-7B, InternVL3.5-8B, Qwen3-VL-8B-Instruct, Qwen3-VL-235B-Instruct) evaluated via the same LLM-as-Judge protocol.

• Generation budget / compute accounting. For RL, compute is measured implicitly via the RL training procedure rather than an explicit generation budget — the paper reports GRPO hyperparameters (learning rate 1 × 10⁻⁶, batch size 256 prompts, 8 rollouts per prompt per update step) but does not specify the total number of training steps or total FLOPs. For test-time scaling, the budget is controlled by the number of reflection rounds (2, 3, or 4). For computational efficiency comparisons (Appendix A.5), the paper measures per-step training latency in hours, finding that Visual-ERM at 8B (0.17 hours/step) is faster than DINOv2-large at 0.3B (0.24 hours/step) because DINO requires segmenting high-resolution images into multiple sub-patches, while Visual-ERM processes them natively.

• Cross-validation / statistical protocol. The paper does not report a formal cross-validation protocol for the RL experiments — performance is reported on standard held-out benchmarks (ChartMimic, OmniDocBench, UniSVG) whose test sets are separate from the RL training data. For VC-RewardBench, the evaluation uses a fixed test set of 1,335 curated instances with no cross-validation. The LLM-as-Judge protocol includes a robustness check (Appendix B.3, Table 10) by rerunning the same predictions with four different judge models, showing F1 variations of only 2–3 points across judges, which supports the reliability of the automated evaluation. The paper does not report confidence intervals, significance tests, or multiple-run variance for any experimental result.

---

Main Quantitative Results

5.1.1. RL Utility: Chart-to-Code

The headline result on chart-to-code appears in Table 1. Starting from Qwen3-VL-8B-Instruct (ChartMimic average 69.6), RL with Visual-ERM as the reward improves the model to 78.0 average, a gain of +8.4 points. This gain decomposes into +11.8 on ChartMimic Direct (67.7 → 79.5) and +4.9 on Customized (71.6 → 76.5). Table 1 also reports per-metric breakdowns: on Direct, Exec_rate improves from 82.2 to 92.5 (+10.3), Low from 62.7 to 74.4 (+11.9), High from 72.7 to 84.6 (+11.9), and Overall from 67.7 to 79.5 (+11.8). On Customized, Exec_rate improves from 86.8 to 91.5 (+4.7), Low from 66.3 to 71.8 (+5.5), High from 76.8 to 81.1 (+4.3), and Overall from 71.6 to 76.5 (+4.9).

Comparing against alternative rewards, DINO-based RL on the same backbone reaches 76.1 average (Direct: 76.5, Customized: 75.8), a gain of +6.5 over the base model. Visual-ERM-guided RL thus outperforms DINO-based RL by +1.9 points on average. The paper attributes this gap to three factors enumerated in the text: stronger downstream policies (Visual-ERM yields larger gains on both backbones), cross-modal coverage (DINO rewards are "unimodal and weak at penalizing errors carried by rendered text"), and the availability of fine-grained interpretable feedback for test-time scaling.

When starting from the stronger VinciCoder-8B-SFT baseline (average 67.4), RL with Visual-ERM delivers even larger absolute gains: +10.1 average, reaching 77.5. On Direct, the gains are +10.3 (72.9 → 83.2), and on Customized +9.8 (61.9 → 71.7). DINO-based RL on the same VinciCoder backbone yields more modest improvements: 72.5 average (+5.1), with most gains concentrated on Direct (+4.8) and smaller improvements on Customized (+5.4). The gap between Visual-ERM and DINO on VinciCoder is +5.0 points (77.5 vs. 72.5), larger than the +1.9 gap on Qwen3-VL-8B-Instruct. This suggests that Visual-ERM's advantage is more pronounced when optimizing stronger policies — DINO rewards saturate earlier because the policy already produces globally similar images (high DINO similarity) but with subtle element-level errors that DINO's coarse features miss. This interpretation is consistent with the DINO over-optimization analysis in Section 2.

The paper also benchmarks against other published models. ChartMaster-7B (a specialized chart-to-code model trained with chart-similarity RL) achieves 72.6 average, which Visual-ERM-guided RL on Qwen3-VL-8B-Instruct surpasses by +5.4 points (78.0 vs. 72.6). The best result overall comes from Visual-ERM + VinciCoder-8B-SFT at 77.5 average, though ChartMaster-7B achieves the highest single-setting score (ChartMimic Direct Overall at 78.3, slightly above Qwen3-VL-8B-Instruct + Visual-ERM RL at 79.5 — the comparison is not head-to-head since ChartMaster uses a different base model and training recipe).

Critical observation about the metrics: The paper reports substantial gains on Exec_rate (code renderability) for the RL-trained policies — Qwen3-VL-8B-Instruct improves from 82.2 to 92.5 (+10.3) on Direct, and VinciCoder-8B-SFT improves from 86.2 to 94.3 (+8.1). These gains likely reflect the render-success reward term (r_rsr) rather than Visual-ERM's fine-grained visual feedback, since r_rsr explicitly rewards renderable code. The High and Low metric improvements (+11.9 and +11.9 for Qwen3-VL-8B-Instruct on Direct) are the metrics most directly measuring visual fidelity, and these are where Visual-ERM's contribution should dominate. The paper does not provide an ablation that isolates the contribution of r_verm vs. r_rsr on the per-metric breakdown, but the overall gains are substantially larger than what r_rsr alone could plausibly achieve (since the base model already achieves 82.2% renderability, the maximum possible gain from r_rsr is bounded by ~17.8 points on Exec_rate, and the observed gains on Low and High exceed what improved renderability alone would explain).

5.1.2. RL Utility: Table-to-Markdown

Table 2 reports results on table-to-markdown parsing. Starting from Qwen3-VL-8B-Instruct (composite average 76.8 across OmniDocBench, OmniDocBench-v1.5, and olmOCRBench), RL with Visual-ERM as the reward achieves 79.5 average, a gain of +2.7. The gains are consistent across benchmarks:

• OmniDocBench: TEDS improves from 78.9 to 81.4 (+2.5), TEDS-S from 83.9 to 86.3 (+2.4), Edit-Dist from 23.2 to 20.7 (+2.5 when inverted for averaging).
• OmniDocBench-v1.5: TEDS improves from 72.7 to 75.4 (+2.7), TEDS-S from 77.2 to 80.4 (+3.2), Edit-Dist from 26.9 to 24.2 (+2.7 inverted).
• olmOCRBench TA: improves from 75.3 to 78.1 (+2.8).

The paper compares against two alternative reward signals:

• TEDS-based RL: the training reward rises steadily, yet downstream performance improves only marginally to 74.8 average (a degradation of −2.0 from the base model). The policy improves on TEDS metrics (OmniDocBench TEDS: 78.9 → 79.2, +0.3; olmOCRBench TA: 75.3 → 78.6, +3.3) but degrades on OmniDocBench-v1.5 (composite metrics drop). The paper interprets this as "a pattern consistent with reward shortcutting in a purely textual/structural space that ignores visual cues" — the policy learns to produce markup that maximizes TEDS score without faithfully rendering into correct tables.

• DINO-based RL: this significantly degrades performance, dropping the composite average from 76.8 to 65.3 (−11.5). The degradation is severe across all benchmarks: OmniDocBench TEDS drops from 78.9 to 62.2 (−16.7), TEDS-S from 83.9 to 69.5 (−14.4), Edit-Dist worsens from 23.2 to 37.0; OmniDocBench-v1.5 TEDS drops from 72.7 to 61.1 (−11.6), TA drops from 75.3 to 71.7 (−3.6). The paper attributes this to tables being "dominated by precise text and layout," where DINO features are particularly unreliable because they are invariant to the exact textual content that constitutes the primary signal. This is the most dramatic negative result in the paper and provides strong evidence for the claim that coarse vision-encoder rewards are not merely suboptimal but actively harmful for text-centric visual parsing tasks.

Comparing against baselines, Qwen3-VL-8B-Instruct + Visual-ERM RL (79.5) outperforms InternVL3.5-8B (66.7), Qwen2.5-VL-7B (64.5), and the base Qwen3-VL-8B-Instruct (76.8). The paper does not compare against a dedicated table-parsing SFT model on these benchmarks, and Table 2 does not include VinciCoder results (which would have been a natural stronger baseline, but Table 2 only reports Qwen3-VL-8B-Instruct results).

Critical observation about the magnitude of gains: The +2.7 average improvement on table-to-markdown is substantially smaller than the +8.4 average improvement on chart-to-code. The paper does not explicitly analyze this gap, but several factors likely contribute: (a) table parsing from the base model is already strong (76.8 average), leaving less room for improvement than chart-to-code (69.6); (b) table errors are dominated by OCR-like text recognition failures that Visual-ERM can detect but the policy may have limited capacity to fix through RL alone (since text recognition depends on the base model's perceptual capabilities, not just its output distribution); (c) the table RL training data is larger (40K images vs. 11K for charts, Appendix A.2), but the per-example optimization signal may be weaker if most rollouts produce similar errors (low reward variance within batches).

5.1.3. RL Utility: SVG-to-Code

Table 3 reports results on SVG-to-Code using the UniSVG ISVGEN subset. Starting from VinciCoder-8B-SFT as the policy model, RL with Visual-ERM improves:

• SSIM: 81.1 → 85.2 (+4.1)
• LPIPS: 19.2 → 12.6 (lower is better; improvement of +6.6)
• CLIP: 92.5 → 95.2 (+2.7)
• Score (aggregate): 87.9 → 91.6 (+3.7)

As a baseline, DINO-based RL on the same VinciCoder backbone degrades performance: SSIM drops from 81.1 to 76.9 (−4.2), LPIPS worsens from 19.2 to 23.3, CLIP is essentially flat (92.5 → 92.7), and the aggregate Score drops from 87.9 to 86.3 (−1.6). This continues the pattern observed in Table-to-Markdown: DINO-based rewards fail to provide meaningful gradients for already-strong policies and can actively harm performance. The paper interprets this as evidence that "Visual-ERM provides more robust and precise guidance than standard feature-similarity rewards, which may fail to provide meaningful gradients for highly optimized policies."

The baseline models on SVG-to-Code include Qwen3-VL-8B (Score 64.2) and JanusCoderV-8B (Score 62.8), both substantially below VinciCoder-8B-SFT (87.9). The paper only reports RL results starting from VinciCoder-8B-SFT, not from Qwen3-VL-8B-Instruct, so the transferability of Visual-ERM-guided RL across SVG base models is not tested. The SVG experiments use fewer metrics than chart and table tasks (three visual similarity metrics rather than task-specific structural metrics like TEDS), which is consistent with the nature of SVG evaluation but also means the paper evaluates a narrower range of SVG quality dimensions than it does for charts and tables.

5.1.4. Reward Model Evaluation on VC-RewardBench

Table 5 reports the direct evaluation of reward model judging capability on VC-RewardBench, independent of downstream RL performance. The headline result: Visual-ERM at 8B achieves F1_h = 42.1, F1_s = 44.7, and S_c = 58.4 averaged across chart, table, and SVG subsets.

Compared to its base model Qwen3-VL-8B-Instruct (F1_h = 5.3, F1_s = 6.5, S_c = 17.5), Visual-ERM improves by +36.8, +38.2, and +40.9 respectively — a dramatic 7–8× improvement in F1 and 3.3× improvement in severity correlation. This confirms the paper's claim in Appendix A.1 that the base model "is not a reliable image-to-image discrepancy judge out of the box—especially for structured visuals where the key differences are often text- and layout-centric."

The per-domain breakdown reveals domain-specific strengths and weaknesses:

• Chart: Visual-ERM achieves F1_h = 39.9, F1_s = 42.8, S_c = 61.2. This is competitive with the best proprietary models (Gemini-3-Flash: F1_h = 38.5, Gemini-2.5-Pro: F1_h = 33.7) and decisively surpasses GPT-4o (F1_h = 22.8) and Qwen3-VL-235B-Instruct (F1_h = 28.0).

• Table: Visual-ERM achieves its strongest per-domain performance: F1_h = 56.4, F1_s = 57.6, S_c = 74.8. This significantly exceeds all other models — the next best is Gemini-3-Flash at F1_h = 48.1 and Gemini-2.5-Pro at F1_h = 46.4. The paper's training data for table-to-markdown (125K instances, the largest of the three domains) and the dominance of text_recognition errors in tables (884 text_error annotations in the benchmark vs. 284 numeric and 185 layout, Appendix A.3) likely contribute to this domain strength, since Visual-ERM's cross-modal grounding is particularly valuable for detecting text discrepancies that DINO-based approaches miss entirely.

• SVG: Visual-ERM achieves F1_h = 28.3, F1_s = 32.6, S_c = 59.6. While this is the weakest per-domain result for Visual-ERM, it still substantially exceeds Qwen3-VL-235B-Instruct (F1_h = 19.4) and is competitive with proprietary models (GPT-5.2: F1_h = 28.5, Gemini-2.5-Pro: F1_h = 29.3). The relatively lower performance on SVG compared to tables likely reflects the domain's emphasis on geometric precision (shape_error and structure_error account for 578 of 741 total errors) which requires fine-grained spatial reasoning that may be harder to learn from the available training data.

The most important comparison in Table 5 is between Visual-ERM at 8B and Qwen3-VL-235B-Instruct (a model ~29× larger from the same family, but without reward-model specialization). Visual-ERM outperforms the 235B model by +12.6 F1_h (42.1 vs. 29.5), +12.3 F1_s (44.7 vs. 32.4), and +2.2 S_c (58.4 vs. 56.2). The paper interprets this as "evidence that fine-grained discrepancy detection and fidelity judgment come from reward-model specialization of a general-purpose LVLM, not from scale alone." This is a striking result: specialized training on discrepancy-annotated data provides capabilities that are not emergent at ~29× scale in the general-purpose model. It implies that the bottleneck for visual discrepancy judgment is not raw model capacity (the 235B model has vastly more parameters) but the training objective and data distribution — the general-purpose model is trained for broad multimodal understanding, not for precise image-to-image comparison.

Comparing against proprietary models, Visual-ERM at 8B achieves the highest overall F1_h (42.1) and F1_s (44.7), surpassing Gemini-3-Flash (40.6 F1_h, 43.4 F1_s), Gemini-2.5-Pro (37.8 F1_h, 40.9 F1_s), GPT-5.2 (32.7 F1_h, 35.0 F1_s), and GPT-4o (25.0 F1_h, 29.5 F1_s). The severity correlation S_c at 58.4 is slightly below Gemini-2.5-Pro (59.1) and GPT-5.2 (58.9) but above Gemini-3-Flash (53.4) and GPT-4o (56.5). This positions Visual-ERM as competitive with or superior to the strongest proprietary models on fine-grained image-to-image discrepancy judgment, despite being 1–2 orders of magnitude smaller in parameter count.

Critical nuance about the GPT-5-mini teacher: GPT-5-mini achieves F1_h = 39.9 on the chart subset — lower than Visual-ERM's 39.9 (the scores happen to be identical, but the point is that Visual-ERM does not exceed its teacher on this domain). On tables, GPT-5-mini achieves substantially lower; on SVG, GPT-5-mini achieves F1_h ≈ 28–30 (estimated from context). This means Visual-ERM exceeds its teacher on some domains (tables, where F1_h = 56.4 is dramatically higher than the teacher's likely performance) and matches it on others (charts). The VC-RewardBench annotations come from a multi-model consensus protocol (GPT-5-mini, Gemini-2.5-Pro, Gemini-3-Pro), not from GPT-5-mini alone, so the benchmark is not a direct measure of teacher fidelity. But the fact that Visual-ERM outperforms GPT-5-mini on some VC-RewardBench subsets suggests that the supervised fine-tuning process generalizes beyond the teacher's specific annotation style — Visual-ERM learns the underlying task of discrepancy detection, not just the teacher's specific wording.

5.1.5. Test-Time Scaling with Visual-ERM

Table 4 reports test-time scaling results on Chart-to-Code. The headline: Visual-ERM-guided reflection adds +8.0 points over the base model and +3.1 points over the RL-tuned model on ChartMimic average.

Starting from Qwen3-VL-8B-Instruct (average 69.6):

• Self-reflection (policy critiques its own output without Visual-ERM): 65.7 (−3.9, a significant degradation)
• Visual-ERM-guided reflection (3 rounds): 77.6 (+8.0)

The gap between Visual-ERM-guided reflection (+8.0) and self-reflection (−3.9) is +11.9 points, quantifying the value of an external trained critic over the policy's unreliable self-assessment. The paper notes this is consistent with prior findings that LLMs struggle with self-critique on precise reasoning tasks (Section 1), and extends this finding to vision-to-code: the policy cannot reliably detect its own rendering errors without external verification.

Starting from Qwen3-VL-8B-Instruct + Visual-ERM RL (average 78.0):

• Self-reflection: 76.1 (−1.9)
• Visual-ERM-guided reflection (3 rounds): 81.1 (+3.1)

The per-setting breakdown for the RL-tuned + Visual-ERM reflection configuration: ChartMimic Direct Overall reaches 80.3, and Customized Overall reaches 82.0 (Table 4). On Customized, the gain from adding reflection to the RL-tuned policy is particularly large: 76.5 → 82.0 (+5.5), while the gain on Direct is more modest: 79.5 → 80.3 (+0.8). This asymmetry suggests that the RL-tuned policy is already strong on Direct (close to ceiling for this model scale?), but still has room for improvement on Customized, where Visual-ERM's localized feedback helps the model adapt to novel chart specifications.

Ablation on reflection rounds (Table 6): The paper varies the number of reflection rounds from 2 to 4. Starting from Qwen3-VL-8B-Instruct + RL (average 78.0 at 0 rounds):

• 2 rounds: 79.2 (+1.2)
• 3 rounds: 81.1 (+3.1)
• 4 rounds: 80.7 (+2.7)

Performance improves from 2 to 3 rounds but slightly degrades at 4 rounds (81.1 → 80.7), suggesting diminishing returns with potential over-correction — at 4 rounds, the policy may "fix" errors that were already correct, or introduce new errors while attempting to address previously identified ones. This is the "correct-to-incorrect reversion" problem that the paper acknowledges as a limitation of revision models in the broader literature (Section 6 of the referenced example), though the paper does not explicitly name it here. The per-setting breakdown in Table 6 shows that the degradation at 4 rounds is primarily on the Direct setting: overall drops from 80.3 (3 rounds) to 80.0 (4 rounds), while Customized drops from 82.0 to 81.5. Exec_rate remains essentially flat (92.3 to 92.0), suggesting the degradation is in visual fidelity (Low/High metrics) rather than renderability.

Test-time scaling on SVG-to-Code (Table 12 in Appendix): The paper also reports SVG TTS results. Starting from Qwen3-VL-8B-Instruct (Score 64.2):

• • Visual-ERM reflection: 65.2 (+1.0)

Starting from Qwen3-VL-8B-Instruct + Visual-ERM RL (Score 69.4):

• • Visual-ERM reflection: 69.8 (+0.4)

The SVG gains are modest compared to chart TTS (+8.0 and +3.1), likely because SVG reconstruction errors are often geometric and structural — a model may not have the capability to fix a fundamentally wrong shape through in-context revision alone (the paper notes in Section 3.3 that TTS gains are "bounded by the policy's editing ability"). The smaller gain on SVG also reflects the weaker starting point for SVG RL (69.4 vs. 78.0 for chart RL), suggesting that RL training has already captured most of the easily correctable errors.

---

Ablation Studies and Robustness Checks

Multi-task data mixing for reward model training (Appendix B.2.1, Table 8): The paper compares a reward model trained on mixed chart+table+SVG data against models trained on single-task data. The mixed-data model achieves the best average performance (F1_h = 42.1, F1_s = 44.7, S_c = 58.4). Single-task models perform well on their own domain but generalize poorly: Chart-Data-Only achieves F1_h = 40.1 on Chart but plummets to 17.2 on Table and 11.3 on SVG; Table-Data-Only achieves F1_h = 53.6 on Table but only 17.1 on Chart and 14.1 on SVG; SVG-Data-Only achieves F1_h = 26.4 on SVG but only 16.4 on Chart and 11.4 on Table. The mixed-data model maintains competitive performance on all domains without negative transfer — it achieves 39.9 on Chart (vs. 40.1 for Chart-Only), 56.4 on Table (vs. 53.6 for Table-Only), and 28.3 on SVG (vs. 26.4 for SVG-Only). This finding supports the "task-agnostic" property claim: shared failure patterns across domains enable positive transfer. The paper attributes this to "cross-task transfer of error patterns (e.g., recognition and layout behaviors learned from tables can generalize to charts due to overlapping failure modes)."

Multi-task data mixing for downstream RL (Appendix B.2.2, Table 9): On Table-to-Markdown RL, the paper compares a reward model trained only on table data against the mixed-data Visual-ERM. The table-only RM improves the base model from 76.8 to 78.6 average (+1.8). The mixed-data RM further improves to 79.5 average (+2.7). The mixed-data RM outperforms the table-only RM on most metrics: OmniDocBench TEDS (81.4 vs. 79.5), TEDS-S (86.3 vs. 84.4), and Edit-Dist (20.7 vs. 21.6). The only metric where table-only RM wins is olmOCRBench TA (79.4 vs. 78.1), suggesting a minor trade-off — the mixed RM may sacrifice some table-specific text recognition accuracy for broader robustness. This is a notable finding: multi-task reward training improves RL performance even on a single downstream task, indicating that the richer reward signal from cross-task training provides more reliable gradients than a task-specialized reward model. This is counterintuitive — one might expect a table-specific reward model to provide the best supervision for table RL — but the paper's interpretation is that training on diverse visual discrepancy types (charts, SVGs) teaches the reward model to be a more robust judge of structured visual fidelity, which transfers to better gradient signals for table optimization.

Reward design: with vs. without render-success reward (Appendix B.4, Table 11): The ablation compares two reward formulations for Table-to-Markdown RL. Without r_rsr (using only the Visual-ERM scalar reward), the policy achieves 79.0 average (+2.2 over baseline). With r_rsr (the full combined reward), the policy achieves 79.5 average (+2.7 over baseline). The difference is modest (+0.5), but the paper notes that r_rsr improves training stability by handling unrenderable outputs during early training: "during the initial stages of training, the model occasionally produces code that cannot be successfully rendered, leading to intermittent zero rewards. However, the policy rapidly learns to navigate these formatting constraints, allowing the optimization focus to transition quickly from basic renderability to the primary objective of preserving fine-grained visual characteristics." The metric-level breakdown shows that with r_rsr, improvements are slightly larger across most metrics (TEDS: 81.4 vs. 80.9, Edit-Dist: 20.7 vs. 21.8, TA: 78.1 vs. 79.0), though TA is slightly lower with r_rsr. The paper does not ablate different methods of combining r_rsr and r_verm (e.g., multiplicative vs. additive), which would have been informative given the different scales of the two terms (r_rsr ∈ {0,1}, r_verm ∈ [0,1]).

LLM-as-Judge robustness on VC-RewardBench (Appendix B.3, Table 10): The paper reruns the same Visual-ERM predictions with four different judge models: GPT-5-mini, GPT-5.2, Gemini-2.5-Pro, and Gemini-3-Flash. Across judges, F1_h ranges from 40.8 to 43.0 (span of 2.2 points), F1_s from 42.4 to 45.1 (span of 2.7 points), and S_c is identical (58.4) because it is computed deterministically from severity values without LLM matching. The paper interprets the "modest" variation as evidence that "VC-RewardBench is not overly sensitive to the choice of LLM judge" and that "replacing the judge model yields consistent conclusions, supporting the robustness of our evaluation protocol." This is a reasonable claim — a 2–3 point F1 range across different proprietary judges is small relative to the 30+ point gaps between model tiers — but the paper does not report whether the relative ranking of models changes under different judges, which would be the strongest robustness test.

General VQA capability preservation (Appendix B.1, Table 7): To verify that Visual-ERM-guided RL does not catastrophically degrade the policy's general multimodal capabilities, the paper evaluates on five general VQA benchmarks: ChartQA, CharXiv_DQ, CharXiv_RQ, DocVQA, and InfoVQA. The base Qwen3-VL-8B-Instruct achieves an average of 78.3. After RL on Chart-to-Code: 78.4 (+0.1); after RL on Table-to-Markdown: 78.1 (−0.2); after RL on SVG-to-Code: 78.5 (+0.2). Individual benchmark scores are essentially flat: ChartQA remains in 81.5–83.2, CharXiv_DQ in 83.5–83.8, DocVQA in 95.5–95.8, InfoVQA in 83.1–83.6. The most consistent change is on CharXiv_RQ (reasoning questions about charts), where all RL variants improve over the base (46.0 → 47.2 / 46.7 / 46.4), suggesting that vision-to-code RL transfers positively to chart understanding tasks. This is a crucial sanity check: the KL regularization in GRPO (Equation 6) successfully prevents policy collapse, and the Visual-ERM reward signal does not incentivize the policy to sacrifice general multimodal competence for vision-to-code improvements.

Scalability and generalization of Visual-ERM's judging (Appendix B.6): The paper argues that Visual-ERM's training covers "macro-level abstractions that encompass nearly the entire spectrum of errors in visual-to-code tasks," and that the dual-route data generation (Targeted Edit for coverage + Natural Inference for realism) ensures the model learns "the underlying logic of visual-to-code equivalence" rather than memorizing a fixed label set. This is a qualitative claim not directly tested with a rigorous out-of-distribution evaluation, though the strong performance on VC-RewardBench (which uses multi-model consensus annotations distinct from the GPT-5-mini training labels) provides indirect evidence. The paper also argues that Visual-ERM can naturally extend to related tasks (UI reconstruction, mathematical diagramming) because "these 'unseen' tasks rely on the same underlying principles of preserving shape, color, and structure," but no experiments on these domains are reported.

Qualitative case studies (Appendix D, Figures 13–16): The paper provides representative examples from VC-RewardBench across chart, table, and SVG domains, illustrating the types of fine-grained errors that Visual-ERM detects and describes. Figure 16 additionally provides cases where DINO similarity is very high (0.974–0.975) but Visual-ERM identifies multiple critical visual errors, reinforcing the Section 2 analysis that DINO-based rewards are too coarse for vision-to-code fidelity.

---

Critical Assessment

Central Claim 1: Visual-ERM provides an aligned, fine-grained, interpretable reward that substantially improves vision-to-code RL over text-based and vision-encoder rewards.

Assessment: Strongly supported for chart-to-code, moderately supported for SVG-to-code, weakly supported for table-to-markdown. The chart-to-code results (Table 1) are the most convincing: +8.4 over the base model on ChartMimic average, outperforming DINO-based RL (+6.5), with gains on both a standard backbone (Qwen3-VL-8B-Instruct) and a specialized one (VinciCoder-8B-SFT). The SVG results (Table 3) show a solid improvement (+3.7 Score) and crucially avoid the degradation that DINO-based RL suffers (−1.6 Score from the same starting point). The table results (Table 2) are more nuanced: +2.7 average is positive, but (a) it's a modest absolute gain on an already-strong baseline (76.8 → 79.5), (b) the paper does not compare against a table-specialized SFT model that would establish a stronger ceiling, and (c) the gain is concentrated in metrics that may partially reflect the render-success reward (the paper's ablation in Table 11 shows r_rsr accounts for some improvement). The dramatic failures of DINO-based RL on tables (−11.5 average) and TEDS-based RL (−2.0 average) are strong negative results that validate the paper's diagnostic framework, but they also set a low bar for Visual-ERM to clear.

Central Claim 2: Visual-ERM at 8B decisively outperforms Qwen3-VL-235B-Instruct and approaches proprietary models on fine-grained image-to-image discrepancy judgment.

Assessment: Supported, with the important qualification that VC-RewardBench evaluates a narrower capability than "general image-to-image discrepancy judgment." Table 5 clearly shows Visual-ERM (F1_h = 42.1) outperforming Qwen3-VL-235B-Instruct (F1_h = 29.5) by +12.6 points, and achieving the highest overall F1_h among all evaluated models (including proprietary ones). This is a genuinely impressive result for an 8B model. However, VC-RewardBench consists of structured visual data (charts, tables, SVGs) with well-defined error categories — it does not test discrepancy detection on natural images, complex scenes, or open-ended visual comparisons. The benchmark is well-matched to Visual-ERM's training distribution (the same domains), so the strong performance demonstrates effective reward-model specialization but does not necessarily indicate that a similar approach would work for other visual domains without comparable training data. The paper acknowledges this implicitly by framing VC-RewardBench as a diagnostic for vision-to-code reward models, not a general visual comparison benchmark.

Central Claim 3: Visual-ERM enables effective test-time scaling via reflection and revision.

Assessment: Supported, with the critical finding that self-reflection without Visual-ERM hurts performance. Table 4 shows Visual-ERM-guided reflection adds +8.0 over the base model and +3.1 over the RL-tuned model on ChartMimic average. The negative self-reflection result (−3.9 for base, −1.9 for RL-tuned) is methodologically important because it rules out the alternative explanation that any reflection loop would help — the external critic is necessary. The ablation on reflection rounds (Table 6) shows diminishing returns after 3 rounds, consistent with the model reaching the limit of its editing capability. The SVG TTS results (+1.0 over base, +0.4 over RL) are much weaker, suggesting that test-time scaling benefits are domain-dependent and larger when (a) the model has good first-attempt quality (so reflections can make targeted fixes rather than wholesale rewrites) and (b) errors are localized and describable (chart labeling errors are easier to describe and fix than SVG shape geometry errors).

Genuine weaknesses in the experimental design:

1. No combination of Visual-ERM-guided RL with PRM search or beam search. The paper treats test-time scaling purely as iterative revision of complete outputs. Alternative test-time strategies — such as sampling multiple candidates, scoring them with Visual-ERM, and selecting the best (a best-of-N approach using Visual-ERM as the verifier) — are not explored. This would have been a natural baseline given the paper's framing of the reward model as a general-purpose supervisor.

2. Missing DINO comparison on SVG RL from the Qwen3-VL-8B-Instruct backbone. Table 3 only reports RL from VinciCoder-8B-SFT, not from the weaker Qwen3-VL-8B-Instruct. This makes it impossible to assess whether Visual-ERM's advantage over DINO on SVG is consistent across base model quality levels, or whether DINO works fine for weaker SVG models (where global visual similarity might provide more signal) but fails for stronger ones.

3. No Table-to-Markdown RL from VinciCoder or other specialized table parser. Table 2 only reports RL from Qwen3-VL-8B-Instruct, with no comparison against a stronger SFT table model. This limits the evidence that Visual-ERM improves table parsing for already-competent policies — the +2.7 gain on a modest baseline (76.8) does not demonstrate that the reward remains aligned for near-ceiling table performance.

4. Single base model family (Qwen3-VL) for RL experiments. All RL experiments use Qwen3-VL-8B-Instruct as the policy backbone. While the paper also tests VinciCoder-8B-SFT (which is based on a different architecture, being a specialized code-generation model), all results are confined to the Qwen3-VL vision encoder and language model architecture. The paper does not demonstrate that Visual-ERM transfers as a reward to other LVLM families (e.g., InternVL, LLaVA), which matters because the reward model was trained to judge outputs from Qwen3-VL-8B-Instruct's error distribution (via the Natural Inference data generation route). Policies from other model families may produce qualitatively different error patterns that Visual-ERM is not calibrated for.

5. No confidence intervals or multiple-run variance. Every table reports point estimates without error bars, standard deviations, or significance tests. The ChartMimic test set, OmniDocBench, and UniSVG are all of moderate size (hundreds to low thousands of instances), and the observed gains (+2.7 on tables, +3.7 on SVG Score) are not so large that statistical noise can be ruled out without quantification. The VC-RewardBench judge ablation (Table 10) partially addresses evaluation variance, but this measures judge-dependent noise, not model-dependent noise (e.g., sensitivity to random seed, training data order, or RL initialization).

6. The reflection threshold and stopping criterion are not specified. The paper states that the policy revises if the reward "falls below a threshold" but does not report what threshold was used, how it was chosen, or whether the results are sensitive to this choice. This is a missing implementation detail that affects reproducibility.

7. Computational cost of test-time scaling is not accounted for in efficiency comparisons. The paper reports impressive gains from test-time scaling (+8.0 over base with 3 reflection rounds), but each reflection round requires an additional Visual-ERM inference plus an additional policy generation. At 3 rounds, this is at least 3× the inference cost of a single forward pass. The paper does not compare this to alternative ways of spending that inference budget (e.g., best-of-N sampling with Visual-ERM scoring, or simply using a larger model). The computational efficiency analysis in Appendix A.5 only covers training-time latency, not inference-time cost of the reflection loop.

Experiments that would have strengthened the paper but were not run:

• Best-of-N with Visual-ERM as a verifier, compared against the iterative revision approach, at matched inference budgets. This would test whether revision (sequential refinement) is better than parallel sampling with selection for vision-to-code.
• Cross-model transfer: training Visual-ERM on errors from Qwen3-VL-8B-Instruct and using it as a reward for InternVL or LLaVA policies, to test whether the reward model generalizes beyond the error distribution it was trained on.
• Scaling the amount of RL training data, to see whether more prompt images (11K → 40K → 100K for charts) yield monotonic improvements or saturate. The paper uses fixed data sizes without ablating this dimension.
• Comparison against human judgment, for instance by having human raters score a subset of chart generations and computing correlation with Visual-ERM's scores. This would directly validate the claim that Visual-ERM captures "visual equivalence" as a human would define it.
• RL with the VC-RewardBench metrics as the reward signal directly (using the F1 matching protocol as a differentiable reward), to quantify how much performance is lost by the severity aggregation + normalization pipeline vs. having access to the full structured output.

Conditions under which the claims hold:

The strongest claim — that Visual-ERM provides aligned supervision that substantially improves vision-to-code policies — holds clearly for chart-to-code across both standard and specialized backbones, with large absolute gains (+8.4, +10.1). It holds more modestly for SVG-to-code (+3.7 Score on VinciCoder) and table-to-markdown (+2.7 average), with the caveat that table baselines are already strong and the room for improvement may be bounded. The claim that specialized training on discrepancy-annotated data substitutes for model scale (Visual-ERM at 8B > Qwen3-VL-235B-Instruct) holds on VC-RewardBench but is strictly within the distribution of structured visual data — it does not extend to natural images or open-ended visual comparison. The claim that Visual-ERM enables effective test-time scaling holds for chart-to-code (+8.0 over base, +3.1 over RL) but is much weaker for SVG-to-code (+1.0, +0.4) and is not tested for table-to-markdown. The negative finding that self-reflection without an external critic degrades performance is consistent across settings (−3.9, −1.9, and implicitly for SVGs where self-reflection is not reported, likely because it was not effective). A broader implicit claim — that Visual-ERM's methodology (generative reward model trained on teacher-distilled discrepancy annotations) is general and transferable to other vision-to-code and multimodal generation tasks — is plausible but untested beyond the three tasks in the paper.

6. Limitations and Trade-offs

Dependence on a Proprietary Teacher Model for Reward-Model Training Data

The assumption or constraint. Visual-ERM's training data — the fine-grained discrepancy annotations on 340K image pairs (the combined chart, table, and SVG reward-modeling datasets) — are generated by GPT-5-mini, a proprietary model accessible only through a paid API. The paper acknowledges this directly in Section 3.1:

"We therefore use a stronger model, GPT-5-mini [35], as a bootstrap teacher that proposes candidate discrepancies, which are then filtered by rendering-consistency checks... We stress that GPT-5-mini is used only to label the training set D_reward and plays no role at evaluation time."

The annotation quality depends entirely on GPT-5-mini's ability to detect and describe structured visual discrepancies across three domains. While the paper implements quality-control mechanisms (rendering-consistency checks to filter hallucinated errors, structural agreement with ground-truth code to remove false positives), these filters can only remove bad annotations — they cannot generate higher-quality annotations than what the teacher provides. If GPT-5-mini systematically misses certain error types (e.g., subtle color mismatches below its detection threshold, or geometric distortions it categorizes incorrectly), those weaknesses propagate into Visual-ERM's training distribution.

The consequence. Three failure modes emerge from teacher dependence. First, Visual-ERM inherits the teacher's blind spots: if GPT-5-mini is poor at detecting a particular error type (say, font-weight mismatches in chart labels, or sub-pixel alignment errors in SVG paths), Visual-ERM will be trained on data that under-represents those errors, making it an unreliable judge for those discrepancy types. The paper provides some indirect evidence of this — Visual-ERM's VC-RewardBench performance on SVG is notably weaker than on charts and tables (F1_h = 28.3 vs. 39.9 and 56.4, Table 5), which could reflect either inherent SVG judging difficulty or GPT-5-mini's relative weakness on geometric error descriptions.

Second, reproducibility and equity barriers: an open-source research group cannot reproduce Visual-ERM's training without API access to a model of GPT-5-mini's capability level. The paper argues that "any residual annotator bias in D_reward is bounded by Visual-ERM's downstream RL gains (Sec. 4.1), which are measured on benchmarks independent of the training labels," but this defense validates the end-to-end system, not the reproducibility of the training pipeline. A group attempting to replicate with a weaker open-source teacher might produce a reward model that is worse at discrepancy detection, leading to weaker RL policies, without knowing whether the failure is due to the methodology or the teacher quality.

Third, distribution shift when the teacher becomes unavailable or updated: proprietary API models change over time (version updates, deprecations, behavioral modifications). If GPT-5-mini's successor model annotates errors differently — using slightly different severity thresholds, different category assignments, or different description styles — the Visual-ERM training distribution would drift, and a newly trained reward model might behave differently from the one evaluated in this paper, affecting reproducibility of the RL and TTS results.

What evidence exists in the paper. The paper does not systematically ablate teacher quality — it reports only GPT-5-mini as the annotation source, with no comparison to annotations from weaker models or human annotators. The VC-RewardBench evaluation (Table 5) reports GPT-5-mini's own judging performance (F1_h = 39.9 on charts, estimated ~30–35 on tables based on the proprietary model range), which is lower than Visual-ERM's performance on tables (56.4) and comparable on charts (39.9). This suggests Visual-ERM can exceed its teacher on some domains (the fine-tuning generalizes beyond the teacher's annotation style), but does not guarantee that all teacher blind spots are corrected. The paper does not report inter-annotator agreement between GPT-5-mini and the multi-model consensus labels in VC-RewardBench, which would directly quantify teacher fidelity.

Mitigation status. The quality-control filtering partially addresses hallucinated annotations, but does not mitigate systematic teacher biases or blind spots. The paper does not propose a method for training Visual-ERM without a proprietary teacher — for instance, using bootstrapped self-training where Visual-ERM's own judgments on unlabeled image pairs are filtered by consensus and added to the training set. The authors acknowledge the teacher's role transparently but treat it as a practical necessity rather than a limitation to be solved, and do not explore alternatives such as training the teacher on open-source data first or using ensemble distillation from multiple weaker open-source models.

---

Difficulty Estimation Cost Is Not Accounted For; Hard Problems Remain Unsolved

The assumption or constraint. The paper's reward model and RL training pipeline operate under an implicit assumption that the base policy can produce correctable outputs — renderings that contain visual errors, but errors that are within Visual-ERM's detection capability and the policy's revision capability. This assumption fails systematically on the hardest vision-to-code instances. The paper quantifies this indirectly through the difficulty-dependent analysis in Section 2 and through the test-time scaling results, but never explicitly identifies a capability floor below which Visual-ERM provides zero benefit.

The paper does not estimate question difficulty before allocating computation — unlike the reference example paper's compute-optimal test-time scaling framework, there is no mechanism to decide whether to apply RL or test-time scaling to a given prompt, only how much to apply. Every prompt receives the same RL reward signal and (in TTS experiments) the same number of reflection rounds (2–4), regardless of whether the base model has any chance of producing a correct output.

The consequence. Two distinct failure regimes emerge, neither of which the paper measures or mitigates:

Regime 1: The base model's pass@1 is near zero for a given prompt. If the policy cannot generate a rendering that is visually close to the reference on its first attempt, Visual-ERM's fine-grained feedback becomes irrelevant — no amount of reflection can fix a fundamentally wrong chart type or a completely garbled table structure. The paper's Section 2 analysis hints at this when showing that the hardest problems (presumably analogous to difficulty bin 5 in the reference example) see minimal RL improvement, but the paper does not stratify its RL gains by problem difficulty. The test-time scaling results provide indirect evidence: on SVG-to-Code, where the base model's performance is weaker (Score 64.2 for Qwen3-VL-8B-Instruct vs. 69.6 ChartMimic average for charts), TTS gains are dramatically smaller (+1.0 vs. +8.0, Tables 4 and 12). This suggests that for domains or prompts where the policy starts from a low-quality baseline, Visual-ERM's feedback cannot compensate for fundamental capability gaps.

Regime 2: Visual-ERM's judging accuracy degrades on highly erroneous outputs. The reward model was trained on a distribution of errors that spans from minor to severe (Targeted Edit injects errors at varying severity levels), but training data is finite, and extremely garbled renderings — where multiple severe errors interact in complex ways — may fall outside the training distribution. In such cases, Visual-ERM may hallucinate errors (detecting discrepancies that aren't present), miss errors (failing to enumerate all issues), or assign incorrect severity scores, producing a noisy reward signal that provides little useful gradient for policy improvement.

The practical consequence for a practitioner is: there is no diagnostic to determine whether Visual-ERM-guided RL or TTS will help for a given deployment task or model capability level. The paper demonstrates gains on Qwen3-VL-8B-Instruct (69.6 ChartMimic average, 76.8 table average, 64.2 SVG Score) and VinciCoder-8B-SFT (67.4 and 87.9), but does not test on weaker models (where gains might be larger or smaller — the direction is unclear) or on substantially harder benchmark subsets.

What evidence exists in the paper. The SVG TTS results (Table 12) are the clearest evidence: +1.0 over the base model, +0.4 over the RL-tuned model, compared to +8.0 and +3.1 for charts (Table 4). The paper acknowledges that "gains are bounded by the policy's editing ability, since TTS reuses π without weight updates" (Section 3.3), but this acknowledges only the TTS boundary, not the RL training boundary — the RL policy also requires a base model capable of generating improvable outputs. The paper does not report difficulty-stratified RL gains (e.g., binned by base model pass@1, analogous to the difficulty quintile analysis), which would reveal whether the +8.4 chart improvement is concentrated on easy-to-medium problems with negligible gain on the hardest instances. The ablation on reflection rounds (Table 6) shows diminishing returns after round 3 and a slight regression at round 4 (80.7 vs. 81.1), which is consistent with the model reaching a capability ceiling but does not directly quantify that ceiling's relationship to prompt difficulty.

Mitigation status. The paper does not attempt to address this — there is no difficulty estimation mechanism, no adaptive allocation of compute budget, and no analysis of how the marginal benefit of Visual-ERM supervision varies with base model capability or prompt difficulty. Future work on compute-optimal test-time scaling for vision-to-code (analogous to the reference example but applied to visual fidelity rewards) would directly address this limitation. The paper's contribution focuses on reward quality, not on when to deploy it, which is a defensible scope choice but leaves a practical gap.

---

Diagnostic Gap: RL Policy Improvements Are Not Directly Attributed to Reward Model Quality vs. Other RL Factors

The assumption or constraint. The paper's central validation strategy is triangulation: strong VC-RewardBench performance (reward model is a good judge) + strong downstream RL gains (reward model is a good supervisor) + positive TTS results (reward model enables inference-time refinement). However, the downstream RL gains are confounded with multiple factors beyond reward quality: the GRPO algorithm hyperparameters (learning rate 1 × 10⁻⁶, batch size 256, 8 rollouts per update), the KL regularization strength β (not reported), the RL training data size and distribution (11K chart images, 40K table images, 10K SVG images), and the number of RL training steps (not reported). A policy trained with Visual-ERM could outperform a policy trained with DINO-based rewards because Visual-ERM provides a genuinely better reward signal or because the GRPO configuration happens to be better-tuned for the Visual-ERM reward's scale and variance characteristics.

The paper does not perform the experiment that would cleanly isolate reward quality: evaluate Visual-ERM's reward scores on a set of policy outputs and compute their correlation with ground-truth task metrics (ChartMimic scores, TEDS, SSIM, etc.). If Visual-ERM's summed severities correlate strongly with downstream task scores, that directly validates alignment. If the correlation is moderate, the RL gains might be attributable partly to other factors (e.g., the render-success reward term, the KL regularization preventing policy collapse, or favorable RL hyperparameters). The paper's ablation in Table 11 shows that removing the render-success reward (r_rsr) has a modest effect (+2.7 → +2.2 average on Table-to-Markdown), but this only isolates r_rsr's contribution, not Visual-ERM's correlation with true quality.

The consequence. A practitioner cannot determine how much of the observed RL gain is due to Visual-ERM's fine-grained, interpretable feedback specifically, versus due to having any visual reward at all that correlates loosely with rendering quality. This matters for two deployment decisions:

1. If Visual-ERM is unavailable or too expensive, could a simpler reward — e.g., a lightweight discriminative model trained to regress ChartMimic scores from image pairs — achieve comparable RL gains? The paper compares against DINO (which is fundamentally misaligned) and TEDS (which is blind to rendering), but not against an intermediate approach: a model trained specifically to predict human-judged visual fidelity scores. This is a missing baseline.

2. If the practitioner wants to improve Visual-ERM, should they invest in better error detection (higher F1_h on VC-RewardBench), better severity calibration (higher S_c), or better coverage of rare error types? Without a direct correlation analysis between reward model metrics and downstream RL gains, the path to improvement is unclear. The paper's multi-task RM ablation (Table 9) shows that a better RM (mixed-data: F1_h = 56.4 on tables) yields better RL (79.5 vs. 78.6 average) than a weaker RM (table-only: F1_h = 53.6 on tables), which provides some evidence that RM quality matters, but this is a single comparison point with confounding factors (the mixed-data RM also had different training data volume).

What evidence exists in the paper. The paper provides some indirect evidence for reward alignment:

• Figure 2(a) shows that Visual-ERM's proxy reward keeps increasing during RL training while DINO and TEDS rewards saturate, suggesting that Visual-ERM's reward remains discriminative even as the policy improves (i.e., it doesn't reward-hack as easily).
• Table 9 shows that Visual-ERM (mixed-data) at F1_h = 56.4 yields better RL than a table-only RM at F1_h = 53.6, consistent with better judging → better supervision → better policy.
• The DINO and TEDS failures (Tables 1–3) demonstrate that bad rewards produce bad policies, establishing a lower bound on acceptable reward quality.

However, the paper does not report:

• Pearson or Spearman correlation between Visual-ERM's r_verm scores and ground-truth ChartMimic/TEDS/SSIM scores on a set of policy outputs.
• A scatter plot of r_verm vs. downstream task metric, which would reveal whether the reward is well-calibrated across the quality range (e.g., whether r_verm = 0.8 always corresponds to better charts than r_verm = 0.6, or whether there is noise).
• A comparison where a discriminative reward model (trained to directly predict ChartMimic scores) replaces Visual-ERM in the RL pipeline. This would test whether the generative, fine-grained reward architecture provides benefits beyond having a well-calibrated visual quality predictor.

Mitigation status. The paper partially addresses the confound concern through the ablation in Table 11 (with vs. without r_rsr) and the multi-task RM comparison in Table 9, but these are coarse. The paper does not provide a formal reward-hacking analysis (analogous to the reference example's analysis of PRM over-optimization) that would quantify at what point Visual-ERM's reward becomes unreliable under aggressive optimization. The triangulation strategy — strong VC-RewardBench + strong RL gains + strong TTS gains — provides convergent evidence for reward quality, but does not isolate the reward signal's individual contribution or establish its causal role.

---

Single Model Family and Lack of Cross-Architecture Transfer Evidence

The assumption or constraint. All RL experiments use Qwen3-VL-8B-Instruct as the policy backbone (the paper also uses VinciCoder-8B-SFT for Chart and SVG RL, but VinciCoder is itself derived from a code-specialized model in the Qwen family, Appendix A.1). Visual-ERM is trained on error data where the Natural Inference component comes specifically from Qwen3-VL-8B-Instruct rollouts — the "weaker LVLM" that generates naturally occurring parsing errors is the same model that serves as the RL policy. The paper states (Section 3.1):

"Natural Inference: weaker LVLMs predict y directly, so the resulting errors match the distribution that an RL policy actually emits during rollout."

This design ensures that Visual-ERM's training distribution matches the RL policy's error distribution — a sound choice for the experiments reported. However, it also means that Visual-ERM is calibrated to the specific error patterns of Qwen3-VL-8B-Instruct. A different base model (InternVL3.5-8B, Qwen2.5-VL-7B, LLaVA, or a model from a different family) would produce qualitatively different errors — different types of chart mistakes, different table formatting failures, different SVG geometric distortions — that may not be well-represented in Visual-ERM's training data.

The consequence. A practitioner using a different LVLM as their vision-to-code policy cannot assume that Visual-ERM will provide equally aligned supervision without additional calibration. Three specific failure modes are possible:

1. Unfamiliar error types are misjudged. If a non-Qwen3 policy produces error patterns that Visual-ERM has not seen during training (e.g., a model that tends to generate syntactically valid but semantically wrong chart code, producing plots with correct structure but completely wrong data), Visual-ERM may assign incorrect severity scores or fail to detect certain errors.

2. Known error types appear with different severity distributions. If a different policy produces errors that are systematically more severe or more subtle than Qwen3-VL-8B-Instruct's errors, Visual-ERM's severity calibration (mapped to S_c on VC-RewardBench) may be off, producing rewards that are either too harsh or too lenient relative to the policy's actual quality.

3. The reward model's own backbone is Qwen3-VL-8B-Instruct. Since Visual-ERM is built by fine-tuning Qwen3-VL-8B-Instruct, it shares the base model's visual encoder and multimodal fusion layers. This means the two models (reward model and policy, when using Qwen3-VL-8B-Instruct as the policy) share inductive biases from the same pretraining. If there are systematic vision-encoder biases in Qwen3-VL — for instance, a tendency to miss certain text fonts or color combinations — both the policy (which generates errors involving those features) and the reward model (which judges them) might share those blind spots, creating a correlated failure mode where the policy's errors go undetected by the reward. This would artificially inflate the apparent alignment of the reward signal.

What evidence exists in the paper. The paper does not test cross-model transfer. The closest evidence is:

• VinciCoder-8B-SFT results (Tables 1 and 3), where Visual-ERM-guided RL on a non-Qwen3 policy still yields gains (+10.1 on ChartMimic, +3.7 on SVG). However, VinciCoder-8B-SFT is itself a specialized code model, and its error distribution may overlap substantially with Qwen3-VL-8B-Instruct's if both are trained on similar chart datasets. This is weak evidence for general cross-model transfer.
• The VC-RewardBench results (Table 5) evaluate Visual-ERM on a fixed benchmark of image pairs, independent of which model generated the errors. High F1 on VC-RewardBench suggests Visual-ERM is a good judge of visual discrepancies in general, but does not guarantee it provides well-calibrated rewards for RL when the error distribution shifts (VC-RewardBench includes errors from multiple sources, but the distribution of error types and severities in RL rollouts may differ substantially).
• The paper evaluates other LVLMs on general VQA benchmarks (Table 7) but only as a sanity check for policy capability preservation, not as RL policy backbones.

Mitigation status. The paper does not address this limitation. It does not report RL experiments with non-Qwen3 policy models, does not analyze whether Visual-ERM's reward scores correlate differently with policy quality for different base models, and does not propose a method for adapting Visual-ERM to new policy error distributions (e.g., through continued fine-tuning on rollouts from the new policy). The Natural Inference data generation route could in principle be reapplied: for any new base model, generate rollouts, render them, compare against references, and (either use GPT-5-mini again or use the existing Visual-ERM) to annotate discrepancies for fine-tuning. However, this requires re-running the expensive teacher distillation pipeline, which the paper does not discuss as a deployment workflow.

---

The Scalar Reward Pipeline Discards Fine-Grained Information That Could Improve RL Sample Efficiency

The assumption or constraint. Visual-ERM produces rich structured output: a categorized, localized, severity-weighted list of errors. The RL reward pipeline (Section 3.2) collapses this into a single scalar r_verm via severity sum → batch normalization → inversion → clipping. This design choice is motivated by compatibility with GRPO, which requires scalar rewards. However, it raises a fundamental question: is all that fine-grained annotation structure actually necessary for RL, or would a simpler model that directly predicts a scalar visual quality score (trained via regression on the same teacher-provided total severities) work equally well?

The paper's architecture generates fine-grained feedback and then discards most of its richness for RL training, preserving the full structure only for test-time scaling. During RL, the policy never sees the localized error descriptions, the per-category breakdown, or even the individual severity scores — it only sees the scalar r_verm. This means the RL gradient through the reward signal provides no information about which types of errors the policy is making or where they are occurring — all errors are pooled into a single penalty sum.

The consequence. Two efficiency losses arise from this information bottleneck:

1. Sample inefficiency in RL: a scalar reward provides a weak learning signal because it doesn't distinguish between qualitatively different failures. A policy that generates a chart with a wrong title (text_error, severity 1) and a policy that generates a chart with inverted axes (structure_error, severity 3) receive different scalar penalties, but the scalar alone doesn't tell the policy that the first error is a text hallucination problem (fixable by attending more carefully to the reference image's text regions) while the second is a global structure planning problem (requiring a different generation strategy). The policy must discover these distinctions through many RL updates, correlating its own token-level decisions with the scalar reward through noisy Monte Carlo estimates. If the reward model instead provided token-level or region-level feedback — e.g., "the title tokens are wrong, here is what the title should be" — the policy could learn much faster.

2. Missed opportunity for structured RL algorithms: recent work on RL with language feedback (e.g., using natural-language critiques as dense rewards, or using structured error types to weight different policy gradient components) could leverage Visual-ERM's rich output directly. The paper's design choice to collapse to a scalar is compatible with standard GRPO — a reasonable engineering decision — but it leaves open the question of whether a more sophisticated RL algorithm that consumes the full structured output (error types, locations, descriptions) would yield even larger gains at the same or lower sample complexity.

What evidence exists in the paper. The paper does not ablate the scalar reward design against alternatives. There is no comparison between:

• The current pipeline (severity sum → scalar → GRPO) vs.
• A hypothetical pipeline where the policy receives Visual-ERM's full structured output as intermediate supervision during RL (e.g., as an auxiliary loss predicting error types from policy hidden states).

The test-time scaling results (Table 4) provide indirect evidence for the value of structured feedback: when the policy IS given the full discrepancy descriptions (during reflection), it improves substantially (+8.0 over base, +3.1 over RL-tuned). This demonstrates that the policy can usefully act on structured feedback — but only at inference time, not during training. The paper does not explore whether incorporating structured feedback into the RL training loop (e.g., through a multi-task objective that jointly optimizes for high r_verm AND low error-type-specific losses) would yield additional gains.

The computational efficiency analysis (Appendix A.5) shows that Visual-ERM at 8B is surprisingly efficient (0.17 hours/step vs. 0.24 for DINOv2-large), suggesting that the cost of generating structured output is not prohibitive. The paper could therefore afford to provide structured feedback during RL training without dramatically increasing computational cost.

Mitigation status. The paper acknowledges that the scalar reward is a simplification for GRPO compatibility:

"The paper frames the choice of how to consume Visual-ERM's output as a pragmatic one — scalar rewards are needed for policy gradient methods — but doesn't analyze whether richer reward consumption would be beneficial."

No direct mitigation is attempted. The test-time scaling pipeline demonstrates that structured feedback HAS value, but this value is realized only at inference time through explicit conditioning, not during RL training through the objective function. The paper positions the dual-use design (scalar for RL, structured for TTS) as a feature rather than a limitation, but a practitioner might reasonably ask: could we get the TTS-level gains (where the policy sees specific error locations) during RL training itself, reducing the need for expensive test-time reflection loops?

---

VC-RewardBench Evaluates Judging on a Matched Distribution; Out-of-Distribution Judging Quality Is Unknown

The assumption or constraint. VC-RewardBench, despite its careful multi-model consensus construction, consists of image pairs and error types drawn from the same underlying distributions as Visual-ERM's training data — structured visual data (charts, tables, SVGs) with error categories that match the taxonomy used during training. The paper notes (Appendix A.3) that charts are dominated by style and data errors, tables by text recognition errors, and SVGs by shape and structure errors. These distributions reflect the composition of the reward-model training set.

However, a reward model deployed in practice will encounter distribution-shifted inputs in several forms:

1. Unseen chart types, table formats, or SVG styles not present in the training data (e.g., radar charts, nested tables with merged cells spanning multiple rows and columns, or SVGs with complex gradient meshes).

2. Errors that combine multiple categories in ways not seen during training — e.g., a chart where a text_error (wrong axis label) causes a secondary data_error (the viewer misinterprets the scale), creating a compound error that Visual-ERM's per-category annotation taxonomy may not cleanly decompose.

3. Entirely new vision-to-code tasks (the paper mentions UI-to-code, scientific diagram reconstruction, and mathematical formula rendering as potential applications; Appendix B.6) where the visual discrepancy types differ qualitatively from chart/table/SVG errors.

4. Adversarial or edge-case inputs designed to exploit blind spots in Visual-ERM's training (e.g., charts where the visual error is a subtle 5% color opacity difference that changes the perceptual hierarchy, or SVG icons where the error is a missing anti-aliasing pixel that makes an edge appear jagged).

The consequence. The paper's strong VC-RewardBench results (42.1 F1_h, surpassing proprietary models) guarantee that Visual-ERM is a reliable judge within the training distribution, but provide no guarantee about out-of-distribution (OOD) robustness. For a practitioner deploying Visual-ERM on a custom vision-to-code task — say, converting architectural floor plans to structured JSON, or parsing hand-drawn diagrams to formal representations — the following failure modes are plausible but unmeasured:

• Systematic under-detection: Visual-ERM may miss error types that don't fit neatly into its training taxonomy, producing spuriously high r_verm scores for incorrect outputs (reward hacking vulnerability).
• Systematic over-detection: Visual-ERM may hallucinate errors in unfamiliar visual patterns, producing spuriously low r_verm scores for correct outputs (unfair penalization, discouraging the policy from exploring novel but valid generation strategies).
• Calibration shift: the mapping from error severities to actual visual impact may differ across domains — a "severe" (3) shape error in an SVG icon might matter less than a "moderate" (2) text error in a data table, but Visual-ERM's severity scale is fixed from training.

What evidence exists in the paper. The paper provides no OOD evaluation. The closest evidence is:

• The multi-task ablation (Table 8) shows that models trained on a single domain (e.g., Chart-Data-Only) generalize poorly to other domains (F1_h drops from 40.1 on Chart to 17.2 on Table and 11.3 on SVG). This suggests that the discrepancy detection capability is domain-specific and does not transfer without explicit multi-task training. If chart-to-table transfer is poor within the same structured-visual family, transfer to completely unseen domains (UI screenshots, diagrams) is likely worse.
• The mixed-data model achieves more balanced performance (F1_h = 42.1 average), but still shows substantial domain variation (56.4 on tables vs. 28.3 on SVG). This suggests that even within the training distribution, judging quality varies significantly by domain, making OOD performance unpredictable.
• The paper's qualitative claim about scalability (Appendix B.6: "Visual-ERM does not just learn task-specific rules; it learns the universal rules of visual-to-code equivalence") is untested speculation. The F1_h drops for single-domain models transferring to other domains contradict the claim of universality — if the rules were truly universal, a chart-trained model would perform reasonably on tables (both require detecting text mismatches, layout errors, and structural deviations), but Table 8 shows it does not.

Mitigation status. The paper does not address OOD robustness. It does not propose evaluation protocols for testing reward model calibration on unseen distributions (e.g., fine-tuning Visual-ERM on a small amount of target-domain data and measuring the improvement in RL gains, which would reveal how quickly the reward model adapts). The paper's suggestion that Visual-ERM "can be naturally extended to a wider range of vision-to-code scenarios without requiring fundamental architectural changes" (Appendix B.6) is proposed as future work, with no experimental evidence. A practitioner would need to either (a) invest in annotation of their target domain and fine-tune Visual-ERM, replicating the expensive GPT-5-mini distillation pipeline, or (b) deploy Visual-ERM as-is and accept unknown OOD judging quality, with the risk of reward misalignment that the paper's Section 2 so carefully analyzes for existing approaches.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper shifts the conversation around reward design for multimodal generation from metric benchmarking to property-based diagnosis. Prior work on vision-to-code RL treated reward selection as an empirical optimization problem: test a few candidate rewards (TEDS, DINO similarity, maybe an ensemble), pick the one that produces the best downstream policy, and move on. ChartMaster used DINO similarity without analyzing why DINO's semantic invariance makes it unreliable for chart fidelity. VinciCoder combined DINO with text-based rewards as a pragmatic ensemble, implicitly treating the weaknesses of each as orthogonal noise to be averaged out. Table2LaTeX-RL used TEDS as if textual structural similarity were a valid proxy for visual correctness. None of these works articulated a necessary-and-sufficient property framework for the reward signal itself.

The paper's Section 2 analysis reframes the entire problem: instead of asking "which reward metric works best?", researchers should ask "which properties must a reward satisfy for this task, and which existing approaches violate them?" The four proposed properties — visual (operate in rendered image space), fine-grained (detect element-level errors), interpretable (expose what went wrong), and task-agnostic (work across related tasks) — are derived from first-principles reasoning about what vision-to-code correctness means, not from empirical comparison. This is a conceptual contribution distinct from the specific method: even if Visual-ERM were eventually superseded by a different architecture, the diagnostic framework would remain useful for evaluating any future vision-to-code reward.

What makes this reframing significant — rather than just a well-structured literature review — is that it is predictive, not just descriptive. The property violations predict specific failure modes: text-based rewards will saturate via reward hacking without improving visual fidelity (Figure 2a,c), and vision-encoder rewards will provide spurious high scores to visually wrong outputs (Figure 2, bottom-left) and degrade performance on text-centric tasks like table parsing (Table 2, DINO-based RL drops average by −11.5 points). These predictions are empirically validated in the paper's own experiments, and they explain why prior RL approaches for vision-to-code have shown mixed or negative results — they were optimizing against rewards that fundamentally violate at least two of the four necessary properties.

The paper also changes the landscape by demonstrating that reward model specialization can substitute for raw model scale in multimodal judging tasks. The comparison in Table 5 — Visual-ERM at 8B (F1_h = 42.1) vs. Qwen3-VL-235B-Instruct (F1_h = 29.5), a model roughly 29× larger — is not just an impressive benchmark number. It establishes that fine-grained visual discrepancy detection is not an emergent capability of scale; it requires targeted training on the right supervision signal. A general-purpose 235B LVLM, trained on broad multimodal understanding, performs poorly at detecting element-level chart errors, table text mismatches, and SVG shape deviations because its training objective (next-token prediction on diverse multimodal data) never requires precise image-to-image comparison. Visual-ERM's specialized training on discrepancy-annotated image pairs confers capabilities that scale alone does not provide. This finding has implications beyond vision-to-code: for any multimodal task requiring precise, localized comparison (medical image analysis, industrial inspection, satellite image change detection), fine-tuning a smaller model on task-specific discrepancy annotations may be more effective than deploying a large general-purpose model.

The paper's dual-use deployment of Visual-ERM — as both a scalar reward provider for RL training and a natural-language critic for test-time scaling — introduces a pattern that could generalize to other domains. The key insight is that a generative reward model produces rich structured output (categorized, localized error descriptions with severities) that can be consumed in two ways: collapsed to a scalar for policy gradient methods (where scalar rewards are required), and preserved in full as actionable feedback for inference-time refinement (where interpretability is essential). Prior work treated these as separate systems — an RL reward model for training, a separate critique model or self-reflection prompt for test-time improvement. The paper demonstrates that a single model can serve both roles without modification, reducing the engineering complexity of deploying vision-to-code systems with both training-time and inference-time optimization.

The paper also provides a practical resolution to the apparent contradiction in the literature about whether VLMs can self-correct on visual tasks. The negative self-reflection results in Table 4 — the policy's own self-critique degrades ChartMimic performance by −3.9 points (base model) and −1.9 points (RL-tuned model) — confirm that self-assessment without external verification is unreliable for vision-to-code, consistent with broader findings about LLM self-correction failures on reasoning tasks. However, the Visual-ERM-guided reflection results (+8.0 and +3.1 points) show that external, trained critics can enable effective self-correction. This reconciles the pessimistic view (VLMs cannot self-correct) with the optimistic view (test-time refinement works) by showing that the key variable is the quality of the critic, not the act of reflection itself. A policy can usefully revise its outputs when given precise, localized, externally-verified feedback about what to fix; it cannot reliably generate that feedback itself.

Finally, the paper's release of VC-RewardBench provides a shared diagnostic tool that the field has been missing. Prior work evaluated reward models for vision-to-code only indirectly, through the downstream performance of policies trained with them — a confounded metric that mixes reward quality with RL algorithm tuning, policy architecture, and training data. VC-RewardBench provides a direct, task-level evaluation of image-to-image discrepancy judgment (F1 on error detection, Pearson correlation on severity calibration), enabling researchers to ablate reward model quality independent of downstream RL. The multi-model consensus construction protocol (three proprietary annotators, human consolidation, LLM-as-Judge matching) sets a methodological precedent for how to build evaluation benchmarks for generative reward models that produce structured natural-language output — a format that defies standard exact-match metrics. The robustness analysis in Appendix B.3 (Table 10), showing only 2–3 point F1 variation across four different judge models, validates that the LLM-as-Judge protocol produces stable rankings, making VC-RewardBench a reliable yardstick for future reward model development.

Follow-Up Research This Work Enables

Direct correlation analysis between Visual-ERM scores and human judgments of visual fidelity. The paper's validation strategy is triangulation (VC-RewardBench performance + downstream RL gains + TTS improvements), but it never directly measures whether Visual-ERM's r_verm scores correlate with human quality ratings. A straightforward follow-up would collect human judgments on a graded set of chart and table renderings (e.g., 500 image pairs rated on a 1–5 Likert scale by 3–5 annotators each), compute Pearson and Spearman correlation between r_verm and mean human ratings, and compare against DINO similarity and TEDS correlations on the same data. This would directly validate the paper's central claim that Visual-ERM captures "visual equivalence" as humans define it. A negative result — moderate correlation despite strong VC-RewardBench performance — would suggest that the benchmark's error categories miss dimensions of visual quality that humans care about (e.g., aesthetic appeal, perceptual readability), revealing a gap between "detecting errors" and "judging quality."

Compute-optimal test-time scaling with Visual-ERM as the verifier. The paper's test-time scaling uses iterative revision (sequential refinement), but does not explore alternative test-time strategies such as best-of-N sampling with Visual-ERM as the selection verifier (generate N independent candidates, score each with r_verm, select the best). This is the natural comparison: for a fixed inference budget (e.g., 4 generations), is it better to generate 4 independent candidates and pick the best (best-of-4), or to generate 1 candidate and revise it 3 times (1 + 3 reflections)? The paper's Table 6 shows that 3 reflection rounds improve the RL-tuned policy from 78.0 to 81.1 (+3.1), but uses 3 additional policy generations plus 3 Visual-ERM inferences. A best-of-4 approach would use 4 policy generations plus 4 Visual-ERM inferences (similar cost) and might perform differently. This experiment would characterize the exploration-exploitation tradeoff in test-time compute: iterative revision exploits the initial candidate by making targeted fixes, while best-of-N explores diverse solutions. The difficulty-dependent analysis — do easy charts benefit more from revision (local refinement) while hard charts benefit from best-of-N (global exploration)? — would mirror the reference example paper's findings on search vs. revisions for math reasoning, applied to visual fidelity.

Cross-model transfer: using Visual-ERM as a reward for non-Qwen3 policy models. The paper's RL experiments all use Qwen3-VL-8B-Instruct as the policy backbone (or VinciCoder, which shares the same vision encoder lineage). The Natural Inference component of Visual-ERM's training data comes specifically from Qwen3-VL-8B-Instruct rollouts, calibrating the reward model to that model's error distribution. A critical stress test is whether Visual-ERM transfers as a reward to policies from different model families — InternVL3.5-8B, Qwen2.5-VL-7B, or a LLaVA-based model. The experiment would: (a) generate rollouts from the non-Qwen3 policy on chart-to-code training prompts; (b) compute Visual-ERM's r_verm scores on those rollouts; (c) measure the correlation between r_verm and ground-truth ChartMimic scores; (d) run GRPO with Visual-ERM as the reward and measure downstream improvement. If Visual-ERM transfers well (correlation remains high, RL yields gains), the reward model is genuinely task-agnostic across policy architectures — a strong result that would justify its use as a drop-in reward for any vision-to-code system. If transfer is poor, the Natural Inference calibration is policy-specific, and deploying Visual-ERM with a new base model requires regenerating training data with rollouts from that model (expensive) or fine-tuning Visual-ERM on the new model's error distribution (a domain adaptation problem). A negative result here would scope the paper's contribution more precisely: Visual-ERM is a good reward for Qwen3-family models, not a universal vision-to-code reward.

Bootstrapping reward models from open-source teachers through iterative self-training. The paper's dependence on GPT-5-mini as the annotation teacher is a reproducibility barrier (Section 6 discusses this as a limitation). A natural follow-up asks: can Visual-ERM be trained without proprietary models? One approach: (1) train an initial weak reward model using only simple rule-based discrepancy heuristics (e.g., pixel-wise difference maps thresholded and clustered into error regions, with template-based severity assignments); (2) use this weak reward model to score and critique rollouts from the policy; (3) select high-confidence critiques (those where multiple independently-trained weak reward models agree, or where the critique matches downstream task metric improvements) as pseudo-labels; (4) fine-tune a stronger reward model on the pseudo-labeled data; (5) iterate. The key question is whether the initial weak reward (far below GPT-5-mini quality) provides enough signal to bootstrap a reward model that approaches Visual-ERM's VC-RewardBench performance. Success would make the methodology fully open-source and self-contained, removing the proprietary teacher barrier. Failure — the bootstrapped reward model plateaus far below Visual-ERM — would establish that a high-quality initial teacher is a necessary ingredient, scoping the methodology's accessibility.

Structured reward consumption: using Visual-ERM's per-category, per-location feedback during RL training (not just TTS). The current pipeline collapses Visual-ERM's structured output into a scalar r_verm for RL, discarding information about error types, locations, and descriptions that could provide denser training signals. A follow-up could design an RL objective that consumes the full structured output: for example, training the policy with auxiliary losses that predict error types from intermediate hidden states (forcing the policy to develop internal representations that anticipate where errors will occur), or using the localized error locations to weight the policy gradient — tokens corresponding to erroneous regions (e.g., the line of code that sets the y-axis label) receive higher gradient magnitudes than tokens far from errors. The experiment would compare: (a) standard GRPO with scalar r_verm (the current approach) vs. (b) GRPO augmented with an auxiliary loss predicting error categories from the policy's last-hidden-layer representations of the generated code, vs. (c) GRPO with gradient weighting based on Visual-ERM's error location fields mapped back to token spans in the code. If (b) or (c) yield faster convergence or higher final performance at matched training steps, it would demonstrate that the fine-grained annotation structure — which the paper argues is essential for reward quality — provides value beyond what a well-calibrated scalar reward could achieve.

Adversarial robustness of Visual-ERM under aggressive policy optimization. The paper documents that DINO-based rewards suffer from reward hacking (Figure 2a: proxy reward saturates while downstream performance plateaus), but does not analyze whether Visual-ERM is similarly vulnerable when the policy is optimized more aggressively. The reference example paper's analysis of PRM over-optimization (beam search degrading easy-problem performance at high budgets) provides a template: train a policy against Visual-ERM for many more steps than the paper reports, deliberately pushing toward over-optimization, and measure whether r_verm continues to correlate with downstream ChartMimic scores or starts to diverge. Specifically, generate policy outputs at different training checkpoints, compute both r_verm and ChartMimic scores, and plot their relationship. If Visual-ERM is robust, the correlation should remain high even for strongly optimized policies (r_verm ≈ 0.95 should correspond to genuinely near-perfect charts). If it exhibits over-optimization, the correlation will weaken after some threshold, and the policy will learn to exploit Visual-ERM's blind spots — generating renderings that score well under Visual-ERM but are visually wrong to humans. Identifying these blind spots (through qualitative analysis of high-r_verm, low-ChartMimic outputs) would reveal specific improvements needed in the reward model's training data or architecture. A negative finding — Visual-ERM is easily reward-hacked — would motivate research on adversarial training for visual reward models, where the training set is augmented with policy-generated examples that achieve spuriously high teacher scores.

Practical Applications and Downstream Use Cases

Automated quality assurance for chart and table generation in production data pipelines. Organizations that generate large volumes of charts and tables from data (financial reporting, scientific publishing, business intelligence dashboards) currently rely on manual review or brittle rule-based checks (e.g., "does the generated Matplotlib code execute without errors?"). Visual-ERM at 8B — which the paper shows is computationally efficient (0.17 hours per training step, faster than DINOv2-large at 0.24 hours; Appendix A.5) — can serve as an automated visual QA system: for each generated chart or table, render it, compare against the reference data specification (rendered as a reference image), and flag any discrepancies with localized descriptions. The VC-RewardBench results (Table 5) suggest this is feasible: Visual-ERM achieves F1_h = 56.4 on table error detection and F1_h = 39.9 on chart error detection, meaning it catches the majority of visual discrepancies and provides actionable localization. The +2.7 average improvement on Table-to-Markdown RL (Table 2) and the +8.4 on Chart-to-Code (Table 1) demonstrate that Visual-ERM's supervision translates to measurable fidelity improvements in the types of outputs these pipelines produce. The test-time scaling capability adds further value: if Visual-ERM flags a chart as having errors, the same policy that generated it can revise it with Visual-ERM's feedback, achieving the +3.1 TTS gain on RL-tuned policies (Table 4) without human intervention. The primary deployment cost is running Visual-ERM inference on each generated output — at 8B parameters, this is feasible on a single GPU with sub-second latency for typical chart/table images.

Bootstrapping vision-to-code capabilities for new domains without large paired datasets. The paper's core methodology — train a reward model on teacher-distilled discrepancy annotations, then use it to guide RL — is domain-agnostic in principle. For a new vision-to-code task where paired (image, ground-truth code) data is scarce but a proprietary teacher model is available (or a strong open-source model suffices), an organization can: (a) collect a modest set of reference images and ground-truth structured outputs (a few hundred to a few thousand); (b) synthesize erroneous predictions via Targeted Edit and Natural Inference (using their existing weaker policy); (c) annotate discrepancies with the teacher; (d) train a Visual-ERM variant on the resulting 50–100K pairs; (e) run GRPO with the new reward model on their policy. The paper's results suggest that this pipeline can be effective with reasonable data volumes: 11K prompt images for Chart RL, 40K for Table RL, 10K for SVG RL (Appendix A.2). The multi-task data mixing ablation (Table 8) suggests that joint training across related domains improves reward quality, so an organization targeting a new domain could augment their task-specific training data with existing chart/table/SVG data to benefit from cross-task transfer of error detection patterns. The key deployment decision is whether the teacher annotation quality — GPT-5-mini was used in this paper — is available or replicable for the new domain. If the teacher's accuracy on the new domain is significantly lower than on charts/tables (which is plausible for niche or highly technical figures), the reward model quality would degrade, and RL gains would shrink.

Self-improving document parsing systems that improve through iterative deployment. A document parsing service (extracting tables and charts from PDFs into structured formats) can deploy an initial policy model, collect real user queries, and use Visual-ERM in an online self-improvement loop: (a) the policy parses a user's document image; (b) Visual-ERM scores the rendered output against the original image; (c) if the score is below a quality threshold, the policy revises using Visual-ERM's feedback (TTS) to improve the immediate output; (d) high-quality revisions (those that substantially improve Visual-ERM's score) are added to a training buffer; (e) periodically, the policy is fine-tuned on the buffer of successful revisions, improving its first-attempt quality. The paper provides evidence for each step: TTS works (+8.0 over base with Visual-ERM feedback, Table 4), RL works (+8.4 on charts, Table 1), and the combined effect is additive (+3.1 TTS gain on top of RL, Table 4). The self-improvement loop amplifies these gains over time: as the policy improves, it generates fewer errors, making Visual-ERM's job easier (fewer discrepancies to detect), and the revision step becomes faster (fewer required reflection rounds). The VC-RewardBench severity correlation (S_c = 58.4, Table 5) suggests Visual-ERM's scores are calibrated enough to serve as a reliable quality gate for deciding which revisions to add to the training buffer. The primary risk is distribution shift: as the policy improves, its error distribution shifts away from the Natural Inference errors in Visual-ERM's training data, potentially reducing reward accuracy. Periodic fine-tuning of Visual-ERM on the policy's updated error distribution (using the same teacher distillation pipeline on recent rollouts) would mitigate this, at the cost of recurring proprietary API usage.

When to Prefer This Method

The paper does not present a systematic tradeoff analysis against named alternatives, and producing a generic decision matrix (e.g., "Prefer Visual-ERM when X, prefer DINO when Y") would be speculation rather than paper-grounded guidance. The paper's experimental design is a series of comparisons showing Visual-ERM outperforming specific baselines (DINO, TEDS, self-reflection, base SFT) on specific tasks (charts, tables, SVGs with Qwen3-VL-8B-Instruct and VinciCoder-8B-SFT backbones), but it does not characterize the conditions under which an alternative reward approach would be preferable. The paper's central claim is that Visual-ERM provides a reward signal satisfying four necessary properties that existing approaches violate, and the experiments demonstrate that satisfying those properties leads to better downstream policies. A practitioner reading the paper should infer that for any vision-to-code task where the reward model can be trained on teacher-distilled discrepancy annotations from the target domain, Visual-ERM's approach is likely to outperform text-based rules (which are blind to rendering) and vision-encoder similarities (which are too coarse and uninterpretable). The paper does not claim that Visual-ERM is always superior to any possible alternative — it does not, for example, compare against a discriminative reward model trained to directly regress ChartMimic scores, or against RL with ground-truth execution feedback (e.g., checking that generated chart code produces exactly the expected data values). The absence of these comparisons means a decision matrix would lack the paper-specific grounding required.