Qwen3.5-4B: Can the Model Localize Its Own Errors in Multi-Step Reasoning?
The one idea you need
Picture reciting a memorized phone number: your voice naturally steadies as you get going, but wavers exactly on the digit you misremember. Correct for that natural steadying, and the leftover waver pinpoints the wrong digit. That waver is the model's confidence dip.
The question
When a small model makes a mistake partway through a multi-step calculation, can its own confidence tell you exactly which step first went wrong?
What we found
Yes, and the dip lands on the exact step, not just late in the chain. Confidence naturally climbs the deeper the model goes, so "least sure" could just mean "last step." Correcting for that, the least-confident step is the true first slip 56% of the time, versus 36% for guessing the usual trouble spot and 19% for blind chance. When it slips several times, though, only 27%.
Why it matters
Log how confidently your small model commits to each reasoning step. When an answer has one error, redo from its least-confident step: cheaper than restarting and just as effective. Don't trust the signal when several steps look shaky.
On this page
Results at a glance 2
How to read
The horizontal axis is each step's distance from the first error: negative before it, zero the error itself, positive after. The vertical axis is confidence with the natural climb-with-position removed; lower means less sure.
Takeaway → The line sits high two steps before the slip, plunges to its lowest point precisely at the first error, then recovers: the dip marks the origin, not just late steps.
Data table
| step offset from first error | mean de-trended confidence (residual) vs step-offset from the first error |
|---|---|
| -2 | 0.227 |
| -1 | 0.063 |
| 0 | -0.146 |
| 1 | -0.049 |
| 2 | -0.084 |
| 3 | -0.005 |
| 4 | -0.024 |
| 5 | -0.031 |
| 6 | 0.017 |
Numbers from
Technical framing
The confidence dip marks the error origin: de-trended confidence is minimized exactly AT the first slip (offset 0) — Extends C40 (single-step metacognition) to MULTI-step: does per-step confidence show WHERE the model first slips? The model advances k steps in a cyclic order over depth-4-7 chains via scaffolded decoding (force 'Step i: <digit>', read the digit distribution at each step). Because confidence RISES with step position (a confound), we DE-TREND (subtract the per-position mean) and plot the residual against the offset from the model's first slip. The dip is EXACTLY at the origin: mean residual confidence is high just before the error (+0.23 at offset -2), plunges to its minimum AT the first error (-0.15 at offset 0), and recovers afterward. So the confidence dip marks the ORIGIN of the error, not merely late positions -- genuine, position-controlled localization. Per-step error prediction also survives de-trending (AUROC 0.75 vs 0.73 raw).
How to read
Each bar is one way to guess which step is the first slip on single-error chains; bar height is how often it's right, so taller is better. Confidence-based methods sit beside guessing-by-position, always-guess-last, and blind chance.
Takeaway → The two confidence bars (56% and 64%) tower over guessing by position (36%) and chance (19%), while always-last is near zero: confidence carries real information about where the error is.
Data table
| condition | localization accuracy = argmin-confidence step is the first slip (single-slip chains, n=137) |
|---|---|
| de-trended residual | 56% |
| raw confidence | 64% |
| position prior | 36% |
| always last | 1% |
| uniform 1/D | 19% |
Numbers from
Technical framing
Localizing the slip (single-slip chains): de-trended confidence beats position baselines -- deployable targeted repair — On single-slip chains (exactly one error = one well-posed origin, n=137), does the lowest-confidence step pinpoint the slip? The position-controlled DE-TRENDED confidence localizes it at 0.56 (raw confidence 0.64), ~3x the uniform 1/depth baseline (0.19) and clearly beating a position-prior baseline (guess the highest-error position, 0.36) and always-guess-last-step (0.01). So confidence carries genuine WHERE-information beyond position. Deployable: redo the chain from the located step (oracle-downstream) fixes 56% of single-slip chains at avg 3.8 steps vs 5.6 for redo-all -- cheaper targeted repair. Caveat: on MULTI-slip chains (n=224) the argmin finds AN error 76% of the time but the FIRST only 27% (several low-confidence steps compete), so the clean single-origin/repair story holds when the model slips once.
In the author’s words from the Overview · “Results”
Per-step error prediction survives de-trending (AUROC 0.75 vs 0.73). The de-trended confidence dips EXACTLY at the first error (offset 0). Single-slip localization 0.56 (raw 0.64) >> position-prior 0.36 >> uniform 0.19. Targeted repair (redo from located step) fixes 0.56 at 3.8 steps vs redo-all 5.6. Caveat: multi-slip chains -- finds AN error 0.76 but the FIRST 0.27. See reports/report.md, analysis/error_localization.png.
Overview
Research Program
- Program:
benchmark_generalization - Question: extends C40 (single-step metacognition) to multi-step. Does per-step confidence pinpoint WHERE the model first slips?
Setup
- Model advances k steps in a cyclic order over depth-4-7 chains via SCAFFOLDED decoding (force 'Step i: <digit>', read the digit distribution at each step = live per-step confidence). Ground truth = local correctness (m_i == successor of the model's OWN previous step). Familiar (natural) order -> genuine arithmetic slips ~31%/step. Make-or-break control: DE-TREND (confidence rises with position). Baselines: uniform, always-last, position-prior.
Run
python scripts/eval_localize.py --n-per-cond 150 then python scripts/analyze.py.
Results
Per-step error prediction survives de-trending (AUROC 0.75 vs 0.73). The de-trended confidence dips EXACTLY at the first error (offset 0). Single-slip localization 0.56 (raw 0.64) >> position-prior 0.36 >> uniform 0.19. Targeted repair (redo from located step) fixes 0.56 at 3.8 steps vs redo-all 5.6. Caveat: multi-slip chains -- finds AN error 0.76 but the FIRST 0.27. See reports/report.md, analysis/error_localization.png.
Interpretation
C40's implicit metacognition is STEP-RESOLVED: per-step confidence carries WHERE the model slipped. Deployable targeted repair; strongest when the model slips once.
Knowledgebase Update
- Claim ledger: C42
Artifacts
scripts/chain_family.py,scripts/eval_localize.py(scaffolded decoding + per-step confidence),scripts/analyze.pyruns/localize.json,runs/verdict.json,analysis/error_localization.png,reports/{report,design_review}.md
Report
Rendered from reports/report.md
Motivation
C40 showed single-step implicit metacognition (answer-token probability predicts correctness). This asks whether that signal is step-resolved: on a multi-step chain, does per-step confidence drop at the step where the model first goes wrong — enabling deployable error localization and targeted repair?
Method (review-hardened)
The model advances k steps in a cyclic order over depth-4–7 chains, via scaffolded decoding: force the Step i: <digit> format and read the digit distribution at each step (genuine live per-step commitment confidence; no prose, no truncation, exact position alignment). Ground truth = local correctness (m_i == successor of the model's own previous output m_{i-1}), so a local error is a genuine slip and the first local error is the origin. Familiar (natural) order — the model applies +k but slips (~31%/step, genuine arithmetic errors). Novel/reversal orders were dropped: forced-scaffold makes the model apply a systematic wrong rule (no single origin — the review's failure case).
The make-or-break control — de-trending: confidence rises with step position (0.66→0.96), so a naive "lowest-confidence = error" could just track position. We subtract the per-position mean and require localization to survive on the residual, plus baselines: uniform 1/D, always-last-step, position-prior.
Results (600 chains)
- Per-step error prediction survives de-trending: AUROC 0.75 (de-trended) vs 0.73 (raw) — not a position artifact.
- The dip marks the origin: mean de-trended confidence by offset-from-first-error is minimized exactly at offset 0 (−0.15), high just before (+0.23 at −2), recovering after.
- Localization (single-slip chains, n=137, well-posed):
| method | localization accuracy |
|---|---|
| de-trended residual (position-controlled) | 0.56 |
| raw confidence | 0.64 |
| position-prior baseline | 0.36 |
| always-last | 0.01 |
| uniform 1/D | 0.19 |
- Targeted repair (oracle-downstream, redo from located step): fixes 0.56 of single-slip chains at avg 3.8 steps vs 5.6 for redo-all — cheaper.
Conclusion
The model's per-step confidence is step-resolved: it carries where it slipped, not just that it did. C40's implicit metacognition composes over multi-step reasoning and enables deployable targeted repair.
Honest caveats
- Multi-slip chains (n=224): the argmin finds an error 0.76 of the time but the first only 0.27 (several low-confidence steps compete) — localization is strongest when the model slips once (38% of error-chains).
- Execute-mode arithmetic slips (familiar order); forced-scaffold competence is lower than free-form (the scaffold strips reasoning) — this is deliberate, to produce genuine per-step slips. Single seed.
Artifact Manifest
See reports/artifact_manifest.yaml.
Experiment log 1
Show the running log (1 entry)
Scaffold
Created as a new experiment scaffold.
Figures 1
Reproduce
Smoke test
python scripts/eval_localize.py --n-per-cond 25Full run
eval_localize.py --n-per-cond 150; analyze.pyRun steps are documented inside the experiment folder (README and scripts).