PaperlayerView exact revision on arXiv

Source-linked AI summary

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

arXiv:2610.17540v1cs.AIcs.RO

TL;DR

Reasoning text can improve VLA models, but conditioning actions on autoregressively generated reasoning adds latency, and its role as memory means it cannot always be omitted. TacitVLA masks current-call reasoning from the action expert and, on memory tasks, generates ledger entries during action execution. Across four benchmarks it matches Explicit Reasoning’s performance with lower latency, while matching No Reasoning’s latency with improved success.

  • Problem

    Reasoning VLAs use text as supervision, memory, and an action input, but autoregressive generation on the action path adds latency and prior reasoning-free deployments had not resolved performance costs or memory-task behavior.

    Source: §1 · p. 2

  • Method

    TacitVLA retains reasoning supervision but masks reasoning tokens from the action expert, generating ledger entries during action execution when memory is needed.

    Source: §1 · p. 2, §7 · p. 10

  • Results

    Across four benchmarks, TacitVLA matches Explicit Reasoning’s performance at up to 3.4× lower latency and matches No Reasoning’s latency with up to +17.1% success.

    Source: §1 · p. 2, §7 · p. 9

  • Takeaways & Limitations

    For this VLA architecture, reasoning supervision can benefit actions without current-call reasoning input, while memory entries can be generated during execution.

    Source: §7 · pp. 9–10

    TacitVLA’s performance depends on the quality of the reasoning data.

    Source: §7 · p. 10

Abstract

from arXiv · show

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.

1. Introduction

Reasoning text can improve VLA models but adds latency when actions wait for its autoregressive generation. TacitVLA tests whether reasoning supervision can retain its benefits while decoupling action execution from current-call reasoning.

1. Introduction

  • Reasoning VLAs use generated text as training supervision, episodic memory on long-horizon tasks, and an action input that adds autoregressive decoding latency.For the LIBERO and PhysicalAI-AV reasoning VLAs studied, generating the reasoning text accounts for 53% to 70% of latency per call.Source: §1 · p. 2
  • Earlier reasoning-free deployments left open whether removing generation costs performance and did not evaluate tasks where the text must be retained as memory.The paper asks whether learning to generate reasoning is sufficient without conditioning the action on current-call reasoning.Source: §1 · p. 2
  • TacitVLA trains on the same sequence as Explicit Reasoning but masks the action expert from reasoning tokens; No Reasoning removes reasoning supervision.This controlled comparison isolates whether the action must condition on the reasoning generated for the current call.Source: §1 · p. 2
  • Across four benchmarks, TacitVLA matches Explicit Reasoning’s performance while reaching up to 3.4× lower latency and No Reasoning’s latency with up to +17.1% success.The benchmarks span manipulation and autonomous driving, and memory and non-memory tasks.Source: §1 · p. 2

2. Related work

Prior work has explored reasoning as a training target, ways to reduce reasoning latency, and memory formats for long-horizon policies. TacitVLA holds the ledger protocol and single-backbone/single-action-expert design fixed while moving memory-entry generation into the action execution window.

2. Related work

  • Prior reasoning VLAs reduce latency through stale-chain reuse, latent reasoning, or inference optimizations, whereas TacitVLA removes the need to generate reasoning before action prediction.Earlier embodied chain-of-thought policies ran at 0.3 to 0.5 Hz versus 3 to 4 Hz without test-time reasoning on the same GPU; hybrid action decoding narrows the gap to 1.4×.Source: §2 · p. 3
  • Earlier work trained on reasoning text but left comparisons confounded or omitted memory tasks; TacitVLA fixes sequence, data, prompts, and optimizer while varying action attention alone.Prior comparisons differed in action decoding, training mixture, checkpoint setup, or policy scale.Source: §2 · p. 3
  • Memory policies retain information as text, latent tokens, or compressed gist, while hierarchical designs run a slower vision-language model alongside a fast controller.Examples include WLA’s subtask ledger [Yang et al., 2026c] and OneTwoVLA’s latest reasoning [Lin et al., 2026a].Source: §2 · p. 3
  • TacitVLA keeps one backbone, one action expert, and the ledger protocol, shifting each ledger entry’s generation into the execution window.This removes its deployment latency while preserving the existing memory format.Source: §2 · p. 3

3. Preliminaries

The policy combines a vision-language backbone that generates reasoning with an action expert that denoises action chunks. Reasoning may serve as a ledger for later calls or as text for the current action only, and explicit generation adds time to the action path.

3.1. Reasoning VLAs

  • A reasoning VLA maps context to an action chunk using a backbone that generates reasoning and an action expert that conditions on the backbone’s representation.The context includes instructions, observations, and history; memory tasks also include a ledger of past subtasks.Source: §3.1 · pp. 3–4
  • The backbone learns reasoning and tokenized-action next-token targets with cross-entropy, while the action expert denoises the action chunk using flow matching.The action expert alone produces the deployed action; tokenized actions are an auxiliary target.Source: §3.1 · p. 4
  • Explicit Reasoning generates reasoning before action denoising and conditions the action expert on it; No Reasoning uses the same architecture without reasoning supervision.The backbone and action expert have separate weights but share attention.Source: §3.1 · p. 4, Figure 2 · p. 4

3.2. Memory and non-memory tasks

  • On memory tasks, reasoning becomes a ledger entry naming the attempted subtask and recording information the current observation no longer shows; non-memory reasoning serves only the immediate action.Later calls condition on the ledger in memory tasks, but not on the reasoning text in non-memory tasks.Source: §3.2 · pp. 4–5

3.3. Latency of a call

  • A call’s action path includes visual encoding, prompt prefill, and denoising; explicit-reasoning latency adds reasoning generation and, when applicable, a backbone pass over generated tokens.The execution window is the physical time committed actions take before the next call is due.Source: §3.3 · p. 5

4. TacitVLA

TacitVLA preserves reasoning supervision while masking reasoning tokens from the action expert. It omits reasoning generation for non-memory tasks and defers ledger generation until action execution on memory tasks.

4.1. Masking reasoning from the action expert

  • Explicit Reasoning and TacitVLA share the training sequence, loss, prompts, data, and optimizer, differing only in the action positions’ attention pattern.The shared sequence contains context, reasoning and tokenized-action targets, plus action-expert placeholder positions.Source: §4.1 · p. 5
  • Reasoning reaches actions through backbone supervision and direct attention to reasoning tokens; TacitVLA retains the first pathway and removes the second.Comparing TacitVLA with No Reasoning isolates the supervision pathway, while comparing it with Explicit Reasoning isolates direct attention to reasoning.Source: §4.1 · p. 5

4.2. Deferring text generation

  • On non-memory tasks, TacitVLA skips reasoning generation; on memory tasks, it generates the ledger entry while the robot executes the action chunk.The next call is delayed only if generation exceeds the execution window, and then only by the overrun.Source: §4.2 · p. 5

5. Experimental setup

The study compares three policy variants across four manipulation and driving benchmarks, spanning memory and non-memory tasks. Evaluations use benchmark protocols and shared training data for each architecture’s variants.

5. Experimental setup

  • Each architecture is trained as No Reasoning, Explicit Reasoning, and TacitVLA; the variants differ in attention, reasoning supervision, and, on memory tasks, ledger use.On memory tasks, No Reasoning measures the joint value of reasoning supervision and the ledger.Source: §5 · p. 5, Table 1 · p. 6
  • RoboMME covers 16 memory tasks, including four counting tasks with ledger entries trained on simple subgoal annotations; RMBench evaluation uses four of its nine tasks, with 100 cases each.RoboMME policies also carry FrameSamp perceptual memory; reasoning policies add the ledger on counting tasks.Source: §5 · p. 6
  • LIBERO evaluation includes its four standard 10-task suites and zero-shot LIBERO-Plus perturbations, while PhysicalAI-AV evaluation includes held-out open-loop segments and closed-loop challenge scenes.LIBERO-Plus applies seven perturbation axes over 10,030 cases; the driving challenge uses the 441-scene public split.Source: §5 · p. 6
  • Robot policies train on each benchmark’s released demonstrations, and success is averaged over three evaluation seeds under official protocols.Closed-loop driving values average three rollouts per scene; inference timing is measured on one H100.Source: §5 · p. 6

6. Results

TacitVLA matches Explicit Reasoning across the reported benchmarks while matching No Reasoning latency. Its action can proceed without waiting for current reasoning, with ledger generation overlapped with execution on memory tasks.

6.1. Performance

  • 89.5 vs. 79.0: TacitVLA exceeds No Reasoning on RoboMME Counting, while the all-task scores are 48.1 for TacitVLA and 44.5 for the best published result.On Counting, Explicit Reasoning scores 86.7; on all 16 tasks, Explicit Reasoning scores 45.8 and No Reasoning 46.5.Source: Table 2 · p. 6, §6.1 · pp. 6–7, Table 3 · p. 7
  • 77.5 vs. 77.0: TacitVLA edges Explicit Reasoning on RMBench’s four-task mean, and all three policies exceed WLA-0’s 56.5 mean.On Press Button, whose count exists only in the ledger, TacitVLA scores 74.3 versus 7.7 for No Reasoning.Source: Table 4 · p. 7, §6.1 · p. 7
  • 72.9: TacitVLA’s LIBERO-Plus success is within a point of Explicit Reasoning’s 73.5 and 5.3 points above No Reasoning’s 67.6.On the four standard suites, the three policies score 98.5, 98.1, and 98.6 for No Reasoning, Explicit Reasoning, and TacitVLA, respectively.Source: Table 5 · p. 8, §6.1 · p. 8
  • 52.5%: TacitVLA’s closed-loop PhysicalAI-AV scene score is close to Explicit Reasoning’s 52.3% and above No Reasoning’s 46.4%.In open loop, TacitVLA’s displacement error is 1.116 m, versus 1.140 m for Explicit Reasoning and 1.166 m for No Reasoning.Source: §6.1 · p. 8, Table 6 · p. 9

6.2. Latency

  • 1.4×–3.4× higher: Explicit Reasoning latency exceeds TacitVLA’s, which matches No Reasoning latency across benchmarks.On memory tasks, ledger generation finishes within the execution window; on non-memory tasks, TacitVLA generates no text at deployment.Source: §6.2 · pp. 8–9, Figure 3 · p. 9

7. Conclusion

Across the four studied benchmarks, an action expert that does not condition on current reasoning matches one that does. TacitVLA routes reasoning benefits through supervision and, on memory tasks, earlier ledger entries, while generating ledger entries during action execution.

7. Conclusion

  • Across four benchmarks spanning manipulation and autonomous driving, memory and non-memory tasks, TacitVLA matches the performance of an action expert that conditions on current reasoning.The reported mechanism is reasoning supervision and, on memory tasks, the ledger of earlier entries in the action expert’s context.Source: §7 · pp. 9–10
  • TacitVLA keeps one backbone and one action expert, masking reasoning tokens from the action expert during training.Generation can be omitted at deployment or deferred to action execution when reasoning serves as memory.Source: §7 · p. 10
  • On memory tasks, deferred ledger generation adds no latency only while it fits within the execution window.In these benchmarks, entries take at most 23% of the window; longer entries or shorter windows add the amount by which generation exceeds it.Source: §7 · p. 10
  • TacitVLA’s performance, like that of other reasoning VLAs, depends on the quality of its reasoning data.Source: §7 · p. 10

A. Implementation and evaluation protocol

The appendix details policy architectures, inputs, training data and settings, prompts, and benchmark protocols. Memory-task ledger construction and deferred generation are also specified.

A. Implementation and evaluation protocol

  • Across benchmarks, the action expert is a second transformer stack with separate weights that shares the backbone’s attention geometry and attends to same-layer backbone keys and values.The RoboMME policy also uses frame-sampling memory; the RMBench, LIBERO, and driving policies use Qwen3-VL-2B architecture with differing vocabularies.Source: A. Implementation and evaluation… · p. 16, Table 8 · p. 17
  • Training uses benchmark-specific data: 400 counting-task demonstrations for RoboMME, 50 per RMBench task, 1,817 successful LIBERO replays, and 3.8 million reasoning-labeled driving events.Of the LIBERO demonstrations, 1,616 have reasoning annotations; the driving events contain a 1.6 s history and 6.4 s future window.Source: A. Implementation and evaluation… · p. 16
  • The policies use benchmark-specific optimization schedules, and reasoning examples use separate prompts from direct-action examples.On LIBERO, unannotated demonstrations train under the direct prompt for action supervision only; both reasoning policies deploy with their training prompt.Source: A. Implementation and evaluation… · pp. 16–17
  • Inputs vary by benchmark, with RoboMME and RMBench including ledger context and No Reasoning dropping only the ledger while retaining the same observations.LIBERO uses agent and wrist images, a lagged agent image, state, and instruction; driving uses front-camera frames, past ego states, and a fixed reasoning prompt.Source: A. Implementation and evaluation… · pp. 16–17
  • Evaluation uses each benchmark’s specified cases and protocols, including 50 RoboMME episodes per task, 100 RMBench cases per task, and 2,000 standard LIBERO cases.Closed-loop driving follows the challenge protocol on its 441-scene public split, with 20 s rollouts at 10 Hz and three rollouts per scene.Source: A. Implementation and evaluation… · p. 18
  • On RoboMME, each ledger entry is appended after its 16-action chunk executes; adjacent duplicates are removed, and the ledger resets each episode without truncation.On RMBench, the next subtask is decoded greedily for each 32-action plan; deferred generation continues from the action path’s key-value cache and can make the next call wait if unfinished.Source: A. Implementation and evaluation… · p. 18

B. Ablations and full result tables

The appendix lists the RoboMME weight sweep, detailed LIBERO results, and ledger-correctness counts. The reported ledger comparison is close across policies on every listed task.

B. Ablations and full result tables

  • The RoboMME weight-sweep table reports success for three policies across three cross-entropy weights, for both counting-suite and 16-task policies.The table gives means and standard deviations over three evaluation seeds; the counting suite covers 200 cases and the 16-task policies cover 800.Source: Table 11 · p. 19
  • The LIBERO tables report success by perturbation axis and across the full 10,030-case LIBERO-Plus suite, alongside results for four standard suites.The tables report means and standard deviations over three evaluation seeds.Source: Table 12 · p. 19, Table 13 · p. 19
  • TacitVLA and Explicit Reasoning are within two points of each other on every ledger-correctness task reported.Every TacitVLA Press Button failure reaches the step budget with the physical press count off target while its ledger remains correct.Source: B. Ablations and full result tables · p. 19, Table 14 · p. 20

C. Latency accounting

Latency is divided into an action path and reasoning generation, with TacitVLA placing memory-task generation inside the execution window. In the reported calls, deferred generation fits within that window.

C. Latency accounting

  • Action-path time includes visual encoding, prompt prefill, and denoising; Explicit Reasoning adds autoregressive generation and a 5–8 ms backbone pass over generated tokens before denoising.On memory tasks, TacitVLA shares one prefill between action and deferred generation, making its action path a few milliseconds above No Reasoning’s.Source: C. Latency accounting · p. 20
  • LIBERO executes five actions per call at 20 Hz for a 250 ms window, RoboMME executes 16 at 20 Hz for 800 ms, and driving replans every 100 ms.Source: C. Latency accounting · p. 20
  • No deferred generation exceeded its execution window in any call, so TacitVLA’s latency was its action-path time in every reported cell.The longest RoboMME entry took 180 ms and the longest RMBench entry 225 ms.Source: C. Latency accounting · p. 20, Table 15 · p. 20
  • On non-memory tasks, TacitVLA and No Reasoning have latencies agreeing to the millisecond; on memory tasks, the two reasoning policies have similar generation costs but place generation at different points.The 16-task RoboMME policy’s other 12 tasks use no ledger and have coincident policy latencies of 143–144 ms.Source: C. Latency accounting · p. 20

D. Qualitative results

The qualitative figures pair successful and failed episodes from TacitVLA and Explicit Reasoning, showing generated text alongside the corresponding calls. The failures shown have similar execution errors under both policies.

D. Qualitative results

  • Figures show TacitVLA and Explicit Reasoning on successful and failed episodes from the same initial states, with call-indexed frames and the text generated at each call.On memory tasks, the text is a ledger entry generated during action execution; for LIBERO and driving, TacitVLA's text was generated after each action for the appendix, leaving actions unchanged.Source: D. Qualitative results · p. 21
  • Shown failures are not clearly specific to TacitVLA: Explicit Reasoning fails the same episodes with the same kinds of execution errors.Examples include cubes left outside the bin, an unregistered confirm press, a grasp without placement, and departure from the lane corridor.Source: D. Qualitative results · p. 21
  • The examples span cube counting, button presses, object placement, and driving instructions involving reasoning and a future trajectory.The task instructions include placing specified colored cubes before pressing a stop button, matching table numbers with button presses, and object-placement tasks.Source: D. Qualitative results · pp. 22–26

Related papers

Loading 2610.17540v1…