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

Yalcin Tur; Jalal Naghiyev; Haoquan Fang; Wei-Chuan Tsai; Jiafei Duan; Dieter Fox; Ranjay Krishna

Source-linked AI summary

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

Yalcin Tur, Jalal Naghiyev, Haoquan Fang, Wei-Chuan Tsai, Jiafei Duan, Dieter Fox, Ranjay Krishna

arXiv:2602.07845v1Feb 8, 2026cs.RO

TL;DR

Fixed-depth VLA models and token-level reasoning do not provide an efficient way to adapt computation for continuous robotic control. RD-VLA uses weight-tied recurrent refinement in latent space, trained with TBPTT and stopped adaptively at convergence. Its recurrent depth improves performance substantially while preserving competitive adaptive results and reducing the need for token-based reasoning.

Problem
VLA models commonly use fixed computational depth, while token-level reasoning introduces output-space bottlenecks for continuous robotic control.
Method
RD-VLA uses a weight-tied recurrent action head for latent iterative refinement, with TBPTT training and convergence-based adaptive stopping at inference.
Results
93.0% success on LIBERO with fixed recurrence and 92.5% with uncertainty-based adaptive computation show strong performance across the evaluated tasks.
Takeaways & Limitations
Recurrent latent refinement enables test-time compute scaling, with performance rising from 8.4% at one iteration to 84.1% at four and 92.6% at eight.
Takeaways & Limitations
The demonstrated system uses a relatively small 0.5B-parameter backbone, and scaling to larger backbones and more diverse datasets remains future work.

Abstract

from arXiv · show

Current Vision-Language-Action (VLA) models rely on fixed computational depth, expending the same amount of compute on simple adjustments and complex multi-step manipulation. While Chain-of-Thought (CoT) prompting enables variable computation, it scales memory linearly and is ill-suited for continuous action spaces. We introduce Recurrent-Depth VLA (RD-VLA), an architecture that achieves computational adaptivity via latent iterative refinement rather than explicit token generation. RD-VLA employs a recurrent, weight-tied action head that supports arbitrary inference depth with a constant memory footprint. The model is trained using truncated backpropagation through time (TBPTT) to efficiently supervise the refinement process. At inference, RD-VLA dynamically allocates compute using an adaptive stopping criterion based on latent convergence. Experiments on challenging manipulation tasks show that recurrent depth is critical: tasks that fail entirely (0 percent success) with single-iteration inference exceed 90 percent success with four iterations, while simpler tasks saturate rapidly. RD-VLA provides a scalable path to test-time compute in robotics, replacing token-based reasoning with latent reasoning to achieve constant memory usage and up to 80x inference speedup over prior reasoning-based VLA models. Project page: https://rd-vla.github.io/

I. INTRODUCTION

Existing VLA models typically use fixed computation or token-level reasoning, limiting adaptive deliberation for continuous robotic control. RD-VLA instead performs recurrent latent refinement with adaptive inference depth, achieving strong benchmark performance and faster reasoning-oriented control.

Most VLAs apply the same computational depth to simple adjustments and complex manipulation, despite task difficulty varying substantially.
Reasoning-centric VLAs commonly generate textual, visual, or coordinate-based intermediate outputs, tying deliberation to token-level representations.
Output-space reasoning repeatedly projects continuous latent states into discretized outputs, introducing information bottlenecks and quantization noise.
RD-VLA differs from diffusion policies by refining internal representations rather than merely denoising an action trajectory in output space.
RD-VLA recursively updates hidden states through a weight-tied recurrent block, enabling arbitrarily deep latent computation with constant memory.
93.0% success on LIBERO and 92.5% with uncertainty-based adaptive computation demonstrate strong performance with dynamically allocated inference.

B. Reasoning and Efficient-Compute VLA Models

Efficient-compute VLA research combines backbone optimization, dynamic resource allocation, and explicit reasoning. Recurrent and latent-space approaches aim to vary inference effort without relying on expensive output-token generation.

VLA efficiency work targets the tradeoff between computational demand and real-time robotic control through backbone optimization and structured reasoning.
Dynamic-resource methods include distillation, adaptive token caching, and selectively activated model segments to reduce redundant or unnecessary computation.
Explicit-reasoning VLAs use textual justifications, visual traces, or latent planning to improve spatial-temporal reasoning and action generation.
RD-VLA contrasts with prior reasoning VLAs by refining representations in latent space instead of autoregressively generating reasoning tokens.
Recurrent Transformers reuse layers so computation can be increased at inference and internal representations can support uncertainty-based adaptive compute.
A LIBERO rollout uses 7–9 iterations for navigation or placing and about 14 iterations for more complex grasping actions.

III. METHOD

RD-VLA decouples inference depth from the pretrained VLM by placing computation in a weight-tied recurrent transformer core operating on continuous latent representations. Its modular action head uses VLM features and learned latent states to iteratively refine actions.

RD-VLA shifts computational depth from a fixed VLM head to a weight-tied recurrent transformer core operating within a continuous latent manifold.
The framework is backbone-agnostic and can integrate with any VLM that produces dense latent representations.
The VLM execution produces task/vision representations for spatial and semantic scene information and latent-specific representations for compressed task-aligned features.
At each iteration, the recurrent head cross-attends to concatenated visual, latent, and proprioceptive context to ground latent reasoning.

B. Recurrent-Depth Architecture

RD-VLA decouples computational depth from fixed VLA backbones by using a weight-tied recurrent transformer core that iteratively refines latent states. A Prelude grounds learned queries in visual features, while persistent input injection preserves task information throughout recurrence.

RD-VLA partitions computation into a Prelude, Recurrent Core, and Coda, moving adaptive depth into a weight-tied recurrent transformer core.
Prelude: The Prelude transforms K = 8 learned queries through bidirectional self-attention and cross-attention over middle-layer visual features.
Latent scratchpad: A high-entropy truncated-normal scratchpad initialization provides the evolving latent state for iterative reasoning.
Recurrent Core: At every recurrent step, the model concatenates the current scratchpad with the fixed Prelude foundation before updating the state.
Recurrent Core: The recurrent block applies bidirectional self-attention across K queries and gated cross-attention to task-aligned latent tokens, vision tokens, and proprioception.

2) Coda and Action Projection:

After recurrent refinement reaches the selected depth, the Coda decodes the converged latent scratchpad and projects it into the robot’s action space.

The non-recurrent Coda performs the final decoding pass, moving the converged representation out of the latent manifold while attending to VLM features.
An output projection layer maps the refined features to the robot’s action space.
Wout is the final linear layer that produces the control commands a.

3) Training with Randomized Recurrence:

RD-VLA trains recurrence for stable refinement across variable depths using randomized iteration counts and truncated backpropagation. At inference, action-distribution convergence determines when the model stops refining.

Training samples the iteration count N from a heavy-tailed log-normal Poisson distribution, with µrec = 32, to promote depth-independent convergence.
TBPTT propagates gradients through only the final d = 8 iterations while detaching earlier steps.
This training procedure teaches the network to refine noisy initializations toward a stable manifold without retraining for different inference depths.
Inference estimates convergence through the KL divergence between consecutive action distributions, approximated by MSE in action space.
With a threshold such as δ = 1e−3, the loop stops when successive predicted action chunks converge, allocating less compute to trivial movements and more to complex situations.

D. Adaptive Execution

Adaptive execution couples reasoning depth to action-horizon length: deeper recurrence signals higher uncertainty, so the policy executes shorter horizons and replans more frequently. The evaluation spans simulation benchmarks and real-world manipulation, comparing end-to-end, token-reasoning, and latent-reasoning VLAs.

Deep recurrence, defined here as k∗> 8, often corresponds to high uncertainty, making long-horizon execution risky because initial-plan errors compound.
The proposed adaptive-execution strategies couple reasoning depth with the number of actions executed.
Threshold-Based Adaptive Execution: Threshold-based execution uses Hshort when convergence requires k∗> τ and Hlong when convergence occurs at k∗≤τ.
Linear Decay Execution: Linear-decay execution reduces Hexec by one step for every additional iteration beyond the base convergence budget, forcing more frequent replanning.
Evaluation: The evaluation uses LIBERO and CALVIN for simulation and a bimanual YAM manipulator for real-world assessment across recurrence scaling, adaptive compute, baselines, and physical robustness.
Evaluation: The LIBERO comparison distinguishes end-to-end VLAs, token-reasoning VLAs, and latent-reasoning VLAs using recurrent latent-space refinement before action emission.

A. Performance Scaling via Recurrent Computation

RD-VLA performance improves sharply as recurrent depth increases, then saturates, while individual tasks converge at different iteration counts. These profiles support task-dependent allocation of recurrent computation.

Aggregate scaling: 93.1% peak success is achieved at N_inf = 24 after performance rises from 8.4% at one iteration to 92.6% at eight.Performance saturates between 8 and 12 iterations, with diminishing returns beyond 12.
Task-dependent convergence: Different tasks exhibit distinct convergence profiles, indicating different computational requirements.The paper presents these profiles as evidence that required depth depends on task complexity.
Task-dependent convergence: Task 4 reaches near-perfect performance with two iterations, whereas Task 5 requires three or more iterations before meaningful success.The selected Long tasks show that optimal iteration counts vary across tasks.
Aggregate scaling: Performance across LIBERO task categories improves with increased computational depth and converges between 8–12 iterations on average.The figure summarizes the aggregate trend across benchmark categories.

C. Adaptive Computation Strategies

RD-VLA’s adaptive strategies preserve fixed-depth performance while reducing inference cost by allocating recurrent steps according to the current state. Binary Adaptation provides the strongest reported efficiency–performance balance, although strategies perform similarly at matched budgets.

Adaptive efficiency: 92.5% success with 7.93 mean iterations matches the 93.0% fixed-recurrence peak while reducing compute by 34%.This result is reported for Binary Adaptation with τ = 5 × 10^-4.
Condition-dependent allocation: Adaptive computation adjusts recurrent steps based on the difficulty of the current state.The adaptive exits are distributed across task categories rather than using one fixed depth.
Strategy comparison: All three adaptive strategies perform comparably at matched compute budgets, making condition-dependent allocation more central than the specific stopping criterion.Binary Adaptation with τ = 5 × 10^-4 achieves the best reported efficiency–performance balance.

D. Performance against Other Baselines

RD-VLA outperforms prior methods on LIBERO and achieves the highest reported CALVIN average chain length, while adaptive and real-world variants retain competitive performance. Real-world evaluation supports dynamic computation but includes a performance trade-off on complex manipulation tasks.

LIBERO comparison: 93.0% LIBERO success outperforms the Fast-ThinkAct baseline at 89.7%, using a model with 0.5B parameters.The adaptive variant reaches 92.5% while retaining dynamic-compute benefits.
CALVIN comparison: 3.39 average chain length on CALVIN ABC→D exceeds OpenVLA’s 3.27.The benchmark evaluates long-horizon task chaining.
Real-world evaluation: RD-VLA variants consistently outperform π0.5 and Diffusion Policy across the evaluated real-world tasks.The fixed 8-iteration model achieves near-perfect dish-wiping performance.
Real-world evaluation: The adaptive real-world variant matches or closely trails the fixed strategy while achieving the highest cube-placement score.It slightly trades off performance on complex tasks such as towel folding.

V. DISCUSSION AND LIMITATIONS

RD-VLA demonstrates latent iterative reasoning for adaptive robotic control while leaving several scaling and intervention questions open. The discussion emphasizes competitive results with minimal tuning, depth-generalization limits, and future uncertainty-aware extensions.

Scope: The study prioritizes investigating latent iterative reasoning over hyper-optimizing state-of-the-art benchmark performance.Reported results use minimal hyperparameter tuning and a relatively small 0.5B-parameter backbone.
Limitations: Depth generalization is bounded: recurrence beyond an optimal iteration count may cause state saturation or performance degradation.Addressing this boundary through architectural innovations or training protocols remains open.
Future work: Recurrent state dynamics can serve as uncertainty proxies for adaptive computation or uncertainty-aware execution.The paper suggests halting execution or requesting operator assistance when recurrent-state variance exceeds a safety threshold, while leaving implementation for future work.
Future work: Future work could combine recurrent depth with per-token modulation to complement Chain-of-Thought reasoning in embodied agents.This direction addresses latency and memory limitations of token-based reasoning while retaining a potential role for CoT.
Contributions: RD-VLA shifts robotic reasoning into continuous latent space and achieves test-time compute scaling without autoregressive Chain-of-Thought memory and latency overhead.The architecture uses recurrent iterations to refine internal state and supports longer computation for harder tasks.