VBVR-Pro: A Scalable and Verifiable Suite for Native Visual Reasoning

Junxiang Xu, Ruisi Wang, Fanyi Pu, Maijunxian Wang, Ran Ji, Tongxi Zhou, Chenyang Gu, Jing Zuo, Hongcan Xiao, Yimeng Geng, Wanqi Yin, Wei Chen, Oscar Qian, Zhengan Yan, Ziqi Huang, Haiwen Diao, Liang Pan, Bo Li, Xiangyu Fan, Dezhi Luo, Fengyuan Yu, Zehong Zhao, Qingying Gao, Tinghui Zhu, Yilan Zhang, Jingqi Tong, Pinyuan Feng, Zhengze Jiang, Letian Wang, Ziyu Guo, Renrui Zhang, Jieneng Chen, Sonia Joseph, Constantin Venhoff, Saman Motamed, Mengyue Yang, Chandra Sripada, Alan Yuille, Philip Torr, Lvmin Zhang, Vikash Kumar, Daniel Khashabi, Nikolaus Kriegeskorte, Raphaël Millière, Vincent C. Müller, Anyi Rao, Quan Wang, Ziwei Liu, Dahua Lin, Lei Yang, Hokin Deng, Zhongang Cai

VBVR-Pro provides a scalable, verifiable testbed for training and optimizing native visual reasoning models.

How can we replace unreliable VLM-based evaluation with verifiable, code-based reward scorers to enable scalable reinforcement learning for visual reasoning?

Native visual reasoning—where models solve problems by constructing and updating visual states—is currently bottlenecked by a lack of scalable training data and reliable, automated feedback. VBVR-Pro addresses this by providing a closed-loop suite of 300 procedurally generated tasks, paired with deterministic, task-specific reward scorers that replace unreliable VLM-as-a-judge methods. Models trained on this suite show consistent transfer gains across seven external benchmarks, demonstrating that visual trajectories are a more critical substrate for reasoning than linguistic chains of thought.

Paper Primer

The core mechanism is a unified task-generation framework that renders identical problems into three aligned modalities: video, keyframe images, and interleaved text-image sequences. This allows for controlled comparisons of how different generative architectures—image, video, or interleaved—handle the same underlying reasoning logic.

The verifiable reward scorers operate by extracting semantic entities (e.g., object counts, spatial relations, trajectories) using classical computer vision rather than raw pixel comparison. This makes the reward signal deterministic, human-aligned, and computationally efficient enough for large-scale reinforcement learning.

Training on VBVR-Pro yields significant performance gains on unseen, real-world visual reasoning benchmarks.

Models fine-tuned on the dataset achieve improvements of up to 20 percentage points on external benchmarks like RISE-Video and MME-CoF-Pro. Average improvement of +0.401 on in-domain tasks and +0.179 on out-of-domain tasks.

Intermediate visual states are the primary substrate for reasoning, not textual chains of thought.

Ablation studies show that removing intermediate visual states causes severe performance degradation, while replacing reasoning text with placeholders has minimal impact. Visual interventions cause substantially larger performance drops than textual interventions during inference.

Why is a new suite needed if we already have large-scale visual datasets?

Existing datasets are often designed for evaluation rather than training, and they lack the procedural diversity and verifiable ground truth required to teach reusable visual reasoning operations rather than just fitting instruction patterns.

Why are rule-based scorers preferred over the common VLM-as-a-judge approach?

VLM judges are often inaccurate on fine-grained spatial tasks, expensive to run at scale, and highly non-reproducible; the proposed scorers are deterministic, human-aligned, and provide unambiguous signals for reinforcement learning.

The paper assumes that visual reasoning is best exposed through generation; it does not address models that treat visual inputs solely as classification or retrieval targets.

Researchers can now use VBVR-Pro as a standardized curriculum to train and optimize generative models for multi-step visual reasoning, moving beyond simple pattern matching toward verifiable, trajectory-based problem solving.

Native Visual Reasoning and the Evaluation Gap

VBVR‑Pro builds a closed‑loop testbed that makes visual reasoning trainable, verifiable, and comparable.

Existing visual‑reasoning benchmarks depend on VLM‑as‑a‑judge feedback, which is costly, noisy, and hard to reproduce. This creates a bottleneck: researchers cannot reliably train or compare models across image, video, or interleaved generators. VBVR‑Pro eliminates the bottleneck by supplying deterministic, code‑based reward scorers that are cheap to run and give stable, reproducible signals—spotting a typo is easier than writing a typo‑free paragraph, and the former mirrors VLM evaluation while the latter mirrors training with VLM judges.

Visual states (images or videos) are treated as active problem‑solving media, not just inputs to be parsed or final outputs to be displayed.

A large vision‑language model is queried after generation to decide whether the visual output satisfies task rules.

**Figure 1** Overview of VBVR-Pro. VBVR-Pro establishes a closed-loop testbed for native visual reasoning, providing 300 visual reasoning tasks that support controlled studies of image, interleaved, and video generators under a unified task distribution. Its verifiable reward scorers provide reproducible, human-aligned evaluation and further serve as task-grounded reward functions for large-scale multi-task reinforcement learning.

The key shift is moving from costly, flaky VLM‑as‑a‑judge feedback to cheap, reproducible code‑based reward scorers.

The VBVR-Pro Dataset

We build a synthetic dataset that expands visual‑reasoning coverage while keeping evaluation fully verifiable.

Large‑scale visual‑reasoning models suffer from a lack of diverse training tasks, limiting transfer to new domains. Simply scaling instance count without expanding the underlying capabilities does not close this gap.

VBVR‑Pro‑Dataset is a synthetic suite of 300 tasks that collectively cover the five cognitive faculties defined by the VBVR benchmark, providing a unified source of verifiable supervision.

The image modality compresses video solutions into three regimes—Last‑Frame, Key‑Frame, and Multi‑Frame—so that the essential answer is retained while keeping the representation compact.

Last‑Frame: render only the final grid with the agent at G, discarding all intermediate positions.

Key‑Frame: keep the start grid, the intermediate grid after the first move, and the final grid with the agent at G.

Multi‑Frame: sample all three grids (start, after first move, final) uniformly, preserving the full trajectory.

All three regimes encode the same solution (the path S→G); the difference lies only in how much of the intermediate process is shown, allowing the same verifier to check correctness regardless of representation.

Define a task generator as a parameterized program (grid size, object count, visual attributes).

Sample a concrete configuration from the generator’s parameter space.

Render the sampled configuration as a video sequence.

Derive the three image‑modality regimes from the video (Last‑Frame, Key‑Frame, Multi‑Frame).

Run the task‑specific solver to obtain the ground‑truth solution.

Store the video, image regimes, solution, and metadata (seed, spec, attributes) together.

Designing Verifiable Reward Scorers

Verifiable reward scorers replace costly VLM judges with fast, deterministic, task‑specific evaluators.

VLM‑as‑a‑judge systems are inaccurate, expensive, and non‑reproducible, which undermines reliable benchmarking for visual reasoning.

A deterministic, code‑based evaluator that checks task‑specific semantic attributes instead of raw pixels, yielding fast and reproducible scores.

Detect objects: Ball 1 → color red, Ball 2 → color blue.

Apply mixing rule: red + blue → expected color purple.

Generated output shows a violet ball (incorrect hue).

Scorer assigns 0.40 (fails mixing check); VLM judges assign ≥0.80 because they ignore fine hue.

The scorer catches the precise hue error that VLM judges miss, demonstrating why semantic checks improve accuracy.

Locate objects of interest in each video frame using HSV segmentation and contour detection.

Extract semantic attributes (color, shape, position, count) via OCR and trajectory tracking.

Run task‑specific checks: compare extracted attributes against the ground‑truth specification.

Combine check results: use a weighted sum for soft criteria, multiply for hard constraints.

Output the final scalar score and a breakdown of failed checks for interpretability.

**Figure 4.** Three failure modes of VLM-as-a-judge (Sec. 3.1). For each mode we show an example consisting of the ground-truth and a model's output, together with the scores and rationales of three strong VLM judges.

**Figure 5.** Examples of task-specific scoring. We show how verifiable reward scorers evaluate generated videos by decomposing each output into task-relevant checks and aggregating them into a final score.

Because verifiable scorers are accurate, cheap, and perfectly reproducible, they become the reliable backbone for large‑scale reinforcement learning on visual reasoning tasks.

Benchmarking Results

VBVR‑Pro scorer beats VLM judges on agreement while costing far less.

We evaluate the VBVR‑Pro scorer on the VBVR‑Pro‑Bench suite, comparing it to leading proprietary VLM judges and to earlier VBVR scorers.

VBVR‑Pro achieves per‑vote agreement above 0.60, surpassing all VLM judges while remaining the cheapest evaluator.

GPT‑5.5 scores 0.54, Gemini‑3.1‑Pro scores 0.52; human ceiling is 0.77.

The scorer’s deterministic, rule‑based pipeline eliminates GPU overhead, making it the least expensive evaluator while guaranteeing reproducible results.

**Figure 6** Left: Per-vote agreement with human preferences ($y$) versus cost per evaluation ($x$, log scale) for each evaluator. Right: Model-level agreement. Each point denotes one generation model, with its scorer-based win ratio on the $y$-axis and human win ratio on the $x$-axis, for in-domain and out-of-domain tasks.

Table 3 lists the open‑source foundation models we benchmark, including BAGEL‑7B‑MoT, FLUX.2‑dev, and Qwen‑Image‑Edit, with “A” marking activated MoE/MoT parameters.

Verifiable scorers outperform VLM judges in human‑preference agreement while incurring far lower evaluation cost.

Related Work

Survey of open‑source generative models and their visual‑reasoning performance.

We evaluate nine open‑source generative foundation models covering image generation, interleaved text‑image generation, and video generation. The list includes ThinkMorph-7B, SenseNova-U1-8B-MoT, 14BA7B, 16BA8B for interleaved tasks, and Wan2.1-I2V-14B-720P, Wan2.2‑TI2V-5B, Wan2.2‑I2V‑A14B, LTX‑2.3‑I2AV for video, spanning sizes from 5 B to 27 BA14B.

The selected models exhibit substantial diversity in scale, architecture (MoT, Dense, MoE), cross‑modal interaction mechanisms, and output representation (latent vs. pixel space). All are trained on the VBVR‑Pro‑Dataset for a single epoch at 512 × 512 resolution; large models receive rank‑32 LoRA while smaller ones are fully fine‑tuned, and video generators run at 16 fps.

Table 4 reports benchmarking results on VBVR‑Pro‑Bench, showing that top‑tier proprietary systems (e.g., Seedance 2.0, GPT‑Image‑2) achieve strong scores, whereas most academic open‑source models fall short. Task‑specific training on the VBVR‑Pro‑Dataset improves every model by an average of 0.290, yet even the best trained model remains well below human‑level performance.

**Table 4.** Benchmarking results on VBVR-Pro-Bench. Overall, In-Domain (ID), and Out-of-Domain (OOD) scores are reported alongside category-wise performance. Bold: best in subgroup; underline: second best.

Model Architectures

Model architectures, training recipes, and transferability results for the VBVR‑Pro experiments.

We evaluate VBVR‑Pro fine‑tuning on a heterogeneous suite of generative foundations spanning image, video, and interleaved text‑image modalities. Table 9 (see Figure table9) lists the architectural properties of each baseline, highlighting differences in scale, cross‑modal interaction, and output representation.

Image generators include BAGEL‑7B‑MoT (14 B total, 7 B active per token pathway), Qwen‑Image‑Edit (20 B‑parameter diffusion Transformer with dual‑stream blocks), and FLUX.2‑dev (dual‑stream then single‑stream blocks, allocating more depth to joint processing). These models illustrate both sparse‑expert and dense designs.

Interleaved text‑image models comprise ThinkMorph‑7B (initialized from BAGEL‑7B‑MoT) and SenseNova‑U1‑8B‑MoT, a native unified model that replaces the conventional visual encoder and VAE with direct RGB‑patch processing. Both retain the Mixture‑of‑Transformers backbone while exposing a latent‑free image pathway.

Video generators cover a sparse Mixture‑of‑Experts DiT (Wan2.2‑I2V‑A14B), a dense 5 B‑parameter DiT (Wan2.2‑TI2V‑5B), a dense 14 B‑parameter DiT (Wan2.1‑I2V‑14B‑720P), and the asymmetric dual‑stream audiovisual diffusion model LTX‑2.3‑I2AV, which allocates more capacity to video than audio.

All models are fine‑tuned for one epoch at 512 × 512 resolution. Smaller image and interleaved models (<10 B active parameters) are fully fine‑tuned, while larger ones receive rank‑32 LoRA adapters (learning rate 1 × 10⁻⁴). All video models use rank‑32 LoRA with the same learning rate.

To isolate the impact of the VBVR‑Pro dataset, we initialize VBVR‑SenseNova‑U1 and VBVR‑Pro‑SenseNova‑U1 from an unreleased checkpoint that never saw VBVR data during pretraining, ensuring any performance gain can be attributed to the fine‑tuning data.

**Table 1.** Performance comparison of various video generation models across different rule categories (Science, Game, Humanity, Vision) and an Overall metric, evaluated using IF, VC, VF, and RC metrics.

**Table.** Performance comparison of various video generation models across different metrics including Fine-grained Discrimination, Visual Tracking, Spatial Perception, Visual Pattern Recognition, and Overall performance.

**Table 11.** Results on RULER-Bench (I2V setting). IF: Instruction Following; VC: Visual Consistency; VF: Visual Fidelity; RC: Rule Coherence.

Reinforcement Learning Pipeline

We speed up training by overlapping rollout generation, reward evaluation, and policy updates.

Training visual‑reasoning models is bottlenecked by idle GPU time while rewards are computed. Overlapping rollout generation with reward evaluation and policy updates eliminates this stall.

Instead of waiting for a rollout’s reward before updating the policy, we insert a single‑step lag so the next rollout can start while the previous reward is still being computed.

GPU generates Rollout 1 (3 steps) → dispatches its frames to a CPU reward worker.

GPU begins Rollout 2 while the CPU worker processes Rollout 1’s reward.

CPU finishes reward 1; GPU uses Rollout 1 to update the policy while still generating Rollout 3.

Policy lag never exceeds one rollout because each update uses the most recent completed reward.

The one‑step delay guarantees that the policy always trains on the freshest available feedback, yet the GPU never sits idle waiting for that feedback.

How does this pipeline differ from fully asynchronous reinforcement learning where rollouts and rewards run completely independently?

Fully asynchronous systems can accumulate arbitrarily stale gradients because updates may use rewards many steps old. Our one‑step‑delayed design caps staleness to a single rollout, preserving deterministic ordering while still achieving overlap.

Generate rollout k on GPU.

Send rollout k’s frames to CPU reward workers for preprocessing and scoring.

Immediately start generating rollout k + 1 on GPU.

When reward k becomes available, update the policy with rollout k.

Repeat, keeping the pipeline one step ahead.

Pseudocode for the one‑step‑delayed pipeline.

Because the pipeline preserves a deterministic order, policy lag is bounded to a single rollout iteration, avoiding the drift that plagues fully asynchronous approaches.

**Figure 14.** Comparison between synchronous training and our one-step-delayed pipeline. Our pipeline overlaps asynchronous preprocessing and reward evaluation with rollout generation and policy optimization, reducing GPU idle time while bounding policy lag to one rollout iteration.

RLVR reduces end‑to‑end training time by $38.7\%$ compared with a VLM‑based judge.

Training 2,200 steps on 128 H800 GPUs takes $5.1$ days with the verifiable scorer versus $8.3$ days with the VLM judge.

Tables 12 and 13 report the resulting performance: our model attains the highest average scores on both the vision‑centric split and BabyVision‑Gen benchmarks.

Training Optimizations

Key training tricks that cut overhead and enable large‑scale visual‑reasoning RL.

Group‑relative KL regularization adds a reference model pass, inflating compute and memory. In our setting it yields no consistent benefit, so we drop it entirely and focus on low‑overhead tricks.

Instead of a separate RMSNorm layer followed by a linear projection, the fused Liger kernel merges the two operations into a single GPU kernel, cutting memory traffic and kernel launch overhead.

Compute RMS per row: $\sqrt{(1^2+2^2+3^2+4^2)/4}= \sqrt{7.5}\approx2.74$, $\sqrt{(5^2+6^2+7^2+8^2)/4}= \sqrt{107.5}\approx10.37$.

Apply learned scale $s=[0.5,0.5]$: rows become $[1.37,1.37,1.37,1.37]$ and $[5.19,5.19,5.19,5.19]$.

All intermediate tensors fit in a single $2\times4$ buffer, avoiding a second $2\times4$ allocation.

The fused version saves one memory allocation and one kernel launch, which adds up across millions of training steps.

How does the fused Liger RMSNorm differ from a standard RMSNorm followed by a linear layer?

Standard RMSNorm computes the norm, rescales, then a separate matrix multiply applies the learned scale. The fused version computes the norm and applies the scale inside the same CUDA kernel, eliminating the extra matrix‑multiply and its associated memory traffic.

FlashAttention‑3 tiles the attention matrix so that each tile fits in on‑chip memory, performing the softmax and weighted sum while the data stays resident, which dramatically reduces off‑chip traffic.

Why not just use the original FlashAttention implementation?

FlashAttention‑3 adds a third‑stage kernel that fuses the scaling, softmax, and value‑weighted sum into a single pass, whereas earlier versions required a separate softmax kernel. This extra fusion yields both memory savings and a modest speed boost.

Hybrid‑sharded FSDP2 splits each model’s parameters across the GPUs of a node (sharding) while still synchronizing gradients across nodes (data‑parallel), so each GPU holds only a fraction of the full state.

Node 1 shards matrices 1–4 across its two GPUs (each stores $64$ parameters).

Node 2 shards matrices 5–8 similarly.

During forward, GPU 0 of Node 1 computes activations for matrices 1–2, GPU 1 computes matrices 3–4; the same pattern holds for Node 2.

After backward, each node all‑reduces its local gradients (64 parameters each) across the two nodes, then updates its shards locally.

Peak memory per GPU drops from $128$ to $64$ parameters, a 50 % reduction.

Hybrid sharding preserves the exact training dynamics of a full‑model data‑parallel run while halving per‑GPU memory, enabling larger batch sizes.

What would break if we omitted the data‑parallel gradient reduction?

Without the all‑reduce step, each node would update only its local shard, causing the model to diverge because the parameters on different nodes would no longer stay synchronized.

Training uses the CPS sampler for $30$ denoising steps with stochasticity $η=0.7$, a learning rate of $5\times10^{-6}$, and a CFG scale of $1.0$. Deterministic ODE sampling is evaluated with Euler (first‑order) and UniPC (higher‑order predictor–corrector).

**Table.** Performance comparison of different models and inference methods across In-Domain and Out-of-Domain categories.

**Table 15** Per-category results on MME-CoF-Pro (no-hint setting). RS: Reasoning Score; CS: Consistency Score; Avg: mean over the five generation-quality dimensions. Following the original paper, each model is reported under all three metrics.

**Table 16.** Results on IntelligentVBench (Implicit I2V). IF: Instruction Following; CP: Condition Preserving; VQ: Visual Quality. AVG = (IF+CP+VQ)/3, MIN = min(IF, CP, VQ). All scores are on a 1–5 scale.

Sampler Sensitivity Analysis

Ablation study of sampler stochasticity and deterministic solvers reveals optimal CPS settings and visualizes trajectories.

We evaluate how sampler stochasticity and deterministic ODE solvers affect both Verifiable‑RL and VLM‑Judge RL performance.

CPS injects controlled random noise into diffusion sampling, letting the policy explore alternative visual outcomes while staying anchored to the prompt.

How does $\eta$ balance exploration versus adherence to the prompt?

$\eta$ scales the random perturbation added at each diffusion step: small $\eta$ keeps the sample close to the deterministic trajectory dictated by the prompt, while larger $\eta$ injects more noise, allowing the policy to wander into alternative visual solutions that may later be refined by the reward scorer.

Increasing CPS stochasticity from $\eta$ = 0.1 to $\eta$ = 0.7 improves Verifiable‑RL overall score by 0.039.

Score rises from 0.509 to 0.548, with gains on both In‑Domain and Out‑of‑Domain benchmarks.

CPS with $\eta$ = 0.7 yields the highest Verifiable‑RL aggregate score of 0.548.

All other $\eta$ values and deterministic solvers fall short of this result.

Deterministic ODE samplers (Euler and UniPC) achieve an overall Verifiable‑RL score of 0.522.

Both solvers produce nearly identical results, differing only marginally at the category level.

VLM‑Judge RL shows smaller and less consistent differences across samplers; its best aggregate results appear at $\eta$ = 0.7 or $\eta$ = 0.9, with UniPC marginally ahead of Euler.

Across all samplers, Verifiable‑RL consistently outperforms VLM‑Judge RL, indicating that the advantage of the verifiable reward scorer is not tied to any particular inference configuration.

VLM‑Judge RL exhibits a temporary performance dip around steps 400–500 under CPS $\eta$ = 0.7, becoming more pronounced at $\eta$ = 0.9, driven by a gradual greying of generated backgrounds while foreground reasoning remains correct.

We compress each 81‑frame video into a colored centerline that encodes the agent’s path, stage boundaries, and motion direction, preserving full temporal information without discarding frames.

Why use the temporal median for background estimation instead of simple averaging?

The median discards transient foreground pixels, preserving the true static background even when the agent appears in many frames; averaging would blend the agent’s color into the background, obscuring the clean scene needed for accurate trajectory overlay.

Qualitative examples show that Verifiable‑RL refines intermediate predictions more effectively and produces smoother, more coherent trajectories than the pre‑RL baseline, confirming that the reward scorer improves both decision quality and temporal consistency.

Dataset Analysis

Dataset analysis details the multi‑modality design, interleaved generation, visual complexity, and reasoning depth of VBVR‑Pro.

Every VBVR‑Pro instance appears in two modalities—video and image—derived from the same solved trajectory rather than from independent corpora.

**Figure 22.** Additional examples illustrating the three output regimes of the VBVR-Pro image modality.

The regime is a property of the task generator, so all instances of a task share the same regime; it is chosen based on how much of the solution trajectory must be made explicit.

Across the 300 VBVR‑Pro tasks, 209 (69.7 %) use Last‑Frame, 58 (19.3 %) use Key‑Frame, and 33 (11.0 %) use Multi‑Frame, reflecting that most reasoning problems are fully answered by the final state.

C.2 describes the interleaved representation that pairs each output image with a preceding textual reasoning step.

For each instance, Gemini‑3.1‑Pro‑Preview receives the task question, the input image, and the full solver‑generated image sequence, then emits one prospective reasoning sentence per image.

Task‑specific prompts are hand‑crafted; the Klotski sliding‑block prompt (shown in Fig. 22) instructs the model to describe the next block to slide and the resulting layout before each output image.

C.3 measures visual complexity on the question frame using four complementary metrics.

Distinct regions count 8‑connected components after 16‑colour quantisation; distinct colours count palette entries after 5‑bit per‑channel quantisation; spatial information is the standard deviation of Sobel gradient magnitudes; encoded size is JPEG‑90 file size on 512 × 512 images.

The newly designed tasks exceed the reworked tasks by 6.9× in distinct regions, 2.4× in distinct colours, 1.7× in spatial information, and 2.0× in encoded size, confirming they are visually richer.

**Figure 15** Evaluation performance throughout training under different inference samplers. The top and bottom rows show RLVR and RLVRM, respectively, while the columns report overall, in-domain, and out-of-domain scores. Each panel compares CPS with $\eta \in \{0.1, 0.3, 0.7, 0.9\}$, ODE (Euler), and ODE (UniPC). Checkpoints are evaluated every 100 training steps.

C.4 evaluates reasoning depth via a blinded pairwise judgement and a per‑task multi‑step classification.

Annotators compared each reworked task with a randomly paired new task twice (order swapped); the new task was judged deeper in 113 of 150 pairs (75.3 %) and the two orderings agreed in 133 pairs (88.7 %).

In the per‑task assessment, 70 of the 150 new tasks (46.7 %) required multi‑step reasoning versus only 10 of the 150 reworked tasks (6.7 %).

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers