Latest / Embodied AI 101 / Think Late, Act Now: TIC-VLA Turns Reasoning Latency into a Control Variable

Transcript

Think Late, Act Now: TIC-VLA Turns Reasoning Latency into a Control Variable · Embodied AI 101

• Think Late, Act Now: TIC-VLA Turns Reasoning Latency into a Control Variable. TIC-VLA: A Think-in-Control Vision-Language-Action Model for Robot Navigation in Dynamic Environments • Zhiyu Huang, Yun Zhang, Johnson Liu, Rui Song, Chen Tang, and Jiaqi Ma • University of California, Los Angeles • 43rd International Conference on Machine Learning, ICML 2026 • 2026. The hidden synchronization bug in VLA navigation. Consider a robot moving down a crowded hallway under the instruction, “Continue to the end, then turn left by the vending machine.” Its vision-language model starts reasoning when the vending machine is still several meters ahead. The model identifies the landmark, interprets the instruction, predicts the turn, and returns a useful semantic representation. But this takes three seconds. By the time the result arrives, the robot has moved forward, a pedestrian has crossed its path, and the vending machine is now beside the robot rather than ahead of it. Nothing in the semantic answer is necessarily wrong. The problem is that the answer is about an earlier world. That is the synchronization bug TIC-VLA is built around. In the paper’s real-robot experiments, the vision-language component takes roughly 3.4 seconds on an RTX 4060 laptop GPU and 4.8 seconds on a Jetson Orin NX, while the action policy runs in about 86 and 120 milliseconds, respectively. A conventional system either stops the robot while waiting, repeats an old action, or applies the newly returned reasoning as though it had been generated from the current observation. All three options are problematic in a dynamic scene. TIC-VLA’s central claim is that reasoning latency is not merely an implementation inefficiency to be optimized away. It changes the observation available to the controller and therefore belongs inside the learning problem. A semantic feature computed from an old image is not equivalent to a slightly noisy feature from the present. It is an observation with a known age, generated from a different robot pose and potentially a different configuration of the surrounding world. The paper’s response is “Think-in-Control”: let the expensive semantic model reason asynchronously while a fast policy continues controlling the robot. Crucially, however, the controller is told how stale the reasoning is and how the robot has moved since that reasoning began. The result resembles a learned delay-compensating controller. Instead of pretending that the slow and fast subsystems share one clock, TIC-VLA exposes their temporal disagreement and trains the policy around it. The architecture: old semantics, current pixels, explicit time. At a high level, TIC-VLA is a dual-system model. The slow system is an InternVL3-1B vision-language model responsible for instruction grounding, scene interpretation, object identification, motion reasoning, and waypoint prediction. The fast system is a six-layer, cross-attention Transformer that turns current visual information, robot state, and cached semantic information into a short trajectory. Both systems share the InternVL vision encoder, helping their visual representations remain compatible even though they process observations from different times. The VLM itself contains an InternViT-300M visual encoder and a Qwen2.5-0.5B language model. For each reasoning update, it can consume four images spanning a nine-second history, sampled three seconds apart. This gives it enough temporal context to infer whether a pedestrian is approaching, whether the robot has already completed part of an instruction, and which landmark should define the next local plan. TIC-VLA defines the effective age of a semantic update as more than the model’s raw inference time. It includes both the time required to perform inference and the time that has elapsed since the last reasoning result finished. If the VLM takes three seconds to produce an update and that update remains cached for another second, the controller is using four-second-old semantics. This is important because a slow system does not simply produce delayed outputs; it produces irregularly updated outputs whose age continues increasing between completions. The interface between the two systems contains four main ingredients:. the current RGB observation;. the robot’s current linear and angular velocity;. the most recently completed VLM hidden state;. the age of that hidden state and the robot’s accumulated translation and rotation since it was generated. The semantic state is taken from the VLM’s final-layer key-value cache rather than reduced to only a textual command or a waypoint. The intuition is that the cache preserves a richer representation of the instruction, relevant objects, temporal context, and intended route. The controller can then cross-attend to that representation while reconciling it with the current camera image. The distinction between age and ego-motion is worth emphasizing. A scalar saying “this reasoning is three seconds old” does not tell the policy whether the robot stood still, traveled three meters forward, or rotated 90 degrees during those three seconds. TIC-VLA therefore supplies both elapsed time and the relative pose change—translation in the robot plane plus heading change. The controller is not asked to infer temporal displacement solely by comparing images. The action expert projects the current visual tokens, delayed VLM cache, robot state, and timing metadata into a shared 512-dimensional space. Thirty learnable temporal queries attend to this context and predict 30 relative motion increments spanning three seconds. Those increments are accumulated into a local trajectory, from which a near-term target is selected for closed-loop execution. Because the complete trajectory is produced in one forward pass, the action side avoids the iterative sampling cost of diffusion or flow-matching policies. Execution is receding-horizon and genuinely asynchronous after initialization. The action expert continues running while a background VLM job processes an earlier image sequence. When that job completes, the semantic cache, its timestamp, and its associated robot pose are atomically replaced. One subtle qualification is that the deployment algorithm initially holds the robot still until the first semantic cache becomes available. Once initialized, however, control no longer blocks on subsequent VLM calls. Training the mismatch instead of wishing it away. Architectural decoupling alone does not solve the problem. If the fast policy is trained only with perfectly aligned semantic features, it can learn to treat those features as a description of the present. At deployment, delayed semantics then become an out-of-distribution input. TIC-VLA addresses this with a three-stage pipeline: supervised VLM fine-tuning, imitation learning with randomized delays, and closed-loop reinforcement learning under asynchronous inference. The training data combines SCAND, GND, and the authors’ DynaNav demonstrations. SCAND contributes 8.7 hours of socially situated robot trajectories, GND contributes more than 11 hours of campus navigation, and DynaNav contributes 5.1 hours from the new simulation environments. The raw sequences are converted into overlapping 20-second episodes and downsampled to 10 hertz. The released dataset includes RGB sequences, trajectories, language instructions, synchronized actions, and reasoning annotations. For VLM supervision, the authors use GPT-5 to generate long-horizon instructions and concise reasoning traces. Instruction generation receives representative future frames and trajectory offsets, allowing the annotator to describe the complete demonstrated route. Four paraphrased versions of each route instruction are generated to increase linguistic diversity. The reasoning annotation additionally uses past observations, past motion, the current view, and future observations, and is structured around the situation, important objects, object motion, progress through the instruction, and the next local plan. The vision encoder remains frozen during VLM fine-tuning. The language component is trained to emit either a reasoning trace followed by waypoint predictions or a more efficient waypoint-only answer. Mixing both formats means the same model can be prompted for explicit test-time reasoning when semantic difficulty warrants the additional latency. In the second stage, the VLM is frozen and the action expert learns from demonstrations. For each training sample, the pipeline draws an artificial reasoning delay uniformly between zero and ten seconds. The action model sees the current image and state but receives VLM features from the sampled earlier time, together with the elapsed time and relative pose offset. It predicts a three-second trajectory, integrates the incremental actions, and minimizes a smooth trajectory regression loss against the expert path. This is effectively temporal domain randomization. Rather than adding generic noise to the semantic representation, the authors create structurally valid but stale representations and tell the policy exactly how stale they are. The controller must learn when delayed intent is still useful, when current vision should dominate, and how an old semantic target transforms as the robot moves. Imitation learning still cannot reproduce the state distribution generated by the complete asynchronous system. Small control errors change future images; dynamic pedestrians react or pass by; VLM completions occur at irregular points in the trajectory. The third stage therefore performs PPO fine-tuning in Isaac Lab while keeping the VLM and vision encoder frozen. During rollouts, the policy consumes actual cached VLM states and latency metadata, and random release delays average approximately five seconds. Only the final cross-attention layer and action decoder are fine-tuned, limiting the scope of the RL update. The reward combines goal completion, progress, collision penalties, and a speed term that discourages both crawling and excessive velocity. The critic receives current visual features, robot state, and the relative goal position, while the actor continues operating from language, current observations, and delayed semantics. This is an asymmetric training arrangement: privileged goal information helps value estimation but is not passed into the deployed action policy. DynaNav: a benchmark built to make delay matter. Classic VLN benchmarks are often poor tests of this particular problem. Discrete viewpoint transitions can hide control latency, and static environments do not punish a system for applying an old semantic interpretation. DynaNav instead runs in Isaac Sim with physics-based motion, animated pedestrians, continuous control, and indoor and outdoor scenes. It supports the Nova Carter wheeled platform and Boston Dynamics Spot, as well as teleoperation, end-to-end model control, and parallel RL training. The evaluation set contains 85 language-conditioned episodes across hospitals, offices, warehouses, and an outdoor urban environment. Difficulty varies through route length, instruction complexity, robot platform, time limit, and crowds ranging from zero to 200 simulated people. The hospital emphasizes long corridors and occlusion; the office emphasizes branching layouts and multi-step landmark instructions; the warehouse is compact and visually ambiguous; and the outdoor scene adds long distances, uneven terrain, and distant landmarks. The authors separately collected 310 teleoperated demonstrations, totaling 5.1 hours, by having an expert complete routes and then record corresponding language instructions. DynaNav is therefore simultaneously an evaluation environment, a demonstration source, and the closed-loop environment for RL. That integration is useful for reproduction, although it also means the strongest model is trained and evaluated within one simulator family. What the experiments actually establish. The main simulation result. In the primary DynaNav evaluation, the action policy runs at 10 hertz while the VLM updates at 0.5 hertz. Full TIC-VLA reaches a 55.29% success rate, 50.29 SPL, and 28.24% collision rate. The version without RL reaches 47.06% success and a 34.12% collision rate. The synchronous variant, which blocks control around VLM reasoning, falls to 32.94% success and 41.18% collisions. That synchronous comparison is one of the paper’s strongest results. The underlying semantic and action machinery is not sufficient if the execution schedule is wrong. Moving from synchronous TIC-VLA to the full asynchronous, latency-trained model improves success by more than 22 percentage points. The strongest point-goal baseline, NavDP, obtains 54.12% success and slightly better navigation error and SPL than TIC-VLA. But NavDP is given the relative goal directly, whereas TIC-VLA receives only egocentric RGB and natural-language instructions. The fairer language-conditioned comparison is against MobileVLA, OmniVLA, DualVLN, NaVILA, and Uni-NaVid, whose success rates range from roughly 22% to 33% under the authors’ evaluation. All language-guided baselines were fine-tuned on the same datasets. The interface matters more than it first appears. The most revealing ablation compares waypoint guidance with VLM KV-cache features. A waypoint interface without latency awareness achieves only 16.47% success; adding latency training raises it to 22.35%. KV-cache features without latency awareness reach 30.59%. Combining the rich cache with explicit latency and motion conditioning reaches 47.06% before RL. This suggests that the contribution is not merely “attach a timestamp to a waypoint.” Sparse waypoints discard information the controller may need when the current view no longer matches the old plan. The VLM cache can represent why a direction was selected, which object defined the turn, how the instruction has progressed, and which alternatives were rejected. The action expert can recover those distinctions through attention without forcing the slow model to express everything through a tiny geometric bottleneck. The ego-motion metadata also earns its place. Removing the pose offset lowers success from 47.06% to 41.18%, worsens SPL, and increases collisions. Time alone provides a prior over likely staleness; pose change provides a direct geometric description of how the robot’s frame has shifted. Reasoning is useful even when it is slow. Disabling explicit reasoning allows the VLM to run at 4 hertz rather than 0.5 hertz, but success falls from 55.29% to 40%, and SPL falls from 50.29 to 34.22. The no-reasoning system records fewer collisions, but the authors attribute this to greater inactivity and more frequent failure to make progress. In other words, a fast but semantically weak robot can look superficially safe because it does less. This result supports the paper’s broader systems argument. The right comparison is not always a large, slow model versus a small, fast model. A third option is to retain slow reasoning while engineering the control pathway so that the robot remains reactive during and after that reasoning. The backbone ablation reinforces the point. A 500-million-parameter SmolVLM2 variant is quicker but reaches only 38.82% success. A three-billion-parameter Qwen2.5-VL variant has greater representational capacity but falls to 32.94%, with the authors attributing the degradation to its longer delay. InternVL3-1B provides the best balance at 47.06% before RL. In this setting, scaling the reasoner without redesigning the surrounding control loop can make the full robot worse. The action-side architecture shows a similar preference for system-level efficiency. Diffusion and flow-matching controllers achieve 38.82% and 32.94% success, respectively, compared with 47.06% for the single-pass query Transformer. The simpler decoder is both faster and easier to fine-tune with on-policy RL. A three-second prediction horizon also works better than one- or five-second alternatives: one second is more reactive but less effective at route completion, while five seconds sacrifices near-term accuracy. Finally, the latency stress test shows that RL makes the success curve substantially flatter as reasoning delays increase. Collision rate changes less than task success, suggesting that current visual input continues supporting local reactivity even when semantic progress becomes unreliable. Under simulated odometry drift, typical noise has almost no effect, while severe accumulated drift lowers success from 55.29% to 43.53%. The real-robot result. The real-world evaluation uses a Unitree Go2 on four tasks: a pedestrian-filled indoor hallway, a cluttered office, an outdoor plaza, and an uneven outdoor walkway. Each task is attempted five times, with no task-specific real-world fine-tuning. Manual intervention to prevent a collision counts as failure. On the RTX 4060 setup, TIC-VLA reaches 85% average success, compared with 70% before RL, 50% for DualVLN, and 35% for NaVILA. It reaches 75% on the Jetson Orin NX despite a VLM update taking nearly five seconds. The remote A6000 produces faster model inference but only 80% success, which the authors associate with communication overhead and its effect on closed-loop timing. These results are encouraging, particularly because the action loop remains functional under multi-second reasoning delay. But the sample is small—20 trials per method across four designed tasks—and the hardware differs across some baselines because the larger models do not fit on the edge devices. The experiment demonstrates feasibility, not a definitive estimate of deployment reliability. Where TIC-VLA sits among slow-fast robot architectures. TIC-VLA is part of a broader move away from asking one large model to perform semantics and control at the same frequency. NaVILA, for example, turns language and vision into mid-level linguistic motions such as moving forward a specified distance, then delegates execution and obstacle avoidance to a real-time locomotion policy. That hierarchy makes difficult embodiments tractable, but it does not explicitly represent the age of the high-level command. StreamVLN tackles another side of the temporal problem. Its fast dialogue context preserves recent interactions while a slow memory stream compresses longer visual history through token pruning and KV-cache reuse. Its primary concern is bounded context and efficient streaming inference rather than compensating a control policy for a semantic state generated from an earlier robot pose. DualVLN is architecturally closer. Its slow system grounds mid-term pixel goals and latent intent, while a lightweight diffusion Transformer generates local trajectories. It demonstrates asynchronous remote inference and dynamic obstacle avoidance across wheeled, quadruped, and humanoid platforms. TIC-VLA’s distinction is that it makes semantic age and ego-motion explicit and incorporates randomized staleness into both imitation learning and RL, rather than treating the slow planner’s latest output as temporally current. The same temporal misalignment problem has also appeared outside navigation. VLASH, posted in November 2025, predicts the robot state expected at action execution time by rolling the current state forward under the previous action chunk. That is an alternative control abstraction: VLASH moves the reasoner’s input toward the future execution state, while TIC-VLA gives the executor an old semantic state and teaches it how to compensate. AsyncVLA appeared on February 13, 2026, eleven days after TIC-VLA’s initial February 2 submission. It runs an OmniVLA foundation model remotely and a 76-million-parameter Edge Adapter onboard. The adapter fuses current low-resolution vision, a comparison between current and delayed images, and delayed action-token embeddings; its training also upweights rare reactive trajectories. It was tested with communication delays ranging up to six seconds. The design is conceptually close but uses visual differencing and an edge adapter rather than TIC-VLA’s explicit time-and-pose-conditioned semantic interface. A later approach, AsyncShield, adds deterministic pose transformations and a constrained-RL edge policy with LiDAR-based safety constraints. That reflects a complementary design philosophy: retain the remote model as a black box, transform its stale geometric intent into the current frame, and let a local safety-aware adapter override it when necessary. TIC-VLA’s novelty is therefore not simply that one module is slow and another is fast. Its distinctive bundle is the use of a rich latent semantic cache, explicit age and ego-motion metadata, delay-randomized imitation learning, genuinely asynchronous RL, and a benchmark in which language grounding, physical control, and moving humans all matter simultaneously. What the paper proves—and what remains open. The strongest contribution is the problem formulation. Embodied models routinely carry hidden timing assumptions: camera timestamps are discarded, cached features are treated as current, and training datasets contain perfectly aligned modalities that deployment cannot reproduce. TIC-VLA shows that exposing one of those hidden variables can produce a large gain without requiring the semantic model itself to become dramatically faster. The empirical evidence also supports several concrete design choices. Rich latent features outperform sparse waypoint interfaces; pose change is more useful than delay alone; on-policy training matters once the slow and fast systems interact; and the best foundation model is not necessarily the largest one. These findings are likely to transfer beyond the exact architecture. The results should not, however, be read as demonstrating safe social navigation. Even the best simulation model records at least one collision in 28.24% of episodes. The described system contains a collision penalty but no formal safety certificate or hard runtime shield. For use around people, TIC-VLA would still benefit from a verified braking layer, control barrier function, reachability filter, or conventional local safety controller. There is also an important limit to ego-motion compensation. The pose offset describes how the robot moved, not how the rest of the world changed. A delayed feature saying that a pedestrian is on the left may remain semantically wrong after coordinate transformation because the pedestrian has crossed to the right. Current RGB lets the action expert react to visible changes, but the system has no explicit object-level temporal correspondence or uncertainty estimate indicating which pieces of the cached semantic state have expired. Timing and pose metadata are assumed to be measurable. The odometry ablation is reassuring under moderate noise, but real deployments can also contain timestamp skew, dropped frames, packet reordering, variable camera buffering, and discontinuities in state estimation. A mature version of this interface would likely carry uncertainty over both semantic age and frame transformation, rather than a single deterministic offset. The supervision pipeline deserves careful interpretation. GPT-5 generates instructions and reasoning from future observations and demonstrated trajectories. That is legitimate privileged supervision, but it makes annotation quality and reproducibility dependent on a proprietary teacher. More subtly, the imitation-learning algorithm feeds stored reasoning traces through the frozen VLM when extracting hidden states. This appears to give the action policy relatively clean, teacher-conditioned semantic states during IL; the subsequent asynchronous RL stage is therefore doing important work to close the gap to free-running VLM outputs. DynaNav is a useful benchmark, but 85 fixed test episodes cannot cover the long tail of human navigation. Isaac Sim pedestrians provide controlled physical interaction, yet they do not reproduce the full ambiguity of human intent, group behavior, social negotiation, or adversarial movement. Likewise, the real-world results are limited to four routes and five repetitions per route. The paper’s own limitations section acknowledges the need for broader real testing, further runtime optimization, and extension beyond navigation. What to steal for your own embodied-AI stack. The most transferable lesson is to treat every slow model output as a time-stamped measurement. Record when its sensor inputs were captured, the pose from which they were captured, when inference began, and how long the result has remained cached. Passing an untagged semantic feature into a controller is equivalent to dropping the timestamp from a physical sensor. Second, preserve both a high-bandwidth latent interface and an interpretable low-bandwidth interface. TIC-VLA shows that the latent cache carries information omitted by a waypoint, but explicit waypoints and text remain valuable for inspection, supervision, and fallback logic. A production system should not have to choose between rich learned state and debuggable intent. Third, train against the deployment scheduler. Sample from measured latency distributions rather than a convenient fixed delay, and include long-tail stalls, jitter, and missing updates. After offline training, run the exact asynchronous pipeline in closed loop. The paper’s improvement from imitation learning to PPO is evidence that random delay augmentation alone does not reproduce the state distribution induced by asynchronous execution. For manipulation, the same abstraction would need more than base ego-motion. A delayed semantic state should be accompanied by camera-to-base and base-to-end-effector transforms, object tracks, gripper state, contact events, and perhaps a belief about which objects may have moved independently. For autonomous driving, one would similarly want ego-motion plus tracked-agent state, traffic-light age, and uncertainty over occluded participants. The authors have released model and training code, DynaNav assets, supervised training entry points, Isaac Lab PPO scripts, a pretrained checkpoint, and the reasoning-annotated dataset. The repository targets Isaac Sim 5.0 and exposes separate configurations for VLM training, action training, benchmark execution, and RL fine-tuning. The dataset is approximately 538 GB and includes SCAND, GND, and DynaNav material organized into 20-second episodes. Closing take. TIC-VLA’s most important idea is almost embarrassingly simple: a robot should know when its thought came from. That turns a vague systems complaint—“the VLM is too slow”—into a learnable control interface. The robot receives old semantics, current perception, elapsed time, and relative motion, and it learns how much to trust each one. The experiments do not establish production-grade safety, but they make a convincing case that asynchronous reasoning should be modeled, not hidden. For embodied AI, that is the broader message. Intelligence is not only a function of what a model knows. It also depends on whether the model’s knowledge arrives in time, whether the controller knows how old it is, and whether the entire training pipeline respects the clocks of the physical system.