Cut the claim until it can lose

Research usually starts above the level at which evidence can operate. “Agents can improve themselves”, “language models reason”, “world models understand physics”, and “multi-agent debate improves truth” are productive ambitions. They organise programmes and attract difficult questions. They are poor first experimental claims because one result can be absorbed by too many interpretations.

John Platt’s account of strong inference urged scientists to devise alternative hypotheses and seek experiments that exclude at least one of them, then repeat the cycle.[1] The useful part is not the promise of a single perfect crucial experiment. Complex learning systems rarely permit one. The useful discipline is contrast: before collecting another score, ask which live explanations predict different observations when the same causal feature is changed.

A claim cone helps. At the wide end sits the motivating ambition. Beneath it sits a claim type: observational, capability, causal, mechanism, measurement or engineering. Beneath that sits a bounded proposition containing a candidate system, task family, intervention, comparator, outcome and scope. At the narrow point sits the record that an instrument can actually produce.

The key cut is from praise to proposition. “The model reasons” is praise unless reasoning has an operational burden. “Removing the scratchpad state selectively reduces performance on compositional problems while preserving retrieval and arithmetic accuracy” is a proposition. It could fail because the ablation creates general corruption, because performance remains unchanged, or because a simpler cache produces the same pattern.

A first contribution should therefore state six things in one sentence: the system, the changed feature, the matched conditions, the comparator, the expected separating observation and the scope. The sentence may be inelegant. It is an experimental contract, not a headline.

The sealed-score thought experiment

Give two teams the same model, dataset and budget. Team A writes its hypothesis, analysis and exclusion rules before training. Team B sees the complete result, then writes an equally plausible story about why it occurred. Both produce coherent papers. Now seal the result and ask each team to predict which of four outcomes will appear after a controlled intervention. Team A can answer from its frozen commitments. Team B’s explanatory freedom was purchased with knowledge of the outcome.

The physical result has not changed, but its evidential role has. Preregistration is useful here because it preserves the distinction between using observations to generate a hypothesis and using new observations to test a prediction.[2] It does not guarantee a good theory, honest execution or a sensitive instrument. It prevents one specific promotion: a post-result accommodation being presented as a risky forecast.

A claim can be interesting before it is confirmatory, but it must say which role it is playing. Exploratory work may discover an unexpected representation direction or failure cluster. Its first defensible contribution can be the pattern, dataset, instrument or counterexample. The confirmatory claim begins only when a fresh observation can disagree with a frozen expectation.

Why a smaller claim can be the larger contribution

Machine-learning papers are often rewarded for breadth: more tasks, more parameters, more metrics and a larger improvement. Yet breadth can reduce identification. If architecture, data, training schedule, prompt, inference budget and evaluator all change together, the paper may establish that a package works while obscuring which idea mattered. Lipton and Steinhardt identified failure to isolate sources of empirical gain as a recurring scholarship problem.[3]

There is nothing inferior about a package-level engineering claim when the package is the decision object. “This configured service reduces cost at an accepted error rate” may be exactly what an operator needs. The error is promoting that result into a mechanism claim about a new module. A defensible contribution chooses its level. It either tests the component causally or owns the package as the unit of evidence.

This yields the first decision rule: do not narrow until the sentence sounds modest; narrow until a plausible rival predicts something else. If every rival expects the same headline result, the planned experiment may be useful evaluation, but it is not yet a discriminating contribution.

Make rivals diverge before data

A serious rival is not the weakest baseline available. It is the cheapest process that could produce the same visible success while making a different causal story true. For the self-improving agent, the rival is not random guessing. It is a compute-matched search-and-select system. For a “world model”, the rival may be a high-capacity video predictor that follows familiar trajectories but fails under intervention. For “metacognition”, the rival may be a direct difficulty threshold that requests more compute without representing uncertainty about its own answer.

Modern ML makes rivals especially important because held-out accuracy under one distribution can be underdetermining. D’Amour and colleagues showed that pipelines can return predictors with similar in-domain performance and sharply different deployment behaviour.[4] Geirhos and colleagues describe shortcut rules that work on standard benchmarks but fail when the cue structure changes.[5] A contribution should therefore attempt to construct the rival, not merely mention it in limitations.

A quantity for planning, not a truth score

Suppose a preferred hypothesis, H₁, and a rival, H₀, each assign probabilities to possible outcomes after design d. Their preregistered prediction separation can be represented by total variation distance:

Here, y ranges over the outcomes the instrument can distinguish. D equals zero when both accounts predict the same distribution. It reaches one when their predictions do not overlap. A high value does not make either hypothesis true. It says the experiment has somewhere to send the evidence.

Prediction separation is wasted if the instrument is insensitive or the intervention is impure. Let q represent measurement sensitivity, the probability that a real predicted difference becomes observable. Let c represent intervention integrity, the degree to which the manipulation changes the proposed cause without changing important alternatives. A coarse planning value is:

Increasing any term helps only if the others remain sound. An exotic manipulation may maximise disagreement while destroying the target process, lowering c. A perfectly controlled experiment may use a metric unable to detect the predicted change, lowering q. The values are design judgements to expose, not numbers to optimise blindly.

Thought experiment: the budget swap

Consider an agent that can spend one extra tool call on 20 of 100 cases. It reports a confidence score and spends calls on the 20 lowest-confidence cases. Accuracy rises. Now change only one feature: randomly permute confidence scores across cases while preserving the exact number of calls, tools, prompts and token budget.

If the gain was caused by targeted metacognitive control, the shuffled condition should lose much of its benefit because calls no longer reach cases where the base answer is likely wrong. If extra compute alone caused the gain, the improvement should remain approximately uniform. If a visible task feature, such as input length, determines both confidence and difficulty, a direct length-based router may match the policy without any self-monitoring account.

The thought experiment does not prove that the system possesses human-like metacognition. It creates a smaller causal burden: does an uncertainty variable have prospective control over information seeking, beyond a compute-matched observable heuristic? That burden is worth testing because it changes architecture. A positive result supports preserving and calibrating the uncertainty channel. A negative result supports replacing it with a simpler router.

Worked example: a minimal uncertainty controller

Use a fixed binary classifier over synthetic cases with known outcome costs. The model outputs a class and calibrated probability. A controller may request one additional noisy feature before committing. The preferred account says the probability is causally used to direct requests to uncertain, high-loss cases. The rival says any policy allowed twenty extra features will improve because more information helps.

Freeze the base classifier, case order, twenty-request budget, feature generator, loss function and final decision rule. Compare four conditions:

1. Live confidence: the controller sees calibrated probabilities and ranks expected value of information.
2. Shuffled confidence: the same probabilities are reassigned between cases after stratifying by class, preserving their distribution but breaking item-level meaning.
3. Observable heuristic: a compute-matched policy uses input length and missing-value count but never receives confidence.
4. Random allocation: the budget is spent on randomly selected cases, providing a lower negative control.

The primary outcome is expected decision loss, not raw accuracy. Secondary outcomes are where requests are allocated, calibration after the extra feature, and harm in low-frequency high-cost cases. The preferred account predicts that live confidence beats shuffled confidence most strongly in the uncertain, high-loss slice. It need not beat the observable heuristic if the heuristic captures the same information.

The negative control is successful when it can reproduce the attractive surface result for the wrong reason. If every extra-feature policy raises accuracy, random allocation confirms that the benchmark lift itself is non-discriminating. The contribution then depends on targeted loss reduction, not the headline increase.

A baseline ladder that earns the claim

Baselines should be selected by causal proximity, not by tradition. A useful ladder has five rungs. The trivial baseline checks whether the task has any signal. The simple competent baseline tests whether complexity is needed. The compute-matched baseline removes resource advantage. The information-matched baseline removes privileged evidence. The mechanism-ablated or countermodel baseline tries to preserve output quality while deleting the proposed process.

Henderson and colleagues showed how implementation details, random seeds and evaluation choices can affect deep reinforcement-learning comparisons.[6] More recently, Hochlehnert and colleagues found that mathematical-reasoning results could be sensitive to decoding, prompts, seeds and even hardware or software configuration, and that some reported gains shrank under a standardised evaluation stack.[7] These findings do not imply that every new method is an artefact. They show why a claim must survive the strongest ordinary route to the same number.

Foundation-model research makes this boundary practical. Full controlled training runs can be prohibitively expensive, so researchers use proxy models, observational comparisons or single-run designs. König and colleagues analyse how each strategy trades different forms of validity: proxy studies can gain internal control while losing confidence in transfer across scale; observational studies face confounding; single-run designs face interference.[8] The defensible response is not to demand impossible experiments. It is to state which validity debt the cheaper design creates and what later observation could repay it.

flowchart LR
  A["The agent that improved<br/>without learning"] --> B["Cut the claim until it can lose"]
  B --> C["Make rivals diverge before data"]
  C --> D["Turn a result into an evidence<br/>graph"]
  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

Turn a result into an evidence graph

A paper normally turns an experiment into a conclusion paragraph. An evidence graph preserves more structure. Its nodes are the bounded claim, rival, intervention, instrument, observed result, negative control, scope, artefact and decision. Its edges use verbs that can be challenged: predicts, measures, changes, supports, weakens, fails to distinguish, transfers to, and expires under.

A result is an edge update, not a badge attached to a theory. Observing a targeted gain may support the uncertainty-control account over the extra-compute rival under the frozen design. It does not prove metacognition, self-knowledge or general agency. A later study can add a new rival, discover that the confidence score encodes input length, or show that the effect transfers to a new model family. The graph can change without rewriting the history.

This structure also separates three achievements often compressed into “reproducible”. The National Academies uses reproducibility for obtaining consistent results with the same data and computational methods, and replicability for a new study addressing the same question with new data.[9] Pineau and colleagues describe a NeurIPS programme aimed at improving how ML research is conducted, communicated and evaluated.[10] Hagmann and colleagues argue for inferential reproducibility, where conclusions about methods account for multiple sources of nondeterminism and data interactions rather than one frozen run.[11]

Each achievement updates a different edge. Re-running code strengthens the link between artefact and reported number. New data tests whether the result recurs. A multiverse analysis asks whether reasonable analytical and implementation choices preserve the conclusion. Bell and colleagues use this idea to examine whether claims survive across a space of plausible ML decisions rather than only at one optimised point.[12]

Revision receipts prevent invisible theory repair

Real research changes after contact with data. A null exposes a bad metric. A reviewer finds an unmodelled confound. An intervention changes more state than expected. Treating every revision as misconduct would encourage researchers to hide learning. Treating every revision as if it had been predicted would destroy evidential calibration.

A revision receipt records the old commitment, the observation that forced change, the new assumption or claim, and a fresh test that has not yet been seen. The receipt gives flexibility a price: the revised account may be better, but support must come from new evidence. This preserves failed predictions as useful information instead of editing them out of the programme.

Leakage illustrates why the evidence record must include data and code paths, not prose alone. Kapoor and Narayanan documented leakage problems across many fields using ML and showed how corrected pipelines could erase apparent advantages over simpler baselines.[13] A contribution manifest should therefore state split construction, temporal cut-offs, preprocessing ownership, model selection data and every route by which evaluation labels could affect training or selection.

Measurement bridges belong inside the graph

A discriminating experiment can still discriminate the wrong thing. If “reasoning” is operationalised as exact-match accuracy on a contaminated benchmark, a clean ablation may identify dependence within the configured task while leaving the construct claim weak. Jacobs and Wallach show why unobservable constructs require explicit measurement models connecting theoretical properties to observables.[14] Raji and colleagues similarly question the use of influential benchmarks as broad stand-ins for general AI progress.[15]

The evidence graph should therefore contain a measurement edge with its own rivals. A score may reflect the target ability, formatting compliance, memorisation, language familiarity or annotation artefacts. Reliability asks whether the score recurs. Construct validity asks whether the intended interpretation survives countermodels. The first defensible contribution may be a better instrument rather than a better model.

When the ruler is uncertain, improving the ruler can dominate improving the score. This is especially true near benchmark saturation, where tiny ranking changes carry large claims and a few ambiguous items can reverse the order.

A production-shaped worked example

Use this bounded proposition: “For synthetic policy-exception cases, typed claim-to-evidence binding reduces unsupported material statements compared with retrieval plus a strict response template, at matched model, source set, token budget and reviewer rubric.” The mechanism is that a statement cannot pass validation unless its evidence record has the required entity, effective time, source type and policy scope.

The strongest rival is formatting discipline. A strict template may make the memo shorter, reduce speculative prose and force citations without needing a context compiler. Another rival is simple retrieval quality: perhaps the compiler wins only because it returns better passages, not because binding matters.

Construct a factorial test. Hold the retrieved passages fixed. Cross two factors: free narrative versus strict template, and untyped passages versus typed evidence records. Add a negative control that preserves citation count and appearance but shuffles evidence identifiers among cases. The shuffled condition is intentionally plausible to a surface-level evaluator while breaking factual support.

Use four outcome families. First, human adjudicators mark unsupported material statements. Second, deterministic checks test whether cited records exist, apply to the named entity and were valid at the decision time. Third, reviewers record correction time and disagreement. Fourth, the system is penalised for omitting decision-relevant facts or abstaining unnecessarily. A system can reduce unsupported claims by saying almost nothing, so omission and abstention are necessary counterweights.

These numbers are illustrative teaching fixtures, not deployment evidence. Their pattern shows what would be discriminating. The strict template improves over free narrative, so the rival was serious. Typed binding adds a larger improvement while shuffled identifiers collapse validity, supporting the claim that evidence identity and compatibility matter beyond citation appearance.

The permitted conclusion remains local: typed binding is worth further evaluation for this memo-construction task. It does not show that the model understands credit, that the full workflow is safe, or that a machine should make the underwriting decision. The decision rights remain with accountable reviewers. The experiment changes one architecture choice, not the authority boundary.

Documentation now becomes part of the contribution. Model cards encourage reporting intended uses, evaluation conditions and relevant performance differences.[16] The REFORMS recommendations provide a broader checklist for ML-based science, including data, evaluation, leakage and reporting concerns.[17] Official NeurIPS guidance also asks authors to address claims, limitations, reproducibility, data, code and societal impacts.[18] These instruments improve transparency, but the contribution canvas below has a different purpose: it asks whether the experiment can distinguish the proposed idea from its strongest ordinary rival before resources are spent.

The research contribution canvas

A proposal is ready for experiment design when every field below contains a concrete sentence. Blank fields are not automatically fatal. They reveal whether the current contribution is exploratory, confirmatory, measurement-focused or engineering-focused. A broad ambition may remain at the top, but only the bounded claim enters the release gate.

Run the pre-acquisition gate

Before acquiring expensive data or training a large model, ask seven questions. Can the rival earn the headline metric? Do the accounts predict different outcomes under the same operationalisation? Is the intervention specific enough to preserve the target? Is the instrument sensitive enough to reveal the predicted difference? Does the negative control have a real chance to embarrass the preferred explanation? Can an independent team reconstruct the result from the artefact? Does each outcome change a named decision?

If the first two answers are no, redesign the claim or experiment. If intervention integrity or sensitivity is uncertain, run a cheap calibration study. If the artefact is incomplete, the work may still generate hypotheses, but it should not be presented as a replayable result. If no decision changes, the study may be intellectually interesting, yet the claimed practical contribution is unformed.

The language column is not cosmetic. A claim becomes portable through sentences. Once “supports under this design” is shortened to “proves”, evidence escapes its graph and starts authorising decisions it never tested. The strongest safe sentence should be stored beside a prohibited sentence. For the credit-memo example, the permitted sentence concerns unsupported statements under synthetic cases. The prohibited sentence is “the agent makes auditable credit decisions”.

Executable artefact: a contrastive experiment planner

The Python artefact below operates on synthetic probability distributions. It validates a contribution card, calculates total-variation separation, discounts it by measurement sensitivity and intervention integrity, then reports how much more expected an observed outcome was under the preferred account than the rival. It contains one positive case and one deliberately non-discriminating negative case.

Assumptions are explicit. The outcome set is finite. Probabilities are preregistered judgements rather than learned estimates. Sensitivity and integrity are coarse planning values. The output is not a posterior probability, publication score or substitute for power analysis. Its purpose is to catch a common design error: an expensive experiment in which both explanations predict the same headline result.

"""Contrastive experiment planner for 'The First Defensible Contribution'.

Python 3.10+. Standard library only.
All examples and probabilities are synthetic teaching fixtures.
"""

from __future__ import annotations

from dataclasses import dataclass, fields
from math import isclose
from typing import Mapping


@dataclass(frozen=True)
class Hypothesis:
    name: str
    predictions: Mapping[str, float]


@dataclass(frozen=True)
class ExperimentCard:
    title: str
    claim: str
    rival: str
    intervention: str
    observable: str
    negative_control: str
    scope: str
    artefact: str
    measurement_sensitivity: float
    intervention_integrity: float

    def __post_init__(self) -> None:
        for field in fields(self):
            value = getattr(self, field.name)
            if isinstance(value, str) and not value.strip():
                raise ValueError(f"{field.name} must not be blank")
        for name in ("measurement_sensitivity", "intervention_integrity"):
            value = getattr(self, name)
            if not 0.0 <= value <= 1.0:
                raise ValueError(f"{name} must be between 0 and 1")


def validate(hypothesis: Hypothesis) -> None:
    if not hypothesis.name.strip() or not hypothesis.predictions:
        raise ValueError("A hypothesis needs a name and at least one outcome")
    if any(probability < 0.0 for probability in hypothesis.predictions.values()):
        raise ValueError("Probabilities cannot be negative")
    if not isclose(sum(hypothesis.predictions.values()), 1.0, abs_tol=1e-9):
        raise ValueError("Outcome probabilities must sum to 1")


def total_variation(left: Hypothesis, right: Hypothesis) -> float:
    """Return 0 for identical predictions and 1 for non-overlapping predictions."""
    validate(left)
    validate(right)
    outcomes = set(left.predictions) | set(right.predictions)
    return 0.5 * sum(
        abs(left.predictions.get(outcome, 0.0) - right.predictions.get(outcome, 0.0))
        for outcome in outcomes
    )


def likelihood_ratio(observed: str, preferred: Hypothesis, rival: Hypothesis) -> float:
    """Return how much more expected the observation was under the preferred account."""
    preferred_probability = preferred.predictions.get(observed, 0.0)
    rival_probability = rival.predictions.get(observed, 0.0)
    if preferred_probability == rival_probability == 0.0:
        raise ValueError("The observed outcome was absent from both preregistered distributions")
    if rival_probability == 0.0:
        return float("inf")
    return preferred_probability / rival_probability


def audit(
    card: ExperimentCard,
    preferred: Hypothesis,
    rival: Hypothesis,
    observed: str,
) -> dict[str, float | str]:
    separation = total_variation(preferred, rival)
    planning_value = (
        separation * card.measurement_sensitivity * card.intervention_integrity
    )
    return {
        "experiment": card.title,
        "prediction_separation": round(separation, 3),
        "planning_value": round(planning_value, 3),
        "observed_likelihood_ratio": round(
            likelihood_ratio(observed, preferred, rival), 3
        ),
        "status": "discriminating" if separation > 0.0 else "shared_prediction",
    }


def main() -> None:
    positive_card = ExperimentCard(
        title="confidence-gated evidence seeking",
        claim="Calibrated uncertainty causally directs extra evidence to risky cases.",
        rival="Extra inference compute improves results regardless of uncertainty.",
        intervention="Shuffle confidence values while preserving cases, budget and tools.",
        observable="Where gains occur: uncertain cases, all cases, or nowhere.",
        negative_control="A compute-matched controller that never receives confidence.",
        scope="Synthetic binary decisions with stable loss and calibrated scores.",
        artefact="This file plus the frozen outcome table.",
        measurement_sensitivity=0.90,
        intervention_integrity=0.85,
    )
    preferred = Hypothesis(
        "uncertainty-sensitive control",
        {"targeted_gain": 0.70, "uniform_gain": 0.20, "no_gain": 0.10},
    )
    rival = Hypothesis(
        "extra-compute effect",
        {"targeted_gain": 0.15, "uniform_gain": 0.60, "no_gain": 0.25},
    )
    positive = audit(positive_card, preferred, rival, observed="targeted_gain")

    shared_card = ExperimentCard(
        title="headline benchmark lift",
        claim="The new module causes the benchmark gain.",
        rival="Prompt and seed choices cause the same gain.",
        intervention="None; both systems are reported only on the final benchmark.",
        observable="Whether the headline score rises.",
        negative_control="A matched system with the module disabled.",
        scope="One benchmark and one reporting configuration.",
        artefact="A score table without per-run traces.",
        measurement_sensitivity=0.95,
        intervention_integrity=0.95,
    )
    preferred_shared = Hypothesis(
        "new-module account",
        {"gain": 0.80, "flat": 0.15, "loss": 0.05},
    )
    rival_shared = Hypothesis(
        "configuration account",
        {"gain": 0.80, "flat": 0.15, "loss": 0.05},
    )
    negative = audit(shared_card, preferred_shared, rival_shared, observed="gain")

    assert positive["prediction_separation"] == 0.55
    assert positive["planning_value"] == 0.421
    assert positive["observed_likelihood_ratio"] > 4.0
    assert negative["prediction_separation"] == 0.0
    assert negative["observed_likelihood_ratio"] == 1.0
    assert negative["status"] == "shared_prediction"

    print("positive:", positive)
    print("negative:", negative)


if __name__ == "__main__":
    main()

Save the source as contribution_discriminator.py and run python3 contribution_discriminator.py. The assertions require the positive design to have non-zero prediction separation and the negative design to report a shared prediction.

positive: {'experiment': 'confidence-gated evidence seeking', 'prediction_separation': 0.55, 'planning_value': 0.421, 'observed_likelihood_ratio': 4.667, 'status': 'discriminating'}
negative: {'experiment': 'headline benchmark lift', 'prediction_separation': 0.0, 'planning_value': 0.0, 'observed_likelihood_ratio': 1.0, 'status': 'shared_prediction'}

The positive case asks where gains occur, not merely whether accuracy rises. Its preferred account predicts targeted benefit; the rival predicts a broader compute effect. The negative case gives both accounts identical probabilities. Even a positive observed gain has a likelihood ratio of one because it was equally expected under each explanation. A successful result from a non-discriminating design creates performance evidence, not mechanism evidence.

The strongest objection

A critic may object that research does not advance through tiny pairwise contrasts alone. New architectures can be valuable before their mechanism is known. Large empirical sweeps can reveal phenomena no one predicted. Engineering packages often succeed through interactions that ablation destroys. A programme obsessed with isolating one cause may prefer clean toy worlds to consequential systems.

The objection is correct. The contribution canvas is not a universal recipe for discovery. It is a gate for causal, mechanism and broad construct claims. Exploratory atlases, datasets, demonstrations, system builds and descriptive failures can be defensible contributions when labelled accurately. A package-level result may be the proper unit when deployment concerns the package. Some interactions are the phenomenon.

The answer is to separate discovery from promotion. Explore with broad instruments. Build the package. Record surprising patterns. Then decide which claim is being advanced. If the claim says the package works under defined conditions, test the package against a credible system baseline. If it says component A caused the gain, create the contrast. If it says the result measures reasoning, build the measurement bridge. Rigour should constrain the inference, not the imagination that generated the study.

stateDiagram-v2
  [*] --> Claim
  state "The sealed-score thought<br/>experiment" as Claim
  state "Why a smaller claim can be the<br/>larger contribution" as Test
  state "A quantity for planning, not a<br/>truth score" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Compact glossary

Ambition

The larger programme-level question that motivates several studies but is too broad for one result to settle.

Bounded claim

A proposition naming the system, task family, comparator, outcome, intervention and scope supported by the current study.

Contrastive commitment

A preregistered difference in what the preferred account and a serious rival expect under the same design.

Negative control

A process designed to reproduce visible success while lacking the proposed mechanism, exposing whether the headline result is discriminating.

Intervention integrity

How specifically a manipulation changes the proposed cause without altering important alternatives or destroying the target process.

Measurement sensitivity

The instrument’s ability to reveal the difference the rival predictions actually specify.

Evidence graph

A typed record linking claims, rivals, designs, observations, artefacts, boundaries and decisions through explicit support or limitation edges.

Revision receipt

A record of how a claim or assumption changed after data, plus the fresh observation required to test the revision.

Make the next result able to say no

Machine intelligence invites claims larger than any available instrument. A fluent model looks like a reasoner. A feedback loop looks like learning. A persistent agent looks like a self. A group of agents looks like collective intelligence. These interpretations may become well supported, but the first experiment should not be asked to carry the whole ontology.

The practical move is to preserve the ambition and narrow the contribution. Name the preferred mechanism. Build the strongest ordinary rival. Hold resources, information and interface constant. Change the feature on which the explanations disagree. Calibrate the instrument. Let a negative control reproduce the attractive surface result. Store the outcome as a local edge in an evidence graph with its artefact, scope and decision consequence.

The contribution is not the claim that survives every possible objection. It is the experiment that makes at least one important objection answerable. A positive result then earns a bounded sentence. A negative result removes a route or exposes a bad assumption. An ambiguous result reveals which instrument or intervention must improve. All three can accumulate.

The changed research decision is simple. Do not fund, publish or architect around a mechanism merely because a configured system scored higher. First require a research contribution canvas that shows where the preferred account and its rival separate. Then run the smallest credible experiment whose outcome would alter the next decision. That is the first defensible contribution, not the final theory, but a piece of evidence strong enough for the next piece to stand on.