Skip to content

How VLMs plan their next step

How VLMs Plan What's Next

arXiv· arXiv:2611.21600· Rohit Gandikota, Arnab Sen Sharma, Adam Belfki, David BauNortheastern UniversityIndexed by this site · 2 days ago· Originally publishedAlignment· Its place in the scan record →

Quick read

Interpretability

Based on the paper PDF (AI-generated); refer to the original

Using causal patching on Qwen3-VL, the authors characterize the planning mechanism by which the VLM enumerates image content item by item: the division of labor among binding, relay, cursor, selection, gaze and the language head; the authors say each step is separable and editable.

Questions
When a VLM describes an image, it names objects one by one and rarely repeats them, but a two-dimensional image itself has no one-dimensional order; how the model internally plans "where to look next" is still unclear; the autoregressive structure also cannot preserve running state across answers.
Methods
The authors design a controllable synthetic visual retrieval task (panel strips, each with a shape and a letter) and use activation patching of paired source/target runs to test each component one by one: binding heads resolve pointers, relay heads carry them, the comma token forms a cursor, selection picks the next step, gaze heads read, and language heads and the late MLP translate.
Experiments and results
On Qwen3-VL-8B, patching the outputs of 16 binding heads moves the pointer 85.9%, and patching the queries of 32 gaze heads 74.0%; progress is a cursor of "which cell has been reached" (98.4% at layer 20); the mechanism mostly holds on 2B–32B, other model families, canvases without panels, six independent images, and COCO natural images.
Limitations and future work
The authors note that repetition or early stopping was not tested on natural images (App. E.2), the reason for reduced reliability of right-to-left listing is left as an open question (App. G.3.5), and whether text models already have this mechanism is undetermined (App. G.3.7); the main experiments focus on one synthetic task and the Qwen3-VL family.
Experimental setupQwen3-VL-8B-Instruct、Qwen3-VL-32B et al. · synthetic visual retrieval task(single-answer 与 list 两种)、colored-shape task et al. · 修补后目标答案为预期字母的百分比、published Gaze Heads 落在预期面板的百分比(Gaze) et al.
Evaluated models
Qwen3-VL-8B-InstructQwen3-VL-32BQwen3-VL-2B
Benchmarks
synthetic visual retrieval task(single-answer 与 list 两种)colored-shape taskobject taskCOCO val2014
Metrics
修补后目标答案为预期字母的百分比published Gaze Heads 落在预期面板的百分比(Gaze)线性探针准确率余弦相似度
AI summaryThe paper characterizes the internal mechanism by which a vision-language model (VLM), when describing an image, decides where to look next, and divides it into four parts: binding heads match the relevant text tokens in the question to the image, resolving them into pointers to the corresponding image regions, while also binding already-written answers to their source regions, forming a cursor-like progress signal marking written positions; a selection step picks the nearest unwritten region after the cursor or stops; gaze heads execute the selected pointer and return the concept of the content there, which language heads and later MLPs then turn into words expressed in the language of the question. The authors validated each part on the Qwen3-VL model through synthetic visual retrieval tasks and causal patching, and compared against alternative hypotheses; the mechanism holds across input formats, natural photographs, and languages, and binding, relay, and gaze heads appear in models of all sizes from 2B to 32B. Project page: https://plan.baulab.info/。

The paper characterizes the internal mechanism by which a vision-language model (VLM), when describing an image, decides where to look next, and divides it into four parts: binding heads match the relevant text tokens in the question to the image, resolving them into pointers to the corresponding image regions, while also binding already-written answers to their source regions, forming a cursor-like progress signal marking written positions; a selection step picks the nearest unwritten region after the cursor or stops; gaze heads execute the selected pointer and return the concept of the content there, which language heads and later MLPs then turn into words expressed in the language of the question. The authors validated each part on the Qwen3-VL model through synthetic visual retrieval tasks and causal patching, and compared against alternative hypotheses; the mechanism holds across input formats, natural photographs, and languages, and binding, relay, and gaze heads appear in models of all sizes from 2B to 32B. Project page: https://plan.baulab.info/。

Paper analysis

6 questions; open one to read the full answer

  1. What problem does this paper attempt to solve?

    How a VLM plans "where to look next" when describing an image item by item: the authors use a controllable task and causal patching to characterize this planning mechanism.

    Core question: when a VLM turns a two-dimensional image into a one-dimensional answer sequence, how does it internally decide which region to describe next and remember what it has already said.

    • Problem setting: When describing an image, a VLM names objects one by one and rarely repeats, but image content has no inherent order, so a "plan" must exist inside the model; the authors consider how this plan is formed to be unclear.
    • Gaps in existing work: Existing mechanistic studies (binding, Gaze Heads, etc.) explain how the model finds a single region to answer a question, but the authors note that multi-answer tasks require tracking already-described regions, which remains unclear; an autoregressive transformer cannot preserve progress as running state updated across answers (layers would run out), so the model must recompute progress at each token from the tokens generated so far.
    • Core observation/hypothesis: Open-ended description is hard to study causally, so the authors instead design a synthetic visual retrieval task (panel strips, each with a shape and a letter), where each step can be controlled individually and tested with causal patching.
    • What the paper proposes: A four-part planning mechanism—binding heads resolve pointers to image regions, the same set of binding heads binds written answers back to their source panels and the comma token forms a "cursor," the selection step takes the nearest unwritten panel after the cursor or stops, gaze heads execute the pointer to retrieve concepts, and language heads and the late MLP translate into the question's language; the authors state that this is verified step by step with causal patching on Qwen3-VL, and that generalization across input formats, natural photos, and languages was tested.
  2. What related research exists?

    Related work falls into four groups: binding and pointers, progress tracking, image-reading heads, and concepts and output language; this paper connects them into a single plan.

    Binding and pointers

    • Feng & Steinhardt (2024), Prakash et al. (2026; 2024), Dai et al. (2024)—language models assign entities abstract position codes bound to mention order, and later retrieve entities by code.
    • Sen Sharma et al. (2026)—filter heads in LLMs carry filtering rules in the query vector and select matching items in a list.
    • Assouel et al. (2026), Cui et al. (2026), and others—VLMs build spatial indices for matching image regions when processing prompts; Cui et al. (2026) state that VLMs bind objects and spatial relations via two routes. The paper notes that this work finds a similar binding mechanism and extends it to "how to track what has been answered and how to choose the next among multiple matching regions."

    Progress tracking

    • Pal et al. (2023), Lindsey et al. (2025), Hanna & Ameisen (2026)—language model planning goes beyond the next token.
    • Gurnee et al. (2025), Hasani et al. (2026), Yan & Jia (2025), Merullo et al. (2024)—models maintain running state of their own outputs: character counts, list-item counts at delimiters, suppression of already-given answers.
    • Budny et al. (2025), Yue et al. (2024), Assouel et al. (2026), Haputhanthri et al. (2026)—VLMs appear to work only serially through generated text, decide to stop by comparing text with the image, enumerate grid objects in raster order, and after training the pointed-to VLM internally records counted objects. The paper notes that the record found in this work, in a general VLM that writes only letters, is neither a count nor a set of written letters, but a position in the image.

    Image-reading heads

    • Kang et al. (2025), Gandikota & Bau (2026) select heads by attention position; Golovanevsky et al. (2025), Schaumlöffel et al. (2026), Liu et al. (2026b) rank heads by causal effect; Baek et al. (2025)'s OCR heads read text in images; Feucht et al. (2026) find that the heads needed for OCR can also read semantics in text-free regions. The paper notes that the heads selected by causal effect in this work read the pointer better and are more causally sufficient than heads selected by attention.

    Concepts and output language

    • Wendler et al. (2024), Schut et al. (2025), Wu et al. (2025)—multilingual models store concepts in intermediate layers in a form close to the dominant language (often English).
    • Dumas et al. (2025), Zhang et al. (2025a), Lasnier et al. (2026), Liu et al. (2026a)—concept and output language can be patched separately, involving a small group of attention heads. The paper notes that when the concept comes from the image, the image-reading heads return a concept independent of the question's language, and other heads and the late MLP translate it.

    Positioning: The authors state that this paper connects multiple mechanisms previously found in different models and tasks into a single plan, and shows that the same components can solve more complex tasks than those on which they were discovered.

  3. How does the paper address this problem?

    Synthetic retrieval task + activation patching with paired source/target runs, verifying the "binding—relay—cursor/selection—gaze—translation" mechanism component by component.

    Overall approach: design a synthetic visual retrieval task in which each step is controllable, use activation patching to copy the source run's internal states one by one into the target run, and infer the information carried by the patched state from changes in the target answer, thereby characterizing the planning mechanism layer by layer and token by token.

    Task and model setup

    • Model: Main study of the language backbone of Qwen3-VL-8B-Instruct (36 layers, 32 attention heads per layer); the vision encoder encodes only once and is cached, with no intervention; other sizes and model families are tested in Appendices G.1 and G.2.
    • Single-answer task: The image is a strip of 4 panels, each with a shape and a letter; the question is "What is the letter inside the {shape}?", with "Answer:" prefilled so that the next token is the answer; the question is asked by shape rather than panel number, to separate binding signals from panel-number knowledge.
    • List task: 6 panels, with the queried shape appearing in 4 panels; the question is "What is the letter inside each {shape}?", and the model lists the letters from left to right, used to study progress and selection.

    Patching protocol and five outcomes

    • Paired design: Source and target differ in both image and question; each patch replaces only a single activation at one token and one layer of the target run, leaving everything else unchanged.
    • Five distinguishable outcomes: T (no effect), D (shallow copy of the source answer), K (carry over the pointer resolved from the source), P (carry over the source's request), R (carry over the source's layout); in the K, P, and R cases the pointer is still executed on the target image. The authors use this so that each transportable type of information leads to a different answer.
    • Patching levels: whole-layer residual, MLP output, attention-head output; for attention heads, query, key, and value are also patched separately.
    • Head selection: first patch all 1,152 heads one by one (200-pair discovery set) and rank by improvement in the expected letter's logit; then sweep top-K on a 100-pair validation set (K from 1 to 128, up to 256 for gaze heads), taking the smallest qualifying K by a preset rule; finally report on the 500-pair held-out set, with same-layer random heads as controls.

    The four parts of the mechanism

    1. Binding (Section 4): At shape tokens, a small number of binding heads (16, layers 15–21) match the requested shape to the image and resolve pointers to each matching region; the query carries the request and the image key carries the layout; relay heads (16, mostly in layers 19–23) carry the pointer from the shape token to the colon token.
    2. Progress and cursor (Section 5): The same set of binding heads binds each written answer to its source panel, and the comma token turns it into a cursor at layers 20–21—"where in the image the list has been written up to."
    3. Selection (Section 5.4): At layers 20–25 of the comma token, the model takes the nearest unwritten panel after the cursor, falls back when there is none to the right, or stops when no matches remain; the authors state that this selection is distributed across multiple heads, with no small group of heads able to do it alone.
    4. Execution and translation (Section 6): Gaze heads (32, layers 19–34) have queries that carry the pointer, image keys that match by position, and values that bring back the letter; language heads (16, layers 19–35) add the question's language, and the late MLP (mainly layers 33–35) composes concept and language into a word.

    Success criterion

    • Each experiment pre-specifies the answer letter predicted by the hypothesis under test (Tables 1–3 list, experiment by experiment, the token, the patched content, the predicted answer, and the result); percentages are computed on the held-out set, some with 95% intervals (2,000 bootstrap resamples).
  4. What experiments did the paper conduct?

    Causal patching verifies the four parts of the mechanism step by step, along with generalization across sizes, across families, across images/prompts and to natural images, and error analysis.

    Experimental setup

    • Models tested: Main experiments use Qwen3-VL-8B-Instruct (revision 0c351dd0, 32-bit floating point, greedy decoding); Appendix G.1 tests Qwen3-VL 2B/4B/32B; Appendix G.2 tests LLaVA-OneVision-7B, InternVL3-8B, Gemma-3-12B, Pixtral-12B, Idefics3-8B; Appendix G.3.7 additionally tests the text model Qwen3-8B.
    • Datasets: Synthetic single-answer task (4 panels) and list task (6 panels, 4 matches); colored-shape task and object task (English/German/French/Chinese); COCO val2014 natural-image list questions.
    • Samples and splits: 200-pair discovery set to rank heads, 100-pair validation set to set K, 500-pair held-out set to report all results; each patch is paired with a same-layer random-head control.
    • Metrics: Percentage of patched runs whose target answer is the expected letter; some experiments report whether published Gaze Heads look at the expected panel (Gaze); probe accuracy and cosine similarity.
    • No-patching baselines: 8B single-answer task accuracy 98.9 ± 0.2% (App. A.7); list-task target second-letter accuracy 97.4 ± 1.0% (App. A.3).

    Main results

    According to Tables 1–3 (Qwen3-VL-8B, 500-pair held-out set, same-layer random-head controls in parentheses):

    Swipe horizontally to read the table

    Experiment (token)Patched contentExpectedResult
    Binding heads (shape token)16 head outputs, layers 15–21K85.9% (≤0.1%)
    Query/key heads (shape token)top 8 queries / top 8 keys reading the source imageP / R81.0% / 83.1%
    Relay heads (colon token)values read by 16 headsK87.5%
    Comma residual→colon (layers 20/21)source comma residualskip written panels91.0% / 70.0%
    Count/set/position (layers 20/21)same, distinguishing three hypothesesposition98.4% / 97.6% (set ≤1.2%)
    Cursor setup (last answer token)16 binding heads read source image keysskip the moved panel84.2% (0.0%)
    Gaze heads (colon token)32 head queries, layers 19–34K74.0% (0.0%)
    Language heads (last token)16 head outputs, layers 19–35language change95.3% (0.0%)
    • The authors state that the pointer is resolved by binding heads at the shape token and carried via relay heads to the colon token for execution; progress is an ordinal position in the image (a cursor) rather than a count or a set of panels.
    • The authors state that gaze heads return concepts rather than words: their LogitLens distributions have cosine 0.95 for two languages on the same image and 0.50 for two images in the same language (Table 3).
    • The authors state that the selection step is distributed across multiple heads in layers 20–25: none of three searches found a qualifying small group of heads (App. E.7).

    Comparison with published Gaze Heads

    • What was tested: The 32 gaze heads selected by causal patching in this paper are compared with the top 100 selected by attention in Gandikota & Bau (2026) (Table 13, Figure 4b).
    • Results: Query patching moves the answer 74.0% vs. 64.2%; reading source image values gives the source letter 93.7% vs. 50.0%; 23 of this paper's 32 heads are within the published top 100.
    • Authors' interpretation: The authors state that heads selected by causal effect read the pointer better than heads selected by attention; the published set is larger because its task (comic description) involves more types of visual content.

    Cross-model generalization

    • Sizes (Tables 18–22): Binding, relay, and gaze heads exist in 2B/4B/32B after re-searching each; on 32B the cursor reaches 100% at layers 48/64, whereas in 2B/4B the "visited panels themselves" and counting signals are comparable to the position signal (e.g., 2B visited panels 41%, cursor at most 22%); the authors state that 8B and 32B cleanly hold a "done up to here" state.
    • Families (Table 23): All six models move the request at shape tokens in early layers (92.5–100%); all four models able to do the list task (Qwen3-VL-8B, InternVL3-8B, Gemma-3-12B, Pixtral-12B) show a cursor (86–99%); single-token residual patches in Gemma-3-12B and Idefics3-8B move the pointer only 30.5–38.5%; LLaVA-OneVision-7B and Idefics3-8B achieve list-task accuracy of only 18.5% and 3.5%, and the list rows were not tested.

    Generalization across images and prompts

    • Panel-free canvas (App. G.3.2): The head sets are unchanged; binding outputs move the pointer 97.5%, relay 95.5%, gaze queries 90.0%; the authors state that "position" is not panel number.
    • Six independent images (App. G.3.3): The cursor experiment gives the same layer profile as the strip (83.0% at layer 20).
    • COCO natural images (Table 28): When the comma token cannot attend to the already-written object A, the model names A again in 79.6% of valid lists (control unchanged at 98.0%); the proportion of cases where gaze heads' per-token attention to the next object exceeds that to the just-named object is 83.6%.
    • Exceptions: Under Prompt B (two question sentences after the shape token), patches drop to 48–62% (Table 24); the authors further show that binding spreads to later tokens and then recovers (Table 25, 87.0%).

    Other ablations and analyses

    • When relay heads' attention to the text is blocked, only 7.8% of answers are retained (random heads 99.8%, Table 1).
    • Blocking the comma's attention to the last answer token causes 67.8% repetition of an already-written letter (Table 2).
    • Stop decision: patching the outputs of 64 heads makes a completed list continue 100.0% of the time and makes an in-progress list stop 96.8% of the time (Table 2).
    • The cursor is a five-dimensional subspace within the comma residual (App. D.5).
    • Right-to-left instructions are read by 16 heads in layers 18–23, and blocking them returns 98.4% to left-to-right (Table 27).
    • Error analysis: on a 10-panel long list, 3.2% of answers skip a panel; when skipping, binding and cursor are intact and selection errs (App. E.2).
  5. What are some points that can be further explored?

    The authors state few follow-up directions; experimental coverage is mainly synthetic tasks and the Qwen3-VL family, and generalization tests are mostly qualitative threshold judgments.

    Limitations and follow-up directions noted by the authors

    • Repetition or early stopping was not tested on natural images, which the authors state is left for future work (App. E.2).
    • Model reliability drops for right-to-left listing (77.0% vs. 87.9%); the authors propose the hypothesis that "the requested order adds a step" and state that it is left as an open question (App. G.3.5).
    • The text model Qwen3-8B is only 32% correct under this prompt, and the authors state that whether this mechanism exists before vision fine-tuning is "undetermined here" (App. G.3.7).
    • In the six-independent-image experiment, whether the cursor counts a position in the image or in the token sequence was not separated (App. G.3.3).
    • On natural images, covarying factors such as size and category, foreground, and recognizability were not separated, and no saliency model was used (App. G.3.6).

    Scope of experimental coverage

    • The main experiments test one model, Qwen3-VL-8B-Instruct; sizes cover four in total, 2B/4B/8B/32B, and families cover five other open-source VLMs (Table 23).
    • Cross-family tests run only experiments that do not require re-searching heads, and whether the mechanism "exists" is judged by a 40% effect threshold (App. G.2.1).
    • Language tasks cover four languages: English, German, French, and Chinese; 32B did not run the language tasks (App. G.1.1).
    • Head search uses a 200-pair discovery set, 100-pair validation set, and 500-pair held-out set; intervals use 2,000 bootstrap resamples (App. A.4).
    • The paper does not report wall-clock time or computational cost for each experiment.
  6. Summarize the main content of the paper

    The authors say they characterize in Qwen3-VL a modular planning mechanism by which the VLM describes an image item by item, verify it causally step by step, and show that it is generalizable and editable.

    A mechanistic interpretability paper that answers how a VLM plans unordered image content into an ordered answer sequence.

    • Problem: Images have no inherent order, and autoregressive models cannot preserve running state across answers; the authors aim to find the "plan" the model reconstructs at each token.
    • Method: A synthetic visual retrieval task (panels + shapes + letters) combined with activation patching of paired source/target runs, with five distinguishable answers so that each type of transported information can be read out; reported on a 500-pair held-out set, with same-layer random-head controls.
    • Mechanism: Binding heads (16, layers 15–21) resolve pointers at shape tokens; relay heads (16) carry them to the colon token; the same set of binding heads binds written answers back to their panels, and the comma token forms a cursor at layers 20–21; selection is completed diffusely at layers 20–25; gaze heads (32) execute the pointer to retrieve concepts; language heads (16) and the late MLP translate into the question's language.
    • Key results: On 8B, patching binding-head outputs moves the pointer 85.9%; the cursor hypothesis beats counting and set hypotheses at layer 20 with 98.4%; gaze-head query patching 74.0%; language-head patching changes language 95.3%; blocking the comma's attention to written answers causes 67.8% repetition.
    • Generalization: The mechanism mostly holds on 2B–32B, four other model families, panel-free canvases, six independent images, other prompts, and COCO natural images; exceptions include unclean cursors in 2B/4B, weak single-token pointers in Gemma-3 and Idefics3, and two models unable to do the list task.
    • Authors' conclusion: The authors state that the plan is structured and modular, with each step separable and editable, and can serve as a tool for explaining, auditing, and debugging model outputs, and opens the way for studying how models track progress in long-horizon multi-step tasks.
Read originalarxiv.org