DeepThinkVLA makes a robot policy think before it acts

What the model actually does differently

DeepThinkVLA rethinks vision-language-action policies with explicit deliberation. Starting from the public pi0-FAST checkpoint, the policy is refactored into a 2.9B parameter hybrid decoder that writes a reasoning trace before emitting action chunks. The architectural point is specific: a think segment is inserted between observations and actions, reasoning tokens are generated autoregressively, and after that the decoder switches to bidirectional attention to emit action vectors in parallel. The stated purpose is to resolve the modality conflict that limits single-decoder baselines, and to make efficient rollouts possible for downstream reinforcement learning. The paper combines embodied chain-of-thought supervised fine-tuning with outcome-driven reinforcement learning, and reports a 97.0 percent average success rate across the LIBERO benchmark, broken down as Object at 99.0, Spatial at 96.6, Goal at 96.4 and Long at 96.2.

Why a hybrid decoder rather than one more autoregressive pass

The claim that gets the most attention is about latency, and it is worth reading the numbers carefully rather than the adjectives. The hybrid architecture alone lifts success by 15.5 percentage points over a naive autoregressive chain-of-thought variant, and the reinforcement learning refinement supplies a further +2.0 point boost on LIBERO-Long. The latency claim is that Masked-CoT inference with DeepThinkVLA preserves accuracy at 96.5 percent average success rate while running at 0.175 times the latency of pi0-FAST in autoregressive mode, whereas random chain of thought quickly degrades performance to 85.1 percent. That last number is the useful one for a reader: randomising the reasoning segment, which is roughly what a naive autoregressive baseline does to a policy that was not trained that way, costs you more than ten points. So the reasoning is not decoration that the model learned to ignore, which is a meaningful thing to know before you try to strip it out to save latency.

Two stages of data generation

A scalable annotation pipeline supplies paired reasoning and action traces, and it is split in two. Stage one isolates key frames using gripper-state heuristics, queries a cloud large vision-language model for high-quality chain of thought, and then performs targeted human review. Stage two fine-tunes a local vision-language model on those reviewed exemplars and auto-labels the remaining frames, with schema and temporal checks applied to keep the trajectories coherent. The economics of this arrangement are obvious once it is laid out: the expensive path, a cloud model plus human review, is spent only on the key frames, and the cheap path, a fine-tuned local model, scales to everything else. The dataset produced is published on Hugging Face as libero_cot under the yinchenghust organisation, alongside the model weights in a DeepThinkVLA collection.

The training pipeline: SFT then GRPO

Training proceeds in two stages. The cold start is supervised fine-tuning with token-level cross-entropy, which teaches the hybrid decoder to produce well-formed chain of thought and aligned actions under the causal and bidirectional masks. The second stage is outcome-driven reinforcement learning using grouped reinforcement policy optimization, which standardises sparse rewards inside task-conditioned batches, with a KL penalty to the SFT policy to prevent drift. The README reports that the RL stage adds +2.0 success rate on LIBERO-Long and strengthens the causal link between thought and action, and separately that RL over SFT lifts LIBERO-Long from 94.2 to 96.2 percent without extra demonstrations, which the authors read as evidence of recoveries on long-horizon tasks. The dependencies for that stage are the usual reinforcement learning stack, with trl, deepspeed, accelerate and ray among the pinned packages.

Running the LIBERO Plus evaluation

The zero-shot evaluation lives in a separate standalone repository, wadeKeith/DeepThinkVLA_libero_plus, and the entry point is a Python script with a set of flags:

python experiments/run_libero_plus_eval.py \
  --pretrained_checkpoint /path/to/deepthinkvla_libero_checkpoint \
  --num_images_in_input 2 \
  --task_suite_name libero_10 \
  --max_new_tokens 2048 \
  --swanlab_mode disabled

There is also a wrapper script for the whole thing:

bash eval.sh

The evaluation writes logs to experiments/logs/ and, if enabled, rollout videos to rollouts/. The protocol is worth stating precisely because zero-shot is used in two different senses in this literature. The model is trained only on the standard LIBERO dataset, with no LIBERO Plus fine-tuning, and is then evaluated directly on LIBERO Plus. The reported per-shift success rates are 0.7993 for objects layout, 0.845 for language instructions, 0.900 for light conditions, 0.885 for camera viewpoints, 0.405 for robot initial states, 0.753 for background textures and 0.944 for sensor noise, giving a total of 0.790. The robot initial state is by a wide margin the hardest shift.

The dependency wall and the repository layout

This is a research stack and the requirements file shows it. The list runs to more than sixty pinned packages, starting with torch 2.4.0, torchvision 0.19.0 and torchaudio 2.4.0, and including transformers 4.48.1, diffusers 0.32.2, timm 1.0.3, tokenizers 0.21.1, peft, bitsandbytes 0.42.0, trl, deepspeed, accelerate, liger-kernel and ray with the default extra. The simulation side brings robosuite 1.4.0, bddl 1.0.1, robomimic 0.2.0, gym 0.25.2, and tracking tools through tensorflow 2.15.0 with tensorflow_datasets and tensorflow_graphics. On top of that sit hydra-core, omegaconf, draccus, swanlab, wandb 0.19.8, datasets 3.3.2 and pytest 8.3.5. The repository itself is laid out with data/, experiments/, figs/, scripts/, src/, tests/ and a requirements.txt, and the package release is 1.0.0 with the tag deepthinkvla-1.0.0 from 2025-11-22, with the last push on 2026-09-08.

Where DeepThinkVLA is the wrong choice

Three cases. The first is anyone who needs a policy running on a robot now, because the project's to-do list still has real-world hardware experiments unchecked alongside the RobotWin benchmark, and a 2.9B parameter model that spends tokens on reasoning before acting is a very different thing from a fast reactive policy on embedded hardware. The second is a team that wants the chain-of-thought idea without this specific implementation, since the two-stage annotation pipeline with cloud model calls and human review is a substantial ongoing cost that has nothing to do with the hybrid decoder architecture. The third is a group that cannot reproduce the evaluation, because the headline numbers depend on the LIBERO protocol and the single-model protocol the authors used, and a zero-shot LIBERO Plus score of 0.790 tells you more about how the method holds up than the 97.0 percent does. Against a plain autoregressive policy, the difference in approach is that the decoder treats reasoning and action as two different attention regimes in one model, which is why the latency stays manageable while the accuracy improves, and why the reasoning segment cannot simply be dropped.

Editorial conclusion

DeepThinkVLA is a good fit for a robotics research group that wants to add explicit deliberation to a vision-language-action policy, has the GPU budget for a 2.9B model plus reinforcement learning, and is willing to work from a fixed set of pinned dependencies. It is a poor fit for a team that needs a deployable policy on real hardware today, since real-world hardware experiments are still an unchecked item in the project's own to-do list. Check three things before you start: that your base checkpoint is the public pi0-FAST one the work starts from, since the whole refactor is built on it, that you can afford the dependency set, which pins torch 2.4.0 with torchvision 0.19.0 and adds deepspeed, trl, ray and robosuite, and that the evaluation you care about is the one that was measured, because the headline 97.0 percent is on LIBERO and the zero-shot numbers are on LIBERO Plus, which is a different benchmark with its own evaluation repository.

Frequently asked questions

Official sources

1. License: MIT
2. OpenBMB/DeepThinkVLA on GitHub
3. Project website
4. README
5. Releases