TacitVLA: Reasoning Vision-Language-Action Models Without Reasoning Latency

Jack Lu; Yurong You; Boyi Li; Yulong Cao; Thomas Tian; Chaowei Xiao; Xiangyu Chen; Wenjie Luo

cs.AIOct 13, 2026

TacitVLA: Reasoning Vision-Language-Action Models Without Reasoning Latency

Authors: Jack Lu, Yurong You, Boyi Li, Yulong Cao, Thomas Tian, Chaowei Xiao, Xiangyu Chen, Wenjie Luo,

Organizations: NVIDIA · New York University · University of California, Berkeley · Johns Hopkins University ·

Abstract

Textual reasoning before acting has improved vision-language-action (VLA) models, but at the cost of latency: every action conditioned on the reasoning text must wait for autoregressive decoding. We show that actions do not need to wait for or condition on the generated reasoning to benefit from it, because the reasoning supervision already improves the backbone representation. We introduce TacitVLA, a reasoning VLA whose action expert never attends to the reasoning it generates for the current call. On long-horizon tasks where the reasoning text also serves as episodic memory, it can generate each entry during action execution rather than before acting. We evaluate it in a controlled study on four benchmarks spanning manipulation and autonomous driving, memory and non-memory tasks: RoboMME, RMBench, LIBERO, and PhysicalAI-AV. On all four, TacitVLA matches the performance of its explicit-reasoning counterpart at up to 3.4x lower latency, and matches the latency of the same architecture trained without reasoning at up to +17.1% success. In absolute terms, it surpasses the best previously published results on the RoboMME Counting suite (82.7% vs. 66.8%) and RMBench (77.5% vs. 56.5%), and reaches 72.9% on LIBERO-Plus and a 52.5% scene score on the public split of the PhysicalAI-AV closed-loop driving challenge. Project page: https://tacitvla.github.io.

Figures & tables

Figure 1: TacitVLA retains the benefit of reasoning supervision without conditioning its actions on the generated text. Left: how the policies act in one call. Given the context $c_{t}$ , on memory tasks including the ledger $M_{t}$ of past subtasks, the backbone generates the reasoning $r_{t}$ and conditions the action expert that outputs the action chunk $a_{t}$ . In Explicit Reasoning , the action expert attends to $r_{t}$ , so every action chunk waits for it. TacitVLA trains on the same sequence with $r_{t}$ masked from the action expert, bypassing the need to generate $r_{t}$ on non-memory tasks. On memory tasks, $r_{t}$ still becomes the next ledger entry (dashed loop), but is generated asynchronously during execution instead of making the action expert wait. No Reasoning is the same architecture trained without reasoning supervision. Right: TacitVLA matches Explicit Reasoning’s success at 1.7 $\times$ and 3.4 $\times$ lower latency, and matches No Reasoning’s latency at +3.5% and +5.3% success (Tables 3 , 5 , 15 ).

Figure 2: Training and deployment of Explicit Reasoning and TacitVLA . The two policies share the training sequence and differ in one attention-mask cell, which decouples TacitVLA’s actions from text generation at deployment. (a) The backbone predicts the reasoning

r_{t}

and the tokenized actions

\tilde{a}_{t}

(an auxiliary target) under cross-entropy, and the action expert denoises the action chunk

a_{t}

under flow matching. (b) Rows attend to columns. The backbone is causal. The action expert attends to

c_{t}

and its own action chunk, to

r_{t}

only in Explicit Reasoning, and never to

\tilde{a}_{t}

. The crossed cell is that difference. (c) On non-memory tasks, Explicit Reasoning needs to generate

r_{t}

before denoising and executing the action chunk, while TacitVLA does not. On memory tasks, both generate the ledger entry

r_{t}

: Explicit Reasoning before action execution, TacitVLA during it concurrently.

Benchmark	Task type	Reasoning text	Backbone	Size
RoboMME	memory	next subtask	PaliGemma ( $\pi_{0.5}$ )	3.7B
RMBench	memory	next subtask	RynnBrain-2B	2.6B
LIBERO (+Plus)	non-memory	scene description and plan	RynnBrain-2B	2.5B
PhysicalAI-AV	non-memory	chain of causation	Qwen3-VL-2B	3.9B

Table 1: The four benchmarks. Each row is one architecture, trained three times on the same data: as No Reasoning, Explicit Reasoning, and TacitVLA. “Reasoning text” is what the backbone generates (Appendix A ). Size is TacitVLA’s total parameter count, action expert included; on the non-memory tasks, Explicit Reasoning needs 0.05B more to generate text (Table 7 ).

Policy	Success
Human (oracle planner)	88.5
No Reasoning	79.0 $\pm$ 1.0
Explicit Reasoning	86.7 $\pm$ 2.0
TacitVLA	89.5 $\pm$ 1.3

Table 2: RoboMME Counting. Success (%) on the benchmark’s four counting tasks (200 cases) of policies trained on them alone, and the benchmark’s human reference ( Dai et al., 2026 ) . Shaded rows are ours, mean

\pm

standard deviation over three evaluation seeds.

Policy	Counting	Permanence	Reference	Imitation	All tasks
$\pi_{0.5}$ ( Black et al., 2025a )	28.8	17.0	17.2	8.8	17.9
$\pi_{0.5}$ with past actions	29.1	22.8	15.9	11.2	19.7
SAM2Act+ ( Fang et al., 2025 )	35.3	26.0	16.8	7.3	21.4
SimpleSG + Qwen3-VL-4B	44.6	19.6	25.2	26.6	29.0
GroundSG + Qwen3-VL-4B	38.0	39.3	31.6	21.9	32.7
MemER ( Sridhar et al., 2025 )	48.8	53.2	38.0	29.5	42.4

Table 3: RoboMME. Success (%) of policies trained on all 16 tasks, on each suite (200 cases) and on all tasks (800 cases). Shaded rows are ours, mean

\pm

standard deviation over three evaluation seeds. Only the counting tasks have reasoning supervision. Published rows are from the RoboMME paper ( Dai et al., 2026 ) , except WeaveLA and AGM, which report their own (Appendix A ).

Policy	Blocks Ranking Try	Battery Try	Press Button	Cover Blocks	Four-task mean
DP ( Chi et al., 2023 )	10	10	0	0	5.0
ACT ( Zhao et al., 2023 )	0	19	0	0	4.8
$\pi_{0.5}$ ( Black et al., 2025a )	6	16	0	0	5.5
X-VLA ( Zheng et al., 2026 )	1	26	0	2	7.3
WLA-0 ( Yang et al., 2026c )	23	45	74	84	56.5
HiMem-WAM ( Sun et al., 2026b )	24	28	8	19	19.8

Table 4: RMBench. Success (%) on each task (100 cases) and the four-task mean. Shaded rows are ours, mean

\pm

standard deviation over three evaluation seeds. Published rows are from the benchmark paper ( Chen et al., 2026 ) , EventVLA ( Yang et al., 2026a ) , and the systems’ own papers (Appendix A ).

Policy	minADE $\downarrow$	Pass rate (%) $\uparrow$	Collision any (%) $\downarrow$	At-fault collision (%) $\downarrow$	Off-road (%) $\downarrow$	km per infraction $\uparrow$	Scene score (%) $\uparrow$
VaVAM (nonlinear)	–	15.0 $\pm$ 0.7	24.3 $\pm$ 0.6	18.0 $\pm$ 0.6	28.0 $\pm$ 1.1	0.14 $\pm$ 0.00	11.0 $\pm$ 0.7
VaVAM (linear)	–	42.1 $\pm$ 0.5	33.3 $\pm$ 0.3	16.4 $\pm$ 0.7	15.2 $\pm$ 0.8	0.35 $\pm$ 0.00	31.4 $\pm$ 0.6
No Reasoning	1.166 $\pm$ 0.010	50.1 $\pm$ 2.2	16.1 $\pm$ 1.3	6.9 $\pm$ 1.6	9.5 $\pm$ 0.5	0.87 $\pm$ 0.08	46.4 $\pm$ 2.2
Explicit Reasoning	1.140 $\pm$ 0.015	56.4 $\pm$ 1.5	16.9 $\pm$ 0.7	5.5 $\pm$ 0.5	9.0 $\pm$ 0.1	1.01 $\pm$ 0.03	52.3 $\pm$ 1.4
TacitVLA	1.116 $\pm$ 0.011	55.8 $\pm$ 0.0	15.6 $\pm$ 0.2	6.7 $\pm$ 0.3	10.0 $\pm$ 0.9	0.87 $\pm$ 0.08	52.5 $\pm$ 0.3

Table 6: PhysicalAI-AV. Open loop: minADE (m), the minimum average displacement error over six samples on the 1,434 held-out segments of the public PhysicalAI-AV release, computed from its released videos, mean

\pm

standard deviation over evaluation seeds. Closed loop: AlpaSim’s metrics on the 441-scene public split of its challenge with one sampled trajectory per call, mean

\pm

standard deviation over three rollouts per scene. Infractions are at-fault collisions and off-road events. Shaded rows are ours. VaVAM ( Bartoccioni et al., 2025 ) : the organizers’ reference runs ( NVIDIA, 2026 ) under the competition’s nonlinear controller, which our policies also use, and under a linear controller that is not available in the competition.

Figure 3: TacitVLA matches the latency of No Reasoning on every benchmark, and Explicit Reasoning ’s latency is 1.4

\times

to 3.4

\times

higher. Each bar is one policy’s latency per call:

T_{\text{action}}

for No Reasoning and TacitVLA, and

T_{\text{action}}+T_{\text{reason}}

for Explicit Reasoning, whose actions wait for text generation. The ratio above each group is Explicit Reasoning’s latency over TacitVLA’s. On the memory tasks, TacitVLA generates the ledger entry during execution, taking at most 23% of the execution window, so the next call never waits for generation. All values are means over model calls on one H100, with the per-stage breakdown in Table 15 (Appendix C ).

Appendix figures & tables14 assets

Supplementary material from the paper’s appendix.

Appendix

	Components				Policy
Benchmark	Vision tower	Text embedding	Language layers	Action expert	No Reasoning	Explicit Reasoning	TacitVLA
RoboMME	0.415	0.527	1.982	0.430	3.547	3.669	3.669
RMBench	0.407	0.311	1.409	0.446	2.527	2.573	2.573
LIBERO	0.407	0.311	1.409	0.446	2.527	2.573	2.527
PhysicalAI-AV	0.407	0.313	1.409	1.774	3.857	3.903	3.857

Appendix

Table 7: Parameters of the policies (billions). The tied output head is counted once. The components sum to Explicit Reasoning’s total. On RoboMME, the total also includes the 0.315B frame-sampling memory, whose history frames pass through the same frozen SigLIP as the current image. A policy that generates no text (No Reasoning, and TacitVLA on the non-memory tasks) uses only the keys and values of the last language layer and not the rest of that layer or the final norm.

Component	Setting	RoboMME	RMBench, LIBERO	PhysicalAI-AV
Vision encoder	layers	27 (SigLIP)	24	24
	width	1,152	1,024	1,024
Language model	layers	18 (Gemma-2B)	28	28
	width	2,048	2,048	2,048
	heads (query / key-value)	8 / 1	16 / 8	16 / 8
	feed-forward	16,384, GeGLU	6,144, SwiGLU	6,144, SwiGLU

Appendix

Table 8: Architecture of the policies. In the output head row,

d

is the action dimension (14 on RMBench, 7 on LIBERO). The RoboMME policies use the

\pi_{0.5}

architecture with RoboMME’s frame-sampling memory. The RMBench, LIBERO, and driving backbones share the Qwen3-VL-2B architecture and differ in vocabulary.

Setting	Batch	Peak learning rate	Warmup	Updates	Noise draws
RoboMME counting	64	$5{\times}10^{-5}$	5k	60k	1
RoboMME all tasks	64	$5{\times}10^{-5}$	10k	80k	1
RMBench	512	$5{\times}10^{-6}$ / $5{\times}10^{-5}$ / $2{\times}10^{-4}$	2k	80k	16
LIBERO	512	$5{\times}10^{-6}$ / $5{\times}10^{-5}$ / $2{\times}10^{-4}$	2k	40k	16
PhysicalAI-AV	256	$1{\times}10^{-5}$ / $1{\times}10^{-4}$ / $4{\times}10^{-4}$	4k	100k	1

Appendix

Table 9: Training settings. Learning rates are for the vision tower, the language model, and the action expert, respectively, and RoboMME uses one rate for all three.

Benchmark	Observation	Predicted chunk	Executed	Solver steps
RoboMME	front and wrist views, up to 32 sampled history frames	20 actions (32-D, 8 active)	16	10
RMBench	first frame, head frame 32 actions earlier, current head/left/right	32 targets (14-D)	32	32
LIBERO	agent and wrist images, agent image 8 steps earlier	10 actions (7-D)	5	32
PhysicalAI-AV	4 frames from two front cameras, 16 past ego states	64 waypoints / 6.4 s	1	10

Appendix

Table 10: Observation, action, and execution. Solver steps are uniform Euler steps. Closed-loop driving replans at every 100 ms control step of the simulator, so one waypoint is executed per call.

	Trained on the Counting suite			Trained on all suites
Policy	$\lambda{=}0.1$	$0.01$	$0.001$	$\lambda{=}0.1$	$0.01$	$0.001$
No Reasoning	77.3 $\pm$ 2.5	79.0 $\pm$ 1.0	74.5 $\pm$ 2.8	43.6 $\pm$ 0.2	46.5 $\pm$ 0.9	44.0 $\pm$ 1.6
Explicit Reasoning	86.7 $\pm$ 2.0	84.7 $\pm$ 1.6	73.0 $\pm$ 2.0	43.5 $\pm$ 1.2	45.8 $\pm$ 1.5	43.8 $\pm$ 1.3
TacitVLA	85.5 $\pm$ 3.3	89.5 $\pm$ 1.3	82.5 $\pm$ 2.5	44.0 $\pm$ 0.9	47.6 $\pm$ 1.4	48.1 $\pm$ 1.0

Appendix

Table 11: RoboMME, the cross-entropy weight sweep. Success (%) of the three policies at

\lambda\in\{0.1,0.01,0.001\}

, mean

\pm

standard deviation over three evaluation seeds: the Counting-suite policies on the four counting tasks (200 cases) and the 16-task policies on all 16 tasks (800 cases).

Policy	Robot init.	Sensor	Camera	Language	Objects	Background	Light	All
Cases	1,550	1,601	1,599	1,537	1,525	1,076	1,142	10,030
No Reasoning	59.7 $\pm$ 1.1	51.7 $\pm$ 1.1	41.0 $\pm$ 1.1	76.6 $\pm$ 0.9	73.2 $\pm$ 1.0	92.9 $\pm$ 0.7	94.0 $\pm$ 0.6	67.6 $\pm$ 0.4
Explicit Reasoning	71.1 $\pm$ 0.8	51.1 $\pm$ 0.9	51.5 $\pm$ 0.9	83.7 $\pm$ 0.6	78.3 $\pm$ 0.7	97.2 $\pm$ 0.3	96.8 $\pm$ 0.4	73.5 $\pm$ 0.3
TacitVLA	69.9 $\pm$ 0.8	60.0 $\pm$ 0.8	42.2 $\pm$ 0.8	83.0 $\pm$ 0.6	77.1 $\pm$ 0.7	98.0 $\pm$ 0.3	95.4 $\pm$ 0.4	72.9 $\pm$ 0.3

Appendix

Table 12: LIBERO-Plus by perturbation axis. Success (%) on each of the seven perturbation axes and on the full 10,030-case suite, mean

\pm

standard deviation over three evaluation seeds.

Policy	Spatial	Object	Goal	Long	Avg.	Plus
No Reasoning	99.2 $\pm$ 0.4	99.6 $\pm$ 0.3	98.8 $\pm$ 0.5	96.4 $\pm$ 0.9	98.5 $\pm$ 0.3	67.6 $\pm$ 0.4
Explicit Reasoning	98.4 $\pm$ 0.7	99.8 $\pm$ 0.3	97.8 $\pm$ 0.9	96.4 $\pm$ 1.1	98.1 $\pm$ 0.4	73.5 $\pm$ 0.3
TacitVLA	99.2 $\pm$ 0.5	100.0 $\pm$ 0.0	98.0 $\pm$ 0.7	97.2 $\pm$ 0.8	98.6 $\pm$ 0.3	72.9 $\pm$ 0.3

Appendix

Table 13: LIBERO, every policy and suite. Success (%) on the four standard suites (50 trials per task) and on the 10,030-case LIBERO-Plus suite, mean

\pm

standard deviation over three evaluation seeds.

Policy	BinFill	PickXtimes	SwingXtimes	Press Button
Explicit Reasoning	90.0	100.0	100.0	99.7
TacitVLA	92.0	100.0	100.0	99.7

Appendix

Table 14: Correct ledgers (%). Episodes whose final generated ledger matches the instructed count, for the Counting-suite policies of Table 2 and the Press Button policies of Table 4 .

		$T_{\text{action}}$			$T_{\text{reason}}$		Latency
Benchmark	$T_{\text{exec}}$	No Reasoning	TacitVLA	Explicit Reasoning	TacitVLA	Explicit Reasoning	No Reasoning	TacitVLA	Explicit Reasoning
RoboMME, counting	800	127	127	127	93	93	127	127	220
RMBench, Press Button	6,972	170	171	170	66	66	170	171	236
RMBench, Blocks Ranking Try	8,116	162	171	171	81	87	162	171	257
RMBench, Cover Blocks	9,359	170	170	169	101	106	170	170	275
RMBench, Battery Try	11,181	162	169	168	120	126	162	169	294

Appendix

Table 15: Stage times and the latency per call (ms). The left columns give the execution window

T_{\text{exec}}

and each policy’s action path

T_{\text{action}}

and reasoning cost

T_{\text{reason}}

(Section 3.3 ), and the right columns give the latency per call:

T_{\text{action}}

for No Reasoning and TacitVLA, and

T_{\text{action}}+T_{\text{reason}}

for Explicit Reasoning, whose action waits for the generation. TacitVLA generates during

T_{\text{exec}}

on the memory tasks and not at all on the non-memory tasks. All values are means of per-call stage timers on one H100. RMBench’s window is the motion planner’s mean time to execute a plan.

Figure 4: RoboMME BinFill. The front camera at the calls that generate a new ledger entry and at the episode’s last call. Counting-suite policies of Table 2 .

Figure 5: RMBench Press Button. The head camera at the calls that generate a new ledger entry and at the episode’s last call. A call can add two entries when a press completes within the action chunk. Policies of Table 4 .

Figure 6: LIBERO. The agent camera at six calls, with the opening of the reasoning generated at each. Policies of Table 5 .

Figure 7: LIBERO-Plus, Camera Viewpoints. The agent camera on two tasks under perturbed viewpoints. Policies of Table 5 .

Figure 8: PhysicalAI-AV closed loop. The front camera at five calls of two public-split scenes, with the chain of causation generated at each call. Policies of Table 6 .

Reasoning for VLA Models

Reasoning for vision-language-action (VLA) models connects visual and language understanding to grounded planning and action.

See all 113 papers

May 28, 2026

VisualThink-VLA: Visual Intermediate Reasoning for Effective and Low-Latency Vision-Language-Action Policies

Recent work has begun to equip vision-language-action (VLA) policies with explicit intermediate reasoning. In embodied control, however, textual chain-of-thought is a poor fit: irrelevant or weakly textual information can interfere with action prediction, while autoregressive text decoding adds too much latency for real-time closed-loop execution. We present VISUALTHINK-VLA, a visual intermediate-reasoning framework for accurate, low-latency VLA policies. Our bootstrapping philosophy is to guide action with effective visual thinking: VISUALTHINK-VLA bootstraps action prediction through a compact visual-evidence interface that preserves spatial precision while avoiding decoding overhead. Besides, to further improve performance and efficiency, VISUALTHINK-VLA adopts a tailored selective routing mechanism to learn the visual evidence tokens, enabling low-latency inference while preserving high-capacity specialization. We also introduce VisualEvidence-Kit, a supervision-and-audit resource centered on a VisualEvidence-Agent that constructs a 754.7k VLA instructions VisualEvidence-Set for route supervision and counterfactual faithfulness tests. Across multiple benchmarks and real-robot evaluation, VISUALTHINK-VLA achieves the highest success rate on most benchmarks while reducing the multi-second latency of reasoning-augmented baselines to the sub-second regime. For example, on BridgeData V2, it reduces step latency from 8.377,s with ECoT to 0.367,s, achieving a 22.8 times speedup.

Mingjian Gao, Wenqiao Zhang, Yuqian Yuan +9

1Zhejiang University · 2Cornell University · 3National University of Singapore +1

Efficient VLM Inference Efficient VLA Model Inference Efficient VLA Models Vision-Language-Action Models Visually Grounded Reasoning VLMs for Robotics+1

Ask PDF

Jun 13, 2026

Think Less, Act Early: Reinforced Latent Reasoning with Early Exit in Vision-Language-Action Models

Existing Vision-Language-Action (VLA) models predominantly rely on explicit Chain-of-Thought (CoT) reasoning to bridge perception and action. While effective, this paradigm suffers from high computational costs and error propagation in multi-step tasks. In this paper, we propose Adaptive Variable Alignment VLA (AVA-VLA), a novel Latent Reasoning VLA framework that models reasoning as a sequence of unobservable latent variables, bypassing the need for explicit text generation. However, latent trajectories are inherently susceptible to noise interference and misalignment with downstream objectives. To address this, we introduce a Reinforcement Learning-based Denoising mechanism that treats latent state generation as a sequential decision process, optimizing reasoning trajectories via task-level rewards. Furthermore, we incorporate an Early-Exit Strategy that adaptively terminates reasoning based on state confidence, enabling a dynamic trade-off between depth and efficiency. Extensive experiments on embodied decision benchmarks demonstrate that AVA-VLA achieves a 6x inference speedup over explicit CoT methods while attaining a 98.3% average success rate on LIBERO, improving both efficiency and long-horizon stability over full-reasoning baselines.

Dianqiao Lei, Lianlei Shan

1Tsinghua University, Beijing, China.

Efficient Inference Efficient VLA Model Inference Efficient VLA Models Latent Visual Reasoning Vision-Language-Action Models VLMs for Robotics+3

Ask PDF

Mar 15, 2026

VLA-Thinker: Boosting Vision-Language-Action Models through Thinking-with-Image Reasoning

Vision-Language-Action (VLA) models have shown promising capabilities for embodied intelligence, but most existing approaches rely on text-based chain-of-thought reasoning where visual inputs are treated as static context. This limits the ability of the model to actively revisit the environment and resolve ambiguities during long-horizon tasks. We propose VLA-Thinker, a thinking-with-image reasoning framework that models perception as a dynamically invocable reasoning action. To train such a system, we introduce a two-stage training pipeline consisting of (1) an SFT cold-start phase with curated visual Chain-of-Thought data to activate structured reasoning and tool-use behaviors, and (2) GRPO-based reinforcement learning to align complete reasoning-action trajectories with task-level success. Extensive experiments on LIBERO and RoboTwin 2.0 benchmarks demonstrate that VLA-Thinker significantly improves manipulation performance, achieving 97.5% success rate on LIBERO and strong gains across long-horizon robotic tasks. Project and Codes: https://cywang735.github.io/VLA-Thinker/ .

Chaoyang Wang, Wenrui Bao, Sicheng Gao +5

University of Central Florida · University of Würzburg · University of Southern California +1

Vision-Language-Action Models Reasoning for VLA Models Visual CoT Robotic Manipulation

Ask PDF

Abstract

Reasoning for VLA Models

Explore similar work

VisualThink-VLA: Visual Intermediate Reasoning for Effective and Low-Latency Vision-Language-Action Policies

Think Less, Act Early: Reinforced Latent Reasoning with Early Exit in Vision-Language-Action Models

VLA-Thinker: Boosting Vision-Language-Action Models through Thinking-with-Image Reasoning