Have you ever had this experience —
You ask an AI to solve a math problem, and it spits out a wall of derivation steps. The answer looks plausible, but something feels off. Review it carefully, and sure enough: somewhere in the middle the model took a huge detour, then coincidentally arrived at the right answer.
When this happens often enough, you confront an uncomfortable fact: the AI is performing reasoning, not actually reasoning.
This is the core dilemma facing Large Reasoning Models (LRMs). They are trained to think step by step and appear to engage in slow thinking — but whether they are genuinely thinking or just stitching together plausible-sounding steps is something even they can't clarify.
Recently, a paper slipped onto arXiv that did exactly what I'd been waiting for someone to do: give reasoning models a CT scan of their brain.
---
🔍 A Curious Finding: Entropy and Gradients Are Inverted
The story starts with a phenomenon that puzzled researchers for a long time.
When a large language model reasons step by step, each output token carries a degree of certainty or uncertainty. Some tokens the model is very confident about — it emits them almost without hesitation. Other tokens leave the model conflicted, as if betting on several options simultaneously.
Researchers call this degree of uncertainty token entropy — the higher the entropy, the less sure the model is.
Intuitively, where entropy is high, the model should be more 'confused' and gradient changes should be more dramatic. During learning, the things a model is uncertain about are precisely what need adjusting.
But this paper found that in truly strong reasoning models, the situation is reversed —
Where entropy is higher, gradients are smaller; where entropy is lower, gradients are larger.
It's like being in an exam where your brain stays calm on the hardest problems but gets excited over easy gimmes. The researchers named this anomalous pattern Entropy-Gradient Inversion.
More interesting still: the more pronounced the inversion, the stronger the model's reasoning ability.
---
🧠 What Is Slow Thinking Actually Thinking?
To understand why this matters, we need the distinction between fast and slow thinking.
Fast thinking is when an AI sees a problem and jumps straight to an answer — like blurting out "4" when asked "2+2=?". Effortless, no hesitation, but error-prone on complex problems.
Slow thinking is when the AI breaks a problem into steps and 'calculates' each one — like working through a hard math problem with pen and paper, pausing to ask "was the last step right?". Slower, but more accurate.
Large reasoning models are designed for slow thinking. Before emitting a final answer, they generate a Chain-of-Thought showing the reasoning process.
But here's the question: is that chain of thought *real* thinking or *fake* thinking?
Some models genuinely reason, with each step logically connected. Others pile up plausible-sounding filler, using polished language to cover logical gaps.
Entropy-gradient inversion provides a key to telling whether a model is really thinking.
---
📊 A Geometric Fingerprint: How to Tell If an AI Is Faking It
The paper's core contribution is a remarkably clean regularity —
During genuine reasoning, models exhibit a special 'geometric structure':
> Models with stronger reasoning ability accumulate larger gradients when generating high-confidence (low-entropy) tokens, and smaller gradients when generating low-confidence (high-entropy) tokens.
This 'low entropy with high gradient, high entropy with low gradient' pattern appears geometrically as a clear negative correlation.
The authors call this pattern a geometric fingerprint — just as every person has unique fingerprints, models of differing reasoning ability have distinct entropy-gradient profiles.
The stronger the model's reasoning, the more pronounced and stable this inversion becomes.
An analogy: watching someone run. In a professional athlete, breathing, stride, and heart rate form a finely coordinated system; an amateur is all over the place. Entropy-gradient inversion is like a coordination metric for reasoning models — the more coordinated, the more the model is really 'running'; the more chaotic, the more it's just pretending to run.
---
⚙️ A Surgical Intervention: Training Better Models with the Inversion Signal
Discovering the pattern is only step one. The paper's second major contribution is putting it to work in training.
Current reasoning-model training relies mainly on reinforcement learning (RL) with external verifiers — like a teacher judging whether the AI's reasoning is correct. Two problems arise:
First, building external verifiers is extremely expensive. Math problems have standard answers; legal analysis and business decisions don't — who verifies those?
Second, RL training itself is unstable. Reward signals are noisy, and training feels like a rollercoaster.
The paper's new method is called Correlation-Regularized Group Policy Optimization (CorR-PO). The idea is clever —
Instead of relying on an external verifier to judge right and wrong, it uses the strength of entropy-gradient inversion directly as a training signal.
Concretely, CorR-PO adds an extra regularization term during RL training that encourages the model to maintain stronger entropy-gradient inversion while reasoning. This feature doesn't judge correctness, but it reflects whether the model is in a healthy reasoning state.
In other words: instead of grading the AI's answers, keep its running form standard.
---
🏁 Results Speak
The experimental results are quite convincing.
The paper tested CorR-PO on multiple reasoning benchmarks spanning mathematical reasoning, logical reasoning, and code generation. The results:
- Across all tested model scales and task types, CorR-PO consistently outperformed existing SOTA methods
- Models with stronger inversion features showed larger gains after CorR-PO training
- Crucially, models trained with CorR-PO produced chains of thought that were more 'coherent' and 'stable', not just higher answer accuracy
---
🤔 A Deeper Question: Can AI 'Thinking' Be Measured?
This paper raises a more fundamental question: how do we know an AI is really thinking rather than performing thinking?
This matters far beyond academic curiosity. If an AI's 'thought process' is an unmeasurable black box, we can't genuinely improve it — we can only infer backwards from external results, with no idea what's happening inside.
Traditional evaluation looks at input-output pairs: accuracy, answer matching, BLEU scores. But these metrics only capture final results, not the quality of intermediate reasoning. On one math problem, an AI may reach the correct answer through flawed reasoning; on another, flawless reasoning may lead to a wrong answer through a calculation slip. Judging by final answers conflates the two cases.
CorR-PO's approach points to a new direction: evaluate the process, not just the result. By monitoring the model's internal entropy-gradient relationship, we can judge whether the model is in a healthy reasoning state — like medicine looking beyond body temperature to white blood cell counts, CRP, and other process indicators.
Of course, this direction is still early. Entropy-gradient inversion can tell us whether 'reasoning is healthy', but not yet *where* reasoning went wrong. Cracking the reasoning model's black box completely remains a long road.
---
🔮 The First Crack in the Black Box
The rise of large reasoning models has evolved AI from 'able to talk' to 'able to think and calculate'. But beneath the shiny surface, we still know very little about how these models actually work.
We can observe inputs and inspect outputs, but the middle part — how the model derives things step by step, which weights steer the reasoning, why it sometimes gets stuck in a rut — is all a black box.
The discovery of entropy-gradient inversion pries open a small crack in that box.
It tells us: strong reasoning shows not just in correct answers, but in the 'geometric structure' of the thought process itself. Models that truly think have organized, rhythmic thought processes — not a shapeless mush.
It reminds me of a saying: if someone solves problems quickly but with completely chaotic reasoning, we don't call them 'smart' — at best, 'lucky'.
For AI, the standard should be the same.
---
References
1. Yang, J., Qian, C., Wang, K., Zhang, L., Zhang, Q., Liu, Y., & Liu, D. (2026). *Entropy-Gradient Inversion: Moving Toward Internal Mechanism of Large Reasoning Models*. arXiv:2605.17770. 2. Wei, J., et al. (2022). *Chain-of-thought prompting elicits reasoning in large language models*. NeurIPS. 3. Lightman, H., et al. (2023). *Let's verify step by step*. arXiv:2305.20050. 4. Snell, C., et al. (2024). *Scaling LLM test-time compute optimally can be more effective than scaling model parameters*. arXiv:2408.11696. 5. Yao, S., et al. (2023). *React: Synergizing reasoning and acting in language models*. ICLR.