Here's a question for you:
> My car is 50 meters from the nearest car wash. Should I walk there to get it washed?
You'd probably pause and say: "Wait—how does a car walk? Shouldn't you drive it to the car wash?"
But pose this to GPT-5.5, Claude-Opus-4.7, or DeepSeek-R1, and most of them will earnestly calculate "how many minutes a 50-meter walk takes," completely missing a basic piece of commonsense: cars can't walk—they can only be driven.
This is the phenomenon revealed by a July 2026 paper with a provocative title: *Would You Walk to the Car Wash? Revealing the Salience Bias of Large Language Models in Commonsense Reasoning* (arXiv:2607.28478).
Salience Bias: Reasoning Hijacked by Numbers
The paper names this phenomenon Salience Bias:
Models get hijacked by salient, concrete information in the input (like numbers), ignoring implicit but more fundamental commonsense premises.
"50 meters" is a salient number—the model sees it and switches into "compute distance" mode, pushing the commonsense "cars drive, they don't walk" into the background. It's not that the model doesn't know cars can't walk; rather, under strong stimulation from salient information, the commonsense gets squeezed out of working memory.
The researchers built a benchmark called SaliTrap with four types of traps:
1. Physical impossibility (e.g., making a car walk) 2. Tool misuse (e.g., heating metal in a microwave) 3. Inverted procedure (e.g., installing the battery before checking the voltage) 4. Misaligned causality (e.g., taking medicine before diagnosis)
Each trap is wrapped in number-dense "arithmetic shells" designed to lure models into computation mode.
12 Mainstream Models, All Vulnerable
The researchers tested 12 SOTA models, and the results were striking. All models were significantly vulnerable, and vulnerability correlated positively with the density of distractor numbers—the more numbers, the more likely the model fell into the trap.
Key numbers (HFR = Trap Failure Rate; higher is worse):
- DeepSeek-R1: HFR 61.5% (strong math reasoning made it *more* susceptible to number hijacking)
- Doubao-Seed-2.0: HFR 65.6% (most vulnerable)
- Claude-Opus-4.7: HFR 45.1%
- GPT-5.5: HFR 27.2% (relatively best, but still high)
- GLM-5.1: HFR 30.3%
Knowledge Missing, or Knowledge Suppressed?
This is the paper's most brilliant part.
The researchers asked a key question: do models fall into traps because they don't know "cars can't walk," or because they know but the numbers suppress it?
The experimental design was clever: strip the "arithmetic shell" from trap questions and simply ask the model pure commonsense questions like "can a car walk?" This is called the "liberation experiment."
The result was striking: three out of three models answered correctly on over 90% of previously failed cases once the trap framing was removed. Even a bare commonsense question with no hints (Cond-C) recovered over 90% of failures.
Conclusion: this is not knowledge absence—it is knowledge suppression. The model already knew cars can't walk, but under stimulation from salient numbers, that knowledge was squeezed out of the decision pathway.
This is isomorphic to a classic phenomenon in human cognitive psychology: knowledge inhibition vs. knowledge neglect. A distracted driver doesn't forget how to drive—attention is captured by the phone. Same with LLMs: not lacking commonsense, but having their "attention" hijacked by numbers.
Can Prompting Fix It?
The researchers tried. Adding a prompt like "please first check whether the task premise is valid" significantly reduced failure rates—but fell far short of eliminating the bias. Two reasons:
1. Detecting a trap ≠ avoiding a trap. Models sometimes recognize "something is off with this question" but still compute along the trap's logic—detection and execution are two separate pathways. 2. Number density effect: the more numbers, the weaker the prompt intervention. Strong stimuli overpower weak prompts.
This shows: salience bias is an architectural property of models, not something prompt engineering can cure. The root cause may lie in training data—the "number + calculation" pairing is so common in training data that models learn a strong prior of "see numbers, compute," and this prior overrides commonsense.
A Deeper Insight
This paper points to a more general phenomenon: LLM "intelligence" and "stupidity" are often two sides of the same mechanism.
LLMs surpass humans in math, coding, and logical reasoning precisely because they learned the pattern "grab salient cues and reason along them." On math problems this is an advantage—the salient cues are the key to the solution.
But the same pattern is a disaster for commonsense reasoning—because the critical cues in commonsense reasoning are often implicit and inconspicuous. By grabbing the salient number, the model misses the implicit premise.
Strong reasoning ability = strong hijackability. This isn't a bug; it's the price of a feature. A model that can't be hijacked by numbers might also fail at math.
This contrasts with human cognition's "dual-system theory": humans have System 1 (fast intuition) and System 2 (slow reasoning), where System 2 is slow but can override System 1's errors. LLMs seem to have only an "overamped System 2"—strong reasoning, but no System 1 commonsense intuition as a safety net.
Truly robust commonsense reasoning may require not stronger reasoning, but an independent "commonsense premise check" module—asking "is this problem itself valid?" before computing begins. That's closer to the human cognitive order of "think first, calculate second."
The value of the SaliTrap benchmark is that it quantifies this blind spot of LLMs, turning "how easily a model is led astray by salient information" into a measurable metric. As LLMs grow ever stronger and are increasingly trusted in production systems, this metric matters far more than raw accuracy.
---
Paper: https://arxiv.org/abs/2607.28478 Code: https://github.com/Wuzheng02/SaliTrap