Models & Evaluation

Emergent Capabilities

Emergent capabilities are abilities that large language models appear to gain abruptly at larger scale, absent in smaller models. Whether these jumps are real or an artifact of the chosen evaluation metric is actively debated.

What Emergent Capabilities Mean

An emergent capability is an ability that is not present in smaller language models but appears in larger ones, where 'larger' is measured by training compute, parameter count, or dataset size. The term was popularized by Jason Wei and co-authors in the 2022 paper 'Emergent Abilities of Large Language Models' (arXiv:2206.07682), published in Transactions on Machine Learning Research. The paper's working definition is that an ability is emergent if it cannot be predicted by extrapolating the performance of smaller models.

The headline observation was that on certain tasks, accuracy stays near random for a wide range of model sizes and then rises sharply once a scale threshold is crossed. Reported examples include multi-step arithmetic, the Massive Multitask Language Understanding benchmark (MMLU, a multi-task knowledge and reasoning test), word unscrambling, and gains from chain-of-thought prompting that the authors found only helped models above roughly 100 billion parameters. The visual signature is a flat curve that suddenly bends upward.

The framing matters because it suggests scaling can produce qualitatively new behavior that designers did not explicitly build in. That claim shaped expectations about what further scaling might produce, and it also raised a safety concern: if capabilities appear without warning, they are hard to forecast and audit before deployment.

Emergent means absent in small models, present in large models, per Wei et al. 2022.
The defining feature is a sharp, hard-to-extrapolate jump rather than steady improvement.
Reported examples include multi-step arithmetic, MMLU, and chain-of-thought gains at scale.
The concept influenced both optimism about scaling and concern about unpredictable behavior.

The Mirage Counterargument

A prominent challenge to the strong reading came from Rylan Schaeffer, Brando Miranda, and Sanmi Koyejo in 'Are Emergent Abilities of Large Language Models a Mirage?' (arXiv:2304.15004), which received a NeurIPS 2023 Outstanding Main Track Paper award, the top award in its track. Their central claim is that many apparent emergences are an artifact of the evaluation metric rather than a property of the model. Nonlinear or discontinuous metrics, such as exact-match accuracy on a long answer, can turn a smooth underlying improvement into what looks like a sudden jump.

The argument runs as follows. As scale grows, a model's per-token error rate tends to fall smoothly, in line with scaling laws. A metric like exact-match requires every token in a multi-step answer to be correct at once, so it stays near zero until per-token accuracy is high enough, then climbs steeply. Swap in a continuous, partial-credit metric such as token-level edit distance or the probability assigned to the correct answer, and the same models often trace a smooth, predictable curve with no discontinuity.

The authors supported this three ways: they predicted which BIG-Bench tasks would show apparent emergence based on metric choice, they showed apparent emergence largely vanished on those tasks when metrics were changed, and they manufactured emergent-looking curves on standard vision models purely by selecting a harsh metric. The conclusion is not that scaling does nothing, but that sharp metric-driven jumps should not be read as evidence of a fundamental phase change.

ExactMatch(N) = p(N)^L,  where p(N) = per-token accuracy at scale N, L = answer length in tokens

If per-token accuracy p(N) rises smoothly with scale N, an exact-match metric over an L-token answer rises as a steep power, producing an apparent sharp jump while the underlying trend is gradual.

Schaeffer et al. 2023 argue apparent emergence often reflects metric choice, not new model behavior.
Discontinuous metrics like exact-match exaggerate smooth gains into sharp jumps.
Continuous metrics such as token edit distance often remove the apparent discontinuity.
The paper reproduced fake 'emergence' on vision models by choosing a harsh metric.

Relationship to Scaling Laws

Neural scaling laws describe how a model's pretraining loss falls smoothly and predictably as compute, parameters, and data increase, typically following a power law. That smoothness sits in apparent tension with the sharp downstream jumps that motivated the emergence literature, and resolving the tension is much of what the debate is about.

The mirage view reconciles the two by noting that loss is a continuous quantity while many downstream benchmarks report a thresholded score. A smooth decrease in loss can map onto a flat-then-steep curve once it passes through a nonlinear metric. Under this view there is no separate emergent phenomenon to explain; there is one smooth trend viewed through different lenses.

Not every case reduces to metric choice. Some tasks still show acceleration under continuous metrics, and follow-up work has examined U-shaped and inverted-U scaling on subgroups of a task that can combine into a sudden overall rise. The careful position is that metric choice explains a large share of reported emergences but does not by itself close every open question about how capabilities scale.

Scaling laws predict smooth power-law decreases in pretraining loss with scale.
Smooth loss can look like a sharp downstream jump after a nonlinear metric is applied.
The mirage account treats emergence as one trend seen through a discontinuous measure.
Some accelerating curves persist under continuous metrics, so the question is not fully closed.

In-Context Learning and Chain-of-Thought

Two behaviors are frequently cited as emergent: in-context learning and chain-of-thought prompting. In-context learning is the ability to perform a task from a few examples placed in the prompt, with no weight updates. Wei et al. listed few-shot in-context performance on several tasks as appearing only above certain scales, which is part of why the behavior is associated with emergence.

Chain-of-thought prompting asks a model to produce intermediate reasoning steps before a final answer. In the original study, adding chain-of-thought hurt or did not help smaller models and only improved accuracy for sufficiently large ones, on the order of 100 billion parameters for the arithmetic tasks tested. This scale dependence is one of the more cited pieces of evidence for emergence, though it too is measured with thresholded accuracy and so is subject to the metric critique.

These behaviors connect emergence to reasoning models and to evaluation design. If a capability only shows up above a certain size, then claims about what a smaller or quantized model can do must be tested directly rather than assumed, and the metric used to test it can change the conclusion.

In-context learning lets a model adapt from prompt examples without retraining.
Chain-of-thought adds intermediate reasoning steps before the final answer.
Chain-of-thought helped only larger models in Wei et al., near 100B parameters on arithmetic.
Both behaviors are scored with thresholded metrics, so the mirage critique applies to them too.

Why Metric Choice Changes the Picture

The practical lesson is that the same model outputs can look emergent or smooth depending only on how they are scored. A short experiment makes this concrete: take a multi-step task, assume per-token accuracy improves gradually with scale, then plot exact-match against a token-level partial-credit metric. The exact-match curve stays near zero and then leaps, while the partial-credit curve rises steadily.

This has direct consequences for benchmarking. Reporting only exact-match or pass-or-fail accuracy can hide steady progress and create the impression of a threshold that is not there. Reporting a continuous metric alongside it, or per-token statistics, gives a more honest view of how performance changes with scale and reduces the risk of overclaiming a capability cliff.

The example below shows the effect with a toy model of per-token accuracy. The numbers are illustrative, not measured, but the shape mirrors what the mirage paper demonstrated on real benchmarks: a discontinuous metric manufactures a jump that a continuous metric does not.

python

# Toy illustration of how metric choice changes an 'emergence' curve.
# per_token_acc grows smoothly with model scale; outputs are L tokens long.
scales = [1, 2, 4, 8, 16, 32, 64, 128]  # arbitrary scale units
per_token_acc = [0.50, 0.62, 0.73, 0.82, 0.89, 0.94, 0.97, 0.99]
L = 5  # answer length in tokens

for s, p in zip(scales, per_token_acc):
    exact_match = p ** L            # discontinuous: all tokens must be right
    token_score = p                 # continuous: partial credit per token
    print(f"scale={s:>3}  per_token={p:.2f}  "
          f"exact_match={exact_match:.3f}  token_score={token_score:.2f}")

# exact_match stays low, then rises sharply (looks 'emergent'),
# while token_score rises smoothly from the same underlying trend.

A smooth rise in per-token accuracy looks like a sudden jump under exact-match (p^L) but stays smooth under a token-level metric, mirroring the Schaeffer et al. 2023 argument.

Exact-match scoring can manufacture an apparent jump from a smooth underlying trend.
Continuous or partial-credit metrics reveal the steady progress that exact-match hides.
Benchmarks should report continuous metrics alongside pass-or-fail to avoid overclaiming.
The same outputs can read as emergent or smooth purely from the metric applied.

How to Reason About Emergence in Practice

Because the debate is unsettled, the safe working stance is to treat emergence as a description of observed benchmark curves rather than a proven mechanism. When a report shows a capability appearing at scale, the first question is which metric produced the curve and whether a continuous version shows the same shape.

For teams deploying models, this means capabilities should be measured directly on the target task and scale, not inferred from a scaling narrative. A smaller, fine-tuned, or quantized model may or may not retain an ability that a benchmark labeled emergent, and only task-specific evaluation can settle it. Metric design is part of that evaluation, not an afterthought.

The balanced summary is that scaling reliably reduces loss and tends to improve downstream performance, that some of the most dramatic 'sudden capability' plots are heavily shaped by discontinuous metrics, and that a residual set of cases still invites study. Treating emergence as settled in either direction overstates the current evidence.

Treat emergence as a label for benchmark curves, not a proven mechanism.
Always ask which metric produced a reported capability jump.
Measure capabilities directly at the target scale rather than assuming them.
Scaling lowers loss reliably, but dramatic capability cliffs are often metric-driven.

Key takeaways

Emergent capabilities are abilities absent in small models but present in large ones, popularized by Wei et al. 2022 (arXiv:2206.07682, TMLR).
Schaeffer, Miranda, and Koyejo 2023 (arXiv:2304.15004) argue many apparent emergences are artifacts of nonlinear metrics like exact-match.
Discontinuous metrics turn smooth per-token gains into sharp-looking jumps; continuous metrics often remove the discontinuity.
Scaling laws predict smooth loss decreases, which the mirage view says explains apparent downstream jumps without a phase change.
Chain-of-thought helped only large models (near 100B parameters) in the original study, but is still scored with thresholded metrics.
The debate is not settled: treat emergence as a description of benchmark curves and measure capabilities directly at the target scale.

Frequently asked questions

They are abilities that are not present in smaller models but appear in larger ones, where size is measured by compute, parameters, or data. The term was popularized by Wei et al. in 2022, who defined an ability as emergent if it cannot be predicted by extrapolating from smaller models. Reported examples include multi-step arithmetic, MMLU, and chain-of-thought gains at scale.

This is actively debated. Schaeffer, Miranda, and Koyejo argued in 2023 that many apparent emergences are artifacts of discontinuous metrics like exact-match and largely vanish under continuous metrics. Scaling still reliably lowers loss and improves performance, but the dramatic sudden jumps are often shaped by the metric, so emergence should not be treated as settled.

A metric like exact-match requires every token of an answer to be correct, so a smooth rise in per-token accuracy stays near zero and then leaps once accuracy is high enough. A continuous metric such as token-level edit distance gives partial credit and shows the same progress as a smooth curve. The same model outputs can therefore look emergent or gradual depending only on scoring.

Scaling laws show pretraining loss falling smoothly with scale, usually as a power law. The mirage view reconciles this with sharp downstream jumps by noting that a smooth loss can pass through a nonlinear benchmark metric and appear discontinuous. Under that account there is one smooth trend viewed through different measurement lenses.

It is often cited as one. In the original study, chain-of-thought prompting did not help and sometimes hurt smaller models, improving accuracy only for models around 100 billion parameters on the arithmetic tasks tested. That scale dependence is evidence cited for emergence, though it is measured with thresholded accuracy and so is subject to the metric critique.

Test it directly on your target task at the scale you plan to deploy, rather than inferring from a scaling narrative. Report a continuous metric alongside any pass-or-fail score so steady progress is not hidden by a threshold. A quantized or fine-tuned model may or may not retain an ability a benchmark labeled emergent, and only task-specific evaluation settles it.

Put the idea into practice

MemX is an AI memory agent built on these ideas: store anything, skip the folders, and find it again by asking in plain English.

Try MemX Free