When Bigger Becomes Brittle: Why Compression Hurts More as Language Models Scale

Gautam Gupta, Dikshant Kukreja, Unique Kumar, Avni Mittal, Deepanshu Dabas, Kshitij Sah, Erik Cambria, Rajiv Ratn Shah, Zhengkui Wang, Avinash AnandarXiv 2026 · arXiv

TL;DR

As language models grow, they become increasingly "brittle" to compression techniques like quantization and pruning. This happens because larger models lose the internal "self-repair" mechanisms—specifically copy-suppression release and backup responses—that allow smaller models to compensate for damaged components.

What Problem Does This Paper Address?

We usually evaluate model compression (quantization and pruning) using aggregate benchmark scores. However, these scores only show the final output loss, masking what’s happening under the hood. Inside a model, the network often tries to "repair" damage: if one component is weakened by compression, others might partially compensate for it.

The authors investigate whether this ability to self-repair scales with model size. If larger models are less able to compensate for internal damage, then compression that seems "harmless" on a small model might be devastating for a larger one, even if their benchmark scores look stable.

Methods

The researchers focused on a specific, well-understood circuit: in-context retrieval for the Indirect Object Identification (IOI) task (e.g., "When Mary and John went to the store, John gave a drink to..." $\rightarrow$ "Mary").

They identified two key types of components:

  1. Retrieval Heads: The primary workers that find the correct answer.
  2. Copy-Suppression Heads: Components that normally act as a "brake," reducing the logit of the predicted name to prevent over-confidence.

To see how the model handles damage, they used an accounting identity to decompose the total output harm ($H$) into four parts:

  • Deficit ($D$): The direct loss of signal from the damaged retrieval heads.
  • Copy-Suppression Release ($R$): The "repair" that happens when the "brakes" (suppression heads) weaken because the signal they usually suppress is gone.
  • Net Backup Response ($B$): The "Hydra effect," where other parts of the network step up to fill the gap.
  • Final Normalization ($N$): Changes caused by LayerNorm.

They applied this analysis across the Pythia model suite (410M to 12B parameters), as well as GPT-2 XL, Llama 3.1 8B, and the OPT family, using interventions like zero-ablation (to measure exact deficits), 4-bit quantization, and structural pruning.

Datasets

The study utilized:

  • 1,000 exploratory IOI prompts for target selection and calibration.
  • 2,000 held-out IOI prompts for final evaluation.
  • All prompts used single-token names to ensure clean logit attribution.

Key Insights and Ideas

  • The "Slack" Hypothesis: Smaller models are "inefficient" in a useful way. They tend to "overshoot" in intermediate layers—predicting the answer too strongly—and then use later layers (copy-suppression) to dial it back. This "standing suppression" acts as a buffer. When retrieval heads are damaged, this suppression naturally releases, automatically restoring much of the lost signal.
  • Specialization Breeds Fragility: Larger models are more specialized. They form the correct answer more gradually and reach peak confidence only at the final layer. Because they don't "overshoot," they have very little standing suppression to "release" as a repair mechanism.
  • The Vanishing Backup: Not only does suppression release fail in large models, but the "backup response" (where other heads step in) also becomes significantly less effective as models scale.
Figure 3: Repair decomposition at the two ends of the Pythia suite. At 410M (left), the response offsets most of the removed contribution; at 12B (right), it offsets a much smaller share.

Key Results

  • Scale-Dependent Harm: When retrieval heads are damaged to create a shared deficit of 0.5 logits, the Pythia-410M model offsets almost all of it, actually ending up with a slightly higher answer margin than the clean run. In contrast, the Pythia-12B model retains about 76% of that deficit as actual output harm.
  • Suppression Release ($R$): This mechanism offsets ~73% of the deficit in the 410M model but only ~10% in the 12B model.
  • Standing Suppression ($S$): As shown in Figure 5, the amount of "buffer" available for release drops sharply as models grow, from ~25% of the logit difference at 410M to just ~5% at 12B.
Figure 5: Standing suppression S across scale, mea- sured on the clean run, as a percentage of each model’s clean logit difference. Less standing suppression in the larger models leaves a smaller contribution available for release after damage.
  • Quantization Impact: The same trend holds for 4-bit quantization. The fraction of internal damage that reaches the output ($H/D$) rises from 0.55 at 410M to 0.91 at 12B.

Limitations and Future Work

  • Task Specificity: The study is limited to the IOI task. While IOI is a standard benchmark for mechanistic interpretability, it's unclear if these "repair" patterns generalize to more complex reasoning or knowledge-heavy tasks.
  • Simulated Quantization: The authors used simulated quantization in fp32. Testing with actual low-precision deployment kernels would be a valuable next step to confirm these findings in production environments.
  • Causal Training Links: While the authors showed that "overshoot" and suppression co-develop during training, they haven't yet proven a causal link (i.e., does the model learn suppression specifically to fix overshoot?). Future work involving interventions during the training process could clarify this.

Summary updated

Abstract

Quantization and pruning reduce the cost of deploying language models, but their effects are usually reported as benchmark scores. Such scores record only the loss that remains at the output. Inside the model, compression damages some components more than others, and the rest of the network can partly compensate. The observed loss therefore reflects both the damage and this compensation, which benchmark scores cannot separate. How the two combine, and whether their balance changes with model size, remains unclear. We study this compensation for in-context retrieval, a capability carried by a small, identifiable set of attention heads. To separate the two, the expected loss from ablating these heads is decomposed exactly into the part restored by the rest of the network, attributed to the components responsible, and the part that reaches the output. This decomposition is then compared across model sizes. For damage of comparable size, smaller models restore most of the loss, whereas larger models retain most of it, because the compensating responses offset less of it as models grow. Compressing the heads produces the same pattern. Compression that is nearly harmless in small models can therefore be costly in large ones.
BibTeX
@misc{gupta2026when,
  author = {Gautam Gupta and Dikshant Kukreja and Unique Kumar and Avni Mittal and Deepanshu Dabas and Kshitij Sah and Erik Cambria and Rajiv Ratn Shah and Zhengkui Wang and Avinash Anand},
  title = {{When Bigger Becomes Brittle: Why Compression Hurts More as Language Models Scale}},
  year = {2026},
  eprint = {2611.07891},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.07891},
}
Figure