Safe Error Correction for Language Models: Frozen-Base Adjustment with Capability Preservation
Gautam Kishore
Eulogik
Published September 14, 2026 · on the feed September 29, 2026 · ▲ 2 · arXiv 2609.16145
The abstract
We study a practical question: can a small correction module fix errors in a frozen language model's outputs without degrading its base capabilities? We propose CRN v2, a lightweight logit-level correction module (~34M trainable parameters, 0.73% of the 4.65B text module) that sits atop a fully frozen Gemma 4 E2B model. The base model is never updated; only the correction module learns, via supervised fine-tuning followed by reference-free DPO on 83,400 error-correction pairs. On a 60-question domain exam (CEHRI: Certified Human-Robot Intelligence, covering facts, arithmetic, and implicit-goal reasoning), CRN v2 corrects 53.3% of base-model errors (reworded variant: 43.3%) while showing no degradation on tested capability benchmarks (MMLU/BoolQ N=200; car-wash N=8). A LoRA baseline at the matched CRN v1 budget (6.6M params, rank 19) achieves 83.3% correction but suffers 30-75% capability loss on the same benchmarks -- the correction-capability tradeoff. An ablation shows that the KL preservation term (lambda=0.1) is critical: lowering it to 0.01 degrades correction to 35.0%. A hidden-state injection variant at earlier layers (1.6M params, SFT-only) reaches 50.0%/55.8% but does not exceed logit correction; shallower injection (layer 4) drops to 30.0%/28.3%; multi-depth logit correction (~35M) reaches only 40%; and longer training (5,000 SFT + 2,000 DPO) stays at 53.3% -- none of the alternative configurations we tested exceeded the rank-128 logit result, consistent with a best-achieved result of ~53% rather than a floor. This is a study of a design principle (frozen base + logit correction + KL anchoring), not a claim of architectural novelty. All code, main-result weights, and evaluation scripts are released (deep variant as code only -- no trained deep checkpoints).
The Brief
3:03A short podcast summary of the paper. Written and voiced by AI.
Transcript
Safe Error Correction for Language Models. Frozen-Base Adjustment with Capability Preservation. By Gautam Kishore, from Eulogik. Published on the fourteenth of September. Its code repository is worked out: about eighty source files, with a readme and a licence.
The question here is practical. Can a small correction module fix the errors a frozen language model makes, without degrading what the model could already do? The paper's answer is a design principle rather than a new architecture, and it says so plainly. Keep the base model frozen. Correct its outputs at the level of the logits. And anchor the correction with a KL preservation term. The vehicle is CRN v2, a lightweight module of about thirty-four million trainable parameters, which is zero point seven three percent of the four point six five billion parameter text module it sits on top of. That base is a fully frozen Gemma 4 E2B model, and it is never updated.
Only the correction module learns. It is trained with supervised fine-tuning and then reference-free DPO, on eighty-three thousand four hundred error-correction pairs. The test is a sixty-question domain exam called CEHRI, short for Certified Human-Robot Intelligence, which covers facts, arithmetic and implicit-goal reasoning. CRN v2 corrects fifty-three point three percent of the base model's errors, and forty-three point three percent on a reworded variant of the exam. On the capability benchmarks tested, MMLU, BoolQ and a small car-wash set, it shows no degradation.
The contrast is a LoRA baseline given the budget of the earlier CRN v1, six point six million parameters at rank nineteen. It corrects more, eighty-three point three percent, but loses between thirty and seventy-five percent of its capability on the same benchmarks. That gap is what the paper calls the correction-capability tradeoff. An ablation shows the KL term matters: with its weight at zero point one things work, and lowering it to zero point zero one drops correction to thirty-five percent.
The author is careful about what the fifty-three percent means. Every alternative tried fell short of it. Injecting into hidden states at earlier layers, with one point six million parameters and supervised training only, reported fifty percent and fifty-five point eight percent, but did not beat logit correction. Injecting shallower, at layer four, fell to thirty percent and twenty-eight point three percent. Correcting logits at multiple depths reached only forty percent, and longer training stayed at fifty-three point three. Since none of these exceeded the rank one hundred twenty-eight logit result, the paper frames that figure as the best it achieved, not as a floor. The capability checks are also small: two hundred items for MMLU and BoolQ, and eight for the car-wash set. Code, the main-result weights and evaluation scripts are released, with the deeper variant shared as code only.
Stripped down, the claim is about where to intervene. Leave the model alone, adjust only what comes out of it, and tether that adjustment to the original behaviour. On this exam, that bought roughly half the errors back with nothing measurable lost, while a comparable LoRA bought more corrections by giving up the model's broader competence.
Paper Quest · 7 chapters · about 39 min
Play this paper
Learn it by doing: make the calls the authors made, guess the result before you see it, and defend it in a viva graded on your own words. Chapter 1 is right here.
Chapter 1 🧩 · The problem
Every deployed model makes mistakes. The hard part is fixing them without breaking everything else.
You run a language model in deployment, and it makes errors: wrong facts, flawed reasoning, bad suggestions. Those errors must be caught and fixed without breaking what the model already does well.
The road ahead
- 1 · The problem ~6 min A deployed language model makes errors, and fixing them by retraining the model tends to break skills it already had.
- 2 · What came before ~3 min
- 3 · The key idea ~8 min Freeze the base model, add a small module that corrects its output logits, and anchor that correction to the base with a KL penalty.
- 4 · Choose your own research ~3 min
- 5 · Build the method ~8 min Freeze Gemma, attach a small logit correction module, teach it with supervised fine-tuning under a KL anchor, then sharpen it with reference-free DPO.
- 6 · The experiment ~6 min You’ll guess: Without ever updating a frozen Gemma base model, what share of a 60-question domain exam did it answer correctly with the small CRN v2 logit correction module?
- 7 · The viva ~5 min Three questions from the examiners, answered in your own words. Win it for the paper’s trophy.
Free, with Google or an email address. Your stars and progress are kept.