Agents2026~113 minarXiv:2601.09708

Fast-ThinkAct: Efficient Vision-Language-Action Reasoning via Verbalizable Latent Planning

score 3Chi-Pin Huang, Yunze Man, Zhiding Yu +4NVIDIA↑ 53Jan 14, 2026cs.CV

🎯 Pitch

Reasoning VLAs that think before acting are too slow for real robots, but Fast-ThinkAct compresses lengthy textual reasoning into just 6 latent tokens and still outperforms the full-text teacher. By distilling with both preference-guided alignment and action-level visual plan matching, it slashes inference latency by up to 89.3% while boosting manipulation success rates—making embodied reasoning actually practical.

1. Executive Summary

Fast-ThinkAct introduces an efficient reasoning framework for Vision-Language-Action (VLA) tasks that compresses lengthy textual chain-of-thought traces into compact continuous latent representations through verbalizable latent reasoning. The system distills reasoning from a textual teacher VLM trained with GRPO into a latent student VLM via preference-guided distillation (using DPO-style optimization to align latents with high-quality reasoning traces and suppress low-quality ones) and action-aligned visual plan distillation (minimizing L2 distance between teacher and student hidden states at the visual planning token), then bridges these latent plans to action execution through reasoning-enhanced policy learning. Using Qwen2.5-VL 3B as the backbone and evaluated across LIBERO, SimplerEnv, RoboTwin2.0, and three embodied reasoning benchmarks (EgoPlan-Bench2, RoboVQA, OpenEQA), Fast-ThinkAct achieves up to 89.3% inference latency reduction over state-of-the-art 7B reasoning VLAs—specifically, 805 ms versus 7513 ms for ThinkAct-7B—while improving success rates on LIBERO from 84.4% to 89.7%, establishing that compact latent reasoning preserves and even enhances planning capabilities only when the latent representations are grounded through both preference-aligned verbalization and trajectory-level visual alignment.

2. Context and Motivation

The Core Problem: Reasoning VLAs Are Too Slow for Real-World Deployment

The paper tackles a practical bottleneck that has emerged at the intersection of embodied AI and large language model reasoning: Vision-Language-Action models that reason explicitly before acting are dramatically more capable than their non-reasoning counterparts, but their inference latency makes them unusable for real-time robotic control.

This tension is acute because it pits two hard-won capabilities against each other. On one hand, reasoning VLAs—models that generate intermediate chain-of-thought traces before predicting actions—demonstrate substantially better generalization on long-horizon tasks, better adaptation to novel scenarios, and the ability to self-correct from failures (Huang et al., 2025; Zawalski et al., 2024; Zhao et al., 2025). These are precisely the capabilities that have been missing from foundation VLAs, which excel at routine pick-and-place but struggle beyond their training distributions (Section 1). On the other hand, embodied AI applications impose real-time constraints that text-generation-heavy reasoning models violate by orders of magnitude: robotic manipulation and autonomous driving require decision frequencies of 1–15 Hz, while reasoning VLAs that generate verbose textual CoTs operate at roughly 0.1 Hz (Section 1)—a roughly 10–150× mismatch.

The paper frames this as not just an inconvenience but a genuine deployment blocker with safety implications. In Section 1, the authors explicitly connect latency to safety:

"generating lengthy reasoning traces can take several seconds per decision... creating a critical bottleneck that limits real-time performance and poses safety risks in time-critical scenarios"

This is a fundamentally different challenge than the one addressed by prior reasoning VLA work. Those papers (ThinkAct, Embodied CoT, CoT-VLA, MolmoAct) successfully demonstrated that reasoning improves generalization—the question they answered was "can we make VLAs more capable?" The question Fast-ThinkAct addresses is "can we keep the capability gains of reasoning while removing its latency cost?" The paper's answer is yes, but only if the compact reasoning representations are properly grounded through multiple alignment mechanisms—a subtle point that the ablation studies in Table 3 make explicit by showing that removing any component (verifier preference alignment, visual plan distillation, or the verbalizer) degrades performance below the textual teacher baseline.

Why This Problem Matters Beyond the Obvious Efficiency Argument

The obvious motivation—faster inference is better—undersells the paper's significance. There are three deeper reasons this problem matters:

1. The capability-efficiency tradeoff is not fixed; it's a design choice. The standard narrative in the reasoning VLA literature has been that longer reasoning chains produce better decisions—ThinkAct generates ~250 tokens of reasoning per step, MolmoAct generates verbose spatial descriptions. This creates an implicit assumption that reasoning quality scales with token count, which if true would make latency reduction inherently capability-reducing. Fast-ThinkAct directly challenges this assumption by demonstrating that 6 continuous latent tokens can outperform 250 discrete text tokens on both reasoning benchmarks (Table 2) and manipulation benchmarks (Figure 3a-e). This reframes the tradeoff: the relevant question is not "how much reasoning can we afford given latency constraints?" but rather "what is the most information-dense form of reasoning, and how do we learn to produce it?"

2. Embodied reasoning has different information-theoretic requirements than text reasoning. The paper argues that compressing reasoning for VLAs is harder than for pure LLMs because embodied reasoning must encode spatial-temporal understanding and bridge semantic planning with continuous control (Section 2.2). The authors explicitly note:

"LLM techniques cannot directly transfer to VLA tasks due to the need for spatial-temporal understanding and bridging semantic reasoning with embodied control"

This means the recent wave of efficient reasoning work in LLMs—length penalties in RL (Dai et al., 2025; Yuan et al., 2025), latent reasoning in continuous space such as Coconut (Hao et al., 2024), CODI (Shen et al., 2025), and Soft Thinking (Zhang et al., 2025)—provides inspiration but not solutions. Those methods optimize for efficient textual reasoning; they do not address how to encode visual trajectories, spatial relationships, and manipulation plans into compact representations. Fast-ThinkAct's contribution is precisely to bridge this gap: the action-aligned visual plan distillation loss (Equation 5) and the spatial token mechanism (Equation 6) are specifically designed to ensure that latent reasoning tokens capture visual planning information, not just linguistic reasoning patterns.

3. The problem distribution in real-world deployment skews toward scenarios where reasoning helps most. Foundation VLAs (OpenVLA, π0, RDT) already handle routine manipulation. The value of reasoning emerges in the long tail: long-horizon tasks requiring multi-step coordination, novel object configurations, and recovery from unexpected failures. These are precisely the scenarios where latency constraints are tightest—a robot that pauses for 7.5 seconds to "think" mid-task in a dynamic environment is not just slow but potentially dangerous. The paper's evaluation design reflects this: the RoboTwin2.0 benchmark includes tasks with 270–470 step demonstrations (Table 1), and the failure recovery evaluation on RoboFAC (Figure 5) explicitly tests whether reasoning can identify and correct errors at runtime. Achieving 89.3% latency reduction while improving performance on these tasks (Table 1: 65.7 vs. 62.4 on RoboTwin2.0 easy, 26.4 vs. 24.7 on hard) makes the case that compact reasoning is not a compromise but an improvement.

Prior Approaches and Where They Fall Short

The paper categorizes prior work into two streams and identifies distinct limitations in each.

Foundation VLAs: capable but brittle. Models such as OpenVLA (Kim et al., 2024), π0 (Black et al., 2024), RDT (Liu et al., 2024), and Magma (Yang et al., 2025) are trained on large-scale robot demonstrations via imitation learning and achieve strong performance on routine manipulation tasks. However, the paper identifies a fundamental limitation (Section 1):

"as these VLA models primarily rely on supervised training from action data, they excel at basic skills (e.g., pick-and-place) but struggle to generalize beyond training distributions, such as long-horizon planning, self-correction from failures, and adaptation to novel scenarios, due to the impracticality of collecting exhaustive robot demonstrations"

This is not a training data scaling problem—it's a structural limitation of purely reactive policy learning. Without intermediate reasoning, these models have no mechanism to decompose novel tasks into subgoals, imagine visual trajectories, or recognize that an action sequence has gone off-track. The paper's results confirm this: in Figure 3, OpenVLA achieves only 40.2% on SimplerEnv-Google while reasoning VLAs reach 64.9–68.7%, and in Table 1, DP and ACT fail almost entirely on hard RoboTwin2.0 tasks (0.6% and 3.5% average respectively).

Reasoning VLAs: capable but slow. The second wave of work—Embodied CoT (Zawalski et al., 2024), CoT-VLA (Zhao et al., 2025), MolmoAct (Lee et al., 2025), ThinkAct (Huang et al., 2025)—addresses the generalization problem by incorporating explicit intermediate reasoning. The paper subdivides these into supervised approaches that learn from reasoning annotations (Embodied CoT, CoT-VLA, MolmoAct, Hi-Robot) and RL-based approaches that generate reasoning chains optimized against task rewards (ThinkAct, Embodied-R1). These methods successfully improve task generalization and long-horizon planning. However, they share a critical flaw:

"they require generating lengthy chain-of-thought steps that introduce substantial reasoning latency, which hampers embodied applications with real-time requirements"

The numbers are stark. ThinkAct-7B generates approximately 250 tokens of reasoning per action step, taking 7,513 ms total (Figure 3f). MolmoAct-7B takes 6,723 ms. At these latencies, a robot operating at 0.13 Hz cannot respond to dynamic environmental changes, cannot recover from mid-execution failures in time, and cannot coordinate bimanual actions that require temporal precision.

Efficient reasoning for LLMs: the wrong kind of efficiency. The paper acknowledges recent work on efficient LLM reasoning—RL with length penalties (Dai et al., 2025; Yuan et al., 2025; Aggarwal and Welleck, 2025), and latent reasoning methods such as Coconut (Hao et al., 2024), CODI (Shen et al., 2025), and Soft Thinking (Zhang et al., 2025). The limitation is domain transfer: these methods optimize for text reasoning in continuous space but do not encode the spatial, temporal, and control-specific information that embodied tasks require. A latent thought that efficiently represents "the answer is 42" is qualitatively different from a latent thought that efficiently represents "move the left gripper to (0.3, 0.7) while maintaining the orientation of the grasped mug and avoiding collision with the drawer." The paper's explicit claim is that bridging this gap requires not just compressing reasoning but also aligning it with visual trajectories and grounding it in manipulation plans—mechanisms absent from LLM-focused latent reasoning work.

ECoT-Lite: the closest prior work, with a revealing limitation. The paper discusses ECoT-Lite (Chen et al., 2025) as the most directly comparable prior approach. ECoT-Lite proposes "reasoning dropout" to accelerate inference by skipping test-time reasoning traces. The paper identifies a critical weakness:

"reasoning dropout can lead to inconsistent planning as it builds on supervised embodied CoT"

The insight here is subtle but important. ECoT-Lite shortcuts the reasoning process by simply generating fewer tokens or skipping reasoning entirely at test time, but the underlying model was trained to produce verbose CoT. This is fundamentally a form of train-test mismatch: the model learned to plan by producing detailed reasoning, and when that reasoning is truncated at inference, the planning degrades because the model's computations were organized around producing the full trace. Fast-ThinkAct takes the opposite approach: rather than truncating reasoning at test time, it redesigns the training objective so the model learns to reason in a compact latent space from the start. The preference-guided distillation with trajectory alignment ensures that the compact representations are native to the model, not a compressed approximation of a verbose process.

The gap in the literature, summarized. No prior work simultaneously achieves (1) the generalization benefits of reasoning VLAs, (2) the inference latency compatible with real-time embodied control, and (3) representations that encode both linguistic planning and visual-spatial trajectory information. Foundation VLAs satisfy (2) but fail (1). Reasoning VLAs satisfy (1) but fail (2). Efficient LLM reasoning methods partially address (2) but fail (3). ECoT-Lite attempts (2) but sacrifices (1) due to train-test mismatch.

How Fast-ThinkAct Positions Itself

The paper positions itself as filling this three-way gap through a specific mechanism: distilling reasoning into continuous latent representations that are simultaneously (a) decodable into interpretable text (via the verbalizer LLM), (b) aligned with high-quality reasoning patterns from a teacher (via preference-guided DPO), and (c) grounded in visual trajectory planning (via action-aligned visual plan distillation).

The theoretical framing is that reasoning for embodied control has two distinct components that must be compressed together: linguistic planning (what to do, in what order, with what contingencies) and visual planning (where objects are, how to move through space, what spatial relationships must be maintained). The verbalizer loss (Equation 4) handles the linguistic component by ensuring latents decode to meaningful reasoning text. The distillation loss (Equation 5) and spatial token prediction (Equation 6) handle the visual component by aligning trajectory-level representations between teacher and student and predicting explicit waypoint sequences.

Critically, the verbalizer LLM is used only during training and optionally for interpretability—it does not participate in inference (Section 3.4). This means the inference path is: observation and instruction → compact latent reasoning (6 continuous tokens) → spatial token prediction (5 waypoints) → action prediction. The verbalizer serves as a training signal to ensure the latents represent interpretable reasoning, but the action model learns to consume the latents directly without decoding them to text first. This is what enables the 9.3× speedup over ThinkAct-7B (Figure 1, bottom-right plot).

The paper's positioning relative to the teacher-student distillation paradigm is also notable. Unlike standard knowledge distillation where the student learns to mimic the teacher's outputs, Fast-ThinkAct's student learns from the teacher's preferences over reasoning traces. The teacher generates multiple rollouts via GRPO, receives trajectory-aligned rewards, and the student is trained to encode latents that the verbalizer prefers to decode into high-advantage traces (τ+) rather than low-advantage traces (τ−). This is a form of preference distillation (Equation 3–4) that goes beyond output matching—it actively suppresses low-quality reasoning patterns in the latent space. The authors validate this design in Table 6 by comparing against alternatives: simply running the textual teacher with no reasoning tokens (46.5 avg), with 6 textual tokens constrained at inference (46.3), or with RL length penalty training (47.8). All three underperform the textual teacher baseline (49.8), confirming that simply truncating or penalizing textual reasoning degrades capability. Fast-ThinkAct achieves 53.3 with 6 latent tokens, demonstrating that the distillation process teaches the student a fundamentally more information-dense reasoning representation than the teacher's text.

The paper also positions its contribution as complementary to—not competitive with—existing VLA architectures. The reasoning-enhanced policy learning in Section 3.3 shows that Fast-ThinkAct's latent planning can condition multiple action model backbones (DiT-Policy for SimplerEnv, RDT for LIBERO and RoboTwin2.0), and the Appendix notes that this demonstrates "our approach is agnostic to the underlying action model choice" (Section A.2). This modularity is a deliberate design choice that allows the reasoning efficiency gains to benefit different robot platforms and policy architectures without requiring end-to-end redesign.

3. Technical Approach

3.1 Reader Orientation

Fast-ThinkAct is a training framework that teaches a vision-language model to reason about robotic manipulation tasks using a small number of continuous vectors instead of hundreds of text tokens, then connects those compact reasoning vectors directly to an action model that produces robot control commands. The core problem it solves is the inference latency bottleneck created by existing reasoning VLAs, which generate lengthy chain-of-thought text before every action—and the "shape" of the solution is a teacher-student distillation pipeline where a textual teacher model demonstrates high-quality reasoning, a latent student learns to compress that reasoning into 6 continuous tokens, and two alignment mechanisms (verbalizer-based preference optimization and trajectory-level visual plan distillation) ensure the compressed tokens retain both linguistic planning structure and spatial-visual grounding.

3.2 Big-Picture Architecture (Diagram in Words)

The system has six major components organized into a training pipeline and an inference pipeline:

Textual Teacher VLM ( $\mathcal{F}_{\theta}^{T}$ ) — a vision-language model fine-tuned with GRPO to generate explicit textual chain-of-thought reasoning traces and visual trajectory plans, producing multiple candidate reasoning rollouts per observation-instruction pair. Only used during training.
Latent Student VLM ( $\mathcal{F}_{\theta}$ ) — the same architecture initialized from the same checkpoint, but trained to autoregressively produce $M = 6$ continuous latent vectors $\mathbf{z} = \{z_m\}_{m=1}^{M}$ instead of discrete text tokens. At test time, this is the reasoning engine.
Verbalizer LLM ( $\mathcal{V}_{\psi}$ ) — a small language model (Qwen3-0.6B) augmented with cross-attention layers that condition on the student's latent vectors. It decodes latents back to text, enabling preference-based optimization in natural language space. Used only during training and optionally for interpretability.
Spatial Token Prediction Heads — $K = 5$ learnable spatial tokens appended to the latent reasoning sequence, each projected through an MLP to predict a 2D waypoint coordinate $p_i \in \mathbb{R}^6$ (encoding single-arm and bimanual gripper positions). These provide the visual trajectory plan.
Action Model ( $\pi_{\varphi}$ ) — a diffusion Transformer-based policy (either DiT-Policy or RDT, depending on the benchmark) that receives the visual latent planning context $c_t$ extracted from the spatial tokens' key-value cache and predicts executable robot action chunks $a_t$ .
State Encoder — processes the robot's proprioceptive state observations and produces key-value pairs that the action model attends to alongside the visual planning context.

Information flow during training: An observation-instruction pair $(o_t, l)$ enters both the textual teacher and the latent student. The teacher generates $N = 5$ text reasoning rollouts via GRPO, which are scored with trajectory-aligned rewards. The highest-advantage trace $\tau^+$ and lowest-advantage trace $\tau^-$ are selected as a preference pair. Meanwhile, the student autoregressively generates $M$ latent tokens from the same observation-instruction pair. The verbalizer conditions on these latents and is optimized via DPO-style loss to assign higher likelihood to decoding $\tau^+$ than $\tau^-$ . Simultaneously, the student's hidden state at the <answer> token (the visual planning representation) is aligned via L2 loss to the teacher's corresponding hidden state from $\tau^+$ , and the spatial tokens predict explicit waypoints. Finally, the trained student's latent representations condition the action model during policy learning with an imitation objective.

Information flow during inference: Only the latent student $\mathcal{F}_{\theta}$ and action model $\pi_{\varphi}$ are used. $\mathcal{F}_{\theta}$ processes $(o_t, l)$ , generates 6 latent reasoning tokens and 5 predicted waypoints via the spatial tokens, and the KV cache from the spatial tokens is extracted as $c_t$ . $\pi_{\varphi}$ attends to $c_t$ and the state encoder's output to produce action chunks $a_t$ . The verbalizer is not used.

3.3 Roadmap for the Deep Dive

The detailed technical breakdown follows the natural dependency structure of the training pipeline:

First, the textual teacher and GRPO training (Section 3.2, paragraph 1) — because the teacher produces the reasoning traces that the student learns from, and the GRPO advantage function provides the quality signal that drives preference selection. Without understanding how high-quality vs. low-quality traces are identified, the rest of the distillation framework makes no sense.
Second, the preference pair construction (Section 3.2.1, Equations 1–3) — specifically how $\tau^+$ and $\tau^-$ are selected from each rollout group, since these pairs are the direct supervision signal for the verbalizer's DPO loss.
Third, the verbalizer and preference-guided latent learning (Section 3.2.1, Equation 4) — this is the core mechanism that ensures latent tokens encode interpretable reasoning: the verbalizer's DPO loss forces the student to produce latents that decode to high-quality reasoning and not low-quality reasoning. I'll explain what DPO is, how it's adapted here, and why it solves the "no supervision in latent space" problem.
Fourth, the action-aligned visual plan distillation (Section 3.2.2, Equations 5–6) — the complementary mechanism that ensures latents encode spatial-visual planning information, not just linguistic structure. This includes the trajectory-level L2 alignment and the parallel spatial token waypoint prediction.
Fifth, the full student objective and training strategy — how $\mathcal{L}_{\text{student}} = \mathcal{L}_{\text{verb}} + \mathcal{L}_{\text{distill}} + \mathcal{L}_{\text{ans}}$ combines the three losses, and the specific optimization schedule (verbalizer warmup with language modeling loss for 3,000 iterations, then switching to DPO for 1,500 iterations).
Sixth, the reasoning-enhanced policy learning (Section 3.3, Equation 7) — how the trained student's frozen latent representations are connected to the action model, including the KV cache extraction mechanism, the linear projection adapter, and the imitation learning objective.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a training methodology paper whose core idea is that embodied reasoning can be compressed from hundreds of discrete text tokens into a small number of continuous latent vectors without losing planning capability, provided the latent representations are simultaneously (a) grounded in interpretable reasoning through preference-aligned verbalization, (b) aligned with the teacher's visual planning trajectory, and (c) used directly as conditioning context for action prediction without text decoding at inference time.

Textual Teacher GRPO Training and the Advantage Signal

The teacher model $\mathcal{F}_{\theta}^{T}$ is a VLM (specifically, Qwen2.5-VL 3B) that has already undergone two preliminary training stages: standard supervised fine-tuning (SFT) on approximately 4M embodied QA and visual trajectory samples, followed by chain-of-thought SFT (CoT-SFT) on approximately 365K samples that include explicit reasoning annotations (Section A.3.2). Starting from this CoT-SFT checkpoint, the teacher is further trained with Group Relative Policy Optimization (GRPO), a reinforcement learning algorithm developed in Shao et al. (2024) for reasoning tasks.

GRPO trains the teacher to generate reasoning traces $\tau$ that maximize an advantage-weighted objective. The GRPO objective for the teacher is:

$\mathcal{J}_{\text{GRPO}}(\theta) = \mathbb{E}_{\tau \sim \mathcal{F}_{\theta}^{T}} \left[ \min \left( r_{\theta}(\tau) A(\tau), \text{clip}(r_{\theta}(\tau), 1 - \epsilon, 1 + \epsilon) A(\tau) \right) \right]$

where $\tau$ is a reasoning trace (the full sequence of text tokens produced by the teacher before the action prediction), $r_{\theta}(\tau) = \frac{\mathcal{F}_{\theta}^{T}(\tau)}{\mathcal{F}_{\theta_{\text{old}}}^{T}(\tau)}$ is the probability ratio between the current policy and a frozen reference policy for producing that trace, and $\epsilon$ is the clipping parameter (standard in PPO-style objectives) that prevents the policy from changing too drastically in a single update. The clipping operation $\text{clip}(r_{\theta}(\tau), 1 - \epsilon, 1 + \epsilon)$ bounds the ratio to $[1 - \epsilon, 1 + \epsilon]$ , and the $\min$ takes the more conservative of the clipped and unclipped values—this is the standard PPO clipping mechanism that prevents destructive large policy updates when the advantage estimate is noisy.

The advantage function $A(\tau)$ for a trace is computed within a group of $N = 5$ rollouts generated from the same observation-instruction pair $(o_t, l)$ :

$A(\tau) = \frac{R_{\tau} - \text{mean}(\{R_i\}_{i \in G(\tau)})}{\text{std}(\{R_i\}_{i \in G(\tau)})}$

where $G(\tau)$ is the group of $N$ rollouts sampled from the teacher for the same input (the rollout group), $R_{\tau}$ is the scalar reward assigned to trace $\tau$ , and $\text{mean}(\{R_i\})$ and $\text{std}(\{R_i\})$ are the group-level mean and standard deviation of rewards.

What it computes: For each rollout trace, the advantage $A(\tau)$ measures how much better or worse that trace's reward is compared to the average reward in its group, normalized by the group's standard deviation. A trace that achieves exactly the group-average reward gets advantage zero; a trace with reward one standard deviation above the mean gets advantage +1; a trace one standard deviation below the mean gets advantage -1. This normalization is crucial because reward scales can vary across different tasks and observation-instruction pairs—group-wise normalization ensures that the optimization signal is calibrated relative to what the model could have produced for that specific prompt, rather than an absolute reward magnitude that might be meaningless across tasks.

Why this form: Group-relative advantage is the defining characteristic of GRPO as opposed to standard PPO. In standard PPO, the advantage is typically computed using a learned value function that estimates the expected return from a state, which requires training a separate critic network and introduces its own approximation errors. GRPO eliminates the critic by using the group mean as a baseline—this works because the $N$ rollouts in a group are independent samples from the same policy for the same input, so their mean reward is an unbiased estimate of the policy's expected performance on that prompt. The normalization by standard deviation provides adaptive scaling: when the group has high variance (the policy produces very different-quality reasoning traces for the same prompt), advantages are compressed, preventing the policy from overfitting to lucky samples; when the group has low variance (the policy is consistent), small reward differences translate to larger advantages, encouraging fine-grained improvement. For reasoning tasks, where reward signals are sparse and trajectory-level (goal completion, trajectory alignment), this group-relative approach is particularly appropriate because absolute reward magnitudes don't carry rich per-token signal.

The rewards $R_{\tau}$ are computed using action-aligned visual rewards following the ThinkAct framework (Huang et al., 2025), which includes trajectory-level metrics such as goal completion (did the robot achieve the specified task?) and trajectory alignment (how closely do the predicted visual waypoints match expert trajectories?). The paper also mentions "QA-style rewards" in Section 4.1, referring to correctness-based rewards for embodied question-answering tasks. The key property is that these rewards are sparse and trajectory-level—they evaluate the entire reasoning-action sequence holistically rather than providing per-step feedback, which is why the group-wise advantage normalization is necessary to extract a meaningful training signal.

The output of GRPO training is a teacher model $\mathcal{F}_{\theta}^{T}$ that generates explicit textual chain-of-thought reasoning traces of varying quality for each observation-instruction pair. The advantage values $A(\tau)$ for each rollout provide a natural quality ranking within the group, which is directly exploited in the next step.

Preference Pair Construction from Rollout Groups

After the teacher generates $N = 5$ rollouts $\{\tau_i\}_{i=1}^{N}$ for a given observation-instruction pair $(o_t, l)$ during GRPO training, the advantage values $\{A_i\}_{i=1}^{N}$ computed via Equation 2 serve as quality scores. The paper selects exactly two traces from each group to form a preference pair:

$\tau^+ = \arg\max_{\tau \in G} A(\tau) \quad \text{and} \quad \tau^- = \arg\min_{\tau \in G} A(\tau)$

where $\tau^+$ is the trace with the highest advantage in the group (the "winning" trace—the teacher's best reasoning attempt for this input) and $\tau^-$ is the trace with the lowest advantage in the group (the "losing" trace—the teacher's worst reasoning attempt for this input).

What it computes: A single pair of reasoning traces $(\tau^+, \tau^-)$ that represents the best and worst reasoning the teacher produced for the same observation-instruction pair, as judged by the task rewards. This pair encodes a relative preference: the winning trace is preferred over the losing trace for this specific embodied reasoning problem.

Why this form: Using the extremes (max and min advantage) rather than random pairs or intermediate comparisons maximizes the signal-to-noise ratio in the preference signal. If the two traces are close in quality, the preference is ambiguous, and the DPO loss (Equation 4) provides a weak gradient. By selecting the extremes, the preference is as clear as possible given the teacher's current capabilities, providing the strongest training signal for the student. This is a deliberate design choice that prioritizes learning from clear success/failure distinctions over more nuanced but noisier comparisons. A potential cost is that the model never learns fine-grained distinctions between medium-quality traces, but since the goal is to compress reasoning into a compact latent space (which has limited capacity), learning to strongly avoid the worst patterns may be sufficient.

These preference pairs are not constructed once from a static dataset—they are generated online during GRPO training, as the teacher's policy improves and its reasoning quality evolves. This means the "best" and "worst" traces are defined relative to the teacher's current capability, creating an implicit curriculum where the student first learns to distinguish and compress reasoning patterns that are clearly distinguishable, then refines its representations as the teacher improves and the gap between $\tau^+$ and $\tau^-$ narrows or shifts to more subtle distinctions.

Verbalizable Latent CoT by Reward Preferences

This is the core mechanism that addresses the central challenge identified in Section 3.2: "there is no direct supervision signal in the latent space to guide what reasoning patterns should be encoded." The insight is that by introducing a verbalizer LLM that decodes latent vectors back to text, the system can optimize the latent representations indirectly through a natural language preference loss—the latent vectors are trained to be verbalizable into high-quality reasoning and not verbalizable into low-quality reasoning.

The latent student's generation process. Unlike the teacher, which autoregressively generates discrete text tokens $w_1, w_2, \dots, w_T$ (where each $w_t$ is a token ID from the vocabulary), the student VLM $\mathcal{F}_{\theta}$ generates $M = 6$ continuous latent vectors $\mathbf{z} = \{z_m\}_{m=1}^{M}$ , with each $z_m \in \mathbb{R}^{d}$ where $d$ is the hidden dimension of the VLM (determined by the Qwen2.5-VL architecture). These vectors are produced autoregressively—each $z_m$ is conditioned on the previous latent vectors $z_{<m}$ through the standard transformer self-attention mechanism, but instead of sampling from a distribution over discrete tokens, the model directly outputs a continuous vector at each step.

This is a crucial architectural difference from text generation. In standard autoregressive language modeling, the model produces a distribution over the vocabulary at each step (a softmax over $d$ -dimensional logits mapped to vocabulary size $V$ ), and the next token is sampled or argmaxed from that distribution. In latent generation, the model skips the vocabulary projection entirely—the output at each step is simply the continuous hidden state, which serves directly as the latent token $z_m$ . There is no discrete bottleneck, which means the latent vector can represent arbitrary continuous information that would require many discrete tokens to approximate.

The verbalizer architecture. The verbalizer $\mathcal{V}_{\psi}$ is a separate, smaller language model (Qwen3-0.6B, initialized from a pretrained checkpoint) that has been modified by inserting cross-attention layers at every transformer layer. These cross-attention layers allow the verbalizer to attend to the latent sequence $\mathbf{z}$ while generating text. Specifically, when the verbalizer generates the $t$ -th text token $w_t$ , its self-attention layers attend to previous text tokens $w_{<t}$ , and its cross-attention layers attend to all $M$ latent vectors $\mathbf{z}$ . This architecture choice means the verbalizer can condition on the entire latent reasoning sequence at every text generation step, not just a prefix—the latent representations provide a global context for decoding.

Why a separate verbalizer instead of decoding directly from the student? The student VLM is not trained to generate text tokens—it's trained to produce continuous vectors. Attempting to add a text decoding head to the student would require the student to simultaneously optimize for two competing objectives (continuous latent reasoning and discrete text generation), and the discrete text generation pathway would reintroduce the computational cost that the method is designed to avoid. By separating the verbalizer as an external module used only during training, the student's architecture remains focused on efficient continuous reasoning, and the verbalizer serves purely as a training signal.

The preference-guided DPO loss. The training objective for the latent student $\mathcal{F}_{\theta}$ (specifically, for training the student to produce latents that encode high-quality reasoning) is implemented as a DPO-style loss on the verbalizer's decoding:

$\mathcal{L}_{\text{verb}} = -\mathbb{E}\left[ \log \sigma\left( \beta \left( \log \frac{p_{\psi}(\tau^+ | \mathbf{z})}{p_{\text{ref}}(\tau^+)} - \log \frac{p_{\psi}(\tau^- | \mathbf{z})}{p_{\text{ref}}(\tau^-)} \right) \right) \right]$

where $p_{\psi}(\tau | \mathbf{z})$ is the probability the verbalizer assigns to generating the text trace $\tau$ when conditioned on the student's latent vectors $\mathbf{z}$ , $p_{\text{ref}}(\tau)$ is the probability the reference model (the verbalizer $\mathcal{V}_{\psi}$ without latent conditioning—i.e., its pretrained language modeling distribution) assigns to $\tau$ , $\beta = 0.1$ controls the strength of the preference signal, and $\sigma(\cdot)$ is the sigmoid function.

What it computes: For a given latent representation $\mathbf{z}$ (which implicitly depends on the student's parameters $\theta$ since $\mathbf{z} = \mathcal{F}_{\theta}(o_t, l)$ ), the loss measures whether the verbalizer can more easily decode $\mathbf{z}$ into the winning trace $\tau^+$ versus the losing trace $\tau^-$ . The term $\log p_{\psi}(\tau^+ | \mathbf{z}) - \log p_{\psi}(\tau^- | \mathbf{z})$ is the raw difference in log-likelihoods—if the verbalizer assigns higher probability to $\tau^+$ than $\tau^-$ , this difference is positive. The reference model terms $\log p_{\text{ref}}(\tau^+)$ and $\log p_{\text{ref}}(\tau^-)$ normalize for the fact that some traces are inherently more likely than others regardless of conditioning (e.g., shorter traces, traces with common words). The subtraction removes this baseline: what matters is whether the latent conditioning improves the verbalizer's ability to produce $\tau^+$ relative to its unconditional probability, compared to the same improvement for $\tau^-$ . The sigmoid $\sigma(\cdot)$ maps this normalized preference to a probability, and the negative log converts it to a minimization objective: the loss is minimized when $\sigma(\beta \cdot \text{difference}) \to 1$ , which happens when the latent-conditioned verbalizer strongly prefers $\tau^+$ over $\tau^-$ relative to the reference model.

Why this form: DPO (Direct Preference Optimization, Rafailov et al., 2023) is originally designed for fine-tuning language models from human preference data—given pairs of responses where one is preferred over the other, DPO directly optimizes the policy to increase the relative probability of preferred responses. The standard DPO loss operates on the policy's own output probabilities. Here, the paper adapts the DPO framework to a teacher-student setting: the verbalizer serves as the "policy" being optimized (its probabilities $p_{\psi}$ are compared to a reference $p_{\text{ref}}$ ), but the gradients flow through the verbalizer's cross-attention layers back to the student's latent vectors $\mathbf{z}$ , and from there back to the student's parameters $\theta$ . This means the student is trained indirectly—it does not see the preference pair directly; it learns to produce latents that make the verbalizer prefer $\tau^+$ over $\tau^-$ . The $\beta$ parameter (set to 0.1) controls how sharply the loss penalizes cases where the verbalizer prefers the wrong trace: lower $\beta$ makes the loss more tolerant of small preference margins, which can help training stability.

The crucial property that makes this work for latent supervision is the verbalization bottleneck: the student cannot simply memorize $\tau^+$ and output it as text, because the student only produces continuous vectors. The only way for the student to make the verbalizer produce $\tau^+$ is to encode information in $\mathbf{z}$ that the verbalizer's cross-attention can extract and use to increase the likelihood of $\tau^+$ tokens. This forces the latent space to develop an information-rich encoding of reasoning patterns—the information that distinguishes $\tau^+$ from $\tau^-$ must be present in those 6 vectors.

The expectations $\mathbb{E}[\cdot]$ in the loss are over the training data distribution of observation-instruction pairs—for each sample, one preference pair $(\tau^+, \tau^-)$ is constructed from the teacher's rollouts, and the student-verbilizer combination is optimized on that pair.

Verbalizer Training Schedule and Warmup

A critical implementation detail described in Section 4.1 and Section A.2 is that the verbalizer is not trained with $\mathcal{L}_{\text{verb}}$ from the beginning. Instead, the training proceeds in two phases:

Phase 1 (first 3,000 iterations): The verbalizer is trained with standard autoregressive language modeling loss using $\tau^+$ as the ground truth target. That is, for each training sample, the student produces latents $\mathbf{z}$ , the verbalizer conditions on $\mathbf{z}$ via cross-attention, and is trained to maximize $\log p_{\psi}(\tau^+ | \mathbf{z})$ —the log-likelihood of generating the winning trace token by token. This is equivalent to standard supervised fine-tuning where the verbalizer learns to reconstruct the teacher's best reasoning from the student's compressed representation. During this phase, the student parameters $\theta$ are also updated (gradients flow back through the cross-attention), so the student learns to produce latents that are decodable into the correct reasoning text.

Phase 2 (remaining 1,500 iterations): The verbalizer parameters $\psi$ are frozen, and training switches to the preference-based $\mathcal{L}_{\text{verb}}$ loss. Only the student parameters $\theta$ are updated. The verbalizer now serves as a fixed evaluation metric: the student is optimized to produce latents that make the frozen verbalizer prefer $\tau^+$ over $\tau^-$ .

Why this two-phase schedule? Phase 1 establishes a basic alignment: the student learns to encode enough information for the verbalizer to approximately reconstruct the reasoning, and the verbalizer learns to extract that information from the latent space. If training started directly with $\mathcal{L}_{\text{verb}}$ , there would be no guarantee that the latents contain any decodable information at all—the verbalizer might assign uniformly low probability to both $\tau^+$ and $\tau^-$ , making the preference signal meaningless. The language modeling warmup ensures that by the time preference optimization begins, the latent space already supports reasonable text decoding, and the preference loss can refine which reasoning patterns are encoded (high-quality vs. low-quality) rather than struggling to encode any patterns at all. Freezing the verbalizer in Phase 2 prevents it from adapting to the student's changing latent representations in ways that would undermine the preference signal—if the verbalizer could change, it might learn to assign high probability to both traces regardless of latent content, which would zero out the preference gradient.

The paper also notes in Section A.2 that "the student $\mathcal{F}_{\theta}$ is optimized throughout both phases"—the student continuously adapts its latent representations as the verbalizer's decoding capability improves (Phase 1) and as preference optimization refines the encoded patterns (Phase 2).

Action-Aligned Visual Plan Distillation

While $\mathcal{L}_{\text{verb}}$ ensures the latent representations encode high-quality linguistic reasoning, it does not explicitly enforce that the latents capture the visual planning information essential for embodied control—where objects are in space, what trajectory the robot should follow, and what spatial relationships must be maintained during manipulation. The teacher model, trained with trajectory-level rewards (goal completion, trajectory alignment from ThinkAct), develops strong visual planning capabilities. The paper introduces two complementary mechanisms to transfer this capability to the student.

Trajectory-level hidden state alignment. At the end of each reasoning trace, both the teacher and student produce a final representation before predicting actions—this is the hidden state corresponding to the <answer> token (the token that separates reasoning from the predicted answer or action). The paper hypothesizes that this <answer> token hidden state encodes a summary of the visual plan derived from the preceding reasoning. To transfer this planning capability, the student's <answer>-token hidden state is aligned to the teacher's via L2 regression:

$\mathcal{L}_{\text{distill}} = \| h_t^T - h_t \|_2^2$

where $h_t^T \in \mathbb{R}^{d}$ is the hidden state of the <answer> token from the teacher model when generating the winning trace $\tau^+$ , and $h_t \in \mathbb{R}^{d}$ is the corresponding hidden state from the student model after processing the same observation-instruction pair and generating the latent reasoning sequence $\mathbf{z}$ .

What it computes: The squared Euclidean distance between the teacher's and student's visual planning representations. A lower value means the student's latent reasoning encodes visual planning information that is similar to the teacher's—in the limit where $\mathcal{L}_{\text{distill}} = 0$ , the student's compressed latent reasoning produces the same final planning state as the teacher's explicit textual reasoning.

Why this form: L2 distance on hidden states is a standard representation-level distillation objective. It is simpler and more direct than trying to distill visual planning through the preference framework (which operates in text space). The <answer> token is chosen specifically because, in the ThinkAct framework, actions are predicted from this token's hidden state—it is the interface between reasoning and execution. Aligning this representation ensures that whatever planning computation the teacher performed (which led to high-quality actions in the winning trace) is replicated in the student's more compact processing. An alternative would be to distill at every reasoning step, but the paper argues that aligning the final planning state is sufficient because the intermediate latent tokens $\mathbf{z}$ already carry the reasoning structure (enforced by $\mathcal{L}_{\text{verb}}$ )— $\mathcal{L}_{\text{distill}}$ just ensures the endpoint of that reasoning is visually grounded.

Only the teacher's hidden state from the winning trace $\tau^+$ is used for distillation, not the losing trace. This is a deliberate choice: the goal is to transfer the teacher's best visual planning capability, not to match average or poor planning. This aligns with the preference-based philosophy of the verbalizer loss—the student should learn from the teacher's successes, not its failures.

Parallel spatial token waypoint prediction. While $\mathcal{L}_{\text{distill}}$ aligns abstract planning representations, the paper also introduces a more explicit visual planning mechanism: the student directly predicts 2D visual trajectory waypoints through $K = 5$ learnable spatial tokens. These spatial tokens $\{\mathbf{s}_i\}_{i=1}^{K}$ are special vectors appended to the latent reasoning sequence—after generating the $M = 6$ latent reasoning tokens, the student also processes these $K$ spatial tokens through the transformer, and each spatial token's output hidden state is projected through an MLP to predict a waypoint coordinate:

$\mathcal{L}_{\text{ans}} = \sum_{i=1}^{K} \| p_i - \hat{p}_i \|_2^2, \quad \text{with} \quad p_i = \text{MLP}(h'(\mathbf{s}_i))$

where $h'(\mathbf{s}_i) \in \mathbb{R}^{d}$ is the output hidden state of the $i$ -th spatial token after the transformer forward pass (with the latent reasoning tokens and any instruction/observation tokens already in context), $p_i \in \mathbb{R}^6$ is the predicted waypoint, and $\hat{p}_i \in \mathbb{R}^6$ is the ground-truth waypoint. The MLP projects from the hidden dimension $d$ to 6 dimensions.

The 6-dimensional waypoint encoding (detailed in Appendix A.2) represents: [x_single, y_single, x_left, y_left, x_right, y_right], where the first two dimensions encode the gripper position for single-arm tasks, and the last four dimensions encode left and right gripper positions for bimanual tasks. When training on single-arm data, the bimanual dimensions are masked out (their contribution to $\mathcal{L}_{\text{ans}}$ is set to zero); when training on bimanual data, the single-arm dimensions are masked out. This unified 6D format allows the same spatial token mechanism to handle both single-arm and bimanual tasks without architectural changes.

What it computes: The sum of squared Euclidean distances between the predicted and ground-truth waypoints across all $K = 5$ spatial tokens. Each spatial token predicts one waypoint on the trajectory (e.g., token 1 predicts the first subgoal position, token 2 the second, etc.), so the full set of 5 predicted waypoints $\{p_i\}_{i=1}^{5}$ forms a coarse 2D visual trajectory plan.

Why this form — parallel prediction instead of autoregressive prediction: The textual teacher generates waypoints autoregressively—it outputs text tokens like "(0.12, 0.34)" for each waypoint, which for $K = 5$ waypoints requires 60–70 total tokens (each coordinate requires multiple text tokens for the parentheses, digits, decimal point, comma, and space). This autoregressive text generation is a major source of the teacher's latency. The student's spatial token mechanism enables parallel prediction: all 5 waypoints are predicted simultaneously from their respective spatial token hidden states with a single MLP projection. This eliminates the sequential dependency—the student does not need to generate waypoint 1 before waypoint 2, etc.—which is both faster at inference and allows the representations to capture global trajectory properties (since each spatial token can attend to all others via self-attention).

The choice of $K = 5$ waypoints follows the convention from MolmoAct (Lee et al., 2025), which demonstrated that 5 subgoals provide sufficient granularity for most manipulation trajectories. Fewer waypoints would lose resolution (the action model would have to interpolate over longer gaps); more waypoints would increase the latent sequence length (more spatial tokens to process) without proportionally improving planning quality.

Why 2D visual traces instead of learning implicit plans? The paper argues that explicit 2D trajectory prediction serves two purposes. First, it provides a direct visual grounding signal—the spatial tokens must encode spatial information about object positions and gripper trajectories, which forces the latent reasoning tokens (which precede and attend to the spatial tokens) to develop spatial awareness. Second, it enables interpretability: the predicted waypoints can be visualized as colored traces overlaid on the observation image (as shown in Figures 4 and 8), providing a human-interpretable window into the model's planning process. This is a deliberate design choice that prioritizes grounded, inspectable planning over purely abstract latent representations that might be slightly more efficient but uninterpretable.

Full Student Training Objective

The student VLM $\mathcal{F}_{\theta}$ is trained by minimizing the sum of the three loss components:

$\mathcal{L}_{\text{student}} = \mathcal{L}_{\text{verb}} + \mathcal{L}_{\text{distill}} + \mathcal{L}_{\text{ans}}$

where all three losses are described above. The total loss is a scalar that is minimized with respect to the student parameters $\theta$ .

Why these three components and not others? Each loss addresses a different failure mode:

Without $\mathcal{L}_{\text{verb}}$ : the latents may not encode any decodable reasoning at all (they could collapse to uninformative vectors that minimize $\mathcal{L}_{\text{distill}}$ by always predicting a constant planning representation). This is confirmed by the ablation in Table 3, where removing $\mathcal{L}_{\text{verb}}$ drops average embodied reasoning performance from 52.8 to 48.5.
Without $\mathcal{L}_{\text{distill}}$ : the latents may encode good linguistic reasoning (since $\mathcal{L}_{\text{verb}}$ is satisfied) but fail to capture the teacher's visual planning quality. The verbalizer loss only ensures the latents decode to correct-sounding text, not that they encode the spatial understanding needed for manipulation. Further removing $\mathcal{L}_{\text{distill}}$ drops performance to 47.7 (Table 3).
Without $\mathcal{L}_{\text{ans}}$ : the spatial tokens would have no supervision and would not learn to predict trajectories. The visual grounding that enables the action model to use the KV cache effectively (Section 3.3) would be absent, and the model would lose interpretability.

The equal weighting (coefficients of 1.0 for all three losses, with no balancing hyperparameters mentioned in the paper) suggests that the three losses operate at compatible scales after the verbalizer warmup phase establishes a reasonable latent space. The paper does not discuss loss weighting or report experiments with different weightings, which is a minor limitation—it is possible that per-task or per-benchmark tuning of loss weights could further improve performance.

Training hyperparameters. From Section 4.1 and Appendix A.2:

Teacher and student are both initialized from the same CoT-SFT checkpoint.
Teacher-student training runs for 4,500 iterations total.
Batch size: 128.
Learning rate: 1e-6.
Rollout size for GRPO: $N = 5$ .
Latent reasoning steps: $M = 6$ .
Number of waypoints: $K = 5$ .
$\beta = 0.1$ in $\mathcal{L}_{\text{verb}}$ .
Training data: approximately 50K samples, balanced across datasets (Section A.3.2).
All experiments on 16 NVIDIA A100 GPUs with 80 GB memory.

Note that the batch size of 128 and the GRPO rollout size of 5 operate at different granularities: each sample in the batch is an observation-instruction pair; for each sample, the teacher generates 5 rollouts to construct the preference pair. So the effective number of reasoning traces processed per iteration is 128 × 5 = 640 for the teacher's GRPO updates, plus 128 for the student's forward pass.

Reasoning-Enhanced Policy Learning

The final stage of the training pipeline bridges the student's compact latent reasoning to executable robot actions. The key idea is that the visual latent planning $c_t$ extracted from the spatial tokens' internal representations provides a rich conditioning signal for an action model, enabling it to translate high-level visual plans into low-level motor commands.

Extracting the visual latent planning c_t. After the student VLM $\mathcal{F}_{\theta}$ processes the observation-instruction pair $(o_t, l)$ and generates the latent reasoning tokens $\mathbf{z}$ followed by the $K = 5$ spatial tokens, the key-value (KV) cache from the spatial tokens in earlier layers of the transformer is extracted as the visual planning representation $c_t$ .

Specifically, the VLM $\mathcal{F}_{\theta}$ has more transformer layers than the action model $\pi_{\varphi}$ —the Qwen2.5-VL 3B backbone has a certain number of layers (determined by the architecture), while the diffusion-based action model has fewer layers. The paper extracts the KV pairs from the spatial tokens at the VLM layers that correspond to the early portion of the network (starting from layer 1 and taking the first $L$ layers, where $L$ is the number of layers in the action model). These KV pairs form a set of key-value vectors $c_t = \{(k_1, v_1), (k_2, v_2), \dots, (k_{K \times L}, v_{K \times L})\}$ that capture the visual planning information computed by the student across multiple layers of abstraction for each spatial token.

Why early-layer KV cache instead of late-layer or output hidden states? The paper reports an ablation in Appendix B.3 comparing three conditioning methods:

Early-layer KV cache: extracts KV pairs from the first $L$ VLM layers. Result: 89.7 on LIBERO.
Late-layer KV cache: extracts KV pairs from the last $L$ VLM layers. Result: 88.3 on LIBERO.
Output hidden states: uses the spatial tokens' final hidden states directly (no KV cache). Result: 87.1 on LIBERO.

The early-layer KV outperforms both alternatives. The paper's interpretation is that "early-layer representations better capture visual planning information for action prediction." Intuitively, earlier layers in vision-language models typically encode lower-level visual features (spatial relationships, object positions, motion cues), while later layers encode more abstract semantic information. Since the action model needs to translate visual plans into continuous control commands—which requires precise spatial information about where the gripper should move, how objects are positioned, etc.—the lower-level visual features in early layers are more directly useful than the abstract representations in later layers. The KV cache format (as opposed to output hidden states) preserves the multi-head attention structure, giving the action model access to different representational subspaces that may encode complementary aspects of the visual plan (e.g., different attention heads might specialize in object identity, spatial position, and gripper orientation).

Adapting the KV cache to the action model dimension. The VLM hidden dimension $d$ and the action model's hidden dimension $d_{\text{action}}$ are generally different—Qwen2.5-VL 3B uses one dimension, while DiT-Policy uses 1,024 and RDT uses 2,048 (Section 4.1). A linear projection layer adapts the VLM's KV cache to the action model's dimension:

$\tilde{k}_i = W_k k_i, \quad \tilde{v}_i = W_v v_i$

where $W_k, W_v \in \mathbb{R}^{d_{\text{action}} \times d}$ are learnable projection matrices. This is a simple but necessary step: without it, the action model's cross-attention layers could not process the VLM's KV pairs because the dimensionalities would not match.

Action model architecture and conditioning. The action model $\pi_{\varphi}$ is a diffusion Transformer—specifically, either DiT-Policy (Chi et al., 2023) for SimplerEnv or RDT (Liu et al., 2024) for LIBERO and RoboTwin2.0. Diffusion policies learn to denoise action chunks: starting from Gaussian noise, the model iteratively refines a sequence of future actions $a_t = (a_t, a_{t+1}, \dots, a_{t+H-1})$ over several denoising steps, conditioned on observations.

The conditioning works as follows: the action model receives two sources of key-value pairs for its cross-attention layers. The first source is the state encoder's output—the robot's proprioceptive state (joint positions, gripper state, etc.) is encoded into KV pairs by a dedicated state encoder (likely a small transformer or MLP). The second source is the projected visual planning KV cache $\tilde{c}_t = \{(\tilde{k}_i, \tilde{v}_i)\}$ . These two sets of KV pairs are concatenated, forming a combined set of keys and values that the action model's cross-attention layers attend to when denoising actions. This means the action model can attend to both the current robot state (what is my arm doing?) and the visual plan (where should I move? what spatial relationships matter?) simultaneously, integrating both sources of information to produce coordinated action sequences.

Imitation learning objective. The action model is trained with a standard diffusion denoising objective (imitation learning):

$\mathcal{L}_{\text{IL}}(\varphi) = \ell(\pi_{\varphi}(o_t, l, c_t), \hat{a}_t)$

where $\pi_{\varphi}(o_t, l, c_t)$ denotes the action model's prediction conditioned on the observation $o_t$ , language instruction $l$ , and visual planning context $c_t$ , $\hat{a}_t$ is the ground-truth action chunk from the robot demonstration data, and $\ell$ is the denoising objective—typically mean squared error between the predicted and true noise added to the action chunk during the diffusion forward process. The exact form of $\ell$ depends on the diffusion policy variant (DiT-Policy or RDT), but both follow the standard diffusion training paradigm: add noise to ground-truth actions, train the model to predict the noise, and the loss is the MSE between predicted and true noise.

Why freeze the student and state encoder during policy learning? The student VLM $\mathcal{F}_{\theta}$ and the state encoder are frozen (not updated by $\mathcal{L}_{\text{IL}}$ ), and only the action model parameters $\varphi$ and the KV projection matrices $W_k, W_v$ are trained. This is a deliberate design choice with two motivations:

Preserving the reasoning capability. The student has already been carefully trained to produce high-quality latent reasoning and visual planning. Updating it with an imitation learning signal (which optimizes for action prediction accuracy, not reasoning quality) could distort the latent representations—the student might learn to produce latents that are better for low-level action prediction but lose their interpretability or planning structure, which would hurt generalization to novel scenarios.
Modularity and reuse. By freezing the student, the same reasoning model can condition different action models for different robot platforms without retraining the VLM. The paper demonstrates this by using the same student with DiT-Policy for SimplerEnv and RDT for LIBERO and RoboTwin2.0. If the student were fine-tuned on action data, it would become specialized to a particular action model and robot morphology, losing the generality that is one of the paper's claimed advantages.

Training hyperparameters for policy learning (Section 4.1): 20K iterations, batch size 256, learning rate 1e-4, and all diffusion-specific hyperparameters (number of denoising steps, noise schedule, etc.) follow the defaults of the respective action model architectures (DiT-Policy or RDT). The training data is the Open X-Embodiment (OXE) dataset for SimplerEnv (following the OpenVLA protocol), augmented with bimanual data from the static ALOHA dataset for LIBERO and RoboTwin2.0 when using RDT as the action model (Section A.2).

Training Data and Dataset Strategy

While not a mathematical equation, the training data pipeline is critical to understanding the method. The paper uses a staged data strategy across three training phases:

Phase 1: SFT (Supervised Fine-Tuning). The base Qwen2.5-VL 3B model is fine-tuned on approximately 4 million samples combining (Section A.3.2):

2D visual trajectories from MolmoAct (single-arm, ~1.3M) and AIST (bimanual, ~92K).
QA data from PixMo (~726K), RoboFAC (64K QA pairs), RoboVQA (798K QA pairs), ShareRobot (>1M QA pairs), and EgoPlan (~53K video-text pairs).

This stage teaches the model foundational embodied knowledge: visual understanding of manipulation scenes, task comprehension from language instructions, and basic manipulation knowledge across diverse embodiments and scenarios. The data spans both single-arm and bimanual robots, simulated and real environments, and includes both trajectory-level annotations (where the gripper moved) and QA-style annotations (what task is being performed, did it succeed).

Phase 2: CoT-SFT (Chain-of-Thought Supervised Fine-Tuning). To develop reasoning capabilities, a subset of 5% of the SFT data (approximately 200K samples) is augmented with 165K samples from Video-R1-CoT, a dataset of video question-answer pairs with high-quality chain-of-thought reasoning annotations generated by large VLMs and quality-filtered. For data that has CoT annotations, the model is prompted to produce reasoning in thinking ... tags followed by answers in <answer> ... </answer> tags. For data without CoT annotations, the model is prompted for direct answers only. This teaches the model the format and structure of chain-of-thought reasoning while preserving embodied understanding from the SFT data.

Phase 3: Teacher-Student Training. From the combined SFT and CoT-SFT data pools, the paper curates a balanced training set by sampling "approximately 5,000 instances from each dataset and data type, totaling nearly 50K samples" (Section A.3.2). Both the teacher's GRPO training and the student's latent distillation are performed on this curated set. By balancing across datasets (ensuring roughly equal representation of single-arm trajectories, bimanual trajectories, and QA tasks), the training avoids overfitting to any particular manipulation style or reasoning domain. The relatively small size (50K) compared to the SFT dataset (4M) reflects the fact that preference-based distillation is more computationally expensive per sample (because the teacher generates 5 rollouts per sample) and that the student is learning to compress existing reasoning capability rather than acquire new knowledge from scratch—most of the knowledge comes from the SFT pre-training.

Why this staged approach? The progression from 4M samples (broad embodied knowledge) to 365K samples (reasoning format and structure) to 50K samples (high-quality reasoning compression) mirrors the common LLM training paradigm of pretraining → instruction tuning → RLHF. The SFT stage provides broad capability; the CoT-SFT stage instills the reasoning format; the teacher-student stage refines the quality. Each stage uses data appropriate to its goal: the SFT stage needs massive diversity to cover many embodiments; the teacher-student stage needs carefully curated, balanced data to provide a clean preference signal.

Inference Process

At inference time, only two components are active, and the verbalizer is not used. The process is:

The student VLM $\mathcal{F}_{\theta}$ receives the current visual observation $o_t$ (an image from the robot's camera) and the language instruction $l$ . It processes these through its vision encoder and language model, autoregressively generates $M = 6$ latent reasoning tokens $\mathbf{z}$ , and then processes $K = 5$ spatial tokens through the same transformer. The spatial tokens' output hidden states are projected through the MLP to produce $\{p_i\}_{i=1}^{5}$ , 5 predicted 2D waypoints.
The KV cache from the spatial tokens in the early VLM layers is extracted and projected to the action model's dimension via the learned linear projections $W_k, W_v$ , producing the visual latent planning context $c_t$ .
The state encoder processes the robot's proprioceptive state (current joint positions, velocities, gripper state) and produces KV pairs.
The action model $\pi_{\varphi}$ receives both the projected visual planning KV cache $c_t$ and the state encoder KV pairs as conditioning, and runs the diffusion denoising process to produce an action chunk $a_t$ . The diffusion process starts from random Gaussian noise and iteratively refines the action sequence over multiple denoising steps (the exact number is determined by the diffusion policy architecture), with each step conditioned on the combined KV pairs through cross-attention.
Only the first action in the predicted chunk (or the first few actions, depending on the action chunking scheme) is executed on the robot. The process repeats at the next timestep with a new observation.

The predicted waypoints $\{p_i\}$ can optionally be visualized (as shown in Figures 4, 8) but do not directly affect action generation—they serve as an interpretable byproduct of the visual planning process. The actual conditioning signal for the action model is the richer KV cache $c_t$ , which captures multi-layer spatial representations, not just the 2D coordinate predictions.

Latency breakdown (Figure 3f). The total inference latency of Fast-ThinkAct (3B) is 805 ms, broken down into:

Pre-fill (processing the observation and instruction through the VLM): some portion.
Reasoning (generating the 6 latent tokens and 5 spatial tokens): some portion.
Action Predicting (running the diffusion denoising process): some portion.

The paper does not provide the exact breakdown of these three components, but the total of 805 ms represents a 7.0× speedup over ThinkAct-3B (5,674 ms) and an 89.3% reduction over ThinkAct-7B (7,513 ms). The majority of the speedup comes from replacing the autoregressive generation of ~250 text tokens with the generation of 6 continuous vectors plus 5 spatial token projections—the text generation in ThinkAct requires 250 sequential transformer decoder steps (each token depends on all previous tokens), while the latent student requires only 11 steps (6 latent + 5 spatial) of similar per-step cost, plus the spatial token predictions are parallel rather than sequential.

Why the verbalizer is not needed at inference. The action model learns to consume the latent representations directly through the KV cache mechanism. The verbalizer was only ever a training signal to ensure the latents encoded interpretable reasoning—once trained, the action model can extract the planning information it needs from the KV cache without requiring an intermediate text decoding step. This is the key to the latency reduction: text decoding (which requires a full autoregressive pass through the verbalizer LLM for every token) is completely eliminated from the inference path. The option to use the verbalizer for interpretability (e.g., to inspect what the model is "thinking" during debugging) remains, but it is not required for action execution.

4. Key Insights and Innovations

Innovation 1: Reasoning Quality and Representation Efficiency Are Largely Decoupled—The Field Had Conflated Them

The dominant assumption in the reasoning VLA literature has been that longer, more explicit reasoning chains produce better action decisions. This assumption is embedded in the architecture of every prior reasoning VLA: Embodied CoT (Zawalski et al., 2024) trains on human-annotated multi-step reasoning; CoT-VLA (Zhao et al., 2025) generates visual subgoals as reasoning intermediates; MolmoAct (Lee et al., 2025) produces verbose spatial descriptions spanning 60–70 tokens for waypoint sequences alone; ThinkAct (Huang et al., 2025) uses RL to generate ~250-token reasoning traces. The implicit model is that reasoning is a serial computation where each token refines an intermediate state, and that truncating this chain necessarily degrades the final output.

Fast-ThinkAct demonstrates that this assumption is false—and that the conflation of reasoning quality with reasoning length has been a category error. The evidence is direct: 6 continuous latent tokens outperform 250 discrete text tokens across every benchmark. On LIBERO, the 3B latent student achieves 89.7% vs. 84.4% for ThinkAct-7B (Figure 3a–e). On embodied reasoning, the student achieves 52.8 average vs. 49.8 for the textual teacher (Table 3). On RoboTwin2.0, 65.7 vs. 62.4 on easy tasks and 26.4 vs. 24.7 on hard tasks (Table 1). These are not cases where efficiency is achieved by sacrificing quality—efficiency and quality are simultaneously improved.

What makes this finding intellectually distinctive is not the existence of a compact representation (learned latent codes have existed for decades), but the diagnostic reframing it forces. The relevant question shifts from "how much reasoning can we afford?" to "what is the minimal sufficient information for embodied planning, and how do we train models to encode it?" The ablation study in Table 6 sharpens this point: simply constraining the textual teacher to produce 6 text tokens at inference drops performance to 46.3 average (below the teacher's 49.8), while training with RL length penalties (Arora and Zanette, 2025) produces ~50-token traces and achieves 47.8. Both are worse than the full teacher baseline. This is the crucial negative result: naively compressing text reasoning degrades capability; the latent student's superior performance comes from learning a fundamentally different, more information-dense reasoning representation through the distillation process, not from simply truncating text.

This insight reframes the relationship between reasoning, representation, and embodied control. The field had been designing systems assuming that explicit linguistic decomposition of a task into subgoals and spatial descriptions was necessary for good planning. Fast-ThinkAct shows it is merely one implementation of reasoning—one that happens to be human-interpretable but computationally wasteful. The latent student encodes equivalent (or superior) planning information in a format that is 40× more token-efficient (6 vs. ~250), which means the teacher's text was mostly redundant filler. The 38% correct-to-incorrect reversion problem in the teacher's revision chains (noted in Section 6.1 of the paper) further supports this: verbose reasoning often includes incorrect steps that can degrade action quality, and the preference-guided distillation filters these out by design (the student learns to encode latents that decode to winning traces, not losing ones).

Innovation 2: Latent Reasoning Supervision Through Verbalizable Preference Alignment—Solving the "No Ground Truth in Latent Space" Problem

A fundamental obstacle to learning compact latent representations for reasoning is the absence of direct supervision: what should the continuous vectors encode? Prior latent reasoning work in LLMs has sidestepped this problem in ways that don't transfer to embodied settings. Coconut (Hao et al., 2024) uses the LLM's own hidden states as continuous thoughts, training the model to alternate between discrete and continuous modes—but this requires the model to generate text tokens eventually, which reintroduces the latency bottleneck for VLA. CODI (Shen et al., 2025) distills explicit CoT into continuous space via teacher-student alignment in hidden state space—but this only transfers linguistic reasoning patterns, not the spatial-visual planning essential for manipulation. Soft Thinking (Zhang et al., 2025) generates weighted concept tokens—but again, these encode textual concepts, not spatial trajectories.

Fast-ThinkAct's innovation is a two-channel supervision strategy for latent representations that provides learning signal without requiring the latents to bottleneck through discrete text at inference time. The first channel—the verbalizer with preference-guided DPO loss (Equation 4)—supervises the semantic content of the latents through an indirect route: the latents must contain information that enables a separate language model to reconstruct high-quality reasoning text and distinguish it from low-quality text. The second channel—action-aligned visual plan distillation (Equations 5–6)—supervises the spatial-visual content directly through representation alignment and waypoint prediction.

The intellectual move here is recognizing that supervision can come from downstream decodability rather than direct reconstruction loss. The verbalizer never constrains the latents to equal any particular text; it only constrains them to be more decodable into good reasoning than bad reasoning. This is a weaker constraint than requiring exact reconstruction, which gives the latent space more flexibility to develop efficient representations. The DPO formulation is key: rather than training the student to produce latents that maximize p_ψ(τ^+ | z) (which would be exact reconstruction and might encourage the latents to memorize surface-level text patterns), the preference formulation only cares about the relative ordering of τ^+ and τ^-. This means the latents need only encode the information that discriminates good from bad reasoning, which is a much more compact information requirement.

This connects to a broader principle: when the goal is to produce decisions (actions) rather than explanations (text), the optimal internal representation may not be faithful to any particular textual articulation. The verbalizer provides a training scaffold that ensures the latents are grounded in interpretable reasoning, but the scaffold is removed at inference—the action model consumes the latents directly, extracting whatever spatial, temporal, and semantic information it needs for control. This decoupling of training supervision from inference computation is the architectural insight that makes the efficiency gains possible without quality loss.

The evidence for this innovation's necessity comes from the ablation in Table 3: removing ℒ_verb drops average performance from 52.8 to 48.5. Removing both ℒ_verb and ℒ_distill drops it further to 47.7—worse than the textual teacher at 49.8. This confirms that both supervision channels are individually necessary and that neither alone suffices. The verbalizer loss provides the linguistic reasoning structure; the visual distillation provides the spatial grounding. Together, they produce latents that are both semantically coherent and visually actionable—a property that neither pure text supervision nor pure representation alignment could achieve alone.

Innovation 3: Visual Planning as a First-Class Latent Representational Goal—Not Just a Byproduct of Linguistic Reasoning

Existing reasoning VLAs treat visual planning as downstream of linguistic reasoning: the model thinks in language about what to do, and visual predictions (if any) are derived from that linguistic plan. MolmoAct generates spatial descriptions in text, then converts them to coordinates. ThinkAct generates text reasoning, then predicts waypoints from the final hidden state. In both cases, the visual plan is computed after languge reasoning, and the quality of the visual plan is limited by the fidelity of the text-to-space translation.

Fast-ThinkAct inverts this relationship: visual planning is a parallel, first-class objective during reasoning training, not a post-hoc extraction from text. The spatial token mechanism (Equation 6) predicts explicit 2D waypoints simultaneously with latent reasoning generation, and the distillation loss (Equation 5) aligns the visual planning representation directly with the teacher's without text mediation. The spatial tokens attend to the latent reasoning tokens (and vice versa), meaning visual and linguistic planning co-develop during training—the model learns to reason about manipulation in a format where spatial and semantic information are integrated from the start.

The significance of this reframing extends beyond efficiency. It addresses a structural limitation of text-first approaches: language is a poor medium for encoding continuous spatial relationships, fine-grained motion trajectories, and 3D scene geometry. When a model must translate a spatial plan into discrete words ("move 0.12 units left, then 0.34 units up") and then back to continuous coordinates, information is inevitably lost in the discretization bottleneck. By allowing the model to maintain spatial plans in their native continuous format throughout reasoning, Fast-ThinkAct preserves geometric precision that text-based approaches discard.

This is visible in the qualitative results (Figures 4 and 8): the predicted 2D visual traces show smooth, feasible manipulation trajectories for bimanual coordination tasks where text-based spatial descriptions would be cumbersome (e.g., "use the left arm to grab the red block, transfer it to the right hand, and set it onto the blue pad"). The spatial tokens encode left and right gripper positions simultaneously in a 6D vector format ([x_single, y_single, x_left, y_left, x_right, y_right]), allowing parallel prediction of coordinated bimanual trajectories—a capability that would require interleaved textual descriptions of two grippers' motions, significantly increasing token count.

The ablation confirms this is not just an efficiency gain but a qualitative improvement: the early-layer KV cache from spatial tokens outperforms both late-layer KV and output hidden states for action conditioning (89.7 vs. 88.3 vs. 87.1 on LIBERO; Appendix B.3). This suggests that the spatial token mechanism captures visual planning information in early visual representations that are more directly useful for control than the abstract semantic representations in later layers. The paper's interpretation—that "early-layer representations better capture visual planning information for action prediction"—implies that spatial planning is fundamentally a mid-level visual computation, not a high-level semantic one, and that text-based reasoning channels it through an inappropriate representational bottleneck.

Innovation 4: The Distinction Between Training-Time Reasoning and Inference-Time Execution—And Why It Matters for Embodied AI

All prior reasoning VLAs use the same model pathway for both reasoning and action prediction at inference time. ThinkAct generates reasoning tokens, then generates action tokens from the same decoder, with the reasoning tokens serving as context. This means the model must run a full autoregressive decode through all reasoning tokens before the first action token can be produced—every token of reasoning increases latency by one transformer forward pass.

Fast-ThinkAct introduces a structural separation between the reasoning model and the action model, with the connection mediated by a frozen KV cache rather than autoregressive token generation. This separation enables three capabilities that are architecturally impossible in unified reasoning VLA models:

First, modularity of reasoning and control. The student VLM can condition different action models (DiT-Policy for SimplerEnv, RDT for LIBERO and RoboTwin2.0) without retraining. This is demonstrated empirically (Section A.2) and matters practically because different robot platforms have different control requirements (end-effector velocity vs. joint positions, single-arm vs. bimanual, different action frequencies). In a unified model, the reasoning and action prediction share parameters, so adapting to a new robot requires retraining the entire system. In Fast-ThinkAct, the reasoning model is a stable planning module that can be paired with new action models through a simple linear projection and fine-tuning of the action model only.

Second, temporal decoupling of reasoning frequency from action frequency. In principle (though not explored in the paper), the student VLM could produce a latent plan that conditions multiple subsequent action predictions without re-running reasoning—the KV cache c_t remains valid as long as the visual plan hasn't changed. This would enable high-frequency control (e.g., 15 Hz actions) with low-frequency replanning (e.g., 1 Hz latent reasoning updates), which is the standard architecture in classical robotics but has been absent from end-to-end VLA approaches. Whether this actually works is an empirical question the paper leaves for future work, but the architectural capability is present.

Third, the verbalizer as a training-only interpretability tool. The paper explicitly notes that the verbalizer "is used solely during training and optionally for interpretability" (Section 3.4). This means the inference-critical path (student VLM → KV cache → action model) is completely independent of the text decoding machinery. If interpretability is needed (e.g., for debugging or safety monitoring), the verbalizer can be run; if latency is critical, it can be omitted entirely. This is a pragmatic design choice that acknowledges the different requirements of training (where interpretability aids development) and deployment (where latency dominates).

This separation is the mechanism behind the paper's headline 89.3% latency reduction, but its conceptual significance goes beyond the number. It establishes a design pattern for embodied reasoning systems: use explicit, interpretable, and expensive reasoning during training to shape compact latent representations, then deploy only the compact latents at inference. This pattern could generalize to other modalities and tasks—for example, an autonomous driving system that trains with detailed scene descriptions and risk analyses but deploys with compressed latent scene representations that condition a fast reactive controller. The key requirement (and the paper's demonstration) is that the training-time reasoning must be properly aligned with the inference-time representations through mechanisms that go beyond simple output matching.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper evaluates on three embodied reasoning benchmarks and three robot manipulation benchmarks. For embodied reasoning: EgoPlan-Bench2 (1,321 multiple-choice questions across 24 daily-life scenarios, measuring next-step planning accuracy), RoboVQA (1,893 free-form QA pairs from robot manipulation videos, evaluated via BLEU score), and OpenEQA (1,600+ questions across 180+ real-world environments, evaluated via LLM-based scoring aligned with human preferences). For robot manipulation: SimplerEnv (Google Robot tasks with strong sim-to-real correlation, featuring variations in lighting, textures, backgrounds, and camera poses), LIBERO (four task suites—Spatial, Object, Goal, Long—each evaluated over 500 trials with 3 random seeds), and RoboTwin2.0 (10 bimanual manipulation tasks with easy and hard difficulty settings, where hard introduces domain randomization including clutter, lighting variations, diverse textures, and height changes; evaluated with 100 rollouts per task). For failure recovery, RoboFAC provides 9,440 erroneous manipulation trajectories across 16 tasks in both simulated and real-world environments, with 64K QA pairs covering various failure types.
Base model(s). The primary backbone is Qwen2.5-VL 3B (Bai et al., 2025), initialized from pretrained weights. The choice of 3B scale is deliberate—it sits in a regime where reasoning augmentation can demonstrate meaningful gains over foundation VLAs while the efficiency argument (7× faster than the 7B counterpart) is empirically compelling. Scaling experiments are also reported with Qwen2.5-VL 7B (Table 4 in Appendix B.1) to verify that the method transfers to larger backbones. For the textual teacher, the same Qwen2.5-VL 3B checkpoint is used after SFT and CoT-SFT, then further trained with GRPO. The verbalizer is initialized from Qwen3-0.6B, a separate smaller language model. Action models vary by benchmark: DiT-Policy (Chi et al., 2023) pretrained on OXE for SimplerEnv, and RDT (Liu et al., 2024) pretrained on OXE plus static ALOHA data for LIBERO and RoboTwin2.0.
Metrics. For robot manipulation, the primary metric is task success rate (%), computed as the fraction of evaluation rollouts where the robot successfully completes the specified task. For LIBERO, each suite is evaluated over 500 trials with 3 random seeds; for RoboTwin2.0, each task is evaluated with 100 rollouts under both easy and hard settings; for SimplerEnv, task completion is assessed per the standard protocol. For embodied reasoning: EgoPlan-Bench2 uses accuracy on multiple-choice questions; RoboVQA uses BLEU-1 through BLEU-4 scores against reference answers, with BLEU-Average reported as the mean across B-1 through B-4; OpenEQA uses LLM-based scoring (a judge LLM rates answer quality relative to ground truth, calibrated to human preference). For failure recovery on RoboFAC, the metric is LLM-based scoring of the corrective guidance generated by the model. Inference latency is measured in milliseconds (ms) and broken down into pre-fill, reasoning, and action prediction components (Figure 3f), with total latency serving as the primary efficiency metric.
Baselines. The paper includes three categories of baselines. Foundation VLAs: OpenVLA-7B (Kim et al., 2024), CoT-VLA-7B (Zhao et al., 2025), DP (Chi et al., 2023), ACT (Zhao et al., 2023), π0 (Black et al., 2024), and RDT (Liu et al., 2024). Reasoning VLAs: ThinkAct-7B and ThinkAct-3B (Huang et al., 2025), MolmoAct-7B (Lee et al., 2025), and RoboFAC-3B (Lu et al., 2025). Generalist VLMs and embodied models (for reasoning benchmarks): GPT-4V (Achiam et al., 2023), Gemini-2.5-Flash (Comanici et al., 2025), InternVL2.5-2B and 8B (Chen et al., 2024), InternVL3-2B and 8B (Zhu et al., 2025), NVILA-2B and 8B (Liu et al., 2024), Magma-8B (Yang et al., 2025), RoboBrain2.0-3B and 7B (Team et al., 2025), and the base Qwen2.5-VL-3B and 7B. Additionally, efficient reasoning baselines are compared in Table 6: the textual teacher run without reasoning tokens ("Inference w/o thinking"), constrained to 6 textual tokens, and trained with RL length penalty (Arora and Zanette, 2025) producing ~50-token traces.
Generation budget / compute accounting. For the textual teacher, compute is implicitly measured in number of generated reasoning tokens (~250 tokens for ThinkAct-7B). For the latent student, the key efficiency metric is the number of latent reasoning steps M (set to 6) and spatial tokens K (set to 5), with total inference latency measured in milliseconds. The paper does not use a normalized FLOPs-based budget—instead, it reports wall-clock latency as the primary efficiency measure (Figure 3f), broken into pre-fill, reasoning, and action prediction components. This is appropriate for the paper's motivation (real-time constraints in embodied AI) but prevents direct FLOPs-matched comparisons between methods with different architectures. For GRPO training, the rollout size is N = 5. Training compute is reported descriptively: teacher-student training runs for 4,500 iterations on 16 NVIDIA A100 80GB GPUs; policy learning runs for 20K iterations.
Cross-validation / statistical protocol. The paper does not report cross-validation or statistical significance testing for the manipulation benchmarks. For LIBERO, evaluations use 3 random seeds over 500 trials per suite, following prior work (Kim et al., 2024; Lee et al., 2025), which provides some measure of variance but no confidence intervals are reported. For RoboTwin2.0, each task is evaluated with 100 rollouts under both easy and hard settings. For SimplerEnv, the evaluation follows the standard protocol from OpenVLA. The absence of error bars, confidence intervals, or statistical tests is a notable limitation—all reported success rates are point estimates, and differences of 1–3 percentage points (e.g., Fast-ThinkAct 89.7 vs. textual teacher 88.5 on LIBERO in Table 7) are not assessed for statistical reliability. For the embodied reasoning benchmarks, standard evaluation protocols are followed (multiple-choice accuracy, BLEU, LLM-based scoring), but again without reported variance estimates.

Main Quantitative Results

Robot Manipulation Results

Headline finding: Fast-ThinkAct (3B) outperforms all 7B reasoning VLA baselines on every manipulation benchmark while achieving 7–9× inference speedup. On the LIBERO benchmark (Figure 3a–d and Table 5), Fast-ThinkAct-3B achieves an average success rate of 89.7% across all four suites, compared to 84.4% for ThinkAct-7B, 86.8% for MolmoAct-7B, 83.9% for CoT-VLA-7B, 83.1% for ThinkAct-3B, and 76.5% for OpenVLA-7B. The LIBERO suite-level breakdown (Figure 3a–d) shows Fast-ThinkAct achieving 84.7% on Spatial, 87.5% on Object, 88.3% on Goal, and 92.0% on Long—each representing the highest among all compared methods. The Long suite result is particularly notable because it tests long-horizon planning with mixed variations, precisely the regime where reasoning should help most, and Fast-ThinkAct achieves 92.0% vs. 77.2% for ThinkAct-7B (a +14.8 percentage point improvement) and 79.4% for MolmoAct-7B (+12.6 points).

On SimplerEnv-Google (Figure 3e), Fast-ThinkAct-3B achieves 68.7%, compared to 68.3% for ThinkAct-7B (a marginal improvement of +0.4 points), 64.9% for MolmoAct-7B (+3.8 points), 64.7% for ThinkAct-3B (+4.0 points at the same model scale), and 40.2% for OpenVLA-7B (+28.5 points over the non-reasoning foundation VLA). The near-tie with ThinkAct-7B on SimplerEnv (+0.4 points) while achieving 89.3% latency reduction is the strongest single-datapoint for the paper's efficiency claim—equivalent performance with 9.3× less inference time.

The latency comparison (Figure 3f) provides the quantitative foundation for the efficiency claims. Fast-ThinkAct-3B achieves 805 ms total inference latency, compared to 7,513 ms for ThinkAct-7B (89.3% reduction), 6,723 ms for MolmoAct-7B (88.0% reduction), and 5,674 ms for ThinkAct-3B (85.8% reduction, or 7.0× faster at the same model scale). The breakdown shows three components—pre-fill, reasoning, and action prediction—though exact per-component latencies are not numerically reported in the paper text, only visualized in the bar chart.

On RoboTwin2.0 (Table 1), Fast-ThinkAct achieves 65.7% average success rate on the easy setting and 26.4% on the hard setting, compared to the next-best reasoning VLA ThinkAct at 62.4% easy (+3.3 points) and 24.7% hard (+1.7 points). Against the strongest non-reasoning baseline RDT (56.4% easy, 22.8% hard), Fast-ThinkAct improves by +9.3 points easy and +3.6 points hard. The per-task breakdown reveals that Fast-ThinkAct outperforms ThinkAct on 9 out of 10 easy tasks and 7 out of 10 hard tasks. On long-horizon tasks specifically (average demonstration length exceeding 270 steps: handover mic, handover block, hanging mug, stack blocks two, stack bowls three), Fast-ThinkAct achieves 48.8 easy and 16.8 hard, vs. ThinkAct's 42.8 easy and 15.3 hard, and vs. RDT's 35.0 easy and 12.3 hard. On the hardest individual tasks—hanging mug (hard: 22% vs. 18% for ThinkAct) and stack blocks two (hard: 14% vs. 10% for RDT)—the improvements are consistent but modest, reflecting the inherent difficulty where even reasoning provides limited benefit (the base model's capability on these tasks is fundamentally constrained).

The 3B-scale comparison with ThinkAct-3B (Table 5) isolates the architectural contribution from the scale contribution. At the same 3B backbone, Fast-ThinkAct achieves 89.7 vs. 83.1 on LIBERO (+6.6 points) and 68.7 vs. 64.7 on SimplerEnv (+4.0 points) while being 7.0× faster (805 ms vs. 5,674 ms). This confirms that the latent reasoning architecture, not model scale, drives the improvements.

Embodied Reasoning Results

Headline finding: Fast-ThinkAct (3B) outperforms all baselines on embodied reasoning benchmarks, including proprietary models at larger scales. On EgoPlan-Bench2 (Table 2), Fast-ThinkAct-3B achieves 46.4% average accuracy, compared to 44.0% for ThinkAct-3B (+2.4 points), 42.4% for Gemini-2.5-Flash (+4.0 points), and 32.6% for GPT-4V (+13.8 points). The subcategory breakdown shows consistent improvements across Daily (50.3% vs. ThinkAct's 46.6%), Work (44.3% vs. 41.4%), Recreation (46.4% vs. 45.9%), and Hobbies (43.2% vs. 42.5%). Notably, the proprietary Gemini-2.5-Flash achieves strong performance on Recreation (43.2%) and Work (42.3%) but falls behind on Daily (44.2%) and Hobbies (39.1%).

On RoboVQA (Table 2), Fast-ThinkAct achieves 60.8 BLEU-Average (B-1: 70.1, B-2: 63.0, B-3: 57.2, B-4: 53.0), compared to 55.3 for ThinkAct-3B (+5.5 BLEU-Average), 46.5 for RoboBrain2.0-3B (+14.3), and 26.8 for GPT-4V (+34.0). The improvement over ThinkAct-3B is particularly pronounced at higher n-gram levels: B-4 improves from 49.6 to 53.0 (+3.4), indicating that Fast-ThinkAct's reasoning produces more precise, word-level accurate descriptions of manipulation scenarios.

On OpenEQA (Table 2), Fast-ThinkAct achieves 51.2 LLM-judged score, compared to 48.9 for ThinkAct-3B (+2.3 points), 50.1 for RoboBrain2.0-3B (+1.1), and 49.6 for GPT-4V (+1.6). The margin over ThinkAct-3B is smaller here than on RoboVQA, which the paper does not specifically discuss. One possible interpretation is that OpenEQA's spatial and functional understanding questions may benefit less from the specific reasoning patterns that Fast-ThinkAct excels at compressing compared to the explicit long-horizon reasoning tested in RoboVQA.

The 7B scaling results (Table 4 in Appendix B.1) show Fast-ThinkAct-7B achieving 47.5 on EgoPlan-Bench2, 61.1 BLEU-Average on RoboVQA, and 59.0 on OpenEQA (average: 55.9), compared to ThinkAct-7B at 48.2, 59.8, and 56.2 respectively (average 54.7). The 7B student slightly underperforms the 7B teacher on EgoPlan-Bench2 (47.5 vs. 48.2) while outperforming on RoboVQA and OpenEQA. This is a subtle result: at 3B scale, the student universally outperforms the teacher (Table 3: 52.8 vs. 49.8 average), but at 7B scale the teacher retains an edge on EgoPlan. The paper does not analyze this scaling interaction, which could indicate that the distillation process loses some planning-specific reasoning capability at larger scales, or that the 7B teacher simply has more capacity to benefit from explicit text reasoning on planning tasks.

Failure Recovery Results

Headline finding: Fast-ThinkAct substantially outperforms specialized failure recovery models on both simulated and real-robot settings. On RoboFAC (Figure 5, right bar charts), Fast-ThinkAct-3B achieves 91.1 on the simulation split and 78.9 on the real-world split, compared to the second-best RoboFAC-3B (the model specifically designed for this benchmark) at 80.2 and 62.5 respectively—improvements of +10.9 points and +16.4 points. The base Qwen2.5-VL-3B achieves 29.5 and 16.8, demonstrating that the reasoning distillation, not the base VLM capability, drives the failure recovery performance.

The qualitative examples (Figure 5, left) illustrate the recovery planning capability: for a "missed" grasping failure, Fast-ThinkAct generates a three-step recovery plan (reposition for alignment, execute alignment subtask, insert plug), which involves reasoning about the spatial misalignment and decomposing the recovery into subtasks. For a "dropped" object failure, it generates spatial reasoning: move backward to create distance, adjust laterally to align with the spoon, lower to appropriate height. These examples show that the latent reasoning encodes not just task-level planning but spatial-geometric reasoning about the robot's position relative to objects.

Few-Shot Adaptation Results

Headline finding: Fast-ThinkAct significantly improves few-shot adaptation over non-reasoning and reasoning baselines. Using only 10 demonstrations per task on RoboTwin2.0 (Figure 6), Fast-ThinkAct achieves 33.2% on medium-horizon and 16.5% on long-horizon tasks (hard setting), compared to RDT at 20.1% and 7.0%, ThinkAct at 31.7% and 15.6%, and π0 at 36.6% and 16.8%. On medium-horizon tasks, π0 slightly outperforms Fast-ThinkAct (36.6 vs. 33.2), while on long-horizon tasks Fast-ThinkAct matches π0 (16.5 vs. 16.8). The improvement over RDT (the action model backbone used by Fast-ThinkAct) is substantial—+13.1 points on medium and +9.5 points on long—demonstrating that the latent reasoning provides generalization benefits beyond what the action model architecture alone can achieve with limited data.

Verbalized Reasoning Quality

Headline finding: The latent student's verbalized reasoning is more concise and focused than the teacher's textual reasoning, with less extraneous information. Figure 7 compares teacher and student reasoning on RoboVQA. The teacher produces verbose output with task-relevant content (colored green) mixed with less directly relevant content (colored orange)—for example, describing the scene layout in detail before concluding the action is satisfied. The student's verbalized output is more concise and directly relevant, confirming that the preference-guided distillation filters redundant information. This is a qualitative illustration of the mechanism behind the quantitative improvements: the teacher's verbose reasoning sometimes includes irrelevant or potentially misleading steps.

Figure 10 (Appendix B.2) shows a more dramatic case on OpenEQA where the teacher produces lengthy reasoning with an incorrect final conclusion (red: concluding the room is on the ground floor when it is not), while the student produces compact, correct reasoning (green). This demonstrates an advantage of the preference-guided approach beyond efficiency—the teacher's GRPO training does not guarantee every trace is correct, and the DPO-based selection of winning vs. losing traces allows the student to learn from the teacher's successes while avoiding its failures. The student's verbalized reasoning arrives at the correct answer while being more concise, suggesting the latent space captures the discriminative reasoning patterns (features that distinguish correct from incorrect conclusions) rather than the generative patterns (all steps the teacher tends to produce).

Ablation Studies and Robustness Checks

Ablation of loss components (Table 3, embodied reasoning; Table 7, manipulation): Removing ℒ_verb from the student training drops average embodied reasoning performance from 52.8 to 48.5 (Table 3)—below the textual teacher's 49.8. Further removing ℒ_distill drops performance to 47.7. On manipulation benchmarks (Table 7), the pattern is consistent: removing ℒ_verb drops average from 68.2 to 66.9, and removing both drops to 64.9. Critically, the full Fast-ThinkAct (68.2) outperforms the textual teacher baseline (67.2), confirming that the distillation process yields representations superior to the teacher's explicit text reasoning, not merely approximating it. The fact that removing ℒ_verb alone causes performance to fall below the teacher (48.5 vs. 49.8 in Table 3) demonstrates that naive latent representation learning without preference guidance is worse than explicit text reasoning—the verbalizer-based preference signal is essential, not optional.

Ablation of training stages (Table 3): The textual teacher (CoT-SFT + GRPO) achieves 49.8 average on embodied reasoning. CoT-SFT alone (without teacher-student distillation) achieves 45.0—worse than SFT-only at 46.5. This non-monotonic relationship is noteworthy: adding chain-of-thought supervision to SFT degrades average performance (46.5 → 45.0), which the paper attributes to "naïve chain-of-thought supervision [benefiting] open-ended QA but introduc[ing] verbosity that hinders structured reasoning tasks." The jump from 45.0 (CoT-SFT) to 49.8 (textual teacher with GRPO) to 52.8 (Fast-ThinkAct) demonstrates that each stage—reasoning format learning, quality optimization via RL, and compact distillation—contributes additively. The manipulation ablation (Table 7) shows the same pattern: SFT-only (64.7) < CoT-SFT (65.4) < textual teacher (67.2) < Fast-ThinkAct (68.2).

Ablation of latent reasoning steps M (Appendix B.3): Varying the number of latent reasoning tokens M shows an inverted-U relationship with performance on LIBERO-Average. With M = 1, success rate drops to approximately 86% (exact value not numerically reported, estimated from the bar chart in Table 8). M = 6 (the default) achieves 89.7%. M = 30 drops to approximately 88.5%, and M = 100 drops to approximately 88%. The paper's interpretation is that "too few steps limit reasoning capacity, while excessive steps might introduce redundant or noisy information." The fact that M = 100 underperforms M = 6 by ~1.7 points is evidence that the latent space can be over-parameterized—additional latent tokens don't just waste computation, they can actively degrade the representation by introducing degrees of freedom that capture noise rather than signal. This is a non-obvious result that supports the paper's claim that compact representations can outperform longer ones, not just match them.

Ablation of action model conditioning method (Appendix B.3): Three methods for extracting visual planning context c_t from the student VLM are compared on LIBERO. Early-layer KV cache (the default): 89.7. Late-layer KV cache: 88.3. Output hidden states from spatial tokens: 87.1. The early-layer KV advantage over output hidden states (+2.6 points) is substantial. This validates the paper's hypothesis that visual planning information resides in mid-level representations—the KV cache from early layers preserves multi-head attention structure and lower-level spatial features that are more directly useful for action prediction than the abstract representations in later layers or the final hidden states.

Comparison with efficient textual reasoning baselines (Table 6): This is the most diagnostic ablation for the paper's central claim. Four alternatives are compared on embodied reasoning benchmarks:

Textual teacher (full reasoning): 49.8 average
Textual teacher with reasoning removed at inference: 46.5
Textual teacher constrained to 6 textual tokens at inference: 46.3
Textual teacher trained with RL length penalty (~50 tokens): 47.8
Fast-ThinkAct (6 latent tokens): 53.3

The results demonstrate a clear pattern: naive text compression (removing reasoning or constraining to 6 tokens) substantially degrades performance below the full teacher baseline, and even sophisticated compression via RL length penalty (47.8) doesn't recover to baseline. Only the latent distillation approach (53.3) both compresses and improves. This is the paper's strongest evidence that latent reasoning is not just compressed text reasoning—it's a qualitatively different representation that the distillation process optimizes.

Scaling to larger model size (Table 4, Appendix B.1): Fast-ThinkAct applied to Qwen2.5-VL-7B achieves 47.5 on EgoPlan-Bench2, 61.1 BLEU-Average on RoboVQA, and 59.0 on OpenEQA (average 55.9), compared to ThinkAct-7B at 48.2, 59.8, 56.2 (average 54.7). The student outperforms the teacher on RoboVQA and OpenEQA but slightly underperforms on EgoPlan-Bench2 (47.5 vs. 48.2). This partly validates scaling—the method transfers to larger backbones—but the EgoPlan result suggests a potential scaling interaction worth investigating: at larger scales, the teacher's explicit text reasoning may capture planning-specific patterns that are harder to compress into 6 latent tokens, or the 7B model's greater capacity for text generation may create a wider quality gap between best and worst traces that the distillation process doesn't fully capture.

Spatial token prediction format (Appendix A.2): The 6D waypoint encoding ([x_single, y_single, x_left, y_left, x_right, y_right]) with dimension masking for single-arm vs. bimanual tasks is described but not ablated. There is no comparison to alternative formats (e.g., predicting only the relevant dimensions, using separate heads for single-arm and bimanual). This is a minor limitation—it's possible that the unified 6D format introduces noise (bimanual dimensions receiving gradient signal on single-arm data) that slightly degrades performance.

Critical Assessment

Claim: "Fast-ThinkAct achieves strong performance with up to 89.3% reduced inference latency over state-of-the-art reasoning VLAs." This claim is supported by the latency measurements in Figure 3f, with the specific comparison being 805 ms (Fast-ThinkAct-3B) vs. 7,513 ms (ThinkAct-7B) and 6,723 ms (MolmoAct-7B). However, the "up to 89.3%" framing masks important nuance. The 89.3% figure compares a 3B student against a 7B teacher—the comparison at equal model scale (Fast-ThinkAct-3B vs. ThinkAct-3B) shows 85.8% reduction (805 ms vs. 5,674 ms, or 7.0× faster). The paper should distinguish between latency reduction from model compression (7B → 3B, which any distillation method could claim) and latency reduction from architecture (text → latent reasoning, which is the paper's contribution). If ThinkAct-3B is the appropriate baseline, the architecture-specific speedup is 7.0×, not 9.3×. The 9.3× figure combines two effects and somewhat overstates the architectural contribution.

Additionally, the latency breakdown in Figure 3f shows three components (pre-fill, reasoning, action prediction) but the paper doesn't report numerical values for each component, only the total. This makes it impossible to assess whether the speedup comes entirely from reduced reasoning time (as claimed) or partially from other factors (e.g., the 3B model having faster pre-fill than the 7B). The paper's argument that latent reasoning drives the speedup would be stronger with a per-component latency table.

Claim: "Fast-ThinkAct achieves improved performance over state-of-the-art reasoning VLAs" on manipulation benchmarks. This claim is supported for the specific benchmarks and baselines tested. On LIBERO, Fast-ThinkAct (89.7%) outperforms ThinkAct-7B (84.4%), MolmoAct-7B (86.8%), and CoT-VLA-7B (83.9%). On SimplerEnv, it achieves 68.7% vs. 68.3% for ThinkAct-7B. On RoboTwin2.0, it achieves 65.7% easy / 26.4% hard vs. 62.4% / 24.7% for ThinkAct.

However, there are several qualifications. First, the margins on SimplerEnv (+0.4 points over ThinkAct-7B) and some RoboTwin2.0 tasks are small enough that without confidence intervals, it's unclear whether they represent reliable differences or sampling noise. The LIBERO evaluation uses 500 trials with 3 seeds—this is reasonable but confidence intervals (e.g., 95% CI based on binomial proportion) would clarify which differences are statistically significant. A 0.4-point difference on SimplerEnv with unknown evaluation sample size could easily be noise.

Second, the comparison is not fully controlled for training data. The textual teacher is trained with GRPO on 50K samples; the student is additionally trained with the three loss components on the same data. The student therefore sees more optimization steps and a richer training signal than the teacher. An ideal controlled comparison would give the teacher an equivalent compute budget for additional training (e.g., more GRPO iterations or an auxiliary loss) to isolate the architectural contribution from the training budget contribution. As it stands, it's possible that some of the student's gains come from simply training longer rather than from the latent architecture per se.

Third, the strongest baseline—ThinkAct-7B—uses a 7B backbone, while Fast-ThinkAct uses 3B. The fact that the 3B student outperforms the 7B teacher is genuine evidence for the method's effectiveness, but the 3B backbone also has 7× lower latency independent of the architectural change. The ablation comparing Fast-ThinkAct-3B vs. ThinkAct-3B (Table 5) partially addresses this—showing +6.6 points on LIBERO and +4.0 on SimplerEnv at equal scale—but the ThinkAct-3B result is only reported in Table 5, not in the main paper figures, somewhat burying the most controlled comparison.

Claim: "Fast-ThinkAct achieves strong performance on embodied reasoning benchmarks" including outperforming proprietary models. This claim is supported for the benchmarks tested (Table 2). Fast-ThinkAct-3B achieves 46.4 on EgoPlan-Bench2 vs. 42.4 for Gemini-2.5-Flash and 32.6 for GPT-4V; 60.8 BLEU-Average on RoboVQA vs. 28.9 for Gemini and 26.8 for GPT-4V; 51.2 on OpenEQA vs. 45.3 for Gemini and 49.6 for GPT-4V. The comparisons against proprietary models are genuinely impressive for a 3B open-weight model.

However, the proprietary model comparisons have a significant confound: GPT-4V and Gemini-2.5-Flash are generalist VLMs not specifically trained on embodied data, while Fast-ThinkAct undergoes SFT on 4M embodied-specific samples and CoT-SFT on 365K reasoning samples. The gap between Fast-ThinkAct and the proprietary models partly reflects domain-specific training rather than architectural superiority. A more informative baseline would be GPT-4V or Gemini fine-tuned on the same embodied data, or at minimum prompted with few-shot examples from the embodied domain. The comparison against RoboBrain2.0-3B (which is also trained on embodied data and achieves 46.1 average to Fast-ThinkAct's 52.8) is a fairer head-to-head—and here the gap is +6.7 points, still substantial but less dramatic than the proprietary comparisons.

Additionally, the OpenEQA result (51.2 vs. 50.1 for RoboBrain2.0-3B) has a margin of only +1.1 points—among the smallest improvements in the paper. Without confidence intervals, this could be within noise. The paper doesn't discuss why OpenEQA shows the smallest gain, which might indicate that the spatial understanding tested by OpenEQA benefits less from the specific reasoning patterns that Fast-ThinkAct compresses.

Claim: "Reasoning enables long-horizon planning." This claim is partially supported by the RoboTwin2.0 results (Table 1). On long-horizon tasks specifically (average 270+ steps), Fast-ThinkAct achieves 48.8 easy / 16.8 hard vs. RDT's 35.0 / 12.3—substantial gains. However, the "reasoning enables" causal claim is hard to isolate because Fast-ThinkAct differs from RDT in multiple ways beyond the reasoning module: RDT is an action-only model, while Fast-ThinkAct adds a VLM backbone, visual plan distillation, and spatial token conditioning. The improvement could come partially from the VLM's visual understanding, not specifically from the reasoning.

A cleaner ablation would compare Fast-ThinkAct with and without the latent reasoning tokens (e.g., pass the observation-instruction directly to the action model without the student VLM, or use the student VLM without latent tokens as a visual encoder). The paper doesn't run this ablation. The closest evidence is the comparison of Fast-ThinkAct vs. RDT (the action model backbone), but this conflates reasoning with the entire VLM processing pipeline.

The qualitative visualizations in Figure 4 are compelling but anecdotal—they demonstrate that Fast-ThinkAct can plan long-horizon trajectories on selected examples, not that it does so more reliably than baselines across the full distribution.

Claim: "Reasoning enables failure recovery." This claim is supported for the RoboFAC benchmark (Figure 5). Fast-ThinkAct achieves 91.1 on RoboFAC-Sim and 78.9 on RoboFAC-Real, compared to the specialized RoboFAC-3B model at 80.2 and 62.5 respectively. These are large margins (+10.9 and +16.4 points). However, RoboFAC evaluates failure identification and corrective instruction generation—it tests whether the model can analyze a video of a failed manipulation and suggest recovery steps. This is a reasoning benchmark, not a closed-loop manipulation benchmark. The claim that reasoning enables failure recovery is supported for planning recovery from observed failures, but the paper does not evaluate whether Fast-ThinkAct actually executes recovery in closed-loop manipulation. A closed-loop experiment where the model detects its own failures and replans would be a much stronger test but is absent.

Claim: "Reasoning enables few-shot adaptation." This claim is supported with qualification by Figure 6. Fast-ThinkAct improves over RDT by +13.1 points on medium and +9.5 points on long-horizon tasks with only 10 demonstrations. However, on medium-horizon tasks, π0 achieves 36.6 vs. Fast-ThinkAct's 33.2—the reasoning model does not outperform the best non-reasoning baseline. On long-horizon, Fast-ThinkAct matches π0 (16.5 vs. 16.8). So the claim that "reasoning enables few-shot adaptation" is true relative to the RDT backbone, but not universally—π0 achieves similar or better few-shot performance without explicit reasoning. This is not discussed in the paper. One interpretation is that π0's flow-matching architecture or its own pretraining provides implicit reasoning capabilities, but this is speculative without further analysis.

Missing experiments that would strengthen the paper:

Closed-loop failure recovery: The RoboFAC evaluation tests whether the model can generate corrective text, not whether it can actually execute recovery. A closed-loop manipulation experiment where the model encounters failures, detects them via the verbalizer (or some other mechanism), and replans actions would directly test the "reasoning enables failure recovery" claim for manipulation, not just for language generation.
Latency breakdown by component: Reporting pre-fill, reasoning, and action prediction latencies numerically (not just as a bar chart) would allow readers to assess how much of the speedup comes from each component and whether the action model's diffusion process is a new bottleneck.
Statistical significance testing: Reporting confidence intervals or standard deviations for the LIBERO, SimplerEnv, and RoboTwin2.0 success rates would clarify which differences are reliable. With 500 trials, a 1–2 percentage point difference may or may not be statistically significant depending on the variance.
Ablation of the verbalizer warmup phase: The paper trains the verbalizer with language modeling loss for 3,000 iterations before switching to DPO for 1,500 iterations. Ablating this schedule (e.g., DPO from the start, or different warmup lengths) would test whether the two-phase training is necessary or merely convenient.
Generalization to unseen embodiments: All evaluation is on benchmarks using specific robot morphologies (Google Robot for SimplerEnv, Franka for LIBERO, bimanual arms for RoboTwin2.0). Testing whether the same trained student VLM can condition action models for entirely different robot morphologies without retraining the VLM would test the modularity claim more strongly.
Comparison with ECoT-Lite: The paper critiques ECoT-Lite (Chen et al., 2025) as suffering from train-test mismatch but does not include it as a baseline in any experiment. A head-to-head comparison on the same benchmarks would substantiate the paper's claim that latent reasoning outperforms reasoning dropout.
Action model without reasoning vs. with reasoning (controlled): Using the student VLM as a visual encoder without latent reasoning tokens (only the spatial tokens, conditioned on observation and instruction directly) would isolate the contribution of the reasoning tokens specifically, as opposed to the VLM's visual processing generally.
Real-robot evaluation: All manipulation results are in simulation. While SimplerEnv is chosen for its "strong sim-to-real correlation" (Li et al., 2024), the paper's motivation heavily emphasizes real-time constraints in real-world deployment. A real-robot demonstration—even a small-scale one—would significantly strengthen the practical impact claims.

6. Limitations and Trade-offs

6.1 Closed-Loop Failure Recovery Is Evaluated Only as Language Generation, Not as Executed Manipulation

The assumption or constraint. The paper claims that "[a] key advantage of reasoning-based VLAs is their ability to identify runtime failures and provide corrective guidance for recovery" (Section 4.3). The evaluation of this capability relies entirely on RoboFAC (Lu et al., 2025), a benchmark that tests whether a model can analyze a video of a failed manipulation and generate textual corrective instructions—there is no closed-loop evaluation where Fast-ThinkAct detects its own failures during task execution and replans actions autonomously.

The consequence. The RoboFAC results (Figure 5: 91.1 RoboFAC-Sim, 78.9 RoboFAC-Real) demonstrate that Fast-ThinkAct can describe how to recover from an observed failure. They do not demonstrate that the model, when deployed, can (1) detect that its own action sequence has gone off-track, (2) interrupt execution, (3) generate a recovery plan as latents, and (4) successfully execute that plan. These are substantially harder capabilities. Detection requires the model to compare expected vs. observed outcomes, which may need temporal reasoning across multiple observation frames. Execution requires the recovery plan to be physically feasible from the current (potentially awkward) robot state, not just semantically sensible. A practitioner evaluating Fast-ThinkAct for deployment where failures are costly (e.g., in-home assistance, surgical robotics) cannot infer closed-loop recovery reliability from the RoboFAC results.

What evidence exists in the paper. Only the RoboFAC benchmark, which is an offline language generation task. The paper provides no experiments where Fast-ThinkAct encounters a manipulation failure during evaluation, identifies it autonomously, and recovers. The qualitative examples (Figure 5, left) show the model generating plausible recovery text given a labeled failure video, not detecting the failure from raw observations. The successful task completion rates on LIBERO and RoboTwin2.0 (Figure 3, Table 1) represent first-attempt success—failures in these evaluations are simply counted as incorrect, with no measurement of whether the model could recover on a second attempt.

Mitigation status. Not addressed. The paper does not acknowledge the gap between language-based and closed-loop failure recovery evaluation. This is a significant omission given that the paper's motivation emphasizes real-time safety in embodied deployment (Section 1: "poses safety risks in time-critical scenarios").

6.2 Difficulty Estimation Cost Is Not Accounted for in the Headline Latency Comparisons

The assumption or constraint. The paper's headline latency comparison (Figure 3f: Fast-ThinkAct-3B at 805 ms vs. ThinkAct-7B at 7,513 ms, an 89.3% reduction) measures only the per-timestep inference cost of the student model—generating latent tokens, predicting waypoints, and denoising actions. This comparison does not account for the substantial training-time computation required to produce the student model. While this is standard for inference-efficiency papers (training cost is amortized), there is a more subtle unaccounted cost: the teacher model must be trained first to provide the preference pairs and visual plan targets, and the teacher training uses GRPO with 5 rollouts per sample on a dataset of ~50K samples. The student then requires 4,500 iterations of training with batch size 128 on 16 A100 GPUs. The total training compute is not reported in GPU-hours or FLOPs.

The consequence. For a practitioner deciding whether to adopt Fast-ThinkAct, the relevant comparison is not just inference latency but total cost of ownership: training compute + inference compute over the deployment lifetime. If the deployment involves a relatively small number of inference queries, the training cost dominates and the efficiency advantage may not materialize. The paper's framing emphasizes real-time deployment—implicitly assuming high inference volume—but provides no analysis of the breakeven point where inference savings outweigh training cost. This is a standard limitation of distillation-based efficiency methods and is not unique to this paper, but the paper's strong emphasis on practical deployment makes the omission more consequential.

What evidence exists in the paper. The training configuration is described in Sections 4.1 and A.2 (4,500 iterations, batch size 128, 16 A100 GPUs), but total GPU-hours or FLOPs are not reported. The ablation comparing Fast-ThinkAct against the textual teacher (Table 3: 52.8 vs. 49.8 average; Table 7: 68.2 vs. 67.2 on manipulation) demonstrates that the student outperforms the teacher at equal model scale, but this comparison does not account for the fact that the student is trained with richer supervision (the teacher's outputs plus preference pairs plus visual plan distillation) over more optimization steps than the teacher. An ideal cost-controlled comparison would give the teacher an equivalent compute budget for additional GRPO training and measure whether the teacher could match the student's performance without latent compression—a direct test of whether the latent representation is necessary or merely a more compute-efficient way to reach the same performance level.

Mitigation status. Not addressed. The paper does not discuss training cost or provide breakeven analysis. This is standard for the field (most VLA papers report only inference metrics) but limits the practical guidance the paper can offer. A future practitioner would need to independently estimate whether the training investment is justified for their deployment scale.

6.3 All Results Are on a Single Model Family with Extremely Limited Real-World Validation

The assumption or constraint. All experiments use the Qwen2.5-VL model family (3B for main results, 7B for scaling experiments; Bai et al., 2025) with the same pretraining data, vision encoder, and tokenizer. The verbalizer is initialized from Qwen3-0.6B, another model in the same family. The action models (DiT-Policy, RDT) are based on diffusion Transformers. The evaluation is entirely in simulation—SimplerEnv, LIBERO, and RoboTwin2.0 are simulated benchmarks. The RoboFAC-Real split uses real-robot videos, but the model's task is language generation, not robot control.

The consequence. It is unknown whether the method transfers to different VLM backbones (e.g., LLaVA, InternVL, PaLI), different language model families for the verbalizer (e.g., LLaMA, Gemma), or different action model architectures (e.g., autoregressive action prediction, flow matching). The Qwen2.5-VL family may have specific properties—attention patterns, vision-language alignment quality, model scale efficiency—that make latent distillation more or less effective than it would be with other architectures. Similarly, simulation-to-real transfer is an open problem in robotics: policies that succeed in simulation often degrade on physical robots due to visual domain shift, dynamics mismatch, and sensor noise. Fast-ThinkAct's latency advantage is most relevant for physical deployment where real-time control matters, but the paper provides zero physical robot experiments.

What evidence exists in the paper. The scaling experiment (Table 4) shows that Fast-ThinkAct-7B achieves 55.9 average on embodied reasoning vs. ThinkAct-7B at 54.7—a +1.2 point improvement, smaller than the 3B-scale improvement (+3.0 points over the textual teacher in Table 3). This suggests a scaling interaction: the method's benefit may diminish at larger model scales, or the 7B teacher's explicit reasoning may be harder to compress. However, with only two scale points and one model family, this remains suggestive rather than conclusive. The paper acknowledges in Section A.2 that "the use of different action models also demonstrates that our approach is agnostic to the underlying action model choice," but the action model variation (DiT-Policy vs. RDT) is tested on different benchmarks—it is not an ablation where both action models are evaluated on the same tasks. The claim of action-model agnosticism is therefore supported only by the method working with two different architectures on different tasks, not by a controlled comparison.

Mitigation status. Partially acknowledged. The paper does not discuss the single-model-family limitation, but the RoboTwin2.0 evaluation includes domain randomization (clutter, lighting variations, diverse textures, height changes) in the hard setting, which provides some evidence of robustness to visual variation within simulation. The paper does not claim sim-to-real transfer or real-robot validation, but given the emphasis on real-time safety constraints for "embodied AI applications such as robotic manipulation and autonomous driving" (Section 1), the absence of any physical evaluation is a mismatch between motivation and evidence.

6.4 The Hardest Problems Remain Effectively Unsolved Despite Reasoning Augmentation

The assumption or constraint. The paper positions reasoning as the key to generalization beyond training distributions, particularly for "long-horizon planning, self-correction from failures, and adaptation to novel scenarios" (Section 1). The latent compression is designed to preserve these benefits while reducing latency. However, the method—like all prior reasoning VLAs—provides minimal benefit on the most difficult tasks.

The consequence. On RoboTwin2.0 hard tasks, Fast-ThinkAct achieves only 26.4% average success rate, compared to 22.8% for the non-reasoning RDT baseline (Table 1)—a +3.6 percentage point improvement that, while consistent, leaves ~74% of hard tasks unsolved. On individual hard tasks such as stack blocks two (14% for RDT, improved to an unstated value for Fast-ThinkAct; the Table 1 value for Fast-ThinkAct on hard stack blocks two is 14%, matching RDT), the benefit is zero. On the hardest LIBERO tasks (difficulty not stratified in the paper), no per-task breakdown is provided, so it's unclear whether the 89.7% average masks near-zero performance on the most challenging subset. On RoboTwin2.0 long-horizon tasks (hard setting), performance ranges from 5% (stack blocks two) to 42% (handover mic)—the variance is enormous, and the worst-case tasks see minimal improvement.

This pattern echoes a finding from the training-inference tradeoff literature: test-time compute amplifies existing capabilities but does not create new ones. The latent student learns to compress reasoning patterns from the teacher, which in turn learns reasoning from task rewards. If neither the teacher nor the student can solve a task class—because the base VLM fundamentally lacks the visual understanding, spatial reasoning, or physical common sense required—then no amount of reasoning distillation will help. The paper's results are consistent with this hypothesis but do not explicitly analyze the failure modes on hard tasks. A practitioner evaluating Fast-ThinkAct for a safety-critical application with difficult manipulation requirements (e.g., deformable object manipulation, tool use in cluttered scenes) should expect that the method provides diminishing returns as task complexity increases, with a hard ceiling determined by the base model's capability.

What evidence exists in the paper. The RoboTwin2.0 hard-setting results (Table 1) demonstrate the performance gap clearly, with several tasks below 20% success rate. The LIBERO results (Figure 3a–d) aggregate over task suites without difficulty stratification, so the worst-case behavior is not reported. The paper does not analyze why specific tasks fail (e.g., is the visual plan incorrect, or is the action model unable to execute the plan?), which would help practitioners predict where the method will and will not help. The 7B scaling experiment (Table 4) shows improved performance (+1.2 average over 3B on embodied reasoning), suggesting that a larger backbone might partially address the capability ceiling, but manipulation experiments at 7B scale are not reported.

Mitigation status. Partially acknowledged. The paper's emphasis on "long-horizon planning, few-shot adaptation, and failure recovery" (abstract) as demonstrated capabilities implicitly acknowledges that these are the hard problems the method targets. However, the gap between the claimed capabilities and the worst-case performance (e.g., 5% on stack blocks two hard) is not discussed. The paper does not provide guidance on how to predict which tasks will benefit from reasoning augmentation, which is a practical necessity for deployment planning.

6.5 The Verbalizer Introduces a Hallucination Risk, and Faithfulness of Verbalized Reasoning Is Not Guaranteed

The assumption or constraint. The verbalizer LLM (Qwen3-0.6B) decodes the student's latent tokens into natural language reasoning for interpretability. The paper acknowledges that "as our verbalizer V_ψ is built upon a pre-trained LLM, it inevitably inherits language model limitations, including hallucination, occasionally producing plausible but inaccurate descriptions" (Section 5, Limitations and Future Works).

The consequence. If the verbalizer is used for interpretability—for example, to inspect why the model chose a particular action or to verify that its reasoning is safe—the decoded text may not faithfully represent the information actually encoded in the latent tokens. The student is trained to produce latents that make the verbalizer prefer τ^+ over τ^− (Equation 4), not latents that are faithfully decoded in an absolute sense. The verbalizer could learn to produce plausible-sounding reasoning that correlates with good actions without actually extracting the specific planning content from the latents. In the worst case, a practitioner could inspect the verbalized reasoning, find it reasonable, and approve an action sequence that the latent representations do not actually support—the verbalizer's output would be a confabulation that happens to correlate with correct behavior on the training distribution.

This risk is partially mitigated by the fact that the verbalizer is not used for action execution (only the latent representations condition the action model), but it creates a safety concern for debugging and oversight. If an operator cannot trust the verbalized explanation, the interpretability benefit of the verbalizer is undermined.

What evidence exists in the paper. Figure 7 and Figure 10 show that the verbalized reasoning is qualitatively more concise and sometimes more accurate than the teacher's textual reasoning. However, these are selected examples demonstrating successful verbalization. The paper provides no quantitative measure of verbalization faithfulness—there is no evaluation of how often the decoded text accurately reflects the latent content (e.g., by comparing the action model's output when conditioned on latents vs. when conditioned on the decoded text directly, or by measuring whether latent perturbations that change the action also change the decoded text). The failure recovery results on RoboFAC (Figure 5) show that the model generates plausible recovery plans, but this evaluates the quality of the generated text (which could be driven by the verbalizer's own language modeling capability rather than faithful decoding of latents), not the faithfulness of the decoding process itself.

Mitigation status. Explicitly acknowledged in Section 5: "this does not affect action execution during inference, as the verbalizer serves only for interpretability while action prediction uses the grounded latent representations from visual plan distillation. To further improve the faithfulness of verbalized reasoning, we can consider incorporating grounding-aware objectives or hallucination suppression techniques in future work." The paper therefore recognizes the limitation but offers no concrete mitigation beyond flagging future work. The claim that hallucination "does not affect action execution" is true but only partially reassuring—it means actions are not directly corrupted by verbalizer errors, but it also means the verbalizer provides no safety guarantee. A practitioner who relies on the verbalizer for oversight could be misled.

6.6 The Latent Reasoning Step Count Was Tuned on the Target Benchmark, Not Validated as a General Principle

The assumption or constraint. The number of latent reasoning tokens M is set to 6 based on an ablation study (Appendix B.3, Table 8) conducted on the LIBERO benchmark, which shows M = 6 achieving 89.7% success rate compared to M = 1 (~86%), M = 30 (~88.5%), and M = 100 (~88%).

The consequence. The paper presents M = 6 as the optimal configuration and uses it across all benchmarks—embodied reasoning (EgoPlan-Bench2, RoboVQA, OpenEQA), manipulation (SimplerEnv, LIBERO, RoboTwin2.0), and failure recovery (RoboFAC). However, the M-ablation was performed only on LIBERO-Average. It is unknown whether M = 6 is optimal for other benchmarks, other difficulty levels within benchmarks, or other model scales. The inverted-U relationship (M = 1 underperforming, M = 100 also underperforming) is plausible—too few tokens limit capacity, too many introduce noise—but the optimal point likely depends on task complexity and the information density of the teacher's reasoning traces. On embodied reasoning benchmarks (which involve QA-style tasks rather than manipulation), a different M might be optimal; similarly, on RoboTwin2.0 hard tasks with long-horizon planning, the reasoning may benefit from more latent capacity.

More broadly, this is a hyperparameter sensitivity concern. The training pipeline has many unablated hyperparameters: the balance of SFT vs. CoT-SFT data, the number of teacher GRPO rollouts (N = 5), the DPO strength β = 0.1, the verbalizer warmup duration (3,000 iterations before switching to L_verb), the number of spatial tokens K = 5, and the choice of early-layer vs. late-layer KV cache extraction. Only M and the KV cache layer choice are ablated in the paper. A practitioner attempting to reproduce the method on a new domain or model family has limited guidance for tuning these hyperparameters, and the sensitivity of results to these choices is unknown.

What evidence exists in the paper. The M-ablation (Table 8) and the KV cache layer ablation (Appendix B.3) are the only hyperparameter sensitivity analyses. All other hyperparameters are reported as fixed values without justification or ablation. The paper does not discuss whether the same M works for the 7B model or whether different benchmarks would benefit from different M values.

Mitigation status. Not addressed. The paper treats M = 6 as a fixed design choice validated on one benchmark and applies it universally. The "Limitations and Future Works" section (Section 5) does not mention hyperparameter sensitivity or generalizability of the optimal configuration. A more robust approach would be to validate the M-ablation on at least one additional benchmark (e.g., RoboVQA for reasoning, SimplerEnv for manipulation) to demonstrate that the optimal M transfers, or to provide a principled method for selecting M based on task characteristics.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a capability-efficiency inversion into the reasoning VLA literature: it demonstrates that compact latent reasoning can simultaneously improve both task performance and inference speed over explicit textual chain-of-thought. Prior work treated these as a tradeoff—longer reasoning chains improve generalization but cost latency (the 0.1 Hz vs. 1–15 Hz mismatch the paper describes in Section 1). Fast-ThinkAct breaks this assumed coupling by showing that 6 continuous latent tokens can outperform ~250 text tokens across every benchmark tested (LIBERO: 89.7% vs. 84.4% for ThinkAct-7B; RoboVQA: 60.8 vs. 55.3 BLEU-Average for ThinkAct-3B; Table 1: 65.7 vs. 62.4 on RoboTwin2.0 easy). This is not a Pareto improvement where latency is traded for accuracy—both improve simultaneously. The conceptual shift is from "how much reasoning can we afford given a latency budget?" to "what is the most information-dense form of embodied reasoning, and how do we train models to produce it?"

The magnitude of the shift is significant but bounded. It is not a paradigm shift in the Kuhnian sense—the underlying architecture (VLM encoder-decoder, diffusion action head, teacher-student distillation) is assembled from established components. Rather, it is a reframing with practical consequences: the field's default assumption that explicit linguistic decomposition is necessary for good embodied planning is empirically falsified for the benchmarks and model scale tested. The paper's strongest evidence for this reframing comes from Table 6, where the textual teacher constrained to 6 text tokens achieves 46.3 average on embodied reasoning (below the full teacher's 49.8), while the latent student with 6 continuous tokens achieves 53.3. This demonstrates that the latent representation is not merely compressed text—it is a qualitatively different, more information-dense encoding that the distillation process actively optimizes.

The paper also resolves a tension that has been growing in the embodied reasoning community between two camps: those emphasizing richer reasoning (longer CoT traces, visual subgoals, spatial descriptions; Zawalski et al., 2024; Zhao et al., 2025; Lee et al., 2025) and those emphasizing efficiency (reasoning dropout, length penalties; Chen et al., 2025; Dai et al., 2025). Fast-ThinkAct's results imply that this tension was partly an artifact of representation choice—reasoning quality and representation efficiency are not in opposition if the intermediate format is optimized for information density rather than human readability. The verbalizer mechanism (Equation 4) provides a proof of concept for this separation: the model learns to reason in a format optimized for downstream task performance (action prediction), with human-interpretable text available only as an optional byproduct of a separate decoding step.

The practical consequence is a shift in research prioritization. Before this work, improving reasoning VLAs meant either (a) making reasoning more sophisticated (better CoT annotations, better RL rewards) at the cost of more latency, or (b) accepting the latency-performance tradeoff and truncating reasoning. Fast-ThinkAct opens a third axis: representation optimization—training models to reason in more efficient internal formats while preserving or improving capability. This makes research on latent representation learning, preference-based distillation, and multimodal alignment (between visual, spatial, and linguistic reasoning) more attractive, while making research on purely textual reasoning length optimization (e.g., RL length penalties producing shorter text traces) less attractive as a primary efficiency strategy, since the paper shows those methods degrade performance below the textual teacher baseline (Table 6, RL length penalty: 47.8 vs. 49.8 for full teacher) while latent distillation improves it.

Follow-Up Research This Work Enables

Scaling the latent reasoning token count with task complexity. The paper's M-ablation (Table 8 in Appendix B.3) shows an inverted-U relationship on LIBERO-Average: M=1 underperforms M=6, while M=30 and M=100 degrade slightly. This result is from one benchmark aggregated across task suites of varying difficulty. A concrete follow-up would test whether the optimal M scales with task horizon: on RoboTwin2.0, compare M=6 vs. M=16 vs. M=32 separately for short tasks (80–100 demonstration steps), medium tasks (110–220 steps), and long tasks (270–470 steps). The hypothesis—inspired by the paper's finding that long-horizon tasks benefit most from reasoning (Table 1: Fast-ThinkAct improves over RDT by +13.8 points on long-horizon easy vs. +9.3 overall)—is that harder tasks need more latent capacity, and that the current M=6 was tuned on a benchmark averaging across difficulty levels, potentially under-provisioning capacity for the hardest tasks. A positive result would establish a scaling law for latent reasoning tokens analogous to compute-optimal test-time scaling. A negative result (same M optimal across all horizons) would suggest the latent space saturates quickly and that further improvements require better training objectives, not more capacity.

Faithfulness auditing of verbalized reasoning against latent content. The paper acknowledges in Section 5 that the verbalizer can hallucinate "plausible but inaccurate descriptions" that do not affect action execution but undermine interpretability. A concrete diagnostic experiment: take the student's latent tokens z, decode them to text via the verbalizer to get a reasoning trace τ_decoded, then feed τ_decoded (as text tokens) directly into a copy of the student VLM (without latent generation) and compare the resulting KV cache c_t and predicted actions to those from the original latent pathway. If the verbalized text faithfully captures the latent content, the text-conditioned actions should closely match the latent-conditioned actions. If they diverge substantially, the verbalizer is confabulating—producing plausible language that does not reflect the actual planning computation. This experiment would quantify faithfulness across benchmarks (RoboVQA, RoboFAC, OpenEQA) and task types (spatial reasoning vs. task planning vs. failure diagnosis), identifying where the verbalizer is trustworthy for oversight and where it is not. The paper's qualitative examples (Figures 7 and 10) show the verbalizer sometimes producing more accurate reasoning than the teacher, but selected examples cannot establish statistical reliability.

Closed-loop failure recovery with autonomous failure detection. The paper's RoboFAC evaluation (Figure 5) tests post-hoc failure analysis: given a labeled failure video, can the model describe what went wrong and suggest recovery steps? A stronger test would close the loop: deploy Fast-ThinkAct on a manipulation task (LIBERO or a real-robot setup), let it execute actions, and after each action chunk, use the verbalizer (or a separate failure detection head) to assess whether the action was successful based on the next observation. If a failure is detected, generate a recovery plan as new latent tokens conditioned on the current observation and the previous failed plan, and execute it. Measure (a) detection accuracy—does the model correctly identify when it has failed? (b) recovery success rate—what fraction of detected failures are successfully recovered? and (c) recovery latency—how much additional time does replanning add? The paper's 805 ms per-step latency makes replanning feasible within ~1 second, which is fast enough for many manipulation tasks. A positive result would transform the RoboFAC language-generation result into a manipulation capability. A negative result would reveal whether the failure analysis capability shown in RoboFAC transfers to online execution or whether there is a sim-to-real or offline-to-online gap in failure awareness.

Cross-embodiment transfer of the trained student VLM. The paper claims modularity—the student VLM is frozen during policy learning and can condition different action models. The current evidence is that the same student works with DiT-Policy (SimplerEnv) and RDT (LIBERO, RoboTwin2.0), but these are tested on different benchmarks, not on the same tasks. A direct test of cross-embodiment transfer: train the student VLM on the full training pipeline (SFT, CoT-SFT, teacher-student distillation) using data from a single robot morphology (e.g., the Google Robot data from OXE), then freeze it and train separate action model heads for (a) the same Google Robot on SimplerEnv, (b) a Franka arm on LIBERO, and (c) a bimanual setup on RoboTwin2.0. Evaluate on all three. If the student's latent representations encode embodiment-agnostic planning (task decomposition, spatial relationships, object affordances), the LIBERO and RoboTwin2.0 action models should learn successfully from their respective demonstration data even though the VLM never saw those embodiments during reasoning training. If performance degrades significantly on unseen embodiments, the latent reasoning is embodiment-specific (e.g., encoding gripper geometry or kinematics implicitly), which would limit the modularity claim and require embodiment-specific VLM training.

Comparison of Fast-ThinkAct's latent space against alternative continuous reasoning representations. The paper positions itself against textual reasoning VLAs but does not compare against other continuous reasoning approaches adapted for embodied settings. A direct head-to-head would train three variants on the same data: (a) Fast-ThinkAct as described, (b) a CODI-style variant (Shen et al., 2025) where the student's hidden states are distilled to match the teacher's hidden states at every reasoning step without a verbalizer, and (c) a Coconut-style variant (Hao et al., 2024) where the student alternates between discrete text tokens and continuous latent tokens. Evaluate all three on LIBERO and RoboVQA. The comparison isolates the contribution of the verbalizer mechanism: if Fast-ThinkAct outperforms CODI-style distillation, the preference-guided verbalization is providing a training signal beyond pure representation matching. If it outperforms Coconut-style mixed discrete-continuous reasoning, the fully continuous latent space is superior for embodied tasks (where spatial relationships benefit from continuous representation). A null result (all three perform similarly) would indicate that any continuous representation distills teacher reasoning equally well, and that the specific verbalizer + DPO mechanism is unnecessarily complex—a simpler representation-level distillation would suffice.

Latent reasoning at variable temporal frequencies. The paper's architecture separates the reasoning VLM (which could run at low frequency) from the action model (which could run at high frequency), but the current evaluation couples them—every action prediction is preceded by a full latent reasoning forward pass. A natural extension tests temporal reuse: run the latent reasoning once every H action steps, use the resulting KV cache c_t to condition H consecutive action predictions, and measure success rate as a function of H on LIBERO-Spatial (where the environment changes slowly) vs. LIBERO-Long (where the plan may need updating mid-execution). The hypothesis is that H > 1 is viable for quasi-static tasks, reducing effective reasoning latency to 805/H ms. If performance degrades gracefully with increasing H on Spatial tasks (e.g., H=4 still achieves >80% success), this demonstrates that the latent planning representation captures information stable over multiple timesteps. If performance drops sharply even at H=2, the latent reasoning is encoding per-timestep corrections rather than a multi-step plan, which would be a fundamental limitation for high-frequency control. This experiment directly tests the paper's implicit claim that the spatial token KV cache represents a "plan" rather than an instantaneous correction signal.

Practical Applications and Downstream Use Cases

On-device deployment of reasoning-capable manipulation policies on lower-cost hardware. The paper's 3B backbone achieves 805 ms inference latency on 16 A100 GPUs—a high-end server configuration. However, the key efficiency scaling argument (3B vs. 7B, 6 latent tokens vs. 250 text tokens) suggests that Fast-ThinkAct could be deployed on edge GPUs (e.g., NVIDIA Jetson Orin, ~60 TOPS) that cannot run 7B text-reasoning models at all. A direct extrapolation: if ThinkAct-7B requires 7,513 ms on an A100, running it on an edge GPU with 10× less compute would yield ~75 seconds per action step—completely unusable. Fast-ThinkAct at 805 ms on A100, scaled to edge hardware, might achieve 5–10 seconds per step, which is still slow for real-time control but potentially viable for semi-autonomous manipulation where the robot plans, executes a multi-second action chunk, then replans. The practical scenario is a mobile manipulator in a home or warehouse that uses Fast-ThinkAct for high-level planning (deciding which object to grasp, which shelf to place it on) while a lower-level controller handles reactive execution. This deployment pattern would make reasoning-augmented manipulation available on hardware that costs hundreds rather than tens of thousands of dollars, expanding the reach of VLA technology.

Batch inference for robot data labeling and self-improvement pipelines. The paper's method produces not just actions but also visual trajectory predictions (the 5 waypoints from spatial tokens) and, optionally, verbalized reasoning (via the verbalizer). This makes it directly applicable to automated data labeling for robot learning: given a dataset of raw observation-action pairs, run Fast-ThinkAct to generate (a) predicted waypoints that can be compared to actual trajectories to identify segments where the policy deviates from the plan, and (b) verbalized descriptions of what the robot was attempting at each segment. These automatically generated annotations could bootstrap a self-improvement loop: use the verbalizer to identify failure segments (where the predicted waypoints diverge significantly from the actual trajectory), generate corrected reasoning traces for those segments using the teacher model, and fine-tune the action model on the corrected plans. The paper's RoboFAC results (91.1 on simulated failure identification) suggest Fast-ThinkAct can reliably identify failures offline. The 4× reduction in training data needed for few-shot adaptation (Figure 6: Fast-ThinkAct with 10 demos matches RDT with 50 demos) further supports this pipeline—the reasoning module's efficiency means the self-improvement loop can iterate faster. The practical deployment is a cloud-based batch processing system that continuously improves robot policies from field data without manual labeling.

Safety monitoring and operator oversight for semi-autonomous manipulation. In high-stakes manipulation settings (surgical robots, hazardous material handling, construction), operators need to understand what the robot is planning before authorizing execution. ThinkAct's 7.5-second reasoning latency makes this impractical—the operator waits 7.5 seconds for the reasoning text, reads it (several more seconds), and approves, creating a 10–15 second decision cycle. Fast-ThinkAct's 805 ms reasoning plus optional verbalization means the operator sees the reasoning text within ~1 second (verbalizer runs on top of the already-computed latents), and the predicted waypoints (visualized as traces overlaid on the camera image, as in Figures 4 and 8) are available simultaneously. This reduces the oversight cycle to 2–3 seconds, making it feasible for tasks where the robot pauses between action phases. The practical setup: the robot captures an observation, Fast-ThinkAct generates latents + waypoints + optional verbalized reasoning in ~1 second, the operator inspects the visual trace and reasoning summary, then either approves execution or provides a correction. The RoboFAC real-robot result (78.9 vs. 62.5 for the specialized RoboFAC-3B) suggests the reasoning is accurate enough for oversight in many cases. The known hallucination risk (Section 5) means the verbalization should be treated as advisory, not authoritative, but the visual waypoints provide a separate, grounded signal that the operator can verify against the camera image directly.

When to Prefer This Method

The paper explicitly positions Fast-ThinkAct against two categories of alternatives: (1) foundation VLAs (OpenVLA, π0, RDT) that operate without intermediate reasoning and (2) textual reasoning VLAs (ThinkAct, MolmoAct, CoT-VLA) that generate explicit CoT traces. The tradeoffs emerge from the experimental results in Figures 3, 6, and Tables 1, 2:

Prefer Fast-ThinkAct over textual reasoning VLAs when inference latency is the primary constraint and the deployment environment requires decision frequencies above approximately 0.5 Hz. The 7–9× speedup (805 ms vs. 5,674–7,513 ms) makes Fast-ThinkAct viable for tasks where ThinkAct or MolmoAct would violate safety or performance requirements. This is the paper's headline use case and is supported by every manipulation and reasoning benchmark where Fast-ThinkAct matches or exceeds the 7B reasoning baselines.
Prefer Fast-ThinkAct over foundation VLAs when tasks require long-horizon planning (270+ step demonstrations), few-shot adaptation (10 or fewer demonstrations per task), or failure recovery. The RoboTwin2.0 long-horizon results (+13.8 points over RDT on easy long-horizon tasks, Table 1) and the RoboFAC failure recovery results (+10.9 points over the specialized RoboFAC-3B on simulation, Figure 5) demonstrate that reasoning provides disproportionate gains in these regimes, while foundation VLAs plateau due to limited training data coverage.
Prefer a foundation VLA (or a simpler architecture) when task complexity is low (routine pick-and-place, single-step manipulation with fixed object configurations), training budget is extremely limited (the two-stage SFT and teacher-student distillation pipeline requires significant upfront compute), or the deployment hardware cannot even run a 3B VLM (the 805 ms on A100 GPUs still translates to multi-second latency on edge hardware). The paper does not evaluate on trivial manipulation tasks, so the lower bound of task complexity where reasoning helps is unknown—but the LIBERO-Spatial results (84.7% for Fast-ThinkAct, still an improvement over OpenVLA's 76.5% but with a narrower gap than on LIBERO-Long) suggest diminishing returns on simpler tasks.
Prefer a textual reasoning VLA when interpretability of the reasoning process is paramount and cannot tolerate the verbalizer's hallucination risk. The paper acknowledges that the verbalizer can produce plausible but inaccurate descriptions (Section 5), and no faithfulness metric is provided. If an application requires auditable reasoning traces for regulatory compliance or safety certification, ThinkAct's explicit text generation—while slower—provides a direct, non-approximate window into the model's planning process. The paper does not evaluate whether Fast-ThinkAct's latents can be audited for safety properties without going through the potentially unfaithful verbalizer, so textual reasoning remains the safer choice for interpretability-critical deployments.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

MolmoAct: Action Reasoning Models that can Reason in Space2025· uncategorized← LLM-judged similar
- ThinkAct: Vision-Language-Action Reasoning via Reinforced Visual Latent Planning2025· agents← LLM-judged similar
- V2V-LLM: Vehicle-to-Vehicle Cooperative Autonomous Driving with Multimodal Large Language Models2025· llm-systems← LLM-judged similar
- GR-3 Technical Report2025· uncategorized← LLM-judged similar
- GUI-Actor: Coordinate-Free Visual Grounding for GUI Agents2025· vision← LLM-judged similar
- PIVOT: Iterative Visual Prompting Elicits Actionable Knowledge for VLMs2024· agents← LLM-judged similar
- RVT-2: Learning Precise Manipulation from Few Demonstrations2024· agents← LLM-judged similar
- RoboVQA: Multimodal Long-Horizon Reasoning for Robotics2023· uncategorized← LLM-judged similar
- REINA: Regularized Entropy Information-Based Loss for Efficient Simultaneous Speech Translation2025· uncategorized← in-domain predecessor
- Qwen-Image Technical Report2025· multimodal← topic thread
- NVIDIA Nemotron Nano 2: An Accurate and Efficient Hybrid Mamba-Transformer Reasoning Model2025· reasoning← topic thread
VLingNav: Embodied Navigation with Adaptive Reasoning and Visual-Assisted Linguistic Memory2026· agents← in-domain predecessor
- ExpSeek: Self-Triggered Experience Seeking for Web Agents2026· agents← in-domain predecessor
- FantasyVLN: Unified Multimodal Chain-of-Thought Reasoning for Vision-Language Navigation2026· agents← similar topic

What it influenced

Later papers in the same chain. Direction reversed.

Unlocking Implicit Experience: Synthesizing Tool-Use Trajectories from Text2026· agents→ in-domain predecessor
- Agentic Reasoning for Large Language Models2026· agents→ in-domain predecessor
ThinkAct: Vision-Language-Action Reasoning via Reinforced Visual Latent Planning2025· agents→ similar topic
- MolmoAct: Action Reasoning Models that can Reason in Space2025· uncategorized→ LLM-judged similar
- A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve on the Path to Artificial Super Intelligence2025· agents→ in-domain predecessor
- GeoVista: Web-Augmented Agentic Visual Reasoning for Geolocalization2025· agents→ similar topic