Part I

The curve and its jurisdiction

Power-law learning curves appeared across language, vision, speech and translation before the current foundation-model era. Hestness and colleagues found that generalisation error often fell as a power of dataset size, with stable exponents across substantial ranges. Kaplan and colleagues then measured language-model cross-entropy against parameter count, data and compute across several orders of magnitude. [1][2]

The attraction is easy to understand. A straight line in log-log space lets a team train cheaper models, infer a slope, and forecast an expensive run. This is not merely descriptive. Once model size and training tokens both consume a fixed compute budget, the surface can prescribe an allocation.

The two decaying terms express different constraints. If the model is too small, the parameter term dominates. If it sees too little data, the data term dominates. Increasing a resource that is no longer the main constraint yields little benefit. Under the dense-transformer approximation C ≈ 6ND, minimising the fitted loss at fixed training compute C produces a compute-efficient frontier. [3]

The exponents matter more than the slogan. The Chinchilla parametric fit reported roughly α = 0.34 and β = 0.28, implying that optimal parameters and tokens grow at similar, though not identical, rates with compute. A larger α means the model-size penalty falls faster, so the optimum shifts relatively towards more data. A larger β does the reverse.

Compute-optimal does not mean universally optimal. It means lowest fitted training loss under a stated compute constraint. It does not include future inference demand, memory footprint, post-training, latency, data rights or the value of a specific task. Sardana and colleagues showed that including large inference demand can favour a smaller model trained on more tokens than a training-only Chinchilla optimum. [16]

From response surface to efficient frontier

The allocation rule follows from a constrained comparison, not from an intuition that parameters and tokens should look balanced. Set the approximate compute budget to C = 6ND. For any chosen parameter count, the token count is then D = C/(6N). Substituting that expression into the loss surface turns a two-variable problem into a one-variable curve. Its minimum is the point where spending the next marginal unit on capacity would reduce loss by the same amount as spending it on more training tokens.

With α = 0.34 and β = 0.28, the parameter exponent is about 0.45 and the token exponent about 0.55. Doubling compute would therefore raise the fitted optimal parameter count by roughly 37 per cent and tokens by roughly 46 per cent, rather than doubling either one. These values are illustrations from one fitted family, not portable constants.

The frontier is also conditional on the objective function. Change the objective from minimum training loss to minimum lifetime cost at a required quality, and inference enters the constraint. Change it to maximum verified task success under a latency ceiling, and test-time search, batching, memory bandwidth and verifier calls enter. The same loss surface can remain accurate while the operational optimum moves.

This is why a scaling law should be stored as a versioned experimental artefact. It needs the fitted equation, run manifest, compute definition, evaluation corpus, residuals, covariance or bootstrap samples, and the optimisation question it answered. A table containing only the recommended token-to-parameter ratio discards the evidence needed to know when the recommendation has expired.

Thought experiment one: one budget, several models

Hold dense training compute fixed at approximately 7.2 × 10²⁰ FLOPs. Consider three synthetic allocations under the same objective and data distribution: a 30-billion-parameter model trained on 4 billion tokens, a 2-billion-parameter model trained on 60 billion tokens, and a 6.75-billion-parameter model trained on 17.8 billion tokens.

All three spend nearly the same compute because their N × D products match. Using the synthetic surface from the fit lab, their losses are 2.412, 2.389 and 2.337 nats per token. The large, short-trained model is data-limited. The small, long-trained model is capacity-limited. The middle allocation sits near the fitted ridge.

The causal feature varied here is allocation, not scale. More parameters alone do not explain the result because compute and objective are held constant. That is the genuine contribution of the iso-loss surface: it turns “bigger is better” into a constrained optimisation problem.

This thought experiment also reveals a limitation. The optimum can be shallow. Small fitting errors, a different compute account, or a modest change in data quality can move the recommended point without materially changing loss. Treating one token-to-parameter ratio as a natural constant mistakes an empirical ridge for a law of physics.

Part II

flowchart TD
  A["The run that was right for the<br/>wrong question"] --> B["The curve and its jurisdiction"]
  B --> C["How smooth loss becomes<br/>unstable capability"]
  C --> D["Fit the law like an experiment"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,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 smooth loss becomes unstable capability

Cross-entropy averages the negative log probability assigned to the observed next token across a held-out distribution. A task score usually asks something else: whether a whole answer exactly matches, whether the correct option outranks several distractors, whether generated code passes all tests, or whether a long trajectory reaches a valid state.

Those scores are functions of model outputs, but they are rarely linear functions of average loss. A task can therefore improve smoothly at token level while its reported score stays flat, jumps, reverses or saturates.

Thought experiment two: change only the ruler

Suppose each larger model assigns slightly more probability to every correct digit in a ten-digit answer. The per-token log loss improves smoothly. Now score the answer two ways. Ruler A averages token log probability. Ruler B awards one point only when all ten digits are correct.

Nothing about the model changes between the two measurements. Under Ruler A, progress is continuous. Under Ruler B, small per-token gains multiply across the sequence and can create an apparent threshold. If the evaluation set is small, one or two additional exact answers can make the jump look even sharper.

Wei and colleagues catalogued abilities that appeared only beyond certain model scales. Schaeffer, Miranda and Koyejo later showed that nonlinear or discontinuous metrics can manufacture some of this appearance from smoothly changing outputs. Both observations matter: abrupt task scores can be operationally real even when the underlying behavioural change is gradual. [11][12]

Multiple-choice evaluation adds another source of instability. The score depends not only on probability assigned to the correct choice but also on several particular wrong choices. Schaeffer and colleagues analysed five model families across twelve benchmarks and found that successive transformations from negative log likelihoods to benchmark accuracy degraded predictability with scale. [10]

Distribution alignment matters as well. Isik and colleagues found machine-translation settings where downstream cross-entropy improved monotonically with more pretraining data while BLEU fluctuated or worsened under moderate pretraining-to-target misalignment. A good upstream curve can coexist with an unstable downstream bridge. [13]

Negative control: when the loss curve is enough

Now remove the extra bridge. The decision is to choose the lower cross-entropy model for the same held-out corpus, tokenizer, objective and inference protocol. No exact-match threshold, new population or tool-using workflow intervenes. In that case, the scaling law predicts the quantity the decision actually values.

This negative control matters because the argument is not “loss is meaningless”. Loss is a proper scoring rule for probabilistic prediction and often an informative upstream measure. Extrapolation theatre begins when a validated loss forecast is presented as if it had already validated a different metric or system.

Validate the bridge at the level where it can fail

A downstream bridge should not begin with one aggregate loss and end with one aggregate accuracy. Aggregation hides the very variation that makes the bridge unstable. Preserve per-example quantities long enough to test three separate claims.

Ordering claim. Does lower loss consistently rank models better on the target task? This is weaker than predicting the exact score, but often sufficient for model selection. Test rank stability across model sizes, seeds, prompt formats and target slices. A high overall correlation can conceal a reversal on the difficult or high-consequence tail.

Calibration claim. Given a forecast loss, can the team predict a task-score distribution with useful uncertainty? Fit the mapping on one set of model scales and test it prospectively on held-out scales. Use a continuous metric where possible. If the operational score is discontinuous, retain the continuous precursor as a diagnostic rather than pretending the threshold contains all information.

Transfer claim. Does the bridge survive the target population? A bridge calibrated on short English questions may fail on long documents, another language or tool-mediated tasks even when average pretraining loss improves. Stratify by features that change the mechanism: sequence length, retrieval dependence, answer entropy, interaction horizon and required exactness.

These tests produce an error decomposition. Let the loss forecast error be εL, the loss-to-capability bridge error εB, and the capability-to-outcome error εO. They should not be added mechanically because the transformations are nonlinear and the errors may correlate. Report them separately, then propagate them by simulation through the actual decision rule.

For example, a 0.01 loss miss may be immaterial on a smooth ranking metric and decisive near an exact-match threshold. A two-point task-score miss may be harmless when human review catches every residual and material when the error clusters in an irreversible action class. The consequence model determines which forecast error matters.

The strongest objection: perhaps the bridge is learnable

A critic can accept every warning above and reject the conclusion’s scope. Loss and capability are generated by the same model. Given enough model families, per-example probabilities and better functional forms, perhaps downstream behaviour will become almost as forecastable as pretraining loss. The current unpredictability could reflect weak measurement rather than a fundamental separation.

That objection is serious. The article does not require a permanent barrier. It requires the bridge to earn evidence as a distinct model. Research on transfer, downstream translation and multiple-choice probability structure points towards more predictable bridges. Better continuous metrics, loss-to-loss relations and distribution-aware features may reduce uncertainty substantially.

The thesis would be weakened by a prospective result with four properties: it predicts held-out larger models rather than fitting them retrospectively; it survives a new but specified data mixture; it predicts target-slice distributions rather than only an overall average; and its interval remains calibrated after the operational inference policy is applied. A bridge that passes those tests can legitimately carry the upstream forecast further.

Even then, the system boundary remains. Predicting code-test success does not predict repository repair under tool failures. Predicting question accuracy does not predict customer outcome under stale retrieval. The more of the surrounding system the evaluation fixes and measures, the farther the bridge can travel. The claim is therefore empirical and defeasible: downstream extrapolation is unearned until prospective calibration demonstrates otherwise.

Regime changes bend the surface itself

The previous section kept the training regime fixed and changed the downstream measurement. A more severe failure occurs when the fitted response surface no longer describes training.

A “regime” includes more than architecture. It includes the data distribution and mixture, deduplication, tokenisation, objective, optimiser, schedule, regularisation, batch regime, parameter accounting and what counts as compute. Porian and colleagues reproduced the discrepancy between Kaplan-style and Chinchilla-style prescriptions, then traced much of it to last-layer compute, warm-up duration and scale-dependent optimiser tuning. [5]

Fitting procedure also matters. Choshen, Zhang and Andreas estimated more than a thousand laws from 485 published models. They found that intermediate checkpoints help, nearby model sizes predict better, and seed variability can make several small runs more useful than one larger run. The Gemstones suite similarly found prescriptions sensitive to experimental design and checkpoint selection. [7][8]

A 2026 analysis identified systematic bias in parabolic IsoFLOP fitting even on noise-free synthetic data, while offering a better-conditioned alternative. The exact cost estimate is specific to its assumptions, but the methodological lesson is broader: a precise optimiser can return a precise answer to a misspecified approximation. [9]

Finite, repeated data is a clear example. Muennighoff and colleagues trained 400 models and found decreasing value from repeated tokens, motivating a separate data-constrained law. More recent preprints report that additive Chinchilla forms can be misspecified when model size and finite-data repetition interact, or when overfitting creates an explicit penalty. [14][15][21]

Data selection can alter the apparent law too. Sorscher and colleagues showed in vision experiments that effective pruning can beat ordinary power-law scaling with raw dataset size. This does not prove that every language corpus can be ranked perfectly. It proves the narrower point that “number of examples” is not a sufficient causal description when selection changes information density. [18]

Part III

Fit the law like an experiment

A scaling study should be designed to discriminate among surfaces, not merely to draw a straight line. The cheapest path to a confident-looking fit is to vary one resource over a narrow range while freezing undocumented choices. The cheapest path to a useful fit is different.

First, specify the estimand. Name the metric, evaluation distribution, checkpoint rule, parameter count, token count and compute account. “Model quality” is not an estimand. “Smoothed validation cross-entropy on corpus V after schedule S” is.

Second, cover the surface. Vary both model size and training duration. Include allocations on both sides of the expected optimum. Intermediate checkpoints are valuable because each run traces part of the surface rather than contributing one endpoint. Repeat selected configurations across seeds to distinguish training noise from curvature.

Third, hold out the expensive direction. Do not fit and celebrate on the same scale range. Reserve larger-compute points or entire allocation slices. Report residuals by scale, not only one global fit statistic. A model can have low average error while systematically missing the frontier.

Fourth, compare plausible functional forms. A simple power law is preferable when it predicts. A broken power law or coupled data-capacity term is justified only when held-out evidence earns the added flexibility. Caballero and colleagues showed that smoothly broken forms can capture non-monotonic and delayed transitions that single power laws cannot, but flexibility can also fit noise. [17]

Fifth, separate parameter uncertainty from regime uncertainty. Bootstrapping observed runs estimates sensitivity to the sampled data. It cannot quantify an unobserved change in corpus repetition, architecture or optimisation. A narrow interval conditional on the old regime can be exactly wrong after a regime break.

Maintain three uncertainty ledgers

A single confidence interval encourages a category error. The experiment should maintain three ledgers whose entries can be updated independently.

The fit ledger records sampling and estimation uncertainty inside the stated family. It includes seed variation, checkpoint noise, residual structure, bootstrap intervals and sensitivity to the fitting loss. This is where additional runs and better statistical methods help.

The regime ledger records assumptions that are held fixed rather than estimated: data composition, deduplication, objective, optimiser, schedule, regularisation, architecture, tokenizer and compute accounting. Its entries are not probabilities extracted from the old data. Each changed entry requires a bridge run, an ablation or an explicit refusal to transfer the forecast.

The decision ledger records the transformations from loss to the quantity that controls spend. It names the target task, inference policy, downstream metric, volume, latency ceiling, risk slices and verified outcome. This ledger belongs to the consuming system, not only to the model laboratory.

Keeping the ledgers separate changes review behaviour. A narrow fit interval no longer silences questions about a new data mixture. A successful regime bridge no longer implies that exact-match accuracy is predictable. A strong task result no longer proves favourable lifetime economics. The forecast can be strong in one ledger and unresolved in another without contradiction.

Executable fit lab

The following artefact uses synthetic data, so every hidden assumption is visible. It fits the additive Chinchilla-style surface by grid-searching the nonlinear exponents and solving the remaining coefficients with least squares. It then tests a modest same-regime extrapolation and a negative case with an unmodelled repetition penalty.

The lab’s crucial result is not the particular coefficient estimate. It is that a bootstrap interval can be narrow and still miss after a regime change. The interval describes uncertainty conditional on the fitted family and sampled runs. It does not include worlds the model cannot express.

"""Scaling-law fit lab for 'Scaling Laws Without Extrapolation Theatre'.

Synthetic/public-safe demonstration. It fits the Chinchilla-style surface
    loss = E + A * N**(-alpha) + B * D**(-beta)
with a grid search over alpha and beta and least squares for E, A and B.

Positive case: forecast a held-out run from the same generating regime.
Negative case: reuse the same fitted law after a hidden data-repetition penalty.
Expected: the same-regime forecast is close; the regime-break forecast is not.
Dependencies: Python 3.10+ and NumPy.
"""
from __future__ import annotations

from dataclasses import dataclass
import numpy as np

RNG = np.random.default_rng(67)


@dataclass(frozen=True)
class Fit:
    E: float
    A: float
    B: float
    alpha: float
    beta: float
    rmse: float


def surface(
    n_billion: np.ndarray,
    d_billion: np.ndarray,
    E: float,
    A: float,
    B: float,
    alpha: float,
    beta: float,
) -> np.ndarray:
    """Return validation cross-entropy in nats/token."""
    return E + A * n_billion ** (-alpha) + B * d_billion ** (-beta)


def fit_surface(
    n: np.ndarray,
    d: np.ndarray,
    loss: np.ndarray,
    alpha_grid: np.ndarray,
    beta_grid: np.ndarray,
) -> Fit:
    """Variable-projection style fit: nonlinear exponents, linear coefficients."""
    best: Fit | None = None
    for alpha in alpha_grid:
        n_term = n ** (-alpha)
        for beta in beta_grid:
            X = np.column_stack([np.ones_like(n), n_term, d ** (-beta)])
            coeff, *_ = np.linalg.lstsq(X, loss, rcond=None)
            E, A, B = coeff
            if E <= 0 or A <= 0 or B <= 0:
                continue
            pred = X @ coeff
            rmse = float(np.sqrt(np.mean((pred - loss) ** 2)))
            candidate = Fit(
                float(E), float(A), float(B), float(alpha), float(beta), rmse
            )
            if best is None or candidate.rmse < best.rmse:
                best = candidate
    if best is None:
        raise RuntimeError("No positive fit found. Widen the grids or inspect the data.")
    return best


def predict(fit: Fit, n: float, d: float) -> float:
    """Forecast loss for one parameter-token allocation."""
    return float(
        surface(
            np.array([n]),
            np.array([d]),
            fit.E,
            fit.A,
            fit.B,
            fit.alpha,
            fit.beta,
        )[0]
    )


def bootstrap_interval(
    n: np.ndarray,
    d: np.ndarray,
    loss: np.ndarray,
    target_n: float,
    target_d: float,
    draws: int = 120,
) -> tuple[float, float]:
    """Return a 90% bootstrap interval for an in-family loss forecast."""
    forecasts: list[float] = []
    alpha_grid = np.linspace(0.20, 0.48, 15)
    beta_grid = np.linspace(0.16, 0.40, 13)
    for _ in range(draws):
        idx = RNG.integers(0, len(n), len(n))
        try:
            resampled = fit_surface(
                n[idx], d[idx], loss[idx], alpha_grid, beta_grid
            )
            forecasts.append(predict(resampled, target_n, target_d))
        except RuntimeError:
            continue
    if len(forecasts) < draws // 2:
        raise RuntimeError("Too few valid bootstrap fits.")
    lo, hi = np.quantile(forecasts, [0.05, 0.95])
    return float(lo), float(hi)


def exact_match_proxy(
    loss: float, midpoint: float = 2.05, sharpness: float = 14.0
) -> float:
    """Illustrative nonlinear bridge from loss to a 0-100 exact-match score."""
    return 100.0 / (1.0 + np.exp(sharpness * (loss - midpoint)))


def main() -> None:
    # Ground-truth synthetic regime. N and D are expressed in billions.
    true = dict(E=1.62, A=0.62, B=0.88, alpha=0.34, beta=0.28)
    n = 10 ** RNG.uniform(np.log10(0.15), np.log10(5.0), 36)
    d = 10 ** RNG.uniform(np.log10(1.5), np.log10(90.0), 36)
    clean = surface(n, d, **true)
    observed = clean + RNG.normal(0.0, 0.004, size=clean.shape)

    # Withhold the highest-compute quarter from fitting.
    compute = 6.0 * n * d
    cutoff = np.quantile(compute, 0.75)
    train = compute <= cutoff
    fit = fit_surface(
        n[train],
        d[train],
        observed[train],
        alpha_grid=np.linspace(0.18, 0.50, 33),
        beta_grid=np.linspace(0.14, 0.42, 29),
    )

    # Positive case: larger allocation generated by the same causal regime.
    n_pos, d_pos = 6.0, 110.0
    pred_pos = predict(fit, n_pos, d_pos)
    true_pos = float(surface(np.array([n_pos]), np.array([d_pos]), **true)[0])

    # Negative case: token count crosses a hidden repetition threshold.
    n_neg, d_neg = 6.0, 180.0
    pred_neg = predict(fit, n_neg, d_neg)
    base_neg = float(surface(np.array([n_neg]), np.array([d_neg]), **true)[0])
    repetition_penalty = 0.055 * ((d_neg - 90.0) / 90.0) ** 1.35
    true_neg = base_neg + repetition_penalty

    pos_lo, pos_hi = bootstrap_interval(
        n[train], d[train], observed[train], n_pos, d_pos
    )
    neg_lo, neg_hi = bootstrap_interval(
        n[train], d[train], observed[train], n_neg, d_neg
    )

    print("FITTED SURFACE (N and D in billions)")
    print(
        f"E={fit.E:.4f}, A={fit.A:.4f}, B={fit.B:.4f}, "
        f"alpha={fit.alpha:.3f}, beta={fit.beta:.3f}, "
        f"train_RMSE={fit.rmse:.4f}"
    )
    print()
    print("POSITIVE CASE: same regime")
    print(f"predicted_loss={pred_pos:.4f} nats/token")
    print(f"true_loss={true_pos:.4f} nats/token")
    print(f"absolute_error={abs(pred_pos - true_pos):.4f}")
    print(f"bootstrap_90pct_interval=[{pos_lo:.4f}, {pos_hi:.4f}]")
    print()
    print("NEGATIVE CASE: hidden repetition regime")
    print(f"predicted_loss={pred_neg:.4f} nats/token")
    print(f"true_loss={true_neg:.4f} nats/token")
    print(f"absolute_error={abs(pred_neg - true_neg):.4f}")
    print(f"bootstrap_90pct_interval=[{neg_lo:.4f}, {neg_hi:.4f}]")
    print()
    print("NONLINEAR DOWNSTREAM BRIDGE (illustrative exact-match proxy)")
    print(f"predicted_score={exact_match_proxy(pred_neg):.1f}/100")
    print(f"true_score={exact_match_proxy(true_neg):.1f}/100")
    print()
    print("DECISION")
    if abs(pred_pos - true_pos) < 0.02 and abs(pred_neg - true_neg) > 0.03:
        print(
            "PASS: trust the fit in-regime; require a new law or direct "
            "experiment after the regime change."
        )
    else:
        print(
            "REVIEW: this random draw did not cleanly separate the positive "
            "and negative cases."
        )


if __name__ == "__main__":
    main()

Part IV

stateDiagram-v2
  [*] --> Claim
  state "From response surface to<br/>efficient frontier" as Claim
  state "Thought experiment one: one<br/>budget, several models" as Test
  state "Thought experiment two: change<br/>only the ruler" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

From forecast to allocation

A research team can use a scaling law to decide which pretraining experiment is worth buying. A product team needs a broader denominator: cost per successfully verified task. Training loss remains one input, but the final comparison must include post-training, inference strategy, retrieval, tools, latency, failure handling and human work.

A production-shaped worked example

Consider a synthetic service that reconstructs policy clauses from long documents. A correct result must cite the active clause, preserve numerical limits and abstain when versions conflict. The service handles five million cases per year. Three candidate systems meet different parts of the requirement.

These numbers are synthetic, but the decision logic is concrete. A pretraining-only scaling forecast might favour the candidate with the lowest predicted loss. The system choice depends on demand and the error stack. The 24B option nearly matches quality at less than half the per-case cost and lower latency. The 8B option converts extra test-time compute into slightly higher average success, but its tail latency and shared verifier failure need scrutiny.

Inference-scaling studies have found settings where smaller models with search or aggregation sit on the cost-performance frontier, including cases where a 7B model with tree search outperformed a 34B model on the tested mathematics benchmark. That is bounded evidence for problem solving, not a universal serving rule. [19]

The workflow’s largest residual is stale evidence, so none of the three model interventions addresses the first constraint. An oracle-context ablation should come before a larger training run. If all candidates improve sharply with current clauses supplied, spend first on document identity, versioning and retrieval. A scaling curve cannot diagnose an error upstream of the model input.

Serving demand changes the optimisation question

Training is paid once; inference is paid on every use. That asymmetry can dominate lifetime cost. A larger model may reach a target loss with fewer training tokens, yet consume more accelerator memory and arithmetic on every generated token. At low demand, training efficiency may dominate. At very high demand, investing more once to train a smaller model longer can reduce total cost.

Test-time compute introduces another axis. Sampling several answers, searching a tree or calling a verifier can raise task success without changing pretrained weights. The relevant comparison is then not “small versus large model” but a portfolio of model size, number of attempts, search policy and verification. Each portfolio point must be measured at the same task quality and service envelope.

There is no universal winner. Parallel samples can improve throughput on batch work and violate an interactive latency ceiling. A verifier can reduce final error and introduce correlated blind spots. A smaller model can be cheap per token and expensive per successful case if it retries often. Use successfully verified tasks as the denominator, including failed attempts, tool calls and human escalations.

The scaling forecast release card

The practical instrument below refuses to compress unlike uncertainties into one score. A forecast is green only within its own layer. Amber items require a bounded experiment. Red items block use of the forecast for the named decision.

A compact glossary

Scaling law

An empirical relation between a measured performance quantity and resources such as parameters, data or compute.

Iso-loss contour

All parameter-token combinations predicted to achieve the same loss.

Compute-efficient frontier

The point on each loss contour requiring the least compute under the chosen compute model.

Bridge

A separately testable mapping from training loss to task capability, or from capability to a system outcome.

Geometric extrapolation

A target beyond the observed resource range while the training regime is held fixed.

Regime extrapolation

A forecast after a causal training condition changes, even if parameter and token counts remain nearby.

Conclusion

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The run that was right for the wrong question
  M->>E: From response surface to efficient frontier
  E-->>M: compare rival explanations
  E->>D: Give the curve one vote
  D-->>Q: revise scope or act

Give the curve one vote

Scaling laws deserve their reputation because they turned expensive training into a partially forecastable engineering discipline. They exposed wasteful parameter-data allocations, made small runs informative about larger ones, and forced a field fond of anecdotes to confront quantitative regularity.

The mistake is to ask the curve to certify claims outside its experiment. A loss forecast is evidence about loss under stated conditions. A capability forecast needs a calibrated metric bridge. A product forecast needs a system bridge. An investment decision needs matched-quality cost, risk and recovery evidence.

This changes the architecture of a scaling programme. Train a surface-covering suite rather than a decorative size ladder. Hold out the expensive direction. Record every regime assumption. Challenge the fit with alternative forms and changed data conditions. Then use the forecast to choose the next discriminating experiment.

The release artefact should make disagreement cheap. Another researcher should be able to substitute a different compute account, remove a suspect run, refit a coupled surface, or apply a revised downstream bridge without reconstructing the study from slides. Forecasting quality is partly a software and lineage property: reproducible data, typed assumptions and executable analysis let evidence update the decision before sunk cost turns the original curve into doctrine.

For a model laboratory, the decision is to release forecasts with jurisdiction, extrapolation distance and falsification conditions. For a product team, the decision is to fund the nearest unresolved constraint, whether it is data, model capacity, test-time compute, retrieval or control. For governance, the decision is to stop treating a smooth upstream line as an end-to-end assurance case.

The curve gets one vote because it answers one causal question well. Respecting that boundary makes scaling evidence more useful, not less ambitious.