Anonymous ACL submission · supplementary site

Download all code and result files Explore the auditEvery figureHow to reproduce

The paper's abstract

Start here

The whole study in plain words

An everyday pictureThink of a mechanic who can repair any car perfectly, but only after watching it break down on the road. Knowing what broke is real knowledge, yet it is not a repair you can make in advance. The fixes we tested are in the same position: the diagnosis is right, but the best repair needs information, the correct answer, that a model does not have when it answers.

New to the words? The glossary explains every term on this page in one or two sentences.

See it in 3D

The oracle gap, inside the architecture

How to use itThis is the main model of the study, Qwen2-VL-2B, built as a building: the picture enters on the left, an image encoder turns it into pieces, and a tower of language-model layers turns those pieces into an answer at the roof. The nine steps follow the paper: the model, then its three questions (Q1 are the defects real? Q2 do the fixes help? Q3 if not, why not?), then its conclusion. The caption on the picture says what each step shows and where to look, and the colours button explains the colours. Press play or click the numbers; drag to turn the model, use + and − to zoom, hover any part for its name, and click a lettered marker to see the fixes that plug in there.

Loading the 3D view…
drag to turn

Scope

How much we tested

A claim that “no fix works” is only as strong as the search behind it. Here is the size of that search, as the paper reports it.

Every vision–language model we ran ·
Show

The benchmarks: fixed sets of test questions with known answers

What we trained

The question

Does the fix a diagnosis suggests beat plain fine-tuning?

In plain wordsMany papers find something broken inside a model and then propose a fix for it. We ask a simple question: does the fix beat the most ordinary alternative, which is plain fine-tuning on the same data, with the same training settings and no more trainable parameters? We call that ordinary alternative the matched control.

Papers that look inside vision–language models often find a defect and then propose a mechanism to fix it. The mechanism is usually compared with the unchanged model. But a mechanism adds trainable parameters and is trained on task data, so the fair baseline is plain low-rank fine-tuning (LoRA) of the same model, on the same data, with a comparable number of trainable parameters. We call it the matched control, and we ran the whole cycle against it.

Figure 2 of the paper · where each mechanism attaches, beside the matched control
Qwen2-VL-2B with the attachment point of each audited mechanism family, and the matched control
Q2 · Do the mechanisms help?

Nineteen mechanisms, each against its matched control

In plain wordsEach row is one fix. The dot shows how many accuracy points the fix scored above its fair opponent (to the right) or below it (to the left), and the bar shows how uncertain that number is. A fix that truly helped would sit clearly to the right of the zero line. None does: the dots gather around zero, and the only ones clearly separated from it are on the left, where the fix did worse.

Each row is one mechanism minus its matched control, in accuracy points. The dot is the difference; the thick bar is one standard error and the thin bar two. A row in red is worse than its control by more than two standard errors. Hover a row for its numbers; click it to see the model, benchmark, accuracies and the result file it comes from.

Families
Sort
The audit ·
difference± one standard error± two standard errorsworse than its control by more than two standard errors
Where the z-scores fall · difference divided by its standard error

Selected row
Tip
Click any row.

A tie, question by question

Same 1,000 questions, three seeds: the mechanism and its control trade answers

In plain wordsWe trained a fix and its opponent three times each and tested them on the same 1,000 questions. They get about the same number right, but not the same questions: each one gets some questions right that the other gets wrong. That is why their totals cancel out.

The two central mechanisms were re-run three times each, with one record per test question. That lets us look past the accuracy and ask on which questions the mechanism and its control differ. A mechanism that really helped would tend to win the same questions on every seed. Instead the wins go both ways, and retraining the control with a new random seed changes about as many answers as the mechanism does, or more.

Pair
Questions only one arm gets right · GQA two-hop test-dev, n = 1,000 · Appendix F re-runs

All 1,000 questions, per seed
How many answers change · disagreements per pair of runs

Real questions where RIFR and LoRA-26 disagree

Answers are scored as in the paper: the first word of the answer must match GQA's answer (or one must start with the other). So a synonym such as “lady” for “woman” counts as wrong for whichever model says it. Photos: GQA test-dev (Visual Genome images, CC BY 4.0).

The oracle gap

Each lever works only when the answer chooses where to pull it

In plain wordsAn oracle is a deliberate cheat: it is allowed to know the correct answer and uses it to decide where to change the model. With that cheat, a change rescues many wrong answers. With less knowledge it helps less, and applied to every question, or learned by the model itself, it no longer helps at all. The drop from the top of this ladder to the bottom is the oracle gap.

An oracle is a fix that is allowed to use the correct answer. For each lever we measured what it gains at every level of knowledge: with hindsight, when the correct answer picks the inputs, applied to every input, and learned as a trainable mechanism. Pick a lever.

Lever
The oracle ladder · Table of the paper

Differences are in accuracy points against the unchanged model, except learned rows, which are against their fine-tuned controls. "≈" marks the hindsight value, which is extrapolated from 44 recoveries among 150 swept failures. Hover a bar for the full condition.

Q1 · Are the defects real?

Three defects that survive their controls, and one caution

In plain wordsBefore testing any fix, we checked that each problem is real, using a control that could have proved us wrong. Three are real. (1) In two-step questions the model finds the answer late in its layers and then loses it. (2) The image encoder records where small objects are poorly. (3) Image patches in the same row get the same height position. A fourth, information that is present but unused, shows up mainly on computer-drawn scenes, so we treat it as a caution.

D1The two-hop answer forms late and is then lostQwen2-VL-2B · GQA two-hop

We read the model's best guess for the answer at every one of its 28 layers (the logit lens). Correct answers first become the top guess at layer on average. In the failures, the bars show where the correct answer got its best rank: most peaks sit in the last six layers, which leaves almost no depth to keep the answer.

What happens in the failures

What an oracle recovers

D3Image patches in the same row share a position coordinatetry Qwen2-VL's own index rule

Qwen2-VL gives every image token three position ids: time, height and width. This explorer applies the model's rule for one image: image tokens start after the text, every token in a row gets the same height id, every token in a column the same width id, and the text after the image continues from the largest id plus one. Click an image token to see which tokens share its ids.

The image, one cell per merged token (h, w)
The sequence the decoder sees

Where each coordinate lives in one attention head

The repair, and what it changes

D2 · D4The count is present in the image tokensSmolVLM-256M, frozen

A linear probe reads the object count from the image tokens at seven points along the pipeline. On rendered scenes it reads the count far better than the model answers. On real images (CountBenchQA) the gap almost disappears, so we treat this present-but-unused information as a caution, not a defect.

Rendered scenes

Real images

probe accuracythe model's own accuracychance
D1, one question at a time

Real examples: watch the answer form and get lost

In plain wordsPick a real question and press play. You will see, layer by layer, how highly the model ranks the correct answer. In many failures it climbs close to the top and then drops away at the very end.

Pick a question. The line shows where the correct answer stands in the model's ranking of all words at each layer (guess #1 is the model's top guess). In a “found, then lost” question the correct answer climbs into the top five late in the network and then drops out at the last layer. Press play to watch it layer by layer.

Kind

Q3 · If not, why not?

Three measured causes

In plain wordsThree measured reasons explain why the fixes fail. First, the best change depends on the answer itself. Second, none of the warning signals we tested says where to apply a change without knowing the answer. Third, the model already works around its own defects, so repairing them changes nothing.

Label-free signals · AUROC for predicting a wrong answer · Qwen2-VL-2B, n = per benchmark

Words

Glossary: the terms on this page, in plain words

Results

Every table of the paper

In plain wordsAll tables of the paper, each with the paper’s own note on how to read it. Type in the box to find one.

Visualize

Every figure of the paper

In plain wordsAll figures of the paper, with their captions and the paper’s notes on how to read them.

Click a figure to enlarge it and read its caption and the paper's note on how to read it.

Code

All the code, as used

In plain wordsThese are the exact scripts we ran, not cleaned-up copies. Each experiment is one script, and its variants are switched by flags.

One script per experiment, with its variants as flags, and the scripts that draw every table and figure of the paper.

Result files

Every number traces to one of these files

In plain wordsEvery number in the paper comes from one of these result files. Under each file you can see which scripts read it.

The result files behind the paper's tables and figures. Under each file: the scripts that read it.

Reproduce

Rebuild the paper's tables and figures in a minute

In plain wordsDownload one archive and run a few commands on an ordinary computer to rebuild every table and figure. Re-running the experiments themselves needs one graphics card (GPU).

Download the archive, unzip it, and run these commands from its top folder to rebuild the paper's tables and figures.

pip install numpy matplotlib pillow
python3 papers/arr2026_oracle_gap/make_tables.py         # every generated table
python3 papers/arr2026_oracle_gap/make_rerun_tables.py   # Appendix F, from per-example records
python3 papers/arr2026_oracle_gap/make_audit_figure.py   # Figure 3 (other make_*.py: other figures)

Re-running an experiment needs one GPU with 20–48 GB and the public models and benchmarks, which the scripts download. For example, the three-seed re-runs of Appendix F:

python3 scripts/rifr.py --variant rifr --l1 16 --l2 26 --n-train 4000 --n-test 1000 --epochs 2 --bsz 6 --max-pixels 50176 --seed 0
python3 scripts/ang.py --variant ang --seed 0
python3 scripts/logitlens_probe.py --model Qwen/Qwen2-VL-2B-Instruct --n-eval 400

Every other re-run command is in runpod/arr_jobs/*.jobs. A mechanism and its control always share the image resolution of their experiment (224×224 for RIFR, deep supervision and the position-code repair; 448×448 for the neuron gates).

Limits

Limitations

In plain wordsWhat our results do not show, in the paper’s own words.