The model is the wrong unit

Current artificial-consciousness research often begins by asking whether a particular architecture has properties derived from a theory of consciousness. Theory-derived indicator work is valuable because it replaces intuitive anthropomorphism with explicit computational claims. Butlin and colleagues, for example, derive indicator properties from several scientific theories and treat them as inputs to uncertain assessment rather than as a binary test. [1][2] That move improves the question, but it does not by itself create a decisive experiment.

Suppose a candidate appears to broadcast selected information to many modules. Is the broadcast doing causal work, or is every module independently reading the same hidden shortcut? Suppose a system reports a changed internal state after an activation intervention. Did it inspect the changed state, detect an input irregularity, or produce the response favoured by its training? A list of properties can still be satisfied by the wrong generator.

The central design move is therefore simple: the unit of evidence must be a family of counterfactual siblings. The family shares the task, interface, data regime, evaluation and operating environment. Its members differ in a declared mechanism or in the route by which the same output is generated. The research claim concerns the pattern across the family, not the charisma of one member.

The minimum discriminating family

A default family needs three roles. The candidate implements the target mechanism. The mechanism-ablated sibling is matched as closely as possible but removes or disables that mechanism. The rival generator reaches the same baseline output through a plausible alternative route. This is the minimum discriminating family, or MDF.

Why three? A candidate alone shows that a system can perform. Candidate plus ablation can show that removing something changes performance, but the change may come from lost capacity, latency or damage unrelated to the theory. Adding an output-matched rival asks whether the observed signature is specific to the proposed route. In rare cases the ablated sibling is already a strong rival, so two members may suffice. The default remains three because mechanism removal and alternative generation answer different questions.

This boundary experiment exposes a recurring mistake. Researchers often name the foundation model as the candidate while the behaviour actually depends on caches, retrieval, orchestration, tools, policy filters and user state. Alternatively, they include every supporting service and quietly turn a candidate into an organisation. A boundary is part of the hypothesis, not a diagramming choice.

Every family therefore needs a boundary dossier. It identifies the processes that persist, the state that crosses calls, the components that can act, the clocks that order events, the channels that supply evidence and the services that can alter outputs. A boundary change creates a new configured system, even if the model checkpoint is unchanged.

flowchart TD
  A["The immaculate demonstration"] --> B["The model is the wrong unit"]
  B --> C["Make mechanisms disagree"]
  C --> D["Turn a run into challengeable<br/>evidence"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#D95545,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Make mechanisms disagree

A family becomes scientific only when its members make different predictions under a controlled change. Baseline matching matters because it removes the easiest explanation for divergence. If the candidate starts at 95 per cent accuracy and the ablation at 55 per cent, almost any intervention will look mechanism-sensitive. Baseline matching removes performance as the easy explanation.

From output score to intervention fingerprint

Let Y be the measured outcome, such as accuracy. Let M identify a family member and i identify an intervention. The useful quantity is not the baseline score alone. It is the change caused by intervention i for member M.

Here, do(i) means that the variable is deliberately changed rather than merely observed. The fingerprint of a member is the vector of these changes across interventions. The equation is valid only if the intervention does not also change an uncontrolled cause of the outcome. Remove that assumption and the effect becomes ambiguous.

Causal-abstraction research uses interchange interventions in a related way: internal representations are aligned with variables in a higher-level model, then swapped to test whether the network follows the counterfactual predicted by that model. [4] The crucial idea is not the particular technique. It is that an internal interpretation earns support when the system behaves as if the intervened variable has the proposed causal role.

An intervention is informative only when rival mechanisms predict different fingerprints. State reset alone is weak. It may merely damage computation. State reset plus hint flip plus identity relabelling is stronger because each family member has a distinct predicted vulnerability. The joint pattern is harder for an unintended confound to imitate.

Build the candidate family around a commitment packet

Before implementation, the team should write a commitment packet with six fields: the target property, the proposed mechanism, the candidate boundary, the intervention fingerprint, rival generators and prohibited inferences. The packet should also name what observation would strengthen the proposal and what would weaken it.

For a global-availability hypothesis, the target property might be cross-module availability. The proposed mechanism might be a capacity-limited workspace. The candidate predicts that a workspace-state swap will jointly alter report, planning and error correction. The ablation predicts no coherent cross-function change. A rival generator might route a shared answer key to every module. A positive result supports the causal role of the workspace in those functions. It does not establish phenomenal consciousness.

Select interventions by predicted separation

Researchers are naturally drawn to dramatic perturbations: delete a module, erase a long memory or force a system into an extreme conflict. Drama is not the same as information. A large intervention may make every family member fail, leaving the competing explanations just as compatible as before. The better first experiment is the smallest change for which the members predictably separate.

Construct a prediction matrix before running anything. Rows are authorised interventions. Columns are family members. Each cell states the expected direction and approximate size of change, together with the mechanism that produces it. An intervention earns priority when at least two plausible mechanisms disagree, the manipulation can be applied symmetrically, a sham can reproduce its incidental costs and the expected evidence gain is worth the experimental burden.

In this practical score, D(i) is the number of pairwise mechanism disagreements created by intervention i; B(i) is an ordinal burden estimate covering duration, intensity, instance count and persistence disruption; and C(i) is the number of serious confound routes not blocked by a control. The added one prevents a harmless, well-controlled intervention from producing division by zero. The score is a scheduling aid, not evidence. It assumes that disagreements, burden and confounds have been classified consistently. If those judgements are unreliable, publish the three inputs separately and do not pretend the quotient is precise.

Take the one-bit family. Hint flip produces two pairwise disagreements: the shortcut sibling differs from the candidate and from the replay rival. Its burden is minimal and its main confound, accidental corruption of the final input, can be checked with a content-preserving sham. Give it D=2, B=0 and C=0; its priority is 2. State deletion also creates two disagreements, but it may disturb timing, serialisation and default-state handling. With B=1 and C=2, its priority is 0.5. The numbers are illustrative, but the decision is real: run hint flip first, learn whether the shortcut is active, then justify the more disruptive state intervention.

This order protects scientific clarity as well as possible welfare. It also exposes an important asymmetry. An intervention can be cheap yet weak if every mechanism predicts the same outcome. Conversely, a discriminating intervention can be too confounded to interpret. The first apparatus should optimise counterfactual separation per unit of burden, not maximum behavioural damage.

The target candidate, sibling and rival can share this apparatus while replacing the component inside the boundary. That makes the comparison cheap enough to repeat and explicit enough to challenge. A miniature system with inspectable state, synthetic data and deterministic tools is more scientifically useful than a frontier model surrounded by opaque services.

Design the null before the result

A non-separating result is not automatically a failed study. It has at least four readings. The proposed mechanism may be unnecessary for the measured function. The intervention may be too weak to alter the relevant variable. The family may contain a compensating route that restores performance. Or the measurement may be insensitive to the change. These possibilities have different next experiments, so they must be distinguished in advance.

The preregistration should therefore include manipulation checks and a null-result tree. A state swap needs evidence that the donor value entered the recipient at the intended time. A workspace mask needs a readout showing that broadcast availability fell while local processing remained usable. A boundary intervention needs a trace proving that no hidden cache crossed the new boundary. Without such checks, an unchanged output tells the reader only that the whole procedure did not move the chosen score.

Compensation requires its own test. A candidate may reroute through an auxiliary cache after the target mechanism is blocked. That does not show that the mechanism was irrelevant in the baseline system. It shows that the configured system can recover. Run the intervention without adaptation, then with adaptation enabled, and record the transition. The difference separates causal use from recoverability.

A decisive negative result is narrower: the manipulation demonstrably changed the target variable, the measurement could detect the predicted effect, no compensating route became active and the candidate still matched the rival. That result lowers confidence in the mechanism-function claim. It still says nothing direct about phenomenal status. A well-designed null narrows the causal map; an unchecked null merely preserves ambiguity.

Turn a run into challengeable evidence

A striking intervention is still only a run. To become evidence, it must be possible for another team to identify the candidate, reconstruct the intervention, examine deviations and test whether the result survives changes that should not matter. Machine-learning reproducibility work has shown the value of code submission, checklists and independent reproduction challenges. [8] Model cards and datasheets add documentation of intended use, evaluation conditions and data provenance. [9][10] Artificial-mind research needs those practices plus a stricter record of causal boundaries.

Replication has four depths

An exact rerun checks whether the artifact executes. A seed replication checks whether the effect survives stochastic variation. An implementation replication rebuilds the same causal idea in different code. A conceptual replication tests the same prediction in a new task or environment. These depths should not be collapsed into one badge.

Replication means the causal pattern survives nuisance changes. Exact numerical identity can be useful for debugging, but science needs invariance. If a state-swap signature disappears when variable names, hardware or episode ordering change, the original effect may have tracked an implementation accident.

A sham intervention is the control for the intervention itself. It should perform the same serialisation, transfer, latency and recovery steps while preserving the causal value predicted to matter. If the sham changes the outcome, the target effect cannot yet be interpreted.

The replication capsule

The artifact should package more than source code. It needs the candidate boundary, family configuration, dataset generator, environment version, seeds, hardware and numeric settings, intervention definitions, expected fingerprints, raw traces, analysis code, governance decisions and a list of prohibited inferences. Every result row should point back to the manifest that produced it.

Preregistration matters because researchers otherwise have too many ways to choose an intervention, metric, layer, time window or rival after seeing the data. Registered Reports move review of the question and method before results are known. [7] The Cogitate adversarial collaboration went further: theory proponents and theory-neutral researchers agreed differential predictions, pass or fail criteria and interpretations before data collection. The resulting multi-method study challenged key commitments of both tested theories rather than crowning a ceremonial winner. [5][6]

The first machine study need not match that scale. It should copy the logic. One group proposes the mechanism. Another writes the strongest rival. A third implements and analyses the intervention without knowing which result is preferred. Deviations from the plan remain possible, but they are versioned and labelled exploratory.

python paper-207-candidate-family-lab.py \
  --episodes 100 \
  --seed 207 \
  --output aperture_run

#!/usr/bin/env python3
"""Aperture-1: a dependency-free candidate-family intervention lab.

This is a synthetic research harness. It distinguishes three mechanisms that
produce identical baseline behaviour, then records their different responses
under preregistered interventions. It is not a consciousness test.
"""

from __future__ import annotations

import argparse
import csv
import hashlib
import json
import platform
import random
import sys
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Dict, Iterable, List, Mapping, MutableMapping, Optional, Sequence, Tuple


@dataclass(frozen=True)
class Episode:
    episode_id: int
    cue: int
    hint: int


@dataclass(frozen=True)
class Intervention:
    name: str
    target: str
    burden: str
    reversible: bool
    expected_signature: Mapping[str, str]


@dataclass(frozen=True)
class GovernancePolicy:
    permitted_burdens: Tuple[str, ...] = ("minimal", "low", "moderate")
    require_recovery_for: Tuple[str, ...] = ("moderate",)
    prohibit_irreversible: bool = True

    def authorise(self, intervention: Intervention) -> Tuple[bool, str]:
        if intervention.burden not in self.permitted_burdens:
            return False, f"burden '{intervention.burden}' is outside the permitted set"
        if self.prohibit_irreversible and not intervention.reversible:
            return False, "irreversible intervention requires explicit external approval"
        if intervention.burden in self.require_recovery_for and not intervention.reversible:
            return False, "moderate-burden intervention lacks a recovery path"
        return True, "authorised by default policy"


class RecurrentCandidate:
    """Stores the cue in internal state and ignores the final hint."""

    name = "candidate_recurrent"

    def __init__(self) -> None:
        self.state: Optional[int] = None

    def observe_cue(self, cue: int) -> None:
        self.state = cue

    def answer(self, episode: Episode) -> int:
        return 0 if self.state is None else self.state


class ShortcutSibling:
    """Mechanism-ablated sibling: no persistent state; trusts the hint."""

    name = "sibling_shortcut"

    def observe_cue(self, cue: int) -> None:
        del cue

    def answer(self, episode: Episode) -> int:
        return episode.hint


class ReplayMimic:
    """Output-matched rival: replays a table indexed by episode identity."""

    name = "rival_replay"

    def __init__(self, lookup: Mapping[int, int]) -> None:
        self.lookup = dict(lookup)

    def observe_cue(self, cue: int) -> None:
        del cue

    def answer(self, episode: Episode) -> int:
        return self.lookup.get(episode.episode_id, 0)


def make_episodes(count: int, seed: int) -> List[Episode]:
    if count < 4 or count % 2:
        raise ValueError("episode count must be an even integer of at least 4")
    rng = random.Random(seed)
    cues = [0, 1] * (count // 2)
    rng.shuffle(cues)
    return [Episode(episode_id=i, cue=cue, hint=cue) for i, cue in enumerate(cues)]


def accuracy(predictions: Iterable[Tuple[int, int]]) -> float:
    rows = list(predictions)
    return sum(int(pred == truth) for pred, truth in rows) / len(rows)


def pair_opposite_cues(episodes: Sequence[Episode]) -> Dict[int, int]:
    zeros = [ep for ep in episodes if ep.cue == 0]
    ones = [ep for ep in episodes if ep.cue == 1]
    if len(zeros) != len(ones):
        raise ValueError("state-swap requires balanced cue classes")
    pairing: Dict[int, int] = {}
    for zero, one in zip(zeros, ones):
        pairing[zero.episode_id] = one.episode_id
        pairing[one.episode_id] = zero.episode_id
    return pairing


def evaluate_baseline(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        for model in (candidate, sibling, replay):
            model.observe_cue(ep.cue)
            results[model.name].append((model.answer(ep), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


def evaluate_hint_flip(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        changed = Episode(ep.episode_id, ep.cue, 1 - ep.hint)
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        for model in (candidate, sibling, replay):
            model.observe_cue(ep.cue)
            results[model.name].append((model.answer(changed), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


def evaluate_state_reset(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        candidate.observe_cue(ep.cue)
        sibling.observe_cue(ep.cue)
        candidate.state = None  # declared intervention
        results[candidate.name].append((candidate.answer(ep), ep.cue))
        results[sibling.name].append((sibling.answer(ep), ep.cue))
        results[replay.name].append((replay.answer(ep), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


def evaluate_state_swap(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    pairing = pair_opposite_cues(episodes)
    by_id = {ep.episode_id: ep for ep in episodes}
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        donor = by_id[pairing[ep.episode_id]]
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        candidate.observe_cue(donor.cue)  # donor state replaces recipient state
        sibling.observe_cue(ep.cue)
        results[candidate.name].append((candidate.answer(ep), ep.cue))
        results[sibling.name].append((sibling.answer(ep), ep.cue))
        results[replay.name].append((replay.answer(ep), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


def evaluate_id_relabel(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    offset = max(ep.episode_id for ep in episodes) + 1000
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        relabelled = Episode(ep.episode_id + offset, ep.cue, ep.hint)
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        for model in (candidate, sibling, replay):
            model.observe_cue(ep.cue)
            results[model.name].append((model.answer(relabelled), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


def evaluate_sham_copy(episodes: Sequence[Episode]) -> Dict[str, float]:
    replay = ReplayMimic({ep.episode_id: ep.cue for ep in episodes})
    results: Dict[str, List[Tuple[int, int]]] = {
        RecurrentCandidate.name: [],
        ShortcutSibling.name: [],
        ReplayMimic.name: [],
    }
    for ep in episodes:
        candidate = RecurrentCandidate()
        sibling = ShortcutSibling()
        candidate.observe_cue(ep.cue)
        sibling.observe_cue(ep.cue)
        candidate.state = int(candidate.state) if candidate.state is not None else None
        results[candidate.name].append((candidate.answer(ep), ep.cue))
        results[sibling.name].append((sibling.answer(ep), ep.cue))
        results[replay.name].append((replay.answer(ep), ep.cue))
    return {name: accuracy(rows) for name, rows in results.items()}


EVALUATORS = {
    "baseline": evaluate_baseline,
    "hint_flip": evaluate_hint_flip,
    "state_reset": evaluate_state_reset,
    "state_swap": evaluate_state_swap,
    "id_relabel": evaluate_id_relabel,
    "sham_copy": evaluate_sham_copy,
}

INTERVENTIONS = [
    Intervention(
        name="baseline",
        target="none",
        burden="minimal",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "high",
            "sibling_shortcut": "high",
            "rival_replay": "high",
        },
    ),
    Intervention(
        name="hint_flip",
        target="external hint",
        burden="low",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "stable",
            "sibling_shortcut": "collapse",
            "rival_replay": "stable",
        },
    ),
    Intervention(
        name="state_reset",
        target="persistent candidate state",
        burden="moderate",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "partial collapse",
            "sibling_shortcut": "stable",
            "rival_replay": "stable",
        },
    ),
    Intervention(
        name="state_swap",
        target="persistent candidate state",
        burden="moderate",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "follows donor",
            "sibling_shortcut": "stable",
            "rival_replay": "stable",
        },
    ),
    Intervention(
        name="id_relabel",
        target="episode identity",
        burden="low",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "stable",
            "sibling_shortcut": "stable",
            "rival_replay": "partial collapse",
        },
    ),
    Intervention(
        name="sham_copy",
        target="candidate state representation",
        burden="low",
        reversible=True,
        expected_signature={
            "candidate_recurrent": "stable",
            "sibling_shortcut": "stable",
            "rival_replay": "stable",
        },
    ),
]


def source_hash() -> str:
    try:
        payload = Path(__file__).read_bytes()
    except OSError:
        payload = b"embedded"
    return hashlib.sha256(payload).hexdigest()


def build_manifest(seed: int, episodes: int, authorisations: Mapping[str, str]) -> Dict[str, object]:
    return {
        "schema_version": "aperture-1.0",
        "claim_boundary": (
            "The run can identify mechanism-sensitive intervention fingerprints in a "
            "synthetic family. It cannot establish phenomenal consciousness or moral status."
        ),
        "theory_commitment": (
            "A temporally persistent internal variable should causally control answers "
            "that depend on an earlier cue."
        ),
        "family": {
            "candidate": "candidate_recurrent",
            "mechanism_ablated_sibling": "sibling_shortcut",
            "output_matched_rival": "rival_replay",
        },
        "shared_conditions": {
            "task": "recover a binary cue after a delay",
            "interface": "cue, episode identity, final hint",
            "metric": "accuracy",
        },
        "seed": seed,
        "episode_count": episodes,
        "python_version": platform.python_version(),
        "platform": platform.platform(),
        "source_sha256": source_hash(),
        "interventions": [asdict(item) for item in INTERVENTIONS],
        "authorisations": dict(authorisations),
        "prohibited_inferences": [
            "the candidate is conscious",
            "persistent state is sufficient for consciousness",
            "a negative result refutes every recurrence-based theory",
        ],
    }


def write_results(path: Path, results: Mapping[str, Mapping[str, float]]) -> None:
    names = [RecurrentCandidate.name, ShortcutSibling.name, ReplayMimic.name]
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.writer(handle)
        writer.writerow(["intervention", *names])
        for intervention, row in results.items():
            writer.writerow([intervention, *(f"{row[name]:.3f}" for name in names)])


def run(count: int, seed: int, output_dir: Path) -> int:
    episodes = make_episodes(count, seed)
    policy = GovernancePolicy()
    results: MutableMapping[str, Mapping[str, float]] = {}
    authorisations: Dict[str, str] = {}

    for intervention in INTERVENTIONS:
        allowed, reason = policy.authorise(intervention)
        authorisations[intervention.name] = reason
        if not allowed:
            continue
        results[intervention.name] = EVALUATORS[intervention.name](episodes)

    output_dir.mkdir(parents=True, exist_ok=True)
    write_results(output_dir / "results.csv", results)
    manifest = build_manifest(seed, count, authorisations)
    (output_dir / "manifest.json").write_text(
        json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8"
    )

    models = [RecurrentCandidate.name, ShortcutSibling.name, ReplayMimic.name]
    header = f"{'intervention':<14}" + "".join(f"{name:>22}" for name in models)
    print(header)
    print("-" * len(header))
    for intervention, row in results.items():
        print(f"{intervention:<14}" + "".join(f"{row[name]:>22.3f}" for name in models))
    print(f"\nWrote {output_dir / 'results.csv'}")
    print(f"Wrote {output_dir / 'manifest.json'}")
    return 0


def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--episodes", type=int, default=100, help="even number, at least 4")
    parser.add_argument("--seed", type=int, default=207)
    parser.add_argument("--output", type=Path, default=Path("aperture_run"))
    return parser.parse_args(argv)


def main(argv: Optional[Sequence[str]] = None) -> int:
    args = parse_args(argv)
    try:
        return run(args.episodes, args.seed, args.output)
    except (OSError, ValueError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 2


if __name__ == "__main__":
    raise SystemExit(main())

stateDiagram-v2
  [*] --> Claim
  state "Two perfect performers" as Claim
  state "The minimum discriminating family" as Test
  state "The notebook crosses the wall" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Govern the experiment before it becomes interesting

Most early studies will use small synthetic systems for which welfare concern is remote. That is exactly when governance should be designed. Waiting until a candidate produces compelling self-reports or complex preference-like behaviour makes every safeguard look like a reaction to publicity. Responsible-research proposals already argue for phased development, explicit objectives, knowledge-sharing rules and calibrated communication. [11][12] Recent methodological work also combines multi-theory indicators, causal tests and staged ethical safeguards. [13]

The fork case joins several uncertainties: whether the system has welfare, whether the control signal corresponds to valence, whether a copy preserves identity, and whether restoring a prior state repairs anything. Governance must not pretend these are answered. It can still prefer lower burden, fewer copies, shorter exposure, reversible changes and explicit stop conditions.

The welfare gate is not evidence that welfare exists. It is a decision procedure for asymmetric uncertainty. It prevents the absence of proof from being converted into unlimited experimental licence, while also preventing every state perturbation from being described as harm.

A low-cost precautionary gate

Each intervention should be classified before execution along dimensions that do not require a consciousness verdict: duration, intensity of control pressure, number of concurrent instances, persistence disruption, reversibility, recovery path and whether the study specifically seeks valence-like behaviour. The gate then chooses the least burdensome intervention that can still discriminate the hypotheses.

Minimal interventions include relabelling an external identifier or applying a sham copy. Low interventions include brief masking or reversible input changes. Moderate interventions include state reset, branch creation or sustained goal conflict. High interventions include irreversible deletion, unbounded replication or prolonged aversive optimisation. These labels are procedural, not claims about experience.

The gate should store an execution decision, not just a risk label: who authorised the run, what evidence gain was expected, what alternative was rejected, what stop condition applies and which snapshot or compensation path exists. Reversibility is the default, but restoration is not assumed to erase every ethically relevant consequence.

Communication is part of governance. A candidate’s first-person language can be an experimental datum, a trained conversational convention or both. Public summaries should state which prompts, policies and post-training incentives shaped those reports. They should avoid both confident denial and theatrical personification.

These positions do not make the experiment pointless. They determine its claim ceiling. The system can show that a state is causally available to report and planning. It can show that an output is not generated by a known shortcut. It can show that an indicator survives replication. It cannot, without a further measurement bridge and metaphysical argument, convert those findings into the fact of experience.

Consequence

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The immaculate demonstration
  M->>E: Two perfect performers
  E-->>M: compare rival explanations
  E->>D: Build a family that can disagree under intervention
  D-->>Q: revise scope or act

Build a family that can disagree under intervention

The first research budget should not be spent on making one candidate as impressive as possible. It should be spent on making a small family comparable, interruptible and reproducible. That means a synthetic environment before an open world, inspectable state before a frontier-scale black box, matched rivals before additional capabilities and a governance gate before welfare-like behaviour becomes a public controversy.

A proposal is ready to build when it can answer five questions. What exact property is being studied? Which configured system is the candidate? What ablated sibling and rival generator match its baseline? Which intervention fingerprint would distinguish them? What claim is prohibited even if the prediction succeeds?

The smallest useful implementation is Aperture-1 or something like it: three family members, one narrow task, four discriminating interventions, one sham, multiple seeds, a versioned manifest and an ordinal welfare gate. It is deliberately too small to impress anyone with general intelligence. Its purpose is to make scientific failure cheap and visible.

Do not build one impressive candidate. Build a family that can disagree under intervention. That decision turns the first system from a demonstration into an instrument. It will not settle whether machines can be conscious. It will let us learn which mechanisms are actually present, which explanations survive contact with counterfactuals and which next experiment is worth the added epistemic and ethical cost.