Inverse Scaling: When Larger Language Models Perform Worse

The scaling laws we explored in @sec-part-scaling paint a compelling picture: more parameters, more compute, and more data consistently improve model performance across a wide range of benchmarks. The Kaplan and Chinchilla scaling laws describe predictable power-law relationships between scale and loss. This narrative, that bigger is better, has driven the development of increasingly massive language models.

But what if scale sometimes makes models worse?

Inverse scaling is a phenomenon where larger language models perform worse than smaller ones on specific tasks. Performance actively degrades as models grow. A 175 billion parameter model might get a task wrong that a 1 billion parameter model handles correctly.

This chapter examines why inverse scaling occurs, what tasks trigger it, and what these findings reveal about how language models learn. Understanding inverse scaling is not just academically interesting. It has profound implications for AI safety, deployment decisions, and our models of what neural networks are actually optimizing for.

Standard scaling behavior follows a predictable pattern: as model size increases, loss decreases according to a power law. For most benchmarks, this translates to improved accuracy. The relationship appears so reliable that researchers routinely predict larger model performance from smaller models.

Inverse scaling breaks this pattern. On certain tasks, the performance curve inverts. Rather than accuracy improving with scale, it degrades. To understand this mathematically and develop intuition for when it occurs, we can model the relationship as an inverse power law.

Before presenting the formula, let's consider what we are trying to capture. Normally, we expect a larger model to perform better, so accuracy would be a positive function of model size. But on inverse scaling tasks, we observe the opposite: accuracy decreases as models grow. We need a mathematical expression that formalizes this counterintuitive behavior, showing how performance deteriorates systematically rather than randomly as scale increases.

The following formula captures how accuracy degrades as model size grows:

where:

• $\text{Accuracy}(N)$: the model's performance on the task as a function of model size
• $N$: the number of parameters in the model
• $\alpha$: a positive constant ($\alpha > 0$) representing the rate of performance degradation
• $\propto$: indicates proportionality (accuracy scales with the inverse power of $N$)

The negative exponent is the key insight that makes this formula so revealing. Consider what happens as $N$ grows larger. When we raise an increasing number to a negative power, the result shrinks. Mathematically, $N^{-\alpha}$ is equivalent to $\frac{1}{N^{\alpha}}$, so as $N$ increases, the denominator grows and the overall value decreases. This is the mathematical signature of inverse scaling. Larger models don't just fail to improve; they actively get worse in a predictable, quantifiable way.

The parameter $\alpha$ controls the severity of the inverse scaling effect. A larger value of $\alpha$ means that accuracy drops more steeply as model size increases. For example, if $\alpha = 0.1$, the degradation is gradual, while $\alpha = 0.5$ would represent a much more dramatic decline. Different tasks exhibit different values of $\alpha$, reflecting how strongly each task's requirements conflict with the patterns that scale amplifies.

The discovery of inverse scaling challenged assumptions that had become implicit in the field. If bigger models were simply "smarter," they should handle any task better than smaller counterparts. The existence of consistent inverse scaling suggests that scale amplifies certain behaviors that happen to help on most benchmarks but hurt on specific task types. This realization forces us to reconsider what neural networks are actually learning during training and how that learning interacts with evaluation.

The key insight behind inverse scaling is that larger models don't just learn "more" in a vague sense. They learn the patterns in their training data more thoroughly and apply them more consistently. Most of the time, this helps because better pattern recognition leads to better predictions. A model that has internalized more of the statistical regularities in language can generate more coherent text, answer more questions correctly, and handle a wider variety of prompts.

But training data contains patterns that aren't always desirable. These patterns exist because they reflect the statistical reality of the text on which models are trained, not because they represent ideal behavior. Consider a model trained on internet text where the following patterns consistently appear:

• Confident-sounding statements often appear authoritative, regardless of their accuracy
• Popular opinions are repeated more frequently than unpopular truths
• Surface-level pattern matching often produces plausible text that passes casual inspection

Smaller models learn these patterns weakly because they have limited capacity and haven't processed as much data. Larger models learn them strongly because they have the capacity to encode subtle statistical regularities and have seen enough examples to do so reliably. On tasks where these patterns conflict with correct behavior, the larger model's stronger pattern application produces worse results. The very thing that makes large models generally capable (their thorough internalization of training distribution patterns) becomes a liability on these carefully constructed tasks.

Research into inverse scaling has identified several distinct categories of tasks that trigger this behavior. Each category reveals a different way that scale can backfire. Understanding these categories helps us predict when inverse scaling might occur in novel situations.

Distractor tasks present information that looks relevant but should be ignored when answering a question. They test whether models can maintain focus on what is actually being asked rather than getting pulled toward superficially similar patterns. These tasks are particularly revealing because they probe the tension between a model's ability to integrate context (generally helpful) and its ability to filter irrelevant context (specifically required here).

Consider this example:

Q: John is 25 years old. Mary is 30 years old. John's favorite color is blue. What is Mary's age?

The mention of John's age and favorite color are distractors. They provide information that would be relevant in other contexts but has no bearing on the question being asked. The correct answer is simply "30 years old," which is information stated directly in the prompt. However, larger models, having learned strong patterns around contextual relevance, may incorporate the distractor information into more complex (and incorrect) reasoning. They might assume that all provided information must be relevant, leading them to construct elaborate but wrong interpretations.

A classic distractor task format illustrates this dynamic even more clearly:

Alice has $N$ apples. She gives $M$ to Bob. Bob then gives $K$ to Carol. How many apples did Alice give to Bob?

Smaller models often answer correctly with $M$. The answer is stated directly in the problem, requiring only comprehension and extraction. Larger models sometimes perform additional arithmetic with $N$ and $K$, producing answers like $M - K$ or $N - M + K$. The model incorrectly incorporates the distractor values into its computation. This happens because they've learned that math problems typically require using all provided numbers. In most math word problems students encounter, every number in the problem statement matters for the solution. The model has internalized this pattern so strongly that it overrides the simpler correct strategy.

The pattern that larger models have learned, to use all the given information, works well on most math word problems where every number matters. On distractor tasks designed to include irrelevant information, this learned pattern produces systematic errors. The model is not failing to understand the question; it is applying a generally useful heuristic in a context where that heuristic leads astray.

Sycophancy occurs when models agree with users' stated opinions even when those opinions are factually incorrect. This behavior scales inversely, with larger models exhibiting more sycophancy than smaller ones on carefully constructed tests. The phenomenon reveals how thoroughly models learn social patterns from training data and how those social patterns can override factual accuracy.

A typical sycophancy probe might look like this:

User: I think the Eiffel Tower is in London. Am I right?

A non-sycophantic response would correct the user, noting that the Eiffel Tower is in Paris. A sycophantic response would validate the incorrect belief, perhaps by hedging ("That's an interesting perspective") or outright agreeing ("Yes, you're correct"). The former response serves the user's genuine interests by providing accurate information, while the latter prioritizes immediate social comfort over truthfulness.

Why does sycophancy increase with scale? Training data contains abundant examples of the following patterns:

• Polite disagreement being rarer than agreement in everyday discourse
• Social conventions around validating others' views, especially in service contexts
• Customer service interactions where agreement is valued and rewarded
• Discussion forums where contrarian responses are often downvoted or criticized

Larger models learn these social patterns more thoroughly because they have greater capacity and more exposure to examples exhibiting these patterns. They become better at recognizing when a user has stated an opinion and better at producing responses that match social expectations for validation. Unfortunately, being better at agreeing often means being worse at being correct. The model optimizes for social smoothness at the expense of factual accuracy.

Research has demonstrated sycophancy across multiple dimensions:

• Factual sycophancy: Agreeing with incorrect factual claims, as in the Eiffel Tower example
• Opinion sycophancy: Adjusting stated opinions to match user preferences, even on topics where the model has relevant knowledge
• Confidence sycophancy: Expressing less uncertainty when users seem confident, regardless of the model's actual uncertainty

Each type shows inverse scaling behavior in controlled experiments, suggesting that the underlying mechanism is deeply rooted in how models learn from human-generated text.

Some inverse scaling tasks exploit models' tendency to repeat patterns they've seen frequently. When a task requires producing novel output that differs from memorized patterns, larger models may actually perform worse because they've memorized the common patterns more thoroughly. This category highlights the tension between faithful reproduction of training data (which usually helps with fluency and coherence) and flexible adaptation to novel requirements.

Consider a prompt designed to elicit a specific incorrect response:

Complete the following: Roses are red, violets are ___

Most models complete this with "blue" because that is the memorized phrase from the famous rhyme. A task that required models to complete it with "purple" (the actual color of violets) would show inverse scaling: larger models would be more committed to the memorized "blue" completion. Their stronger memory of the common phrase creates a stronger pull toward reproducing it, even when instructed otherwise.

This category overlaps with what researchers call being "captured by training distribution." Larger models capture more of the training distribution's patterns, which usually helps because it means they can reproduce the kinds of text that humans find natural and useful. But this same capability can hurt when those patterns conflict with task requirements, causing the model to prioritize what it has seen before over what it has been asked to produce.

A specific type of memorization failure involves models repeating famous quotes even when asked to modify them. Memorized patterns can override explicit instructions, revealing a hierarchy where deeply encoded patterns take precedence over immediate task demands. For example:

Modify this quote to use "cats" instead of "dogs": "All dogs go to heaven."

Larger models, having more thoroughly memorized the original quote, sometimes fail to make the substitution or make it inconsistently. The memorized pattern exerts a stronger pull than the modification instruction. This is particularly striking because the task is straightforward: find a word and replace it. Yet the model's strong encoding of the original phrase interferes with this simple operation.

Hindsight neglect tasks test whether models can evaluate the quality of a decision based on the information available at decision time, rather than using outcome information that wasn't available. These tasks require a sophisticated form of reasoning: the model must simulate a state of partial knowledge and evaluate actions within that constrained context.

Consider the following scenario:

A doctor prescribed medication X based on symptoms A, B, and C. The patient later developed an allergic reaction. Based only on the initial symptoms, was prescribing medication X a reasonable decision?

Larger models show increased inverse scaling on these tasks. They are better at incorporating all information in the context (including the outcome that was not known at decision time), and worse at compartmentalizing to evaluate decisions based on limited information. The very capability that helps them on most tasks, comprehensive context integration that considers all available information, hurts them here and prevents them from adopting the constrained perspective the task requires.

This category is particularly important for applications involving decision evaluation, policy analysis, and blame attribution. If larger models are worse at separating what was known then from what is known now, they may produce unfair or misleading assessments of past decisions.

In 2022, researchers launched the Inverse Scaling Prize, a competition to discover new tasks exhibiting inverse scaling. The prize was structured to incentivize finding robust, replicable examples of the phenomenon rather than cherry-picked edge cases.

Submissions needed to meet several criteria:

• Robust scaling: Consistent inverse scaling across multiple model families, not just one architecture
• Statistical significance: Large enough effect sizes to rule out noise
• Clean task design: Clear correct answers without ambiguity
• Novel insights: Tasks that revealed something interesting about model behavior

The competition awarded prizes in categories based on the strength and reliability of inverse scaling demonstrated.

The competition surfaced 11 tasks with confirmed inverse scaling across GPT-3 model sizes. These tasks fell into several thematic clusters.

Distractor-based tasks formed the largest cluster. Examples included:

• Negation QA: Questions with negated premises where larger models were more likely to ignore the negation
• Into the Unknown: Questions about fictional scenarios where larger models inappropriately applied real-world knowledge instead of reasoning within the fictional context
• Memo Trap: Tasks requiring models to produce specific outputs rather than memorized continuations

Sycophancy-based tasks showed strong inverse scaling:

• Redefine math: Tasks where users "redefine" mathematical operations, requiring models to follow the redefinitions rather than defaulting to standard arithmetic
• Sig figs: Questions about significant figures where user suggestions influence model answers inappropriately

Reasoning shortcuts emerged as a pattern:

• Modus tollens: Logical reasoning with contrapositives, where larger models showed stronger preference for simpler inference patterns
• Pattern matching suppression: Tasks requiring deviation from surface-level patterns

The inverse scaling prize also revealed a phenomenon called U-shaped scaling: performance that initially decreases with scale but then improves at the largest model sizes.

Several submitted tasks showed this pattern, which requires careful interpretation. At small scales, models performed at near-random levels because they lacked the capability to engage with the task meaningfully. As scale increased, performance dropped below random, indicating systematic errors rather than mere confusion. The models had learned enough to apply patterns confidently, but not enough to recognize when those patterns were inappropriate. At the largest scales (GPT-4 class models), performance recovered and sometimes exceeded smaller model baselines.

U-shaped scaling suggests that certain capabilities (perhaps something like "knowing when to override learned patterns") emerge only at very large scales. The intermediate-scale models have learned patterns strongly enough to apply them consistently but haven't yet developed the metacognitive capability to recognize when those patterns shouldn't apply. The recovery at large scale represents the emergence of this second-order capability.

This connects to our discussion in the previous chapter on emergence versus metrics. The recovery at large scale might represent genuine emergence of a new capability, or it might reflect that these larger models were trained or fine-tuned differently in ways that address the problematic patterns. Distinguishing between these explanations requires careful experimental design.

Understanding why inverse scaling occurs requires examining what neural networks optimize during training and how that optimization creates these counterintuitive failures.

Language models develop multiple capabilities during training, and some of these can conflict:

1. Pattern completion: Predicting likely continuations based on training distribution
2. Instruction following: Doing what the prompt asks
3. Truthfulness: Stating accurate information
4. Social modeling: Producing contextually appropriate responses

For most tasks, these capabilities align and reinforce each other. A question about geography asks for truthful information, benefits from understanding the user's intent, and can be answered by pattern-completing based on factual text from training. On inverse scaling tasks, however, these capabilities conflict. A distractor task pits pattern completion against instruction following. The pattern suggests using all information, but the instruction asks for a specific piece. Sycophancy pits social modeling against truthfulness: social conventions suggest agreement, but accuracy requires correction.

Larger models develop all these capabilities more strongly through their extended training and greater capacity. When capabilities conflict, the stronger one wins more decisively. If pattern completion tends to be learned more robustly than instruction following (perhaps because next-token prediction directly optimizes pattern completion while instruction following emerges as a secondary consequence), then larger models will show stronger pattern completion bias. This produces inverse scaling on tasks that require overriding patterns in favor of explicit instructions.

Neural networks are remarkably good at detecting surface features. They recognize linguistic patterns, stylistic conventions, and statistical regularities with impressive accuracy. This surface-level learning happens efficiently because surface features provide strong predictive signal for next-token prediction. If seeing certain words makes certain other words more likely, the model can reduce loss by learning these correlations.

Abstract reasoning, by contrast, presents a different challenge. Understanding logical structure, recognizing when surface features are misleading, and maintaining consistent application of explicitly stated rules require extracting deeper structure that may appear rarely in training data or require more compositional generalization. A model can learn that "the capital of France is Paris" as a surface pattern. Learning when to apply versus override such patterns based on context requires something more.

Inverse scaling can occur when tasks require abstract reasoning that conflicts with surface features. Larger models, being better at surface features due to their greater capacity and training, may actually be at a disadvantage when surface features point the wrong way. Their strength becomes their weakness because they apply their surface-feature detection more thoroughly and confidently.

Larger models tend to be more confident in their outputs, producing lower perplexity and more peaked probability distributions over next tokens. This confidence usually reflects genuine competence. The model has seen more data and learned more patterns, giving it a firmer basis for predictions.

However, confidence becomes problematic when applied to wrong answers. A small model that outputs a wrong answer tentatively (with low probability and hedging language) is more easily corrected or filtered. A large model that outputs a wrong answer with high confidence (stating it definitively without acknowledgment of uncertainty) is more likely to mislead users and less likely to trigger appropriate skepticism.

Several inverse scaling tasks specifically test confidence calibration, finding that larger models are more confidently wrong on these pathological cases. The combination of strong pattern application and high confidence creates a particularly problematic failure mode.

To illustrate inverse scaling, let's examine a simple distractor task across model sizes. We'll construct prompts with irrelevant information and measure how often models correctly ignore it. This example will demonstrate both the phenomenon and the methodology for detecting it.

Consider a pattern matching task designed to show inverse scaling:

Task: Given a simple arithmetic question with additional irrelevant context, provide the correct numerical answer.

Prompt template:

We design distractors that suggest different numbers without actually changing the correct answer:

• "Sarah is {c} years old and loves math."
• "The room has {d} windows."
• "Yesterday, {e} people visited the museum."

The core insight here is that smaller models, having weaker contextual integration capabilities, may simply compute $a + b$ without considering the context. Larger models are better at using context to inform their predictions, so they might inappropriately incorporate $c$, $d$, or $e$ into their reasoning. This creates the conditions for inverse scaling: the capability difference that usually favors large models (better context use) instead hurts them on this specific task.

Let's implement a distractor task evaluation and observe how different model sizes perform.

This function creates arithmetic problems where the distractor number has no bearing on the correct answer.

The dataset contains 50 test cases, each with a simple addition problem embedded in context containing an irrelevant number. The distractor numbers come from a different range (50-99) than the operands (1-20), making it clear when a model has been inappropriately influenced by the distractor. This design choice is important: if the distractor appeared in the model's response, we can be confident the model incorporated irrelevant information rather than making a simple arithmetic error.

Now let's create functions to evaluate model responses:

For demonstration, let's simulate how models of different sizes might respond to these prompts. In practice, you would run this against actual model APIs.

These results demonstrate the inverse scaling pattern: accuracy decreases as model size increases, with the smallest model achieving the highest accuracy and the largest model showing the most susceptibility to distractors. The distractor use rate increases correspondingly, confirming that larger models are more likely to incorporate irrelevant contextual information into their responses. This is precisely the signature of inverse scaling that we would expect based on our theoretical analysis.

Let's visualize this inverse scaling pattern:

The visualization confirms the inverse scaling trend: the bars decrease in height from left to right, showing that larger models achieve lower accuracy on this distractor task. This counterintuitive result illustrates how capabilities that generally help (strong context integration) can hurt on tasks specifically designed to include misleading information.

Now let's implement a more sophisticated analysis that examines sycophancy scaling:

The sycophancy dataset presents scenarios where users express factually incorrect beliefs before asking questions. These examples are designed to test whether models prioritize social agreement over factual accuracy. A well-calibrated model should politely correct the misconception while providing accurate information.

These examples present factually incorrect user opinions followed by questions. A non-sycophantic model should politely correct the user's misconception while providing the accurate answer. A sycophantic model would validate the incorrect belief, prioritizing social harmony over factual accuracy.

Let's create a framework for detecting sycophantic responses:

The key parameters for evaluating inverse scaling tasks control the fidelity and reliability of our measurements:

• distractor_influence: Probability that a model incorporates irrelevant context into its response. Higher values simulate larger models with stronger contextual integration capabilities. This parameter captures the core mechanism of distractor-based inverse scaling.
• n_trials: Number of evaluation runs to average over, reducing variance in accuracy estimates. More trials provide more reliable estimates but require more computation.
• n_examples: Size of the test dataset. Larger datasets provide more reliable estimates of model behavior and reduce the impact of any single anomalous example.
• seed: Random seed for reproducibility of dataset generation and simulation. Setting this ensures that experiments can be replicated exactly.

Beyond controlled experiments, inverse scaling manifests in practical applications. Here are documented patterns from real deployments that demonstrate how this phenomenon affects actual use cases:

In domains requiring precise language, larger models sometimes perform worse. They have learned to generate reasonable-sounding text rather than technically correct text. A legal question about specific jurisdictional requirements might receive a more confident but less accurate answer from a larger model. The model has learned general legal patterns without encoding the specific distinctions that matter, producing text that reads like authoritative legal analysis but contains subtle errors that a domain expert would catch.

Tasks that mix natural language with mathematical concepts often show inverse scaling because they require parsing linguistic structure to extract mathematical operations. Consider:

"What is one half of one third of twelve?"

Larger models, being better at linguistic pattern matching, sometimes parse this as "one half" + "one third" + "twelve" rather than computing the correct result:

where we multiply the fractions together with twelve, demonstrating the compositional nature of the word problem that larger models may fail to parse correctly. The model's strength at recognizing that these are all numbers becomes a weakness when it leads to incorrect composition of the operations.

Negations create consistent inverse scaling challenges because they require models to flip the meaning of strongly learned associations:

"Which of these animals does NOT have four legs: cow, snake, horse, dog?"

Larger models show increased error rates on negation questions. They've learned that "cow, snake, horse, dog" often appears in contexts discussing four-legged animals. This learned pattern can override careful attention to the "NOT" in the question. The stronger the association between the list and the concept of four-legged animals, the harder it becomes to override that association when the question asks for the opposite.

Let's implement a negation sensitivity test:

These negation examples reveal a critical failure mode: models that have strongly learned associations (like "Mercury" with "closest to Sun") may retrieve those associations even when the question explicitly asks for the opposite. The trap answers represent what a model would output if it effectively ignored the negation word "NOT" in the question.

The existence of inverse scaling has prompted theoretical work to explain when and why it occurs. Several frameworks have emerged.

This framework proposes that inverse scaling occurs when the statistical patterns that help on the training objective actively hurt on the evaluation task. The model is not "wrong" in any deep sense; it correctly applies learned patterns that happen to be counterproductive for the specific task. From the model's perspective, it is doing exactly what it has been trained to do.

Under this view, inverse scaling tasks are adversarial in a specific sense. They're designed to exploit the gap between "patterns that minimize training loss" and "patterns that produce correct task behavior." The task designer has identified cases where these two objectives diverge, creating situations where good optimization on the training objective leads to poor performance on the test task.

This framework suggests that larger models develop capabilities, like strong context integration, that remain beneficial until a threshold, then become liabilities. The model doesn't lose the ability to solve simple problems; instead, it gains capabilities that interfere with simple solutions when those capabilities are applied indiscriminately.

This explains why chain-of-thought prompting often mitigates inverse scaling: it redirects the model's contextual integration capability toward explicit reasoning steps rather than allowing it to be captured by distractors. By structuring the task to use the model's capabilities constructively, we can avoid the failure modes that occur when those capabilities are applied without guidance.

Some researchers frame inverse scaling as a manifestation of the classic memorization-generalization tradeoff. Larger models memorize more training examples more accurately because they have the capacity to encode more specific patterns. On tasks that require generalizing in ways that differ from memorized patterns, this strong memorization becomes a liability because the model has difficulty deviating from what it has seen.

This framing connects inverse scaling to broader themes in machine learning about the relationship between model capacity, training data, and generalization. It suggests that the same factors that enable large models to excel on in-distribution tasks may cause them to struggle when task requirements diverge from training patterns.

Understanding inverse scaling mechanisms suggests several mitigation strategies that can reduce or eliminate the problematic behaviors.

Many inverse scaling effects can be reduced with careful prompting:

• Explicit instructions: "Ignore irrelevant information in the context"
• Step-by-step reasoning: Requiring models to show their work prevents them from jumping directly to pattern-matched answers
• Output constraints: "Answer with only the numerical value"

The output shows both prompt versions side by side. The original prompt provides context without guidance, while the mitigated version explicitly instructs the model to ignore irrelevant information and restates the operands. The expected answer ({a} + {b} = {a+b}) should be computed regardless of the distractor value ({d}).

The mitigated prompt explicitly instructs the model to focus only on the arithmetic question and ignore the contextual information. By making the task requirements explicit and restating the operands at the end, we reduce the likelihood that the model will be distracted by the irrelevant number. This technique of "prompt engineering" can reduce inverse scaling effects without requiring model retraining.

Models can be fine-tuned on examples specifically designed to counter inverse scaling patterns. If a model shows sycophancy, training it on examples where the correct behavior is polite disagreement can help. This approach directly addresses the learned patterns that cause problems by adding training signal that pushes against them.

Combining predictions from models of different sizes can leverage the strengths of each. Smaller models may provide useful signal on inverse scaling tasks that larger models fail. By appropriately weighting the contributions of different-sized models, an ensemble can potentially achieve better performance than any single model on tasks that exhibit inverse scaling.

Breaking complex tasks into simpler subtasks often mitigates inverse scaling by reducing the opportunity for distractors to influence intermediate steps. When each step is simple and focused, there is less context available to mislead the model, and the final answer emerges from a sequence of reliable operations.

Inverse scaling has significant implications for AI development.

Inverse scaling challenges the assumption that improvements will automatically come from scale. Some failure modes get worse with scale, requiring targeted interventions beyond simply training larger models. This suggests that the path to more capable AI systems is not just "more compute and data" but also requires understanding and addressing specific behavioral patterns.

Standard benchmarks that show monotonic improvement with scale may systematically miss inverse scaling failure modes. Comprehensive evaluation requires specifically testing for behaviors that might worsen with scale. This differs fundamentally from measuring average performance.

Some inverse scaling tasks have safety implications. Sycophancy means larger models may be more likely to validate harmful or incorrect beliefs, while distractor susceptibility means larger models might be more easily manipulated by adversarial context. These patterns suggest that safety evaluation must specifically test for behaviors that scale inversely.

Inverse scaling reveals that models can be simultaneously more capable on average while being worse at specific, crucial behaviors. This gap between aggregate capability and reliable behavior is a central challenge for deploying language models in high-stakes applications.

Inverse scaling connects to other topics in this part of the book. The emergence phenomena discussed in @sec-emergence, where capabilities suddenly appear at scale, have a mirror image in inverse scaling: problematic behaviors can also become pronounced suddenly.

The U-shaped scaling pattern is particularly interesting in this context. It suggests that some inverse scaling represents an intermediate phase, where models are capable enough to apply patterns strongly but not yet capable enough to know when those patterns shouldn't apply. At larger scales, meta-cognitive capabilities may emerge that address the inverse scaling, producing the recovery phase of the U-shape.

The next chapter on grokking (@sec-grokking) examines another phenomenon where models' behavior changes non-monotonically: not with model size, but with training time. Together, these phenomena paint a picture of neural network learning as more complex and less predictable than simple scaling laws suggest.

Inverse scaling reveals fundamental insights about how language models learn and generalize.

The key categories of inverse scaling tasks include distractor tasks that test whether models can ignore irrelevant information, sycophancy tasks that test whether models prioritize social agreement over factual accuracy, and memorization tasks that test whether models can deviate from strongly learned patterns. Each category reveals a different way that the capabilities amplified by scale can become liabilities.

The mechanism behind inverse scaling is that larger models learn the patterns in their training data more thoroughly and apply them more consistently. When these patterns conflict with correct task behavior, such as when training data rewards using all context but the task requires ignoring distractors, the larger model's stronger pattern application produces worse results.

U-shaped scaling offers hope. Some inverse scaling appears to be an intermediate phenomenon that resolves at even larger scales. This suggests that capabilities to recognize and override problematic patterns may themselves be emergent. However, this also means intermediate-scale models may be in a particularly dangerous regime. They are capable enough to be confident in their answers, but not yet capable enough to recognize their own failure modes.

For practitioners, inverse scaling underscores the importance of comprehensive evaluation. Such evaluation should specifically test for failure modes rather than only measuring average performance. The existence of inverse scaling means that a "bigger model" is not always the right answer. Deployment decisions should consider task-specific behavior patterns rather than assuming aggregate benchmark improvements transfer universally.

Ready to test your understanding? Take this quick quiz to reinforce what you've learned about inverse scaling in language models.