TL;DR
An LLM can give a right-sounding answer built on wrong reasoning — and no check of the final text will catch it. The paper introduces reasoning safety as a separate dimension: can you trust not the answer but the model's line of thought? The authors put together a taxonomy of 9 error types in a chain of reasoning and showed that an ordinary LLM with this taxonomy in its prompt can find and classify such errors better than any specialized tool.
The core LLM weakness: it doesn't "check itself" as it goes. The model generates step by step, and an error in an early step quietly propagates forward. Asking it to explain its reasoning won't help: it will explain what it has already generated. Checking only the final answer won't help either: the answer can be technically correct yet follow from wrong premises. Meanwhile, some errors almost never show up on their own — only when the model is under pressure or confused. That's a useful signal.
The method tackles the problem with a separate audit prompt: the taxonomy of every possible error is baked into it, and the model checks the chain of reasoning step by step — like a judge with a checklist. No code or fine-tuning needed: the prompt works in a regular chat.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
The Error Taxonomy
This is the heart of the method. Remember it — it works as a checklist for any complex task you hand to an LLM.
CATEGORY 1 — Task-parsing errors (before reasoning starts)
1a Misinterpretation → understood the request wrong
1b Missed constraints → ignored the conditions
1c Mapping error → translated concepts into logic incorrectly
CATEGORY 2 — Execution errors (during reasoning)
2a Logical error → wrong conclusion from the premises
2b Calculation error → got the math/formulas wrong
2c Contradiction → steps contradict each other
CATEGORY 3 — Process-control errors (meta level)
3a Looping → going around in circles
3b Goal drift → wandered off onto another topic
3c Premature conclusion → answered without reasoning
⚠️ Category 3 errors almost never occur in normal operation.
If you see looping or a sharp drift from the goal, that's an alarm
signal: the model is either confused or working with
a contradictory prompt.
Method Blueprint
STEP 1: Get the chain of reasoning
Ask the model to answer with detailed reasoning:
"Think out loud, show every step"
→ Chain of steps: [Step 1] → [Step 2] → ... → [Answer]
STEP 2: Run the audit (separate prompt or new chat)
Paste the chain + the audit prompt with the taxonomy
→ For each step: error yes / no, error type
BOTH STEPS — in a regular chat, no code.
STEP 2 can run in the same conversation or a separate one.
Example
Task: You're about to put $50,000 into a friend's small business — a meal-delivery service in Denver. You asked Claude to assess the risks and got a long analysis with reasoning. Before deciding, you want to check whether the model botched the logic anywhere.
Prompt — Step 1 (get the reasoning):
Assess the risks of investing $50,000 in a small meal-delivery service
in Denver. Think out loud — show each step of your reasoning
separately and number them. After the steps, give your final conclusion.
Prompt — Step 2 (audit):
You are a logic auditor. Check the chain of reasoning below.
For each step, determine: is there an error? If so, name its type
from the taxonomy:
CATEGORY 1 — Parsing errors:
1a: Misinterpretation — the model understood the task wrong
1b: Missed constraints — it ignored an important condition
1c: Mapping error — it translated a concept into logic incorrectly
CATEGORY 2 — Execution errors:
2a: Logical error — the conclusion doesn't follow from the premises
2b: Calculation error — a mistake in the math
2c: Contradiction — the step contradicts another step
CATEGORY 3 — Control errors:
3a: Looping — repeats the same thing
3b: Goal drift — wandered off topic
3c: Premature conclusion — an answer without justification
Format for each step:
Step [N]: [ERROR: type + explanation] or [OK]
Then a final verdict: at which step the reasoning broke down
and whether the conclusion can be trusted.
Chain of reasoning:
[paste the reasoning from Step 1]
Result:
The model walks through every step of the reasoning and gives a breakdown — where it's OK, where there's an error and what type. For example, it may find that step 3 left out a caveat about competitors (1b), and that in step 6 the profitability conclusion doesn't follow from the data (2a). At the end — a verdict: trust the conclusion or not, and why.
Why It Works
An LLM generates text sequentially, moving forward — each new token builds on the previous ones. If an error creeps into step 2, steps 3, 4 and 5 will consistently build on it. By the time you reach the final answer, the error is already "buried" under several layers of plausible text. Checking the answer means looking at the tip of the iceberg.
The good news: LLMs know how to classify text into given categories. They do this very well. When the error taxonomy is built into the prompt and the task is framed as "find the match," the model works like an experienced editor with a checklist — it checks rather than generates.
The third pattern is the key one in practice: category 3 errors (looping, goal drift) almost never happen without a reason. If you see them in the reasoning, it's a sign the task was worded in a contradictory way, or the model was working with conflicting instructions. Rewrite the prompt.
Control knobs: - Taxonomy detail → the more thoroughly the error types are described, the more accurate the audit - Alarm threshold → you can ask it to "flag only category 2-3 errors, ignore minor inaccuracies" — for a quick pass - Output format → ask for "only the steps with errors" instead of a full breakdown — shorter and faster - Chain in one conversation → ask the model to reason first and then immediately check itself against the taxonomy — one request instead of two
Prompt Template
You are a logic auditor. Check the chain of reasoning against the taxonomy.
ERROR TAXONOMY:
[Category 1 — Task parsing]
1a Misinterpretation: understood the task wrong
1b Missed constraints: ignored a condition from {task}
1c Mapping error: translated a concept into logic incorrectly
[Category 2 — Execution]
2a Logical error: the conclusion doesn't follow from the premises
2b Calculation error: a mistake in the math or formulas
2c Contradiction: this step contradicts another step in the chain
[Category 3 — Process control]
3a Looping: repeats what's already been said without progress
3b Goal drift: the reasoning wandered away from {task}
3c Premature conclusion: an answer given without sufficient justification
RULES:
- Evaluate each step independently
- Take the context of previous steps into account
- Don't count exploring hypotheses or weighing options as an error
- Flag an error only if it genuinely breaks the logic
ANSWER FORMAT:
Step [N]: [OK] or [ERROR — type: explanation]
...
SUMMARY: [Chain is reliable / Broke down at step N / Needs checking]
CHAIN OF REASONING:
{reasoning_chain}
Placeholders:
- {task} — a short description of the original task (2-5 words): "investment risk assessment", "legal contract analysis"
- {reasoning_chain} — dump the full text of the reasoning from the first request here
🚀 Quick start — paste into the chat:
Here is the Reasoning Safety Monitor template for auditing LLM reasoning.
Adapt it to my task: {describe the task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what task you gave the model and which reasoning you want to check — because it needs the task context to calibrate category 1 errors properly (misinterpretation is relative to the original question). It will take the taxonomy structure and tailor it to your case.
Limitations
⚠️ Subjective tasks: The taxonomy works well wherever there's a logical structure — analysis, calculations, legal questions, planning. For creative tasks without a clear correctness criterion (write a poem, come up with a name) it barely applies.
⚠️ An audit doesn't guarantee correctness: The model may miss an error it made itself. The authors acknowledge this. The audit lowers the risk but doesn't eliminate it. A human second look at important decisions is still a must.
⚠️ Short answers: The method only works when the reasoning is detailed and visible. If the model answered without steps, there's nothing to check. Ask it to "think out loud" first.
⚠️ Deeply buried errors: If the error happens at the very first step (misinterpreting the task), all the following steps may be internally logical — and the auditor will miss the systemic failure, seeing only correct steps.
Resources
Paper: Beyond Content Safety: Real-Time Monitoring for Reasoning Vulnerabilities in Large Language Models
Authors: Xunguang Wang, Yuguang Zhou, Qingyue Wang, Zongjie Li, Ruixuan Huang, Zhenlan Ji, Pingchuan Ma, Shuai Wang (corresponding)
Institutions: The Hong Kong University of Science and Technology (HKUST), Zhejiang University of Technology
Related work cited in the paper: BadChain, OverThink (DoS attacks on reasoning), ProcessBench (a benchmark for evaluating step-by-step reasoning), SelfCheckGPT (the hallucination detector used for comparison)