Can an LLM Fix a Language Model Without Training It?

Bharath Kumar Bolla, Raghavender Surya Upadhayula, Vishnu Surya Reddy Nandi, Ramesh NandipalliarXiv 2026 · arXiv

TL;DR

Researchers have demonstrated that an external Large Language Model (LLM) can act as a "weight surgeon," diagnosing and repairing faults in a target model's weights without any gradient-based training. By selecting specific numerical projection operators based on internal telemetry, the LLM-guided "editor" can restore broken behaviors and even prevent model collapse during subsequent fine-tuning.

What Problem Does This Paper Address?

When a language model breaks—whether due to a specific "bug" in its weights, poor quantization, or catastrophic forgetting—the standard solution is more training. However, fine-tuning can be expensive, requires labeled data, and often "learns around" a problem rather than fixing the underlying structural cause.

This paper explores the frontier of Weight-Space Programming. The authors ask: Can we treat a model's weight matrices as editable code? Specifically, can an external LLM inspect a damaged model's activations and weight statistics to propose a surgical, zero-shot numerical edit that restores its original behavior?

Methods

The authors established a "blinded" experimental setup where an external LLM (the Editor) interacts with a Projection Engine to fix a Target Model (ranging from BERT to Qwen2.5).

  1. Fault Injection: The researchers intentionally "broke" the target models by injecting low-rank perturbations into specific MLP or attention layers, causing them to fail at simple completion tasks (e.g., outputting repetitive "the the the..." instead of a correct answer).
  2. The Blinded Interface: The LLM Editor cannot see the original weights or the injected fault. It only receives "telemetry": SVD spectra of weights, activation drift summaries, and diagnostic outputs.
  3. Projection Operators: Instead of training, the Editor chooses a "recipe" for a linear projection. This operation essentially "erases" components of the weight matrix along a specific direction to nullify the fault.
  4. Interactive Feedback: The Editor can propose an edit, see how it performs on a small validation set, and then refine its strategy (e.g., changing the target layers or the rank of the projection) before finalizing the repair.
Figure 1. Overview of the recovery experiment. A known perturbation creates a damaged target. Live LLM and non-LLM procedures receive the damaged state and their permitted observations. Evaluation separates task behavior, geometric restoration and preservation. Optional adaptation starts from the selected repaired state.

Datasets

The study uses a Controlled Recovery Benchmark involving five models: BERT-Base, PubMedBERT, SmolLM2-135M, Pythia-70M, and Qwen2.5-0.5B.

  • Task: Adjective completion (e.g., "While fresh snow is white rather than hot, ice is [cold]").
  • Evaluation: The authors used two test splits: Test A (new entities) and Test B (syntax and distractor shifts) to ensure the fix wasn't just memorizing a specific prompt structure.
  • Preservation: They also measured KL-divergence on factual prompts to ensure the "surgery" didn't cause collateral damage to the model's general knowledge.

Key Insights and Ideas

  • Behavioral vs. Geometric Recovery: A crucial finding is that you don't need to perfectly restore the weights to their original state to fix the model's behavior. As shown in the paper's geometric analysis, a "blind" projection can clear the obstruction and restore accuracy even if the resulting weights are still numerically distant from the original "clean" weights.
  • The "Repair-then-Train" Synergy: For models like Pythia-70M, standard LoRA fine-tuning often fails to fix a damaged model, leading to "short-horizon collapse." However, using the LLM to perform a structural repair before starting LoRA allows the model to recover fully.
  • LLM as a Strategic Controller: The LLM isn't doing the heavy math; it’s acting as a high-level strategist. It identifies where and how much to edit, outperforming standard black-box optimization in complex scenarios like compound faults affecting both attention and MLP layers.
Figure 2. Projection and exact restoration have different endpoints. The two-dimensional example explains why behavioral recovery can coexist with residual weight error. Geometric restoration is therefore measured separately from task success.

Key Results

  • Pythia Recovery: In a core two-layer fault, the LLM-guided editor achieved 65.62% accuracy, while a matched-budget Bayesian black-box search failed completely (0%).
  • Compound Faults: On a complex fault involving three different types of damage, LLM-guided selection raised the mean accuracy across five checkpoints from 24.89% to 71.25%.
  • Weight Restoration: The edits significantly reduced weight error, bringing relative weight deviation down to ~0.06 for causal models, effectively "un-distorting" the model's internal representations.

Limitations and Future Work

The authors acknowledge several constraints:

  • Synthetic Faults: The faults were low-rank and precisely injected. Real-world model degradation (like that from poor fine-tuning) might be more "diffuse" and harder to target with simple projections.
  • Information Leakage: While the setup was blinded, the descriptive names of fault families might have provided subtle hints to the LLM.
  • Scope of Tasks: The evaluation focused on narrow adjective completions. Future work is needed to see if these surgical edits hold up across long-form reasoning and broader creative tasks.

Ultimately, this research suggests a future where "model debugging" looks less like retraining from scratch and more like an automated surgeon precisely removing the "tumors" in a network's weight space.

Summary updated

Abstract

Although an external language model can select and test repairs to another model's weights, behavior can also be recovered through fixed numerical edits. We assessed the value of interactive selection in a controlled study of Transformer repair. After inspecting predictions, activation summaries, and weight statistics, the editor selects projection recipes to apply to the target without gradient updates. We analyzed 20 recorded sessions involving five masked and causal language models, comparing the selected edits with fixed projections, scripted and matched-budget black-box search, and low-rank adaptation. Under the core two-layer fault, live selection matches black-box search on SmolLM2 and Qwen2.5. For Pythia, live selection achieves 65.62% completion accuracy, compared with 0% for black-box search and 66.15% for a fixed projection. Under a separate compound fault affecting attention and feed-forward weights, both scripted and LLM-guided selection increase the descriptive five-checkpoint mean from 24.89% to 71.25% using the same operator family. On unmodified checkpoints, scripted projection yields small gains or losses on a separate set of framed questions. The experiments identify cases in which feedback changes an edit decision, operator coverage accounts for recovery, or supervised adaptation performs better. Combined with measurements of parameter restoration and preservation, these comparisons establish the scope of controller-guided repair for the tested faults and completion tasks.
BibTeX
@misc{bolla2026can,
  author = {Bharath Kumar Bolla and Raghavender Surya Upadhayula and Vishnu Surya Reddy Nandi and Ramesh Nandipalli},
  title = {{Can an LLM Fix a Language Model Without Training It?}},
  year = {2026},
  eprint = {2611.25613},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.25613},
}
Figure