Emergent Abilities

Loss falls smoothly with scale. Some benchmark curves do not — they sit at chance across several orders of magnitude and then rise sharply. Wei et al. catalogued over a hundred such tasks and named the phenomenon emergence, defining it as an ability “not present in smaller models but present in larger ones”.

If true in the strong sense, it is a serious problem: capability would be unforecastable from anything measurable in advance, and safety evaluation of a model would tell you nothing about the next one.

The mirage argument

Schaeffer et al. observed that the tasks showing sharp emergence share a property. They are scored with a discontinuous metric — exact string match, multiple-choice accuracy, “all five digits correct”.

Consider arithmetic. A model’s per-token accuracy improves smoothly with scale. Exact match on a five-digit answer requires all five tokens right at once.

At $n = 5$, per-token accuracy rising smoothly from 0.3 to 0.9 takes exact match from 0.002 to 0.59 — a curve that looks flat, then vertical, produced by nothing but the exponent.

They go further and manufacture the effect on demand: applying a discontinuous metric to a vision model produces “emergent” abilities in a setting where nobody had claimed any.

What survives

Two things, and they are not nothing.

Discontinuous metrics are what people care about. A model that gets four digits of five right is wrong. If the deployment question is whether the model can do the task, the sharp curve is the honest one and the smooth curve is the diagnostic. The mirage argument reframes the mechanism without making the capability jump less real to a user.

Loss does not predict capability. This is the durable version. Two models at the same pre-training loss can differ substantially on downstream tasks, and the mapping from loss to any particular ability is not something we can compute. Scaling laws forecast loss precisely and forecast capability not at all, which is the gap Ganguli et al. call predictability and surprise: the aggregate is predictable, the specifics are not.

The state of the question

The strong claim — genuine phase transitions in capability — has not been supported once the metric is controlled for. A handful of candidate cases remain under discussion, and the honest position is that none is well established.

The practical consequence is unchanged. If you want to know whether a model can do something, measure that thing; the loss curve will not tell you, and neither will the previous model. And when you do measure it, use a continuous metric for the trend and a discontinuous one for the deployment decision — they are answering different questions and conflating them is how the argument started.

def exact_match_curve(token_accuracy: list[float], length: int) -> list[float]:
    """Turn a smooth per-token curve into an 'emergent' one. Schaeffer et al. §3."""
    return [p**length for p in token_accuracy]


def is_metric_artefact(scores: dict[str, list[float]]) -> str:
    """Plot the same predictions under a continuous metric. If the jump goes,
    it was the scoring; if it stays, the claim survives this test."""
    sharp = max(
        b - a for a, b in zip(scores["exact_match"], scores["exact_match"][1:])
    )
    smooth = max(
        b - a for a, b in zip(scores["edit_distance"], scores["edit_distance"][1:])
    )
    return "metric artefact" if sharp > 4 * smooth else "survives the substitution"

That second function is a rule of thumb rather than a test — the factor of four is a judgement call and the comparison assumes both metrics are on comparable scales. It is written down because the substitution is the thing worth doing, not because the threshold means anything.