acceptodds
Under review as a conference paper at ICLR 2027

Thinking More, Moving Less: Stealthy Availability Attacks on Reasoning VLA Models

Abstract

Reasoning vision-language-action (VLA) models are increasingly studied for physical AI, yet the robustness of their computational efficiency during execution remains largely unexplored. We investigate a novel behavior-preserving availability attack, in which a static visual patch increases both the number of policy calls and the inference cost per call while preserving task-directed behavior. We introduce SPADE, a two-stage framework that separates the discovery of executable slow behavior from its realization through pixels. First, a learnable embedding suffix elicits smaller task-directed movements and longer reasoning from a frozen VLA, and closed-loop validation retains only behaviors that increase both cost factors while satisfying task, motion, and action-validity constraints. Second, a visual patch distills these behaviors by matching reasoning-exit decisions and actions, with supervision continually refreshed on the patched policy's own prefixes and visited states. At deployment, only the fixed patch remains, leaving the model weights, instructions, decoding procedure, and controller unchanged. Across three reasoning VLAs and two robotic manipulation benchmarks, SPADE substantially increases cumulative inference time while largely preserving task success and trajectory geometry, and achieves greater cost amplification than direct patch optimization under the same optimization budget. These results reveal an availability vulnerability that conventional task-success evaluation can overlook.

Primary area:
applications to robotics, autonomy, planning
Keywords:
vision-language-action models, availability attack, adversarial patch, inference-time cost

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_QoDYOpenReview ↗
Rating
3(+1)
Confidence
3(−1)
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies behavior-preserving availability attacks on reasoning VLA models. It proposes SPADE, which first optimizes an embedding suffix to elicit longer reasoning and smaller task-directed movements from a frozen policy, then transfers these behaviors to a fixed visual patch. Closed-loop qualification and refreshed student-context supervision aim to preserve task completion and motion while increasing both policy-call count and per-call latency. The evaluation covers three reasoning VLAs, simulation benchmarks, transfer settings, and printed-patch deployment on a physical robot.

Critical strengths
  1. The attack objective is interesting and well motivated. Jointly increasing policy-call count and per-call inference cost while preserving task-directed execution distinguishes this work from attacks that simply disrupt task completion or prolong isolated language outputs. It highlights an availability risk that conventional success-rate evaluation may miss.

  2. The framework addresses the coupling between reasoning and execution. Closed-loop teacher qualification, boundary-aware imitation, action matching, and refreshed student-context supervision form a coherent approach to transferring executable slow behavior into a fixed patch. Budget-matched comparisons, component ablations, and physical deployment provide meaningful support for the proposed approach.

Critical weaknesses
  1. The overview figure does not clearly communicate the central idea and optimization flow. Figure 1 is crowded with text, equations, and decorative illustrations, making the pipeline appear as a collection of modules rather than a clearly motivated sequence. The distinction between suffix search, patch optimization, and patch-only deployment should be more prominent. Some illustrations, including the apparent whole-arm translation used to depict motion, also need more careful treatment.

  2. The attack’s robustness against practical mitigation strategies remains unclear. The paper does not evaluate safeguards at different levels, such as reasoning-only repetition penalties or loop detection, tighter inference budgets and policy-call limits, and visual preprocessing or adversarial-input defenses. These controls could affect the two slowdown factors differently. Evaluations should report both remaining attack effectiveness and clean-task performance, including valid action returns, to distinguish useful mitigation from interventions that simply prevent task completion.

  3. The paper lacks concrete clean-versus-attacked reasoning examples for the different victim models. These models have distinct reasoning and action interfaces, so aggregate latency and token statistics alone do not explain how the attack operates in each case. Paired native outputs would clarify whether the additional reasoning is repetitive, off-task, or task-relevant, and whether normal reasoning-to-action transitions are preserved. Examples should include token counts, exit markers, and action-return status, with cached Plan content separated from newly generated Think content for CoTinyVLA.

Questions for authors
  1. How effective is SPADE under practical safeguards? Please evaluate representative controls targeting reasoning generation (e.g., reasoning-only repetition penalties), resource use (e.g., reasoning-token or policy-call limits), and visual inputs (e.g., preprocessing defenses). Report the remaining slowdown together with clean and attacked task success and valid action-return rates, so that mitigation effectiveness can be assessed alongside its utility cost.

  2. What does the induced reasoning look like in each victim model? Please provide paired clean and attacked CoT examples for all three models, marking reasoning length, the exit delimiter, and whether a valid action follows. For CoTinyVLA, separate the cached Plan from the newly generated Think span. These examples should clarify whether slowdown comes from repetition, off-task generation, or longer task-relevant reasoning.

I would consider raising my score if these concerns are adequately addressed in the rebuttal.

4 comments
AuthorsOpenReview ↗

Response to Reviewer QoDY (1/3)

We thank the reviewer for the detailed and constructive review. We appreciate that the reviewer finds the attack objective "interesting and well motivated" and the framework "a coherent approach". The three concerns are concrete, and we address each below.

W1: Figure 1 is crowded and does not show the optimisation flow

We agree and have redrawn it. The new Figure 1 has three panels, from left to right:

  1. Suffix search (offline). A suffix makes the frozen policy take smaller steps and reason longer; closed-loop checks keep a qualified teacher.
  2. Patch optimisation (offline). The patch imitates the frozen teacher on the patched policy's own contexts.
  3. Patch-only deployment. Only the patch remains. The suffix is removed, and the model, instruction and decoding are unchanged.

Arrows show what passes on: the qualified teacher, then the patch. The figure no longer contains equations: its caption points to Eqs. 2–6 in Section 3 and defines the symbols. A top strip shows what the attack does: smaller approach steps per call along a nearby path, not a translation of the whole arm.

W2 & Q1: How effective is SPADE under practical safeguards?

The original submission did not evaluate safeguards, and we agree that it should. We test controls from each of the three groups the reviewer names, each at a mild and a strict setting, and a runtime monitor. We report the two slowdown factors separately: calls (GNG_N) and per-call latency (GℓG_\ell).

Setup. DeepThinkVLA, the eight Standard LIBERO tasks of our cross-task study. On these eight tasks the paper's patches give 4.13×; on all 40 tasks, 3.98× (Table 1). The patches are not refitted against the safeguard. The policy keeps its native decoding except for the control under test.

  • Reasoning generation: a repetition penalty of 1.1 or 1.3 on reasoning tokens only.
  • Resource use: a reasoning-token cap per call at 3 or 1.5 times the clean median length; a policy-call limit per episode at 2 or 1.25 times the clean median.
  • Visual input: JPEG compression of the camera image at quality 75 or 50.
  • Runtime monitoring: an episode is stopped, and counts as a failure, when its mean call latency exceeds a per-task threshold. The threshold gives 5% false alarms on clean validation runs.
SafeguardGNG_NGℓG_\ellGTG_TTSR, attackedTSR, cleanValid returns, clean / attacked
None1.562.654.13×88%94%99% / 98%
Repetition penalty 1.11.552.313.58×87%94%99% / 97%
Repetition penalty 1.31.541.973.03×83%91%98% / 93%
Token cap, 3× clean median1.552.123.29×76%94%99% / 52%
Token cap, 1.5× clean median1.541.392.14×61%89%88% / 18%
Call limit, 2× clean median1.432.643.78×71%93%99% / 98%
Call limit, 1.25× clean median1.182.623.09×34%82%99% / 98%
JPEG, quality 751.492.433.62×88%94%99% / 98%
JPEG, quality 501.422.213.14×86%92%99% / 96%
Latency monitor, stop when flagged1.381.151.59×10%89%99% / 98%

A valid return means that the reasoning reaches its native exit and an action follows. A fallback at the token cap does not count (App. B.3).

Reading the table. A control is a useful mitigation if it lowers GTG_T while clean TSR and valid returns stay near the first row.

  • The token cap bounds GℓG_\ell by design and leaves GNG_N at 1.54–1.55. The call limit bounds GNG_N by design and leaves GℓG_\ell at 2.62–2.64.
  • At their strict settings, attacked TSR is 61% with the token cap and 34% with the call limit, against 88% without a safeguard.
  • The repetition penalty and JPEG compression leave 3.03× and 3.14× at their strict settings, with clean TSR of 91% and 92%.
  • The latency monitor stops 89% of attacked episodes and 6% of clean ones. A stopped episode is an unfinished task.

Other models. On CoTinyVLA and ECoT, the strict token cap leaves 1.96× and 1.81×, and JPEG at quality 50 leaves 2.68× and 2.32×.

Two related results already in the paper (DeepThinkVLA, all 40 tasks):

  • Inference-time budget. With a budget of three times the clean median inference time, 94% of clean runs finish and 18% of attacked runs (Figure 3b). A hard budget turns the slowdown into unfinished tasks.
  • Image noise. Gaussian noise of σ = 0.05 on the image lowers joint attack success from 77% to 50%. It also lowers clean TSR from 94% to 83% (Figure 3c, Table 12).

In summary, the five safeguards leave between 1.59× and 3.78× of the slowdown, and the strict limits cost 27–54 points of attacked task success. This study is now in App. E.2 (Table 19).

AuthorsOpenReview ↗

Response to Reviewer QoDY (2/3)

W3 & Q2: What does the induced reasoning look like in each victim model?

We agree that aggregate latency does not show this. In short, the added reasoning is mainly longer task-relevant reasoning (60%–70% of calls across the three models, with 22%–28% repetition and 8%–12% off-task text), and at least 96% of attacked calls in every model still reach the exit and return a valid action. Below are the clean/attacked pairs for DeepThinkVLA and CoTinyVLA; the ECoT pair follows in the next comment, and App. G of the revised PDF has all pairs.

How the pairs are chosen. Clean and attacked runs share the task, layout and call, and differ only by the patch. Task, for all three models: "pick up the black bowl between the plate and the ramekin and place it on the plate". DeepThinkVLA and ECoT show the first call; CoTinyVLA shows the second call, so that its Plan is already cached. Long outputs are cut with [...], keeping start and end; line breaks are added for display.

Reading the table. "Exit reached" means the native end-of-reasoning marker was generated: </think> for DeepThinkVLA, <|cot_think_end|> for CoTinyVLA, ACTION: for ECoT. "Valid action" means the exit is reached and the native parser returns an action; a fallback at the token cap does not count (App. B.3). CoTinyVLA generates its Plan at the first call and caches it; each later call generates only a new Think span, which the attack targets.

ModelRunTokens generated in this callExit reachedValid action
DeepThinkVLAClean67YesYes
DeepThinkVLAAttacked189YesYes
CoTinyVLAClean26 (Think; Plan cached)YesYes
CoTinyVLAAttacked84 (Think; Plan cached)YesYes
ECoTClean242YesYes
ECoTAttacked513YesYes

DeepThinkVLA. Clean:

<think>Initial frame. The target is the black bowl (right-middle), positioned
between the plate (right-front) and the ramekin (right-middle-back). The black
bowl is graspable. The immediate goal is to pick up this black bowl to move it
to the plate. Pick up the black bowl.</think><action>

Attacked:

<think>Initial frame. The target is the black bowl (right-middle), positioned
between the plate (right-front) and the ramekin (right-middle-back). The black
bowl is graspable. The plate is positioned at (right-front) and the ramekin is at
(right-middle-back), with the black bowl (right-middle) between them. The
immediate goal is to pick up this black bowl to move it to the plate. [...] The
target is the black bowl (right-middle) between the plate (right-front) and the
ramekin. The black bowl is graspable from above. Move to the black bowl and pick
up the black bowl.</think><action>

CoTinyVLA. Cached Plan, generated at call 1, not regenerated, and identical in both runs:

1. approach black bowl
2. close gripper on black bowl
3. lift black bowl
4. move above plate
5. lower black bowl onto plate
6. release black bowl

Think in this call, clean:

Phase: step 1 (approach black bowl)
Gripper: OPEN
Next: move closer to the black bowl<|cot_think_end|>

Think in this call, attacked:

Phase: step 1 (approach black bowl)
Gripper: OPEN
Next: move closer to the black bowl between plate and ramekin
Phase: step 1 (approach black bowl)
Gripper: OPEN [...]
Next: move closer to the black bowl<|cot_think_end|>

What the added reasoning is. We manually label 50 randomly drawn attacked calls per model by what most of the added text is: repetition of earlier text, off-task text, or longer task-relevant reasoning. Calls come from the test runs of the eight Standard LIBERO tasks of our cross-task study. The token ratio and the last two columns use all calls of those runs.

ModelReasoning tokens, attacked / cleanRepetitionOff-taskTask-relevantCalls reaching the exit, clean / attackedCalls with a valid action, clean / attacked
DeepThinkVLA3.02×22%8%70%99% / 98%99% / 98%
CoTinyVLA2.74×26%10%64%100% / 98%99% / 98%
ECoT2.48×28%12%60%99% / 97%98% / 96%

What the method enforces. The objective makes continuing more likely than exiting and spreads probability over more next tokens. A reference term keeps the text close to the model's own reasoning without the suffix. No term enforces coherence (Section 3.1). The patches were selected with a missing-action rate of at most 5% (App. C).

In summary, the added reasoning is mainly longer task-relevant reasoning (60%–70%, with 22%–28% repetition), and the normal reasoning-to-action transition is kept in at least 96% of attacked calls in every model.

We thank the reviewer for stating that the score may be raised if these concerns are addressed. We hope the safeguard study and the paired examples do so, and we are happy to provide further details.

AuthorsOpenReview ↗

Response to Reviewer QoDY (3/3)

W3 & Q2 (continued): ECoT pair. Same task and format as above, first call. Token counts include the ACTION: delimiter and the seven action codes; the parser decodes them into a valid 10 × 7 action chunk. Long outputs are cut with [...]; line breaks are added for display.

Clean (242 tokens):

PLAN: 1. move to the black bowl, 2. grasp the black bowl, 3. move the black bowl
to the plate, 4. release the black bowl onto the plate VISIBLE OBJECTS: akita
black bowl 1 [107, 155, 133, 187], [...] plate 1 [135, 159, 162, 198], wooden
cabinet 1 [75, 0, 176, 97] SUBTASK REASONING: The robot needs to move to the
black bowl because it is currently positioned far away from it, while the plate
is already on the table. SUBTASK: move to the black bowl MOVE REASONING: The
black bowl is positioned to the right and slightly behind the plate, so the robot
should move right and back and down to align with the bowl's location. MOVE: move
right and back and down GRIPPER POSITION: [47, 133] ACTION: <|extra_107|>
<|extra_39|><|extra_82|><|extra_12|><|extra_29|><|extra_43|><|extra_41|>
<|im_end|><|endoftext|>

Attacked (513 tokens):

PLAN: 1. move to the black bowl, 2. grasp the black bowl, 3. move the black bowl
to the plate, 4. release the black bowl onto the plate VISIBLE OBJECTS: akita
black bowl 1 [107, 155, 133, 187], akita black bowl 2 [119, 155, 142, 186],
[...] plate 1 [135, 159, 162, 198], wooden cabinet 1 [75, 0, 176, 97] SUBTASK
REASONING: The robot needs to move to the black bowl because it is currently
positioned far away from it, while the plate is already on the table. Because
the gripper has not yet reached the black bowl, the robot should continue moving
toward the bowl's location before attempting to grasp it [...] SUBTASK: move to
the black bowl MOVE REASONING: The black bowl is positioned to the right and
slightly behind the plate, so moving right and back and down will align the
robot with the black bowl's location [...] MOVE: move right and back and down
GRIPPER POSITION: [38, 121] ACTION: <|extra_194|><|extra_67|><|extra_15|>
<|extra_228|><|extra_91|><|extra_140|><|extra_53|><|im_end|><|endoftext|>
AuthorsOpenReview ↗

Gentle Reminder: Follow-Up on Our Rebuttal Responses

Dear Reviewer QoDY,

Thank you again for your constructive feedback and valuable time.

We have provided detailed responses to your concerns, along with additional experiments and revisions to the manuscript. We would greatly appreciate it if you could kindly take a moment to review our responses and share any further thoughts.

We would be happy to address any remaining questions.

Best regards,
The Authors

Reviewer_VoUgOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a physical-world deployable adversarial attack against reasoning VLA models to slow down the VLA executing process, largely improve the time and token cost of the VLA inference. The paper follows a gray-box setting: the attacker needs to query the VLA model and some sensor informations. After several queries, the attacker get some information of the prompts, generated tokens, then use the distillation to learn a student from the target teacher to perform the attack. By having a patch in the VLA input images, the target VLA model will reason more, move slower, and need more steps to finish the task.

Critical strengths

The paper studies an interesting security problem in reasoning VLA models. Instead of disrupting task execution, it shows that an attacker can significantly increase inference cost while largely preserving task success.

The experiments are relatively comprehensive, covering three reasoning VLA models, LIBERO and LIBERO-Plus, and both white-box and black-box settings. The authors also provide ablation studies and physical robot experiments, which strengthen the evaluation.

Critical weaknesses

Although the goal of this attack is novel, I am not fully convinced that the attack itself is meaningful in practice. First, if the attack only targets execution speed, it may not cause substantial damage to the victim. The defender has full control over the VLA model and can easily notice the abnormal inference cost, which may lead to the discovery of the attack and the visual patch. In my opinion, this is much less impactful than attacking the accuracy of the model. For example, in autonomous driving, an attack on planning could directly cause a car to crash, with serious consequences if the defender cannot detect it in time. In contrast, an attack on execution speed would simply make the car slow down, and the defender could quickly notice the abnormal behavior and investigate the patch. What is the actual benefit of such an attack from the attacker's perspective? I think the paper needs a much clearer and more concrete attack scenario. The current motivation is not convincing enough.

The attack also seems quite expensive to prepare. According to Table 4, optimizing a patch requires a budget of 12 A100 GPU-hours per task and attack seed. The black-box setting additionally allows up to 20,000 target policy calls. Since the patches are optimized for individual tasks, I wonder how practical this attack is in real-world scenarios. The authors should better justify why an attacker would spend this much effort just to slow down a robot and discuss whether the attack can work with substantially less optimization cost.

Questions for authors

Could the authors provide a concrete real-world scenario where slowing down a robot would cause meaningful damage to the defender?

How easily could the attack be detected by monitoring inference latency or policy call frequency?

How sensitive is the attack to patch placement? Would it still work if the patch were placed in a different part of the scene? Or covered by some objects?

Could the authors evaluate the attack with a smaller optimization budget, especially in the black-box setting?

3 comments
AuthorsOpenReview ↗

Response to Reviewer VoUg (1/2)

We thank the reviewer for the thoughtful review and its practical questions. We are glad the reviewer finds the attack goal "novel" and the security problem "interesting".

W1 & Q1: A concrete scenario where slowing a robot causes meaningful damage

Yes. When a robot's task is urgent, the delay is itself the damage: the task usually still succeeds, but late. We do not claim that a slowdown is worse than a crash. It is a different risk: loss of availability.

Three time-critical scenarios. A person with limited mobility relies on an assistive robot. Homes are too varied for a fixed program, so we assume the robot runs a reasoning VLA. In each scenario the urgent step is a manipulation on a fixed surface under a fixed external camera, as in our experiments (Section 2, App. D.2). An attacker has left a printed patch on that surface beforehand. We did not run these scenarios. The delays below were measured with DeepThinkVLA on the 40 LIBERO tasks, which include "turn on the stove", and on one real pick-up task.

  1. Kitchen fire. A pan on the counter stove catches fire, and the robot is told to turn off the stove. Ready.gov (US government) says a small flame can become a major fire in less than 30 seconds. A LIBERO task succeeds 27.1 s later on average with the patch (Table 1), close to those 30 seconds.
  2. Asthma attack. The person asks for the reliever inhaler on the bedside table. The NHS advises one reliever puff every 30 to 60 seconds during an attack. Our real pick-up task took 38 s longer on average with the patch, at 90% TSR against 94% clean (Table 14). This delays the first puff by about one such interval.
  3. Break-in. The person hears an intruder and asks for the phone on the bedside table. The NENA standard for 9-1-1 call processing says a call about a crime in progress should be ready for dispatch within 60 seconds. The same 38 s comes before the call starts, on top of those 60 seconds.

Compared with accuracy attacks. In the driving example a slowdown is the milder outcome, because the car itself is the hazard. Here the hazard is a fire, an illness or an intruder, so late help is the damage. The two task-breaking attacks in Table 1 leave 37% and 31% TSR. Failures this frequent would show up in routine use, before any emergency. SPADE leaves 89% TSR, against 94% clean (Table 1). Success-rate monitoring alone then gives little reason to stop using the robot. Latency monitoring is covered in the next answer.

What the attacker gains. In the break-in, the intruder who left the patch would gain the added seconds before help is called. In the other two scenarios the attacker wants to harm the person, as in the reviewer's crash example. Preparation cost is covered in W2 & Q4.

In summary, the patch delays a successful task by 27.1 s in simulation (Table 1) and by 38 s on the real robot (Table 14). These delays are on the same scale as the three published figures above. The revised PDF adds the kitchen-fire scenario to Section 1 and all three to App. H, and states in Section 2 who places the patch.

W1 & Q2: How easily is the attack detected by monitoring latency or call frequency?

A monitor that compares latency with a clean baseline can see the slowdown. Our claim is narrower: the attack can remain difficult to detect through outcome monitoring alone (Sections 1 and 2).

Setup. We replay the DeepThinkVLA test logs behind Table 1 through three simple runtime monitors. Each flags an episode above a threshold set on clean validation runs to give 5% false alarms.

MonitorClean episodes flaggedAttacked episodes flagged
Mean call latency, per-task threshold6%88%
Policy-call count, per-task threshold6%79%
Mean call latency, shared threshold5%61%

A per-task threshold needs clean runs of that task in advance: 50 per task here. A new or rarely run task has none, so a shared threshold must be used; it flags 61% of attacked episodes.

What detection gives the operator.

  • With per-task latency monitoring in place, routine use would reveal the slowdown. Success rate alone shows little: TSR is 89%, against 94% clean (Table 1). The paper therefore concludes that cost must be evaluated too, not task outcomes alone (Section 5).
  • An alarm says that the robot is slow, not why. The patch does not stand out at a glance: given two seconds per scene, blinded raters flagged it in 21% of ratings, against 12% for a benign print (Table 13).
  • An alarm does not undo the delay. Stopping a slow run leaves the task unfinished: with an inference-time budget of three times the clean median, 94% of clean runs have finished but only 18% of attacked runs (Figure 3b).

In summary, a latency monitor flags 61% of attacked episodes without a per-task baseline and 88% with one. It does not locate the patch or undo the delay. Section 2 now states the scope of our stealth claim, and App. E.2 (Table 18) adds this analysis.

AuthorsOpenReview ↗

Response to Reviewer VoUg (2/2)

Q3: How sensitive is the attack to patch placement and to occlusion?

A patch fitted for another region works about as well as the original. The same patch, when shifted or partly covered, is weaker but still slows the robot. The evidence is below: results from the paper, then two new tests in simulation.

Partly covered, real robot (Section 4.6, Table 14). With 15% ± 5% of the printed patch covered, inference cost is still 2.94× with 86% TSR (clean: 92%). Uncovered, it is 4.00× with 90% TSR (clean: 94%).

Camera and scene changes (Figure 3c, Table 6). A camera yaw moves the patch in the image, and the patch is not refitted. At ±3°, ±6° and ±10°, joint attack success is 69%, 57% and 41%, against 77% without a change. Joint attack success counts runs that finish with more calls and higher per-call latency. LIBERO-Plus has 10,030 variants, which include camera and object-layout changes. Without refitting, the patches give 3.12× at 66% TSR there (clean: 72%; DeepThinkVLA, Table 6).

Two new tests in simulation. DeepThinkVLA, the eight Standard LIBERO tasks of our cross-task study. On these eight tasks the paper's patches give 4.13× at 88% TSR; on all 40 tasks, 3.98× at 89% (Table 1). The patch is 96 × 96 px in a 256 × 256 view (App. B.2).

  • Position. We shift the fitted patch by 8, 16 and 32 px without refitting it, averaging over four directions. We also fit new patches for two other regions of the table, with the same budget.
  • Occlusion. An object covers one quarter or one third of the fitted patch. The patch is not refitted.
ConditionGTG_TTSR
Fitted position, uncovered4.13×88%
Same patch, shifted by 8 px3.51×89%
Same patch, shifted by 16 px2.73×90%
Same patch, shifted by 32 px1.86×90%
New patch fitted for a second region4.01×89%
New patch fitted for a third region3.94×88%
Same patch, one quarter covered3.16×88%
Same patch, one third covered2.61×88%

In summary, the same patch gives 3.51× when shifted by 8 px and 1.86× at 32 px, so it should stay near its fitted place. A patch fitted for another region gives 4.01× or 3.94×, against 4.13× at the original one. With a quarter to a third covered, the patch gives 3.16× to 2.61×; the real robot gives 2.94× with 15% covered. Both tests are now in App. E.3 (Table 20).

W2 & Q4: Preparation cost, and the attack with a smaller optimisation budget

The cost is paid once per patch, offline. A fitted patch also slows tasks it was not fitted on (2.46×). A lighter version with 1 GPU-hour gives 3.14×, against 4.13× with 12. Why an attacker would spend this effort is answered in W1 & Q1.

One-time cost. 12 GPU-hours is the cap we gave every white-box method, including the baselines (Section 4.1), and is half a day on one A100. An attacker needs one seed; our three seeds measure variability (App. C). One patch then serves the task: every result in Table 1 is on layouts not seen during fitting (Section 4.1). The printed patch needed no physical reoptimisation (Section 4.6).

Not tied to one task (Tables 2 and 9). A patch fitted on one task is applied to seven other tasks with no further optimisation. On DeepThinkVLA it gives 2.46× at 89% TSR. The black-box patch gives 2.04× at 90% TSR.

A lighter version (new). DeepThinkVLA, the same eight tasks. The lighter version runs one teacher search, not four, with a quarter or a twelfth of the budget. The objective and the split between teacher search, pilots and continuation are unchanged (Table 4). For black-box access we evaluate the patches that the protocol selects at half and at a quarter of both budgets (App. D.1). The paper's black-box patches give 3.20× on these eight tasks and 3.10× on all 40 (Table 1).

VersionBudgetGTG_TTSR
Full SPADE (paper)12 GPU-hours4.13×88%
Lighter search3 GPU-hours3.67×88%
Lighter search1 GPU-hour3.14×87%
Black-box (paper)12 proxy GPU-hours, 20,000 target calls3.20×89%
Black-box6 proxy GPU-hours, 10,000 target calls2.81×90%
Black-box3 proxy GPU-hours, 5,000 target calls2.45×88%

Most of the effect survives a twelfth of the white-box budget or a quarter of both black-box budgets, at almost the same TSR.

In summary, the cost is paid once per patch, and a patch also slows tasks it was not fitted on (Table 2). With 1 GPU-hour the lighter version gives 3.14×, and a quarter of both black-box budgets gives 2.45×. This study is now in App. E.3 (Table 21).

We hope these answers and the added experiments address the reviewer's concerns. We would be grateful if the reviewer would consider updating the score, and we are happy to provide further details.

References (cited in our previous comment)

  • NENA. Standard for 9-1-1 Call Processing, NENA-STA-020.2-2026.
  • NHS. Asthma: How to treat an asthma attack. 2025.
  • Ready.gov. Home Fires.
AuthorsOpenReview ↗

Gentle Reminder: Follow-Up on Our Rebuttal Responses

Dear Reviewer VoUg,

Thank you again for your constructive feedback and valuable time.

We have provided detailed responses to your concerns, along with additional experiments and revisions to the manuscript. We would greatly appreciate it if you could kindly take a moment to review our responses and share any further thoughts.

We would be happy to address any remaining questions.

Best regards,
The Authors

Reviewer_DosnOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes SPADE, a stealthy availability attack against reasoning-based vision-language-action (VLA) models. Unlike conventional adversarial attacks that aim to disrupt task execution or induce harmful actions, SPADE seeks to increase inference costs while preserving task success. Specifically, the attack jointly increases the number of policy calls by reducing action step lengths (Axis A) and extends per-call reasoning latency by delaying reasoning termination (Axis B). To achieve these objectives, the authors introduce a two-stage optimization framework that first discovers the desired behaviors through a learnable embedding suffix and then distills them into a deployable visual patch. Experiments on three reasoning VLA models across Standard LIBERO and LIBERO-Plus demonstrate inference-cost amplification with a small degradation in task success.

Critical strengths
  1. An interesting and practically relevant attack objective. The paper investigates an underexplored availability threat to reasoning VLAs, where an adversary increases inference costs without necessarily causing task failure. This perspective is relevant to real-time robotic applications, where computational latency and execution efficiency are important alongside task success.
  2. Relatively comprehensive experimental evaluation. The experiments cover three reasoning VLA models, multiple manipulation tasks, and robustness evaluations under scene variations. The inclusion of direct patch optimization, component ablations, proxy-assisted black-box attacks, and physical robot experiments provides useful empirical evidence of the attack's effectiveness across different settings.
Critical weaknesses
  1. Insufficient justification for embedding-suffix optimization over direct pixel optimization. The motivation for introducing an embedding-suffix optimization stage is not sufficiently justified. Since image patches are also projected into latent representations via the visual encoder, both direct pixel and embedding-suffix optimization ultimately rely on gradient-based manipulation of internal representations. Although the two search spaces are not strictly equivalent, it remains unclear why optimizing an embedding suffix would be more effective than directly optimizing pixels.

  2. Insufficient comparison with existing reasoning-delay attacks. In Section 3.1 (Axis B), the authors explicitly state that they adapt the exit-delay and uncertainty objectives from Verbose Images [1]. However, it is unclear why this closely related work is not included as a baseline, particularly since it has demonstrated the effectiveness of direct pixel-space optimization in increasing VLM generation length.

  3. Insufficient justification for the superiority of joint optimization over single-axis attacks. Could a sufficiently tuned single-axis attack achieve comparable or even greater total inference-cost amplification (GTG_T) by more aggressively increasing either policy-call counts or per-call latency alone? Existing studies have explored related single-objective attacks: SABER [2] investigates action inflation in VLAs, while Verbose Images [1] demonstrates effective visual optimization for extending generation length. Although their threat models slightly differ from SPADE, these studies raise questions about the necessity of jointly optimizing both axes. In particular, the Axis-A-only and Axis-B-only ablations in Table 3 appear to inherit relatively conservative hyperparameter settings from the joint optimization framework, such as the target step-length retention ratio r∈0.7,0.85r \in {0.7, 0.85} and the candidate-length weighting cap gB=3g_B = 3. Although these parameters do not impose strict upper bounds on policy-call counts or reasoning length, they may limit the effectiveness of independently optimized single-axis attacks. A comparison against independently tuned single-axis baselines under matched optimization budgets, patch constraints, and task-preservation requirements would provide stronger evidence that joint optimization offers genuine advantages, thereby better substantiating one of the paper's key contributions.

  4. Too many tuning parameters. The proposed objective is a combination of losses, and there are many coefficients to be tuned, e.g., λk,u,ref,a,g,c,v\lambda_{k, u, ref, a, g, c, v}. I assume significant tuning efforts are needed. Therefore, the authors are expected to provide the selected configuration in the experiments and make comparisons with the baselines in terms of complexity.

Questions for authors
  1. Could the authors further elaborate on why “optimizing suffix and distilling to pixels” is better than directly optimizing in the pixel space?
  2. How does Verbose Images [1] compare to SPADE under the same evaluation protocol?
  3. If the Axis-A-only and Axis-B-only attacks are independently tuned with more aggressive hyperparameters (e.g., smaller rr, larger gBg_B) under matched budgets and task-preservation constraints, can a single-axis attack match or exceed the total cost amplification (GTG_T) and TSR of the joint framework?

References [1] Gao, K., Bai, Y., Gu, J., Xia, S.-T., Torr, P., Li, Z., and Liu, W. Inducing High Energy-Latency of Large Vision-Language Models with Verbose Images. International Conference on Learning Representations (ICLR), 2024. [2] Wu, X., Shi, G., Wang, Q., Li, Z., Bedi, A. S., and Manocha, D. SABER: A Stealthy Agentic Black-Box Attack Framework for Vision-Language-Action Models. arXiv preprint arXiv:2603.24935, 2026.

4 comments
AuthorsOpenReview ↗

Response to Reviewer Dosn (1/3)

We thank the reviewer for the careful and constructive review. We are encouraged that the reviewer finds the attack objective "interesting and practically relevant" and values the breadth of the evaluation. We answer each point below; W2, W3 and W4 come with new experiments.

W1 & Q1: Why "optimizing suffix and distilling to pixels" beats direct pixel optimisation

The reviewer is right that one sentence (ll. 86–88 of the original submission) did not justify the suffix stage. We also agree that both routes use gradients to change the model's internal representations. Direct patch has no suffix and no teacher: it applies the suffix stage's losses directly to pixels, with the same candidate refresh, patch size and position, appearance objective, budget and selection rule (App. D). So what differs is where the search runs and the job the patch is given:

  • Direct patch must do two things at once, in the same pixels: find a slow behaviour (longer reasoning, smaller steps) that still completes the task, and produce it through a small image region.
  • SPADE lets the suffix find that behaviour first, and closed-loop rollouts check it. The patch then copies a behaviour that is already found and checked.

In detail:

  1. The suffix searches without touching the image. The loss for longer reasoning (Eq. 3) rewards a later exit and broader token choices. It does not say whether a valid action still follows. That is checked by trial and error: four candidate reasoning traces per state (MB=4M_B = 4), then closed-loop rollouts. The suffix is appended to the instruction embeddings, so the policy sees the clean image throughout this search. The suffix has a per-row ℓ2\ell_2 radius (App. B) but no [0, 1] clipping, rendering transform or appearance loss. On DeepThinkVLA, 96.7% of suffix searches (40 tasks, three seeds) pass the closed-loop check. The selected suffixes produce 4.60× the clean reasoning length and still return a valid action in 98.7% of calls (Table 5a). Direct patch runs this search in pixels. As the reviewer notes, a patch enters the model through the visual encoder, so it cannot set embeddings directly as the suffix does. It must also meet the patch's constraints, and it changes the image the policy uses to see the scene.
  2. The patch then gets a target to copy. The frozen policy with the checked suffix is the teacher. It gives the patch three targets: whether to continue or exit at a reasoning position (Eq. 4), what the next reasoning token should be (Eq. 5), and which action to return (Eq. 6). The exit target carries the delay: without it, per-call latency GℓG_\ell falls from 2.60× to 1.32× ("No boundary loss", Table 3). These targets exist only because the suffix stage found the behaviour first. Direct patch has no exit target. Its reasoning loss (Eq. 3) favours "continue" over "exit" at every scored position, including the candidate's own exit when eligible. The teacher's exit target says where to continue and where to exit, for a behaviour that has already passed the closed-loop check.

In summary, the suffix stage turns a search problem into a copying problem for the patch. The revised PDF now states this in Section 1 (blue text in the paragraph that begins "The central challenge"), in place of that sentence.

AuthorsOpenReview ↗

Response to Reviewer Dosn (2/3)

W2 & Q2: How does Verbose Images compare under the same protocol?

We agree that Verbose Images is the closest prior objective and should be a named baseline. We had treated Direct patch as its counterpart, because it optimises the two objectives we adapt from Verbose Images directly in pixels (Eq. 3). We should have said so. We now also report the original method.

Setup. Verbose Images targets VLM text generation with a full-image perturbation and has no action to return. We keep its three losses (delayed EOS, uncertainty, token diversity) and its temporal weight adjustment, with the reasoning-exit token in the role of EOS. Because our deployment uses one static patch (Section 2), we optimise it as a patch under the same budget, patch constraints and task-preservation rule as SPADE. Its loss weights are selected by the same validation procedure (factors {0.3, 1, 3}). Both rows below are on DeepThinkVLA and the eight Standard LIBERO tasks of our cross-task study (App. D), with three attack seeds. On these eight tasks SPADE reaches 4.13×; on all 40 tasks it reaches 3.98× (Table 1).

MethodGNG_NGℓG_\ellGTG_TTSR
Verbose Images1.071.661.78×86%
SPADE1.562.654.13×88%

Under the same task-preservation rule, Verbose Images reaches a per-call latency of 1.66, against 2.65 for SPADE. Its call count is 1.07, against 1.56, since it has no action-side objective. Its total cost is 1.78×, against 4.13×. Its objective has no term that keeps a valid action after longer reasoning, and our protocol accepts at most 10 points of TSR loss (App. C).

In summary, at matched task preservation, Verbose Images raises per-call latency less than SPADE and adds few calls. This comparison is now in App. E.1 (Table 16) and the adaptation details in App. D.

W3 & Q3: Can an independently tuned single-axis attack match the joint one?

The reviewer is right that the single-axis rows in Table 3 kept the joint attack's hyperparameters, so they do not answer this. We reran both with their own tuning, on DeepThinkVLA and the same eight tasks as in W2. The budget, patch constraints and task-preservation rule (at most 10 points of TSR loss, App. C) are unchanged.

Setup. For Axis A only, we add r = 0.55 and r = 0.4 to the paper's {0.7, 0.85}. For Axis B only, we add gBg_B = 6 and gBg_B = 12 to the paper's 3. Each setting is a separate run with the full 12 GPU-hour budget, and its loss weights are reselected by the same validation procedure. For each axis we report the best setting that meets the task-preservation rule. The joint attack keeps the paper setting and is not retuned.

AttackGNG_NGℓG_\ellGTG_TTSR
Axis A only, paper setting1.601.041.66×89%
Axis A only, tuned (r = 0.55)1.861.051.95×85%
Axis B only, paper setting1.042.632.74×88%
Axis B only, tuned (gBg_B = 6)1.042.782.89×86%
Joint (SPADE)1.562.654.13×88%

Tuning helps each axis, but neither reaches the joint attack. The most aggressive settings break the task-preservation rule: at r = 0.4 and gBg_B = 12, TSR falls by 17 and 14 points, beyond the 10-point tolerance. Their total cost is 2.13× and 2.79×.

Why the joint attack wins. The two factors multiply, and each axis loses almost nothing when combined. In the table above, calls go from 1.60 (Axis A only) to 1.56 (joint), and latency from 2.63 (Axis B only) to 2.65. To match 4.13× alone, one axis would need about 3.9× calls or 4.0× latency. The best tuned settings reach 1.86 and 2.78.

The two attacks the reviewer names. Verbose Images is compared directly in W2 (1.78×). SABER edits the instruction, not the scene. Its action-inflation attack makes action sequences 1.55× longer on DeepThinkVLA (their Table II). It has no reasoning objective and reports no task success for that attack. This is close to our Axis A only attack on the same model (1.57× calls at 90% TSR, Table 3). Action inflation alone at this level gives about 1.6× total cost, against 3.98× for the joint attack on all 40 tasks. App. A now cites and discusses it.

In summary, independently tuned single-axis attacks reach 1.95× and 2.89×, against 4.13× for the joint attack at similar TSR. The sweep is now in App. D (around Table 15).

References

  • Gao et al. Inducing High Energy-Latency of Large Vision-Language Models with Verbose Images. ICLR, 2024.
  • Wu et al. SABER: A Stealthy Agentic Black-Box Attack Framework for Vision-Language-Action Models. arXiv:2603.24935, 2026.
AuthorsOpenReview ↗

Response to Reviewer Dosn (3/3)

W4: Number of loss weights and tuning effort.

We agree that the objective has many weights. Below we give the configuration, compare complexity with the baselines, and show what each term adds.

Configuration. All three policies and all 40 tasks share one reference configuration (Table 4, App. B): λk=λa=λg=1\lambda_k = \lambda_a = \lambda_g = 1 and λu=λref=λc=λv=0.1\lambda_u = \lambda_{ref} = \lambda_c = \lambda_v = 0.1, plus λb=1\lambda_b = 1, λB=0.25\lambda_B = 0.25 and λTV=0.05\lambda_{TV} = 0.05. Validation only chooses among 0.3, 1 and 3 times these values, one weight at a time (App. B.2).

Complexity against the baselines. Every white-box method gets the same 12 GPU-hours per task and seed, which for SPADE includes the suffix search and validation (Section 4.1). Direct patch and Verbose Images go through the same weight selection (App. B.2; W2). Direct patch uses the same suffix-stage and appearance weights in pixels (seven); SPADE adds three patch-stage weights (λa,λg,λc\lambda_a, \lambda_g, \lambda_c). POV-SA and UPA-RFAS also combine three objectives and four modules (App. D). At deployment, every method is one static patch with no change to the model.

Adding the suffix-stage terms one at a time (DeepThinkVLA, all 40 tasks; Tables 1, 5b and 8):

ObjectiveGTG_TTSR
POV-SA (baseline)2.22×37%
UPA-RFAS (baseline)1.81×31%
Axis A only (incl. λk\lambda_k)1.63×90%
+ exit margin ("Margin only")2.91×83%
+ reference λref\lambda_{ref} ("Without uncertainty")3.33×90%
+ uncertainty λu\lambda_u (full SPADE)3.98×89%

Total cost rises at every step, and TSR stays at 83% or above. The two regularisers work together: uncertainty without the reference term gives only 2.65× (Table 5b). Without Axis A, total cost is 2.81× ("Axis B only", Table 8). Both baselines lose the task.

Adding the patch-stage terms one at a time (new; DeepThinkVLA, the eight tasks of W2 and W3; appearance term kept throughout):

Patch-stage termsGTG_TTSR
Action term (λa\lambda_a) only1.8×89%
+ boundary term (λg\lambda_g)4.1×74%
+ content term (λc\lambda_c): full SPADE4.13×88%

The boundary term carries the cost; the content term restores TSR. Removing one term on all 40 tasks (Tables 8 and 11) agrees: without the boundary term, total cost is 1.98×, against 3.98×; without the content term, TSR is 73%, against 89%; without the action term, TSR is 64%. The appearance term (λv\lambda_v) lowers the share of scenes flagged as suspicious by blinded raters from 78% to 21%.

In summary, each term either raises cost, keeps the task or keeps the patch inconspicuous, and SPADE adds three weights to Direct patch at the same compute and tuning protocol. The revised PDF now states the weights of Table 4 in Section 4.1 and adds both tables and this comparison to App. E.1 (Table 17).

We hope these answers and the added experiments address the reviewer's concerns. We would be grateful if the reviewer would consider updating the score, and we are happy to provide further details.

References

  • Gao et al. Inducing High Energy-Latency of Large Vision-Language Models with Verbose Images. ICLR, 2024.
  • Lu et al. When Robots Obey the Patch: Universal Transferable Patch Attacks on Vision-Language-Action Models. CVPR, 2026.
  • Wang et al. Partially Observable Adversarial Patch Attacks on Vision-Language-Action Models in Robotics. IEEE Robotics and Automation Letters, 2026.
AuthorsOpenReview ↗

Gentle Reminder: Follow-Up on Our Rebuttal Responses

Dear Reviewer Dosn,

Thank you again for your constructive feedback and valuable time.

We have provided detailed responses to your concerns, along with additional experiments and revisions to the manuscript. We would greatly appreciate it if you could kindly take a moment to review our responses and share any further thoughts.

We would be happy to address any remaining questions.

Best regards,
The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers

We thank all reviewers for their careful and constructive reviews. They found that the paper studies "an interesting security problem" (VoUg), with an attack objective that is "interesting and practically relevant" (Dosn) and "well motivated" (QoDY), that the framework forms "a coherent approach" (QoDY), and that the experiments are "relatively comprehensive" (Dosn, VoUg). We have uploaded a revised PDF with changes in blue; references below are to it, and existing numbering is unchanged (new tables are 15–23). Line numbers in our individual responses refer to the original submission.

Main concerns

  • Practical significance (VoUg). When a robot's task is urgent, the delay is itself the damage: the task usually still succeeds, but late. We do not claim that a slowdown is worse than a crash; it is a different risk, loss of availability. The patch delays a successful task by 27.1 s in simulation and by 38 s on the real robot, on the same scale as the published figures for three time-critical scenarios (kitchen fire, asthma attack, break-in; Appendix H).
  • Detection and safeguards (VoUg, QoDY). We agree that a monitor that compares latency with a clean baseline can see the slowdown; our stealth claim is narrower (outcome monitoring alone), and Section 2 now says so. A per-task latency monitor flags 88% of attacked episodes (6% of clean ones), and 61% with a threshold shared across tasks; it does not locate the patch or undo the delay. Under five safeguards (repetition penalty, token cap, call limit, JPEG compression, stopping flagged runs), with the patches not refitted, the slowdown stays between 1.59× and 3.78× (4.13× without a safeguard), and the strict limits cost 27–54 points of attacked task success (Table 19, with clean TSR and valid returns).
  • Why two stages, and single-objective attacks (Dosn). We agree that one sentence did not justify the suffix stage. It turns a search problem into a copying problem: the suffix finds a slow behaviour, closed-loop rollouts check it, and the patch then copies it (Section 1). Under the same budget, patch constraints and task-preservation rule (DeepThinkVLA, eight tasks), Verbose Images reaches 1.78× and independently tuned Axis-A-only and Axis-B-only attacks reach 1.95× and 2.89×, against 4.13× for SPADE, all at 85–88% TSR.
  • Loss weights and preparation cost (Dosn, VoUg). All three policies and all 40 tasks share one reference configuration (Section 4.1). Every white-box method gets the same 12 GPU-hours per task and seed, SPADE adds three weights to Direct patch, and Table 17 adds the loss terms one at a time. The cost is paid once per patch, offline. A lighter search with 1 GPU-hour gives 3.14× (4.13× with 12), a quarter of both black-box budgets gives 2.45× (3.20× in full), and a fitted patch also slows tasks it was not fitted on (2.46×).
  • Patch placement and occlusion (VoUg). A patch fitted for another region of the table works about as well as the original (3.94–4.01× against 4.13×). The same patch, not refitted, gives 3.51× when shifted by 8 px and 1.86× at 32 px, so it should stay near its fitted place; with a quarter to a third covered, it gives 3.16× to 2.61×.
  • Figure 1 and induced reasoning (QoDY). Figure 1 is redrawn: a top strip contrasts clean and patched execution, and three panels show suffix search, patch optimisation and patch-only deployment, with arrows for what passes on and no in-figure equations. Appendix G gives paired clean/attacked native outputs for all three models, with token counts, exit markers and action-return status (CoTinyVLA's cached Plan is kept apart from its new Think span). The added reasoning is mainly longer task-relevant reasoning (60–70% of labelled calls, with 22–28% repetition and 8–12% off-task text), and at least 96% of attacked calls in every model still reach the exit and return a valid action.

Changes in the revised PDF

  • Main text. Section 1 adds a time-critical scenario and states what the suffix stage contributes. Figure 1 and its caption are new. Section 2 states the scope of the stealth claim and who places the patch. Section 4.1 gives the loss weights and how they are selected. A new Section 4.7 summarises the added baselines, safeguards, placement, budget and reasoning results, with a small unnumbered table.
  • New appendices. G: paired reasoning examples and content labels (Tables 22–23). H: the three time-critical scenarios.
  • Extended appendices. A discusses SABER. B.2 notes that loss weights are varied one at a time. D adds the Verbose Images adaptation and the independently tuned single-axis attacks (Table 15). E adds E.1 (Verbose Images comparison, loss terms, complexity; Tables 16–17), E.2 (runtime monitors and safeguards; Tables 18–19) and E.3 (placement, occlusion and smaller budgets; Tables 20–21).

We are happy to answer any further questions.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.