🤖 AI

No Universal Signal Predicts Sample-Level LLM Regression under Version Updates

This paper investigates how to predict sample-level performance regressions in updated LLMs by comparing single-model and cross-version signals across six benchmarks, finding that no single signal is universally effective but that task-dependent patterns can guide practitioners in selecting appropriate signals to implement a selective fallback mechanism routing high-risk samples to previous model versions.

Original authors: Jia Sheng, Yiwei Lu

Published 2026-08-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jia Sheng, Yiwei Lu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you just bought the latest, most powerful smartphone. The box promises it's faster, smarter, and better at everything than your old one. You're excited! But then, you try to open a specific app you used to use perfectly, and suddenly, it crashes. Or maybe it gives you the wrong answer to a math problem you've solved a thousand times. This is the weird, frustrating reality of Artificial Intelligence updates. In the world of Large Language Models (LLMs)—the super-smart AI brains behind chatbots and coding assistants—developers are constantly releasing "Version 2.0," "Version 3.0," and so on. Usually, these new versions are better on average. But sometimes, in a phenomenon researchers call a "negative flip," the new model gets worse at specific tasks it used to nail. It's like upgrading your car's engine only to find the radio no longer works.

The big question is: How do we know before we hit "send" that the new AI is about to mess up? Can we spot a "glitch" in the making? To understand the paper, you need to know two main ways we usually try to guess if an AI is confused. First, there's confidence. If an AI says, "I'm 99% sure the answer is Blue," it's usually right. If it says, "I'm 51% sure," it's probably guessing. Second, there's cross-version comparison. This is like asking the old AI and the new AI the same question and seeing if they disagree. If the old one said "Blue" and the new one says "Red," something changed. The paper asks: If we want to catch these "negative flips" in real-time, without having a teacher's answer key handy, which of these signals is the best detective?

The researchers, Jia Sheng and Yiwei Lu, decided to play detective across six different types of challenges, ranging from multiple-choice trivia and tricky math problems to writing computer code. They tested six different pairs of model updates (like going from Qwen 2.5 to Qwen 3, or Llama 3 to Llama 3.1) to see which signal could predict when the new model would trip up on a question the old one got right.

Here is the twist they found: There is no single "magic signal" that works for everything. It's not like having one universal alarm clock that rings for every type of emergency. Instead, the best alarm depends entirely on what kind of task you are doing.

If you are asking the AI multiple-choice questions (like "What is the capital of France?") or simple math, the old-school confidence signal is the champion. If the new model looks unsure (low confidence), it's likely about to flip from right to wrong. The paper found that for these tasks, checking how "sure" the new model feels is usually enough; you don't need to compare it to the old model.

However, the story changes completely when the tasks get harder. When the AI is doing complex math or writing code, confidence becomes a liar. A model can be super confident and still be completely wrong, especially in coding where a single missing semicolon breaks the whole program. In these high-stakes, complex scenarios, the paper found that cross-version signals are the real heroes. These are signals that measure the "drift" or difference between the old and new model. For example, if the new model's internal "thought process" (its hidden math) has shifted wildly compared to the old one, or if the probability of the words it chose has drifted, that's a huge red flag. The paper suggests that for code and hard math, you need to compare the new model against the old one to catch the errors that confidence alone misses.

The researchers also tested a practical idea: what if we use these signals to create a safety net? They proposed a "selective fallback" system. Imagine a traffic cop at a busy intersection. If the signal says a specific request is "high risk" (likely to be a negative flip), the system automatically routes that question back to the old, reliable model instead of the new one. They found this works! In some cases, like with code generation, using these cross-version signals allowed them to catch nearly 30% of the errors that would have happened, fixing the answer by switching back to the old model.

But there's a catch. The paper explicitly rules out the idea that you can just mix and match all these signals to get a super-predictor. They tried combining confidence, drift, and other signals together, but found that one good signal is usually better than a messy mix. The signals tend to compete rather than help each other; adding more didn't make the prediction much better. Also, they debunked the idea that these "negative flips" are just the hardest questions the old model ever faced. While the old model's difficulty does play a part, it doesn't explain everything. The new model can suddenly fail on easy questions that the old one found simple, meaning you can't just rely on the old model's history to predict the new one's mistakes.

In short, the paper suggests that if you are an engineer or a user trying to keep AI updates safe, you can't just use a "one-size-fits-all" rule. You have to look at the job. If it's a trivia quiz, trust the new model's confidence. If it's coding or complex math, trust the comparison between the old and new models. There is no universal signal, but by matching the right tool to the right task, we can build a guardrail that catches the AI before it trips over its own shoelaces.

Technical Summary: No Universal Signal Predicts Sample-Level LLM Regression under Version Updates

Problem Statement

Frontier Large Language Models (LLMs) undergo frequent updates that typically improve aggregate accuracy on benchmarks. However, these updates can introduce negative flips: specific instances where a response that was correct under an older model ( $M_{old}$ ) becomes incorrect under a newer model ( $M_{new}$ ). While aggregate metrics mask these regressions, they pose significant risks for high-stakes applications.

The core problem addressed is sample-level regression prediction at inference time. The authors investigate whether signals available during inference—without access to model parameters or ground-truth labels—can effectively flag samples likely to undergo a negative flip. The study distinguishes between:

Single-model signals: Uncertainty metrics derived from a single model version (e.g., confidence, logit margin).
Cross-version signals: Metrics comparing the behavior of $M_{old}$ and $M_{new}$ on the same input (e.g., output KL divergence, likelihood drift).

The central hypothesis tested is whether cross-version disagreement is inherently predictive of regression, or if signal effectiveness is contingent on task structure and specific model updates.

Methodology

Experimental Setup

The study evaluates six model update pairs across four open-weight model families (Qwen, Llama, Mistral, Gemma), covering approximately two years of releases. This includes five same-family updates and one boundary case (Llama-2 $\to$ Llama-3).
Evaluation spans six benchmarks in three task families:

Multiple-Choice Question Answering (MCQ): MMLU-Pro, GPQA.
Math Reasoning: GSM8K, MATH-full.
Code Generation: HumanEval, MBPP.

Models are decoded deterministically (greedy decoding, temperature 0) to ensure reproducible negative-flip labels. The prediction target is the binary label $z(x) = \mathbb{I}\{c_{old}(x)=1 \land c_{new}(x)=0\}$ .

Signal Taxonomy

The authors compare two families of signals:

Single-Model Signals:
- Confidence: Maximum softmax probability (MCQ) or length-normalized sequence log-likelihood (generative).
- Logit Margin: Gap between top-1 and top-2 option logits (MCQ).
- Attention Entropy: Rényi-2 entropy of attention weights (MCQ).
Cross-Version Signals:
- Output KL/JSD: Divergence between option distributions (MCQ).
- Likelihood Drift: Difference in per-token negative log-likelihood (NLL) when scoring a fixed trajectory (old or new) on both models.
- Top-k Token KL: KL divergence between next-token distributions restricted to the top- $k$ tokens of the generating model.
- Representation Drift: Cosine distance between last-layer hidden states.

Evaluation Protocol: Added-Value Test

To isolate the unique predictive power of each signal, the authors employ a unified added-value test.

Baseline: A logistic regression model using only new-model confidence ( $LR(conf_{new})$ ).
Augmented Model: $LR(conf_{new}, s)$ , where $s$ is the candidate signal.
Metric: The change in 5-fold cross-validation AUROC ( $\Delta$ CV-AUROC). A signal is considered useful only if it improves performance over the confidence baseline, rather than merely duplicating information already captured by confidence.

Key Results

1. Task-Dependent Effectiveness

No single signal universally predicts negative flips across all tasks and updates. Effectiveness is strongly correlated with task output structure:

MCQ Tasks: New-model confidence is the strongest predictor. Cross-version signals (like Output KL) show high standalone AUROC but provide little added value over confidence, as MCQ correctness relies on a single discrete choice.
Math Reasoning (Harder Tasks): On the MATH-full benchmark, cross-version likelihood/KL signals (specifically new-trajectory likelihood drift and token KL) consistently outperform confidence. On the simpler GSM8K, confidence remains sufficient.
Code Generation: Cross-version signals (likelihood drift and token KL) provide the most frequent gains. Code correctness is functional (dependent on the entire trajectory), meaning a fluent, high-confidence generation can still fail unit tests. Trajectory-level signals capture information that confidence misses.

2. No Universal Winner Across Updates

Even within a specific task family, the best signal varies by model update pair. For example, while likelihood drift often helps on code tasks, its magnitude and direction are update-dependent.

3. Hardness vs. Regression

Negative flips are not solely the "hardest" examples for the old model. While low old-model confidence correlates with flips in MCQ, this relationship weakens significantly in math reasoning and code generation. Old-model confidence alone cannot reliably identify which samples will flip under an update.

4. Label-Free Applicability

When evaluated on the full dataset (without filtering for $M_{old}$ -correct samples, simulating real deployment where ground truth is unavailable):

New-model confidence performance drops significantly (e.g., AUROC $\approx$ 0.6 on MMLU-Pro).
Some cross-version signals (e.g., new-trajectory likelihood drift) remain more stable and informative, supporting a proof-of-concept selective fallback strategy where high-risk samples are routed back to the old model.

5. Signal Combination

Combining multiple cross-version signals rarely improves performance over the best individual signal, suggesting competition rather than complementarity among these metrics.

Significance and Contributions

The paper makes four primary contributions:

Characterization of Negative Flips: It demonstrates that negative flips are not fully explained by the old model's hardness or low confidence, particularly as task complexity increases.
Task-Dependent Signal Patterns: It identifies that the optimal signal for predicting regression depends on the task family: confidence suffices for MCQ and simple math, while cross-version likelihood/KL signals are superior for code and complex math.
Practical Fallback Mechanism: It shows that certain cross-version signals remain informative without ground-truth labels, enabling a selective fallback strategy to mitigate regression risks in production.
Competition vs. Complementarity: It establishes that combining multiple cross-version signals generally yields diminishing returns, indicating that a single well-chosen signal is usually sufficient.

Conclusion: Practitioners should not default to confidence-based filtering for all updates. Instead, they should match the regression signal to the specific task and model update pair. For generative tasks like code and complex math, cross-version behavioral comparisons offer a necessary guardrail that single-model confidence cannot provide.