acceptodds
Withdrawn from ICLR 2027

What Happens Inside VLAs for Compositional Generalization? A Mechanistic Analysis

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Vision-language-action (VLA) policies show strong performance on many manipulation benchmarks, but they fail to generalize compositionally: even when objects and skills are familiar, visual shortcuts or isolated object words can dominate the full instruction. Prior work develops mitigation methods based on hypothesized failure mechanisms. We instead analyze internal representations to understand when and where task-relevant information supports action generation. We study how task information flows from text prompts to final actions and what happens internally when compositional generalization fails. We introduce VLA-PatchLens, an analysis framework based on activation patching and path patching for localizing task-critical information. The framework compares matched clean and corrupted runs that differ in task-critical instructions or task behavior. For each matched pair, we replace the corrupted run’s activation at a layer-token group with the clean-run activation and measure whether the patch recovers action loss and rollout success. We construct three compositional generalization task suites, and for π₀.₅, the analysis shows that task-critical information in text tokens is evenly distributed across layers, with early and late layers carrying complementary parts of the task; in later layers, early text-token information becomes concentrated in image tokens and reaches action tokens through cross-attention. We also find that action-loss recovery and success-rate recovery are highly consistent, making action-loss recovery a lightweight proxy for selecting intervention targets before closed-loop evaluation. In compositional generalization failures, VLA-PatchLens reveals clear breaks in this task-critical information flow, and finds simple single-layer activation patching improves success rate from 0% to 3.9–23.5% on average and up to 66.7% at the best layer across three task suites, while activation-similarity scores remain uninformative.

Primary area:
interpretability and explainable AI
Keywords:
Robot manipulation Mechanistic Interpretability Compositional Generalization

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_K5aSOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies why vision-language-action (VLA) policies fail at compositional generalization by analyzing their internal representations. The authors propose VLA-PatchLens, which applies activation patching and path patching to matched clean/corrupted rollout pairs and measures recovery with a single-step action metric (R_action) and the closed-loop success-rate gain (R_rollout). They build three compositional generalization suites from LIBERO: paraphrase, seen-goal recombination and seen-target recombination. For π0.5, the analysis suggests that task-critical information in text tokens is spread across layers, and that early-layer text information is concentrated into image tokens in later layers and reaches the action expert through cross-attention. It also finds that R_action tracks R_rollout closely enough to serve as a cheap proxy. In failure cases, the authors identify breaks in this information flow and show that single-layer patching raises success rate from 0% to 3.9–23.5% on average, and up to 66.7% at the best layer. The analysis is also extended to StarVLA-OFT and a real Franka robot.

Critical strengths
  1. The question is important and the angle is timely. Most prior work on compositional failures in VLAs proposes behavior-level fixes based on hypothesized mechanisms. This paper instead asks where task information lives inside the model and where it breaks down. Adapting activation and path patching to VLAs, with closed-loop readouts, provides causal rather than correlational evidence.

  2. The analysis is systematic and produces clear, interpretable findings: a layer-by-token-group map of task information in π0.5, and a text→image→action flow traced by path patching that agrees with the attention analysis. A further useful observation is that activation similarity is uninformative about patching success, while causal patching is informative.

  3. The evaluation is reasonably broad. It covers three suites, several simulator time steps, negative controls (random, cross-task and reverse patching), a second architecture and a real robot. The authors are also upfront about some limitations: they report fixed-layer results and note that the best-layer numbers are descriptive.

Critical weaknesses
  1. The patching procedure is underspecified in ways that change how the results should be read. The paper never states whether the backbone layers after the patched layer are recomputed. Fig. 3(a) suggests they are not: patching all prefix tokens at layer 0 yields R_action ≈ 0, whereas with recomputation every later layer would be clean and R_action should approach 1. If only a single layer's KV (as read by the action expert) is replaced, the "evenly distributed and complementary across layers" result is largely expected by design. It would then reflect which layers the action expert reads from, not where information resides in the backbone. It is also unclear which input differs between clean and corrupted runs in the failure setting, since both share the instruction and layout (L206–208).

  2. The repair results rest on very few rollouts. R_rollout in Fig. 7(a) only takes the values 0, 33 and 67 pp. The reported averages are consistent with 3 rollouts per layer per suite (e.g., CG-goal: 3.9% = 2/3 ÷ 17 layers), not the N = 15 stated in Appendix B. The 66.7% figure is the best of 17 layers, selected on the evaluation data. The 0% baseline holds by construction, because pairs are selected so that the corrupted run fails. Before the gains can be attributed to restored task information, the paper needs a larger N, confidence intervals, and baselines in the failure setting: the unselected success rate, re-running the same initial state with a different seed, and norm-matched random patching.

  3. The experiments do not test the failure mode that motivates the paper. The introduction frames compositional failures mainly as vision shortcuts. Yet no experiment varies the visual scene while keeping the instruction fixed (e.g., swapping target and distractor positions), so the analysis cannot localize where visual input overrides language. In addition, the image input is identical across runs in the blank-prompt setting, so task information in image tokens must come from text by construction. The only informative part of this finding is which layers it happens at.

Questions for authors

n/a

Reviewer_s2PFOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents VLA-PatchLens, which applies activation patching and path patching to trace how task information flows from the language prompt to the actions inside a VLA, mainly π0.5 on LIBERO. Using three compositional-generalization suites, the authors find that text-token information is spread across layers and is later absorbed into image tokens before it reaches the action expert. They also find that a cheap action-level score tracks closed-loop success. In failure cases, patching a single layer recovers part of the success rate. The analysis is further extended to StarVLA-OFT and a real robot.

Critical strengths
  1. Bringing causal patching tools from LLM interpretability to VLAs, and studying compositional-generalization failures in particular, is a fresh direction. It goes beyond the probing and steering focus of prior work,
  2. The information-flow picture in Fig. 1 is intuitive and potentially useful for designing interventions.
  3. The effects are measured with closed-loop success, not only internal metrics. R_action as a cheap proxy for rollout success is practically useful, and the cross-architecture and real-robot experiments add credibility.
Critical weaknesses
  1. The "repair" claims lack proper controls. Patching uses clean activations from the same task, so it is an oracle intervention rather than a fix. The 0% corrupted baseline is produced by selecting failed runs, and the failure setting has no matched null or random-patch control.
  2. It is not specified which clean activation is injected once the closed-loop trajectories diverge, nor whether downstream layers and the KV cache are recomputed. Because the action expert reads the prefix at every layer, the "complementary across layers" conclusion may partly follow from the architecture itself.
Questions for authors
  1. During closed-loop patching, which clean activation is used at each step after the trajectories diverge? Are downstream layers and the KV cache recomputed?
  2. Could you report unpatched or null-patch success rates and random-patch controls on the same failure pairs?
  3. Does the main finding (Fig. 3) hold with minimal-pair corruptions instead of blank prompts?
Reviewer_EdNFOpenReview ↗
Rating
2
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduces VLA-PatchLens, a method to locate task information inside Vision-Language-Action models with activation patching and path patching. Each experiment uses a matched pair of rollouts. The two rollouts share the initial scene and state, but they differ in the instruction or in the behavior. The authors define two metrics that estimate how far a patch moves the corrupted run back towards the clean run. The first metric, RactionR_{\text{action}}, uses the normalized L2 distance between the patched and the clean action prediction for a single step. The second metric, RrolloutR_{\text{rollout}}, measures the change in task success rate between patched and corrupted full rollouts.

The authors apply their method to π0.5\pi_{0.5} and StarVLA-OFT on a total of 30 tasks from three task suites built from LIBERO. They also apply it to π0.5\pi_{0.5}-DROID on a real Franka robot.

The main findings fall into three groups:

  • Information flow in successful runs. Text tokens carry task information at all depths. In later layers, image tokens collect this text information, and the action expert reads it through attention.
  • Failure analysis and repair. Failed runs show breaks in this text → image → action path. Single-layer patching increases the success rate from 0% to between 3.9% and 23.5% on average, and to 66.7% at the best layer.
  • Metrics. RactionR_{\text{action}} agrees with RrolloutR_{\text{rollout}}. Activation similarity does not predict success.
Critical strengths

Strength 1 - Clarity The paper is well written. I commend the authors for the structure of research questions and findings. This structure makes the paper easy to follow.

Strength 2 - Relevance The paper investigates a real problem: VLAs often ignore the instruction and follow visual cues. The authors connect internal interventions to task success in closed-loop execution. This gives the analysis more practical value than a comparison of activations alone.

Strength 3 - Extensive experiments The study covers several token groups, single layers, layer combinations, and different time steps of the rollout. The experiments on a second architecture (StarVLA-OFT) show that the observed patterns depend on the architecture. The real-robot experiments give initial evidence that the method also works for physical control.

Strength 4 - Controls and transparent reporting The authors include negative control experiments: reverse patching, random activations with matched norm, and activations from another task. The authors also report all tested layers and state that they select the best layer on the evaluation data. This transparency helps the reader to judge the limits of the results.

Critical weaknesses

Weakness 1 - Soundness: missing implementation and task details The paper does not state exactly which tensors the method patches. Appendix B specifies "post-FFN", which is the residual stream after the FFN block. Appendix D specifies "norm-input", which is the residual stream before the layer norm.

The paper also does not state what happens after the patch. It is not clear if the method recomputes the downstream layers, uses cached keys and values, or keeps the corrupted-run values.

The closed-loop protocol also needs more detail. The paper does not state if the method patches at each action query or only at selected times. Also, if I understand correctly, the patched run and the clean run see different scenes after a few steps of the rollout. It is not clear how the method is applied at that point.

Weakness 2 - Significance The findings are interesting. However, the authors do not show a practical use case without a matched clean run. A matched clean run is not available in real-world deployment. The authors also state this limitation.

In addition, the paper assumes that the location of the information shows where to intervene. The paper does not test this assumption. Unfortunately, prior work on language models found that the location from causal tracing does not predict the best location for model edits.

Weakness 3 - Findings that follow from the architecture Some of the presented findings follow directly from the model architecture. For example, in the successful task-following setting, the two runs have the same initial state (Section 3.1). Thus, at the first frame, all differences in the image tokens must come from the text, through the bidirectional prefix attention of π0.5\pi_{0.5}.

As a second example, in StarVLA-OFT the image tokens come before the text tokens, and the attention is causal. Because the image inputs are identical, a patch of the image tokens cannot change the output. The authors give this explanation themselves (Section 4.4).

Questions for authors
  1. Which tensor exactly do you patch? Appendix B says "post-FFN", while Appendix D says "norm-input". Do these refer to the same position in the residual stream with a different layer index?
  2. After you patch layer ll, do you recompute the downstream backbone layers and the cached keys and values? Or do you keep the corrupted-run values?
  3. In the closed-loop experiments, do you patch at each action query or only at selected times? Do you use stored activations from the clean rollout at the same time step, or do you compute them again?
  4. After a few steps, the patched run and the clean run see different scenes. How do you make sure that the policy does not partly copy the clean trajectory through the patched image tokens?

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

Related papers

Discussion (0)

Sign in to comment.