💬 NLP

Revisiting the Reliability of Language Models in Instruction-Following

This paper introduces the IFEval++ benchmark and the reliable@k metric to reveal that while advanced language models achieve high scores on standard instruction-following tests, they exhibit significant fragility and up to a 61.8% performance drop when faced with subtle prompt nuances, highlighting a critical gap in real-world reliability.

Original authors: Jianshuo Dong, Yutong Zhang, Yan Liu, Zhenyu Zhong, Tao Wei, Chao Zhang, Han Qiu

Published 2026-04-15

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jianshuo Dong, Yutong Zhang, Yan Liu, Zhenyu Zhong, Tao Wei, Chao Zhang, Han Qiu

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

Title: The "Cousin" Test: Why Smart AI Still Gets Tripped Up by Small Changes

Imagine you hire a brilliant new assistant. You give them a task: "Write a story about a cat, but make sure it's exactly 100 words long." They do it perfectly. You're impressed. You give them the same task again, but this time you say, "Write a story about a feline, ensuring the word count is precisely 100." They do it again. You feel confident.

But then, you ask them to write a story about a cat that is "around 100 words." Suddenly, they panic. They write 90 words, then 110, then 85. They fail.

This is the core problem researchers at Tsinghua University and Ant Group discovered in their new paper, "Revisiting the Reliability of Language Models in Instruction-Following."

The Illusion of Perfection

For a while, AI models (LLMs) have been getting perfect scores on standardized tests like IFEVAL. Think of these tests like the SATs for computers. They check if an AI can follow strict rules, like "use no commas" or "start with the letter A." Top models are scoring 95% or higher. It looks like they are flawless.

But in the real world, humans aren't robots. We don't speak in perfect, standardized test questions. We say things differently depending on our mood, our context, or how we've phrased a request before. We use "cousin prompts."

What is a "Cousin Prompt"?
Imagine you ask a friend to "bring a red shirt."

Prompt A: "Bring a red shirt."
Prompt B: "Wear something red."
Prompt C: "I need a crimson top."
Prompt D: "Bring a red shirt, but ignore the blue one on the chair."

To a human, these are all the same request. To an AI, they might be completely different puzzles. The researchers call these "cousin prompts"—they are related, they mean the same thing, but they have subtle differences in wording or constraints.

The Big Discovery: The "Reliability Gap"

The researchers built a new testing ground called IFEVAL++. Instead of asking an AI one question, they asked it 10 slightly different "cousin" versions of the same question at once. They introduced a new score called reliable@k.

Here is the shocking result: Even the smartest AI models are not reliable.

When they took a model that scored 95% on the standard test and gave it the "cousin" test, its performance often crashed.

Some models dropped by 60%.
Even the most advanced model (GPT-5) dropped by nearly 20%.

It's like a student who can ace a math test with perfect numbers but fails the moment you change "add 2 and 2" to "combine two pairs of items." The AI isn't actually understanding the intent; it's just memorizing the specific phrasing of the test.

Why Does This Happen?

The paper suggests AI is like a parrot that has memorized a script. If you change the script slightly, the parrot gets confused.

Rephrasing: Changing "at least 400 words" to "around 450 words" confuses the model.
Distractions: Adding a tiny, irrelevant sentence like "by the way, the sky is blue" can make the AI forget the main rule.
Reconfiguration: Changing the context slightly (e.g., asking for a blog post about sleep vs. a story about sleep) breaks the model's logic.

How Do We Fix It?

The researchers didn't just point out the problem; they tried three ways to fix it:

Guessing the Answer (Prediction): They tried to make the AI "think" about whether it could do the task before doing it. It didn't work well; the AI was too overconfident.
More Training (SFT): They taught the AI specifically on these "cousin" variations. This helped, but it was slow and expensive.
The "Try Again" Method (Test-Time Scaling): This was the winner. Instead of asking the AI to answer once, they let it generate 10 different answers and picked the best one. It's like asking a student to write the essay three times and handing in the best version. This simple trick made even weaker models perform better than the strongest ones.

The Takeaway

This paper is a wake-up call. Just because an AI gets an "A" on a standardized test doesn't mean it's ready for the real world. Real life is messy, full of "cousin prompts" and subtle nuances.

To build truly trustworthy AI, we need to stop testing them on perfect, robotic questions and start testing them on the messy, varied, and nuanced ways humans actually talk. Until then, we should be careful: The AI might be smart, but it's not yet reliable.

1. Problem Statement

While Large Language Models (LLMs) have achieved near-ceiling accuracy on standard instruction-following benchmarks like IFEVAL, these scores do not guarantee reliability in real-world scenarios. In practice, users often express identical intents with subtle variations in phrasing, contextual framing, or task instantiation (e.g., changing "at least 400 words" to "around 450 words").

The paper identifies a critical gap: Nuance-Oriented Reliability. Current benchmarks primarily measure comprehensiveness (diversity of tasks) but fail to capture stability across "cousin prompts"—prompts that convey analogous user intents but differ in subtle linguistic or semantic nuances. The authors ask: Are current LLMs reliable when handling these nuanced variations, or do they fail inconsistently?

2. Methodology

A. The New Metric: `reliable@k`

To quantify nuance-oriented reliability, the authors introduce reliable@k. Unlike standard accuracy (which checks a single prompt), reliable@k measures whether a model can simultaneously solve a set of $k$ related "cousin prompts."

Definition: For a set of $k$ cousin prompts, the model passes the metric only if all $k$ responses satisfy their respective constraints.
Significance: This transforms reliability from a binary pass/fail on a single instance into a measure of robustness across a distribution of semantically similar inputs.

B. Data Augmentation Pipeline (IFEVAL++)

The authors constructed IFEVAL++, an extended benchmark containing 541 test cases. Each original IFEVAL case is expanded into 10 prompts (1 original + 9 cousins) using three automated augmentation strategies:

Rephrasing: Rewriting the prompt to alter wording while preserving core constraints (e.g., changing "Write a blog post..." to "Compose an article...").
Distractor Addition: Appending a non-interfering constraint (e.g., "Include a distractor sentence about the weather") to test if the model can maintain focus on original constraints.
Constraint/Task Reconfiguration: Modifying specific parameters (e.g., changing word count from "at least 400" to "around 450") or reconfiguring the task context while keeping the underlying requirement type the same.

Validity Checker: To ensure high-quality data, a code-assisted validity checker was developed. It embeds evaluation logic directly into the prompt to rigorously flag invalid, contradictory, or unattainable test cases, achieving 99.7% recall on flawed cases.

C. Experimental Setup

The study evaluated 46 models (20 proprietary, 26 open-source) ranging from small (0.6B) to massive (70B+) parameters, including reasoning and non-reasoning variants. The evaluation used greedy decoding to ensure reproducibility.

3. Key Results

A. The Reliability Gap

The most striking finding is the substantial drop in performance when moving from standard accuracy to reliable@10:

Significant Drops: Many models experienced performance drops of 30% to 60%. For instance, Qwen3-0.6B dropped by 61.8%, and GPT-3.5-turbo-1106 dropped by 54.7%.
Even Top Models Fail: The strongest model, GPT-5, saw an 18.3% decline (from 95.9% accuracy to 78.4% reliable@10).
Ranking Inversion: Nuance-oriented reliability is a distinct property. Gemma-3-IT-27B ranked 17th in standard accuracy but rose to 7th in reliable@10, indicating that high accuracy does not guarantee high stability.

B. Sensitivity to Specific Nuances

Constraint Types: Models were most sensitive to English Capitalization constraints (41.0% average drop) and Number of Words constraints (26.4% drop), likely due to tokenization issues and training data biases.
Augmentation Difficulty: Models handled Rephrasing well but struggled significantly with Distractor Addition and Constraint Reconfiguration, suggesting that adding complexity or altering parameters disrupts planning and execution more than simple wording changes.

C. Improvement Pathways

The paper explored three methods to improve reliability:

Prediction-based: Attempting to predict if a model will follow an instruction before generation (via confidence, perplexity, or probing hidden states). Probing hidden states showed the most promise but was not a perfect predictor.
Training-based: Fine-tuning on general data (Alpaca) did not help. However, Supervised Fine-Tuning (SFT) on curated cousin prompts significantly improved reliability, confirming that targeted data is more effective than scale alone.
Test-Time Scaling:
- Sequential: Increasing reasoning effort (Chain-of-Thought) helped some models (e.g., GPT-5-mini) but hurt others.
- Parallel (Rejection Sampling): Generating multiple samples ( $n$ ) and selecting the one that passes all constraints proved most effective. A weaker model (Qwen3-4B) with $n=3$ samples surpassed the strongest open-source model (LLaMA-3.3-70B) in reliability.

4. Key Contributions

Conceptual Framework: Defined and operationalized nuance-oriented reliability as a critical, underexplored dimension of LLM trustworthiness.
New Metric: Introduced reliable@k, a rigorous metric that penalizes inconsistency across semantically similar prompts.
Benchmark (IFEVAL++): Created a systematic, automated pipeline to generate high-quality cousin prompts, resulting in a benchmark that reveals vulnerabilities invisible to standard evaluations.
Empirical Insights: Demonstrated that current SOTA models are fragile to subtle prompt variations and identified parallel test-time scaling (rejection sampling) and targeted SFT as effective mitigation strategies.

5. Significance

This work challenges the community to move beyond "accuracy on a fixed test set" toward robustness in dynamic environments. It highlights that an LLM's ability to follow instructions is not just about knowing what to do, but maintaining that capability when the how (phrasing, constraints, context) shifts slightly. The findings suggest that for LLMs to be truly dependable in real-world applications, future development must prioritize consistency across nuances rather than just peak performance on static benchmarks. The authors release their code and benchmark to facilitate this shift in evaluation standards.