Emergent Abilities in Large Language Models: Real or a Mirage?

Emergent abilities in large language models are the skills that seem to switch on at some model size: a family of models scores at chance on a task, then a slightly bigger sibling suddenly does well. Whether those switches are real changes in what the network computes, or an optical effect of the scoring rules researchers use, is still argued in the literature. The answer matters for more than tidiness. If capabilities appear abruptly, nobody can forecast what the next training run will be able to do, and safety evaluation has to treat every scale-up as a possible surprise. If the jumps are a measurement effect, careful metrics should make capability growth roughly as predictable as training loss.

The question travels well beyond conference halls. A 2023 preprint that asked it outright was reposted, for example, on the LibreTranslate community forum, and newsletter explainers on the same paper turn up readily in search results. This article sets out what is known, steelmans the competing readings, runs a small simulation built for it, and ends with tests that could settle the matter.

The precise question

The term has a fairly exact origin. Wei and colleagues (2022) catalogued tasks where performance sat flat across smaller models and then rose steeply, and defined the property this way:

“We consider an ability to be emergent if it is not present in smaller models but is present in larger models.”

Wei et al., 2022

That definition is about observations, not mechanisms. It says nothing about why the curve bends. So the open question can be stated in two parts. First, when a benchmark plot shows a sharp rise with scale, does some internal quantity that drives the behavior also change sharply, or does a smoothly improving quantity pass through a scoring rule that converts gradual change into a cliff? Second, even granting the measurement story for some tasks, are there tasks where no reasonable continuous metric removes the jump?

A related distinction helps. Ganguli et al. (2022) described a paradox in large generative models: aggregate loss on the training distribution follows smooth trends, yet specific capabilities are hard to anticipate. Smooth loss scaling itself is well documented; Kaplan et al. (2020) reported power-law relationships between cross-entropy loss and model size, data and compute, some spanning more than seven orders of magnitude. Downstream task scores are a different matter, and that gap is where the dispute lives.

What is established

Several points are not seriously contested.

• Pre-training loss falls smoothly and predictably as models grow (Kaplan et al. 2020).
• Plots of task accuracy against model scale do sometimes show long flat stretches followed by steep climbs; this is an empirical pattern in published benchmark results (Wei et al. 2022).
• The choice of metric changes the shape of those plots. Schaeffer, Miranda and Koyejo (2023), presented at NeurIPS 2023, showed that for GPT-3-family models on multi-digit arithmetic, exact-match accuracy looked emergent for longer answers while token edit distance on the same outputs improved smoothly.
• Sharp transitions do occur during training of small networks on some tasks. Learning sparse parities with stochastic gradient descent produces abrupt drops in error after long plateaus (Barak et al. 2022, preprint).

In the BIG-Bench meta-analysis within the same 2023 paper, the authors report that at most 5 of 39 preferred metrics showed emergence, and that claimed emergent abilities clustered under a small number of metrics such as Multiple Choice Grade and Exact String Match. Switching one LaMDA result from Multiple Choice Grade to the continuous Brier score made the jump disappear. Those are their figures; this article did not re-run them.

Hypothesis one: a mirage of the metric

The strongest version of the skeptical case runs like this. Suppose a model’s probability of producing each correct token improves gradually with scale. A task scored by exact match on a k-token answer only rewards the model when every token is right, so its score behaves roughly like per-token accuracy raised to the k-th power. Raising a slowly growing number to a high power keeps it near zero for a long time and then lifts it fast. Add a finite test set, and the small models record a flat zero because the true score is below what a few hundred items can resolve.

Schaeffer and colleagues were careful about the scope of the claim. Their paper does not say emergence is impossible:

“nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities”

Schaeffer, Miranda and Koyejo, 2023

A later preprint from an overlapping group, Schaeffer et al. (2024), extended the argument to multiple-choice benchmarks across five model families and twelve benchmarks. Their account is that the score is reached through a chain of transformations from log-likelihoods, and each step weakens the link to scale; forecasting accuracy requires modeling how probability on specific wrong answers moves, not only probability on the right one. A third line, from Lu et al. (2023, preprint), attributes many reported emergent abilities to a combination of in-context learning, memorized knowledge and linguistic competence, based on more than a thousand experiments.

Evidence against this hypothesis is mostly that it explains some cases far better than others. It handles arithmetic and exact-string tasks neatly. It is less obviously sufficient for tasks where even the best continuous metric shows a plateau.

Hypothesis two: genuine thresholds

The opposing reading holds that some abilities do depend on internal changes that happen over a narrow range of scale or training. The cleanest evidence comes from studying loss rather than parameter count. Du et al. (2024, preprint) trained models with matched corpora, tokenization and architecture and found that downstream performance tracked pre-training loss across different sizes, staying at chance until loss fell below a task-specific threshold. They report that this held under continuous metrics as well, which speaks directly to the mirage critique. Their proposal:

“This inspires us to redefine emergent abilities as those that manifest in models with lower pre-training losses”

Du et al., 2024

Training-dynamics research adds a mechanistic angle. Sparse-parity learning shows discontinuous error curves even though, according to Barak and colleagues, gradient descent is quietly amplifying the correct features the whole time; standard loss and error metrics do not reveal that progress until the transition. Grokking tells a similar two-sided story. Nanda et al. (2023) reverse-engineered small transformers trained on modular addition and found a Fourier-based algorithm forming inside them. Their summary cuts both ways:

“grokking, rather than being a sudden shift, arises from the gradual amplification of structured mechanisms”

Nanda et al., 2023

Read one way, this supports the measurement camp: the jump in test accuracy rides on a continuous internal process. Read another, it shows that a qualitatively new circuit can take over the behavior, and the visible switch reflects that changeover, which is something more than a scoring quirk. Nanda and colleagues supply the progress measures that let both readings be checked, which is the main reason their work matters here.

A third position: real, but forecastable

A middle view is gaining ground: thresholds may be genuine at the level of observable task success, yet still predictable in advance with the right instruments. Snell et al. (2024, preprint) found that fine-tuning on a task shifts its point of emergence toward smaller models. By fitting what they call emergence laws across fine-tuning amounts, they report that small-model data can, in some cases, predict whether models trained with up to four times more compute will have crossed the threshold, on MMLU, GSM8K, CommonsenseQA and CoLA. The hedge “in some cases” is theirs.

This position shifts the dispute from metaphysics to engineering. If loss thresholds, fine-tuning probes or wrong-answer modeling can forecast a jump, the label “emergent” stops implying “unpredictable,” even if the curve really is steep. The survey by Berti, Giorgi and Kasneci (2025, preprint) notes that the field’s definitions remain inconsistent, which is part of why people talk past each other.

A small simulation built for this article

The experiment below asks a narrow question: how much apparent emergence can exact-match scoring manufacture out of smooth skill growth, and what would a genuine threshold look like under the same tools? It simulates 41 hypothetical model sizes spaced evenly in log scale from 10⁷ to 10¹² parameters. Per-token accuracy follows a logistic curve in log size, with a floor of 0.10 (chance for a single digit) and a ceiling of 0.99. Two scenarios are compared. In the smooth one, per-token skill takes about three decades of scale to rise from 10% to 90% of its total gain. In the step one, per-token skill itself jumps within under half a decade.

Each model is scored on 200 test items using exact match on answers of k tokens, with tokens treated as independent, so exact-match probability equals per-token accuracy to the power k. Binomial sampling adds realistic test-set noise. Finally, a logistic curve is fitted to per-token accuracy from models at or below 10⁹ parameters only, and used to forecast exact match at 10¹¹ and 10¹². Python with NumPy and SciPy; random seed fixed at 5.

import numpy as np
from scipy.optimize import curve_fit
rng = np.random.default_rng(5)
logN = np.linspace(7, 12, 41)            # model size: 10^7 to 10^12 parameters
sig = lambda x, a, c: 1/(1 + np.exp(-a*(x - c)))
tokacc = lambda x, a, c: 0.10 + 0.89*sig(x, a, c)   # per-token accuracy, floor = chance
SCEN = {"smooth": (1.2, 9.0),            # per-token skill improves gradually
        "step":   (12.0, 10.5)}          # per-token skill itself jumps
def width(y):                            # decades to go from 10% to 90% of total gain
    g = (y - y[0])/(y[-1] - y[0])
    return logN[np.argmax(g >= 0.9)] - logN[np.argmax(g >= 0.1)]
N_ITEMS = 200
print("scenario  k  width_tok width_EM  EM@1e9 zero_score_models onset(EM>=10%)")
for s, (a, c) in SCEN.items():
    p = tokacc(logN, a, c)
    for k in [1, 2, 5, 10, 20]:
        em = p**k                          # exact match needs all k tokens right
        em_obs = rng.binomial(N_ITEMS, em)/N_ITEMS
        print(f"{s:7s} {k:3d} {width(p):9.2f} {width(em):8.2f} {tokacc(9.0,a,c)**k:7.3f}"
              f" {np.sum(em_obs == 0):17d} {logN[np.argmax(em_obs >= 0.10)]:14.2f}")
# Forecast: fit per-token accuracy on small models only (<= 10^9), predict exact match
print("scenario  k  predEM@1e11 trueEM@1e11 predEM@1e12 trueEM@1e12")
for s, (a, c) in SCEN.items():
    k, small = 10, logN <= 9.0
    p_obs = rng.binomial(N_ITEMS*k, tokacc(logN, a, c))/(N_ITEMS*k)
    (ah, ch), _ = curve_fit(tokacc, logN[small], p_obs[small], p0=[1, 9],
                            bounds=([0.1, 7], [20, 14]))
    pred = [tokacc(x, ah, ch)**k for x in (11, 12)]
    true = [tokacc(x, a, c)**k for x in (11, 12)]
    print(f"{s:7s} {k:3d} {pred[0]:11.3f} {true[0]:11.3f} {pred[1]:11.3f} {true[1]:11.3f}")

The first table reports the width of each curve’s rise (decades of scale between 10% and 90% of the total gain), the true exact-match score at 10⁹, how many of the 41 models scored exactly zero on 200 items, and the smallest size whose observed exact match reached 10%.

Under smooth skill growth, lengthening the answer from 2 to 20 tokens narrowed the visible rise from 2.88 to 1.38 decades and pushed its onset from about 10^8.25 to 10^10.75 parameters. At k = 20, more than half the simulated models (22 of 41) scored a flat zero. Nothing about the underlying skill changed between those rows; only the answer length did. The step scenario looks different in one diagnostic respect: its per-token curve is itself narrow (0.38 decades), so the jump survives the switch to a continuous metric.

The forecasting test separates the cases more starkly. With k = 10:

When skill grows smoothly, the per-token curve from small models predicted large-model exact match to within about 0.01, even though exact match at those small sizes was essentially zero. When the skill genuinely steps, small models carry no signal at all, and the forecast misses by almost 0.9.

What this shows: exact match on multi-token answers can turn three decades of steady improvement into an abrupt-looking rise, and a continuous metric can make that rise forecastable. What it does not show: anything about real language models. The token-independence assumption is a simplification, the logistic shapes are chosen by hand, and the step scenario is put in by construction. Whether real abilities resemble the first table or the second is exactly the empirical question. Tokenization also matters, since k depends on how an answer is split; the byte-level models discussed in our piece on Bolmo and byteification would score the same answer over many more units.

The author’s reading

This section is opinion. My reading is that the original framing bundled two claims that should be separated. The observational claim, that benchmark scores sometimes rise steeply, is true and uninteresting by itself. The stronger claim, that new abilities appear unpredictably because something discontinuous happens inside the model, has lost much of its support for tasks scored by exact match or multiple choice. The mirage argument explains those cases economically, and the simulation above shows how little machinery that requires.

Even so, I do not think the measurement story covers everything. The loss-threshold results of Du and colleagues, if they replicate across labs, point to a real nonlinearity between pre-training loss and task competence, one that continuous scoring did not remove in their reports. The grokking and parity work shows such nonlinearities exist in small networks, even when a hidden progress measure moves smoothly underneath. A fair summary: emergence as a property of the eval is common; emergence as a property of the network is plausible for some tasks and unproven for most.

The practical stakes sit in forecasting. Benchmark scores already depend heavily on evaluation choices, a point our article on inference compute and fixed token budgets makes from a different direction, and on whether graders check final outcomes, as in benchmarks that grade the database rather than the reply. Anyone claiming a capability arrived unannounced should first show the continuous metric.

Tests that would settle it

The following predictions are framed so that results could go against them.

1. Continuous-metric replication. For each published emergent task, report a proper scoring rule (log-likelihood of the full correct answer, Brier score, or token edit distance) on the same model family. If the measurement hypothesis is right, the large majority of jumps should flatten into curves fitted well by a smooth function of log compute.
2. Pre-registered forecasts. Before a larger model is trained, publish predictions of its task scores using only smaller checkpoints, via per-token likelihoods, loss thresholds or fine-tuning emergence laws. Genuine unpredictable emergence predicts that these forecasts fail on some tasks by large margins, as the step scenario did here.
3. Matched-loss comparisons across labs. If tasks track pre-training loss with a sharp threshold, independent groups with different data should find thresholds at comparable loss values once tokenization is controlled. Scattered thresholds would weaken the loss-based account.
4. Mechanistic progress measures. For a task that still jumps under continuous metrics, look for an internal circuit whose strength grows before the behavioral jump. Finding one supports “hidden progress”; finding a component that forms abruptly would support a true internal phase change.
5. Evaluation resolution. Re-test small models on far larger item sets. If their exact-match scores are tiny but nonzero and lie on the curve implied by per-token accuracy, the flat region was a resolution artifact.

Common questions

Does the mirage paper prove emergent abilities are fake?

No. It shows that many reported jumps disappear when the metric is changed or the test set grows, and its authors say explicitly that models may still display genuine emergent abilities. It shifts the burden of proof onto anyone claiming a jump is intrinsic.

Why do exact-match scores create sudden jumps?

Exact match gives zero credit unless every part of the answer is right. If each part becomes more reliable gradually, the chance of getting all of them right stays tiny for a long time, then climbs quickly. Longer answers make the effect stronger.

Is grokking the same thing as emergence with scale?

Not quite. Grokking is a sudden improvement in generalization during training of a fixed model, while emergence usually refers to comparisons across model sizes. Both raise the same question of whether a visible jump hides gradual internal progress, which is why researchers discuss them together.

Can anyone predict what the next large model will be able to do?

Partially. Training loss is predictable, and several groups report forecasting some downstream scores from smaller models with continuous metrics or fine-tuning probes. No method has been shown to forecast every task, so specific capabilities can still surprise.

References

1. Wei, J., Tay, Y., Bommasani, R., et al. (2022). Emergent Abilities of Large Language Models. arXiv:2206.07682. https://arxiv.org/abs/2206.07682
2. Schaeffer, R., Miranda, B., & Koyejo, S. (2023). Are Emergent Abilities of Large Language Models a Mirage? Advances in Neural Information Processing Systems (NeurIPS 2023). arXiv:2304.15004. https://arxiv.org/abs/2304.15004
3. Schaeffer, R., Schoelkopf, H., Miranda, B., et al. (2024). Why Has Predicting Downstream Capabilities of Frontier AI Models with Scale Remained Elusive? arXiv preprint 2406.04391. https://arxiv.org/abs/2406.04391
4. Du, Z., Zeng, A., Dong, Y., & Tang, J. (2024). Understanding Emergent Abilities of Language Models from the Loss Perspective. arXiv preprint 2403.15796. https://arxiv.org/abs/2403.15796
5. Snell, C., Wallace, E., Klein, D., & Levine, S. (2024). Predicting Emergent Capabilities by Finetuning. arXiv preprint 2411.16035. https://arxiv.org/abs/2411.16035
6. Lu, S., Bigoulaeva, I., Sachdeva, R., Tayyar Madabushi, H., & Gurevych, I. (2023). Are Emergent Abilities in Large Language Models just In-Context Learning? arXiv preprint 2309.01809. https://arxiv.org/abs/2309.01809
7. Nanda, N., Chan, L., Lieberum, T., Smith, J., & Steinhardt, J. (2023). Progress measures for grokking via mechanistic interpretability. arXiv:2301.05217. https://arxiv.org/abs/2301.05217
8. Barak, B., Edelman, B. L., Goel, S., Kakade, S., Malach, E., & Zhang, C. (2022). Hidden Progress in Deep Learning: SGD Learns Parities Near the Computational Limit. arXiv preprint 2207.08799. https://arxiv.org/abs/2207.08799
9. Ganguli, D., Hernandez, D., Lovitt, L., et al. (2022). Predictability and Surprise in Large Generative Models. ACM. doi:10.1145/3531146.3533229. https://doi.org/10.1145/3531146.3533229
10. Kaplan, J., McCandlish, S., Henighan, T., et al. (2020). Scaling Laws for Neural Language Models. arXiv preprint 2001.08361. https://arxiv.org/abs/2001.08361
11. Berti, L., Giorgi, F., & Kasneci, G. (2025). Emergent Abilities in Large Language Models: A Survey. arXiv preprint 2503.05788. https://arxiv.org/abs/2503.05788