The cliff in the dashboard

Emergence has a respectable scientific ancestry. In physics, collective organisation can demand concepts that are not useful at the level of isolated components. Philip Anderson’s “more is different” was not a licence to call every surprise emergent. It was a claim that scale and organisation can create stable higher-level regularities that require their own explanatory vocabulary.¹ The challenge for machine learning is that its higher-level regularities arrive through an evaluation pipeline. We never observe “capability” naked. We observe model outputs under a task interface, then score, aggregate and compare them.

That matters because modern scaling research contains two facts that can coexist. Pre-training loss has often changed smoothly and predictably with model size, data and compute over substantial ranges.² Yet downstream tasks have sometimes shown delayed, steep or apparently discontinuous gains, motivating the language of emergent abilities.⁵ A steep benchmark curve does not tell us which fact caused it. The curve may reveal a new internal organisation, a smooth latent improvement passed through a nonlinear score, a mixture of successful and unsuccessful training runs, or sparse sampling across scale.

The hidden transparency assumption

When a score rises suddenly, the mind treats the metric as a transparent window. The hidden assumption is that the plotted y-axis preserves the important geometry of the underlying behaviour. Sometimes it does. Often it compresses, thresholds or selects. Exact match discards partial success. Pass@1 ignores the probability mass assigned to a correct program. A benchmark average hides which item difficulties changed. A best-of-twenty prompt result mixes model capability with a search procedure. A leaderboard rank turns small score differences into discrete positions.

A ruler is more than the final metric. It includes the task sample, prompt distribution, decoding rule, scoring function, aggregation, baseline, scale variable, model-selection rule and any threshold used to declare success. Each choice may be reasonable for a particular decision. The error is to treat one reasonable ruler as if it were the unique natural coordinate system of the capability.

Why the distinction changes engineering

Suppose a code model crosses a 90 per cent unit-test threshold. For release management, that binary crossing may be exactly the right operational ruler. A service either meets its acceptance criterion or it does not. But the threshold cannot also carry the scientific claim that a new internal algorithm appeared. The operational consequence may be real even when the cliff is measurement-created.

This distinction prevents two opposite mistakes. The first is hype: a benchmark threshold is advertised as an unforeseen cognitive phase transition. The second is complacency: because the underlying curve is smooth, a team ignores a real external threshold such as the point at which automated exploitation becomes economical. Smooth capability can produce discontinuous consequences. Scientific attribution and operational control therefore require different, explicitly named rulers.

flowchart LR
  A["The capability that appeared<br/>on Thursday"] --> B["The cliff in the dashboard"]
  B --> C["How a ruler manufactures a jump"]
  C --> D["When the cliff is in the system"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#007D68,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

How a ruler manufactures a jump

Let s denote scale. It might mean parameters, training tokens, training compute, inference compute or a lower-dimensional capability coordinate. Let z(s) denote the system’s internal state and y its raw response on an item. A reported score can be written schematically as:

The symbol θ collects the ruler settings. The equation is not an explanation. It is a reminder that the plotted curve is composed. A discontinuity in R can enter through z, the response distribution, the metric, the aggregation or the threshold. Calling the result emergent before locating the discontinuity skips the causal work.

Nonlinearity is enough

Take the lock again. If each of k required substeps succeeds with probability p(s), exact-match success is q(s)=p(s)^k under conditional independence. Even when p(s) is a gentle sigmoid, raising it to the twelfth power delays visible success and steepens the region near the top. The independence assumption is rarely exact. Correlated errors can make the curve steeper or flatter. The mechanism remains: an all-components-must-pass rule changes the geometry.

Finite test sets add another ruler. With 100 items, a true success probability below one per cent will often produce zero observed successes. The score therefore has a resolution of one percentage point and substantial binomial noise. Sparse model sizes then turn a steep but continuous curve into three points on the floor and one point above it. The eye draws a phase transition through missing measurements.

One model has several scales

Parameter count is a particularly tempting ruler because it is simple. It is also incomplete. Training tokens and model size jointly determine a compute-efficient frontier, as the Chinchilla experiments made concrete.³ Data mixture, curriculum, post-training, retrieval, tool access, decoding and test-time search can move downstream performance without changing parameter count. A capability plotted against parameters may look late only because smaller models were undertrained or lacked the relevant data.

Recent work makes the point from another angle. Fine-tuning a task can shift its apparent emergence point towards smaller models, enabling forecasts from otherwise chance-level base models in some settings.¹² This does not prove that emergence is unreal. It proves that “critical scale” is conditional on a learning path. The correct x-axis is part of the causal claim, not decoration beneath it.

What survives a change of coordinates

There is a useful mathematical distinction between a steep curve and a discontinuous one. Suppose a latent competence c(s) changes smoothly with scale, and the reported score is r(s)=g(c(s)). If g is smooth, then r remains smooth, but its slope becomes g′(c)c′(s). A transformation with a large derivative in one region can make a gentle improvement look abrupt. If g is a hard threshold, the displayed score can contain a literal step even though c does not.

This matters because empirical papers often use “discontinuous” to describe a few widely separated observations. Four points cannot establish a mathematical discontinuity. They can establish that a chosen model fits a steep transition better than a chosen smooth baseline, subject to uncertainty. Add dense checkpoints or an intermediate loss and the apparent gap may fill. Conversely, a smooth fitted curve can conceal two qualitatively different strategies if both produce similar aggregate scores.

Physics handles a related problem by searching for an order parameter, a quantity that tracks the organisation responsible for a phase change. For a learning system, test accuracy is not automatically that quantity. Circuit strength, margin distribution, error correlation, representational rank or probability of entering a successful training basin may be better progress measures. The most informative ruler is the one that changes when the proposed mechanism changes. It should predict held-out behaviour and respond selectively to causal intervention, rather than only correlate with scale.

Selection is a ruler too

Best-of-n, self-consistency, verifier selection and tool retries can all be legitimate system designs. They must be placed inside the candidate boundary. Otherwise a scaling curve silently compares different amounts of inference work. This is the same reason that a person with a calculator and a person without one are not measurements of the same configured cognitive system.

There is no single universal debunking metric. Schaeffer and colleagues showed that nonlinear or discontinuous metrics could generate apparent emergent abilities from fixed model outputs in several cases, while continuous metrics yielded smoother trends.⁶ Later work has shown that seed distributions, continuous loss behaviour and task learning can still produce steep or delayed transitions.¹³ The lesson is methodological rather than partisan: run the ruler intervention instead of assuming its result.

When the cliff is in the system

If every apparent jump could be dissolved by rescoring, emergence would be only a measurement error. That conclusion is too strong. Complex learning systems can reorganise. New circuits can become causally sufficient, training can enter a different basin, and a composed system can cross a stability boundary. The problem is not that system emergence is impossible. It is that a graph of one metric cannot locate it.

Three locations of the cliff

The useful distinction is not “real versus fake” emergence. It is a typed claim about where the discontinuity resides.

The three types can stack. A mechanism may gradually strengthen, a behavioural success probability may then steepen, and a binary score may make the final chart look instantaneous. Removing the display cliff does not show that the underlying mechanism is unchanged. Finding a stable behavioural cliff does not show which internal process created it.

Grokking shows why “sudden” needs a progress measure

Grokking is a useful boundary case. Small neural networks can fit training data and then, much later, jump from chance to near-perfect generalisation on algorithmic tasks.⁹ Behaviourally, the transition is striking. Mechanistic analysis of modular addition found continuous phases of memorisation, circuit formation and cleanup. Structured Fourier components grew before the visible generalisation jump, and causal ablations supported the identified algorithm.¹⁰

This does not make grokking unreal. It changes the explanation. The observed capability is a thresholded consequence of competing internal circuits. The correct “order parameter” was not test accuracy alone but the strength and interaction of mechanism-specific components. A better ruler did not erase the phenomenon. It located its precursor.

A recent preprint offers a complementary controlled result. Baherwani and colleagues report that pattern completion and indirect-object identification can appear abruptly when task-relevant sparse attention patterns are learned, with larger models acquiring them earlier on average in synthetic settings.¹⁴ Because the study is recent, preprint-stage and focused on controlled tasks, it should not be generalised to all large-model capabilities. It nevertheless supplies the kind of evidence a mechanism claim needs: a candidate circuit, training trajectories and architecture-sensitive interventions.

A worked configured-system audit

Consider Mica-Code, a synthetic family of six checkpoints evaluated on program synthesis. The decision-relevant score is pass@1: does the generated program pass every hidden unit test? The research team also preserves per-test pass fractions, syntax validity, calibrated probability assigned to the selected program, prompt-level distributions and adversarial variants. No real deployment or measurement is claimed here. The numbers are designed to expose the audit logic.

Synthetic worked example. Percentages are illustrative and not evidence about any real model family.

The exact score suggests a dramatic M4-to-M5 breakthrough. Partial credit and rule-preserving variants show a steadier trajectory. Prompt medians reveal that some of the pass@1 jump came from selection. Yet the M5 and M6 mechanism evidence raises a second possibility: a causally useful circuit is becoming available at roughly the same region. The correct verdict is not “mirage” or “proven phase transition”. It is display-amplified behavioural transition with emerging mechanism support.

The criterion: invariance plus intervention

A strong system-emergence claim should satisfy three demands. First, the transition should be reasonably stable across admissible rulers that preserve the task’s causal demand. Second, it should replicate across seeds, checkpoints and nearby task variants rather than depend on one lucky run or one sparse interval. Third, a candidate mechanism should survive causal tests: ablation, patching, architecture substitution, state replacement or training intervention.

Ruler invariance is necessary but not sufficient. Several correlated metrics can inherit the same hidden threshold. Mechanism evidence is also not sufficient on its own. A circuit may be readable and causally relevant while growing smoothly. The word “emergent” earns explanatory value only when the location and type of the transition are stated.

Which rulers are admissible?

Ruler sensitivity does not mean trying arbitrary transformations until every claim disappears. An admissible ruler must preserve the question under investigation. Four tests help. Task preservation asks whether the alternative metric rewards the same causal achievement. Giving partial credit for correct intermediate steps preserves much of a multistep reasoning task; replacing reasoning with lexical overlap does not. Information preservation asks whether the ruler exposes evidence already present in the raw record rather than importing a new capability.

Decision relevance asks whether the ruler corresponds to a real consequence. Exact transaction completion may be the right measure for operations even when it is a poor diagnostic of learning. Specification independence asks whether the ruler was declared without inspecting which choice made the curve most dramatic. A post hoc threshold can still be explored, but it cannot carry the same confirmatory weight as a pre-registered one.

These tests also constrain comparisons across systems. If one model receives tool retries, a verifier and a larger sampling budget, the evaluation is no longer a ruler change applied to the same candidate. It is a different configured system. The audit must either equalise those resources or enlarge the candidate boundary and plot total inference cost. Likewise, changing the task distribution from familiar templates to rule-preserving variants is more than rescoring. It is a controlled environmental intervention that tests whether the claimed capability travels.

The practical consequence is a small equivalence class, not an unlimited metric zoo. A good audit might include item-level log loss, partial task completion, exact success, an operational threshold and one rule-preserving transfer set. Agreement across this family is meaningful because each ruler retains a declared relation to the target capability. Disagreement is also meaningful because it localises what the original score compressed. Robustness means stability across justified alternatives, not stability across every imaginable description.

stateDiagram-v2
  [*] --> Claim
  state "The hidden transparency assumption" as Claim
  state "Why the distinction changes<br/>engineering" as Test
  state "Nonlinearity is enough" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Audit before you name emergence

The ruler-sensitivity audit is a decision instrument, not a metaphysical detector. It asks what happens to the claimed breakpoint when the raw observations are passed through alternative defensible rulers. It then asks whether any remaining transition has a distributional or mechanistic correlate. The output is a typed conclusion with prohibited inferences.

The eight-step protocol

Preserve item-level evidence. Store outputs, probabilities or losses, prompt identifiers, decoding settings, seeds, checkpoints and task metadata. Aggregate-only leaderboards cannot be fully audited. Next, declare the candidate boundary and the proposed scale axis. Parameter count, training compute and inference budget are not interchangeable.

Construct a family of admissible rulers before looking for the most dramatic curve. Include at least one continuous precursor, one decision-relevant outcome, multiple thresholds, prompt or interface variants, and disaggregated item difficulties. Fit smooth and change-point models with held-out scales. Report uncertainty and breakpoint dispersion rather than selecting the prettiest fit.

Inspect distributions across seeds and checkpoints. A mean may conceal two modes, and one final checkpoint may conceal a long precursor. Then intervene on the candidate mechanism or learning path. Finally, issue one of three typed verdicts: ruler-driven, system-supported or unresolved. None of these verdicts establishes strong metaphysical emergence or consciousness.

Executable artefact: the ruler-sensitivity audit

The Python artefact below generates a synthetic scaling family or reads a CSV. It computes several rulers from the same item-level records, estimates each ruler’s steepest transition, measures breakpoint dispersion, and combines that result with an explicit mechanism-intervention flag. It is intentionally conservative. A positive result permits a system-supported emergence hypothesis, not a claim of ontological novelty. A negative result says the observed cliff is sensitive to the ruler. It does not say the underlying capability is unimportant.

Run it with Python 3.10 or later and NumPy. Save the code as ruler_audit.py, then execute python ruler_audit.py. To use real records, provide a CSV with columns scale, seed, item, probability, correct and partial, then replace the synthetic-data call with a loader that returns records in the same shape.

from __future__ import annotations

from dataclasses import dataclass, asdict
from typing import Callable, Iterable
import json
import numpy as np


@dataclass(frozen=True)
class Record:
    scale: float
    seed: int
    item: int
    probability: float
    correct: int
    partial: float


@dataclass(frozen=True)
class RulerResult:
    name: str
    breakpoint: float
    breakthrough_ratio: float
    values: list[float]


def logistic(x: np.ndarray, centre: float = 5.2, rate: float = 0.82) -> np.ndarray:
    return 0.34 + 0.63 / (1.0 + np.exp(-rate * (x - centre)))


def synthetic_records(
    scales: Iterable[float] = range(1, 11),
    seeds: int = 12,
    items: int = 240,
    substeps: int = 10,
    rng_seed: int = 7,
) -> list[Record]:
    """Create item-level records with smooth component skill and steep exact match."""
    rng = np.random.default_rng(rng_seed)
    rows: list[Record] = []
    for scale in scales:
        base = float(logistic(np.array([scale]))[0])
        for seed in range(seeds):
            seed_shift = rng.normal(0.0, 0.028)
            for item in range(items):
                difficulty = rng.normal(0.0, 0.055)
                p_step = float(np.clip(base + seed_shift - difficulty, 0.01, 0.995))
                steps = rng.binomial(1, p_step, size=substeps)
                partial = float(steps.mean())
                correct = int(steps.all())
                rows.append(Record(scale, seed, item, p_step, correct, partial))
    return rows


def group_metric(rows: list[Record], fn: Callable[[list[Record]], float]) -> tuple[np.ndarray, np.ndarray]:
    scales = np.array(sorted({r.scale for r in rows}), dtype=float)
    values = np.array([fn([r for r in rows if r.scale == s]) for s in scales], dtype=float)
    return scales, values


def steepest_breakpoint(scales: np.ndarray, values: np.ndarray) -> tuple[float, float]:
    """Return midpoint of the largest adjacent gain and its ratio to typical positive gain."""
    gains = np.diff(values) / np.diff(scales)
    idx = int(np.argmax(gains))
    positive = gains[gains > 1e-12]
    typical = float(np.median(positive)) if positive.size else 1e-12
    ratio = float(gains[idx] / max(typical, 1e-12))
    return float((scales[idx] + scales[idx + 1]) / 2.0), ratio


def evaluate_rulers(rows: list[Record]) -> list[RulerResult]:
    rulers: dict[str, Callable[[list[Record]], float]] = {
        "mean_probability": lambda xs: float(np.mean([r.probability for r in xs])),
        "partial_credit": lambda xs: float(np.mean([r.partial for r in xs])),
        "exact_match": lambda xs: float(np.mean([r.correct for r in xs])),
        "useful_at_70pct": lambda xs: float(np.mean([r.partial >= 0.70 for r in xs])),
    }
    results: list[RulerResult] = []
    for name, fn in rulers.items():
        scales, values = group_metric(rows, fn)
        breakpoint, ratio = steepest_breakpoint(scales, values)
        results.append(RulerResult(name, breakpoint, ratio, values.round(6).tolist()))
    return results


def ruler_sensitivity(results: list[RulerResult], scale_span: float) -> float:
    """Maximum breakpoint spread as a fraction of the tested scale range."""
    points = np.array([r.breakpoint for r in results], dtype=float)
    spread = float(points.max() - points.min())
    return spread / max(scale_span, 1e-12)


def audit(rows: list[Record], mechanism_intervention_positive: bool = False) -> dict:
    results = evaluate_rulers(rows)
    scales = sorted({r.scale for r in rows})
    sensitivity = ruler_sensitivity(results, max(scales) - min(scales))
    all_steep = all(r.breakthrough_ratio >= 1.8 for r in results)

    if sensitivity > 0.12:
        verdict = "RULER_DRIVEN"
        permits = "Use decision thresholds operationally, but do not infer a system phase change."
    elif mechanism_intervention_positive and all_steep:
        verdict = "SYSTEM_SUPPORTED"
        permits = "Treat system emergence as a testable hypothesis and replicate it."
    else:
        verdict = "UNRESOLVED"
        permits = "Report a behavioural transition and collect mechanism evidence."

    return {
        "verdict": verdict,
        "ruler_sensitivity": round(sensitivity, 4),
        "mechanism_intervention_positive": mechanism_intervention_positive,
        "rulers": [asdict(r) for r in results],
        "what_positive_means": permits,
        "cannot_establish": [
            "strong metaphysical emergence",
            "consciousness or sentience",
            "transfer beyond the tested task family",
        ],
    }


if __name__ == "__main__":
    data = synthetic_records()
    report = audit(data, mechanism_intervention_positive=False)
    print(json.dumps(report, indent=2))

How the audit can be gamed

An evaluator can search hundreds of prompts, metrics and task subsets, then publish the combination with the sharpest jump. This is breakpoint p-hacking. The inverse is also possible: choose a smoothing transform that dissolves a real decision boundary. The safeguard is to pre-register the ruler family, preserve every attempted specification, and distinguish exploratory from confirmatory analysis.

Dense, controlled model suites make this work much easier. Pythia, for example, provides many sizes and checkpoints trained on public data in the same order, enabling trajectory analysis that a handful of final models cannot support.⁸ Observational scaling across many public models has also found that several apparently emergent behaviours can be modelled as smooth sigmoids and forecast from weaker models, while acknowledging family-efficiency differences.¹¹ These results do not end the emergence debate. They show what higher-resolution rulers can recover.