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

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, Boris Ivanovic, Marco Pavone*, Yan Wang* (NVIDIA, with New York University, UC Berkeley, Johns Hopkins University and Stanford University; * equal advising; first author's work done during an internship at NVIDIA)
arXiv:2610.17540v1 [cs.AI], submitted 2026-10-13 · arXiv:2610.17540 · project page tacitvla.github.io
Code status: the project page lists "Code soon"; as of 2026-10-15 no training or evaluation code has been released, and the only TacitVLA repository on GitHub is the project page itself (TacitVLA/tacitvla.github.io). All four policy sets train only on each benchmark's released demonstrations, and Appendix A specifies initializations, architectures, batch sizes, learning rates, prompts, decoding settings, the ledger protocol, and the source of every published comparison row, so reproducibility currently rests on that appendix rather than on code.

In One Sentence

Hold the training sequence, loss, prompts, data and optimizer fixed, mask one cell of the attention pattern so that the action expert never attends to the reasoning tokens generated for the current call, and the benefit of reasoning supervision survives intact: TacitVLA matches its explicit-reasoning counterpart on all four benchmarks (RoboMME, RMBench, LIBERO/-Plus, PhysicalAI-AV) at up to 3.4x lower latency per call, and on long-horizon tasks where the reasoning text doubles as an episodic ledger it writes each entry asynchronously inside the action-execution window (longest measured entry 180 ms, never overflowing the window in any call).

1. The Reasoning Text Does Three Jobs at Once

Embodied chain-of-thought trains a vision-language-action model to emit text before acting: a scene description, a plan, or the next subtask. It outperforms policies that map observations straight to actions (Zawalski et al., 2024), and the pattern now runs through manipulation, driving and hierarchical policies. The paper's first move is to separate the three jobs that text performs over a policy's lifetime, and that separation carries the whole argument.

(i) At training time it is a target. The cross-entropy shapes the backbone representation on which the action expert conditions. (ii) On long-horizon tasks it can serve as episodic memory. Each generated subtask is appended to the context and records what the current observation no longer shows, such as how many button presses have already happened. (iii) At deployment it is an input. The action expert conditions on the reasoning generated for the current call, and because that text is decoded autoregressively, the action waits for the decoding to finish.

All of the latency is charged to job (iii). By the paper's own measurement, generating the reasoning text accounts for 53% to 70% of per-call latency for the reasoning VLAs it trains on LIBERO and PhysicalAI-AV. In frequency terms from the literature: embodied chain-of-thought policies run at 0.3 to 0.5 Hz where the same architecture without test-time reasoning runs at 3 to 4 Hz on the same GPU (Chen et al., 2025b), and DeepThinkVLA's hybrid action decoding narrows that gap to 1.4x (Yin et al., 2026).

Existing remedies trade something away. Dual-system designs run the vision-language model below the control rate and let a separate controller follow (Helix, Fast-in-Slow); they either do not remove the wait or make the controller act on what the slow model produced for an earlier observation. Reusing a possibly stale chain across calls (Fast ECoT), latent reasoning in place of tokens, and generic VLA inference tricks (early exit, token caching, state-space backbones) all reduce the cost of reasoning rather than removing the requirement to generate before acting.

A second family trains on reasoning text and deploys without generating it: implicit planning in VLA-OS, $\pi_{0.5}$ deployed without subtask inference, ECoT-Lite's reasoning pre-training and dropout recipes, ZR-0, and ERVLA. They establish that reasoning supervision can help a policy that emits no text at deployment, but none of them isolates the variable: either there is no explicit-reasoning counterpart (ZR-0), or the comparison also changes how actions are decoded (ERVLA) or the training mixture (ECoT-Lite), or generation is switched off on a checkpoint that was trained to condition on it ($\pi_{0.5}$), or the policy is small and trained from scratch (VLA-OS). Parallel evidence exists in language modeling, where rationales used only as training targets still improve answers (Hsieh et al., 2023) and chains of thought can be internalized (Deng et al., 2023; Hao et al., 2025; Kim et al., 2026). Fast-WAM asks the analogous question about future video and concludes that video prediction helps mainly by improving representations during training.

The paper therefore reduces the problem to one falsifiable question, which is also the headline on its project page: must the action condition on the current reasoning, or is learning to generate it enough? If the benefit travels mostly through job (i), generating the text buys latency and nothing else. Where the text also serves as memory (ii), it must still be generated for later calls, but that can happen during action execution rather than before it.

Figure 1 (paper teaser). Left: what one call looks like under each policy. Given the context $c_t$ (plus the ledger $M_t$ of past subtasks on memory tasks), the backbone generates the reasoning $r_t$ and conditions the action expert that emits the action chunk $a_t$. Under Explicit Reasoning the action expert attends to $r_t$, so every chunk waits for it. TacitVLA trains on the same sequence with $r_t$ masked from the action expert, which removes the need to generate $r_t$ at all on non-memory tasks; on memory tasks $r_t$ still becomes the next ledger entry (dashed loop) but is generated asynchronously during execution. Right: the matched-success, lower-latency comparison.

To answer the question, three versions of one architecture are trained per benchmark, differing only in the action expert's attention to reasoning tokens, in whether reasoning supervision exists at all, and on memory tasks in when a ledger entry is written. Explicit Reasoning deploys the way embodied chain-of-thought does: its action expert attends to the reasoning it just generated, so every action chunk waits. TacitVLA trains on the same sequence and differs only in masking the action expert's attention to those tokens. No Reasoning is the same architecture without reasoning supervision; it has TacitVLA's latency and quantifies what the supervision is worth. The four benchmarks split by how the text is used: RoboMME and RMBench are memory tasks, where each generated subtask becomes the next ledger entry that every later call conditions on; LIBERO and PhysicalAI-AV are non-memory tasks, where the text serves the current action and is discarded.

2. The Shared Skeleton: One Backbone, One Flow-Matching Action Expert

The paper studies the form recent reasoning VLAs converge on: a vision-language backbone generates the reasoning text and an action expert conditions on the backbone's representation ($\pi_{0.5}$, Alpamayo-R1, WLA, OneTwoVLA, ZR-0, ERVLA). One call maps a context to one action chunk, part or all of which executes before the next call is due. The context $c_t$ at call $t$ holds the instruction and the observation: camera views, robot or vehicle state, and whatever history the policy keeps; on memory tasks it also holds a ledger $M_t$ of past subtasks. From it the backbone generates $r_t$, which is the next subtask, a scene description plus plan, or a chain of causation, depending on the benchmark.

The action expert produces the chunk $a_t$ by denoising with flow matching in $K$ Euler steps. Backbone and expert form a Mixture-of-Transformers: separate weights, one shared attention in which the action positions attend to the backbone's keys and values layer by layer. Both train jointly on the same examples with

$$\mathcal{L}\;=\;\mathcal{L}_{\text{flow-matching}}(a_t)\;+\;\lambda\,\mathcal{L}_{\text{cross-entropy}}(r_t,\tilde{a}_t) \tag{1}$$

where the flow-matching term is the expert's denoising objective on the noised action chunk and the cross-entropy is the backbone's next-token loss on the reasoning text and on $\tilde{a}_t$. Here $\tilde{a}_t$ is the same chunk in tokenized form, predicted by the backbone after $r_t$: FAST+ tokens for manipulation (Pertsch et al., 2025), trajectory tokens for driving. Training the backbone on tokenized actions while the deployed action comes only from the flow-matching expert follows $\pi_{0.5}$, and the tokenized actions speed up training.

The implementation of the action positions matters because that is exactly where the one masked cell lives. The action expert is a second transformer stack with the backbone's attention geometry and no vocabulary: at layer $\ell$ its positions attend to the backbone's layer-$\ell$ keys and values together with their own, so the two stacks form a single attention over a single sequence while keeping separate weights. Action positions continue the prefix's position IDs and attend to one another without a causal mask; one action position is one action of the chunk. On RoboMME the flow time enters through adaptive RMSNorm as in $\pi_{0.5}$, and the frame-sampling memory adds a memory attention plus a memory-conditioned modulation in every layer of both stacks. On RMBench and LIBERO the expert embeds the noised action with the flow time and appends one clean state token. The driving expert encodes each waypoint with Fourier features and outputs acceleration and curvature, integrated by a unicycle model.

Sizes (Appendix Tables 7 and 1): RoboMME 3.7B including a 0.315B frame-sampling memory whose history frames pass through the same frozen SigLIP as the current image, RMBench 2.6B, LIBERO 2.5B, PhysicalAI-AV 3.9B. On the non-memory tasks Explicit Reasoning needs 0.05B more than TacitVLA, because a policy that generates no text uses only the keys and values of the last language layer, not the rest of that layer or the final norm.

Figure 2 (paper Figure 2). Training and deployment of Explicit Reasoning and TacitVLA. The two share one training sequence and differ in a single attention-mask cell (crossed out in the figure), which is what decouples TacitVLA's actions from text generation at deployment. (a) The backbone predicts $r_t$ and the tokenized actions $\tilde{a}_t$ under cross-entropy while the expert denoises $a_t$ under flow matching. (b) Rows attend to columns: the backbone is causal, the action expert attends to $c_t$ and its own chunk, to $r_t$ only under Explicit Reasoning, and never to $\tilde{a}_t$. (c) On non-memory tasks Explicit Reasoning must generate $r_t$ before denoising and executing; on memory tasks both generate the ledger entry, one before execution and one concurrently with it.

3. A Call's Time, in Three Accounts

Three stage times describe one call. $T_{\text{action}}$ is the action path: visual encoding, prompt prefill and denoising, identical for all three policies. $T_{\text{reason}}$ is the cost of explicit reasoning: generating $r_t$, plus, where the action expert conditions on it, the backbone's pass over the generated tokens. $T_{\text{exec}}$ is the execution window: the physical time the committed actions take before the next call is due. Latency is the time from observation until the action chunk is ready, so

$$T_{\text{No Reasoning}}=T_{\text{action}},\qquad T_{\text{Explicit}}=T_{\text{action}}+T_{\text{reason}}$$

and memory and non-memory tasks look the same in this equation: Explicit Reasoning's actions always wait for text. The execution windows come from the simulators' own control rates. LIBERO executes 5 actions per call at 20 Hz (250 ms window), RoboMME 16 actions at 20 Hz (800 ms), and closed-loop driving replans at every 100 ms control step so one waypoint executes per call. RMBench has no control rate at all: an action is a joint-position target, and the simulator hands each plan's 32 targets to a motion planner that moves the arm under its velocity and acceleration limits, stepping physics at 4 ms until the arm arrives (218 to 349 ms per target, plan means of 6,972 to 11,181 ms over each task's 100 cases). That window is one to two orders of magnitude larger than text generation, which is the physical reason deferring generation is free on memory tasks.

4. Method, Part One: the Cell Removed from the Attention Mask

Both policies see one sequence: the context $c_t$, the reasoning target $r_t$, the tokenized actions $\tilde{a}_t$, then the action chunk's placeholder positions for the expert. Equation 1, the prompts, the data and the optimizer are shared. Only the attention pattern of the action positions differs:

$$\text{Explicit:}\quad \pi\bigl(a_t\mid c_t,r_t\bigr),\qquad \text{the action expert attends to } c_t \text{ and } r_t \tag{2}$$

$$\text{TacitVLA:}\quad \pi\bigl(a_t\mid c_t\bigr),\qquad \text{the action expert attends to } c_t \text{ only} \tag{3}$$

Reasoning can therefore reach the action by two pathways: the cross-entropy on the reasoning text trains the backbone whose representation the expert conditions on, and the expert can attend to $r_t$ directly. Explicit Reasoning has both, TacitVLA only the first, No Reasoning neither. Comparing TacitVLA with No Reasoning isolates the first pathway; comparing it with Explicit Reasoning isolates the second. This is the cleanest part of the experimental design.

The claim that makes it work is about information, not architecture: at deployment Explicit Reasoning's $r_t$ is itself generated from $c_t$ alone, so the second pathway adds computation, not information. TacitVLA matches Explicit Reasoning on all four benchmarks, which means that computation buys no performance. The contrapositive is what would falsify the paper: on any task where the second pathway genuinely carries information the expert cannot get from the representation, TacitVLA would lose. Four benchmarks, two training scales on RoboMME and a three-point sweep of $\lambda$ are the evidence that this does not happen in the regimes studied.

One detail is easy to miss: both patterns are masks over the same shared sequence, so the sequence shape is identical and the comparison is not "a different model" but "a different cell in the attention mask". As a side effect TacitVLA's updates cost slightly less than Explicit Reasoning's, whose action positions also attend to $r_t$; No Reasoning's sequences carry no reasoning text and are cheapest.

5. Method, Part Two: Deferring Generation into the Execution Window

On non-memory tasks nothing at deployment consumes $r_t$, so TacitVLA does not generate it and its latency is $T_{\text{action}}$, matching No Reasoning to the millisecond. On memory tasks it computes the action first and writes the ledger afterwards: at call $t$ the expert acts from $c_t$, which already contains $M_t$; while the robot executes that chunk, the backbone generates $r_t$, which enters the ledger for call $t+1$ exactly as under Explicit Reasoning. The ledger update is

$$M_{t+1}=M_t\oplus r_t$$

and generation delays the next call only if it runs longer than the execution window, and then only by the difference:

$$T_{\text{Tacit}}=T_{\text{action}}+\max\bigl(0,\;T_{\text{reason}}-T_{\text{exec}}\bigr) \tag{4}$$

The ledger semantics in Appendix A are what make this safe, and they are specified closely. On RoboMME each call generates one subtask sentence, using the benchmark's simple subgoal annotation without the image coordinates of its grounded variant; an entry enters the ledger only after its 16-action chunk has executed, so the first entry appears at the second call; adjacent duplicates are removed; the ledger resets per episode and is never truncated. Explicit Reasoning generates its entry before the action it conditions on and TacitVLA after computing the action, but both append it at the same boundary, so every later call conditions on a ledger built under one protocol. In both policies an entry names the subtask being undertaken and carries no outcome: a grasp that fails still leaves its entry, and the count recovers when the next call generates the subtask again. On RMBench the next subtask is decoded greedily for each 32-action plan.

In deployment the deferred generation continues from the key-value cache the action path already built; if it has not finished when the next observation arrives, the next call waits for it, which is the second term of Equation 4 becoming non-zero. During training the ledger prefix is the annotated subtask sequence, while at deployment it is generated. That train/deploy shift is one Explicit Reasoning faces too, but it is the real risk of deferral: a wrong entry stays in the ledger and is read by every subsequent call.

flowchart TD
    C[Context c_t instruction observation ledger M_t on memory tasks] --> PF[Backbone prefill builds the KV cache]
    PF --> A1[Explicit autoregressive generation of r_t
RoboMME 93 ms LIBERO 345 ms driving 143 ms]
    A1 --> A2[Backbone pass over the generated tokens 5 to 8 ms]
    A2 --> A3[Flow matching denoising K Euler steps
action expert attends to c_t and r_t]
    A3 --> A4[Chunk ready T_action + T_reason
220 ms 495 ms 269 ms]
    A4 --> A5[Execute the chunk window T_exec]
    PF --> B1[Tacit flow matching denoising
action expert attends to c_t only one masked cell]
    B1 --> B2[Chunk ready T_action
127 ms 147 ms 127 ms]
    B2 --> B3[Execute the chunk window 800 ms to 11181 ms]
    B2 -->|memory task reuses the same KV cache| B4[Generate ledger entry r_t asynchronously
longest measured 180 ms at most 23 percent of the window]
    B4 --> B5[Append at the same boundary M_t+1 = M_t + r_t]
    B3 --> B6[Next call never waits for generation]
    B5 --> B6
    B2 -->|non-memory task nothing consumes r_t| B7[Generate no text at all]

6. Setup: Four Benchmarks, Three Trainings, One Recipe

The comparison runs on four benchmarks, two memory and two non-memory (Table 1). Each row is one architecture trained three times on the same data. On the memory tasks No Reasoning therefore measures the joint value of reasoning supervision and the ledger, since it carries neither.

Benchmark	Task type	Reasoning text	Backbone	Size	Observation and action (Appendix Table 10)
RoboMME	memory	next subtask	PaliGemma ($\pi_{0.5}$)	3.7B	front and wrist views plus up to 32 sampled history frames; predicts 20 actions (32-D, 8 active), executes 16, 10 Euler steps
RMBench	memory	next subtask	RynnBrain-2B	2.6B	first frame, head frame from 32 actions earlier, current head/left/right; predicts 32 targets (14-D), executes all 32, 32 Euler steps
LIBERO (+Plus)	non-memory	scene description and plan	RynnBrain-2B	2.5B	agent and wrist images plus the agent image from 8 steps earlier; predicts 10 actions (7-D), executes 5, 32 Euler steps
PhysicalAI-AV	non-memory	chain of causation	Qwen3-VL-2B	3.9B	4 frames from each of two front cameras at 10 Hz plus 16 past ego states; predicts 64 waypoints over 6.4 s, closed loop executes 1 per 100 ms

Table 1: the four benchmarks and the configuration shared by all three policies (compiled from the paper's Tables 1 and 10). Size is TacitVLA's total parameter count including the action expert.

Per-benchmark protocol. RoboMME is a 16-task memory benchmark whose four counting tasks require counting repeated actions or events; its authors found perceptual and symbolic memory complementary and suggested combining them, which this paper does inside one backbone: every policy carries the benchmark's FrameSamp perceptual memory with its modulator on all 16 tasks, and the reasoning policies add the ledger on the counting tasks only, trained on the benchmark's simple subgoal annotations. Two training setups are reported, counting-suite only and all 16 tasks. RMBench tests memory over long manipulation episodes; the paper uses the four of its nine tasks that WLA-0 reports, 100 cases each (Blocks Ranking Try, Battery Try, Press Button, Cover Blocks). LIBERO is the standard four-suite, ten-task manipulation benchmark with DeepThinkVLA's released reasoning annotations, plus zero-shot LIBERO-Plus over seven perturbation axes and 10,030 cases for out-of-distribution robustness. PhysicalAI-AV trains on a proprietary corpus of 3.8 million driving events annotated with Alpamayo-R1-style chains of causation; open loop evaluates on 1,434 held-out segments of the public release, closed loop on the 441-scene public split of the AlpaSim driving challenge (20 s rollouts at 10 Hz, three rollouts per scene, a failed rollout counted as a failure, route not given to the model).

Training (Appendix Table 9) uses AdamW on nodes of eight H100s. RoboMME: batch 64, peak learning rate $5\times10^{-5}$, warmup 5k (counting) or 10k (16 tasks), 60k or 80k updates, constant rate after warmup. RMBench and LIBERO: batch 512, per-component rates of $5\times10^{-6}$ / $5\times10^{-5}$ / $2\times10^{-4}$ for vision tower, language model and action expert, cosine decay to 10% of peak, 80k and 40k updates, 16 noise draws per example. Driving: batch 256, $1\times10^{-5}$ / $1\times10^{-4}$ / $4\times10^{-4}$, decay to 1%, 100k updates. The cross-entropy weight $\lambda$ in Equation 1 is 0.1 on LIBERO and driving and 1.0 on RMBench; on RoboMME every policy is trained at $\lambda\in\{0.1,0.01,0.001\}$ and reported at its best. The same $\lambda$ scales the tokenized-action term in every policy, and in No Reasoning it scales that term alone. Gradients from the action expert into the backbone are enabled after 2k updates on RMBench and LIBERO, after the 4k warmup in driving, and from the start on RoboMME.

Evaluation is equally uniform: the three robot benchmarks train only on each benchmark's released demonstrations, report success as mean and standard deviation over three evaluation seeds under the official protocol and cases, and separate a reasoning prompt from a direct prompt (LIBERO's 201 unannotated demonstrations train under the direct prompt for action supervision only). Reasoning is decoded greedily on the three robot benchmarks with a cap of 128 tokens (RoboMME) or 256 (RMBench, LIBERO), and sampled in driving at temperature 0.6 with top-p 0.98. Open-loop driving reports the minimum over six sampled trajectories of the average displacement error. All three policies run the same inference implementation, timed on one H100.

7. RoboMME: A Ledger Written During Execution Keeps the Whole Gain

Trained on the counting suite alone and evaluated on its four tasks (200 cases), TacitVLA reaches 89.5 and Explicit Reasoning 86.7, against 79.0 for No Reasoning (Table 2). The benchmark's human reference is 88.5, and in that reference people only chose each high-level action while an oracle planner executed it without error; TacitVLA also has to execute every motion. Reasoning supervision adds 10.5 points for TacitVLA and 7.7 for Explicit Reasoning, so an entry generated during action execution retains the full gain of one generated before the action.

Trained on all 16 tasks, the three policies score 46.5, 45.8 and 48.1 overall, against 44.5 for FrameSamp + Modulator, the best published result on the benchmark. On the counting tasks TacitVLA's 82.7 is 15.9 points above the best published row (FrameSamp + Expert, 66.8), within 1.2 points of the two oracle-subgoal rows (83.9 and 82.6) that receive the simulator's ground-truth subgoals, and above the trained symbolic systems (38.0 to 48.8) that run a second vision-language model to generate their subgoals.

Policy	Counting-suite training Counting (200 cases)	16-task training Counting	16-task training Permanence	16-task training Reference	16-task training Imitation	16-task training All tasks (800 cases)
Human (oracle planner)	88.5	—
$\pi_{0.5}$ (published)	—	28.8	17.0	17.2	8.8	17.9
MemER (published)	—	48.8	53.2	38.0	29.5	42.4
FrameSamp + Expert (published)	—	66.8	25.2	24.1	28.9	36.3
FrameSamp + Modulator (best published)	—	65.2	25.1	36.3	51.4	44.5
No Reasoning (this paper)	79.0 ± 1.0	79.2 ± 1.0	23.8 ± 2.6	35.2 ± 2.0	48.0 ± 1.0	46.5 ± 0.9
Explicit Reasoning (this paper)	86.7 ± 2.0	81.5 ± 1.8	26.8 ± 0.6	27.7 ± 2.0	47.0 ± 2.6	45.8 ± 1.5
TacitVLA (this paper)	89.5 ± 1.3	82.7 ± 3.8	23.8 ± 3.1	37.8 ± 2.9	48.0 ± 1.5	48.1 ± 1.0

Table 2: RoboMME success (%). The left column is the policy trained on the counting suite alone; the five right columns are the policy trained on all 16 tasks, where only the counting tasks receive reasoning supervision. Rows from this paper are mean ± standard deviation over three evaluation seeds; published rows are quoted as printed (compiled from the paper's Tables 2 and 3).

The $\lambda$ sweep (paper Table 11) gives a less comfortable and more complete picture. On the counting suite, No Reasoning scores 77.3 / 79.0 / 74.5 at $\lambda=0.1$ / 0.01 / 0.001, Explicit Reasoning 86.7 / 84.7 / 73.0, and TacitVLA 85.5 / 89.5 / 82.5; on all 16 tasks the three policies score 43.6 / 46.5 / 44.0, 43.5 / 45.8 / 43.8, and 44.0 / 47.6 / 48.1. TacitVLA is above No Reasoning in all six settings and best of the three in five, and in the sixth (counting suite at $\lambda=0.1$) it is 1.2 points below Explicit Reasoning. The headline tables report each policy at its best of three $\lambda$ values, and the three policies do not share an optimum: Explicit Reasoning peaks at $\lambda=0.1$ while TacitVLA peaks at 0.001 on the 16-task setup. That is a small hyperparameter selection applied per policy.

Figure 3 (paper Figure 4). RoboMME BinFill, front camera at the calls that generate a new ledger entry and at the episode's last call, using the counting-suite policies of Table 2. Entries name the subtask being attempted and carry no outcome.

8. RMBench: the Count That Exists Only in the Ledger

On three of the four RMBench tasks (Blocks Ranking Try, Battery Try, Cover Blocks) the policies sit within a point of one another. The separation is on Press Button, where the number of presses exists only in the ledger and nowhere in the current observation: 7.7 for No Reasoning, 73.3 for Explicit Reasoning, 74.3 for TacitVLA (Table 3). Both reasoning policies keep a correct ledger in 99.7% of episodes. The four-task means are 60.4, 77.0 and 77.5, all above WLA-0's 56.5, and TacitVLA's margin over No Reasoning is the +17.1 points quoted in the abstract.

Policy	Blocks Ranking Try	Battery Try	Press Button	Cover Blocks	Four-task mean	Correct ledger (Press Button)
DP / ACT / $\pi_{0.5}$ / X-VLA (published)	10 / 0 / 6 / 1	10 / 19 / 16 / 26	0 / 0 / 0 / 0	0 / 0 / 0 / 2	5.0 / 4.8 / 5.5 / 7.3	—
MemER (published)	0	27	0	6	8.3	—
QwenOFT / HiMem-WAM (published)	37 / 24	14 / 28	0 / 8	0 / 19	12.8 / 19.8	—
MemoryVLA (QwenOFT, published)	53	33	0	69	38.8	—
EventVLA (published)	81	35	3	97	54.0	—
WLA-0 (best published)	23	45	74	84	56.5	—
No Reasoning (this paper)	94.3 ± 2.5	42.0 ± 1.7	7.7 ± 2.1	97.7 ± 2.1	60.4 ± 1.5	—
Explicit Reasoning (this paper)	94.3 ± 1.2	42.3 ± 1.5	73.3 ± 2.5	98.0 ± 1.0	77.0 ± 1.9	99.7
TacitVLA (this paper)	94.7 ± 1.5	43.0 ± 2.6	74.3 ± 2.5	98.0 ± 1.0	77.5 ± 1.1	99.7

Table 3: RMBench success (%), 100 cases per task (compiled from the paper's Tables 4 and 14). "Correct ledger" is the fraction of episodes whose final generated ledger matches the instructed count. The same table on the RoboMME side gives BinFill 90.0 (Explicit) versus 92.0 (Tacit) and 100.0 for both on PickXtimes and SwingXtimes.

Ledger correctness deserves its own reading, because the safety of deferred generation rests entirely on it: if asynchronously written entries were more often wrong, the error would be read by every later call and would compound. The paper's finding is that the two policies are within two points on every task, and that every TacitVLA failure on Press Button ends on the step budget with the physical press count off target while its ledger is correct. That qualification matters: the failures are on the execution side, not the memory side.

Figure 4 (paper Figure 5). RMBench Press Button, head camera at the calls that generate a new ledger entry and at the last call of the episode. One call can add two entries when a press completes inside a single action chunk.

9. LIBERO and LIBERO-Plus: +5.3 Points Without Emitting a Single Token

On LIBERO-Plus, reasoning supervision lifts success from 67.6 (No Reasoning) to 73.5 (Explicit Reasoning), and TacitVLA scores 72.9: within a point of Explicit Reasoning and 5.3 points above No Reasoning. The four standard suites are close to saturation, where the three policies score 98.5, 98.1 and 98.6, within a point of each other and of WLA-0's 98.6. The load-bearing fact here is that TacitVLA emits no text at all on this benchmark at deployment, so those 5.3 points reach the action through the representation alone.

Against published policies trained, like these, on the LIBERO demonstrations alone, the two reasoning policies hold the top two LIBERO-Plus totals: MergeVLA 72.4, Evo-Depth 69.6, $\pi_{0.5}$ (LIT's baseline) 69.0, LoopOFT $\alpha$ 65.8, MolmoAct2 63.6, MolmoAct† 60.8, VLA-Adapter 59.1, DreamVLA 48.9. Policies of the same backbone class trained without reasoning supervision land near this paper's No Reasoning (67.6): LoopVLA's Qwen3-VL-2B baseline with a direct action MLP scores 68.8 and LIT's $\pi_{0.5}$ baseline 69.0, so No Reasoning is a competent policy of its class and the lift comes from supervision. The paper explicitly excludes systems with robot-action pretraining (DeepThinkVLA, 79.0) and systems with substantially more parameters (VLA-GSE 81.2, FoMoVLA 80.5) from the matched comparison, which is a cleaner boundary than most papers draw.

Policy	Robot init.	Sensor	Camera	Language	Objects	Background	Light	LIBERO-Plus all	Standard four suites
cases	1,550	1,601	1,599	1,537	1,525	1,076	1,142	10,030	2,000
No Reasoning	59.7 ± 1.1	51.7 ± 1.1	41.0 ± 1.1	76.6 ± 0.9	73.2 ± 1.0	92.9 ± 0.7	94.0 ± 0.6	67.6 ± 0.4	98.5 ± 0.3
Explicit Reasoning	71.1 ± 0.8	51.1 ± 0.9	51.5 ± 0.9	83.7 ± 0.6	78.3 ± 0.7	97.2 ± 0.3	96.8 ± 0.4	73.5 ± 0.3	98.1 ± 0.4
TacitVLA	69.9 ± 0.8	60.0 ± 0.8	42.2 ± 0.8	83.0 ± 0.6	77.1 ± 0.7	98.0 ± 0.3	95.4 ± 0.4	72.9 ± 0.3	98.6 ± 0.3

Table 4: LIBERO-Plus broken down by its seven perturbation axes, plus the standard four suites (compiled from the paper's Tables 12 and 13; per-suite values are Spatial 99.2 / 98.4 / 99.2, Object 99.6 / 99.8 / 100.0, Goal 98.8 / 97.8 / 98.0, Long 96.4 / 96.4 / 97.2).

Axis by axis, the largest gain over No Reasoning is on changed robot initial states: +11.4 for Explicit Reasoning and +10.2 for TacitVLA. The two reasoning policies do not agree axis by axis, though. TacitVLA is 8.9 points above Explicit Reasoning on Sensor (60.0 versus 51.1) and 9.3 points below it on Camera (42.2 versus 51.5). The paper does not explain either reversal, and both are larger in magnitude than the 0.6-point gap in the totals: the "matched performance" claim on this benchmark is the net of offsetting deviations rather than agreement on every axis. With per-axis standard deviations around 0.8 points over three evaluation seeds, neither reversal can be classified as noise or as effect from what is reported.

Figure 5 (paper Figure 6). LIBERO agent camera at six calls with the opening of the reasoning generated at each, for the policies of Table 4. On this non-memory benchmark TacitVLA does not generate this text at deployment; its row reflects the reasoning supervision it received during training.

10. PhysicalAI-AV: the Same Argument in Closed-Loop Driving

All three policies train on the driving corpus and are evaluated on scenes disjoint from it. In open loop both reasoning policies lower displacement error below No Reasoning's 1.166 m, to 1.140 m for Explicit Reasoning and 1.116 m for TacitVLA. In closed loop TacitVLA reaches a scene score of 52.5% and Explicit Reasoning 52.3%, against 46.4% for No Reasoning; both reasoning policies pass more scenes and cause fewer at-fault collisions.

For scale, on the organizers' published reference rollouts under the same scenes and protocol, Alpamayo-R1 (a 10B model with four cameras) scores 55.0%; VaVAM scores 11.0% under the competition controller and 31.4% under a linear controller that the competition does not provide; five unattributed submissions score between 5.8% and 16.8%. TacitVLA comes within 2.5 points of Alpamayo-R1 with fewer than half the parameters and half the cameras.

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

Table 5: PhysicalAI-AV. Open-loop minADE is the minimum over six samples of the average displacement error on 1,434 held-out segments of the public release; closed-loop values are AlpaSim's metrics on the 441-scene public split of the challenge with one sampled trajectory per call, averaged over three rollouts per scene (compiled from the paper's Table 6). Infractions are at-fault collisions and off-road events.

The infraction columns show that a matched scene score is not a matched row. TacitVLA's at-fault collision rate is 6.7% against Explicit Reasoning's 5.5%, its off-road rate 10.0% against 9.0%, and its kilometers per infraction 0.87 against 1.01; it recovers the scene score through a lower any-collision rate (15.6% versus 16.9%) and a nearly identical pass rate. Scene score is a competition aggregate, and these one-point differences on safety-related sub-metrics are not accompanied by a significance test at 441 scenes and three rollouts each. Appendix D shows one successful and one failed episode per reasoning policy per benchmark together with the reasoning text they generate, and the paper's statement is that no failure mode in those examples is clearly specific to TacitVLA. That is a qualitative observation, not a statistical one.

Figure 6 (paper Figure 8). PhysicalAI-AV closed loop: front camera at five calls in two public-split scenes, with the chain of causation generated at each call. Driving reasoning is sampled at temperature 0.6 and top-p 0.98 rather than decoded greedily.

11. Latency: Which Stage the Savings Actually Come From

Timing uses host wall-clock timers with device synchronization at each stage boundary, on one NVIDIA H100 80 GB in bf16, one policy process at a time. The visual encoder, prompt prefill and each denoising step run as captured CUDA graphs, and text generation replays one graph per token over a static key-value cache. $T_{\text{action}}$ is visual encoding, prefill and denoising, the same three stages for every policy, with the prefill charged to $T_{\text{action}}$ (under Explicit Reasoning it runs as the first step of generation). $T_{\text{reason}}$ is the autoregressive generation of $r_t$ plus, for Explicit Reasoning only, the backbone's 5 to 8 ms pass over the generated tokens that its expert conditions on. On memory tasks TacitVLA's action and its deferred generation share one prefill, so its $T_{\text{action}}$ sits a few milliseconds above No Reasoning's. That is the only visible cost of asynchronous generation.

Benchmark	$T_{\text{exec}}$ (ms)	$T_{\text{action}}$ No Reasoning	$T_{\text{action}}$ TacitVLA	$T_{\text{reason}}$ TacitVLA	$T_{\text{reason}}$ Explicit	Latency No Reasoning	Latency TacitVLA	Latency Explicit
RoboMME, counting	800	127	127	93	93	127	127	220
RMBench, Press Button	6,972	170	171	66	66	170	171	236
RMBench, Blocks Ranking Try	8,116	162	171	81	87	162	171	257
RMBench, Cover Blocks	9,359	170	170	101	106	170	170	275
RMBench, Battery Try	11,181	162	169	120	126	162	169	294
LIBERO	250	147	147	—	345	147	147	495
LIBERO-Plus	250	147	147	—	347	147	147	497
PhysicalAI-AV, closed loop	100	127	127	—	143	127	127	269

Table 6: stage times and latency per call in milliseconds (compiled from the paper's Table 15). TacitVLA generates inside the execution window on memory tasks and not at all on non-memory tasks; RMBench's window is the motion planner's mean time to execute one plan.

Table 6 reads as three separate claims. First, the ratio: Explicit Reasoning's latency is 1.4x to 3.4x TacitVLA's, and the largest gap is on a non-memory task, LIBERO at 495 ms versus 147 ms, because the entire difference is the generation of text the next call never uses. Second, whether the window constraint holds: LIBERO's window is 250 ms (5 actions at 20 Hz), which TacitVLA's 147 ms meets and Explicit Reasoning's 495 ms does not, meaning explicit reasoning cannot even finish computing before the chunk it is computing for has executed. Third, the margin on asynchronous generation: no deferred generation exceeded its window in any call, the longest RoboMME entry took 180 ms against an 800 ms window and the longest RMBench entry 225 ms against windows of 6,972 ms and up, at most 23% of the window. TacitVLA's latency therefore equals $T_{\text{action}}$ in every cell.

Figure 7 (paper Figure 3). Latency per call for the three policies on each benchmark. Each bar is $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 over TacitVLA. Values are means over model calls on one H100.

One more detail is easy to miss. The RoboMME row is the 16-task policy measured on its four counting tasks; on the other twelve tasks, which keep no ledger, no policy generates text and the three latencies coincide at 143 to 144 ms. The latency gap is therefore a property of the schedule, not of the architecture: the same model is already equally fast on tasks that write no ledger.

12. Limitations

(Stated by the authors) Performance depends on the quality of the reasoning data. Since TacitVLA's benefit travels exclusively through the pathway where reasoning supervision shapes the representation, weak annotations narrow that pathway. The paper's own evaluation partly hides the sensitivity: LIBERO uses DeepThinkVLA's released per-frame annotations, RoboMME the benchmark's simple subgoals, RMBench WLA's subtask-ledger form, and driving Alpamayo-R1-style chains of causation. All four are mature annotation sets, and no experiment reports how each policy degrades as annotation quality drops.

(Stated by the authors) Deferral is free only while the entry fits the execution window. It occupies at most 23% of the window in these benchmarks; longer entries or shorter windows add back exactly the amount by which generation exceeds the window (Equation 4). The closed-loop driving row is already against that boundary: its window is 100 ms while the driving policy's $T_{\text{reason}}$ is 143 ms. It pays nothing only because driving is a non-memory task that generates no text at all; using the chain of causation as a ledger would put this configuration straight back into the second term of Equation 4.

(Stated by the authors) The interpretability use is left to future work. On non-memory tasks TacitVLA can still generate the reasoning text after the action for inspection, which is attractive in safety-critical settings such as driving, but the paper does not evaluate whether that after-the-fact text faithfully describes what produced the action. For an action expert that no longer conditions on the text, the coupling between explanation and action is unknown.

(This review) Every result is in simulation. The four benchmarks are RoboMME, RMBench, LIBERO(-Plus) simulators and AlpaSim; there is no real-robot experiment. $T_{\text{exec}}$ here is a simulator control rate or a motion planner's time, whereas a real execution window jitters and loses margin to communication and safety checks, so the "never overflowed the window" conclusion, which rests on a margin of at most 23%, needs re-measuring on hardware.

(This review) The headline numbers include a hyperparameter selection, and axis-wise agreement does not hold. On RoboMME each policy is reported at its best of three $\lambda$ values, and the three policies do not share an optimum. In the LIBERO-Plus breakdown TacitVLA and Explicit Reasoning disagree in opposite directions on Sensor (+8.9) and Camera (−9.3), both larger than the 0.6-point difference in the totals. Combined with the saturated standard suites (98.1 to 98.6, within a point), the evidence for "matches explicit reasoning" concentrates on the few metrics that are not yet saturated: RoboMME counting, RMBench Press Button, LIBERO-Plus, and the driving scene score.

(This review) The driving group is not reproducible, and the Alpamayo-R1 comparison is not equal-condition. The training corpus is 3.8 million proprietary driving events that outsiders cannot rerun. TacitVLA uses two cameras and about 3.9B parameters against Alpamayo-R1's four cameras and 10B, so "within 2.5 points with half the cameras and parameters" is true, but fewer cameras also means less input information, and that difference can cut in either direction when reading the comparison.

13. Conclusion and Outlook

The contribution is less a new model than a clean attribution experiment. It separates two things that reasoning VLAs have kept bundled, supervision at training time and conditioning at deployment time, and shows with three versions differing by one attention-mask cell, across four benchmarks and two task types, that within the studied regimes an action expert that never conditions on the current reasoning matches one that does. The benefit reaches the action through the representation shaped by supervision and, on memory tasks, through the earlier ledger entries already in the action expert's context; the current entry does not participate.

Its engineering value is that it adds no parts: still one backbone feeding one action expert, with no second model, no scheduler and no dual-system frequency split. The paper draws the practical corollary itself: any reasoning VLA of this form can be trained as TacitVLA by masking the reasoning tokens from the action expert, then deployed with generation omitted, or, when the text serves as memory, run during action execution.

Two next steps follow directly. One is to turn the after-the-fact text into a verifiable explanation for inspection in safety-critical settings, which the authors name as future work. The other is to merge this result with Fast-WAM's: if predicting future video also helps mainly through training-time representations, then a backbone with three experts (reasoning, future video, action), trained on all three targets and deployed without generating either reasoning or video, is the natural extension of the argument here. Neither has results yet, and both rest on the premise this paper just tested.

Golden Quote

Must the action condition on the current reasoning, or is learning to generate it enough? Across four benchmarks the answer is the latter: an action expert that never reads the reasoning it just wrote matches one that must, and it does not have to wait.