TL;DR
This paper exposes a novel security vulnerability in reasoning-augmented Vision-Language-Action (VLA) robotic models by intercepting and corrupting their internal Chain-of-Thought (CoT) text plans. The authors reveal a striking "selective causal sensitivity": while the robot's action decoder completely ignores sentence scrambling and spatial reversals, swapping object names (entities) severely degrades physical performance while leaving external inputs completely clean and invisible to traditional defenses.
What Problem Does This Paper Address?
Modern robotic manipulation increasingly relies on Vision-Language-Action (VLA) models to translate sensory inputs directly into motor commands. A powerful recent trend is augmenting these models with explicit Chain-of-Thought (CoT) reasoning. Before executing an action, the model generates an internal natural-language plan (e.g., "I need to pick up the wine bottle and place it on the rack"), which an action decoder then uses to output control signals.
While CoT vulnerabilities (like prompt hijacking or trace poisoning) are well-documented in text-only LLMs, their security implications for embodied AI have been entirely overlooked. This paper investigates a critical safety question: Can an adversary degrade a robot's physical performance solely by corrupting its internal reasoning trace, even when all external inputs (camera feeds and user instructions) remain perfectly clean? Beyond security, this work probes the fundamental mechanics of VLA architectures to understand which properties of an internal text plan the action decoder actually relies on.
Methods
The authors formalize a text-channel interception attack targeting modular VLA pipelines. The attacker is assumed to have access to the message bus or inter-process communication layer connecting the reasoning module (System 2) to the action decoder (System 1), allowing them to read and replace the CoT text at runtime without needing access to model weights, gradients, or training data.
To systematically diagnose what the action decoder attends to, the authors develop a taxonomy of seven text corruptions across three attacker capability tiers:
- Tier 1: Noise (Blind)
- Random Tokens: Replacing 50% of the CoT tokens uniformly at random to destroy local coherence.
- Padding: Replacing the entire CoT with length-matched repeated filler tokens to test if the model merely benefits from the presence of text context.
- Tier 2: Mechanical-Semantic (Linguistic Knowledge)
- Shuffled: Randomly permuting the order of sentences while keeping all words intact.
- Entity Swap: Systematically replacing every object mention with a different object from the environment pool (e.g., "wine bottle" $\rightarrow$ "caddy").
- Negation Flip: Replacing all spatial direction terms with their direct antonyms (e.g., left $\leftrightarrow$ right, open $\leftrightarrow$ close).
- Tier 3: LLM-Adaptive (Auxiliary LLM Access)
- LLM-Adversarial: Using a frozen
Llama-3.1-70B-Instructmodel to rewrite the clean CoT into a highly plausible-but-wrong plan, altering strategies and target objects while maintaining grammatical correctness.
The primary target model evaluated is DeepThinkVLA (a state-of-the-art reasoning VLA). As a control, the authors also apply these text injections to OpenVLA-OFT (a non-reasoning VLA) to verify whether the vulnerabilities are truly architecture-specific.
Datasets
The approach is evaluated on LIBERO, a rigorous, standardized benchmark for lifelong robotic trick-and-tabletop manipulation. Experiments span all four of its specialized task suites (40 tasks total, evaluated over 2,400 episodes per condition):
- LIBERO-Object: 10 distinct tasks focused on basic pick-and-place operations.
- LIBERO-Spatial: 10 tasks emphasizing spatial reasoning and relative positioning.
- LIBERO-Goal: 10 tasks featuring diverse, complex goal specifications.
- LIBERO-Long: 10 multi-step, long-horizon manipulation tasks.
Key Insights and Ideas
- Selective Causal Sensitivity: The action decoder treats the internal CoT plan primarily as an entity-grounding map rather than a logical or sequential guide. Scrambling sentence order (
Shuffled) or reversing directions (Negation Flip) resulted in virtually zero performance loss because the decoder successfully overrides textual spatial terms using its clean visual inputs. However, when object names are altered (Entity Swap), the grounding breaks completely. - Capability Inversion: Counterintuitively, a sophisticated attacker using a 70B LLM to craft a deceptive, plausible plan causes significantly less damage (-0.5 pp) than a simple mechanical string-swap of object names (-8.3 pp). This happens because the LLM's effort to maintain environmental plausibility inadvertently preserves the exact entity-grounding structure the decoder needs to succeed.
- A Stealthy Threat Vector: Because CoT attacks occur entirely within the internal model pipeline, they leave no trace on external inputs. Traditional input-sanitization firewalls (which scan user instructions or camera frames) are completely blind to this vector.
- Reasoning Amplifies Input Fragility: In a cross-surface comparison, the authors discovered that reasoning VLAs are actually more vulnerable to corrupted user instructions than non-reasoning models. The reasoning module acts as an error amplifier: a corrupted instruction leads to a corrupted internal CoT, which the action decoder then faithfully executes, creating a two-stage cascade of physical failure.
Key Results
- The Destructive Power of Entity Swaps:
Entity Swapwas the only internal corruption that caused severe performance drops, slashing the overall success rate by 8.3 percentage points (pp) on average, and plunging by 19.3 pp on the complexLIBERO-Goalsuite. - On individual challenging tasks, such as "put wine bottle on rack", the success rate collapsed by a massive 45 pp.
- Indifference to Other Corruptions: All other internal trace corruptions—including sentence shuffling (+0.1 pp), spatial negation (+0.0 pp), and adaptive LLM rewrites (-0.5 pp)—had negligible impacts on the robot's final success rate.
- A Lightweight Defense: Because the vulnerability is tightly bottlenecked on entity names, the authors demonstrated that a simple, zero-cost string-matching runtime check (cross-referencing CoT entity mentions against the user instruction) successfully flags 100% of
Entity Swapattacks with a false-positive rate of just 3.3%.
Limitations and Future Work
- Single-Model Scope: The study focuses heavily on a single reasoning VLA architecture (
DeepThinkVLA) and a simulated tabletop environment (LIBERO). Evaluating generalizability across other emerging text-based reasoning pipelines, such asFast ECoTor dual-system frameworks likeFast-in-Slow, remains an open requirement. - Simulated Interception: The threat model assumes successful middleware interception. Future work must validate these vulnerabilities against real-world robotic operating frameworks (like ROS2) under actual network-level man-in-the-middle conditions.
- Advanced Defenses: While simple string-matching works for basic entity swaps, more sophisticated attacks will require advanced defense mechanisms, such as dual-generation consensus checks, cryptographic signing of internal reasoning traces, or RL-based trace recovery.
Summary updated