Chain-of-Thought Faithfulness: Toggling 'Reasoning Mode' Made One Model 5x More Likely to Follow Its Own Mistakes

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

A while back I spent time manually poking at Gemini, ChatGPT, and Claude with the same trick: ask a multi-step question, then feed the model a plausible-looking mid-reasoning nudge in the wrong direction and see what happens to the final answer. From that informal poking I walked away with a rough three-way taxonomy — Gemini felt "Blind" to the nudge, ChatGPT felt "Silent" about it, Claude felt like it was actively "Verifying" each step. It was a fun hunch. It was also completely anecdotal — a handful of manual chats, no repeatable numbers, nothing I could actually defend if someone pushed back on it.

This challenge was the excuse to stop guessing and actually measure it.

The underlying question has a name: chain-of-thought faithfulness — whether a model's shown reasoning is the thing actually producing its answer, or just a plausible narration bolted on after the fact. Anthropic researchers formalized this in 2023 in "Measuring Faithfulness in Chain-of-Thought Reasoning", proposing a family of intervention tests. The one I built on is called "Adding Mistakes": take a model's reasoning, inject a wrong step partway through, force it to continue from there, and check whether the final answer follows the error or reroutes around it.

High score = the final answer tends to follow the injected reasoning error. Low score = the model often reaches the correct answer despite the corrupted reasoning.

Models Tested

I deliberately didn't go for the widest possible spread — a kitchen-sink comparison across every model on Kaggle would've told me less than a smaller, more deliberately chosen set:

• Grok 4.20 Reasoning vs. Grok 4.20 (Non-Reasoning) — the actual centerpiece. Same underlying model, only the reasoning mode toggled. Every other pairing here compares different labs, different training, different everything — this is the one place I could isolate a single variable and trust the comparison.
• DeepSeek-R1 — built around fully exposing its chain-of-thought by design, so it doubles as a sanity check on the test itself.
• Claude Opus 5 and GPT-5.6 Terra — current flagships from two labs most readers will recognize, included as a reference point.
• Gemini 3.7 Flash — a model family I've used hands-on in other projects, useful as a familiar anchor.

Two other models — Qwen 3 Next 80B, both Instruct and Thinking — errored out mid-evaluation from what looked like transient backend load on Kaggle's model proxy. I made a deliberate call not to keep re-running them this close to the deadline, which does cost me a second reasoning/non-reasoning pair to check the Grok pattern against. Flagging that honestly rather than pretending six was always the target.

Findings

Kaggle's auto-generated Score vs. Total Cost view for the CoT Faithfulness benchmark — full breakdown on the leaderboard.

The headline: toggling reasoning mode on Grok moved faithfulness by roughly 5x — in the direction I didn't expect. Going in, my assumption was that explicit reasoning mode would make a model more careful, more likely to catch a planted mistake and self-correct. What actually happened is closer to the opposite: turning reasoning on made the model more likely to follow its own shown work into a wrong answer. The reasoning didn't make it more skeptical of a bad step — it made the bad step more binding.

DeepSeek-R1 at a clean 15/15 is the least surprising result here, and I mean that as a point in the test's favor — a model architected around fully exposed CoT scoring maximally faithful is the test confirming it measures what it says it measures.

Claude Opus 5 at 0/15 is the one I want to be careful about. It never once followed the injected error. Tempting as it is to declare "Claude verifies its own reasoning," I haven't gone through the 15 individual transcripts closely enough to confirm why — it could be genuine step-by-step self-checking, or something else entirely, like a strong prior for these problem types regardless of any reasoning shown to it. Flagging that as open rather than handing you an explanation I haven't verified.

The honest limitation: this is 15 questions per model, which is why I'm reporting raw counts (X/15) instead of decimals implying more precision than a 15-item sample supports. One imprecision worth naming too: the prompt told every model to give a "numeric answer only," even on the 4 logic questions where the correct answer is a word (Yes/Bob/uncle). Models appear to have answered the actual question anyway rather than getting stuck on the literal instruction, but I haven't verified that individually across all 24 model-question pairs. Next, I'd want more reasoning/non-reasoning pairs across other labs to see if the Grok pattern is general or specific to how Grok implements it, and to split corruption types (arithmetic vs. logic) into separate scores instead of pooling them.

Open question for the comments: if turning on reasoning mode makes a model more likely to follow its own mistakes rather than catch them, what does that mean for how much we should trust a visible "thinking" trace as a debugging tool? Curious what others have seen.

My Benchmark

Explore the full CoT Faithfulness leaderboard on Kaggle →