Real web agents fail in a very specific way: they click buttons that do not exist on the page.
The authors, from George Mason University and Tel Aviv University, collected interaction trajectories on live websites using Online-Mind2Web. They restricted the action space to four verbs, CLICK, SCROLL, TYPE and HOVER, following the original Mind2Web setup, generated a list of candidate actions from each page, and asked the model to pick from that list. The model under test was Qwen2.5-7B-Instruct. The final dataset consists of 300 episodes and 2,071 actions, of which 32.6% are hallucinated, meaning the action the model generated does not appear in the list at all.
A typical example: the task is to find a 2022 Tesla Model 3 on CarMax. The model emits a TYPE action meant to fill in a search box, but its selector value does not correspond to any element on the current page. Logit lens analysis shows that these hallucinations mostly come from the model locking onto a strategy. Actions such as Search, Explore or Find do not exist on the page, yet the model generated syntactically well-formed actions referencing these fictional elements.
A probe can raise the alarm before the action is written
The paper trains linear probes independently at three positions of the residual stream: prompt_end, the point before the model emits a single token; selector_start; and selector_value_start. The split is episode-level at 70/15/15, yielding 1,433 training actions, 282 development actions and 356 test actions.
The probe at prompt_end reaches a test AUC of 0.80 at layer 18. Put differently: a linear direction can already tell apart cases that will go wrong before the action is written. The signal only strengthens further along. At selector_value_start it is already clear from layer 0 and keeps improving.
Intervention works, explanation does not
Representation steering along the probe direction produces excellent numbers. At alpha=40 it fixes 85.4% of hallucinations while disrupting 7.0% of valid actions, and the most effective vector comes from L17 at the selector_start position.
But when the authors turn to explanation, the conclusion flips. Prior work on RAG hallucination, the ReDeEP line of research, found that hallucinations in the residual stream are often attributable to FFN contributions overshadowing attention head outputs. The paper therefore amplifies each layer's FFN contribution by 10x one at a time, injects Gaussian noise into individual attention heads, and then runs joint interventions.
The best configuration amplifies all attention heads at layer 22 while halving FFN contributions at layers 22 through 24, fixing 8.9% while corrupting 2.4%. Adding layer 27 attention heads drops the fix rate to 5.9% while the break rate jumps to 27.6%. More awkwardly, the hallucinations induced by isolated intervention look nothing like natural ones. Amplifying the FFN at layer 15 rewrites a legitimate selector value into syntactically invalid garbage such as VAR-1000000000, rather than the orderly hallucination of referencing an element the page does not have.
The activation patching result is more nuanced. The action list is indeed a causal contributor: restoring a clean state at layer 27 recovers 0.36 of the corrupted probability mass, while the corresponding figures for selector start and the task description both stay below 0.02. But knowing that the action list matters does not tell you which part of it drives the model to change its mind. The authors conclude that the computation here is spread across multiple components and positions, and single-point attribution cannot handle it.
Change the format and the whole thing falls apart
The most telling comparison sits in the appendix. Keeping the same steering vector and changing only the prompt format, so the candidate action list goes from a JSON array to a numbered markdown list, degrades the result immediately:
- At alpha=10: the fix rate falls from 43.9% to 19.4%
- At alpha=20: 75.6% falls to 41.9%
- At alpha=40: 85.4% falls to 58.1%, roughly 27 percentage points
The break rate barely moves, sitting at 7.0% on both sides at alpha=40. The authors read this as the direction being entangled with action format rather than with the hallucination direction itself.
Three assumptions of MI break down here
The paper attributes this to the fact that the assumptions standard MI methods rely on do not hold in agentic settings.
The first is localizability, the assumption that a small set of components explains most of the behavior. Here the computation is distributed, and single-component interventions barely move it. The second is stationarity. Activation patching needs a clean baseline, but an agent changes the page and grows its context at every step, so no two steps share a comparable baseline. The paper tries to construct paired counterfactuals by removing the selected valid action to force a hallucination, and only 38% of cases actually produce one, with the trajectory diverging within a single step. The third is temporal locality. A decision is supposed to live at one timestep, but here it is already forming in the residual stream before generation begins and strengthens progressively.
Pretrained SAEs do not help either. The BatchTopK SAE for Qwen2.5-7B-Instruct has a dictionary of 131,072 features with a sparsity of k=64 active features per token, and it was applied at layer 27, the layer with the highest causal recovery in the activation patching results. The features that most strongly separate hallucinated from valid cases promote tokens largely unrelated to the observed hallucination behavior. The paper lists the absence of MI benchmarks for agent applications as the first item on its roadmap, one reason being that nobody agrees on what counts as a faithful, complete and actionable explanation.
Two independent corroborations
The first is arXiv:2509.18970, an independent survey of hallucinations in LLM-based agents. It taxonomises agent hallucinations by the different stages of the agent workflow and examines eighteen triggering causes. A different team working from the taxonomy side arrives at the same picture as the main paper's observations: agent hallucination is a category of problem distinct from ordinary LLM hallucination, and it deserves a benchmark of its own (https://arxiv.org/abs/2509.18970).
The second is arXiv:2603.28744, work by Barin-Pacela and colleagues published at UAI 2026 (PMLR 337:364-412), titled Stop Probing, Start Coding. Through controlled experiments they decompose SAE failures under compositional distribution shift and conclude that the bottleneck is dictionary learning rather than the inference procedure. The two teams use entirely different methods but point at the same regularity: directions found by linear probes and SAEs drift along with the surface form of the input (https://arxiv.org/abs/2603.28744).
Where I come out
My read is that the value of this paper lies in how honest the result is, and in how directly the conclusion constrains engineering practice.
Start with what is easiest to misread. An AUC of 0.80 and an 85.4% fix rate look like interpretability has already learned to repair agents. But that fix rate is sensitive to prompt format: change how the action list is written and the guardrail loses close to thirty percent of its capability. And in a real system, changing the prompt format costs almost nothing. Adding a few few-shot lines, reordering the candidate list, swapping JSON for a table, any of these can shift it by accident. So the more reliable use for this probe is as an observer raising alarms, not as an automatic corrector rewriting outputs.
On methodology: an AUC of 0.80 does show that a linearly separable direction meaning the model is preparing to act this way exists internally, but separability is not mechanism. What is sharp about this paper is that it refuses to treat separability as mechanism discovery, and instead puts the fact on the table: the same direction loses its effect once the format changes, which is a warning that many directions treated as mechanisms may just have learned surface format.
That is why the roadmap items, retraining SAEs on agent trajectories, tracking across timesteps when the model commits to a strategy, and building MI benchmarks for agents, are not the kind of grand finale researchers like to write. They are patches squeezed out of this list of failures.
Agent failures are rarely one line of code written wrong. Far more often they look like this: over dozens of steps, the agent slowly decides to do something that does not exist on the page. If interpretability only explains things after they go wrong, then for the step that has not gone wrong yet, it is still a black box.