{"id":"c280ce7f-cbfa-4122-aa17-79eb33db07e5","arxiv_id":"2412.16653","paper_version":1,"verdict":"REJECT","confidence":"HIGH","novelty_score":3.0,"correctness_risk":"high","formal_verification":"none","parameter_count":1,"one_line_summary":"Training LLMs with injected errors followed by correction tags aims to teach the model to self-correct at inference, demonstrated on a single arithmetic conversion example.","lead":"This paper proposes Internalized Self-Correction (InSeC), a training method that injects mistakes and their corrections into LLM fine-tuning data so the model learns to correct itself at inference. The evidence is one anecdotal arithmetic example; no quantitative evaluation is provided.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The experiment only shows correction of an error already present in the prompt, not of an error the model itself generates; the central claim of internalized self-correction is therefore untested and unsupported.","rationale":"The reader's weakest_assumption pinpoints exactly the same gap, and I agree. The paper's proposed mechanism—negative sampling in training—is a conditional repair mechanism for errors in the input context. The transition to 'self-correction' requires an additional assumption: that the model treats its own sampled tokens as context to be monitored. The training data never contains a model-generated error being corrected; it contains a human-authored or template error followed by a correction. Under standard next-token training, the model learns to map (context-with-error) -> (correction). It does not learn to map (its own draft) -> (error detection) because that mapping is not in the data. The one example in Section 6 operates in the first mode: the error is in the prompt. Even if we accept that example as genuine, it only establishes that the model can copy a correction pattern when it sees an error. It does not establish spontaneous self-correction. Because the abstract and contributions explicitly claim the latter, this is a load-bearing failure of evidence, not merely a stylistic issue. I also note the absence of quantitative evaluation, code, and baselines, but those are secondary; a single compelling demonstration might be enough if it tested the right phenomenon. This one tests a different phenomenon. Thus the reader's REJECT verdict stands. No verdict adjustment is needed.","tokens_in":3199,"tokens_out":4405,"duration_ms":36872,"concrete_test":"Fine-tune Llama-3.1-8B with the InSeC protocol of Section 5, then evaluate on 100 previously unseen arithmetic/conversion problems where no error is injected into the prompt. Use both greedy and temperature=0.7 decoding. For each output, detect whether the model emits a self-correction tag (e.g., '<Found a mistake...>') after an erroneous step that it itself generated, and whether the final answer changes from incorrect to correct. Compare the self-correction rate against the fine-tuned without-negative-samples baseline. If the InSeC model does not show a significantly higher rate of correcting its own mistakes, the central generalization claim is falsified.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim of InSeC is that a model trained with injected errors and correction tags will 'correct themselves' at inference. The only experiment (Section 6, Listings 3-5) does not test this claim. In the test prompt, the erroneous statement ('There are 50 minutes in 1 hour') is already present in the input prefix; the model is not generating the mistake, it is responding to a mistake supplied by the user. The training scheme in Section 5 reinforces this pattern: negative samples are placed in the input context, and the model learns to output a correction tag after seeing an incorrect sentence. Under this training distribution, the model learns a contextual repair behavior: if a false statement appears in the context, emit a correction. It never learns to detect a false statement that it itself has just produced, because such self-generated errors are never paired with correction tags in training. For 'internalized self-correction' to work, the model would need to monitor its own output autoregressively, notice an error it generated, and correct it. The paper provides no evidence for that capability. The single example is also not quantitative: no error rates, no number of trials, no baseline with the same test distribution. Therefore the load-bearing assumption—that contextual correction of injected errors transfers to self-correction of the model's own generated errors—is both untested and unargued.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes 'Internalized Self-Correction' (InSeC), a training strategy in which approximately 15% of sentences in a fine-tuning corpus are replaced with incorrect sentences followed by special correction tags and reasons, with the model learning to emit corrections alongside its normal continuation. The authors fine-tune Llama-3.1-8B on synthetic chain-of-thought data with and without these negative samples and report, via a single qualitative continuation example, that the model trained with negative samples corrects an erroneous conversion factor in a test prompt while the model trained without negative samples does not. The paper argues that this internalizes self-correction and can generalize to hallucinations and instruction following.","tokens_in":3461,"tokens_out":3509,"duration_ms":28931,"significance":"If the central claim were established—that a model can learn from injected errors to spontaneously detect and correct errors that it itself generates at inference—the approach would offer an inexpensive complement to inference-time reflection methods. The idea of converting self-correction into supervised negative-sample training is plausible and worth exploring. The manuscript offers no data, no code, no quantitative results, and no controlled experiments, so its current contribution is a plausible hypothesis with a single illustrative example. The qualitative example does demonstrate that fine-tuning with correction tags can induce a model to repair an error explicitly present in the prompt, which is a modest and credible baseline behavior.","major_comments":[{"comment":"The sole experimental evidence is one hand-picked continuation. There is no test set, no accuracy or error metric, no number of independent runs, no sampling temperature details, and no analysis of failure cases. The abstract and conclusion generalize far beyond this single example.","section":"Section 6, Listings 3-5"},{"comment":"The error in the test prompt is already present in the input context (the assertion \"There are 50 minutes in 1 hour\" is supplied as the last line of the prefix). The training scheme in Section 5 also injects errors into the input context. Thus the model learns and is tested on contextual repair of externally provided errors; the paper never tests whether the model detects and corrects an error in text it generates itself. This is the load-bearing gap between the experiment and the claim of \"internalized\" self-correction.","section":"Section 6, test prompt design"},{"comment":"The training examples are not clean controls. Listing 1 contains the same wrong substitution (length = 6 cm) as Listing 2 but without a correction tag, and the positive example also contains two consecutive \"2.\" steps. This means the two fine-tuning conditions differ not only in the presence of negative samples but also in the quality of the positive data. The comparison therefore cannot be attributed solely to negative sampling.","section":"Section 5, Listings 1 and 2"},{"comment":"The 15% negative-sample rate is a free parameter with no sensitivity analysis. There is no evidence that this rate is appropriate, nor any study of what happens with different rates. The paper also does not specify hyperparameters for fine-tuning (learning rate, epochs, hardware), which is necessary given the qualitative nature of the results.","section":"Section 5, negative-sample rate"}],"minor_comments":[{"comment":"The abstract contains a stray space in \"self-reflect ion\" and other typos throughout (e.g., inconsistent spacing around citations), which detract from readability.","section":"Abstract"},{"comment":"The paper calls Listing 3 a \"test set\" but it contains a single prompt; this wording is misleading.","section":"Section 6, Listing 3"},{"comment":"The listed challenges (e.g., \"Selecting Informative Negative Samples\") are not linked to any proposed remedy or experiment, so they read as caveats rather than an engaged discussion.","section":"Section 8"},{"comment":"The related-work section considers only three preprints and omits the substantial literature on LLM self-correction and self-refinement, which weakens the positioning of the contribution.","section":"Section 3"}],"recommendation":"reject","confidential_remarks":"The manuscript is a five-page extended abstract with a single qualitative example. Its contribution is an idea rather than a validated method. Even if the authors add more examples, the current evidence would not convince a careful reader that the trained model can self-correct its own generations; a proper evaluation would require a new experimental setup. The paper might be more appropriate for a workshop or a position-paper venue. I would encourage the authors to run a systematic study with quantitative metrics on a diverse set of tasks and to test self-correction of model-generated errors."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take: the idea is easy to state—inject fake errors and correction tags into SFT data—and the paper shows one example where a fine-tuned model repairs a wrong conversion factor. That example is real, and the transparency is nice. But the demonstration is one qualitative example, and it tests the wrong thing: the error is already in the prompt, so the model is doing contextual repair, which is exactly what it was trained to do. The paper never shows the model catching a mistake it generated itself. That's the load-bearing claim of 'internalized self-correction,' and it's unaddressed.\n\nWhat's actually new? The specific combination of negative sampling with inline correction tags and a special token is a minor variant of existing ideas (RLRF, negative sampling), but I don't think any of the cited papers do exactly this. The writing is clear and the method is easy to implement. The single example at least shows the behavior exists in principle.\n\nThe soft spots are severe, though. The evaluation is one cherry-picked continuation. No test set, no accuracy, no multiple runs, no ablations beyond one without-negative-samples model. The test prompt's error is supplied by the user, not generated by the model. The training scheme in Section 5 only inserts incorrect sentences in the input context. So the model learns 'if you see a false statement, emit a correction tag.' It never learns to detect a false statement it just produced. The paper's own 'Challenges' section is generic and doesn't mention this gap. The abstract and conclusion overclaim, saying InSeC 'allows LLMs to correct themselves' and 'correct hallucinations or incorrect sentences generated by LLMs.' That's not demonstrated.\n\nOverall: this is a speculation with an anecdote. The idea is worth a small experiment—train with self-generated errors and see if the model corrects its own chain-of-thought—but as it stands the central claim is untested. I would not send this to a serious referee. A constructive desk reject with a pointer to what evaluation would be needed is the right call. If the authors come back with a proper setup (model-generated errors, held-out distribution, quantitative metrics), it could be a workshop-level contribution.","headline":"A clear but tiny idea with one illustrative example that doesn't actually test the 'self-correction' claim; interesting as a note, not as a research paper.","tokens_in":3947,"tokens_out":2993,"would_cite":false,"duration_ms":26665,"reading_group":"no","serious_thinker":"unclear","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Training LLMs on injected mistakes with correction tags makes them self-correct at inference time.","keywords":["internalized self-correction","large language models","negative sampling","fine-tuning","self-reflection","chain-of-thought","hallucination correction","instruction following"],"falsifier":"Fine-tune the same model on InSeC-style data, generate many free-form samples at high temperature, and count how often a correction tag follows an incorrect sentence the model itself just wrote. If correction tags appear only after errors that were planted in the prompt and never after self-generated errors, the central claim fails.","tokens_in":2998,"feed_emoji":"🧠","tokens_out":6537,"duration_ms":55306,"temperature":0.7,"pith_summary":"This paper tries to establish that a large language model can internalize self-correction during training, so that at inference time it catches and fixes errors without being prompted to reflect. The proposed method, InSeC, injects deliberately wrong next-sentences into fine-tuning data, each followed by a correction tag and the corrected sentence, turning the task into supervised learning with negative and positive examples. The authors report a fine-tuned Llama 3.1 8B that, when its context contains a false conversion factor, flags the error, states the reason, and continues to the correct answer (10800 seconds), while a model fine-tuned without negative samples propagates the error and answers 9000 seconds. If the effect holds more generally, it would make error correction a built-in behavior of generation rather than an external process.","feed_headline":"Trained on injected errors, an LLM self-corrects","feed_subtitle":"Fine-tuning with wrong steps plus correction tags fixed a false conversion factor that a baseline model kept.","key_machinery":"The mechanism is negative sampling of continuations with structured self-correction tags. During fine-tuning, approximately 15% of sentences are replaced by wrong sentences; each wrong sentence is immediately followed by a correction tag giving a reason and then the corrected sentence. The model is trained to predict the tagged correction sequence, so at inference the tag becomes a natural continuation whenever the context contains an error. The tags double as artifacts that can be stripped post-generation to keep the final output clean.","core_discovery":"The paper's central claim is that the correction process can be placed inside the model's own sequence-level training. By pairing an incorrect continuation with special tokens such as '<Found a mistake in the previous sentence. Reason: ...>' and then the true continuation, the model learns to produce the correction as ordinary text. The authors call this 'internalized' because no reflection prompt, external verifier, or inference-time loop is required. The demonstration is a continuation of a chain of thought in which the first step says there are 50 minutes in an hour; the InSeC fine-tuned model inserts a correction and computes 3*60*60 = 10800 seconds, whereas the baseline propagates 50 and outputs 9000.","pith_inferences":["The paper's test case places the false conversion factor in the given prompt, so the harder case of the model catching an error it generated itself is not demonstrated and is instead a predicted consequence of the method.","If the effect transfers to self-generated errors, InSeC would let deployment drop multi-step reflection loops and external verifiers, cutting latency and cost for error correction.","A graded test—injecting errors at different positions and rates during training, then sampling free generations at high temperature—could separate recognition of planted errors from genuine self-correction."],"forward_implications":["A model fine-tuned with InSeC data can continue a chain of thought by flagging and fixing an erroneous step instead of propagating the error to the final answer.","Because the training data contains explicit wrong examples paired with corrections, the learning objective becomes a supervised task with both negative and positive examples, which the paper argues is more sample-efficient than positive-only self-supervised training.","At inference, no reflection prompt or external feedback mechanism is required for the correction to appear, since the behavior is learned as part of normal continuation.","The authors state that the same tagging scheme extends from arithmetic errors to correcting hallucinations and improving instruction following, because any incorrect sentence can be paired with a correction and a reason.","Special tokens around corrections can be removed after generation, so the final answer remains clean even though the model internally produced correction text."],"supporting_citations":[{"why":"Supplies the transformer architecture that the proposed fine-tuning method is applied to.","marker":"[1]"},{"why":"Represents the external feedback and reflection approach that InSeC contrasts with by moving correction into training.","marker":"[2]"},{"why":"Provides the prompting-based self-reflection baseline that InSeC replaces with training-time internalization.","marker":"[3]"},{"why":"Describes an external process for reflection and problem decomposition, serving as a contrast for the training-phase approach.","marker":"[4]"},{"why":"Supplies the negative-sampling idea that InSeC adapts to next-sentence generation.","marker":"[5]"}],"fun_headline_variants":["LLMs learn to self-correct from injected mistakes","Internalized self-correction: no inference-time reflection needed","Train LLMs to fix errors with correction tokens","Self-correction without loops: internalize the fix during training","New training method lets LLMs correct their own false steps"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that a model trained to correct errors deliberately planted in its input will spontaneously apply the same correction behavior to errors it itself produces at generation time, without being prompted or told to reflect.","fun_headline_variants_meta":{"raw":{"variants":["LLMs learn to self-correct from injected mistakes","Internalized self-correction: no inference-time reflection needed","Train LLMs to fix errors with correction tokens","Self-correction without loops: internalize the fix during training","New training method lets LLMs correct their own false steps"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000259,"raw_usage":{"total_tokens":1500,"prompt_tokens":771,"completion_tokens":729,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":387,"completion_tokens_details":{"reasoning_tokens":650}},"tokens_in":387,"tokens_out":729,"duration_ms":7434,"temperature":1.0,"reasoning_tokens":650,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T10:21:54.183583+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Fine-tune the same model on InSeC-style data, generate many free-form samples at high temperature, and count how often a correction tag follows an incorrect sentence the model itself just wrote. If correction tags appear only after errors that were planted in the prompt and never after self-generated errors, the central claim fails.","supporting_citations":[{"cited_title":"Attention is all you need,","cited_arxiv_id":null,"evidence_quote":"Supplies the transformer architecture that the proposed fine-tuning method is applied to."},{"cited_title":"Reinforcement Learning from Reflective Feedback (RLRF): Aligning and Improving LLMs via Fine-Grained Self-Reflection","cited_arxiv_id":"2403.14238","evidence_quote":"Represents the external feedback and reflection approach that InSeC contrasts with by moving correction into training."},{"cited_title":"Efficient estima tion of word representations in vector space,","cited_arxiv_id":null,"evidence_quote":"Supplies the negative-sampling idea that InSeC adapts to next-sentence generation."}],"review_version":1}