InternVL3.5: Advancing Open-Source Multimodal Models in Versatility, Reasoning, and Efficiency

ArXiv: 2508.18265

🎯 Pitch

A dynamic resolution router lets InternVL3.5 slash visual tokens by half yet still retain performance, while a coarse-to-fine reinforcement learning strategy delivers up to a +16% reasoning gain. The result is an open-source model family that runs 4× faster than its predecessor and narrows the gap with GPT-5 to under 4% across 35 multimodal benchmarks.

---

1. Executive Summary

This paper introduces InternVL3.5, a new family of open-source multimodal models that advances versatility, reasoning, and inference efficiency over its predecessor InternVL3 through three named innovations: Cascade Reinforcement Learning (Cascade RL—a two-stage framework combining offline RL via mixed preference optimization with online RL via group sequence policy optimization), Visual Resolution Router (ViR—a dynamic patch-level compression mechanism that selects between 256-token and 64-token representations per image patch), and Decoupled Vision-Language Deployment (DvD—an asynchronous deployment architecture separating vision and language models across different GPUs). Evaluated across 35 benchmarks spanning general multimodal understanding, reasoning, text-centric tasks, and agentic tasks using models from 1B to 241B parameters (both dense and mixture-of-experts), InternVL3.5 achieves up to a +16.0% gain in overall reasoning performance and a 4.05× inference speedup compared to InternVL3, with the flagship InternVL3.5-241B-A28B narrowing the gap with GPT-5 to 3.9% on overall score—establishing that Cascade RL provides scalable reasoning improvements across model sizes while ViR reduces visual tokens by 50% with negligible performance loss.

2. Context and Motivation

The Core Problem: Open-Source MLLMs Lag Behind Commercial Models in Reasoning and Efficiency

The fundamental challenge this paper addresses is a widening capability gap between open-source multimodal large language models (MLLMs) and their commercial counterparts. As the authors observe in the introduction, the field has evolved beyond simple multimodal understanding toward "more general, complex, and realistic tasks such as text-related tasks, reasoning tasks and agentic tasks." In these demanding domains, the paper asserts that "commercial models have created huge gaps with current open-source models, as shown in Table 2."

This gap is not merely academic—it has practical consequences for the broader AI ecosystem. When the most capable multimodal models remain proprietary, research progress becomes bottlenecked by what external groups can reproduce and study. Deployment in privacy-sensitive or cost-constrained settings becomes infeasible. The authors frame their work as a direct response to this asymmetry: InternVL3.5 aims to narrow the distance between what open-source and closed-source systems can achieve, making advanced multimodal capabilities broadly accessible.

The gap is quantified concretely in the paper's benchmark comparisons. Across the 35-benchmark suite, the authors show that prior open-source leaders like GLM-4.5V-106B-A12B and Step-3-321B-A38B achieve overall scores in the 67–70 range, while GPT-5 reaches 76.5 (Figure 1). InternVL3.5-241B-A28B reaches 72.6, cutting the gap to 3.9 percentage points. This framing—the distance to a specific commercial frontier—drives much of the technical motivation.

Why This Problem Matters: The Dual Challenge of Capability and Cost

The paper identifies two intertwined pressures that make the open-source gap particularly urgent.

First, reasoning capability is the new frontier. The authors note that recent open-source efforts "aim to explore advanced reinforcement learning (RL) methods to mitigate the gap and pursue higher multimodal intelligence." However, despite significant activity around RL algorithms and verifiers, the authors argue that "a stable, effective, and scalable reinforcement learning framework for MLLMs still remains an open problem." The subtext here is crucial: it is not that RL has never been applied to MLLMs—it has, extensively—but that existing approaches suffer from instability, inefficiency, or poor scaling behavior that prevents their reliable use across model sizes and tasks. The consequence is that open-source models have been unable to consistently close the reasoning gap, particularly on benchmarks like MMMU (multidisciplinary reasoning) and MathVista (mathematical reasoning in visual contexts) where commercial models hold commanding leads.

Second, enhanced capabilities amplify computational costs. The paper explicitly connects the growth of multimodal capabilities—"long visual context and high-resolution understanding"—with "ever increasing computational costs, which have become a crucial bottleneck of real-world applications." This is the efficiency side of the problem. High-resolution image processing, in particular, creates a tension: the dynamic high-resolution strategy that InternVL and other MLLMs use to handle varied image sizes generates large numbers of visual tokens (1024 per image patch before compression in InternVL3.5's case), and these tokens must be processed by both the vision encoder and the language model. As the authors note in Section 2.5, when MLLMs are deployed at scale, "the vision and language models often block each other, thus incurring additional inference cost," an effect that "becomes more pronounced with larger vision models or higher-resolution images."

These two pressures—reasoning quality and inference cost—are in tension. Making models reason better typically requires more computation (chain-of-thought, test-time scaling, larger architectures). Making models faster typically requires cutting corners that can degrade quality. A solution that addresses only one side of this tension would be incomplete; the paper's ambition is to advance both simultaneously.

Where Existing Approaches Fall Short

The paper identifies specific limitations across three dimensions: reinforcement learning for MLLMs, training strategies for multimodal reasoning, and inference efficiency.

Reinforcement learning for MLLMs remains unstable and inefficient. The paper references a substantial body of recent work on applying RL to improve multimodal reasoning, including process reward models (VisualPRM), verifier-guided training, and various online RL algorithms. The core challenge, as the authors see it, is that these methods have generally been applied in isolation, without a principled framework for combining their complementary strengths. Offline RL methods like DPO offer stability and efficiency—they train on pre-collected rollouts, avoiding the cost and variance of online sampling—but the authors observe that "their performance ceiling is generally lower compared to online RL methods." Online RL methods like PPO, GRPO, and GSPO can push performance higher by training on the model's own evolving outputs, but they are "often computationally expensive and time-consuming." The field lacked a training recipe that could deliver the stability and amortized cost of offline RL while still achieving the performance ceiling of online RL. Cascade RL is the paper's direct answer to this gap.

Importantly, the paper does not claim that prior RL approaches for MLLMs are simply ineffective—rather, it argues they are insufficiently engineered for the specific demands of multimodal training at scale. The instability and cost issues are not inherent to RL but reflect suboptimal combinations of algorithms and training procedures. This is a constructive critique: the problem is not that RL cannot work, but that nobody has yet put the pieces together in the right way.

SFT-based approaches hit a reasoning ceiling. Prior versions of InternVL (and many other MLLMs) relied heavily on supervised fine-tuning (SFT) for post-training. The paper acknowledges this explicitly in describing its own SFT stage, which uses high-quality conversation data to enhance capabilities. However, the authors draw a sharp distinction between what SFT can achieve and what RL can unlock:

"Compared to Pre-training and Supervised Fine-tuning (SFT), the core advantage of RL lies in its ability to introduce negative samples, which prune low-quality regions in the model's output space and thereby enhance the overall response quality."

This is a specific technical claim: SFT trains the model to imitate correct outputs but does not explicitly teach it to avoid incorrect ones. In regions of the output space where the model has multiple plausible responses—some correct, some subtly wrong—SFT provides a weak learning signal. RL, by contrast, can directly penalize incorrect outputs through reward signals, reshaping the output distribution in ways that SFT cannot. The paper positions Cascade RL as the mechanism for achieving this reshaping efficiently.

Inference efficiency is bottlenecked by architectural coupling. The paper's diagnosis of the efficiency problem is specific and architectural. In standard MLLM deployment (what the paper calls "Vanilla Deployment"), the vision encoder (ViT), the vision-language connector (MLP), and the language model (LLM) all execute sequentially on the same hardware. The authors identify two distinct problems with this arrangement:

1. Computational mismatch: The vision encoder is "highly parallelizable and does not rely on long-term history state," while the language model is autoregressive, "more sensitive to memory bandwidth and latency." When they share hardware, each blocks the other from fully utilizing its preferred computational pattern.

2. Resolution-dependent overhead: The dynamic high-resolution strategy increases the number of patches processed by the vision encoder. For high-resolution images, multi-image understanding, and video—all increasingly important capabilities—"the number of patches processed by the vision encoder grows even further, leading to greater visual overhead." At 1344× resolution, the vision computation can dominate total inference time, making the serial bottleneck severe.

The paper's DvD architecture addresses this by physically separating vision and language processing, but this is not merely an engineering optimization—it is motivated by the observation that the coupling problem gets worse as capabilities improve, creating a scalability barrier that must be addressed architecturally.

Prior token compression approaches are too coarse. The paper acknowledges that InternVL3 already used pixel shuffle to compress visual tokens from 1024 to 256 per image patch. This is a uniform compression—every patch gets the same treatment regardless of its semantic content. The authors argue that this is wasteful: some image patches (e.g., text-heavy regions, fine details in diagrams) truly need the full 256-token representation, while others (e.g., uniform backgrounds, low-texture regions) could be compressed much further with negligible information loss. The gap is that no existing approach provided a learned, patch-level routing mechanism that could make this determination dynamically.

How This Paper Positions Itself Relative to Existing Work

The paper situates InternVL3.5 as the latest iteration in an evolving model family, building on InternVL, InternVL1.5, InternVL2.5, and InternVL3. This lineage matters because it establishes that the improvements are cumulative and systematic, not one-off tricks. The authors explicitly state that InternVL3.5 retains architectural decisions from prior versions—the "ViT–MLP–LLM" paradigm, the Dynamic High Resolution strategy, the pixel shuffle compression—while introducing innovations on top of this foundation.

Relative to prior InternVL versions. InternVL3 (immediate predecessor) established several practices that InternVL3.5 inherits: native pre-training with mixed text and multimodal data, square averaging loss reweighting, and random JPEG compression for robustness. InternVL3.5's improvements come primarily from the post-training pipeline—specifically, replacing InternVL3's RL approach with Cascade RL—and from the efficiency innovations of ViR and DvD. The paper quantifies this: InternVL3.5-8B achieves 73.4 on MMMU versus InternVL3-8B's 62.7, a +10.7 point improvement (Table 3). This is not a marginal gain; it represents a qualitative jump in reasoning capability at the same model scale.

Relative to other open-source MLLMs using RL. The paper acknowledges concurrent work on applying RL to MLLMs—GLM-4.5V, MiMo-VL-RL, Keye-VL, and others—but positions Cascade RL as addressing the specific gap of stability and scalability. The ablation in Table 16 makes this concrete: training InternVL3.5-8B with GSPO alone (online RL, 1 episode) reaches 57.3 overall reasoning score at a cost of ~5.5K GPU hours. Two episodes of GSPO reach 58.2 at ~11K GPU hours. Cascade RL, which runs MPO first then GSPO, reaches 60.3 at ~5.8K GPU hours—better performance at roughly half the cost of two-episode GSPO. The claim is not that Cascade RL is the only way to do RL for MLLMs, but that it is a more compute-efficient recipe that makes RL practical for large-scale multimodal training.

Relative to commercial models. The paper positions InternVL3.5 explicitly against GPT-5, Gemini-2.5 Pro, and other frontier closed-source models. On general multimodal tasks, InternVL3.5-241B-A28B achieves an overall score of 74.1 versus GPT-5's 74.0—essentially tying. On reasoning, the gap remains substantial (67.1 vs. 74.3), which the paper treats as motivation for future work rather than a failure. On text tasks, the compact InternVL3.5-30B-A3B achieves 78.9 versus GPT-5's 91.3, while the flagship 241B model reaches 85.3—still behind but closing. This positioning is carefully calibrated: the paper does not claim to have caught commercial models across the board, but rather to have substantially narrowed the gap while remaining fully open-source, a combination that no prior open-source MLLM had achieved.

On the training-inference tradeoff. The paper does not frame ViR and DvD as afterthoughts or minor optimizations—they are presented as co-equal contributions alongside Cascade RL. This reflects a specific position: that efficiency is not separable from capability in MLLM research. A model that achieves state-of-the-art reasoning but requires prohibitive compute to deploy is not practically useful. By demonstrating that ViR reduces visual tokens by 50% with negligible performance loss (Table 17) and that DvD provides up to 2.01× speedup on its own, the paper argues that architectural efficiency innovations deserve the same research attention as training innovations. This is a methodological claim about what "advancing the field" means—it includes deployability, not just benchmark scores.

3. Technical Approach

3.1 Reader orientation (approachable technical breakdown)

The system being built is a family of multimodal large language models that take images, text, and video as input and produce text responses across a wide range of tasks—from answering questions about photographs to solving math problems with visual diagrams to interacting with graphical user interfaces. The core problem it solves is the dual challenge of reasoning capability and inference efficiency in open-source MLLMs: how to make models that reason better without becoming prohibitively expensive to run. The "shape" of the solution is a three-component architecture—a vision encoder transforms images into token sequences, a connector compresses and routes these tokens, and a language model processes everything autoregressively—paired with a post-training pipeline that progressively builds capabilities through supervised fine-tuning, a two-stage reinforcement learning process, and a visual consistency training stage that enables dynamic token compression at deployment time.

3.2 Big-picture architecture (diagram in words)

The system has five major architectural components and four training stages:

Architectural components:

• Vision Encoder (InternViT): A vision transformer that converts input images into sequences of visual feature tokens. Available in two sizes: InternViT-300M (300M parameters) and InternViT-6B (5.5B parameters).
• Dynamic High Resolution Preprocessing: Before reaching the vision encoder, each input image is matched to pre-defined aspect ratios (1:1, 1:2, 2:3, etc.) and split into 448×448 pixel tiles, plus a downsampled thumbnail of the whole image. This enables the model to handle images of arbitrary size and aspect ratio without losing fine detail.
• Vision-Language Connector (MLP Projector + Pixel Shuffle): The bridge between vision and language. A pixel shuffle operation first compresses the high-dimensional vision encoder output (1024 tokens per patch) down to 256 tokens per patch. An MLP projector then maps these visual tokens into the embedding space of the language model. In InternVL3.5-Flash, an additional pixel shuffle module compressing to 64 tokens per patch is added, controlled by the Visual Resolution Router.
• Language Model (LLM): The autoregressive text decoder—either Qwen3 (dense models from 0.6B to 32B, plus a 30B-A3B MoE and 235B-A22B MoE) or GPT-OSS-20B (a 20B-A4B MoE architecture). This component does the actual reasoning and text generation, attending to both visual tokens and text tokens.
• Visual Resolution Router (ViR): A binary classifier that examines each image patch and decides whether it can be compressed to 64 tokens (if semantically simple) or needs the full 256 tokens (if semantically rich, e.g., containing text or fine detail).

Training stages (in order):

1. Native Pre-training: ~250B tokens of mixed text and multimodal data, training all parameters jointly with next-token prediction, establishing basic vision-language alignment.
2. Supervised Fine-Tuning (SFT): ~130B tokens of high-quality conversation data, including reasoning traces in "Thinking" mode and capability-expansion datasets for GUI, embodied, and SVG tasks.
3. Cascade Reinforcement Learning: A two-substage RL process—first offline RL via Mixed Preference Optimization (MPO) for stable warm-up, then online RL via Group Sequence Policy Optimization (GSPO) for refined alignment—using ~270K samples for offline and ~70K queries for online training.
4. Visual Consistency Learning (ViCO): A two-substage process for Flash variants—first consistency training to make the model produce similar outputs regardless of compression rate, then router training to teach ViR when compression is safe.

Information flow at inference time: An image enters → Dynamic High Resolution splits it into tiles + thumbnail → InternViT encodes each tile into 1024 tokens → pixel shuffle compresses to 256 tokens (or, with ViR, 64 for simple patches) → MLP projector maps to LLM embedding space → LLM processes visual tokens alongside text prompt autoregressively → generates text response. With DvD deployment, the vision processing (ViT + MLP + ViR) happens on a separate GPU server from the language model, with visual features transmitted asynchronously over TCP.

3.3 Roadmap for the deep dive

I will explain the system in this order, which follows the training pipeline from data to deployment:

• First, Pre-training and Supervised Fine-Tuning: The foundation stages that establish basic capabilities, including the training objectives, data composition, and specific design choices like square averaging loss reweighting. This provides the base model that all subsequent stages build upon.

• Second, Cascade Reinforcement Learning: The core innovation for reasoning improvement. I will walk through each substage—MPO's three-component loss (preference + quality + generation), GSPO's geometric-mean importance sampling ratio and group-normalized advantage—and explain how the two stages complement each other in terms of stability, efficiency, and performance ceiling. The training data filtering logic (selecting queries with accuracy between 0.2 and 0.8) is critical here.

• Third, Visual Consistency Learning (ViCO): The training process that enables InternVL3.5-Flash variants. The two-stage design—consistency training to align output distributions across compression rates, then router training to learn which patches need high resolution—will be explained with the loss ratio thresholding mechanism.

• Fourth, Visual Resolution Router (ViR) Architecture: How the router is structured and integrated into the model, including the binary classification decision, the dynamic threshold based on historical loss ratios, and the patch-level routing mechanism.

• Fifth, Decoupled Vision-Language Deployment (DvD): The inference-time architecture that separates vision and language processing across GPUs, including the asynchronous three-stage pipeline (vision processing → feature transmission → language processing) and why it provides increasing benefits at higher resolutions.

• Sixth, Test-Time Scaling (Deep Thinking + Parallel Thinking): The inference-time strategies for further improving reasoning, including best-of-N selection with VisualPRM as the critic model.

3.4 Detailed, sentence-based technical breakdown

This is primarily a systems and training methodology paper whose core idea is that reasoning capabilities in MLLMs can be efficiently improved through a two-stage RL framework (offline then online), while inference costs can be reduced through learned dynamic token compression and decoupled deployment architecture—and that these improvements scale consistently from 1B to 241B parameters.

---

Pre-training: Establishing Vision-Language Alignment

Training objective. During pre-training, the model is trained with standard next-token prediction (NTP) on a mixture of text-only and multimodal sequences. For any training sample represented as a token sequence $x = (x_1, x_2, ..., x_L)$ of length L, the loss on each text token is:

$\mathcal{L}_i = -\log p_\theta(x_i \mid x_1, \dots, x_{i-1})$

where $x_i$ is the predicted token, $\theta$ represents all model parameters, and the prefix tokens in $\{x_1, x_2, ..., x_{i-1}\}$ can be either text tokens or image tokens (the model can condition on visual information when predicting subsequent text).

What it computes: For each position in the sequence where the model needs to predict a token, the negative log probability of the correct token under the model's predicted distribution. The model sees all previous tokens (both visual and textual) and must output a probability distribution over its vocabulary; this loss penalizes it for assigning low probability to the actual next token. For conversation samples, only the response tokens contribute to the loss—the prompt tokens are conditioned on but not predicted. The total loss is summed or averaged over all positions that require prediction.

Why this form: Next-token prediction is the standard autoregressive language modeling objective that enables a single model to handle both understanding (by conditioning on input tokens) and generation (by predicting output tokens). The key property is that it provides a dense training signal—every token position contributes a gradient—unlike objectives that only supervise final answers. This density is crucial for learning the fine-grained alignment between visual features and language, since the model must learn not just what to say about an image but how visual information should influence each word choice throughout a response.

Square averaging loss reweighting. To prevent the training from being dominated by either very long or very short responses, the paper applies square averaging to reweight the NTP loss:

$\mathcal{L}'_i = \frac{w_i}{\sum_j w_j} \cdot \mathcal{L}_i, \quad w_i = \frac{1}{N^{0.5}}$

where $N$ is the number of tokens in the training sample on which the loss is calculated (i.e., the number of response tokens that require prediction).

What it computes: A per-sample weight that is inversely proportional to the square root of the response length. Each token's loss is multiplied by this weight, and the weighted losses are normalized to sum to one across the batch. The effect is that a sample with 100 response tokens receives weight $1/\sqrt{100} = 0.1$ per token, while a sample with 400 tokens receives $1/\sqrt{400} = 0.05$ per token. The shorter sample's tokens are weighted twice as heavily as the longer sample's tokens.

Why this form: Without reweighting, longer responses would dominate the gradient because they contain more loss-contributing tokens. Simple averaging over tokens (dividing by N) would make the model equally sensitive to every token regardless of sample length, but this can cause very long samples to have disproportionately small per-token gradients, slowing learning on important detailed responses. Square root scaling ($N^{-0.5}$) is a compromise that partially compensates for length while still giving longer samples somewhat more total influence, based on the empirical observation that this balance works well for multimodal training (carried forward from InternVL2.5). A linear weight ($N^{-1}$) would equalize sample influence but might underweight the importance of getting every token right in long, complex responses, while no reweighting ($N^0$) would let long responses dominate.

Additional regularization. The paper applies random JPEG compression to input images during training. This is a data augmentation technique: before encoding, images are randomly compressed and decompressed using JPEG, introducing artifacts (blocking, ringing) that simulate real-world image quality degradation. The purpose is to make the model robust to the kinds of compressed, low-quality images it will encounter in deployment—screenshots, user uploads, web images—without requiring those specific images in the training data.

Data composition. The pre-training corpus contains approximately 116 million samples, corresponding to roughly 250 billion tokens. The data is split into two categories:

1. Multimodal data: Sourced primarily from InternVL3's training corpora, covering image captioning, general question answering, mathematics, scientific disciplines, charts, optical character recognition (OCR), knowledge grounding, document understanding, multi-turn dialogue, and medical data. This is the data that teaches the model to connect visual inputs with language outputs.

2. Text-only data: Constructed from InternLM series training corpora and augmented with open-source datasets. The paper specifically mentions SmolLM-corpus, AceMath, SCP-116K, and s1 as sources.

The ratio of text-only to multimodal data is approximately 1:2.5—meaning roughly 71% of training samples are multimodal and 29% are text-only. This mixed training (called "native pre-training" since InternVL3) is a deliberate design choice: by training on both modalities simultaneously rather than first training a text-only LLM and then adding vision, the model can learn linguistic and multimodal abilities in an integrated way, avoiding the "catastrophic forgetting" of language capabilities that often occurs when vision is added post-hoc. The maximum sequence length is set to 32K tokens to accommodate long-context understanding and reasoning.

What happens during pre-training: All model parameters—vision encoder, connector, and language model—are updated jointly. The vision encoder learns to extract features from image tiles that are useful for the language model's prediction task; the connector learns to map these features into a representation the language model can effectively attend to; and the language model learns to use both visual and textual context for next-token prediction. This joint optimization is crucial because it allows the vision encoder to adapt its representations specifically for the language model it will be paired with, rather than producing generic visual features that the language model must then learn to interpret from scratch.

---

Supervised Fine-Tuning: Adapting to Downstream Tasks

After pre-training establishes basic vision-language alignment, the SFT stage refines the model's capabilities using higher-quality, more targeted data. The training objective remains next-token prediction with square averaging, but the data changes substantially.

Data sources. The SFT dataset comprises approximately 56 million samples (~130 billion tokens), drawn from three sources:

1. Instruction-following data from InternVL3: Reused to maintain broad coverage of vision-language tasks. This ensures the model does not lose general capabilities while specializing.

2. Multimodal reasoning data in "Thinking" mode: This is the critical addition for reasoning capability. The paper describes a specific construction pipeline: a large-scale reasoning model samples rollouts with detailed reasoning processes (chain-of-thought, step-by-step derivations). These rollouts undergo strict filtering beyond answer correctness—the reasoning processes themselves are evaluated for clarity, checked for redundancy, and validated for consistent formatting. The questions span expert domains including mathematics and scientific disciplines. By training on these reasoning traces, the model learns not just to produce correct answers but to produce coherent, step-by-step reasoning that leads to correct answers.

3. Capability-expansion datasets: These endow InternVL3.5 with entirely new skills not present in prior versions, including GUI-based interaction (understanding screenshots, locating UI elements), embodied interaction (spatial reasoning, navigation), and scalable vector graphics (SVG) understanding and generation.

The text-only to multimodal ratio shifts to roughly 1:3.5 in SFT—more multimodal-heavy than pre-training, reflecting the focus on visual task capabilities.

What SFT accomplishes relative to pre-training. Pre-training produces a model that can generally connect images and text, but its outputs may be inconsistent, poorly formatted, or lacking in specific capabilities. SFT trains the model on examples of desired behavior—concise answers, formatted reasoning, specific task skills—teaching it the output patterns expected in deployment. The "Thinking" mode data is particularly important because it instills the habit of producing intermediate reasoning before final answers, which later stages (Cascade RL, test-time scaling) can refine and improve.

Design choice: SFT before RL. The paper runs SFT before any RL, establishing a strong supervised baseline. This is not merely convention—it serves a specific purpose in the Cascade RL framework. The SFT model provides a starting point where the model already produces reasonable (if not optimal) outputs. This means when RL begins collecting rollouts for training, those rollouts will be of sufficient quality that the reward signal can meaningfully distinguish better from worse responses. If RL started from a pre-trained model that produced mostly poor outputs, the reward signal would be sparse—almost all rollouts would be bad, providing little gradient for improvement. SFT creates a "warm start" that makes the subsequent RL stage both more stable and more effective.

---

Cascade Reinforcement Learning: The Core Reasoning Innovation

Cascade RL is the paper's primary contribution to training methodology. It is a two-stage process: first, offline RL via Mixed Preference Optimization (MPO) efficiently reaches a satisfactory level; second, online RL via Group Sequence Policy Optimization (GSPO) refines the model's output distribution using its own rollouts. The key insight is that these two stages complement each other—offline RL provides stability and amortized cost while creating a strong enough model that online RL can run efficiently, and online RL pushes past the performance ceiling that offline RL alone cannot exceed.

Offline RL Stage: Mixed Preference Optimization (MPO)

What MPO is. MPO is a training algorithm that fine-tunes the model using pre-collected preference data—pairs of responses where one is known to be better than the other, plus additional signals for response quality and generation fluency. The algorithm does not require the model to generate new rollouts during training (hence "offline"), dramatically reducing computational cost compared to online methods.

Training data. The paper uses MMPR-v1.2, a dataset containing approximately 200K sample pairs specifically designed for multimodal preference optimization. The key property of this dataset is that the rollouts are pre-computed and shared across different model training runs, amortizing the expensive sampling cost that online RL would incur repeatedly.

The MPO objective. The loss function combines three terms:

$\mathcal{L}_{\text{MPO}} = w_p \mathcal{L}_p + w_q \mathcal{L}_q + w_g \mathcal{L}_g$

where $w_p$, $w_q$, and $w_g$ are scalar weights (not explicitly stated in the paper, but presumably tuned for the specific training configuration), and the three losses are:

• Preference loss $\mathcal{L}_p$: Implemented as DPO (Direct Preference Optimization) loss. DPO works by contrasting a preferred (chosen) response with a dispreferred (rejected) response for the same prompt, without needing to train a separate reward model. The loss increases the model's probability of generating the preferred response relative to the dispreferred one, while keeping the overall distribution close to the reference (pre-MPO) model via an implicit KL penalty.

• Quality loss $\mathcal{L}_q$: Implemented as BCO (Binary Classifier Optimization) loss. While DPO operates on relative preferences (A is better than B), BCO provides an absolute quality signal—classifying whether a response is good or bad independent of comparisons. This complements DPO by penalizing uniformly poor responses that might not be caught by pairwise preference comparisons.

• Generation loss $\mathcal{L}_g$: Implemented as standard language modeling loss (LM loss) on the preferred responses only. This is essentially supervised fine-tuning on the "good" examples, ensuring the model maintains fluency and factual accuracy on the positive samples while the preference and quality losses push it away from negative ones.

What the MPO objective computes: For each training sample (a prompt with one chosen and one rejected response), the DPO component computes a loss that is small when the model assigns higher relative probability to the chosen response, the BCO component computes a loss that is small when the model correctly classifies response quality, and the LM component computes the standard next-token prediction loss on the chosen response. The weighted sum is the total loss for that sample.

Why this three-component form: Each loss addresses a different limitation of the others. DPO alone can lead to the model "cheating" by reducing probability on both responses while maintaining the relative ordering, which degrades fluency—the LM loss prevents this by explicitly rewarding correct token prediction on good responses. DPO also only captures relative preferences and might not penalize a response that is less bad than the rejected one but still poor; BCO's absolute quality signal fills this gap. BCO alone would treat all bad responses equally without learning the nuanced ordering that DPO provides. Together, they provide complementary gradients that lead to more robust improvement than any single loss.

Why this form for offline RL: The offline nature of MPO—using pre-collected rollouts rather than generating new ones during training—is the key to its efficiency. The sampling cost (running the model to generate multiple responses per prompt) is paid once when constructing MMPR-v1.2 and then amortized across all models trained with it. This means the MPO stage can achieve meaningful performance gains at a fraction of the computational cost of online RL, making it an effective warm-up. The paper reports that MPO on InternVL3.5-8B requires only ~0.3K GPU hours to improve the overall reasoning score from 53.6 to 56.3 (Table 16).

Online RL Stage: Group Sequence Policy Optimization (GSPO)

What GSPO is. GSPO is an online RL algorithm—meaning the model generates its own rollouts during training and receives rewards on them—that extends the widely-used GRPO algorithm with a different importance sampling formulation. The "group" in the name refers to the fact that for each prompt, multiple responses are generated and their rewards are normalized relative to each other within the group.

Training data. For the online RL stage, the paper constructs a filtered dataset called MMPR-Tiny from the broader MMPR-v1.2. The filtering criterion is specific and important: for each query, the authors compute the model's accuracy using the provided rollouts (from MMPR-v1.2) and select only queries whose accuracy falls between 0.2 and 0.8. The dataset is further extended with recent multimodal datasets to enhance diversity, yielding approximately 70K queries in total.

Why the 0.2–0.8 filtering: This is a deliberate choice to focus RL training on questions where the model has room to improve. Queries with accuracy below 0.2 are essentially impossible for the current model—no amount of RL on these queries will help because there are no good rollouts to learn from. Queries with accuracy above 0.8 are already largely solved—the model almost always gets them right, so RL provides little learning signal. The 0.2–0.8 range identifies queries where the model sometimes succeeds and sometimes fails, meaning there are both positive and negative examples in the rollout distribution and the reward signal can meaningfully distinguish better from worse responses. This is a form of curriculum learning: train on problems at the edge of the model's current capability.

The advantage function. Like GRPO, GSPO computes advantages by normalizing rewards within each group of responses to the same prompt. For a query $x$ and a set of $G$ generated responses $\{y_i\}_{i=1}^G$, the advantage for response $y_i$ is:

$\hat{A}_i = \frac{r(x, y_i) - \text{mean}\left(\{r(x, y_i)\}_{i=1}^G\right)}{\text{std}\left(\{r(x, y_i)\}_{i=1}^G\right)}$

where $r(x, y_i)$ is the reward (some scalar score) for response $y_i$ given prompt $x$, and the mean and standard deviation are computed over the $G$ responses generated for this specific prompt.

What it computes: For each response in the group, subtract the group's average reward and divide by the group's standard deviation. A response better than average gets a positive advantage; worse than average gets a negative advantage. The magnitude of the advantage reflects how many standard deviations above or below the mean the response is. This is a form of reward normalization that removes prompt-dependent difficulty: a score of 0.7 might be excellent for a hard prompt (where the mean is 0.3) but poor for an easy prompt (where the mean is 0.9). Normalization converts raw rewards into relative advantages that are comparable across prompts of varying difficulty.

Why this normalization form: Without normalization, RL training would be dominated by prompts with large reward variance—the model would learn primarily from cases where the raw reward differs dramatically between responses, ignoring prompts where the signal is subtler. Normalization ensures that every prompt contributes equally to the gradient regardless of its inherent reward scale. The specific choice of z-score normalization (subtract mean, divide by std) assumes rewards are approximately normally distributed within each group, giving a principled statistical interpretation to the advantage: it measures how exceptional each response is relative to the model's typical output on that prompt.

The GSPO objective. The training loss is a clipped policy gradient:

$\mathcal{L}_{\text{GSPO}}(\theta) = \mathbb{E}_{x \sim \mathcal{D}, \{y_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot \mid x)} \left[ \frac{1}{G} \sum_{i=1}^G \min\left( s_i(\theta) \hat{A}_i, \text{clip}(s_i(\theta), 1 - \varepsilon, 1 + \varepsilon) \hat{A}_i \right) \right]$

where $\theta$ are the current policy parameters, $\theta_{\text{old}}$ are the parameters used to generate the rollouts, $\varepsilon$ is the clipping threshold (not explicitly stated but typically 0.2 in PPO-family algorithms), and $s_i(\theta)$ is the importance sampling ratio.

The importance sampling ratio in GSPO. This is where GSPO differs from standard PPO/GRPO. The importance sampling ratio is defined as the geometric mean of per-token probability ratios:

$s_i(\theta) = \left( \frac{\pi_\theta(y_i \mid x)}{\pi_{\theta_{\text{old}}}(y_i \mid x)} \right)^{\frac{1}{|y_i|}} = \exp\left( \frac{1}{|y_i|} \sum_{t=1}^{|y_i|} \log \frac{\pi_\theta(y_{i,t} \mid x, y_{i,<t})}{\pi_{\theta_{\text{old}}}(y_{i,t} \mid x, y_{i,<t})} \right)$

where $\pi_\theta(y_i \mid x)$ is the probability of generating the entire response $y_i$ under the current policy, $\pi_{\theta_{\text{old}}}(y_i \mid x)$ is the probability under the old policy, $|y_i|$ is the length of the response in tokens, and $\pi_\theta(y_{i,t} \mid x, y_{i,<t})$ is the per-token generation probability at position $t$.

What it computes: Rather than using the full sequence probability ratio (which can vary by orders of magnitude for sequences of different lengths), GSPO takes the geometric mean—equivalently, the exponential of the average log-ratio across tokens. This normalizes the importance weight by sequence length, so a response of 100 tokens and a response of 10 tokens contribute importance ratios of comparable magnitude. The ratio measures how much more or less likely the current policy is to generate each response compared to the policy that actually generated it, on a per-token basis. A value > 1 means the current policy has increased probability on this response; < 1 means it has decreased probability.

What the full objective computes: For each response in the group, multiply its (length-normalized) importance ratio by its advantage. Clip the ratio to $[1-\varepsilon, 1+\varepsilon]$ and take the minimum of the clipped and unclipped products. Average over all $G$ responses for the prompt, then average over prompts. The clipping ensures that any single update does not change the policy too dramatically—if improving a response would require multiplying its probability by more than $1+\varepsilon$, the gradient is clipped, preventing the kind of destructive large updates that make online RL unstable.

Why this geometric-mean importance ratio: Standard PPO uses the full sequence probability ratio $\pi_\theta(y_i \mid x) / \pi_{\theta_{\text{old}}}(y_i \mid x)$, which is the product of per-token ratios. For long sequences, this product can become extremely large or small due to the multiplicative accumulation of small per-token differences. This causes the variance of the policy gradient estimator to grow with sequence length, making training unstable for long responses—exactly the kind of detailed reasoning traces that MLLMs need to produce. The geometric mean normalizes by sequence length, keeping the importance ratio at a per-token scale regardless of response length. This is particularly important for multimodal reasoning, where responses can range from short answers to multi-paragraph explanations, and the model should learn from all of them without being dominated by length artifacts.

Why GSPO without a reference model constraint: Standard PPO and DPO include a KL divergence penalty that keeps the policy close to a reference model (typically the SFT model), preventing the policy from drifting too far and losing general capabilities. GSPO explicitly removes this constraint. The paper states they "find [GSPO without reference model constraints] more effective in training both dense and mixture-of-experts (MoE) models." The implicit claim is that the clipping mechanism alone provides sufficient regularization, and the reference model constraint may be overly conservative—preventing the policy from reaching regions of parameter space that would actually improve performance. This is a more aggressive approach that assumes the offline RL stage has already moved the model to a region where unconstrained online RL can safely explore.

Design choice: MPO before GSPO (why this ordering matters). The paper argues for three specific benefits of running offline RL before online RL rather than using either alone:

1. Better training stability: In offline RL (MPO), rollouts are pre-collected and fixed, so there is no feedback loop between the current policy and the training data. This eliminates "reward hacking"—the phenomenon where online RL policies learn to exploit quirks of the reward function rather than genuinely improving. By the time online RL begins, "stronger models exhibit more stable and robust training dynamics," so the MPO-warmed model is less prone to instability during GSPO.

2. Improved training efficiency: The rollouts from MMPR-v1.2 used in MPO are shared across all model variants—they are generated once and reused. This amortizes the sampling cost that online RL would otherwise incur from scratch. The model then enters GSPO already performing well, meaning it needs fewer online training steps to reach a given performance level. Table 16 quantifies this: MPO alone gives +2.7 points (53.6 to 56.3) at negligible cost (~0.3K GPU hours); GSPO alone (1 episode) gives +3.7 points (53.6 to 57.3) at massive cost (~5.5K GPU hours); Cascade RL gives +6.7 points (53.6 to 60.3) at ~5.8K GPU hours, achieving better final performance than two episodes of GSPO alone (58.2) at roughly half the cost.

3. Higher performance ceiling: The MPO stage provides "high-quality rollouts for the subsequent online stage," meaning that when GSPO starts, the rollouts it collects are already reasonably good. This means the advantage signal is meaningful—there are clear differences between good and bad responses—rather than all responses being poor, which would give weak gradients. The online stage can then refine from a higher baseline, reaching a final performance that neither stage could achieve alone.

---

Visual Consistency Learning (ViCO): Enabling Dynamic Compression

ViCO is the training process that creates InternVL3.5-Flash variants—models that can dynamically reduce their visual token count using the Visual Resolution Router while maintaining performance. It consists of two sequential training stages, each with a distinct purpose.

Why ViCO is needed. InternVL3.5's standard architecture compresses every image patch from 1024 vision encoder tokens to 256 tokens via pixel shuffle. This is uniform—every patch gets the same compression regardless of content. The ViR module (described structurally in the next section) can route patches to a heavier compression (64 tokens), but simply adding this router to a trained model would break performance: the model has only ever seen 256-token patch representations during training, so suddenly feeding it 64-token representations would produce gibberish. ViCO solves this by first training the model to be robust to different compression rates, then training the router to decide when each rate is appropriate.

Stage 1: Consistency Training

What it does. The entire model (vision encoder, connector, language model) is trained to produce similar output distributions regardless of whether each image patch is represented as 256 tokens or 64 tokens. A frozen reference model (initialized from the trained InternVL3.5 checkpoint) always receives 256-token representations, while the policy model (being trained) receives randomly compressed representations.

The ViCO objective:

$\mathcal{L}_{\text{ViCO}} = \mathbb{E}_{\xi \sim R} \left[ \frac{1}{N} \sum_{i=1}^N \text{KL}\left( \pi_{\theta_{\text{ref}}}(y_i \mid y_{<i}, \mathbf{I}) \;\middle\|\; \pi_{\theta_{\text{policy}}}(y_i \mid y_{<i}, \mathbf{I}_\xi) \right) \right]$

where:

• $\xi$ is a compression rate sampled uniformly from $\{\frac{1}{4}, \frac{1}{16}\}$ (256 tokens and 64 tokens respectively, relative to the original 1024 vision encoder output),
• $\mathbf{I}$ is the image represented at $\xi = \frac{1}{4}$ (256 tokens per patch), always used by the reference model,
• $\mathbf{I}_\xi$ is the image represented at compression rate $\xi$, used by the policy model,
• $\pi_{\theta_{\text{ref}}}(y_i \mid y_{<i}, \mathbf{I})$ is the reference model's predicted probability distribution for token $y_i$,
• $\pi_{\theta_{\text{policy}}}(y_i \mid y_{<i}, \mathbf{I}_\xi)$ is the policy model's predicted distribution,
• $\text{KL}(P \| Q)$ is the Kullback-Leibler divergence from Q to P—how much information is lost when using Q (the policy on compressed images) to approximate P (the reference on full-resolution images),
• The expectation is over the random compression rate and the training data,
• The sum is over all $N$ tokens in the response.

What it computes: For each training sample, randomly choose a compression rate for all patches in the image. Run the frozen reference model on the full 256-token-per-patch representation and the trainable policy model on the randomly compressed representation. At each token position, measure the KL divergence between their output probability distributions. Average over token positions and training samples. The loss is minimized when the policy model's predictions match the reference model's predictions, regardless of compression rate.

Why KL divergence: Using KL divergence rather than cross-entropy to a ground-truth token ensures the model learns to mimic the full distribution of the reference model, not just the most likely token. This captures uncertainty—if the reference model is uncertain between two plausible next tokens (e.g., a 60/40 split), the policy model should reproduce that uncertainty even when seeing compressed visual input. Cross-entropy to the reference model's argmax would lose this distributional information and could lead to overconfident predictions. The KL divergence penalizes any deviation in the shape of the distribution, preserving the nuanced behavior of the original model.

Why the reference model always uses full resolution: The reference model provides a fixed target that represents "correct behavior." If both models were trained, they could co-adapt—the reference might degrade to match the policy rather than the policy improving to match the reference. Freezing the reference ensures the policy is pulled toward the high-quality uncompressed behavior, learning to extract the same information from fewer tokens.

Why both compression rates are sampled during training: If the model were only trained with $\xi = \frac{1}{16}$ (64 tokens), it would become specialized to low-resolution inputs and lose its ability to use high-resolution information. By sampling both rates uniformly, the model must learn to produce consistent outputs regardless of the input resolution. The paper notes: "During the consistency training stage, all patches of the same image are represented with a random compression rate, in order to ensure that the model retains its capability when no compression is applied."

Data used: The consistency training stage uses the same datasets as the SFT stage. This is deliberate—by training on SFT data, the model learns to maintain its task capabilities while adapting to variable compression. Using different data might cause the model to forget SFT-learned skills during ViCO.

Stage 2: Router Training

What it does. After consistency training, the model can handle either compression rate but does not know when to use each. The router training stage teaches the ViR module to predict, for each image patch, whether compressing to 64 tokens would cause significant performance degradation. The main MLLM (ViT, MLP, LLM) is frozen during this stage—only the ViR classifier is trained.

Constructing training targets. For each training sample, the loss incurred at each compression rate is computed using the consistency-trained model. The loss ratio for each patch is:

$r_i = \frac{\mathcal{L}_{\text{ViCO}}(y_i \mid \mathbf{I}_{\frac{1}{16}})}{\mathcal{L}_{\text{ViCO}}(y_i \mid \mathbf{I}_{\frac{1}{4}})}$

where the numerator is the ViCO loss (KL divergence from reference) when patch $i$ is compressed to 64 tokens, and the denominator is the ViCO loss when it is compressed to 256 tokens.

What it computes: A scalar ratio that measures how much worse the model's predictions become when a specific patch is heavily compressed. A ratio near 1.0 means compression has negligible impact—the model produces nearly identical output distributions regardless of resolution. A ratio substantially above 1.0 means compression significantly degrades the model's predictions for that patch.

Why this ratio-based metric: Absolute loss values depend on the difficulty of the sample (hard samples have higher loss regardless of compression). The ratio normalizes out sample difficulty, isolating the marginal impact of compression on each specific patch. This is crucial because the router needs to make patch-level decisions: two patches in the same image might have very different compression sensitivity (e.g., a text-heavy region vs. a uniform background), and the ratio captures this while canceling out image-level effects.

Binary label definition. The ratio is thresholded to produce a binary label:

$y_i^{\text{router}} = \begin{cases} 0, & r_i < \tau \quad \text{(compression has negligible impact, use 64 tokens)} \\ 1, & r_i \geq \tau \quad \text{(compression has significant impact, use 256 tokens)} \end{cases}$

where $\tau$ is a dynamic threshold computed as the $k$-th percentile of historical $r_i$ values maintained in a sliding window. The paper does not specify $k$ explicitly, but notes that "the target distribution is balanced," implying $k$ is chosen so that roughly half of patches are labeled 0 and half labeled 1.

Why a dynamic threshold: If $\tau$ were fixed, the distribution of router labels would depend on the difficulty of the training data. Some datasets might have mostly easy patches (all ratios near 1.0, all labeled 0) while others might have mostly hard patches (all ratios high, all labeled 1). A dynamic threshold adapts to the data distribution, ensuring the router learns a meaningful binary decision rather than collapsing to always predicting one class. The balanced target distribution means the router is trained to be discriminative—it must learn which patches are relatively harder or easier than others, not just whether patches exceed some absolute difficulty threshold.

Router training objective. The ViR is trained as a standard binary classifier using cross-entropy loss against these dynamically thresholded labels. The ViR takes patch features as input (the vision encoder output before pixel shuffle) and predicts a binary decision: compress to 64 tokens (class 0) or keep at 256 tokens (class 1). During training, only the ViR parameters are updated; the rest of the model remains frozen.

Data used for router training: A subset of the SFT data, "primarily composed of OCR and VQA examples, which are rich in visual information and sometimes require high-resolution understanding." This is a deliberate choice: training on text-rich images teaches the router to recognize when fine details matter. A router trained only on natural images with large objects might learn to compress everything aggressively, missing the fact that reading text requires high resolution. By including OCR and VQA data specifically, the router learns that text-heavy patches should typically be routed to high resolution.

---

Visual Resolution Router (ViR) Architecture

The ViR is a lightweight binary classifier that operates at the patch level, inserted between the vision encoder and the pixel shuffle compression modules in InternVL3.5-Flash.

Structural integration. In standard InternVL3.5, each 448×448 image patch is processed by InternViT to produce 1024 visual tokens, which are then compressed to 256 tokens by a pixel shuffle operation (a spatial reorganization that trades spatial resolution for channel depth). In InternVL3.5-Flash, an additional pixel shuffle module compressing to 64 tokens is added in parallel. The ViR sits between the vision encoder output and these two pixel shuffle modules: it examines each patch's features and routes the patch to either the 256-token or 64-token compression path.

What the router sees. The router receives the vision encoder's output for each patch—1024 tokens of visual features—and must make a binary decision. The paper does not specify the exact architecture (e.g., whether it pools over the 1024 tokens, uses attention, or takes a subset), but the key design property is that it is a learned function that maps patch-level visual features to a binary routing decision.

Why patch-level routing: The alternative would be image-level routing—deciding a single compression rate for the entire image. This would be simpler but wasteful: most images contain a mix of information-dense regions (text, faces, fine structures) and information-sparse regions (sky, walls, uniform textures). Patch-level routing allows the model to spend its visual token budget where it matters, compressing backgrounds aggressively while preserving detail in regions that need it. This is the "adaptivity from the perspective of semantic content" that the paper claims distinguishes ViR from Dynamic High Resolution, which only adapts from the "perspective of image width and height."

Deployment behavior. At inference time, the ViR examines each patch and routes it accordingly. The paper reports that InternVL3.5-Flash "reduces 50% of the visual tokens while maintaining nearly 100% of the original performance" (Table 17). For example, InternVL3.5-8B-Flash achieves a 79.8 average score across nine benchmarks versus 80.2 for InternVL3.5-8B—a 0.4-point drop for a 50% token reduction. The 50% figure implies that on average, about half of patches are routed to 64 tokens and half to 256 tokens.

---

Decoupled Vision-Language Deployment (DvD)

DvD is an inference-time deployment architecture, not a training technique. It addresses the hardware inefficiency that arises from running vision and language models on shared GPUs.

The problem with vanilla deployment. In standard MLLM inference (Figure 4, left), the vision encoder (ViT), connector (MLP), and language model (LLM) execute sequentially on the same GPU(s). The computational pipeline is: load image → ViT encodes → MLP projects → prepend visual tokens to text → LLM autoregressively decodes. The problem is that the ViT and LLM have fundamentally different computational characteristics. The ViT is highly parallel—it processes all image patches simultaneously in a feedforward pass—and does not require maintaining state across time steps. The LLM is autoregressive—each token depends on all previous tokens—making it memory-bandwidth-bound and stateful. When they share hardware, they block each other: the ViT's parallel computation must complete before the LLM can begin, and during this time the LLM hardware sits idle. Conversely, the LLM's long decode phase prevents the GPU from being used for other vision processing.

This blocking becomes more severe at higher resolutions because the Dynamic High Resolution strategy increases the number of patches. At 448 resolution, the vision encoder processes relatively few patches; at 1344, it processes many more, and the ViT computation time grows proportionally, extending the period during which the LLM is stalled.

The DvD solution (Figure 4, right). DvD physically separates vision and language processing across different GPU servers. The architecture has two components:

1. Vision Server: Runs the vision encoder (InternViT), the connector (MLP projector), and, for Flash variants, the ViR. This server receives images, encodes them to visual features, and transmits the compact feature embeddings to the language server.

2. Language Server: Runs only the language model (LLM). This server receives text prompts from the user and visual features from the vision server, concatenates them, and performs autoregressive decoding.

Communication. Visual features are transmitted from vision server to language server as BF16 (16-bit floating point) tensors over TCP, with RDMA (Remote Direct Memory Access) optionally employed for higher transmission speed. The communication is unidirectional—vision → language only—which simplifies the protocol.

Asynchronous pipeline. The key to DvD's efficiency is that vision processing, feature transmission, and language processing are organized into an asynchronous three-stage pipeline:

• While the language server is decoding tokens for one request, the vision server can be encoding images for the next request.
• Feature transmission happens in the background, overlapping with both vision encoding and language decoding.
• This minimizes "pipeline stalls"—periods where one component is idle waiting for another.

What DvD achieves concretely. The paper reports (Table 18) that DvD alone (without ViR) accelerates inference by 1.19× at 448 resolution, 1.87× at 896, and 1.97× at 1344 for InternVL3.5-38B. The speedup increases with resolution because the vision computation time (which DvD overlaps with language processing) grows as a fraction of total inference time. At low resolutions, the language model dominates total time, so parallelizing vision provides limited benefit. At high resolutions, vision becomes the bottleneck, and DvD's overlap is transformative.

When combined with ViR, the speedups compound: at 1344 resolution on InternVL3.5-38B, DvD + ViR achieves 3.47× speedup over the vanilla baseline, and at 896 resolution, 4.05× (the headline number). This is multiplicative: DvD provides parallelism, ViR reduces the total work, and together they deliver throughput improvements neither could achieve alone.

Why DvD matters beyond raw speed. The paper notes that DvD "supports independent hardware cost optimization for the vision and language modules." The vision server can use GPUs optimized for throughput (e.g., high memory bandwidth for large-batch ViT inference), while the language server can use GPUs optimized for latency (e.g., high clock speed for autoregressive decoding). This disaggregation allows organizations to right-size their hardware for each component rather than using a one-size-fits-all configuration. The paper also notes that DvD "facilitates the seamless integration of new modules without requiring modifications to the language server deployment"—a modularity benefit for future model iterations.

---

Test-Time Scaling: Deep Thinking and Parallel Thinking

Test-time scaling (TTS) is applied only to reasoning benchmarks, since the authors found that perception and understanding capabilities are already strong enough that TTS provides no significant improvement there.

Deep Thinking. The model is prompted to engage in step-by-step reasoning before producing a final answer. The paper describes this as "decomposing complex problems into logical steps and validating intermediate conclusions." This is implemented by activating the "Thinking" mode—the model has been trained during SFT on reasoning traces with explicit intermediate steps, and at inference time it is prompted to produce such traces. The benefit is that the model can catch its own errors, explore alternative approaches, and build toward a solution incrementally rather than attempting to produce the final answer directly.

Parallel Thinking. Following the approach from InternVL3, the model generates multiple candidate solutions for the same problem (best-of-N sampling) and uses VisualPRM-v1.1 as a critic model to select the best response. VisualPRM is a process reward model—it scores individual steps of a reasoning trace rather than just the final answer—trained specifically for multimodal reasoning evaluation. The best-of-N weighted selection procedure (consistent with how the PRM is used during training evaluation) aggregates scores across solutions that reach the same final answer and selects the answer with the highest total score.

Why TTS is only applied to reasoning: The paper observes that on perception and understanding benchmarks, the model's accuracy is already near ceiling, and additional sampling provides no benefit—the model almost always produces the correct answer on the first try. On reasoning benchmarks, by contrast, the correct answer is often one of several plausible outputs, and sampling multiple times increases the probability of finding it. VisualPRM then identifies which of the sampled solutions is most likely correct, providing a form of "verification" that compensates for the model's imperfect generation.

Magnitude of TTS gains. The paper provides concrete numbers in Table 3: InternVL3.5-8B achieves an overall reasoning score of 60.3 without parallel thinking and 62.4 with it (+2.1 points, or +3.5%). InternVL3.5-4B gains +2.6 points, and InternVL3.5-241B-A28B gains +1.8 points. The diminishing returns at larger scales suggest that bigger models already have higher pass@1 rates and benefit less from sampling diversity, though the gains remain meaningful even at 241B.

Design choice: not including TTS in main results. The paper explicitly notes: "unless otherwise specified, the experimental results reported in Section 3 are obtained without applying TTS." This means all the benchmark comparisons against other models use the base model output (presumably with "Thinking" mode activated where relevant, as part of the model's standard behavior, but without best-of-N sampling). The TTS results are reported separately, showing what additional gains are possible but keeping the main comparisons on a level playing field where all models are evaluated without sampling-based enhancements.

4. Key Insights and Innovations

Innovation 1: Cascade RL as a Stability-Efficiency-Peak Triangle, Not Just Two RL Stages

The most common framing of reinforcement learning for language models treats offline and online methods as competing alternatives: DPO is cheaper but hits a lower ceiling; PPO/GRPO reaches higher but is unstable and expensive. The standard practice—exemplified by most prior work on RL for MLLMs—is to pick one paradigm and optimize within it. Cascade RL's intellectual move is to recognize that these two paradigms are not substitutes but complementary stages in a coarse-to-fine optimization process, where each addresses a specific failure mode of the other.

The conceptual insight is subtle but important. It is not simply that running MPO before GSPO works better than either alone—though the ablation in Table 16 (Cascade RL at 60.3 vs. GSPO-alone at 57.3) shows that it does. The deeper insight is about what property of the optimization landscape makes this ordering necessary. Offline RL (MPO) cannot use the model's own rollouts, so it is limited to improving within the distribution of pre-collected data—it can only make the model better at what someone else's model already did reasonably well. Online RL (GSPO) can explore beyond that distribution, generating novel rollouts and learning from them, but this exploration is dangerous when the model is weak: the rollouts are mostly poor, the advantage signal is noisy, and training easily destabilizes. The Cascade RL framework diagnoses this as a warm-start problem for online exploration: you need a model that is already good enough to generate rollouts where better and worse responses are distinguishable, so that the online advantage signal is informative rather than noise-dominated.

This framing matters because it changes how practitioners should think about RL for MLLMs. The dominant narrative in the field has been that online RL is the "real" RL and offline methods are a cheaper but inferior substitute. Cascade RL argues the opposite: offline RL is an enabler that makes online RL tractable at scale. The offline stage is not a compromise—it is a necessary precondition for stable, efficient online training. This is a conceptual inversion of how the field has approached the problem.

The evidence for this framing is not just the headline performance numbers but the specific pattern in the ablation. Table 15 shows that MPO provides gains across every model scale (1B: 25.7 → 29.1, 8B: 53.6 → 56.3, 241B: 60.4 → 62.4). These gains are systematic, not cherry-picked—every model benefits from the offline stage. More tellingly, Table 16 shows that two full episodes of GSPO-alone (11K GPU hours, score 58.2) underperform Cascade RL (5.8K GPU hours, score 60.3). This is the key result: brute-forcing online RL for longer is worse than spending a fraction of that compute on an offline warm-up. If offline RL were merely a cheaper-but-weaker alternative, spending the same compute on more online RL should eventually catch up. It does not—which implies the offline stage provides something that online training alone cannot recover, even with more iterations.

This is a fundamental reframing, not an incremental training trick. It changes the default mental model from "pick one RL paradigm" to "sequence them for complementary benefits," with specific guidance on which stage provides which benefit and why both are necessary for efficient scaling.

Innovation 2: Diagnostic Discovery That Model-Specific Difficulty, Not Task Difficulty, Governs RL Effectiveness

The Cascade RL framework incorporates a data filtering step that is easy to overlook but represents a quiet methodological insight: only train online RL on queries where the model's current accuracy falls between 0.2 and 0.8. This filtering criterion is not about dataset difficulty—it is about model-specific difficulty, measured by the actual rollout success rate of the specific model being trained.

The standard approach in RL for language models is to train on the full dataset or to filter by some external difficulty metric (e.g., problem level in MATH, grade level in school exams). Cascade RL rejects this in favor of a dynamic, model-relative criterion. The reasoning is specific: queries with accuracy below 0.2 contain almost no correct rollouts, so the advantage signal is uniformly negative—there is nothing to reinforce. Queries with accuracy above 0.8 contain almost no incorrect rollouts, so there is nothing to penalize. The 0.2–0.8 band identifies the "learning frontier"—problems where the model sometimes succeeds and sometimes fails, providing both positive and negative examples for the advantage function to contrast.

This is not merely a data-cleaning heuristic. It is a diagnostic about where RL gradients come from. In standard supervised learning, every example provides a gradient regardless of model performance—the loss is computed against a fixed target. In RL, the gradient depends on the relative quality of rollouts within each prompt's group. If all rollouts for a prompt are similarly good or similarly bad, the advantage is near zero, and that prompt contributes almost no learning signal regardless of how many training steps it receives. By filtering to prompts with intermediate accuracy, Cascade RL concentrates training compute on the subset of data that actually produces informative gradients.

The significance of this insight extends beyond the specific implementation. It implies that RL data efficiency is not a function of dataset size but of gradient informativeness per prompt, which depends on the dynamic match between the model's current capability and the prompt's difficulty. This suggests a research direction the paper does not fully explore: adaptive data selection during RL training, where the set of training prompts evolves as the model improves, always targeting the 0.2–0.8 accuracy band. The static filtering used in Cascade RL is a first step; the underlying principle points toward dynamic curriculum learning for online RL.

The paper does not explicitly ablate the 0.2–0.8 threshold or compare it to alternative filtering strategies, so the empirical case is suggestive rather than definitive. But the conceptual move—shifting from task-difficulty filtering to model-capability filtering for RL data selection—is a genuine methodological contribution that changes how practitioners should approach data curation for multimodal RL.

Innovation 3: Architectural Decoupling as a First-Class Efficiency Strategy, Not an Afterthought

The standard approach to MLLM efficiency focuses on compression: reduce the number of visual tokens (via downsampling, token merging, or pruning), reduce model size (via distillation or quantization), or reduce computation (via early exiting or sparse attention). These are all work-reduction strategies—they make the model do less. DvD is a fundamentally different kind of efficiency innovation: it is a work-reorganization strategy. It does not reduce the total computation required; it rearranges when and where that computation happens so that the critical path (the longest sequential dependency) is shortened.

The intellectual move is recognizing that the vision and language components of an MLLM have a temporal mismatch that work-reduction alone cannot fix. The vision encoder is feedforward and embarrassingly parallel; the language model is autoregressive and memory-bandwidth-bound. When they share hardware, the vision encoder's parallelism is wasted because it must complete entirely before the language model can start, and the language model's sequential nature stalls the GPU during vision processing. No amount of compression fixes this—even if you reduce visual tokens by 90%, the vision encoder still runs to completion before decoding begins.

DvD's insight is that these two workloads should be physically separated and pipelined, not because it reduces FLOPs but because it eliminates the blocking that creates idle time. The paper's ablation in Table 18 quantifies this: the speedup from DvD grows from 1.19× at 448 resolution to 1.97× at 1344 resolution. This is the signature of a bottleneck-removal strategy: as the bottleneck (vision processing time) grows, the benefit of removing it grows proportionally. If DvD were merely reducing work, the speedup would be constant across resolutions.

The broader significance is that DvD establishes hardware topology as a design dimension for MLLMs, alongside architecture and training. Prior work treats deployment as an engineering detail—something you figure out after the model is trained. DvD argues that deployment architecture is co-equal with model architecture in determining overall system efficiency. The vision server and language server can use different GPU types optimized for their respective workloads; the communication protocol (TCP vs. RDMA) becomes a tunable parameter; the pipeline depth can be adjusted based on workload characteristics. This is a systems-level reframing that opens design space that pure model compression approaches cannot access.

The negative finding implicit in DvD is equally important: work-reduction alone cannot solve the MLLM efficiency problem. Even after ViR reduces visual tokens by 50%, the remaining vision computation still blocks the language model. The combined DvD + ViR results (4.05× speedup at 896 resolution) show that work-reduction and work-reorganization are multiplicative, not additive. This implies that future efficiency research should target both axes simultaneously, rather than treating compression as the primary lever and deployment as an afterthought.

Innovation 4: Verifier-Guided Content-Aware Compression That Treats Information Density as Spatially Heterogeneous

The insight behind ViR is easy to state but difficult to operationalize: not all image regions are equally informative for the downstream task, and a compression strategy should allocate its token budget where the information density is highest. This is not a new observation—saliency-based cropping, region-of-interest encoding, and foveated rendering have explored similar ideas in computer vision. What makes ViR distinctive in the MLLM context is the specific mechanism for operationalizing "information density": it is defined not by low-level image statistics (contrast, edges, entropy) but by the model's own sensitivity to compression, measured through the KL divergence between output distributions at different token budgets.

This is a form of learned, task-aware compression. Standard image compression (JPEG, PNG, learned codecs) optimizes for perceptual reconstruction quality—how similar the decompressed image looks to the original. But perceptual quality is the wrong objective for MLLM token compression. What matters is not whether a human can see the difference between the 256-token and 64-token representations, but whether the language model's predictions change when fed one versus the other. A patch containing a uniform blue sky might have high perceptual entropy (subtle cloud gradients) but zero impact on the model's answer to "what color is the sky?" A patch containing tiny text might have low perceptual entropy (black pixels on white background) but enormous impact on the model's answer to "what does the sign say?"

ViR's training procedure operationalizes this distinction. The consistency training stage teaches the model to produce the same output distribution regardless of compression rate—essentially, to become robust to compression. The router training stage then asks: for which patches is this robustness easy to achieve, and for which is it hard? Patches where the model can easily match the reference distribution even with 64 tokens (low loss ratio) are labeled "compressible"; patches where matching requires the full 256 tokens (high loss ratio) are labeled "uncompressible." The threshold is dynamic and data-driven, not a fixed hyperparameter.

The result, shown in Tables 17 and 18, is a compression strategy that reduces total visual tokens by 50% (on average across patches) while maintaining nearly 100% of the original performance—a loss of only 0.4 points on the 8B model's average across nine benchmarks (80.2 → 79.8). This near-lossless compression at 2× token reduction is substantially better than what uniform compression strategies achieve, precisely because the budget is reallocated from information-sparse to information-dense regions.

This is not a fundamental theoretical advance—it is an elegant engineering solution to a well-defined problem. But the framing—defining compression impact through downstream task sensitivity rather than perceptual reconstruction—is a methodological contribution that applies beyond this specific architecture. Any MLLM that processes images in patches could, in principle, learn a patch-level routing function trained on model sensitivity rather than image statistics. The specific ViR architecture and ViCO training procedure are particular to InternVL3.5, but the principle of task-aware adaptive compression is broadly applicable.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on 35 benchmarks organized into four categories: General Tasks (MMStar, MMVet, MMBench V1.1 en, MTVQA, AI2D, OCRBench, WildVision, MME-RealWorld en, HallusionBench, MVBench, VideoMME, MLVU, LongVideoBench), Reasoning Tasks (MMMU val, MathVista mini, MathVision, MathVerse vision-only, DynaMath worst case, WeMath, OlympiadBench, LogicVista), Text-Centric Tasks (MATH500, AIME24, AIME25, GPQA, MMLU-Pro, C-Eval, GAOKAO, IFEval), and Agentic Tasks (SGP-Bench, ScreenSpot, ScreenSpot-v2, OSWorld-G, VSI-Bench, ERQA, SpaCE-10, OmniSpatial). Additionally, OCR/chart/document benchmarks (ChartQA, TextVQA, DocVQA, InfoVQA, SEED-2-Plus, CharXiv, VCR), multi-image benchmarks (BLINK, Mantis-Eval, MMIU, MuirBench, MMT-Bench, MIRB), real-world benchmarks (RealWorldQA, R-Bench), multilingual benchmarks (MMMB, Multilingual MMBench, MTVQA in 6 languages), grounding benchmarks (RefCOCO series), and video benchmarks (MMBench-Video) are used. Most are evaluated through VLMEvalKit, and text-only capabilities are assessed via OpenCompass on MMLU, CMMLU, C-Eval, GAOKAO, TriviaQA, NaturalQuestions, C3, RACE-High, WinoGrande, HellaSwag, BBH, GSM8K, MATH, AIME24, AIME25, and HumanEval. The MATH benchmark uses the split from Lightman et al. (2022) with 12,000 training and 500 test questions. For the Cascade RL training data, MMPR-v1.2 provides ~200K sample pairs for offline RL, and MMPR-Tiny (~70K queries filtered to accuracy 0.2–0.8) is used for online RL.

• Base model(s). The InternVL3.5 family spans 10 model configurations from 1B to 241B total parameters, using InternViT-300M (0.3B) or InternViT-6B (5.5B) for vision and Qwen3 (0.6B to 32B dense, 30B-A3B and 235B-A22B MoE) or GPT-OSS-20B (20B-A4B MoE) for language. Dense variants include 1B, 2B, 4B, 8B, 14B, and 38B total parameters. MoE variants include 20B-A4B, 30B-A3B, and 241B-A28B. The choice spans from phone-scale (1B) to datacenter-scale (241B), enabling analysis of how innovations scale with model size. The immediate predecessor InternVL3 serves as the primary internal baseline across all scales.

• Metrics. The primary metric is accuracy (%) on each benchmark, computed as the fraction of test samples where the model's final answer matches the ground truth. For OCRBench, scores are on a 0–1000 scale and normalized to 0–100 when computing overall averages. For MMBench-Video, scores are on a 0–3 scale and normalized to 0–100. For MME, scores are on a 0–2800 scale and normalized to 0–100. Overall scores within each category (General, Reasoning, Text, Agentic) are reported as the arithmetic mean across constituent benchmarks. The "Overall" score in Figure 1 and Table 2 is the average across all 35 benchmarks. For SVG generation (SArena-Icon), metrics include FID (lower is better), FID-C, CLIP score, DINO score, SSIM, LPIPS, and PSNR. For efficiency, metrics are request throughput (requests/second) measured by sending 16 requests per second to the deployed server.

• Baselines. The paper compares against an extensive set of open-source and closed-source models. For open-source, the primary competitors are InternVL3 (all scales, as the direct predecessor), Qwen2.5-VL (3B, 7B, 32B, 72B), GLM-4.1V-9B, GLM-4.5V-106B-A12B, Kimi-VL-2506-16B-A3B, Keye-VL-8B, MiMo-VL-RL-7B and 8B, MiniCPM-V-4-4B and MiniCPM-V2.6, Ovis and Ovis2 at various scales, Gemma-3 (12B, 27B), Skywork-R1V3-38B, Step-3-321B-A38B, and others as listed in each benchmark table. For closed-source, comparisons include GPT-4V, GPT-4o, GPT-5, GPT-5-nano, Claude-3-Opus, Claude-3.5-Sonnet, Claude-3.7-Sonnet, Claude-4-Sonnet, Gemini-1.5-Pro, Gemini-2.0-Pro, Gemini-2.5-Pro, Gemini-2.0-Flash, Gemini-2.5-Flash, Grok-3, Llama-3.1 and Llama-3.2 variants, Llama-4-Scout and Llama-4-Maverick, DeepSeek-V3, Seed1.5-VL, Doubao-1.5-Pro, and QvQ-72B-Preview. For grounding tasks, specialist models like Grounding-DINO-L, UNINEXT-H, ONE-PEACE, Shikra-7B, CogVLM-Grounding, TextHawk2, and Ferret-v2 are included. For GUI tasks, specialist agents like ShowUI, UI-TARS, JEDI, OS-Atlas, UGround-V1, Aguvis, and GTA1 are compared. For video, VideoChat2-HD, LLaVA-OneVision, Oryx-1.5, VILA-1.5, and VideoLLaMA2 are included.

• Generation budget / compute accounting. For most evaluations, the model generates a single response (greedy decoding or single sample), and accuracy is reported. There is no sampling-based compute budget in the main results—test-time scaling results are reported separately and explicitly labeled as using best-of-N with VisualPRM. For efficiency ablations, compute is measured in request throughput (requests/second) with 16 concurrent requests on 8 A100 GPUs for the language model. For RL training efficiency, compute is measured in GPU hours (Table 16). For ViR efficiency, the metric is the reduction in visual tokens (50% on average) and the corresponding throughput improvement at different input resolutions (448, 896, 1344).

• Cross-validation / statistical protocol. No formal cross-validation or statistical significance testing is described for the benchmark evaluations. Results are reported as single-point accuracy scores. For the Cascade RL ablation, models at each training stage (Instruct, MPO, Cascade RL) are evaluated once on the full benchmark suite. For test-time scaling with parallel thinking, VisualPRM-v1.1 is used as the critic model to select the best response from N candidates, but the specific value of N is not stated in most tables (the "w/ Parallel Thinking" rows in Table 3 are the primary exception). For ViR training, the threshold k for the loss ratio percentile is chosen to balance the class distribution, but the specific value is not reported.

Main Quantitative Results

Overall Performance Across 35 Benchmarks

The headline result is presented in Table 2 and Figure 1: InternVL3.5-241B-A28B achieves an overall average score of 72.6 across 35 benchmarks (weighted equally), compared to GPT-5's 76.5—a gap of 3.9 percentage points. Broken down by task category, the 241B model scores 74.1 on General tasks (vs. GPT-5's 74.0), 67.1 on Reasoning (vs. 74.3), 85.3 on Text (vs. 91.3), and 66.2 on Agentic (GPT-5's agentic average is not reported as a single number). The compact InternVL3.5-30B-A3B achieves 70.5 overall, surpassing GLM-4.5V-106B-A12B (not explicitly in Table 2 but shown in Figure 1) and Step-3-321B-A38B (which scores 67.9 in the general category per Table 2 but its overall is not directly reported in the same table format—Figure 1 shows Step-3 at approximately 65.3 overall).

On General tasks specifically (Table 2), InternVL3.5-241B-A28B achieves the highest open-source scores on MMVet (81.2), MTVQA (39.3), WildVision (82.8), MME-RealWorld (65.1), and LongVideoBench (67.1). On MMStar, it scores 77.9, behind GLM-4.5V's 75.3. On MMBench V1.1, it scores 87.4, behind Qwen2.5-VL-72B's 88.4 and GPT-5's 88.6.

Multimodal Reasoning and Mathematics

Table 3 reports results on 8 reasoning benchmarks across all model scales. The flagship InternVL3.5-241B-A28B achieves 77.7 on MMMU (val), 82.7 on MathVista (mini), 63.9 on MathVision, 68.5 on MathVerse (vision-only), 46.5 on DynaMath, 62.3 on WeMath, and 66.7 on LogicVista, for an overall reasoning average of 66.9. With parallel thinking (best-of-N with VisualPRM), the overall rises to 68.7. Compared to GPT-5, the gap is 74.1 vs. 66.9—a 7.2-point difference. Compared to InternVL3-78B (the predecessor's largest model), the gain is 66.9 vs. 54.6, a +12.3-point improvement.

The scaling pattern is consistent: every model size shows substantial gains over its InternVL3 counterpart. InternVL3.5-8B scores 60.3 vs. InternVL3-8B's 44.3 (+16.0 points, the headline +16.0% figure expressed as absolute gain). InternVL3.5-2B scores 50.7 vs. InternVL3-2B's 32.4 (+18.3 points). InternVL3.5-38B scores 66.0 vs. InternVL3-38B's 52.8 (+13.2 points). The smallest model, InternVL3.5-1B, scores 33.8 vs. InternVL3-1B's 25.1 (+8.7 points), and with parallel thinking reaches 43.3.

Against competing open-source models of similar scale, InternVL3.5-8B (60.3) outperforms Qwen2.5-VL-8B (41.4), Ovis-8B (40.6), and GLM-4.1V-9B (62.6—though slightly behind on this aggregate, InternVL3.5 leads on MMMU 73.4 vs. 68.0). Against MiMo-VL-RL-8B (64.8) and Keye-VL-8B (58.6), InternVL3.5-8B is competitive but not dominant on the overall average, though it leads on MMMU (73.4 vs. 66.7 and 71.4). At 38B, InternVL3.5-38B (66.0) outperforms Qwen2.5-VL-32B (53.6) and Skywork-R1V3-38B (59.5) by wide margins.

A notable finding is the performance of the MoE model InternVL3.5-30B-A3B (59.0 overall reasoning), which underperforms the smaller dense InternVL3.5-14B (62.0) on reasoning despite having more total parameters, though with parallel thinking the gap narrows (61.8 vs. 63.5). The 20B-A4B MoE model scores 56.0, also below the 14B dense.

OCR, Chart, and Document Understanding

Table 4 reports on 9 OCR-related benchmarks. InternVL3.5-241B-A28B achieves an overall score of 85.2, slightly below InternVL3-78B's 85.8—one of the few categories where the new model does not improve over its predecessor. InternVL3.5-8B scores 81.2 vs. InternVL3-8B's 81.3—essentially identical. InternVL3.5-14B scores 82.0 vs. InternVL3-14B's 83.4—a 1.4-point decrease. This pattern of flat or slightly declining OCR performance at larger scales, contrasted with large reasoning gains, is explicitly acknowledged by the authors in Section 3.6 as a tradeoff: "our optimization of text and reasoning capabilities... slightly impairs the performance of multimodal understanding."

At the small scale, however, InternVL3.5 shows consistent gains: InternVL3.5-2B scores 76.7 vs. InternVL3-2B's 74.7 (+2.0 points). InternVL3.5-4B scores 80.0, substantially ahead of MiniCPM-V-4-4B's 75.0. On ChartQA, InternVL3.5-4B achieves 86.0 vs. InternVL3-2B's 80.7—a 5.3-point gain at similar model scale.

Multi-Image and Real-World Understanding

Table 5 (left half) reports multi-image understanding on 6 benchmarks. InternVL3.5-38B achieves 67.4 overall vs. InternVL3-38B's 66.2 (+1.2 points). InternVL3.5-241B-A28B scores 65.5, below InternVL3-78B's 68.0—another regression at the largest scale, though on the challenging MIRB benchmark it shows substantial improvement (73.0 vs. 64.3). The strongest relative gains appear at small scales: InternVL3.5-4B (57.2) vs. InternVL3-2B (50.1), a +7.1-point improvement, though the comparison is across slightly different model sizes within the small-model regime.

Table 5 (right half) reports real-world comprehension on 4 benchmarks. InternVL3.5-241B-A28B achieves 74.6 overall vs. InternVL3-78B's 73.6 (+1.0 point). On WildVision, it reaches 82.8 win rate vs. 73.6—a 9.2-point gain. InternVL3.5-1B scores 50.6 vs. InternVL3-1B's 52.1 (-1.5 points), the only regression at the smallest scale.

Comprehensive Multimodal Understanding and Hallucination

Table 6 reports comprehensive benchmarks (MME, MMBench, MMVet, MMStar) and hallucination benchmarks (HallusionBench, CRPE, POPE). InternVL3.5-241B-A28B achieves an overall understanding score of 84.2 vs. InternVL3-78B's 83.1 (+1.1 points). On MMStar, it reaches 77.9 vs. 72.5 (+5.4 points). On MMVet, it scores 81.2 vs. 81.3—essentially unchanged. For hallucination, the 241B model scores 75.3 vs. 76.2 for the predecessor (-0.9 points). This mixed pattern—gains on some metrics, slight regressions on others—is consistent with the paper's narrative that reasoning optimization can slightly degrade certain perception capabilities.

At smaller scales, InternVL3.5-8B scores 79.2 overall understanding vs. InternVL3-8B's 79.4 (-0.2 points), while InternVL3.5-4B scores 75.8 vs. MiniCPM-V-4-4B's 68.0 (+7.8 points). For hallucination, InternVL3.5-8B scores 72.8 vs. InternVL3-8B's 72.4 (+0.4 points), while InternVL3.5-2B scores 70.5 vs. InternVL3-2B's 67.9 (+2.6 points).

Visual Grounding

Table 7 reports RefCOCO, RefCOCO+, and RefCOCOg results. InternVL3.5-241B-A28B achieves a new state-of-the-art overall score of 92.4, surpassing InternVL3-78B's 91.4 (+1.0 point) and Qwen2.5-VL-72B's 90.3 (+2.1 points). However, at the 38B scale, InternVL3.5-38B scores 89.1 vs. InternVL3-38B's 91.2—a 2.1-point regression, the largest negative change in the grounding evaluation. The paper does not discuss this specific regression, but it fits the broader pattern of larger models sometimes trading perceptual precision for reasoning capability.

Multilingual Understanding

Table 8 reports MMMB, Multilingual MMBench (en, zh, pt, ar, tr, ru), and MTVQA across six languages. InternVL3.5-241B-A28B achieves 70.8 overall vs. InternVL3-78B's 68.9 (+1.9 points), with the largest gain on MTVQA (39.3 vs. 32.5, +6.8 points). Across all model scales, InternVL3.5 consistently outperforms InternVL3 on multilingual metrics, with gains ranging from +1.2 points (1B: 49.1 vs. 47.9) to +2.5 points (4B: 62.1 vs. the smaller 2B comparison at 57.4). On MTVQA specifically, InternVL3.5-8B achieves 35.2 vs. InternVL3-8B's 30.2 (+5.0 points), and InternVL3.5-38B achieves 36.1 vs. 32.4 (+3.7 points). Against GPT-4V's 56.1 overall multilingual score, InternVL3.5-241B-A28B leads by 14.7 points.

Video Understanding

Table 9 reports on Video-MME, MVBench, MMBench-Video, MLVU, and LongVideoBench. Testing uses 16, 32, 48, and 64 frames with the maximum result reported. InternVL3.5-241B-A28B achieves 71.4 overall vs. InternVL3-78B's 72.1 (-0.7 points). At the 38B scale, InternVL3.5-38B scores 71.0 vs. InternVL3-38B's 71.7 (-0.7 points). At 8B, the score is 65.8 vs. 66.2 (-0.4 points). These consistent slight regressions at larger scales contrast with clear improvements at the smallest scales: InternVL3.5-1B scores 54.1 vs. InternVL3-1B's 51.9 (+2.2 points), and InternVL3.5-2B scores 60.0 vs. InternVL3-2B's 59.6 (+0.4 points). On LongVideoBench, InternVL3.5-1B shows a notable +4.9 point gain (53.0 vs. 48.1). Against GPT-5, InternVL3.5-241B-A28B trails on VideoMME (72.9 vs. 81.8) and LongVideoBench (67.1 vs. 72.6), with the gap on video understanding being larger than on general multimodal tasks.

GUI Agent Tasks

Table 10 reports GUI grounding (ScreenSpot, ScreenSpot-v2, OSWorld-G) and online agentic evaluation (OSWorld, WindowsAgentArena, WebArena-Lite-v2). InternVL3.5-241B-A28B achieves 89.8 on ScreenSpot, 92.9 on ScreenSpot-v2, and 53.2 on OSWorld-G. On ScreenSpot-v2, this surpasses the specialized UI-TARS-72B (90.3) by 2.6 points and approaches Seed1.5-VL's 95.2. On the online agent benchmarks, InternVL3.5-241B-A28B achieves 18.0 on WindowsAgentArena (vs. GPT-4o's 3.5 and UI-TARS-72B's 17.9) and 11.7 on WebArena-Lite-v2 (vs. GPT-4o's 1.9 and Qwen2.5-VL-72B's 14.4). The 8B variant achieves 87.9 on ScreenSpot vs. InternVL3-8B's 79.5 (+8.4 points). The 30B-A3B MoE achieves 86.6 on ScreenSpot vs. InternVL3-38B's 85.6 (+1.0 point), while the 38B dense scores 81.0—notably lower than the 8B model and a regression from InternVL3-38B's 85.6, with the paper providing no explanation for this anomaly.

Embodied Agent Tasks

Table 11 reports VSI-Bench, ERQA, SpaCE-10, and OmniSpatial. InternVL3.5-241B-A28B achieves 55.8 overall, the highest among all compared models including GPT-5 (51.7), Gemini-2.5-Pro (51.0), and Claude-3.7-Sonnet (43.9). On VSI-Bench, the flagship scores 69.5 vs. InternVL3-78B's 48.4 (+21.1 points). Even InternVL3.5-1B scores 49.3 on VSI-Bench, surpassing Qwen2.5-VL-72B's 36.1 and matching GPT-5's 37.5. The scaling trend is monotonic: 1B (39.7 overall) → 2B (42.0) → 4B (43.7) → 8B (46.1) → 14B (49.7) → 30B-A3B (50.8) → 38B (51.2) → 241B (55.8). On ERQA, the 241B model scores 46.8, close to Gemini-2.5-Pro's 48.3 but behind GPT-5's 65.7.

SVG Tasks

Table 12 reports SGP-Bench for SVG understanding. InternVL3.5-241B-A28B achieves 70.7 overall vs. InternVL3-78B's 60.3 (+10.4 points), setting a new open-source state-of-the-art. At smaller scales, InternVL3.5-4B scores 57.7, surpassing InternVL3-14B's 52.9 (+4.8 points). The 30B-A3B MoE scores 69.4, approaching the 241B model, while the 38B dense scores 69.5—slightly higher. Against GPT-5's 77.5, the gap is 6.8 points.

Table 13 reports SVG generation on SArena-Icon (Text2SVG and Img2SVG). InternVL3.5-241B-A28B achieves an FID of 11.27 and FID-C of 4.43 on Text2SVG—the best among all open-source models and competitive with Claude-4-Sonnet (15.84 FID, 4.29 FID-C) and Claude-3.7-Sonnet (14.38 FID, 3.50 FID-C). InternVL3.5-38B achieves 14.56 FID and 5.22 FID-C, surpassing GPT-4o's 15.18 FID. On Img2SVG, InternVL3.5-241B-A28B achieves a CLIP score of 76.81 and DINO of 0.88, behind Claude models but ahead of GPT-4o (77.74, 0.87). At the 20B-A4B scale, the model achieves a remarkable PSNR of 12.75, substantially higher than most competitors, though its FID (16.78) is mid-range. The scaling pattern in SVG generation is not monotonic: the 20B-A4B MoE outperforms the 30B-A3B MoE on several metrics (FID 16.78 vs. 16.31; PSNR 12.75 vs. 9.64), and the 14B dense outperforms the 8B dense by a wide margin on FID-C (5.99 vs. 7.13).

Text-Only Capabilities

Table 14 compares InternVL3.5 against the Qwen3 language models that serve as their LLM initialization. InternVL3.5-1B outperforms Qwen3-0.6B on 15 of 16 text benchmarks, with an overall gain of +6.7 points (44.8 vs. 38.1). InternVL3.5-241B-A28B scores 87.6 vs. Qwen3-235B-A22B's 85.3 (+2.3 points). The largest improvements are on mathematical reasoning: InternVL3.5-1B scores 68.2 on MATH vs. Qwen3-0.6B's 32.4 (+35.8 points), and InternVL3.5-2B scores 85.5 vs. 43.5 (+42.0 points). On AIME2025, InternVL3.5-1B scores 14.7 vs. Qwen3-0.6B's 13.3 (+1.4 points), while at 241B the gain is reversed: InternVL3.5 scores 75.6 vs. Qwen3's 83.3 (-7.7 points). On HumanEval, InternVL3.5-1B scores 45.7 vs. 39.6 (+6.1 points), and the 38B model scores 98.2 vs. 89.6 (+8.6 points). The paper attributes these gains to "high-quality text corpora we use during pre-training and SFT" and "our Cascade RL, which significantly benefits text-based reasoning tasks."

Ablation Studies and Robustness Checks

Cascade RL training stages (Figure 5, Table 15): Across all model scales from 1B to 241B, each stage of Cascade RL provides additional gains. Using reasoning benchmarks as the metric: InternVL3.5-Instruct (SFT-only) already outperforms InternVL3 at every scale—e.g., 8B: 53.6 vs. 44.3 (+9.3 points), 241B: 60.4 vs. 54.6 (+5.8 points). MPO adds further gains—8B: 56.3 (+2.7 over Instruct), 241B: 62.4 (+2.0 over Instruct). The full Cascade RL (MPO + GSPO) adds still more—8B: 60.3 (+4.0 over MPO, +6.7 over Instruct), 241B: 66.9 (+4.5 over MPO, +6.5 over Instruct). The gains from the online stage (MPO → CascadeRL) are consistently larger than the gains from the offline stage (Instruct → MPO) across all scales: 8B +4.0 vs. +2.7, 241B +4.5 vs. +2.0. However, the offline stage is dramatically cheaper (~0.3K GPU hours for MPO vs. ~5.5K for one episode of GSPO), making the marginal cost-per-point for offline RL much lower.

Training efficiency of Cascade RL vs. GSPO-alone (Table 16): On InternVL3.5-8B, MPO achieves an overall reasoning score of 56.3 at ~0.3K GPU hours. GSPO alone (1 episode, ~5.5K GPU hours) reaches 57.3—only 1.0 point above MPO at ~18× the compute cost. GSPO alone (2 episodes, ~11.0K GPU hours) reaches 58.2—still below Cascade RL's 60.3 at ~5.8K GPU hours. This is the critical evidence that offline warm-up is not merely cheaper but enables better final performance than spending equivalent compute on more online RL. Notably, the second episode of GSPO (57.3 → 58.2, +0.9 points) provides diminishing returns at high cost, while the GSPO stage within Cascade RL (56.3 → 60.3, +4.0 points) is dramatically more efficient—suggesting that the quality of the starting policy fundamentally changes the efficiency of online RL, not just its final performance.

Visual Resolution Router (ViR) performance impact (Table 17): InternVL3.5-Flash (with ViR) maintains nearly 100% of the performance of InternVL3.5 (without ViR) across nine benchmarks at both 8B and 38B scales. At 8B: Full model scores 80.2 overall vs. Flash's 79.8 (-0.4 points). On DocVQA: 92.3 vs. 91.9 (-0.4). On MMMU: 73.4 vs. 72.9 (-0.5). On MathVista: 78.4 vs. 78.0 (-0.4). At 38B: 83.9 vs. 83.4 (-0.5 overall). At 241B-MoE: 85.0 vs. 84.5 (-0.5 overall). The consistency of the ~0.4–0.5 point drop across scales suggests the ViR compression introduces a small but systematic information loss that does not compound with model size. The paper claims ViR reduces visual tokens by 50%, though this is the average over patches—the actual reduction depends on the image content and the router's decisions.

ViR efficiency gains (Table 18): On InternVL3.5-38B, DvD alone provides 1.19× speedup at 448 resolution, 1.87× at 896, and 1.97× at 1344. Adding ViR on top of DvD provides additional gains: 1.50× at 448, 4.05× at 896, and 3.47× at 1344 (all relative to the baseline without DvD or ViR). At 241B, the pattern holds: DvD + ViR achieves 1.85× at 448, 3.47× at 896, and 3.12× at 1344. The peak speedup (4.05×) occurs at 896 resolution on the 38B model. The speedup from DvD increases with resolution because vision computation becomes a larger fraction of total inference time at higher resolutions, making the overlap more impactful. The speedup from ViR is relatively constant across resolutions for the 38B model (1.26× at 448, 2.16× at 896, 1.76× at 1344, computed as the ratio of DvD+ViR to DvD alone) but increases with resolution for the 241B model (1.49× at 448, 1.86× at 896, 1.55× at 1344), likely due to the larger vision encoder (6B vs. 300M) benefiting more from token reduction.

Test-time scaling with parallel thinking (Table 3): For reasoning benchmarks, parallel thinking provides consistent but modest gains across model scales. At 1B: +9.5 points overall (33.8 → 43.3, +28.1% relative). At 8B: +2.1 points (60.3 → 62.4, +3.5% relative). At 241B: +1.8 points (66.9 → 68.7, +2.7% relative). The diminishing relative gains at larger scales are expected: larger models have higher pass@1 rates, so best-of-N sampling provides less additional value. The absolute gains are relatively consistent (1.8–2.1 points for models 4B and above), suggesting the benefit is a fixed increment rather than a percentage improvement.

Critical Assessment

The experiments supporting InternVL3.5 span an unusually broad range of benchmarks (35+) and model scales (1B to 241B), providing one of the most comprehensive evaluations in the open-source MLLM literature. However, the paper's specific claims require careful scrutiny against what the experiments actually demonstrate.

On the claim of +16.0% reasoning improvement: The paper's abstract and conclusion state that InternVL3.5 achieves "up to a +16.0% gain in overall reasoning performance" compared to InternVL3. Looking at Table 3, InternVL3.5-8B scores 60.3 vs. InternVL3-8B's 44.3—an absolute difference of 16.0 points. InternVL3.5-2B shows +18.3 points (50.7 vs. 32.4). InternVL3.5-38B shows +13.2 points (66.0 vs. 52.8). The "up to +16.0%" phrasing is accurate as a maximum (the 8B case) but should be understood as absolute percentage points, not relative percentage improvement (which would be 60.3/44.3 - 1 = 36.1% relative improvement). This distinction matters for interpreting the practical significance.

On the claim that Cascade RL is the driver of reasoning gains: The ablation in Table 15 attributes the reasoning gains to specific training stages. However, the paper does not isolate Cascade RL from the SFT improvements. InternVL3.5-Instruct (SFT-only) already substantially outperforms InternVL3 at every scale (e.g., 8B: 53.6 vs. 44.3). The incremental contribution of Cascade RL over SFT is +6.7 points at 8B—meaning SFT accounts for slightly more than half the total gain over InternVL3 (9.3 out of 16.0 points). This does not diminish Cascade RL's contribution, but it means the +16.0% figure should not be attributed solely to RL—the SFT data and training improvements are equally important. The paper does not ablate the SFT data changes (e.g., adding Thinking-mode data, capability-expansion datasets) to quantify their individual contributions, making it impossible to determine whether the SFT gains come from data quality, data quantity, or both.

On the claim of 4.05× inference speedup: This figure comes from Table 18 for InternVL3.5-38B at 896 resolution with DvD + ViR. This is the maximum speedup observed across the tested configurations, not the typical speedup. At 448 resolution (a more common deployment setting), the speedup is 1.50×. At 1344 resolution, it is 3.47×. The 4.05× figure is therefore a best-case scenario at a specific (high) resolution on a specific model. Additionally, the baseline is "vanilla deployment" on shared GPUs, not the best possible single-GPU optimization. The throughput measurement uses 16 concurrent requests on 8 A100 GPUs for the language model alone—the vision server's GPU count and type are not specified. This makes exact replication of the efficiency numbers difficult.

On the claim of narrowing the gap with GPT-5 to 3.9%: Figure 1 shows InternVL3.5-241B-A28B at 72.6 vs. GPT-5 at 76.5—a gap of 3.9 percentage points. However, this aggregate masks substantial heterogeneity. On reasoning, the gap is 7.2 points (66.9 vs. 74.1 per Table 3). On text tasks, it is 6.0 points (85.3 vs. 91.3 per Table 2). The near-parity on general tasks (74.1 vs. 74.0) is doing most of the work in narrowing the overall average. For practitioners whose primary use case is reasoning or text understanding, the effective gap is larger than 3.9%.

On the generalizability of ViR performance preservation: Table 17 shows that InternVL3.5-Flash maintains nearly 100% of the original performance on the nine tested benchmarks. However, these benchmarks are heavily weighted toward OCR and document understanding (DocVQA, ChartVQA, InfoVQA, TextVQA, OCRBench, AI2D) with only two reasoning benchmarks (MMMU, MathVista) and one general benchmark (MMStar). The strong preservation on OCR tasks is expected—the router was trained specifically on OCR and VQA data to recognize when high resolution is needed. Performance preservation on OTHER task types (video understanding, embodied tasks, GUI agent tasks, SVG tasks) is not reported. If the router over-compresses on tasks requiring fine-grained spatial reasoning that were not in its training distribution, performance could degrade more than the reported 0.4–0.5 points.

On missing experiments: Several ablations would strengthen the paper's claims but are not present: (1) The relative contribution of each loss component in MPO (preference vs. quality vs. generation) is not ablated—we do not know whether all three are necessary or whether a simpler two-component loss would suffice. (2) The sensitivity to the 0.2–0.8 accuracy threshold for online RL data filtering is not explored—would a wider band (0.1–0.9) include more training data with minimal degradation, or would a narrower band (0.3–0.7) improve efficiency further? (3) The ViR threshold percentile k is never specified, and the sensitivity of the speed-performance tradeoff to this parameter is not shown—a curve showing throughput vs. accuracy as k varies would characterize the Pareto frontier. (4) No head-to-head comparison of Cascade RL against other RL approaches for MLLMs beyond GSPO and MPO in isolation—comparisons with GRPO, standard PPO with a KL penalty, or the RL approaches used by GLM-4.5V and MiMo-VL-RL would contextualize the claimed advantages. (5) The ViR routing decisions are never visualized—showing which patches the router chooses to compress for example images would provide intuition about what "semantic richness" means in practice and whether the router learns sensible policies.

On the single-model-family limitation: All experiments use InternViT vision encoders and Qwen3/GPT-OSS language models. The Cascade RL framework is presented as a general approach, but whether it transfers to other vision encoders (SigLIP, CLIP, DINOv2) or other language model families (Llama, Gemma, DeepSeek) is untested. Similarly, ViR's effectiveness depends on the specific pixel shuffle compression architecture—whether the approach generalizes to MLLMs using different token compression strategies (e.g., learned pooling, Q-former, perceiver resampling) is unknown.

On the test-time compute accounting: The main benchmark results explicitly exclude test-time scaling (parallel thinking), which is reported separately. This means InternVL3.5's headline numbers represent single-sample performance, while commercial models like GPT-5 may use unknown amounts of test-time compute by default. If GPT-5 uses chain-of-thought or internal search that is not disclosed, the comparison is not fully controlled. The paper's TTS results show that parallel thinking adds 1.8–2.1 points for models 4B and above—if GPT-5's reported scores already include similar TTS, the "true" single-sample gap would be smaller than reported.

On the anomalous 38B grounding and GUI results: InternVL3.5-38B shows regressions on visual grounding (Table 7: 89.1 vs. InternVL3-38B's 91.2) and GUI tasks (Table 10: ScreenSpot 81.0 vs. InternVL3-38B's 85.6) that are substantially larger than expected from the general pattern of slight OCR/understanding regressions. The paper does not discuss or explain these anomalies, which appear on tasks where the 241B model shows improvements. This suggests possible training instability or hyperparameter sensitivity at the 38B scale that was not fully diagnosed.

Overall assessment of the evidence quality: The paper's central empirical claims—that Cascade RL improves reasoning across scales, that ViR reduces tokens with minimal performance loss, and that DvD improves throughput—are well-supported by the reported experiments. The broader positioning claim—that InternVL3.5 narrows the gap with commercial models to 3.9%—is an accurate reading of the aggregate metric but requires careful qualification about task-level heterogeneity. The paper's value is primarily as a comprehensive systems contribution demonstrating that specific training and deployment innovations can simultaneously improve capability and efficiency at scale, rather than as a fundamental algorithmic advance. The ablation of Cascade RL stages (Table 15) and the efficiency analysis (Table 18) are the strongest experimental sections, providing clear, causally interpretable evidence for the paper's specific technical claims. The benchmark comparisons against competitors, while extensive, provide correlational evidence of overall quality rather than causal evidence about which specific design choices drive the improvements.

6. Limitations and Trade-offs

Cascade RL Dependence on Pre-Collected Rollout Data

The assumption. The offline RL stage (MPO) depends entirely on MMPR-v1.2, a dataset of approximately 200K pre-collected preference pairs with rollouts generated by some prior model. The paper states that "rollouts can be shared across different models, amortizing the sampling cost typically incurred during online RL" (Section 2.3). This amortization is the efficiency argument for Cascade RL, but it embeds a strong assumption: that rollouts generated by one model (or ensemble of models) provide informative preference signals for a different model being trained.

The consequence. If the model generating MMPR-v1.2 rollouts has a substantially different error distribution from the model being trained, the preference pairs may provide a misleading training signal. The MPO stage could reinforce behaviors that were good for the rollout-generating model but suboptimal for the target model, or fail to penalize error patterns specific to the target model's architecture. This is the standard off-policy problem in RL—training on data from a different policy—and it is not addressed by the Cascade RL framework beyond the empirical observation that it works for InternVL3.5. For a practitioner training a substantially different MLLM architecture (e.g., with a different vision encoder or language model family), the MMPR-v1.2 dataset may transfer poorly, and the cost of constructing an equivalent dataset for their model would eliminate the amortization benefit Cascade RL claims.

What evidence exists. The paper provides no ablation studying the sensitivity of MPO performance to the provenance of the rollout data. All experiments use MMPR-v1.2 rollouts without varying the data source, model used for generation, or degree of distribution shift. Table 15 shows that MPO consistently improves over the Instruct baseline across all model scales (e.g., +2.7 points at 8B, +2.0 at 241B), but this only demonstrates that the specific MMPR-v1.2 dataset works for the specific InternVL3.5 architecture initialized from Qwen3/GPT-OSS backbones. There is no experiment testing whether MPO with rollouts generated by the InternVL3.5-SFT model itself (on-policy off-policy data) would outperform MPO with the pre-collected MMPR-v1.2 rollouts, or whether performance degrades when using rollouts from a model with a different vision encoder.

Mitigation status. Not addressed. The paper treats MMPR-v1.2 as a fixed asset whose transferability is assumed rather than tested. The online RL stage (GSPO) partially mitigates this by training on the model's own rollouts, which are on-policy—but only after the MPO stage has already shaped the model. If MPO reinforces suboptimal behaviors due to distribution shift, GSPO may be initialized in a worse region of parameter space than if offline RL had been skipped entirely. The paper's suggestion that "stronger models exhibit more stable and robust training dynamics" during online RL (Section 2.3) assumes MPO genuinely improves the model rather than fitting it to an off-policy dataset. A practitioner deploying Cascade RL with a novel architecture would need to either construct a new preference dataset (at substantial cost) or accept the risk of negative transfer.

---

Hard Problems Remain Fundamentally Unsolved

The assumption. The Cascade RL framework, ViR compression, DvD deployment, and test-time scaling all assume that the base model has some non-trivial probability of producing correct answers—that improved training and inference strategies can amplify existing capabilities. The paper's online RL data filtering explicitly enforces this: queries with accuracy below 0.2 are excluded from MMPR-Tiny because "there are no good rollouts to learn from."

The consequence. For problem categories where the base model's pass@1 is near zero, no amount of Cascade RL, test-time scaling, or efficient deployment helps. This is a hard capability boundary: the techniques in this paper amplify what is already present but do not create new competencies. This has direct practical implications for deployment. If an application requires handling a long tail of genuinely difficult problems—complex mathematical proofs, novel scientific reasoning, tasks requiring knowledge the base model lacks—InternVL3.5 offers no mechanism for closing that gap beyond what pretraining already provides. The paper's own framing of "narrowing the gap with GPT-5" is achieved primarily on tasks where the base model already has reasonable performance; on the hardest reasoning tasks, the gap remains large.

What evidence exists. The difficulty-dependent pattern is visible throughout the benchmark results, though the paper does not explicitly bin by difficulty as some prior works do. Table 3 shows that on the most challenging reasoning benchmarks, InternVL3.5-241B-A28B trails GPT-5 by substantial margins: MathVision (63.9 vs. 72.0), MathVerse (68.5 vs. 81.2), DynaMath (46.5 vs. 60.9), LogicVista (66.7 vs. 70.0). On AIME25, a competition math benchmark, InternVL3.5-241B-A28B scores 75.6 vs. GPT-5's 94.6 (Table 2). These gaps are far larger than the 3.9% aggregate difference reported in Figure 1, precisely because the aggregate is diluted by easier benchmarks where both models perform well. The Cascade RL ablation (Table 15) shows that even after full Cascade RL training, the 241B model's DynaMath score improves from 36.5 to 46.5—a meaningful gain but still far below GPT-5's 60.9. This suggests that RL amplifies reasoning on problems the model partially understands but does not create understanding where none existed.

Mitigation status. The paper is partially transparent about this. Section 2.4 notes that test-time scaling is only applied to reasoning benchmarks because "the model already exhibits strong perception and understanding capabilities, and initiating TTS yields no significant improvement"—an implicit acknowledgment that these techniques have ceilings. However, the paper does not characterize the capability boundary systematically. There is no analysis of which types of reasoning problems benefit from Cascade RL versus which remain unsolved, no difficulty-stratified breakdown of benchmark results, and no estimate of what fraction of real-world tasks fall above versus below the model's capability threshold. A practitioner cannot determine from the paper whether their specific use case is likely to benefit from the proposed methods or falls in the "still unsolved" regime.

---

Visual Compression Robustness Evaluated Only on OCR-Heavy Tasks

The assumption. The ViR training procedure and the performance-preservation claim rest on an implicit assumption: that if the model can maintain accuracy on OCR, document, and chart understanding benchmarks with 50% token reduction, it will maintain accuracy on all task types. The router training data is "primarily composed of OCR and VQA examples, which are rich in visual information and sometimes require high-resolution understanding" (Section 2.3), and the performance evaluation of InternVL3.5-Flash (Table 17) uses nine benchmarks heavily weighted toward text-rich understanding: DocVQA, ChartVQA, InfoVQA, TextVQA, OCRBench, AI2D, plus MMStar, MMMU, and MathVista.

The consequence. The ViR learns to preserve resolution for text-heavy patches because it was trained primarily on tasks where text reading is the dominant visual skill. On tasks requiring fine-grained spatial reasoning that does not involve text—estimating relative distances between objects, counting overlapping instances in cluttered scenes, recognizing subtle texture differences, interpreting human poses or facial expressions—the router may over-compress patches that contain critical non-textual detail. A patch showing a person's facial expression contains almost no text but may require high resolution to distinguish a smile from a neutral expression. A patch showing a dense crowd for a counting task has no text but requires fine spatial resolution. The ViR, trained on OCR/VQA data, has no explicit signal to preserve resolution in these cases, and may route them to 64-token compression—losing detail that matters for non-OCR tasks.

What evidence exists. Table 17 shows that InternVL3.5-Flash preserves performance within 0.4–0.5 points across the tested benchmarks. But the tested benchmarks are exactly those where the router was trained to perform well. Performance on video understanding, embodied tasks (VSI-Bench, OmniSpatial, SpaCE-10), visual grounding (RefCOCO), GUI agent tasks (ScreenSpot, OSWorld), and SVG tasks is not reported for the Flash variants. The paper provides no evidence that ViR preserves performance on these task categories. The claim in Section 3.15 that "ViR can greatly benefit the model performance without sacrificing performance" has only been demonstrated for a specific, narrow set of visually text-heavy benchmarks. The abstract's claim that "InternVL3.5-Flash reduces 50% of the visual tokens while maintaining nearly 100% of the original performance" should be understood as applying to the evaluated benchmarks, not as a universal guarantee.

Mitigation status. Not addressed. The paper acknowledges that router training uses "a subset of the SFT data, primarily composed of OCR and VQA examples" but does not discuss the potential for task-specific overfitting of the compression policy. There is no experiment evaluating Flash variants on non-OCR tasks, no analysis of routing decisions on different image types, and no characterization of failure modes where inappropriate compression degrades performance. A practitioner deploying Flash variants for applications heavy in spatial reasoning, video understanding, or embodied tasks would be operating in an uncharacterized regime where the performance-preservation claim is untested.

---

Difficulty Estimation and Dynamic Thresholding Opaque to Practitioners

The assumption. Two critical hyperparameters in the training pipeline are specified only qualitatively. The online RL data filtering uses queries "whose model accuracy falls between 0.2 and 0.8"—but this requires computing per-query accuracy from MMPR-v1.2 rollouts generated by some prior model, not by the model currently being trained. The ViR router training uses a dynamic threshold τ computed as "the k-th percentile of historical r_i values" where k is chosen so that "the target distribution is balanced" (Section 2.3). Neither k nor the sliding window size for historical values is specified.

The consequence. These seemingly minor details encode substantive design choices that affect training dynamics. For online RL data filtering, using accuracy computed from a different model's rollouts (MMPR-v1.2) rather than the current model's rollouts means the 0.2–0.8 band is approximate—queries that MMPR-v1.2's generator found medium-difficulty may be trivially easy or impossibly hard for the current model at its current training stage. As training progresses and the model improves, the effective difficulty distribution shifts, but the filtering remains static. This could mean the model spends training compute on queries that are already saturated (accuracy near 1.0 for the current model but ~0.7 for the data-generating model) or continues to exclude queries that have recently become learnable. For ViR, the choice of k directly controls the aggressiveness of compression: a higher k means fewer patches are compressed (more conservative, higher quality, lower speedup), while a lower k means more patches are compressed (more aggressive, lower quality, higher speedup). Without knowing k, a practitioner cannot reproduce the speed-quality tradeoff, cannot tune it for their deployment requirements, and cannot determine whether the reported 50% token reduction is near-optimal or could be substantially improved with different thresholding.

What evidence exists. The paper provides no sensitivity analysis for either the accuracy filtering threshold or the ViR percentile threshold. Table 17 shows the final Flash performance at one operating point, and Table 18 shows the throughput at that point, but the Pareto frontier—how throughput and accuracy co-vary as k changes—is not characterized. Table 16 shows the training efficiency for the specific 0.2–0.8 filtering used, but alternative filtering strategies (no filtering, 0.1–0.9, 0.3–0.7, dynamic filtering based on current model accuracy) are not compared. This makes the paper's specific choices appear as magic numbers rather than principled selections from an explored design space.

Mitigation status. Not addressed. The paper acknowledges that the difficulty estimation for Cascade RL data filtering uses pre-computed accuracies from MMPR-v1.2, but does not discuss the approximation error or propose dynamic re-estimation during training. The ViR threshold is described as dynamic and balanced but without the specificity needed for reproduction. Both are flagged implicitly as areas where practitioners would need to tune for their own setups, but the paper provides no guidance on how to perform that tuning or what tradeoffs to expect.

---

Tradeoff Between Perception and Reasoning Not Quantified or Controlled

The assumption. The paper optimizes InternVL3.5 primarily for reasoning performance through Cascade RL, while assuming that perception and understanding capabilities will be largely preserved. The authors acknowledge this tradeoff explicitly in Section 3.6: "our optimization of text and reasoning capabilities—which, while achieving improvements on relevant benchmarks, slightly impairs the performance of multimodal understanding."

The consequence. Practitioners deploying InternVL3.5 must accept degraded perception capabilities in exchange for improved reasoning, with no mechanism to control the tradeoff. The degradation is not uniform: some benchmarks show regressions while others show improvements, and the pattern varies by model scale. A practitioner whose application requires both strong OCR (e.g., document processing) and strong reasoning (e.g., mathematical problem-solving from diagrams) cannot choose a model variant that optimizes both simultaneously—they must accept the OCR regression to get the reasoning gain, or use the predecessor InternVL3 and accept weaker reasoning. This is a fundamental tension the paper does not resolve: the training innovations that improve reasoning appear to systematically degrade certain perceptual capabilities, but the paper provides no analysis of why this happens or how to mitigate it.

What evidence exists. The regression pattern is visible across multiple benchmark categories. On OCR/chart/document understanding (Table 4), InternVL3.5-241B-A28B scores 85.2 vs. InternVL3-78B's 85.8 (-0.6 overall), with DocVQA dropping from 95.4 to 94.9 and InfoVQA from 86.5 to 82.0. On hallucination (Table 6), the 241B model drops from 76.2 to 75.3. On video understanding (Table 9), the 241B model drops from 72.1 to 71.4. On OCRBench, the 8B model drops from 880 to 840 despite similar overall scores. These are individually small but collectively systematic: perception-oriented benchmarks consistently show slight regressions while reasoning benchmarks show large gains. At the 38B scale, the grounding regression is more severe (Table 7: 89.1 vs. 91.2, -2.1 points). The paper does not analyze whether these regressions are caused by catastrophic forgetting during RL, by changes in the model's attention patterns that favor textual reasoning over visual detail, or by the specific data mixtures used in post-training.

Mitigation status. The paper acknowledges the tradeoff but treats it as acceptable collateral: "this is partly because the model's understanding performance has approached saturation, and also partly stems from our optimization of text and reasoning capabilities" (Section 3.6). No mitigation strategy is proposed. There is no experiment testing whether perception capabilities can be recovered through multi-task training, replay of perception data during RL, or an additional fine-tuning stage. The Flash variants (Table 17) add a small additional degradation on top of the base regression—InternVL3.5-8B-Flash scores 79.8 vs. 80.2—but the compounding effect of reasoning optimization + compression on perception-heavy tasks is not characterized. A practitioner who needs both strong OCR and strong reasoning has no guidance on how to navigate this tradeoff.

---

Cascade RL Computational Cost Still Substantial, Not Fully Amortized

The assumption. The paper positions Cascade RL as efficient relative to pure online RL, showing in Table 16 that Cascade RL (~5.8K GPU hours for 8B) outperforms two episodes of GSPO (~11K GPU hours) by 2.1 reasoning points. However, this comparison is against an inefficient alternative, not against the total cost of the training pipeline. The MPO stage's cost (~0.3K GPU hours) is described as amortized because "rollouts can be shared across different models," but this amortization only holds if the same MMPR-v1.2 dataset can be reused for multiple training runs. For the first training run, the cost of constructing MMPR-v1.2—generating rollouts from a capable model, computing rewards, forming preference pairs—must be incurred and is never accounted for.

The consequence. A practitioner training an MLLM from scratch cannot realize the amortized cost the paper claims. They must either: (1) construct their own preference dataset, paying the full rollout generation cost (which, for 200K samples, could be comparable to or exceed the online RL cost), or (2) use MMPR-v1.2 and hope it transfers to their architecture. In either case, the effective cost of Cascade RL is substantially higher than the ~5.8K GPU hours reported for the 8B model when the full data construction pipeline is included. This makes the efficiency comparison against GSPO-alone misleading for first-time training: GSPO-alone requires no pre-collected preference data, while Cascade RL's apparent efficiency depends on access to a dataset whose construction cost is externalized from the accounting.

What evidence exists. Table 16 reports only the training GPU hours for each method applied to the already-SFT model, not the end-to-end cost including data construction. The paper notes that MMPR-v1.2 rollouts are "directly reused" for offline RL and data filtering, and that this "reduces the cost of sampling additional rollouts." But the initial cost of sampling those rollouts is never stated. For scale context, constructing a dataset of 200K preference pairs likely requires generating multiple rollouts per query (at least 2–4 per query to form preference pairs), plus scoring/verification. At 200K queries with 4 rollouts each at the scale of a model capable of generating high-quality reasoning traces, this could easily cost several thousand GPU hours—comparable to the online RL stage itself.

Mitigation status. The paper is partially transparent: it explicitly states that MMPR-v1.2 rollouts are reused, and that this is an efficiency benefit. However, it never quantifies the data construction cost or presents an end-to-end cost comparison that includes data preparation. The abstract and introduction's efficiency claims for Cascade RL should be understood as referring to training efficiency given a pre-existing preference dataset, not end-to-end efficiency for a practitioner starting from scratch. The paper does not discuss whether MMPR-v1.2 will be publicly released, whether its construction methodology is documented sufficiently for reproduction, or what the expected cost of constructing an equivalent dataset for a new architecture would be.

7. Implications and Future Directions

How This Work Changes the Landscape

InternVL3.5 is not a paradigm shift—it does not introduce a fundamentally new architecture, training objective, or theoretical framework. Rather, it is an engineering synthesis paper that demonstrates how to combine existing components (offline RL, online RL, dynamic token compression, decoupled deployment) into a coherent system that advances both capability and efficiency simultaneously. The paper's impact on the field should be understood along four dimensions, each with a different magnitude of contribution.

Cascade RL reframes the offline-online RL debate from competition to sequencing. Before this paper, the dominant framing in the MLLM RL literature—implicit in work like GLM-4.5V, MiMo-VL-RL, and Keye-VL—treated offline RL (DPO and variants) and online RL (PPO, GRPO) as competing approaches with different cost-quality tradeoffs. The field was gravitating toward online RL as the "real" method, with offline RL seen as a cheaper-but-weaker fallback. Cascade RL's key empirical finding—that MPO followed by GSPO achieves better performance at lower total cost than GSPO alone run for twice as many episodes (Table 16: 60.3 at ~5.8K GPU hours vs. 58.2 at ~11K GPU hours)—inverts this narrative. It demonstrates that offline RL is not a substitute for online RL but a precondition for efficient online training. The warm-start model produces rollouts with clearer advantage signals, making each online training step more informative. This reframing has immediate methodological implications: future RL for MLLMs should budget for an offline stage not as a compromise but as an investment that improves the return on online training.

The reframing also explains why prior online-only RL attempts for MLLMs have been unstable or inefficient—they were starting from policies too weak to generate informative rollouts, making the advantage estimates noise-dominated. Cascade RL provides a recipe for escaping this trap, and the consistency of gains across model scales from 1B to 241B (Table 15) suggests the principle is not scale-dependent. This shifts the default training pipeline from "pick one RL paradigm" to "sequence them in the right order," which is a genuine methodological advance even if the individual components are not novel.

ViR establishes task-aware compression as a first-class design dimension. The paper's approach to visual token compression—defining compression impact through downstream task sensitivity (KL divergence in output space) rather than perceptual reconstruction quality—is a methodological contribution that generalizes beyond InternVL3.5. Standard compression research optimizes for metrics like PSNR, SSIM, or LPIPS, which measure how similar the compressed image looks to the original. ViR's training procedure optimizes for a fundamentally different objective: can the language model produce the same output distribution with compressed tokens as with full tokens? This is task-aware compression—the compression budget is allocated based on what the downstream model needs, not what a human observer would notice.

The practical impact is demonstrated in Table 17: 50% token reduction with only 0.4–0.5 points of performance degradation across nine benchmarks. This is not a marginal improvement—it is near-lossless 2× compression, which changes the economics of deploying high-resolution MLLMs. The ViCO training procedure (consistency training followed by router training) provides a template for any MLLM using patch-based image encoding: train the model to be robust to variable compression, then train a router to predict when compression is safe based on the model's own sensitivity. This template could be applied to MLLMs using different vision encoders (SigLIP, CLIP, DINOv2) or different compression strategies (token merging, learned pooling), making ViR's contribution larger than its specific implementation.

DvD establishes deployment architecture as co-equal with model architecture. The traditional MLLM development pipeline treats deployment as an engineering afterthought—you train the best model you can, then figure out how to serve it efficiently. DvD argues, through empirical demonstration (Table 18: up to 2.01× speedup from DvD alone, 4.05× combined with ViR), that deployment architecture deserves the same research attention as training innovations. The key insight is that the vision and language components of MLLMs have fundamentally different computational characteristics (feedforward parallel vs. autoregressive sequential), and physical separation enables each to be optimized independently—vision servers can use throughput-optimized GPUs, language servers can use latency-optimized GPUs, and the pipeline eliminates the blocking that creates idle time in shared deployments.

This insight becomes more important as MLLMs scale to higher resolutions, multi-image inputs, and video—all of which increase the vision computation fraction and make the serial bottleneck more severe. The paper notes that DvD's speedup increases with resolution (1.19× at 448, 1.97× at 1344), confirming that the benefit grows as the vision workload grows. For practitioners deploying MLLMs at scale, DvD provides a concrete architectural pattern (vision server + language server + asynchronous pipeline) that can be adopted independently of specific model choices. This is a systems contribution rather than an algorithmic one, but for real-world deployment, it may have more immediate impact than any training innovation.

The aggregate benchmark framing reveals but also masks the capability gap. The paper positions InternVL3.5 as narrowing the gap with GPT-5 to 3.9% on overall score (Figure 1). This aggregate is an accurate average across 35 benchmarks, but its interpretability depends on how a practitioner weights those benchmarks. The near-parity on general multimodal tasks (74.1 vs. 74.0) masks large remaining gaps on reasoning (67.1 vs. 74.3) and text (85.3 vs. 91.3). For a practitioner whose primary use case is mathematical reasoning from diagrams, the effective gap is 7.2 points, not 3.9. The paper does not misrepresent this—the per-category breakdowns are clearly reported in Table 2—but the headline figure requires careful interpretation. The methodological contribution is not the number itself but the demonstration that open-source models can match commercial models on perception while still lagging on reasoning—a diagnostic that focuses future research attention on the reasoning gap specifically rather than on multimodal capability broadly.

---

Follow-Up Research This Work Enables

Characterizing and mitigating the perception-reasoning tradeoff through controlled multi-objective RL. The paper documents but does not explain the systematic perception regressions that accompany reasoning gains (Tables 4, 6, 7, 9). A strong follow-up would train multiple InternVL3.5 variants with Cascade RL where the reward function explicitly includes perception-preservation terms—for example, adding an OCR accuracy reward or a visual grounding reward alongside the reasoning reward during GSPO—and measure whether the tradeoff is fundamental (the model's capacity must be allocated between perception and reasoning, like a fixed budget) or contingent (the current training data and reward design inadvertently penalize perception). The specific experiment: run GSPO with a reward that is a weighted sum of reasoning accuracy and OCRBench score, sweeping the weight from 0.0 to 1.0, and plot the resulting reasoning-vs-perception frontier. If the frontier is convex (improving reasoning requires disproportionate perception loss), the tradeoff is fundamental and practitioners must choose their operating point. If it is concave (modest perception-preservation rewards recover most of the lost perception without sacrificing reasoning), the current regressions are an artifact of reward misspecification that can be fixed.

Dynamic difficulty estimation for adaptive online RL data selection. The paper's 0.2–0.8 accuracy filtering for online RL data is static—it is computed once from MMPR-v1.2 rollouts and never updated. As the model improves during GSPO, the effective difficulty distribution shifts, meaning the model may spend training compute on queries that have become too easy or continue to exclude queries that have become learnable. A dynamic filtering system would periodically re-estimate per-query accuracy using the current policy's rollouts and adjust the training data distribution accordingly. The specific experiment: compare static filtering (current approach) against dynamic filtering where accuracy is re-estimated every N GSPO steps using a small batch of on-policy rollouts, measuring both final reasoning performance and training efficiency. The paper's own motivation—that the 0.2–0.8 band identifies "the learning frontier"—implies that dynamically maintaining this frontier should improve sample efficiency. The MMPR-Tiny dataset construction (filtering MMPR-v1.2 to queries with accuracy 0.2–0.8) already provides the infrastructure; the extension is to make it adaptive.

Stress-testing ViR on non-OCR tasks to characterize the compression failure surface. The strongest limitation of the ViR evaluation is that performance preservation is only demonstrated on benchmarks heavily weighted toward text-rich understanding (Table 17). A rigorous stress-test would evaluate InternVL3.5-Flash on tasks requiring fine-grained spatial reasoning without textual elements: counting tasks with dense overlapping objects, relative depth estimation from monocular images, fine-grained action recognition in video, and embodied navigation where spatial precision matters. The specific experiment: run both InternVL3.5 and InternVL3.5-Flash on VSI-Bench (spatial reasoning), OmniSpatial (spatial understanding), and RefCOCO (visual grounding) and quantify the performance delta. If the delta remains ~0.5 points, the ViR routing generalizes beyond its OCR/VQA training distribution and the compression strategy is broadly safe. If the delta is 5–10 points or more, the router is over-specialized to text-rich tasks, and the ViCO training data must be diversified. Additionally, visualizing which patches the router compresses for different image types (natural scenes, charts, medical images, GUI screenshots) would provide qualitative insight into what "semantic richness" means to the learned policy. A follow-up could also characterize the Pareto frontier of throughput vs. accuracy by sweeping the ViR threshold percentile k (which the paper leaves unspecified) and measuring the resulting token reduction rate and benchmark performance.

Combining Cascade RL with test-time scaling to characterize the training-inference compute tradeoff. The paper reports Cascade RL gains and test-time scaling gains separately but provides no analysis of how they interact. Does Cascade RL reduce the need for test-time compute (because the single-sample policy is stronger) or increase it (because the improved policy benefits more from parallel sampling)? The specific experiment: for a fixed InternVL3.5 model at each Cascade RL training stage (Instruct, MPO, CascadeRL), measure reasoning accuracy as a function of best-of-N budget (N = 1, 4, 16, 64) using VisualPRM as the critic. Plot accuracy-vs-budget curves for each training stage. This would characterize whether RL training and test-time scaling are substitutes (the curve shifts up but becomes flatter—better single-sample performance, less benefit from sampling) or complements (the curve shifts up and maintains slope—the policy benefits from sampling at all training stages). This is directly relevant to the training-inference tradeoff literature that InternVL3.5 touches on but does not systematically explore. If RL training reduces the marginal benefit of test-time compute, practitioners should invest more in training; if it does not, the optimal strategy is to train as much as possible AND sample at inference time.

Generalizing Cascade RL to other MLLM architectures and modalities. The paper's Cascade RL recipe is validated only on InternViT + Qwen3/GPT-OSS architectures. A replication study applying the same MPO → GSPO pipeline to MLLMs with different vision encoders (SigLIP, DFN, EVA-CLIP) and language models (Llama-3, Gemma, DeepSeek) would establish whether Cascade RL's benefits are architecture-specific or broadly applicable. The specific experiment: take a publicly available MLLM checkpoint (e.g., LLaVA-OneVision, Qwen2.5-VL) that was trained with SFT but no RL, apply MPO using a preference dataset constructed from that model's own rollouts, then run GSPO, and measure the same reasoning benchmarks. If the gains replicate (+3–6 points from Cascade RL over SFT), the framework is general. If gains are architecture-dependent, the paper's findings are specific to InternVL3.5's training recipe. Additionally, extending Cascade RL to video understanding or audio-visual tasks would test whether the warm-start principle applies beyond static image reasoning. A negative result—e.g., Cascade RL helps image reasoning but not video reasoning—would refine our understanding of when offline RL pretreatment is beneficial, suggesting it is specific to tasks where the base SFT model already produces non-trivial rollouts.

---

Practical Applications and Downstream Use Cases

Cost-efficient batch inference for document processing pipelines. Organizations that process large volumes of documents (invoices, contracts, academic papers, medical records) using MLLMs for extraction, summarization, and question-answering face a direct cost-quality tradeoff. InternVL3.5-Flash with DvD deployment provides a concrete solution: ViR reduces visual tokens by 50% with negligible accuracy loss on OCR and document benchmarks (Table 17: DocVQA drops from 92.3 to 91.9 at 8B, InfoVQA from 76.2 to 76.0), while DvD provides additional throughput gains through pipelined vision and language processing. At 896 resolution—typical for document images scanned at reasonable quality—the combined DvD + ViR achieves 4.05× speedup over vanilla deployment on InternVL3.5-38B (Table 18). For a batch processing operation handling 1 million document pages, this reduces GPU-hours from approximately 1,000 to approximately 250, directly translating to infrastructure cost savings. The Flash variant also enables processing higher-resolution documents (e.g., 1344 resolution for fine-print legal documents) that would be prohibitively slow without ViR compression, expanding the operational envelope without requiring larger GPU clusters.

On-device or edge deployment of reasoning-capable MLLMs. The InternVL3.5 family includes models as small as 1B and 2B parameters that achieve non-trivial reasoning performance (Table 3: InternVL3.5-1B scores 33.8 overall reasoning, rising to 43.3 with parallel thinking; InternVL3.5-2B scores 50.7). For applications requiring privacy-sensitive on-device processing—medical image analysis on a hospital's local server, educational apps running on tablets without internet connectivity, field-deployed robots with intermittent connectivity—these small models, combined with ViR compression and DvD for efficient multi-GPU utilization when available, provide a deployment option that does not require cloud API calls. The finding that InternVL3.5-1B outperforms Qwen3-0.6B (its base language model) on 15 of 16 text benchmarks (Table 14) with an overall gain of +6.7 points means the multimodal training improves the language capabilities of the underlying model—the MLLM is not just adding vision at the cost of text quality, but improving text performance through the training process. This makes small InternVL3.5 variants viable as general-purpose on-device assistants rather than vision-only specialists.

Generalist GUI agent deployment with strong spatial and textual grounding. InternVL3.5 achieves strong performance across GUI grounding (ScreenSpot, ScreenSpot-v2), GUI agent tasks (OSWorld, WindowsAgentArena), and embodied spatial reasoning (VSI-Bench, OmniSpatial) within a single model family (Tables 10, 11). This is significant because most GUI agents use specialized architectures or task-specific fine-tuning. InternVL3.5-8B—a 8.5B parameter model deployable on a single GPU—achieves 87.9 on ScreenSpot and 56.3 on VSI-Bench, while InternVL3.5-241B-A28B reaches 89.8 on ScreenSpot and 69.5 on VSI-Bench. A practitioner building a generalist desktop assistant that must both read screen content (OCR), understand spatial layout (GUI grounding), and execute multi-step tasks (agent benchmarks) can use a single InternVL3.5 checkpoint rather than orchestrating multiple specialized models. The efficiency innovations (ViR + DvD) are particularly relevant here: GUI screenshots often contain large uniform regions (window backgrounds, empty space) that ViR can aggressively compress, while text-heavy regions (menus, dialog boxes) retain full resolution, making the 50% average token reduction realistic for this domain. The DvD architecture also aligns with GUI agent deployment patterns where vision processing (screenshot encoding) is bursty and can be overlapped with language model decoding of action sequences.

Self-improvement data generation pipelines with principled compute allocation. The Cascade RL framework's data filtering step—selecting training queries where model accuracy is between 0.2 and 0.8—provides a criterion for allocating generation compute in self-improvement pipelines (e.g., STaR, ReST^EM, rejection sampling fine-tuning). Rather than generating solutions uniformly across a training dataset, a practitioner can: (1) estimate per-query difficulty using a small number of initial samples and a verifier, (2) allocate more generation budget to queries in the 0.2–0.8 accuracy band where additional samples are likely to produce both positive and negative examples, (3) skip queries below 0.2 (impossible, waste of compute) and above 0.8 (already solved, no learning signal). The paper's MMPR-Tiny construction (filtering 200K pairs to 70K queries with accuracy 0.2–0.8) demonstrates that this filtering removes ~65% of data, meaning a self-improvement pipeline using this criterion could allocate 3× more compute per remaining query at the same total budget, potentially improving the quality of generated training data. The key enabling finding is Table 16: Cascade RL achieves better performance than pure online RL with the filtered dataset, validating that filtering to the learning frontier does not harm final performance and may improve training efficiency. This principle applies to any MLLM self-improvement pipeline, not just InternVL3.5.