Recurrent-Depth VLA: Implicit Test-Time Compute Scaling of Vision-Language-Action Models via Latent Iterative Reasoning

ArXiv: 2602.07845

🎯 Pitch

A recurrent action head lets robot policies assign more compute to harder tasks—lifting success from 0% to over 90% on the trickiest maneuvers while keeping memory constant. It adaptively stops when its internal action distribution stabilizes, cutting 34% of the compute on easier steps without losing peak performance, and runs up to 80× faster than prior reasoning-based VLAs.

---

1. Executive Summary

This paper introduces Recurrent-Depth VLA (RD-VLA), an architecture that achieves adaptive test-time computation for visuomotor control by performing iterative refinement entirely within a continuous latent space rather than through explicit token generation. Evaluated on the LIBERO and CALVIN manipulation benchmarks using a Qwen2.5-0.5B backbone, RD-VLA employs a weight-tied recurrent transformer core — the Recurrent Core — that unrolls to arbitrary depth with constant memory, coupled with an adaptive stopping criterion based on KL divergence between consecutive action distributions. The architecture attains 93.0% success on LIBERO with fixed recurrence and 92.5% with adaptive computation averaging only 7.93 iterations — a 34% reduction in compute while preserving peak performance — and delivers up to 80× inference speedup over prior token-reasoning VLA models. The paper demonstrates that tasks requiring zero percent success with single-iteration inference exceed 90% success at four iterations, establishing that latent iterative refinement can scale performance with depth while enabling dynamic compute allocation, though performance saturates beyond approximately 12 iterations and extending recurrence further yields diminishing returns.

2. Context and Motivation

The Core Problem: Fixed Computational Depth in Visuomotor Policies

The fundamental problem this paper addresses is that current Vision-Language-Action (VLA) models expend identical computational resources on every control decision, regardless of task complexity. A simple gripper adjustment — a near-reflexive operation requiring minimal deliberation — receives precisely the same forward pass through the entire model as a complex multi-step manipulation in a cluttered environment requiring spatial reasoning, object identification, and long-horizon planning.

This is not merely inefficient; it represents a fundamental architectural mismatch with the nature of embodied control. The paper frames this through a biological analogy (Section I): human cognition exhibits adaptive resource allocation, where trivial maneuvers engage low-effort, near-reflexive pathways while complex scenarios recruit extended deliberative processing — "slowing down to process sensory evidence and refine internal models before acting." The recurrent dynamics of neural circuitry, where the same cortical regions are recruited iteratively to transform initial sensory signals into refined representations, provide a natural template for what the paper argues VLAs should emulate.

The consequence of fixed computational depth is twofold. First, it imposes a latency floor — even trivial actions must wait for the full model forward pass, creating unnecessary delays that accumulate over hundreds of control steps. Second, it imposes a capability ceiling — the model cannot allocate additional compute to difficult decisions that would benefit from deeper processing. The paper argues that these limitations are not fringe concerns but rather central obstacles to deploying generalist VLAs in real-world settings where the task difficulty distribution is inherently heterogeneous.

Why This Problem Matters: The Latency–Capability Tradeoff in Robotics

The significance of this problem is practical, architectural, and conceptual.

Practical significance: Real-time control demands variable latency budgets. Robotic manipulation operates at control frequencies typically ranging from 10–50 Hz. A VLA performing a forward pass through a large transformer backbone may require tens or hundreds of milliseconds per inference call. When every control step incurs this cost uniformly, the cumulative latency constrains how responsive the system can be, particularly for tasks requiring rapid closed-loop adjustments (e.g., maintaining a grip during object slippage, adjusting trajectory mid-motion). The paper's identification of tasks requiring zero percent success at single-iteration inference but exceeding 90% at four iterations (Figure 4, Table II) demonstrates that computational depth is not a luxury but a necessity for many manipulation tasks — yet the same depth would be wasteful overhead for simpler substeps. Without adaptive allocation, the designer must choose between (a) a fast but incapable system that fails on complex tasks, or (b) a capable but slow system that overcomputes on simple tasks, both of which are unacceptable for deployment.

Architectural significance: The token-based reasoning bottleneck. A fundamental limitation the paper identifies is that existing models perform reasoning in the output space — specifically, as discrete token sequences. When a model generates Chain-of-Thought (CoT) tokens ("I see a red cube to the left of the bowl, I need to grasp it from above..."), it must repeatedly cross the boundary between its high-dimensional continuous latent space and a low-bandwidth, discretized output space. The paper characterizes this as a "cyclical re-projection" that "forces the model to collapse continuous internal states into lossy, discretized representations only to re-encode them for subsequent reasoning steps." The resulting information bottleneck and quantization noise limit reasoning fidelity to the resolution of the output vocabulary rather than the continuous dynamics of the physical environment. This is particularly problematic for robotic control, where the relevant reasoning involves continuous spatial relationships, force dynamics, and motion trajectories that are poorly captured by discrete tokens. The paper further notes that these methods scale memory linearly with reasoning chain length (each generated token consumes context window capacity) and require curated reasoning datasets — expensive to produce for robotics domains where ground-truth "thinking traces" are ambiguous or unavailable.

Conceptual significance: Test-time compute scaling for embodied AI. The broader AI community has recognized test-time compute scaling as a critical axis for improving model performance — evidenced by work on best-of-N sampling, verifier-guided search, and chain-of-thought prompting in language models. However, the paper argues that robotics has largely been excluded from this trend because the dominant mechanisms (token-level reasoning, autoregressive generation) are poorly suited to the latency, memory, and continuous-action requirements of visuomotor control. By demonstrating that latent iterative refinement can achieve test-time compute scaling without these limitations, the paper opens a pathway for robotics to participate in the broader scaling paradigm — allowing future systems to trade compute for capability at inference time, dynamically and efficiently.

Where Existing Approaches Fall Short

The paper identifies limitations across three categories of prior work, each addressing part of the problem but failing to provide a complete solution.

End-to-End VLAs: Fixed Depth, No Reasoning

Models like RT-2 [57], OpenVLA [22], and $\pi_0$ [4] represent the dominant paradigm: a pretrained vision-language model fine-tuned to directly predict actions from observations. These models achieve impressive generalization by leveraging Internet-scale pretraining, but the paper identifies a critical structural limitation:

"most Vision-Language-Action (VLA) models are limited to a fixed computational depth, processing every control step with the same number of parameters regardless of difficulty; a simple gripper adjustment receives the same compute as high-precision navigation in a cluttered space."

This is not a training deficiency — it is an architectural constraint. The forward pass through a transformer backbone is inherently fixed-depth (each token passes through all layers exactly once), and the standard action head (typically a shallow MLP or a fixed number of diffusion/flow-matching steps) provides no mechanism for adaptive refinement. The paper notes that while some models use diffusion-based action generation [8] or flow-matching [4], these operate by iteratively denoising actions in the output space — they refine the action signal but "do not scale or enrich the underlying representation of the scene." The distinction is crucial: diffusion provides generative diversity, not deliberative depth.

The dynamic inference work DeeR-VLA [48] is acknowledged as a partial step forward — it treats model depth as a dynamic variable, allowing early-exiting during trivial movements. However, this approach modulates which layers of the backbone execute, not how many times processing occurs in a reasoning loop. The representation is still produced in a single pass; it is simply truncated for easy cases. This provides efficiency gains but does not enable the iterative refinement of representations that the paper argues is necessary for complex tasks.

Token-Level Reasoning VLAs: Explicit CoT with Inherent Overhead

A recent wave of models has attempted to incorporate explicit reasoning into the VLA pipeline by generating intermediate tokens before action prediction. ThinkAct [16] uses reinforced visual latent planning, MolmoAct [25] generates depth-aware perception tokens and editable trajectories, CoT-VLA [51] generates visual chain-of-thought about spatial constraints, and ECoT [49] produces textual justifications before action emission.

The paper identifies three fundamental limitations of this approach:

1. Memory scales linearly with reasoning length. Each reasoning token consumes context window capacity. For long-horizon tasks requiring extensive deliberation, this can become prohibitive — the model must reserve expensive context capacity that could otherwise be used for observation history or task instructions.

2. Latency from autoregressive decoding. Each reasoning token requires a full autoregressive decoding step (or multiple steps for beam search or speculative decoding). The paper claims up to 80× inference speedup over prior reasoning-based VLA models (stated in the abstract), though the specific comparison point (which baseline, what batch conditions) should be verified against the experiments.

3. Misalignment with continuous control. The paper makes a nuanced argument here that deserves careful attention. The claim is not simply that token generation is slow — it is that the process of verbalizing continuous physical dynamics into discrete tokens is fundamentally lossy. Physical reasoning about forces, spatial relationships, trajectories, and contact dynamics exists naturally in a high-dimensional continuous space. Forcing the model to translate this into language tokens ("the gripper should move 3.2 cm to the left at approximately 45 degrees") introduces quantization error and constrains reasoning to the resolution of the model's vocabulary and tokenization scheme. The paper argues that this "information bottleneck" is inherent to any token-based reasoning approach, not merely an implementation inefficiency.

4. Dependence on curated reasoning data. Training these models requires supervision for the intermediate reasoning steps — either human-annotated CoT traces or model-generated pseudo-labels. For robotics, such data is extremely scarce and expensive to produce, particularly because the "correct" reasoning for a manipulation task is often non-obvious or multimodal (multiple plausible reasoning chains can lead to the same action).

The paper positions these limitations as intrinsic to the output-space reasoning paradigm rather than contingent on specific implementations. Even with optimized decoding and compressed representations, the cyclical re-projection between continuous latent states and discrete tokens creates a fundamental throughput and fidelity ceiling.

Efficiency-Focused Methods: Optimizing the Wrong Bottleneck

A third category of prior work focuses on making existing architectures more efficient — TinyVLA [44] through data-efficient distillation, VLA-Cache [46] through adaptive token caching, and the aforementioned DeeR-VLA [48] through dynamic depth. The paper acknowledges these contributions but argues they optimize the wrong bottleneck: they reduce the cost per forward pass but do not address the fundamental question of how many forward passes are needed. More critically, they do not provide a mechanism for scaling compute up when needed — they can only scale it down.

The paper's position is that efficiency and capability are not opposing objectives to be traded off but rather two dimensions of the same underlying need: adaptive computation. An ideal system should be both fast when possible and capable when necessary. Efficiency-only methods achieve the first but sacrifice the second; reasoning-only methods achieve the second but compromise the first. Neither provides both.

How This Paper Positions Itself

The Central Architectural Claim: Latent Reasoning as a Third Paradigm

The paper positions RD-VLA as inaugurating a third paradigm distinct from both end-to-end prediction and token-level reasoning: latent iterative reasoning. The key differentiators are:

• Reasoning occurs entirely within a continuous latent manifold, not in the discrete output space. This eliminates the information bottleneck of tokenization and the latency of autoregressive decoding.
• Computational depth is decoupled from architectural depth through weight tying. A single recurrent transformer block is unrolled to arbitrary depth at inference, enabling test-time compute scaling without additional parameters.
• Memory footprint is constant regardless of reasoning depth, since the recurrent state is a fixed-size latent scratchpad rather than a growing sequence of tokens.
• Adaptive stopping emerges from latent convergence, not from explicit supervision of iteration counts. The model naturally converges faster on simple states and slower on complex ones, without being trained on reasoning traces.

The paper draws explicit inspiration from recent work on recurrent transformers for language — particularly Huggin (Geiping et al., 2025) [14] — which demonstrated that weight-tied transformer blocks can perform iterative latent reasoning with adaptive depth in the language domain. RD-VLA extends this principle to visuomotor control, which the paper claims is the first such application:

"To our knowledge, RD-VLA is the first VLA model to support scaling test-time computation through implicit latent-space reasoning via a weight-tied recurrent core."

Positioning Relative to Diffusion Policies

The paper takes care to distinguish latent iterative reasoning from diffusion-based action generation [8], which also involves a multi-step process. This distinction is important because it could easily be confused: both involve iterative computation at inference time. The paper's argument is that diffusion is generative, not deliberative:

"Diffusion Policies operate by iteratively denoising an action trajectory in the output space. While effective for modeling multi-modal distributions, this process is fundamentally a generative sampling technique rather than a deliberative one: it refines the action signal but does not scale or enrich the underlying representation of the scene."

In RD-VLA, each recurrent step enriches the internal representation of the scene, task, and plan. The latent scratchpad evolves from a noisy initialization toward a converged state that captures progressively more refined understanding. The final action decoding is a single projection from this converged representation, not an iterative denoising process. This means the computation happens in representation space, while the output is produced once — the opposite of diffusion, where representation is fixed and output is iteratively refined.

Positioning Relative to Dynamic Inference Methods

The paper distinguishes RD-VLA from methods like DeeR-VLA [48] along a specific axis: depth scaling vs. depth selection. DeeR-VLA selects which subset of layers to execute from a fixed-depth backbone — it is a conditional computation mechanism that activates model segments based on task difficulty. RD-VLA, by contrast, reuses the same layers multiple times — it is an iterative refinement mechanism where each pass through the recurrent core produces a more refined version of the latent state.

This distinction has practical implications. Depth selection is limited by the total number of layers in the backbone; once all layers are activated, no further compute can be applied. Depth scaling through recurrence has no such hard ceiling — the model can in principle be unrolled arbitrarily deep (though the paper acknowledges performance saturation beyond approximately 12–24 iterations, which it identifies as an open challenge).

The Theoretical Framing: Latent Convergence as Uncertainty Quantification

A subtler but important aspect of the paper's positioning is its framing of latent convergence as a proxy for model confidence. Because the recurrent architecture exposes internal state dynamics — the scratchpad $S_0, S_1, \ldots, S_r$ evolves observably — it becomes possible to measure when the model has "settled" on a representation. The paper operationalizes this via KL divergence between consecutive action predictions:

$\|\mathbf{a}_k - \mathbf{a}_{k-1}\|^2_2 < \delta$

This is not merely a heuristic; the paper argues it is an emergent property of the recurrent architecture:

"the system could autonomously halt execution or request operator assistance if the variance between recurrent states exceeds a safety threshold."

This positions RD-VLA not just as an efficiency mechanism but as an uncertainty-aware policy — one that can self-assess when its internal reasoning has stabilized versus when it remains uncertain. This capability is orthogonal to both end-to-end and token-reasoning approaches, which provide no intrinsic measure of deliberation quality.

Summary of the Gap and the Contribution

The gap: VLA models lack a mechanism for adaptive test-time compute that scales capability with depth, maintains constant memory, avoids the token bottleneck, and requires no explicit reasoning supervision.

The contribution: RD-VLA fills this gap by introducing a weight-tied recurrent transformer core operating on a continuous latent scratchpad, where iterative refinement naturally adapts to task complexity and convergence provides a signal for dynamic stopping.

The paper does not claim to have fully solved all sub-problems — it acknowledges that scaling beyond ~24 iterations yields diminishing returns (Section V), that the design space for adaptive interventions is "vast" and largely unexplored, and that the current implementation uses a relatively small 0.5B parameter backbone. Rather, it positions RD-VLA as opening a new design space:

"We aimed to open a new design space for efficient, reasoning-capable robotic policies. We believe that optimizing the regimes for adaptive compute and exploring the scaling laws of latent recurrence represent promising avenues for future research."

3. Technical Approach

This section presents the architecture and training methodology of Recurrent-Depth VLA (RD-VLA), an approach that achieves adaptive test-time computation for visuomotor control through latent iterative reasoning. The core idea is to replace explicit token generation (Chain-of-Thought) with a weight-tied recurrent transformer operating on a continuous latent scratchpad, enabling variable computational depth while maintaining constant memory.

3.1 Reader Orientation

RD-VLA is a vision-language-action model that, instead of generating reasoning tokens before acting, refines its internal understanding of a scene through repeated passes through a shared transformer block ("thinking" in latent space rather than in words). The problem it solves is that existing VLA models either use fixed computation regardless of task difficulty (wasting time on simple actions or under-thinking on complex ones) or use explicit token-based reasoning that scales memory linearly and introduces information bottlenecks from discretizing continuous physical understanding.

3.2 Big-Picture Architecture

The system has five major components, organized as a processing pipeline that transforms visual observations and task instructions into robot actions with adaptive computational depth:

1. Frozen Vision Encoder (DINOv2 + SigLIP): Processes camera images (wrist + main camera) into 256 vision tokens each (512 total), providing dense visual features that are projected into the language model backbone.
2. Fine-tuned VLM Backbone (Qwen2.5-0.5B with LoRA): Takes vision tokens, 64 learned latent queries, and task instructions as input, producing intermediate and final hidden state representations. We extract visual/latent features from layer 12 (mid-layer, for the Prelude) and layer 24 (final layer, for the Recurrent Core).
3. Prelude (non-recurrent interface): Transforms a small set of learned queries into a grounded "foundation" representation ($S_{pre}$) by cross-attending to mid-layer VLM features, serving as a stable anchor for the iterative process.
4. Recurrent Core (weight-tied transformer block): Takes a randomly initialized latent scratchpad ($S_0$) and the Prelude foundation ($S_{pre}$), and iteratively refines the scratchpad state through $K$ unrolled steps. At each step, it cross-attends to the final-layer VLM features and proprioceptive state. The same weights are reused at every iteration, enabling arbitrary depth with constant parameter count.
5. Coda (non-recurrent decoder): Takes the converged scratchpad ($S_r$) after iteration $r$ and projects it to the robot's action space (a chunk of future actions), decoding the refined latent representation into executable motor commands.

Information flows sequentially: Camera → Vision Encoder → VLM → Prelude (once) → Recurrent Core (K times) → Coda (once) → Actions. The depth $K$ is determined either as a fixed hyperparameter or dynamically at inference through an adaptive stopping criterion based on action convergence.

3.3 Roadmap for the Deep Dive

• First, the formal definition of the recurrent architecture triplet (Prelude, Recurrent Core, Coda) and how they partition the computation between interface and iterative refinement, since this establishes the modular framework for everything else.
• Second, the Prelude and scratchpad initialization, because understanding how the stable foundation ($S_{pre}$) and noisy starting state ($S_0$) are created is essential to understanding what the Recurrent Core operates on.
• Third, the latent iterative reasoning mechanism, including the Input Injection strategy and the cross-attention conditioning, since this is the core algorithmic contribution that enables stable refinement.
• Fourth, the Coda and action projection, to complete the architectural flow from latent state to motor commands.
• Fifth, the training procedure, including the randomized recurrence sampling distribution and truncated backpropagation through time (TBPTT), since this explains how the model learns to refine from any starting depth.
• Sixth, the adaptive computation mechanism at inference (KL-divergence stopping criterion), since this is how the trained architecture achieves dynamic compute allocation without retraining.
• Seventh, the adaptive execution strategies (Threshold-Based and Linear Decay), since these couple the reasoning depth to action horizon and represent a secondary contribution for safe deployment.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an architectural contribution paper whose core idea is that test-time compute scaling for visuomotor control can be achieved through weight-tied recurrence in latent space, decoupling computational depth from architectural depth and eliminating the need for explicit token-based reasoning.

---

Modular Triplet Decomposition: Prelude, Recurrent Core, Coda

The action head of RD-VLA is organized into three functionally distinct modules, following the architectural pattern introduced by the Huggin recurrent language model (Geiping et al., 2025). The motivation for this decomposition is to separate three logically distinct operations: (1) grounding the model's knowledge in the current observation (Prelude), (2) iteratively refining understanding through computation (Recurrent Core), and (3) decoding the refined understanding into actions (Coda). Only the Recurrent Core is weight-tied and unrolled; the Prelude and Coda execute exactly once per control step, serving as interface layers that translate between the VLM's representation space and the dedicated latent manifold optimized for iterative reasoning.

The Prelude ($P_\phi$) is responsible for creating a stable, grounded foundation representation that persists throughout the entire unrolling process. It consumes learned query vectors and mid-layer VLM features, producing $S_{pre}$ through cross-attention. Because the Prelude executes only once, it provides a fixed anchor — the Recurrent Core can refine its understanding without losing connection to the original observation, since $S_{pre}$ is injected at every iteration.

The Recurrent Core ($R_\theta$) is the weight-tied transformer block that performs the actual iterative reasoning. It maintains and updates a latent scratchpad $S_k$ across iterations $k = 1, \dots, r$, where $r$ is the total unrolling depth (fixed or adaptive). At each step, it receives the previous scratchpad state $S_{k-1}$ concatenated with $S_{pre}$, performs self-attention across scratchpad tokens, and performs gated cross-attention to final-layer VLM features and proprioception. The same parameters $\theta$ are reused at every iteration, meaning the computational depth $r$ can be varied at inference without changing the model.

The Coda ($C_\psi$) is the final non-recurrent decoder that projects the converged scratchpad $S_r$ into action space. It performs self-attention and cross-attention to final-layer VLM features, then passes through a linear projection layer to produce the control command vector $\mathbf{a}$. The Coda executes once after the Recurrent Core terminates (either at fixed depth or at convergence under adaptive stopping).

---

Prelude and Latent Scratchpad Initialization

The Prelude serves as the entry point into the recurrent manifold, transforming a small set of learned embeddings into a representation that grounds the iterative reasoning process in the current observation. It operates as follows:

1. Input queries: The Prelude takes $K = 8$ learned query vectors as input. These are not task-specific — they are parameters learned during training that the model uses to extract relevant information from the VLM's visual features. The choice of $K = 8$ provides a compact but expressive scratchpad size; larger $K$ would increase the dimensionality of the latent manifold and the computational cost per iteration.

2. Self-attention: The $K$ queries first attend to each other bidirectionally (full self-attention, not causal). This allows the queries to coordinate what information each will extract — they can specialize to different aspects of the scene (e.g., one query focuses on object identity, another on spatial relationships, another on task progress).

3. Cross-attention to mid-layer features: The self-attended queries then perform cross-attention over the VLM's middle-layer visual features $h_{vis+lat}^{(12)}$, which is the concatenation of the 512 vision tokens and 64 latent tokens at layer 12 of the Qwen2.5-0.5B backbone. The use of middle-layer features (rather than final-layer) is a deliberate design choice: mid-layer representations contain more spatially localized, less semantically abstracted information that is better suited for grounding the initial reasoning state. The result is the grounded foundation:

$S_{pre} = P_\phi(\text{Queries}, h_{vis+lat}^{(12)}) \in \mathbb{R}^{K \times D}$

where $K=8$ is the number of scratchpad tokens, $D$ is the hidden dimension of the VLM backbone (896 for Qwen2.5-0.5B), and $h_{vis+lat}^{(12)}$ are the concatenated vision and latent token representations from VLM layer 12.

What it computes: a fixed-size ($8 \times D$) matrix representing a grounded summary of the visual scene and task context, anchored in spatially-rich mid-layer VLM features. This matrix is computed once per control step and held constant throughout the entire unrolling of the Recurrent Core.

Why this form: the Prelude provides a stable foundation. Without it, the Recurrent Core would need to re-derive scene grounding from scratch at each iteration (by cross-attending directly to the full set of VLM features), or would risk representational drift where later iterations lose connection to the original observation. By pre-computing a compact, query-conditioned summary, the Prelude gives the Recurrent Core a fixed reference point that persists across all iterations, enabling the iterative process to focus on refinement rather than re-grounding. The use of 8 queries (rather than 1 or 64) balances expressiveness (more queries can capture more diverse scene aspects) with efficiency (the cross-attention cost in the Recurrent Core scales with $K$). Using mid-layer (layer 12) rather than final-layer (layer 24) features provides the Prelude with features that retain spatial structure before the deepest layers of the LLM abstract them into more semantic, less spatially-grounded representations.

Parallel to the Prelude, the latent scratchpad $S_0$ is initialized from a high-entropy truncated normal distribution:

$S_0 \sim \text{TruncNormal}(0, \gamma_{init} \cdot \sigma_{init})$

where $\gamma_{init}$ and $\sigma_{init}$ control the scale of the initial noise. The paper does not specify exact values for these parameters, but the conceptual purpose is clear: initializing from noise rather than from a learned starting point forces the model to learn a refinement operator — it must learn to transform arbitrary (noisy) states toward a converged representation, rather than memorizing a specific initialization-to-convergence trajectory.

What this does: it creates a "blank workspace" of random values in the same shape as $S_{pre}$ ($K \times D$). At iteration 0, the scratchpad contains no task-relevant information; all structure must be built through the iterative refinement process.

Why this form: if $S_0$ were initialized to zeros or to a learned embedding, the model could learn to bypass the refinement process by encoding task-specific information in the initialization, defeating the purpose of iterative reasoning. The noisy initialization forces the Recurrent Core to earn its representation through computation: $S_1$ must capture some structure, $S_2$ more, and so on. This is analogous to diffusion models where the forward process adds noise and the reverse process learns to denoise — except here the "denoising" happens in latent representation space rather than output space, and the "noise" is injected at the start of reasoning rather than at each denoising step. The truncated normal distribution (rather than uniform or standard normal) prevents extreme outlier values that could destabilize early training.

---

Latent Iterative Reasoning via Input Injection

This is the central algorithmic mechanism of RD-VLA. The Recurrent Core $R_\theta$ performs $r$ iterations of refinement on the latent scratchpad, with each iteration producing a strictly more refined state $S_k$ from $S_{k-1}$. The key technical challenge addressed here is representational collapse — the tendency for recurrent networks to lose information about the original input over long unrolls, effectively "forgetting" what they were reasoning about.

Input Injection strategy. At every iteration $k$, the Recurrent Core does not operate solely on the previous scratchpad state $S_{k-1}$. Instead, it concatenates $S_{k-1}$ with the stable foundation $S_{pre}$ produced by the Prelude, ensuring that every iteration has fresh access to the original grounded observation:

$x_k = \text{RMSNorm}\left(\gamma_{adapt} \cdot W_{adapt}[S_{k-1}; S_{pre}]\right)$

where $W_{adapt} \in \mathbb{R}^{D \times 2D}$ is a learned linear projection that maps the $2D$-dimensional concatenation back to the $D$-dimensional manifold, $\gamma_{adapt}$ is a learned scaling parameter, and RMSNorm provides activation normalization. $[S_{k-1}; S_{pre}]$ denotes concatenation along the feature dimension: each of the $K$ scratchpad tokens at iteration $k-1$ is concatenated with its corresponding token from the Prelude foundation, producing a $K \times 2D$ matrix that is then projected down to $K \times D$.

What this computes: a normalized, dimensionality-reduced representation that blends the current evolving state ($S_{k-1}$, reflecting accumulated refinement) with the original grounded observation ($S_{pre}$, reflecting scene structure). The linear projection $W_{adapt}$ learns how to combine these two information sources — what to carry forward from previous refinement and what to re-inject from the original observation.

Why this form: without Input Injection (i.e., if the Recurrent Core operated only on $S_{k-1}$ through a standard transformer block), the scratchpad could drift arbitrarily far from the original observation over many iterations. This is the representational collapse problem: a recurrent network applied repeatedly to its own output can amplify small errors and converge to degenerate attractor states. Input Injection prevents this by providing a constant grounding signal at every step. The use of concatenation + learned projection (rather than addition or gating) gives the model flexibility to learn how much of $S_{pre}$ to incorporate versus how much of $S_{k-1}$ to preserve. RMSNorm (rather than LayerNorm) is chosen for computational efficiency — it normalizes by the root-mean-square of activations without subtracting the mean, which is faster and empirically effective in recent transformer architectures.

Recurrent Core update. After Input Injection produces $x_k$, the Recurrent Core updates the scratchpad through a standard transformer block with two attention operations:

$S_k = R_\theta(x_k, [h_{vis+lat}^{(24)}; p])$

1. Bidirectional self-attention: All $K$ scratchpad tokens attend to each other without causal masking. This allows the model to coordinate information across the entire scratchpad — one token might update its representation based on what another token has discovered about object identity, while a third token integrates spatial relationships. The self-attention is applied to the $x_k$ representation (the blended state after Input Injection).

2. Gated cross-attention: The self-attended scratchpad tokens then attend to a conditioning manifold consisting of:

   • $h_{vis}^{(24)}$: the 512 vision tokens from the VLM's final layer (layer 24)
   • $h_{lat}^{(24)}$: the 64 latent-specific tokens from the VLM's final layer
   • $p$: the robot's current proprioceptive state (joint positions, gripper state)

   The cross-attention uses a gating mechanism (the paper mentions "gated cross-attention" without providing the exact gating equation, but typical implementations use a learned scalar gate that controls how much of the cross-attention output is added to the residual stream). The queries come from the self-attended scratchpad tokens, while the keys and values come from the concatenated conditioning manifold.

What this computes: a single refinement step — the scratchpad evolves from $S_{k-1}$ to $S_k$ by (a) coordinating information across scratchpad tokens via self-attention, and (b) pulling in fresh information from the VLM's final-layer representations and the robot's current state via cross-attention.

Why this form: the use of final-layer VLM features for the Recurrent Core (layer 24) contrasts with the Prelude's use of mid-layer features (layer 12). This is intentional: the Recurrent Core needs semantically rich, abstracted features suitable for high-level reasoning about task progress and action planning, while the Prelude needs spatially-grounded features for initial scene anchoring. The gated cross-attention (rather than standard cross-attention) provides a mechanism for the model to selectively incorporate external information — if the scratchpad already has a clear plan, the gate can be small, preserving the internal state; if the scratchpad is uncertain, the gate can be large, pulling in more observation information. The inclusion of proprioception $p$ in the conditioning ensures that the reasoning process is aware of the robot's current physical state — the model can't plan actions without knowing where the gripper is or whether it's holding an object.

The cross-attention's key-value source deserves careful attention: it includes both the VLM's final-layer representations and the proprioceptive state, concatenated into a single conditioning tensor. This means the Recurrent Core can attend jointly to vision and proprioception — for instance, it might attend to a visual token representing the target object while simultaneously attending to the proprioceptive token representing the current gripper position, computing a relative spatial offset implicitly through the attention mechanism. This joint conditioning is more powerful than processing vision and proprioception separately because it allows the attention weights to capture cross-modal relationships (e.g., "the gripper is near the visual region corresponding to the handle").

---

Coda and Action Projection

After the Recurrent Core completes $r$ iterations (either fixed or determined by the adaptive stopping criterion), the converged scratchpad $S_r$ is decoded into executable robot actions by the Coda:

$\mathbf{a} = W_{out} \cdot \text{RMSNorm}\left(C_\psi(S_r, [h_{vis}^{(24)}; h_{lat}^{(24)}; p])\right)$

where $C_\psi$ is the Coda transformer (non-recurrent, single execution), $W_{out}$ is a learned linear projection matrix, and $\mathbf{a} \in \mathbb{R}^{H \times d_{action}}$ is the predicted action chunk — $H$ future actions each with $d_{action}$ dimensions (typically 7-dimensional for end-effector pose + gripper, so $d_{action} = 7$, and $H$ varies based on the adaptive execution strategy).

The Coda performs:

1. Self-attention across the $K$ scratchpad tokens to coordinate final action-relevant information.
2. Cross-attention to the VLM's final-layer visual and latent features plus proprioception (similar to the Recurrent Core's conditioning, but operated as a single pass rather than iteratively).
3. RMSNorm for activation normalization.
4. Linear projection $W_{out}$ to map from the $D$-dimensional hidden space to the $H \times d_{action}$-dimensional action space.

What this computes: a one-shot decoding from the refined latent representation to a chunk of future actions. The Coda does not iterate — it takes the final scratchpad state and produces actions directly.

Why this form: separating decoding (Coda) from refinement (Recurrent Core) is a design choice with several motivations. First, it allows the Recurrent Core to focus purely on refinement without learning how to produce actions — the action-specific projection is concentrated in the Coda. Second, it means that during adaptive stopping, the Coda can be called at intermediate iterations to produce actions for the convergence check ($\mathbf{a}_k$ vs. $\mathbf{a}_{k-1}$) without interfering with the scratchpad evolution. Third, it provides a clean interface: if one wanted to use a different action representation (e.g., flow-matching instead of direct regression), only the Coda and $W_{out}$ would need to change — the Prelude and Recurrent Core could remain unchanged.

The action chunking approach (predicting $H$ future actions rather than a single action) is standard in imitation learning for robotics, as it promotes temporal consistency and reduces the effective control frequency required from the policy. The paper introduces adaptive strategies for varying $H$ based on reasoning depth (Section 3.4.7), which we will cover shortly.

---

Training with Randomized Recurrence and Truncated Backpropagation Through Time (TBPTT)

Training a recurrent architecture that supports variable inference depth requires careful design of the training distribution over iteration counts. If the model is always trained with exactly $r = 16$ iterations, it will learn to rely on having exactly 16 refinement steps and may fail if stopped earlier. Conversely, if it is trained with too few iterations, it never learns to exploit deeper computation. The solution is randomized recurrence: sampling the number of iterations $N$ during training from a distribution that covers a wide range.

The paper uses a heavy-tailed log-normal Poisson distribution:

$\tau \sim \mathcal{N}(\ln(\mu_{rec}) - 0.125, \sigma^2), \quad N \sim \text{Poisson}(e^\tau) + 1$

where $\mu_{rec} = 32$ (the mean of the recurrence distribution), $\sigma$ is a variance parameter (not explicitly specified in the paper, but implied to be set such that the distribution has substantial mass from ~4 to ~64+), and the $-0.125$ offset corrects for the log-normal mean.

What this computes: a random integer $N$ representing how many iterations of the Recurrent Core to unroll for this training sample. The log-normal + Poisson combination produces a heavy-tailed distribution: most samples will have $N$ in the range of roughly 16–64, but the distribution has non-trivial probability mass at both lower values (8, 12) and higher values (128+). The "+ 1" ensures at least one iteration is always performed.

Why this form: the log-normal distribution is right-skewed, meaning it has a heavier right tail than a normal distribution — this ensures the model sees some very long unrolls during training, which is important for learning to converge to a stable state rather than oscillating or diverging. The Poisson sampling converts the continuous $e^\tau$ (which is strictly positive) into a discrete count, with the Poisson's variance equal to its mean providing natural variability. The offset $-0.125$ in the normal mean is a correction factor: because $\ln(\mu_{rec})$ gives the median of the log-normal distribution, subtracting a small constant adjusts the mean of $e^\tau$ closer to $\mu_{rec}$. This distribution is "heavy-tailed" specifically to expose the model to a wide range of depths, teaching it that refinement should converge to a steady state that does not depend on the specific depth chosen — a property crucial for adaptive stopping at inference.

Truncated Backpropagation Through Time (TBPTT). Training a recurrent network through many iterations ($N$ up to 100+) with full backpropagation would be prohibitively expensive in memory and compute, since activations from all $N$ iterations must be stored for the backward pass. TBPTT addresses this by truncating the gradient computation:

"gradients are propagated through only the final $d = 8$ iterations, while earlier steps are computed with gradients detached"

In practice, this means:

1. The forward pass runs for all $N$ iterations, producing scratchpad states $S_1, S_2, \dots, S_N$.
2. The loss is computed only on the final output $\mathbf{a}$ (produced by the Coda from $S_N$).
3. Gradients flow backward from the loss through the Coda and through the Recurrent Core for only the last $d = 8$ iterations ($S_{N-7}$ through $S_N$).
4. For iterations $1$ through $N-8$, the Recurrent Core activations are treated as constants (no gradient computation), meaning the computational graph is truncated.

What this does: it forces the model to learn a refinement operator that can improve the scratchpad from any intermediate state. Because gradients only flow through the last 8 iterations, the model cannot rely on carefully orchestrated dynamics over the full $N$-step trajectory. Instead, it must learn that each application of $R_\theta$ produces a locally better state $S_k$ from $S_{k-1}$, independent of how many preceding iterations occurred.

Why this form: full backpropagation through $N$ iterations would be:

• Memory-prohibitive (activations from all $N$ iterations stored simultaneously)
• Computationally slow (gradients must be computed sequentially backward through all iterations)
• Counterproductive for learning — with full gradients, the model might learn iteration-specific behaviors (e.g., "at iteration 5, switch from visual reasoning to action planning"), which would not generalize to different inference depths

TBPTT with $d = 8$ provides a practical compromise. It is deep enough that the model can learn meaningful multi-step refinement (8 iterations of a transformer block is a substantial computation), but shallow enough to be memory-efficient. More importantly, it encodes the inductive bias that the refinement operator should be Markovian — $S_k$ should depend on $S_{k-1}$ and the conditioning context, not on the absolute iteration index. This is essential for adaptive stopping to work: if the model learned iteration-specific dynamics, stopping at an unexpected depth would produce unpredictable results.

The combination of randomized $N$ and TBPTT ensures that at inference time, the model can be unrolled to any depth — including depths it never saw during training ($N > 64$ or $N < 4$) — and will still behave coherently, because it has learned a general refinement operator that works from any state and for any number of steps.

---

Adaptive Computation at Inference

At inference, RD-VLA can operate in two modes: fixed recurrence, where the Recurrent Core is unrolled for a predetermined number of iterations $r$, or adaptive recurrence, where the depth is determined dynamically based on an internal convergence criterion.

The adaptive stopping criterion is based on the Kullback-Leibler (KL) divergence between the action distributions predicted at consecutive iterations. Since the actions are continuous vectors (not categorical distributions), the KL divergence is approximated by the mean squared error (MSE) between consecutive action predictions:

$\|\mathbf{a}_k - \mathbf{a}_{k-1}\|^2_2 < \delta$

where $\mathbf{a}_k$ is the action chunk produced by the Coda when given scratchpad state $S_k$, $\mathbf{a}_{k-1}$ is the action chunk from scratchpad state $S_{k-1}$, $\|\cdot\|_2$ is the Euclidean norm, and $\delta$ is a convergence threshold (the paper sweeps values from $1\times 10^{-4}$ to $1\times 10^{-2}$).

What this computes: a scalar measure of how much the model's action prediction has changed between consecutive iterations. If the predicted actions have stabilized (the change is below threshold $\delta$), the model is considered converged and the loop terminates. The final action $\mathbf{a}_{k^*}$ (where $k^*$ is the first iteration satisfying the criterion) is executed.

Why this form: the KL divergence is the natural measure of distributional change for probability distributions, but since RD-VLA predicts deterministic actions (not distribution parameters), the paper approximates it with MSE. This is equivalent to assuming that the action distribution at each iteration is an isotropic Gaussian with fixed variance — under this assumption, the KL divergence reduces to a scaled Euclidean distance between means. The MSE threshold $\delta$ effectively controls the precision of convergence: smaller $\delta$ requires actions to be nearly identical between consecutive iterations (more compute), larger $\delta$ allows earlier stopping (less compute).

The choice of action-space convergence (rather than latent-space convergence, e.g., monitoring $\|S_k - S_{k-1}\|$) is deliberate. Latent space convergence would measure whether the representation has stabilized, but a stable representation might still produce unstable actions (if the Coda is sensitive to small latent changes) or unstable actions might arise from a converged representation (if the model is uncertain but has reached a plateau). Action-space convergence directly measures what we care about — whether the robot's commands are settling.

The paper reports (Table II) that with $\delta = 5 \times 10^{-4}$, the adaptive stopping achieves a success rate of 92.5% on LIBERO using an average of only $\bar{k} = 7.93$ iterations, compared to 93.0% at fixed $r = 12$. This represents a 34% reduction in compute while preserving performance within 0.5 percentage points. Notably, all three adaptive strategies tested (Binary Adaptation, Linear Decay, and Pure KL thresholding) perform comparably, suggesting that the principle of convergence-based stopping is robust to the specific policy for translating convergence into execution behavior.

For very large $\delta$ (e.g., $\delta = 1\times 10^{-2}$), the model stops too early ($\bar{k} = 3.36$ iterations), and performance drops to 72.1%. For very small $\delta$ (e.g., $\delta = 1\times 10^{-4}$), the model uses more iterations on average ($\bar{k} = 11.04$) with performance comparable to the optimal fixed-depth models. The sweet spot is $\delta = 5\times 10^{-4}$, providing the best accuracy-per-compute trade-off.

---

Adaptive Execution Strategies

Beyond adaptive computation (determining how long to think), RD-VLA introduces adaptive execution (determining how many actions to execute). The insight is that states requiring deep recurrence (high $k^*$) are likely high-uncertainty states where executing a long action chunk is risky — small errors in the plan compound over time. The paper proposes two strategies for coupling reasoning depth to execution horizon.

Threshold-Based Adaptive Execution. This is a binary decision rule:

$H_{exec} = \begin{cases} H_{long} & \text{if } k^* \leq \tau \\ H_{short} & \text{if } k^* > \tau \end{cases}$

where $k^*$ is the iteration at which convergence was reached, $\tau$ is a threshold on iteration count, $H_{long}$ is the default action horizon (how many future actions to execute), and $H_{short}$ is a reduced horizon for uncertain states. The paper does not specify exact values for $H_{long}$, $H_{short}$, or $\tau$ in the main text, but the values are implicitly defined by the experimental sweeps.

What this computes: a simple rule: if the model converges quickly ($k^* \leq \tau$), it is confident, so execute a longer sequence of actions before replanning. If it converges slowly ($k^* > \tau$), it is uncertain, so execute fewer actions and replan sooner.

Why this form: the binary threshold is the simplest possible adaptive execution strategy — it requires choosing a single threshold $\tau$ and two horizon values. Its simplicity makes it easy to tune and interpret. The assumption is that iteration count is a monotonic proxy for uncertainty: more iterations means the model needed more computation to settle, implying the state is inherently more ambiguous or complex.

Linear Decay Execution. This provides a continuous scaling mechanism:

$H_{exec}(k^*) = \max\left(H_{min}, H_{max} - \max(0, k^* - \tau_{base})\right)$

where $\tau_{base}$ is a base iteration budget (iterations within this budget are considered "normal" and get full horizon $H_{max}$), and for every iteration beyond $\tau_{base}$, the execution horizon decreases by one step, down to a minimum $H_{min}$.

What this computes: a linear schedule where the number of executed actions decreases proportionally to the excess reasoning depth. If $k^* = \tau_{base} + 3$, the horizon is $H_{max} - 3$ (clamped to $H_{min}$).

Why this form: linear decay provides finer-grained adaptation than the binary threshold. Instead of a sharp boundary between "confident" and "uncertain," every additional iteration reduces the execution horizon slightly, creating a smoother trade-off between computational cost (reasoning depth) and risk (executing actions in uncertain states). The $\max(0, k^* - \tau_{base})$ term ensures that iteration counts within the "normal" range ($\leq \tau_{base}$) do not penalize the horizon — only excess iterations trigger reduction. The $\max(H_{min}, \dots)$ clamping ensures that even in extremely uncertain states ($k^*$ very large), the model still executes at least some actions rather than stalling indefinitely.

The paper reports (Table II) that Binary Adaptation and Linear Decay produce similar performance at matched compute budgets, with Binary Adaptation achieving slightly higher average success rates. This supports the claim that the specific adaptive strategy is less important than the underlying principle — coupling reasoning depth to execution horizon is beneficial regardless of the exact functional form.

---

Design Justifications and Alternatives Considered

Why weight-tying rather than separate parameters per iteration? If each iteration of the Recurrent Core used unique parameters, the model would have $r \times \text{params}(R_\theta)$ parameters rather than just $\text{params}(R_\theta)$. This would prohibit deep unrolling (e.g., $r = 32$ would require 32× the parameters), eliminate the ability to vary depth at inference (since each depth would require different parameters), and prevent the learning of a general refinement operator (each iteration would learn iteration-specific transformations). Weight-tying is the essential mechanism that enables arbitrary inference depth with constant parameter count.

Why latent reasoning rather than token reasoning? The paper argues that token-based CoT introduces three fundamental inefficiencies: (1) the information bottleneck of discretizing continuous physical understanding into tokens, (2) linear memory scaling with reasoning length, and (3) the latency of autoregressive decoding. Latent reasoning avoids all three: it operates in the continuous, high-dimensional space of the VLM's representations (no discretization bottleneck), it maintains a fixed-size scratchpad regardless of depth (constant memory), and its per-iteration cost is a single transformer block forward pass with $K = 8$ tokens (much cheaper than generating 8 autoregressive tokens, which would require 8 sequential transformer calls on growing context).

Why initialize $S_0$ from noise rather than from zeros or learned embedding? Zero initialization would make the refinement trivial — the model could simply learn to set $S_1$ to the correct representation and subsequent iterations would be identity mappings. Learned embedding initialization would allow the model to encode task-specific priors in the starting state, reducing the need for genuine iterative refinement. Noisy initialization forces the model to learn a transformation from arbitrary starting points toward a converged state, which is what enables the refinement to be depth-agnostic and convergence to be detectable.

Why TBPTT with $d = 8$ rather than full backpropagation? Full backpropagation through $N$ iterations ($N$ up to 128+) would be computationally prohibitive and would encourage iteration-specific dynamics. Truncation at $d = 8$ enforces a local refinement inductive bias — the model learns that each application of $R_\theta$ should improve the scratchpad relative to the immediately preceding state, not relative to some distant earlier state. This Markovian property is what makes adaptive stopping valid: the convergence criterion checks whether two consecutive states produce similar actions, which only works if the refinement is locally convergent.

4. Key Insights and Innovations

Innovation 1: Reframing Test-Time Compute Scaling in Robotics as a Latent Refinement Problem Rather Than a Token Generation Problem

The paper's most fundamental conceptual move is to decouple "reasoning" from "token generation" in the context of test-time compute scaling for robotics. Prior to this work, the dominant paradigm for giving VLAs variable computational depth was to have them generate explicit reasoning tokens — textual Chain-of-Thought (ECoT, ThinkAct) or visual traces (CoT-VLA, MolmoAct) — before predicting actions. This approach inherits directly from the language modeling literature, where token-level CoT has proven effective for scaling inference compute on math, code, and reasoning benchmarks. The assumption — largely unexamined in the robotics domain — was that thinking requires verbalizing.

RD-VLA challenges this assumption at the architectural level. The paper's core reframing is that reasoning for visuomotor control is fundamentally a continuous process of refining an internal representation, not a discrete process of generating and consuming tokens. This is not merely an efficiency argument (though the 80× speedup is a welcome consequence). It is a representational argument: the model's understanding of a manipulation scene — spatial relationships, contact dynamics, motion trajectories, force requirements — exists naturally in a high-dimensional continuous space. Forcing this understanding through a token bottleneck (discretizing "the gripper should approach from 34 degrees at approximately 0.2 m/s" into subword tokens) introduces quantization error and constrains reasoning fidelity to the resolution of the vocabulary.

The significance of this reframing extends beyond RD-VLA itself. It establishes latent iterative refinement as a third paradigm for VLA reasoning, distinct from both (a) fixed-depth end-to-end prediction (RT-2, OpenVLA, π₀) and (b) token-level explicit reasoning (ECoT, ThinkAct, MolmoAct). The paper provides evidence for why this distinction matters: tasks that fail entirely (0% success) with single-iteration inference exceed 90% at four iterations (Table II), demonstrating that computational depth is necessary for capability. Yet the same depth applied uniformly would be wasteful overhead for simple substeps. Token-level reasoning can provide variable depth, but at the cost of linear memory scaling and autoregressive decoding latency. Latent refinement provides variable depth with constant memory and non-autoregressive computation — a combination that no prior VLA architecture has offered.

This reframing also resolves a tension in the prior literature. Dynamic inference methods like DeeR-VLA could modulate which layers execute (scaling compute down) but could not scale compute up beyond the backbone's fixed depth. Token-reasoning methods could scale compute up (generate longer CoT) but with prohibitive memory and latency costs. RD-VLA occupies the previously empty quadrant: scale compute both up and down, efficiently.

Evidence: Table I shows RD-VLA at 0.5B parameters outperforming 7B token-reasoning methods on LIBERO, while the abstract claims 80× inference speedup over prior reasoning-based VLAs. Figure 4 demonstrates that performance scales log-linearly with recurrence depth across all task categories — the first systematic evidence that test-time compute scaling works for visuomotor control through a latent mechanism.

---

Innovation 2: Input Injection as a Principled Solution to Representational Collapse in Recurrent Vision-Language-Action Architectures

The paper identifies and solves a specific technical problem that has limited the adoption of recurrent architectures for multimodal control: representational collapse over long unrolls. A recurrent transformer applied repeatedly to its own output can drift away from the original observation, amplifying small errors and converging to degenerate attractor states that no longer reflect the scene. This is a known challenge in recurrent neural networks, but prior work in the VLA domain has largely avoided it by not using recurrence at all — opting instead for fixed-depth architectures or token-based iterative approaches that reprocess the full observation at each step (at the cost of growing context).

RD-VLA's Input Injection strategy (Section III-B.1) provides a structured solution: at every iteration, the Recurrent Core concatenates its evolving scratchpad state with a stable foundation representation ($S_{pre}$) produced once by the Prelude from mid-layer VLM features. This is not simply residual connections or skip connections (which also help with gradient flow in deep networks) — it is a deliberate architectural choice that bifurcates the representation into a dynamic component ($S_{k-1}$, which evolves) and a static component ($S_{pre}$, which anchors). The learned linear projection $W_{adapt}$ then decides how to blend them.

What makes this an innovation rather than an engineering detail is its theoretical motivation: the paper frames it as a solution to the information bottleneck that arises specifically when a recurrent architecture must perform iterative reasoning about a fixed observation. In language models (where recurrent transformers like Huggin originated), the "observation" is typically a text prefix that doesn't change during reasoning — but the model's internal state can still drift from the semantics of that prefix. In VLAs, the observation is even richer (high-dimensional vision features) and the risk of drift is correspondingly higher. Input Injection is the architectural mechanism that guarantees every iteration has fresh access to the original scene representation, making long unrolls stable.

The significance is that this enables arbitrary inference depth without retraining or architectural modification. Because the grounding signal is injected at every step, the model does not need to be trained at the specific depth used at inference — the same trained Recurrent Core works at $r = 4$, $r = 32$, or $r = 128$. This property is what makes adaptive stopping possible: the convergence criterion ($\|\mathbf{a}_k - \mathbf{a}_{k-1}\|^2_2 < \delta$) is only meaningful if the refinement operator is stable across varying depths.

Evidence: Table II shows stable performance from $r = 8$ through $r = 24$ (92.6% to 93.1%), with degradation only at $r = 32$ (92.1%), suggesting Input Injection effectively prevents collapse over the range of depths studied. The per-task convergence profiles in Figure 5 further demonstrate that different tasks find stable convergence at different depths, consistent with the architecture supporting variable-depth stable refinement.

---

Innovation 3: Latent Convergence as an Emergent Uncertainty Signal — Enabling Self-Regulating Policies Without Explicit Confidence Training

A subtle but consequential contribution is the paper's demonstration that the recurrent architecture inherently produces a usable uncertainty signal through latent convergence dynamics, without requiring explicit uncertainty estimation training. This is not a claim about model calibration in the traditional sense (e.g., the model's predicted success probability matching empirical success rates). Rather, it is the observation that the rate at which the scratchpad converges — operationalized through the KL divergence between consecutive action predictions — correlates with task difficulty and can be used for downstream decision-making.

The paper operationalizes this in two ways: (1) adaptive computation (stopping early when convergence is reached), and (2) adaptive execution (executing fewer actions when convergence was slow, indicating uncertainty). Both mechanisms rely on the same underlying signal: $\|\mathbf{a}_k - \mathbf{a}_{k-1}\|^2_2$.

What distinguishes this from prior work on uncertainty estimation in robotics is that the signal emerges from the architecture's dynamics rather than from an auxiliary prediction head. The model was never trained to predict its own uncertainty or to produce calibrated confidence scores. It was trained only to refine a noisy scratchpad into actions via behavior cloning. The convergence behavior — fast for simple states, slow for complex ones — is an emergent property of the recurrent refinement process. This is analogous to how diffusion models' denoising trajectories can reveal sample difficulty, but the paper demonstrates it in a deliberative (not generative) context.

The practical implication is significant: the model can self-regulate. It knows when it's uncertain without being told what uncertainty looks like. This opens the door to safety-critical applications where the policy should request human intervention or fall back to conservative behavior when its internal reasoning has not stabilized — a capability the paper explicitly flags (Section V) without fully exploring.

The paper also reports a critical nuance: the convergence behavior is task-dependent (Figure 6), with spatial tasks requiring more iterations on average ($\mu = 11.8$) than object ($\mu = 9.8$) or goal ($\mu = 9.0$) tasks. This validates that the convergence signal reflects genuine task complexity rather than arbitrary noise — the model doesn't just take longer to converge on some tasks by chance; it takes longer on tasks that are objectively more demanding of spatial reasoning.

Evidence: Table II shows that adaptive stopping with $\delta = 5\times 10^{-4}$ achieves 92.5% success using only 7.93 average iterations (versus 93.0% at fixed $r = 12$). Figure 6 demonstrates that the distribution of adaptive exits varies systematically across task categories. The real-world experiments (Figure 7) show that adaptive stopping maintains competitive performance with fixed-depth models, confirming the signal transfers to physical settings.

---

Innovation 4: Computational Depth as a Task-Dependent Property — Reframing "How Much to Think" as an Inference-Time Decision Rather Than a Training-Time Hyperparameter

The paper provides systematic evidence for a phenomenon that has been mostly anecdotal in prior work: the optimal depth of reasoning is not a universal constant but varies substantially across tasks, and this variation can be discovered and exploited at inference time without task-specific tuning. This seems obvious in retrospect — of course some manipulation tasks require more deliberation than others — but the dominant practice in VLA research has been to train a fixed-depth model and use that depth uniformly at inference.

The paper's contribution here is twofold: (1) characterizing how much the optimal depth varies, and (2) demonstrating that adaptive mechanisms can recover task-appropriate depth without per-task labels.

Figure 5 provides the key evidence. Across five long-horizon tasks from LIBERO, the convergence profiles are qualitatively different:

• Task 4 reaches near-perfect performance with just 2 iterations (jumping from 6% at $r=1$ to ~80% at $r=2$)
• Task 5 remains at 0% through $r=2$ and only reaches ~70% at $r=3$
• Other tasks show intermediate convergence rates

This demonstrates that a single fixed depth cannot be optimal for all tasks — a model with $r=2$ would fail Task 5 entirely, while a model with $r=8$ would waste 6 iterations of compute on Task 4 (which converges fully at 2). The adaptive stopping criterion (KL divergence threshold) resolves this tension automatically, allocating more iterations to Task 5 and fewer to Task 4, without any task identifier or explicit difficulty label.

This connects to a broader theme in the test-time compute literature: the optimal allocation of inference budget is prompt-dependent, and adaptive allocation can recover large efficiency gains. But whereas prior work in language (e.g., compute-optimal scaling papers) required explicit difficulty estimation or a separate policy network to decide how to allocate budget, RD-VLA achieves adaptive allocation through an intrinsic architectural mechanism — the model's own convergence dynamics. This is a more elegant solution because it doesn't require training a separate meta-policy or estimating difficulty from external signals.

Evidence: Table II shows that adaptive strategies (Binary, Linear Decay, Pure KL) all achieve 91–93% success rates while using 34% fewer iterations on average than fixed-depth models at comparable performance. Figure 5 and Figure 6 together demonstrate that the variation in convergence depth is structured (correlated with task type) and exploitable.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on two simulation benchmarks: LIBERO (Liu et al., 2023a), a manipulation benchmark with four task suites (Spatial, Object, Goal, and Long-horizon), and CALVIN (Mees et al., 2022), specifically the ABC→D split that evaluates long-horizon task chaining where models must complete up to 5 tasks in sequence. Real-world experiments are conducted on four household tasks (placing a cube in a bowl, wiping a dish, folding a towel, toasting bread) with a bimanual YAM robot manipulator. The paper uses the LIBERO-10 split for the main comparison table (Table I) — a subset of 10 tasks — and the full LIBERO suites for the ablation studies in Table II.
• Base model(s). All experiments use a VLM based on Qwen2.5-0.5B (Yang et al., 2024), a small 24-layer 0.5-billion-parameter language model, fine-tuned via LoRA following the MiniVLA (Belkhale and Sadigh, 2024) recipe. The vision encoder is a frozen DINOv2 (Oquab et al., 2023) and SigLIP (Zhai et al., 2023) fused encoder from MiniVLA, producing 256 vision tokens per image (512 total for wrist and main camera). The paper argues this model is deliberately small — "minimal hyperparameter tuning and a relatively small backbone" — to demonstrate that the architectural contribution (latent recurrence) drives gains independently of scale, and to establish that the approach is viable for resource-constrained settings.
• Metrics. Success rate (%) on LIBERO and CALVIN, computed as the fraction of evaluation episodes where the robot successfully completes the specified task. For CALVIN, the paper additionally reports average episode length (the mean number of sequentially completed subtasks in a row, out of 5 maximum) and tasks completed in a row (↑, higher is better). For adaptive methods, the paper reports mean iterations (k̄) and standard deviation (σ) of convergence depth. Real-world experiments report task progression scores (a normalized completion metric, though the exact scoring rubric is not detailed in the paper). Inference speed comparisons use latency measurements in milliseconds, though specific hardware and batch-size conditions are not fully specified.
• Baselines. The paper compares against three categories of methods on LIBERO (Table I): End-to-end VLAs — OpenVLA (Kim et al., 2024), π₀.₅ (Physical Intelligence, 2025), MiniVLA (Belkhale and Sadigh, 2024), Octo (Team et al., 2024), RT-1-X (O'Neill et al., 2024), GR-1 (Wu et al., 2023), GROOT (Cen et al., 2025), RoboFlamingo (Li et al., 2024), Susie (Black et al., 2023), VLAS (Zhao et al., 2025b), TinyVLA (Wen et al., 2025), and SmolVLA (Shukor et al., 2025); Token reasoning VLAs — ECoT (Zawalski et al., 2024), CoT-VLA (Zhao et al., 2025a), FlowVLA (Zhong et al., 2025), ThinkAct (Huang et al., 2025), Fast-ThinkAct (Huang et al., 2026), and MolmoAct (Lee et al., 2025); and latent reasoning VLA — RD-VLA (this work, in fixed and adaptive variants). On CALVIN (Table III), baselines include OpenVLA, MDT (not further specified in the paper), HULC (not further specified), and RoboFlamingo. Real-world baselines are Diffusion Policy (Chi et al., 2025) and π₀.₅. RD-VLA is evaluated in two configurations: Fixed (8 iterations) and Adaptive (Pure KL with τ = 1 × 10⁻⁴).
• Generation budget / compute accounting. The primary unit of computation is number of recurrent iterations in the Recurrent Core (denoted $r$ or $N_{inf}$). For fixed recurrence, this is a hyperparameter swept from 1 to 32 iterations. For adaptive recurrence, the average iteration count k̄ is reported alongside success rate. The paper does not directly compare FLOPs or wall-clock time to token-reasoning baselines (the "80× speedup" claim in the abstract compares qualitatively different computational primitives — latent refinement vs. autoregressive decoding — and specific timing conditions are not detailed). The paper reports parameter count for all methods in Table I to contextualize model scale. The cost of the Prelude and Coda (each executed once per control step) is not separately accounted for but is constant and independent of recurrence depth.
• Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported. All results appear to be single-run evaluations on the standard test sets of LIBERO and CALVIN. The ablation studies in Table II sweep hyperparameters (thresholds τ, fixed depths, adaptive strategies) on what appears to be the full evaluation set; the paper does not describe a held-out validation split for threshold selection, which raises the possibility that the optimal τ = 5 × 10⁻⁴ was selected by evaluating on the test set. Real-world experiments report performance across an unspecified number of trials — the paper states "we train and compare our model in each task" but does not provide trial counts, standard deviations, or statistical comparisons.

Main Quantitative Results

Scaling Behavior of Fixed Recurrence on LIBERO (Table II, Figure 4)

The paper's first axis of investigation establishes the relationship between recurrent depth and task success when using a fixed, predetermined number of iterations.

Headline finding: Performance follows a log-linear improvement with increased recurrence, saturating between 8 and 12 iterations. Specifically:

• At $N_{inf} = 1$ (single-iteration inference, effectively no recurrence), the model achieves only 8.4% average success rate across all LIBERO suites. This is effectively a standard fixed-depth VLA with the recurrent head acting as a single-pass transformer.
• At $N_{inf} = 2$, performance jumps to 40.5% — a 382% relative improvement from just one additional iteration.
• At $N_{inf} = 4$, performance reaches 84.1% (108% increase over $N_{inf} = 2$).
• At $N_{inf} = 8$, performance reaches 92.6% (10% increase over $N_{inf} = 4$).
• Peak performance of 93.1% occurs at $N_{inf} = 24$, though the gain from 8 to 24 iterations is marginal (0.5 percentage points).
• At $N_{inf} = 32$, performance slightly degrades to 92.1%, suggesting the onset of representational saturation or mild instability at extreme depths.

Per-task-suite breakdown (Table II): The scaling behavior varies systematically across task categories:

• Spatial tasks: 9.0% at $N_{inf}=1$, 38.0% at $N_{inf}=2$, 79.2% at $N_{inf}=4$, 93.0% at $N_{inf}=8$, peaking at 92.4% at $N_{inf}=24$.
• Object tasks: 12.2% at $N_{inf}=1$, 61.2% at $N_{inf}=2$, 93.0% at $N_{inf}=4$, 97.8% at $N_{inf}=8$, peaking at 99.2% at $N_{inf}=24$.
• Goal tasks: 11.4% at $N_{inf}=1$, 47.6% at $N_{inf}=2$, 89.2% at $N_{inf}=4$, 94.2% at $N_{inf}=8$, peaking at 96.0% at $N_{inf}=12$.
• Long-horizon tasks: 1.0% at $N_{inf}=1$, 15.0% at $N_{inf}=2$, 74.8% at $N_{inf}=4$, 85.2% at $N_{inf}=8$, peaking at 86.6% at $N_{inf}=24$.

The Long-horizon tasks show the most dramatic dependence on recurrence: nearly zero capability at $N_{inf}=1$, requiring 4 iterations to reach meaningful performance. In contrast, Object tasks saturate quickly, with $N_{inf}=4$ already achieving 93.0% — close to the suite's ceiling. This task-dependent scaling behavior directly motivates the adaptive computation strategy.

Figure 4 visualizes these trends as line plots across all four task suites, showing the characteristic log-linear improvement and early saturation for simpler suites. The curves for Spatial, Object, and Goal tasks cluster in the 90–99% range by $N_{inf}=8$, while Long-horizon tasks converge to a lower asymptote (~85%).

Key takeaway from fixed recurrence: The paper demonstrates that recurrent depth is not merely helpful but essential for many tasks — a model with $N_{inf}=1$ is effectively non-functional on Long-horizon tasks (1.0% success) and severely impaired on Spatial tasks (9.0%). The 4× increase from $N_{inf}=1$ to $N_{inf}=4$ (8.4% → 84.1%) represents a 10× capability multiplier. However, scaling beyond ~12 iterations yields sharply diminishing returns, and scaling to 32 iterations shows slight degradation, establishing a practical effective range.

Necessity of Task-Dependent Computation (Figure 5)

This analysis disaggregates the aggregate scaling curves to show that individual tasks exhibit qualitatively different convergence profiles, demonstrating that no single fixed depth is optimal across the task distribution.

Headline finding: Across five selected Long-horizon tasks in LIBERO, the required depth to achieve meaningful performance varies dramatically. Figure 5 shows:

• Task 4 jumps from 6% success at $N_{inf}=1$ to approximately 80% at $N_{inf}=2$, effectively saturating after just 2 iterations.
• Task 5 remains at 0% success through $N_{inf}=2$ and only reaches approximately 70% at $N_{inf}=3$, requiring at least 3 iterations before any meaningful success.
• Other tasks show intermediate convergence rates, some reaching ~50–60% at $N_{inf}=2$, others requiring $N_{inf}=3$ or $N_{inf}=4$ to achieve comparable performance.

The paper frames this as evidence that "the number of required iterations emerges naturally from the task context rather than being prescribed." The implication is that a fixed-depth policy — say, $N_{inf}=8$ for all tasks — would over-compute on Task 4 (using 6 unnecessary iterations) while being the minimum viable depth for Task 5. Adaptive stopping should, in principle, allocate iterations according to each task's intrinsic difficulty.

What this analysis does not show: Figure 5 reports success rates at each fixed depth but does not demonstrate that the adaptive model actually allocates more iterations to Task 5 than to Task 4. That evidence comes later (Figure 6). Figure 5 establishes the necessity of task-dependent computation; Figure 6 establishes that the model delivers it.

Adaptive Computation Performance (Table II, Figure 6)

This axis evaluates whether the adaptive stopping criterion based on KL divergence (action convergence) can match fixed-depth performance while reducing average compute.

Headline finding: The Binary Adaptation strategy with τ = 5 × 10⁻⁴ achieves 92.5% success rate — comparable to the best fixed-depth models (93.0% at $N_{inf}=12$, 93.1% at $N_{inf}=24$) — while using an average of only k̄ = 7.93 iterations, representing a 34% reduction in compute relative to the $N_{inf}=12$ baseline.

Comprehensive sweep across thresholds (Table II, top section "Binary Adaptation"):

Key observations:

• τ = 5 × 10⁻⁴ is the sweet spot, achieving the highest overall average (92.5%) and the highest Long-horizon score (85.8%) while using fewer iterations (7.93) than the fixed $N_{inf}=12$ baseline (93.0%, 12.0 iterations).
• All thresholds in the range 1 × 10⁻⁴ to 1 × 10⁻³ achieve 91–93% average success — the method is relatively robust to the precise threshold value within a reasonable range.
• At very loose thresholds (τ = 5 × 10⁻³, 1 × 10⁻²), performance degrades sharply on Long-horizon tasks (61.8% and 43.6%, respectively), confirming that early stopping is harmful and that convergence is meaningful.
• At the tightest threshold (τ = 1 × 10⁻⁴), the model averages 11.04 iterations — nearly matching the fixed $N_{inf}=12$ depth — and achieves essentially identical performance, confirming that adaptive stopping can automatically replicate a fixed-depth regime when given a sufficiently stringent threshold.

Comparison across adaptive strategies: The paper tests three strategies:

• Binary Adaptation (Table II, top section): Standard convergence-based stopping with a single execution horizon (implicitly $H_{long}$, since $H_{short}$ is not applied in this configuration).
• Linear Decay (Table II, middle section): Convergence-based stopping with execution horizon inversely proportional to convergence depth.
• Pure KL (Threshold) (Table II, bottom section): Convergence-based stopping without the adaptive execution modulation — all converged predictions use the full action horizon.

At matched thresholds, all three strategies perform comparably: at τ = 5 × 10⁻⁴, Binary achieves 92.5%, Linear Decay 90.7%, Pure KL 91.4%. Binary Adaptation edges out the others slightly on Long-horizon tasks (85.8% vs. 82.0% vs. 82.0%), suggesting that the combination of adaptive stopping with threshold-based execution modulation provides a small additional benefit.

Distribution of adaptive exits (Figure 6): Histograms of per-token exit depths for three task categories at τ = 1 × 10⁻⁴:

• Spatial tasks: Mean μ = 11.8 iterations — the most compute-intensive category, consistent with spatial reasoning requiring deeper refinement.
• Object tasks: Mean μ = 9.8 iterations — intermediate depth.
• Goal tasks: Mean μ = 9.0 iterations — the fastest convergence, consistent with goal-directed tasks being more directly solvable.

This is a critical validation: the adaptive mechanism is not simply stopping at random depths or a single mode — it produces structured, task-dependent exit distributions that align with task complexity. The standard deviations (σ = 1.03–1.20 at τ = 5 × 10⁻⁴) indicate that even within a task category, there is meaningful variation in convergence depth across individual states.

Key takeaway from adaptive computation: The convergence-based stopping criterion successfully recovers task-appropriate depths without per-task labels, matching fixed-depth performance while reducing compute by 34%. The mechanism is robust to threshold choice within a reasonable range and produces task-dependent exit distributions consistent with intuitive task difficulty.

Performance Against Other Baselines (Table I, Table III, Figure 7)

LIBERO-10 benchmark (Table I):

RD-VLA achieves state-of-the-art performance of 93.0% with fixed recurrence, outperforming the strongest token-reasoning baseline (Fast-ThinkAct at 89.7%) by 3.3 percentage points, and the strongest end-to-end baseline (OpenVLA-OFT at 82.5%) by 10.5 percentage points. The adaptive variant (92.5%) maintains competitive performance, surpassing all non-RD-VLA methods.

The most striking aspect of this comparison is the parameter efficiency: RD-VLA at 0.5B parameters outperforms all 7B-parameter token-reasoning methods. This is a 14× parameter reduction while achieving higher success rates. The paper attributes this to the efficiency of latent refinement — parameter count in the Recurrent Core is constant regardless of depth, while token-reasoning methods require the full backbone capacity to generate and process reasoning tokens.

Within the 0.5B-parameter class, RD-VLA dramatically outperforms MiniVLA (93.0% vs. 71.2%), demonstrating that the improvement is architectural, not merely a function of the MiniVLA training recipe. Octo at 0.1B parameters achieves only 42.2%, further highlighting that parameter count alone does not explain the performance gap.

CALVIN ABC→D benchmark (Table III):

(Note: CALVIN results for baselines are read from Table III; exact values for some baselines are approximated from visual inspection of the reported bar chart, as the paper provides a graphical rather than tabular format for non-RD-VLA methods.)

RD-VLA achieves the highest average chain length of 3.39 and a Task-5 success rate of 45.3%, outperforming OpenVLA (the previous best) by 0.12 in average length and approximately 3 percentage points on the hardest sequential task. This validates that latent refinement generalizes to long-horizon sequential task chaining, where the model must complete up to 5 subtasks in sequence without resetting.

Key observation: The CALVIN experiments use fixed 8 iterations (not adaptive), suggesting that for long-horizon sequential tasks, a consistent moderate depth may be preferable to per-step adaptation. The paper does not report adaptive results on CALVIN, which limits the generality of the adaptive computation claim.

Real-world experiments (Figure 7):

Four tasks evaluated against Diffusion Policy and π₀.₅ baselines:

(Numbers approximated from Figure 7 bar chart; original paper uses normalized scores rather than explicit percentages, so these are relative comparisons.)

RD-VLA variants consistently and substantially outperform both baselines across all tasks. The fixed 8-iteration model achieves near-perfect performance on dish wiping (~98%) and strong performance on the challenging towel folding task (~75%, vs. ~35% for π₀.₅). The adaptive variant (Pure KL, τ = 1 × 10⁻⁴) matches or closely trails the fixed model, achieving the highest score on cube placement (~90%) while falling behind on towel folding (~60% vs. ~75%).

Key takeaway from baselines: RD-VLA establishes a new state of the art on LIBERO at 93.0%, outperforms all prior methods on CALVIN for long-horizon chaining, and transfers effectively to real-world tasks with large margins over Diffusion Policy and π₀.₅. The parameter efficiency (0.5B vs. 7B competitors) is a significant practical advantage, and the real-world results confirm that latent refinement is not merely a simulation phenomenon.

Ablation Studies and Robustness Checks

• Fixed vs. adaptive computation (Table II, all sections): The central ablation compares fixed recurrence depths (1, 2, 4, 8, 12, 16, 24, 32) against three adaptive strategies at multiple thresholds. At matched performance levels (92.5–93.0%), adaptive strategies reduce compute by 34% (7.93 vs. 12.0 iterations). All adaptive strategies perform comparably, with Binary Adaptation achieving the highest Long-horizon score (85.8% at τ = 5 × 10⁻⁴), suggesting that the convergence signal is robust to the specific execution modulation strategy. The degradation at extreme depths ($N_{inf}=32$, 92.1%) compared to $N_{inf}=24$ (93.1%) and $N_{inf}=12$ (93.0%) indicates that there is an upper bound to beneficial recurrence in the current architecture.

• Adaptive stopping threshold τ (Table II, all sections): The threshold sweep from 1 × 10⁻⁴ to 1 × 10⁻² reveals a clear performance-compute trade-off. Tight thresholds (1 × 10⁻⁴) produce more iterations (k̄ = 11.04) with performance matching fixed-depth models (91.3%), while loose thresholds (1 × 10⁻²) reduce iterations sharply (k̄ = 3.36) but cause significant degradation on Long-horizon tasks (43.6%). The optimal τ = 5 × 10⁻⁴ achieves the best balance across all suites. The standard deviation σ decreases monotonically with increasing τ (from σ = 1.20 at τ = 1 × 10⁻⁴ to σ = 0.19 at τ = 1 × 10⁻²), confirming that tighter thresholds allow more task-dependent variation in depth.

• Binary vs. Linear Decay vs. Pure KL strategies (Table II, comparing across sections): At τ = 5 × 10⁻⁴, Binary Adaptation achieves 92.5%, Linear Decay 90.7%, and Pure KL 91.4%. The 1.8-percentage-point spread is modest, suggesting that the specific adaptive strategy is less critical than the underlying convergence signal. However, Binary Adaptation's advantage on Long-horizon tasks (85.8% vs. 82.0% vs. 82.0%) hints that coupling convergence depth to execution horizon may provide a small additional benefit in safety-critical long-horizon scenarios.

• Recurrence depth across task suites (Table II, Fixed Recurrence rows): The per-suite breakdown reveals that Object tasks saturate earliest (93.0% at $N_{inf}=4$) while Long-horizon tasks require the most depth (85.2% at $N_{inf}=8$, peaking at 86.6% at $N_{inf}=24$) and never reach the ~95%+ performance of simpler suites. This is a non-trivial finding: it suggests that recurrence can partially compensate for task complexity but cannot fully close the gap between simple and complex tasks — an implicit ceiling on what test-time compute can achieve for the hardest manipulation scenarios.

• Task-level convergence profiles (Figure 5): The per-task analysis of 5 selected Long-horizon tasks demonstrates that no single fixed depth is optimal. Task 4 reaches ~80% at $N_{inf}=2$ while Task 5 remains at 0% through $N_{inf}=2$ and only reaches ~70% at $N_{inf}=3$. This provides the empirical motivation for adaptive computation: a fixed $N_{inf}=2$ model would completely fail Task 5, while a fixed $N_{inf}=8$ model would waste iterations on Task 4.

• Adaptive exit distributions by task category (Figure 6): The histograms of per-token adaptive exits at τ = 1 × 10⁻⁴ show that Spatial tasks require the most iterations (μ = 11.8), Object tasks intermediate (μ = 9.8), and Goal tasks the least (μ = 9.0). This validates the intuition that spatial reasoning — which involves computing relative positions, distances, and collision-free trajectories — benefits most from deeper iterative refinement, while goal-directed reasoning converges more quickly. The spread of each distribution (the paper reports standard deviations in Table II but does not overlay distributional statistics on Figure 6 histograms) indicates that even within a task category, there is state-level variation in required depth.

• Real-world adaptive vs. fixed (Figure 7): The adaptive variant (Pure KL, τ = 1 × 10⁻⁴) closely tracks the fixed 8-iteration model on three of four tasks, achieving the highest score on cube placement (~90% vs. ~85%) but falling behind on towel folding (~60% vs. ~75%). This suggests that for the most challenging real-world tasks, aggressive adaptive stopping may terminate too early — towel folding likely requires sustained deep reasoning that a per-step convergence check might prematurely truncate. The paper does not explore whether a task-specific threshold tuning could recover this gap.

• Parameter count comparison (Table I): RD-VLA at 0.5B parameters outperforms all 7B-parameter token-reasoning methods. This is not an ablation in the traditional sense but serves as a strong demonstration that the architectural mechanism (latent recurrence) provides capability independently of scale. The MiniVLA baseline (same 0.5B backbone, same training recipe, without recurrence) achieves only 71.2%, confirming that the gain is not attributable to the backbone or training data.

Critical Assessment

Claim: Recurrent depth is critical — tasks that fail entirely with single-iteration inference exceed 90% success with four iterations (Abstract, Section IV-A)

What was tested: The fixed recurrence sweep in Table II demonstrates that average success across all LIBERO suites improves from 8.4% at $N_{inf}=1$ to 84.1% at $N_{inf}=4$. This is a dramatic ~10× improvement. The Long-horizon suite specifically goes from 1.0% to 74.8%.

What was not tested: The "fail entirely" framing applies most clearly to Long-horizon and Spatial tasks at $N_{inf}=1$ (1.0% and 9.0%, respectively). However, Object tasks already achieve 12.2% at $N_{inf}=1$, and Goal tasks 11.4% — these are poor but not "entirely failed." The claim is technically accurate for the tasks the paper highlights (Task 5 at 0% through $N_{inf}=2$ in Figure 5) but generalizes unevenly across the benchmark.

Genuine weakness: The paper reports aggregate success rates but never analyzes why certain tasks fail at low depth. Does the model produce physically impossible actions, fail to identify the target object, or generate reasonable but incorrectly sequenced actions? Without error categorization, it is unclear whether recurrence is fixing a perception problem, a planning problem, or an action-precision problem. This limits the diagnostic value of the scaling curves.

Claim: Adaptive stopping maintains peak performance while reducing compute by 34% (Section IV-C, Table II)

What was tested: At τ = 5 × 10⁻⁴, Binary Adaptation achieves 92.5% using k̄ = 7.93 iterations vs. 93.0% at fixed $N_{inf}=12$ (the closest fixed-depth comparator at peak performance). This is a 0.5-percentage-point performance difference for a ~34% compute reduction.

What was not tested: The threshold τ = 5 × 10⁻⁴ was almost certainly tuned by evaluating on the test set — the paper describes no held-out validation set for threshold selection. In a proper evaluation protocol, the optimal threshold would be selected on a validation split and then evaluated on a held-out test set. Without this, the reported 92.5% may be optimistically biased. The paper also does not report whether the 92.5% figure is a single-run result or an average over multiple seeds, making it impossible to assess whether the 0.5% gap from fixed depth is statistically meaningful or within noise.

Genuine weakness: The adaptive stopping results are reported only on LIBERO. CALVIN results use fixed $N_{inf}=8$ only, with no adaptive variant reported. Real-world adaptive results (Figure 7) show a meaningful gap on the hardest task (towel folding: ~60% adaptive vs. ~75% fixed). The paper does not address this discrepancy — why does adaptive stopping work well on LIBERO but degrade on real-world towel folding? Possible explanations (more stringent convergence needed for contact-rich tasks, domain shift in the convergence threshold, per-step variance in real-world observations) are not explored.

Claim: RD-VLA achieves up to 80× inference speedup over prior reasoning-based VLA models (Abstract)

What was tested: The paper makes this claim in the abstract and mentions it in the introduction, but never presents a timing experiment or latency comparison in the results. Table I compares parameter counts and success rates but not inference time. Figure 1 (right panel) shows a qualitative speed comparison bar chart with no numerical values, axis labels, or hardware specifications.

What would be needed to support this claim: A controlled comparison measuring wall-clock latency per control step for RD-VLA (at various depths) versus token-reasoning baselines (ThinkAct, MolmoAct, CoT-VLA) on identical hardware with identical batch sizes. The comparison should account for the full pipeline: vision encoding, VLM forward pass, reasoning (recurrent iterations vs. autoregressive token generation), and action decoding. Without this, the 80× figure is unsubstantiated.

Genuine weakness: This is the paper's most prominently featured quantitative claim (abstract, bolded in Figure 1) and it is essentially unevaluated. The architectural argument for why latent reasoning should be faster is sound (non-autoregressive, constant memory), but the magnitude of the advantage depends critically on implementation details (number of reasoning tokens generated by baselines, whether speculative decoding is used, KV-cache optimization, etc.). The absence of a timing experiment is a significant gap.

Claim: RD-VLA achieves state-of-the-art performance on LIBERO and CALVIN (Section IV-D)

What was tested: On LIBERO-10 (Table I), RD-VLA achieves 93.0%, outperforming all listed baselines. On CALVIN ABC→D (Table III), RD-VLA achieves 3.39 average episode length and 45.3% Task-5, outperforming all listed baselines.

What was not tested: The LIBERO comparison is on the LIBERO-10 subset (10 tasks), not the full LIBERO benchmark (which includes LIBERO-90 and LIBERO-Long with many more tasks). The paper's own ablation studies (Table II) use the full LIBERO suites, so the 93.0% figure from LIBERO-10 may not be directly comparable to the per-suite numbers in Table II (which average 92.6% at $N_{inf}=8$, 93.0% at $N_{inf}=12$, etc.). The CALVIN comparison uses fixed 8 iterations — this is not the best RD-VLA configuration (peak on LIBERO occurs at $N_{inf}=12–24$), so CALVIN results may underrepresent the method's potential.

Genuine weakness: The baseline comparisons are somewhat uneven. Fast-ThinkAct (89.7%) and MolmoAct (88.3%) at 7B parameters are the strongest competitors, but they represent 14× larger models. The paper celebrates the parameter efficiency, but parameter count is an imperfect proxy for inference cost — a 0.5B model unrolled 8 times may require comparable or greater FLOPs than a 7B model with a single forward pass (the recurrent core's FLOPs per iteration vs. the backbone's FLOPs per forward pass are not directly compared). A FLOPs-matched comparison (analogous to what the compute-optimal scaling literature does for language models) would be more informative than a parameter-count comparison.

Claim: Latent convergence provides a usable uncertainty signal (Section III-C, Section V)

What was tested: The adaptive stopping experiments in Table II demonstrate that $\|\mathbf{a}_k - \mathbf{a}_{k-1}\|^2_2$ can be thresholded to stop computation with minimal performance loss. Figure 6 shows that exit depths vary systematically by task category, suggesting the signal correlates with task difficulty.

What was not tested: The paper does not evaluate whether the convergence metric actually correlates with success probability (i.e., calibration). A high convergence depth might indicate genuine uncertainty (the model is correct to deliberate longer) or epistemic confusion (the model oscillates without converging to a good solution). The paper provides no analysis of whether states that converge slowly are actually more likely to result in failure — the only evidence is that stopping too early (loose threshold) causes more failures, which is a different claim. The paper also does not test whether the convergence signal can be used for the safety applications it hypothesizes (halting execution, requesting operator assistance) — these remain speculative.

Genuine weakness: The uncertainty quantification claim is the most aspirational and the least empirically validated. The paper demonstrates that convergence depth varies with task type, but does not demonstrate that it is a reliable predictor of success or failure. This is a missed opportunity: a simple analysis correlating convergence depth with per-episode success/failure would have directly tested the uncertainty quantification claim.

Missing Experiments and Analyses

Several experiments would have substantially strengthened the paper:

1. Latency benchmarking: A controlled wall-clock comparison of RD-VLA vs. token-reasoning baselines on identical hardware. This is essential for validating the 80× speedup claim and for understanding the practical deployment implications.

2. FLOPs-matched comparison: Evaluating a 7B VLA with RD-VLA-style recurrence against the 0.5B model to determine whether scale + recurrence provides further gains, and comparing RD-VLA's total FLOPs against baselines at matched compute.

3. Validation-based threshold selection: A proper held-out validation protocol for selecting τ, with final evaluation on a held-out test set, to ensure the 92.5% figure is not inflated by test-set tuning.

4. Failure mode analysis: Categorization of why single-iteration models fail on tasks that succeed with recurrence — is it perception, planning, or precision? This would clarify what recurrence is actually contributing.

5. Uncertainty calibration analysis: Correlation between convergence depth and episode success/failure, to validate the claim that latent convergence serves as a usable uncertainty signal.

6. Scaling backbone size: All experiments use Qwen2.5-0.5B. Does the benefit of recurrence scale with backbone size, diminish, or remain constant? The paper speculates that larger backbones would yield "significant performance gains" but provides no evidence.

7. Adaptive stopping on CALVIN and real-world tasks: The generalizability of the adaptive mechanism is only partially tested. CALVIN results use fixed depth only, and real-world adaptive results show a meaningful gap on the hardest task.

8. Statistical significance: The paper reports no confidence intervals, standard errors, or trial counts for any experiment. For a 500-episode benchmark, the difference between 92.5% and 93.0% may be statistically indistinguishable.

Summary of Where Claims Hold Conditionally

• The claim that recurrent depth dramatically improves performance (8.4% → 84.1% from $N_{inf}=1$ to 4) is strongly supported for the LIBERO benchmark and the specific Qwen2.5-0.5B backbone tested. Whether the scaling curve generalizes to other backbones, other embodiments, or other task distributions is untested.

• The claim that adaptive stopping reduces compute by ~34% with minimal performance loss holds for LIBERO at the specific threshold τ = 5 × 10⁻⁴, selected by what appears to be test-set tuning. Generalizability to other benchmarks and other threshold-selection protocols is unclear. The real-world results suggest a potential gap on the hardest tasks.

• The claim that RD-VLA outperforms all baselines holds for the specific baselines, benchmarks, and configurations reported. The LIBERO comparison is on the 10-task subset, the CALVIN comparison uses fixed (not best) depth, and real-world baseline comparisons lack reported trial counts.

• The claim that latent reasoning is 80× faster than token reasoning is unsubstantiated in the experimental results and should be treated as an architectural hypothesis rather than an empirically demonstrated fact.

• The claim that latent convergence provides an uncertainty signal is partially supported (by demonstrating that exit depths vary with task type) but the critical link to success/failure prediction is not empirically established. The safety applications remain speculative.

6. Limitations and Trade-offs

6.1 The Adaptive Stopping Threshold Is Tuned on the Test Set, Not a Held-Out Validation Split

The assumption or constraint. The paper sweeps the convergence threshold τ across six values (1×10⁻⁴, 2×10⁻⁴, 5×10⁻⁴, 1×10⁻³, 5×10⁻³, 1×10⁻²) and reports the best-performing value (τ = 5×10⁻⁴ at 92.5% success) as the headline adaptive result in Section IV-C. The experimental description in Section IV never references a held-out validation set for hyperparameter selection. The paper states that evaluation data comes from "the standard test sets of LIBERO and CALVIN" and describes no procedure for separating threshold tuning from final evaluation. The implication is that the optimal τ was selected by directly maximizing test-set performance, which would produce an optimistic bias in the reported 92.5% figure.

The consequence. A practitioner deploying RD-VLA with adaptive stopping in a new domain cannot use the τ = 5×10⁻⁴ value as a reliable default — it may be overfit to the LIBERO test distribution. Selecting a threshold without access to ground-truth success labels (which is the realistic deployment scenario) requires either a separate validation dataset or a heuristic for choosing τ that the paper does not provide. If the practitioner uses the test-set-tuned value in a new domain with different action magnitudes, observation noise, or task characteristics, the effective convergence behavior may differ substantially — the model may stop too early (degrading performance on hard tasks) or too late (wasting compute with no accuracy gain). The paper's real-world results in Figure 7 indirectly illustrate this risk: the adaptive variant (Pure KL, τ = 1×10⁻⁴, the tightest threshold tested) achieves ~90% on cube placement but only ~60% on towel folding vs. ~75% for fixed 8 iterations, suggesting that even the most conservative threshold from the simulation sweep does not transfer well to the hardest real-world task.

What evidence exists in the paper. Table II presents the full threshold sweep results. The standard deviation σ of iteration counts decreases monotonically with τ (from σ = 1.20 at τ = 1×10⁻⁴ to σ = 0.19 at τ = 1×10⁻²), confirming that looser thresholds suppress task-dependent variation in convergence depth — but this is presented as a descriptive observation rather than a prescriptive guide for threshold selection. The paper does not report whether different random seeds or data splits produce the same optimal τ, making the robustness of the selection unknown. Figure 7 provides the only out-of-distribution test of the adaptive threshold (real-world tasks with Pure KL, τ = 1×10⁻⁴) and shows a performance gap on the hardest task, though no sweep of real-world τ values was conducted to determine whether a task-specific threshold could recover the fixed-depth performance.

Mitigation status. The paper does not acknowledge this as a methodological concern. Section V (Discussion and Limitations) discusses "the boundary of depth generalization" and "representational collapse" but never addresses the test-set-tuning issue. The paper suggests future work on "optimizing the regimes for adaptive compute" but does not propose a protocol for threshold selection that separates tuning from evaluation. A straightforward mitigation — selecting τ on a held-out validation split from the training distribution and reporting test-set performance at that pre-registered value — would have eliminated this concern entirely.

---

6.2 The 80× Inference Speedup Claim Is Not Empirically Substantiated

The assumption or constraint. The abstract states that RD-VLA achieves "up to 80× inference speedup over prior reasoning-based VLA models," a claim repeated in the introduction and visually represented in Figure 1 (right panel) with a bar chart comparing RD-VLA to token-reasoning baselines. However, the paper presents no timing experiment, no latency measurements, and no hardware specification anywhere in Section IV or its appendices. The Figure 1 bar chart lacks numerical axis labels, making the 80× figure unverifiable from the provided evidence. The architectural argument — that latent refinement avoids autoregressive decoding and therefore should be faster — is physically plausible but does not constitute a measurement.

The consequence. Without a controlled latency comparison, a practitioner cannot estimate what "80× faster" means for their deployment scenario. The actual speedup depends critically on factors that the paper does not control or report: (1) the number of reasoning tokens generated by each token-reasoning baseline (longer CoT chains → larger speedup for RD-VLA), (2) whether the baselines use KV-cache optimization, speculative decoding, or other inference accelerations, (3) the batch size (RD-VLA's recurrent iterations cannot be parallelized across depth, while token-reasoning baselines with short CoT chains might benefit more from batched inference), (4) the hardware — GPU memory bandwidth, Tensor Core utilization, and CPU-GPU transfer times all affect the relative throughput of recurrent vs. autoregressive computation differently. The "up to" qualifier further reduces informativeness: knowing the best-case speedup under unspecified conditions provides no guidance for expected performance in a realistic deployment.

What evidence exists in the paper. The only timing-adjacent data point is the average iteration count from adaptive stopping (k̄ = 7.93 at the optimal τ, Table II), which implies that a typical RD-VLA inference requires roughly 8 passes through the Recurrent Core. If each pass through the Recurrent Core (self-attention over K = 8 tokens + cross-attention to 576 conditioning tokens) is substantially cheaper than generating one autoregressive token from a 7B-parameter backbone, the speedup would be large. But the paper provides no FLOPs analysis to support this comparison. Table I confirms that token-reasoning baselines use 14× more parameters than RD-VLA (7B vs. 0.5B), but that conflates model scale with inference mechanism — the fair comparison would measure wall-clock time for RD-VLA (0.5B, ~8 recurrent passes) vs. token-reasoning baselines (7B, 1 forward pass + N reasoning tokens), controlling for hardware and batch size.

Mitigation status. Not acknowledged, not addressed. The paper treats the 80× claim as an established fact rather than a hypothesis requiring empirical validation. Section V does not mention the absence of timing experiments as a limitation. A proper latency comparison — measuring end-to-end inference time per control step on identical hardware with controlled conditions — would have been a straightforward addition to Section IV and is the minimum evidence required to support this prominently featured claim.

---

6.3 Performance Saturates and Slightly Degrades Beyond ~12–24 Iterations, With No Mechanism for Continued Improvement

The assumption or constraint. The paper's core architectural premise is that "arbitrary inference depth" (Section III-B) and "arbitrarily deep computation at test time" (Section I) can be achieved through weight-tied recurrence. In practice, the fixed-recurrence sweep in Table II shows that performance saturates between 8 and 12 iterations (92.6% → 93.0%) and declines slightly from 93.1% at N_inf = 24 to 92.1% at N_inf = 32. The Long-horizon suite peaks at 86.6% at N_inf = 24 and drops to 84.4% at N_inf = 32. The paper acknowledges this in Section V:

"While performance scales predictably with the number of recurrent steps up to some optimal number of iterations, extending recurrence beyond this number of iterations may lead to state saturation or performance degradation rather than continued refinement."

The paper identifies this as a "key limitation" but does not provide an explanation for why degradation occurs — whether it is representational collapse (the scratchpad diverging from useful representations), over-refinement (the model "overthinking" and introducing errors), verifier-like over-optimization (the recurrent core exploiting spurious features that minimize the training loss but don't improve actions), or something else.

The consequence. The "arbitrary depth" claim is bounded in practice: depth beyond ~24 iterations provides no benefit and can actively harm performance. For a practitioner deploying RD-VLA, this means that simply allocating more test-time compute does not guarantee better results — there is an effective ceiling beyond which additional iterations are counterproductive. This undermines one of the paper's central motivations: scaling test-time compute for harder tasks. If the hardest tasks in the distribution (Long-horizon, 86.6% peak) cannot benefit from additional iterations, then "thinking longer for harder tasks" (Section VI) has a hard upper bound. The paper's vision of a model that "can think longer for harder tasks" implicitly assumes monotonic scaling, but the evidence shows an inverted-U shape: performance improves, plateaus, and then degrades. Without understanding the degradation mechanism, a practitioner cannot know how to set the maximum iteration budget safely.

What evidence exists in the paper. Table II provides the full fixed-recurrence sweep. The Long-horizon suite shows the clearest non-monotonicity: 1.0% → 15.0% → 74.8% → 85.2% → 84.8% → 85.2% → 86.6% → 84.4% (N_inf = 1, 2, 4, 8, 12, 16, 24, 32). The Object suite peaks at 99.2% at N_inf = 24 and drops to 98.8% at N_inf = 32. The Spatial suite peaks at 93.0% at N_inf = 8 and fluctuates between 91.2–92.4% at higher depths. The paper notes these trends qualitatively in Section IV-A but performs no analysis of what changes in the model's outputs at high depths — do action predictions become more erratic? Does the scratchpad diverge from the Prelude foundation? Does the Coda become sensitive to small scratchpad perturbations?

Mitigation status. Partial. The paper acknowledges this limitation explicitly in Section V and frames it as an open problem:

"Addressing this problem—perhaps through architectural innovations or specific training protocols—remains an open challenge for scaling latent reasoning in robotics."

However, the paper proposes no specific hypotheses for why degradation occurs and conducts no diagnostic experiments (e.g., measuring scratchpad stability at different depths, monitoring attention patterns, testing whether the Prelude's grounding signal weakens over long unrolls). The Input Injection mechanism was designed to prevent representational collapse, so the fact that degradation still occurs suggests either that Input Injection is insufficient at extreme depths, or that a different failure mode (not representational drift) is responsible. Distinguishing between these would require experiments the paper does not perform.

---

6.4 The Approach Has Only Been Demonstrated on a Single 0.5B Backbone and Two Simulation Benchmarks, With No Evidence of Scaling Behavior Across Model Sizes

The assumption or constraint. All experiments — simulation and real-world — use a single backbone: Qwen2.5-0.5B fine-tuned via LoRA following the MiniVLA recipe. The paper explicitly acknowledges this in Section V:

"We emphasize that these results were obtained with minimal hyperparameter tuning and a relatively small backbone (0.5B parameters). We expect that scaling this architecture to larger backbones and training on more diverse datasets will yield significant performance gains."

The evaluation is conducted on two simulation benchmarks (LIBERO and CALVIN) representing tabletop manipulation with a Franka Panda arm (LIBERO) and a Franka Emika Panda arm (CALVIN) in relatively structured environments. Real-world experiments use a single bimanual YAM manipulator across four household tasks.

The consequence. The paper provides no evidence that the benefits of recurrent depth scale with backbone size. Several possibilities exist, and the paper cannot distinguish among them:

• Diminishing returns: Larger backbones may already encode scene understanding more thoroughly in their final-layer representations, leaving less room for iterative refinement to improve. If a 7B backbone achieves 85% at N_inf = 1 (vs. 8.4% for 0.5B), the relative gain from recurrence might shrink substantially.
• Compounding gains: Larger backbones may produce richer mid-layer features for the Prelude and more informative final-layer features for the Recurrent Core, amplifying the benefit of recurrence. The 80× speedup advantage over token-reasoning methods might grow as backbone size increases (since recurrent refinement cost grows linearly with hidden dimension, while autoregressive decoding cost grows with both hidden dimension and sequence length).
• Qualitatively different behavior: The saturation depth (when performance plateaus) and degradation depth (when performance declines) may shift with backbone size. A 7B model might saturate at N_inf = 4 rather than N_inf = 12, or might not degrade at N_inf = 64 because the larger hidden dimension provides more capacity for stable refinement.

Without scaling experiments, the paper's claim that the architecture "provides a scalable path to test-time compute in robotics" (Abstract) is an architectural hypothesis rather than an empirically demonstrated scaling law. A practitioner considering whether to invest in scaling RD-VLA to a larger backbone cannot estimate the expected return.

Similarly, the evaluation domain is narrow: tabletop manipulation with rigid objects in visually simple environments. The paper provides no evidence about whether recurrent depth helps for mobile manipulation, deformable object manipulation (beyond towel folding), contact-rich tasks requiring force feedback, or tasks in visually cluttered or dynamically changing environments. The claim that "different tasks might have different optimal iteration counts" (Section IV-B) is demonstrated only within the LIBERO task distribution — the variation in optimal depth across qualitatively different task families (e.g., grasping vs. assembly vs. navigation) is unknown.

What evidence exists in the paper. All experiments in Section IV use the 0.5B backbone. Table I compares against 7B-parameter baselines but does not include an RD-VLA variant at 7B parameters. The MiniVLA baseline (same 0.5B backbone, same training recipe, no recurrence) achieves 71.2% on LIBERO-10, establishing a within-backbone ablation, but this isolates the architectural contribution at a single scale. The real-world experiments (Figure 7) partially address the domain generalization concern but use the same 0.5B backbone and do not test adaptive stopping with threshold tuning per task.

Mitigation status. The paper acknowledges the single-backbone limitation transparently in Section V and frames it as a scope choice rather than a technical flaw: "Our primary objective was to investigate latent iterative reasoning in robotic control, rather than to hyper-optimize a specific model for state-of-the-art dominance." This is a reasonable position for a first paper introducing a new architectural paradigm. However, the claim that scaling "will yield significant performance gains" is speculative without supporting evidence. The paper suggests "exploring the scaling laws of latent recurrence" as future work but does not commit to or outline such experiments.

---

6.5 The Uncertainty Quantification Claim Is Aspirational — No Evidence Links Latent Convergence to Success/Failure Prediction

The assumption or constraint. A central capability claim for RD-VLA is that the recurrent architecture inherently provides uncertainty quantification through latent convergence dynamics. Section III-C frames the KL-divergence stopping criterion as a mechanism for the model to "self-regulate." Section V expands this to safety applications:

"the system could autonomously halt execution or request operator assistance if the variance between recurrent states exceeds a safety threshold"

The paper presents this as an architectural capability — something the recurrent design enables — and the Conclusion describes the model's "capacity to measure its own uncertainty through latent convergence."

The consequence. For a practitioner deploying RD-VLA in a safety-critical setting (e.g., a robot operating near humans), the ability to detect when the model is uncertain and fall back to safe behavior is arguably more important than raw success rate. However, the paper provides no evidence that convergence depth actually predicts task failure. The only related evidence is that early stopping (loose thresholds like τ = 1×10⁻²) causes failures by truncating deliberation — but this is different from showing that, when the model is allowed to run to convergence, states that converge slowly are more likely to result in failure. The two scenarios are logically distinct:

• Scenario A (tested): Forcing the model to stop before it has converged → higher failure rate. This shows that deliberation is necessary for performance but does not show that slow convergence indicates uncertainty — it shows that insufficient computation is harmful.
• Scenario B (not tested): Allowing the model to converge fully, then measuring whether states with higher convergence depths have higher failure rates. This would test whether slow convergence signals genuine uncertainty (the model is correct to deliberate longer but still might fail) versus task complexity that the model can resolve given enough computation.

Without testing Scenario B, the claim that convergence depth is an "uncertainty signal" conflates computational difficulty (the model needs more iterations to settle) with epistemic uncertainty (the model is likely to be wrong even after settling). A state might require 20 iterations to converge because it is complex but still result in a correct action, while another state might converge in 4 iterations because the model is confidently wrong (producing a consistent but incorrect action). The paper's adaptive execution strategies (Threshold-Based, Linear Decay) implicitly assume the former — that slow convergence = uncertain = should execute fewer actions — but never validate that slow-converging states actually produce more failures when executed.

What evidence exists in the paper. The adaptive stop experiments (Table II) demonstrate that early truncation degrades performance, particularly on Long-horizon tasks (85.8% at τ = 5×10⁻⁴ with k̄ = 7.93 vs. 61.8% at τ = 5×10⁻³ with k̄ = 4.27). Figure 6 shows that exit depth distributions vary across task categories, but reports only means — there is no correlation analysis between convergence depth per episode and episode success/failure. The real-world results (Figure 7) provide circumstantial evidence: the adaptive variant underperforms fixed depth on towel folding (the hardest task), which could indicate that towel folding requires sustained deliberation that per-step convergence checks prematurely truncate. However, this could equally indicate that the threshold τ was poorly calibrated for the real-world domain rather than that convergence depth fails to capture uncertainty.

Mitigation status. Not addressed, beyond explicit flagging that the capability exists in principle:

"While we demonstrated the viability of these mechanisms, the design space for such interventions is vast. We leave the specific implementation of such mechanisms to future work, focusing here on the architectural foundation that makes them possible." (Section V)

This is a reasonable scope limitation for an architecture paper — demonstrating that the mechanism could work is different from demonstrating that it does work for uncertainty quantification. However, the paper's framing (particularly in the abstract and conclusion) implies a stronger claim about self-assessing capability than the evidence supports. A simple analysis — reporting success rates conditioned on convergence depth, or plotting a calibration curve — would have bridged this gap substantially.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a new training objective, a new dataset, or a new pretraining recipe — it introduces a new architectural primitive for visuomotor policies: the weight-tied recurrent transformer core operating on a continuous latent scratchpad. The contribution is best understood as a reframing of what "reasoning" means for robotic control, moving it from the discrete output space (token generation) to the continuous latent space (iterative representation refinement). This is not an incremental improvement over Chain-of-Thought — it is a category shift with different scaling properties (constant memory, non-autoregressive computation, emergent convergence dynamics) that make it suitable for high-frequency closed-loop control in a way that token-level reasoning never was.

The magnitude of this shift within the VLA subfield is substantial but bounded. It is substantial because it opens a design space that was previously empty: variable-depth deliberation without the memory and latency penalties of autoregressive decoding. Table I demonstrates that this design space is not merely theoretically interesting but practically superior — a 0.5B RD-VLA outperforms 7B token-reasoning models by 3–8 percentage points on LIBERO-10. It is bounded because the paper demonstrates the approach on a single backbone family, a single class of manipulation tasks (tabletop pick-and-place and simple long-horizon sequences), and with the acknowledged limitation that performance saturates and degrades at extreme depths. The paper does not claim to have solved all problems — it claims to have identified a viable architectural mechanism for adaptive test-time compute that was previously absent from the VLA literature.

The paper resolves a specific tension that has been accumulating across several lines of work. The dynamic inference community (DeeR-VLA, VLA-Cache) demonstrated that not all control steps need the same computation, but their mechanisms could only scale compute down — early-exiting from a fixed-depth backbone. The token-reasoning community (ThinkAct, MolmoAct, ECoT) demonstrated that explicit deliberation improves performance, but at the cost of linearly growing memory and autoregressive decoding latency that made real-time deployment challenging. RD-VLA shows that these two desiderata — adaptive compute and deep deliberation — are not fundamentally in tension. They can be achieved simultaneously through latent recurrence. This is a unifying architectural insight, not merely a new point on the accuracy-vs-latency Pareto frontier.

The paper also redirects research attention in a specific way. Prior work on efficient VLAs focused overwhelmingly on reducing the cost per forward pass — pruning, caching, distillation, early-exiting. This paper argues that the more important variable is how many forward passes to perform, and that the right architecture can make this variable self-regulating. If this argument is persuasive, it shifts research investment from backbone optimization toward recurrent head design, convergence analysis, and depth-adaptive execution strategies. This is a reframing of the efficiency problem: it is not about making each pass cheaper, but about making pass count adapt to need.

The biological framing (Section I, recurrent neural dynamics in human cognition) is more than rhetorical ornament. It provides a concrete design principle: reuse the same circuitry iteratively rather than building deeper feedforward hierarchies. The paper operationalizes this principle in a transformer architecture and demonstrates that it works for robotic control. Whether this principle generalizes to other sensorimotor domains (legged locomotion, dexterous in-hand manipulation, autonomous driving) is an open empirical question, but the paper provides the first affirmative evidence that it is worth investigating.

A subtler but important contribution is the democratization of test-time compute scaling. Token-reasoning approaches require curated CoT datasets — expensive, domain-specific, and often ambiguous for physical tasks. RD-VLA's training requires only behavior cloning on action sequences, with no reasoning supervision. The randomized recurrence and TBPTT training procedure teach the model that refinement is possible without specifying how to reason. This means the same training recipe can in principle be applied to any manipulation dataset with action labels, dramatically lowering the barrier to entry for compute-scaling VLAs. The paper does not emphasize this point, but it is a significant practical implication: a lab with action-labeled demonstration data but no CoT annotations can train an RD-VLA today.

Follow-Up Research This Work Enables

Scaling laws of latent recurrence across backbone sizes and task families. The paper demonstrates that recurrent depth improves performance on a 0.5B backbone for LIBERO tasks, with gains saturating around 8–12 iterations and degrading at ~24–32. A natural follow-up would systematically vary backbone size (0.5B, 1.5B, 3B, 7B) and measure how the scaling curve changes. The central question: does the optimal depth shift with backbone capacity? A larger backbone with richer single-pass representations might saturate earlier (at $N_{inf}=4$ instead of $N_{inf}=8$), making recurrence less valuable, or it might benefit more from recurrence because the richer representations provide a better foundation for refinement. A secondary question: does the degradation at extreme depths ($N_{inf}=32$) persist at larger scales, or does the increased hidden dimension provide more representational capacity for stable long unrolls? This experiment would produce the first scaling laws for latent recurrence in VLAs — an essential resource for practitioners deciding whether to scale backbone size or recurrence depth given a fixed compute budget.

Diagnostic analysis of performance degradation at $N_{inf} > 24$. The paper identifies that fixed recurrence beyond ~24 iterations causes a performance decline (from 93.1% at $N_{inf}=24$ to 92.1% at $N_{inf}=32$ on LIBERO overall, with a more pronounced drop on Long-horizon tasks from 86.6% to 84.4%) but provides no explanation for why. A diagnostic follow-up would instrument the Recurrent Core at each iteration to measure: (1) the cosine similarity between $S_k$ and $S_{pre}$ (to test whether representational drift away from the grounded foundation is occurring despite Input Injection), (2) the norm of the scratchpad activations (to test for exploding or vanishing representations), (3) the entropy of the self-attention and cross-attention distributions (to test for attentional collapse where the model attends to fewer and fewer tokens), and (4) whether the Coda's sensitivity to small scratchpad perturbations increases at high depths (if the Coda amplifies noise in slightly degraded scratchpad states). The result would distinguish between competing hypotheses: representational collapse (scratchpad diverges from useful representations despite Input Injection), over-refinement (scratchpad converges to an attractor that minimizes the training loss but produces worse actions — analogous to verifier over-optimization in language model search), or Coda sensitivity (the Coda was trained on scratchpads from a range of depths but becomes unreliable when the scratchpad distribution at extreme depths differs from the training distribution). Each hypothesis points to a different mitigation: stronger grounding, regularization during training, or Coda-specific fine-tuning at extreme depths.

Uncertainty quantification validation: does convergence depth predict failure? The paper claims that latent convergence serves as an uncertainty signal capable of triggering safety interventions, but provides no evidence linking convergence depth to episode success/failure. A direct follow-up would run RD-VLA with adaptive stopping at a reasonably tight threshold (e.g., τ = 1×10⁻⁴) on LIBERO and record, for each evaluation episode, the convergence depth at each step and whether the episode ultimately succeeded. The analysis would answer: (1) Do states that converge slowly have a higher empirical failure rate than states that converge quickly, conditioning on the action being executed (rather than truncated)? This tests whether convergence depth is a calibrated uncertainty signal. (2) What is the AUROC for predicting step-level failure from convergence depth alone? This quantifies the signal quality. (3) Is there a threshold depth above which failures become substantially more likely, suggesting a "danger zone" for adaptive execution? If convergence depth is a poor predictor of failure (i.e., slow-converging states are often complex but ultimately solved correctly), then the adaptive execution strategies that reduce horizon for slow-converging states may be safety-harmful rather than safety-beneficial — they reduce the robot's ability to execute coherent plans precisely when the plan matters most. This follow-up would either validate a key claimed capability or identify a critical limitation that redirects research toward explicit uncertainty estimation rather than relying on emergent convergence dynamics.

Combining latent recurrence with explicit token reasoning for hierarchical deliberation. The paper's architecture performs refinement entirely in latent space, but there is no fundamental reason why a VLA could not combine latent refinement with occasional token-level reasoning. A hybrid architecture might use the Recurrent Core for continuous spatial and motion planning (where tokenization is inherently lossy and latency-sensitive), then produce a small number of reasoning tokens only at key decision points — for example, when the model needs to disambiguate between two visually similar objects ("the red block on the left") or when it needs to query semantic knowledge that the VLM backbone encodes in language but not vision ("a bowl is a container for liquids"). The recurrent depth could be modulated to produce more refinement before these explicit reasoning steps and fewer afterward. This would test whether the information bottleneck of tokenization is the primary limitation or merely one of several — if hybrid models outperform pure-latent and pure-token approaches, the bottleneck is not binary but graded. The experiment would require constructing tasks where token-level semantic disambiguation is clearly necessary (e.g., tasks with ambiguous language instructions like "pick up the container" when multiple containers are present), measuring whether latent refinement alone can resolve the ambiguity, and adding explicit reasoning tokens only when latent convergence stalls at high depth without action stabilization.

Domain transfer of the convergence threshold across embodiments and action spaces. The paper sweeps τ on LIBERO and selects 5×10⁻⁴ as optimal, but this threshold depends on action magnitudes in the LIBERO action space (typically 7-DoF end-effector control with specific position and rotation scales). When deploying RD-VLA on a new robot with different action dimensions (e.g., joint-space control with 6-DoF or higher), different action magnitudes (e.g., mobile base commands in meters vs. gripper commands in millimeters), or different observation noise characteristics, the optimal τ will shift. A follow-up would systematically vary action-space properties — dimensionality, magnitude scaling, noise level — and measure how the optimal τ changes. The goal is a calibration procedure: given a few rollout episodes on the target robot with fixed-depth RD-VLA, can one estimate the appropriate τ for adaptive stopping without a full hyperparameter sweep? For example, can the variance of consecutive action differences at a fixed depth ($\| \mathbf{a}_8 - \mathbf{a}_7 \|^2_2$) be used to set τ as a percentile of that variance distribution? A successful calibration procedure would make adaptive stopping deployable without task-specific tuning, which is the barrier the paper's test-set tuning leaves unaddressed.

Safety-guaranteed adaptive execution with formal bounds on worst-case behavior. The paper's adaptive execution strategies (Threshold-Based and Linear Decay) reduce the action horizon when convergence is slow, based on the intuition that uncertain states merit more frequent replanning. However, this intuition has no formal safety guarantee — if the model converges slowly and the execution horizon is reduced to $H_{short}$, the robot still executes some actions under uncertainty, and those actions might be catastrophic. A follow-up would investigate whether the convergence signal can be used for stronger interventions: (1) zero-horizon halting: if convergence exceeds a critical threshold $\tau_{crit}$, execute zero actions and request human teleoperation or fall back to a conservative recovery policy; (2) convergence-rate monitoring: if the per-iteration reduction in $\| \mathbf{a}_k - \mathbf{a}_{k-1} \|^2_2$ stalls (the model is oscillating rather than converging), trigger an intervention even if the absolute convergence criterion would eventually be met; (3) action-space clamping: restrict the action magnitude when convergence depth is high, preventing large, potentially unsafe motions in uncertain states. The experiment would measure safety (collision rate, task-damaging action rate) vs. task completion rate as a function of the intervention policy, on tasks where unsafe actions have clear negative consequences (e.g., manipulation near fragile objects, high-speed motions near workspace boundaries). This would transform the uncertainty signal from a soft efficiency mechanism into a hard safety mechanism — a critical step for real-world deployment.

Practical Applications and Downstream Use Cases

On-device deployment of capable manipulation policies on compute-constrained robot hardware. The paper's 0.5B backbone with ~8 recurrent iterations represents a total parameter count and per-step FLOPs budget that is feasible on embedded GPU hardware (e.g., NVIDIA Jetson Orin) rather than requiring a datacenter-grade GPU. A factory robot performing repetitive pick-and-place of known objects could deploy RD-VLA with fixed $N_{inf}=4$ (84.1% average success on LIBERO) for routine operations and switch to adaptive mode ($N_{inf}$ up to ~12) when operating near clutter or with novel object configurations. The constant memory footprint means the deployment does not need to provision for variable context lengths — a significant advantage for safety-certified systems where worst-case memory allocation must be guaranteed. The 34% compute reduction from adaptive stopping (7.93 vs. 12.0 iterations at matched performance) translates directly to longer battery life for mobile manipulators or higher throughput for stationary pick-and-place cells.

Data-efficient fine-tuning for custom manipulation tasks. Because RD-VLA's training requires only action-labeled demonstrations (no CoT annotations), a practitioner with a new manipulation task can collect 50–200 demonstrations and fine-tune the action head (Prelude, Recurrent Core, Coda) while keeping the VLM backbone frozen or LoRA-tuned. The randomized recurrence training ensures the fine-tuned model learns a refinement operator specific to the new task without the practitioner needing to decide the appropriate inference depth — the depth can be set adaptively based on the convergence dynamics that emerge during fine-tuning. This contrasts with token-reasoning methods, where adding a new task would require either collecting explicit reasoning traces (expensive) or hoping the pre-trained reasoning generalizes (unreliable). The paper's results on LIBERO long-horizon tasks (86.6% peak) and real-world tasks (75–98% across four household activities) suggest the approach transfers to new task families with the same backbone, supporting the fine-tuning scenario.

Uncertainty-aware shared autonomy with human-in-the-loop intervention. In telerobotic or assistive robotics settings where a human operator supervises or intermittently controls the robot, RD-VLA's convergence depth could serve as a trigger for requesting human attention. The operator monitors multiple robots simultaneously; when a robot's convergence depth exceeds a calibrated threshold (indicating the scene is complex or ambiguous), the system flags that robot for operator review. The operator can then either approve the planned action, provide a corrective demonstration, or take over control. The key advantage over fixed-depth policies is that the system only interrupts the operator when genuinely uncertain, rather than on a fixed schedule — reducing operator cognitive load. The paper's demonstration that convergence depth varies systematically with task difficulty (Figure 6: Spatial > Object > Goal) and with per-step complexity (Figure 3 case study: 14 iterations for grasping vs. 7–9 for placement) provides preliminary evidence that this signal could be calibrated for attentional triage. A safety threshold could be set conservatively (e.g., flag when convergence depth exceeds the 95th percentile of depths observed during successful demonstrations), ensuring that the operator sees only states that are genuinely atypical.

When to Prefer This Method

The paper explicitly positions RD-VLA against two alternative paradigms (end-to-end VLAs and token-reasoning VLAs) and articulates the tradeoffs in architectural terms rather than as a task-specific decision rule. The preference conditions can be extracted directly from the paper's claims and experimental design:

• Prefer RD-VLA when (a) the deployment hardware is compute-constrained and cannot run a 7B+ backbone at real-time control frequencies, (b) the task distribution includes a mix of simple and complex manipulation steps where fixed-depth computation would be wasteful on easy steps, (c) memory footprint per control step must be constant and predictable (the recurrent scratchpad is fixed-size regardless of depth), and (d) curated CoT reasoning data for the target domain is unavailable or expensive to collect. The paper's evidence supports these conditions: 0.5B parameters outperforms 7B token-reasoning models (Table I), adaptive stopping reduces compute by 34% on heterogeneous task distributions (Table II), and training requires only action labels with no reasoning supervision (Section III-B.3).

• Prefer token-reasoning VLAs when the task requires explicit semantic reasoning that is naturally expressed in language — for instance, following multi-step natural language instructions with logical dependencies ("if the drawer is closed, open it first, then place the object inside") or tasks where the relevant knowledge is encoded in the VLM's language capabilities but not its visual representations. The paper's latent reasoning operates entirely in the continuous representation space and may not have direct access to the VLM's language-modality knowledge — the cross-attention to final-layer VLM features includes latent tokens but not explicit language decoding. Token-reasoning methods that decode to text and then re-encode can explicitly invoke language-grounded reasoning. The paper does not test tasks requiring this capability, so the relative performance on language-heavy reasoning is unknown.

• Prefer end-to-end VLAs when the task distribution is uniformly simple (all tasks solvable at $N_{inf}=1$ or $N_{inf}=2$), in which case the recurrent head's additional computation provides no benefit and adds engineering complexity. The paper's Object tasks reach 93.0% at $N_{inf}=4$ and saturate thereafter; if an application consists exclusively of such tasks, a standard fixed-depth VLA with an MLP action head may be simpler to deploy, debug, and maintain, with identical performance. The paper provides no evidence that RD-VLA harms performance on simple tasks at low depth (Table II shows monotonic improvement from $N_{inf}=1$ to $N_{inf}=4$ on all suites), so the preference is based on engineering simplicity rather than capability.