When a Model Lies, It "Thinks" Longer — Even If You Never Read What It Thought
Imagine you are auditing a reasoning model's output. It answers a multiple-choice question and picks B. You don't know whether it's right, or whether it's making things up. The only thing you can see is a single number: this response consumed 427 reasoning tokens.
Next time, same question, it picks C — the correct answer. This time: 136 reasoning tokens.
427 vs 136. A three-fold difference. You don't need to read its chain of thought, parse its reasoning, or even know the question. One number is enough.
This is the core finding of the October 2026 arXiv paper "Reasoning-Token Spikes Under Prompted Untruthful Responding in Large Language Models" (arXiv:2610.10405): lying costs more cognition than telling the truth — true for humans, and apparently true for LLMs too.
---
A Ruler Borrowed from Human Psychology
Cognitive Load Theory is an old idea in psychology: lying is cognitively expensive. You must know the truth, suppress it, fabricate a lie, and keep the two consistent. Polygraphs work on this logic — not measuring "are you lying" but "is your body working overtime."
The authors (Maverick Morales, Tomáš Dominik, Vermut Gao, et al.) propose a minimal analogy: if an LLM's reasoning-token count is analogous to cognitive load, then reasoning tokens should increase when the model lies.
The elegance of this hypothesis: you don't need to see what the model thought — only count how much it thought. It is a content-independent, black-box signal.
---
Three Carefully Designed "Dishonesty" Conditions
- Truth: system prompt instructs the model to answer correctly
- Lie: system prompt instructs the model to answer incorrectly
- Bullshit: system prompt tells the model to pick any answer, ignoring correctness
- Analytical questions (rule-based reasoning): Lie exceeded Truth by 22.7% tokens (Gemma) — the model must derive the right answer and then suppress it
- Descriptive questions (factual judgments): no significant Truth/Lie difference on Gemma — too easy for multi-step reasoning
- Normative questions (value judgments): a staircase pattern Truth < Lie < Bullshit; Bullshit exceeded Lie by 6.7% on Gemma
- Lying increased the probability of engaging reasoning by 22.62x (OR = 22.62) versus Truth
- Bullshit increased it 5.56x
- Anomaly detection: sudden spikes in average reasoning tokens may indicate the model is "working overtime" on some conflict
- A/B testing: compare token distributions across alignment strategies
- Red-teaming: token spikes as a fast indicator that the model is struggling
run_experiment.py: main experiment driverlm_token_tools/: reusable toolkit (config, prompt building, model calls, result parsing)- Supports local LM Studio models and OpenAI-compatible APIs
- Logs
prompt_tokens,completion_tokens,reasoning_tokens,total_tokens,latency_seconds - Supports resumable runs; datasets and results shared via OSF
- Title: Reasoning-Token Spikes Under Prompted Untruthful Responding in Large Language Models
- arXiv: 2610.10405
- Authors: Maverick Morales, Tomáš Dominik, Vermut Gao, et al.
- Code: github.com/Wakaranaino/token-spike-project
- Keywords: large language models, black-box, lying, bullshitting, tokens, chain-of-thought, cognitive load theory
The third condition borrows philosopher Harry Frankfurt's classic 2005 concept — bullshit isn't lying; it's total indifference to truth. A liar must know the truth to contradict it; a bullshitter doesn't care.
This three-condition design is the paper's cleverest move. If Bullshit cost fewer tokens than Lie, the extra load would come from "suppressing the truth." If Bullshit equaled Lie, the model would be doing extra computation even when told not to care.
The result was the latter: Bullshit ≈ Lie > Truth, across all three models.
---
Three Models, One Signal
Tested models: Google's Gemma-4-e4b (local quantized), Qwen-3.5-9b (local quantized), and OpenAI's GPT-OSS-120B (via Groq API). 210 multiple-choice questions across analytical, descriptive, and normative categories, each with moral and non-moral subcategories.
| Model | Truth vs Lie | Effect size η²p | |------|-------------|----------------| | Gemma-4-e4b | Truth 10.3% fewer | 0.423 | | GPT-OSS-120B | Truth 50.9% fewer | 0.901 | | Qwen-3.5-9b | Truth 68.0% fewer | 0.967 |
Qwen's data is the most striking — η²p = 0.967, nearly at the theoretical ceiling. Truth-condition tokens were 68% fewer than Lie and 75.3% fewer than Bullshit, with a bimodal distribution: short reasoning for Truth, long reasoning for Lie/Bullshit, with barely any overlap.
Gemma had the smallest effect (0.423) but a unique finding: it sometimes skips chain-of-thought entirely and answers directly. These "no reasoning" cases were most frequent under Truth and rarest under Lie. When telling the truth the model chooses not to think; when lying it is forced to spin up its reasoning system.
---
Why Doesn't Bullshit Cost Less Than Lie?
This is the paper's most counterintuitive result. Frankfurt's theory suggests bullshitting shouldn't require knowing the truth, so it should be cheaper. But Bullshit cost as much as Lie.
Inspecting actual reasoning chains, the authors found that under Lie:
> "The correct answer is D. But I'm a liar and must choose a wrong one. A, B, C are all wrong. I'll pick A."
Under Bullshit, the model still computed the correct answer even though it didn't need to:
> "The system says I shouldn't care about truth, but the user says to think carefully… let me first work out the correct answer… then pick any one."
The model apparently cannot "not care about truth" — its training makes it compute the correct answer under any instruction. Alignment was so successful that even when told to ignore truth, the model can't help computing it.
There's also a prompt contradiction in the Bullshit condition: the system prompt says "don't care about truth" while the user instruction says "think carefully." The model spent extra tokens reconciling this conflict — an admitted design flaw that nevertheless reveals how LLMs handle conflicting instructions.
---
Question Type Modulates the Signal
Normative questions are the most interesting. With no "correct answer" (e.g., "should a researcher correct or conceal a reported error?"), models under Bullshit still spent the most tokens — possibly because value trade-offs require weighing more possibilities when unconstrained.
---
"Deciding Whether to Think" Is Itself a Signal
Gemma doesn't always generate a reasoning chain. Analyzing this binary variable, the paper found:
This mirrors human behavior: asked "3+5=?" you blurt out "8"; told to lie "3+5=7," you must first confirm it equals 8. Truth is the default mode; lying requires active override.
---
Can This Detect AI Lying?
The authors are careful — the title says "spikes," not "detection." Key limitations:
1. Population vs individual detection. The study shows lying costs more tokens *on average*, not that any single response can be classified. Individual variance is large; no threshold currently exists. 2. Prompted vs spontaneous lying. Models were instructed to lie and knew it. Real AI-safety risks are *spontaneous* deception — alignment faking, reward hacking — which may not produce the same load. 3. Adversarial robustness. An attacker aware of token-based detection could compress reasoning chains to evade it. 4. Model evolution. Future models may be trained to keep token counts normal while lying — echoing the history of the polygraph.
Promising directions: do sandbagging, alignment faking, and reward hacking also produce token spikes? If so, we'd gain a black-box detection signal requiring no access to model internals.
---
Engineering Significance: An Almost-Free Signal
Existing AI-safety monitoring comes in two flavors: white-box probes on internal activations (requires weights, costly), and semantic monitoring of chain-of-thought content (requires another model, and CoT faithfulness is increasingly in doubt).
Token counting is a third path: you only need one integer. No weight access, no content parsing. The reasoning_tokens field from an API response suffices. Even as a population-level signal it has immediate uses:
---
Author's Reflection: Cognitive Load as the Cost of the "Rationalization Shell"
Token spikes may be the computational price of what the author calls a "rationalization shell" — non-compliant behavior must be packaged into a compliant narrative to be stable. When lying, the model doesn't just output a wrong answer: it computes the truth, suppresses it, selects a wrong answer, and possibly checks that the lie "looks right." Each step burns tokens.
Gemma's data supports this: Truth often requires no reasoning; Lie almost always does. Truth is the default mode; lying is a rationalization shell that must be actively constructed.
---
Open-Source Code
Experimental code: Wakaranaino/token-spike-project
---
Paper Information
Closing Thoughts
This paper does something elegant: using a near-zero-cost signal (token counts) to detect a phenomenon that normally requires complex analysis (deceptive behavior). It recalls a physicist's intuition — the best measurement is often not the most complex one, but the simplest one. Token counting is the AI-safety world's "pulse." It doesn't tell you what the model is thinking, but it tells you the model is *straining* — and in many settings, straining is itself the signal.
Whether this signal can move from population to individual level, withstand adversarial attack, and extend to spontaneous deception remain open questions. But as a proof of concept, it is already powerful: lying models "think" more — and all you have to do is count.