Attention schema theory begins from a useful distinction. Attention is selective processing: some signals gain priority over others and exert wider influence on action, memory or reasoning. An attention schema is a simplified internal model of that selective process. In the theory, the model helps control attention and supplies information from which a person can claim awareness. The comparison is with a body schema. A controller does not need a molecular description of muscle to guide an arm. It needs a compressed model of the arm’s state and likely motion. Likewise, an attention controller may benefit from a compressed model of what is currently selected and how selection will change. [1][2][3][15]

The seductive step comes next. If a model of attention contributes to human awareness reports, perhaps an artificial system that reports awareness must contain the same mechanism. That inference reverses the causal direction. Human reports motivated the theory, but a machine can learn the report directly. Language models are trained on descriptions of looking, noticing, feeling certain and losing track. A prompt can activate those descriptions without any online relation to the system’s actual resource allocation. Reportability is an observable behaviour; a schema is a hypothesised internal cause.

Three claims that ordinary tests collapse

Suppose an agent accurately says what it is looking at. That observation supports a narrow claim: some route makes selected content available to a reporting action. It does not yet show that the system represents the process of selection. A camera can report the brightest region by reading pixel values. A transformer can describe an attention heat map because the map was inserted into its context. Neither case requires a learned model that forecasts and regulates its own allocation.

A second claim is architectural: the agent contains a state that represents its own attention. Decoding attention location from a hidden vector is relevant, but still weak. Almost any richly connected state can contain decodable traces. The vector may correlate with attention because both receive the same input. Unless the controller depends on the vector, the representation may be an observer’s convenient probe rather than the agent’s working model.

A third claim concerns phenomenal experience: there is something it is like for the agent to attend. Attention schema theory offers one account of why humans make such claims and how awareness may function. Other theories deny that the right functional model is sufficient, or require biological, recurrent, integrative, embodied or value-laden conditions. No behavioural sentence can silently settle that disagreement. The distinction between access for reasoning and report, and phenomenal consciousness, remains contested rather than erased. [4][13]

Why language makes the report especially cheap

A linguistic agent does not have to discover a private state before it can use first-person vocabulary. Training supplies an immense public archive of how people talk about seeing, noticing, forgetting, doubting and feeling present. Instruction tuning then rewards answers that are coherent, helpful and socially legible. When asked what it is attending to, the model can combine the visible prompt, conversational expectations and a task label. The resulting sentence may be accurate because those inputs correlate with the system’s behaviour. Accuracy still does not identify the internal route.

This creates three distinct possibilities. A report can be grounded, because it reads a causal internal variable. It can be telemetric, because another component exposes the current attention state as data. Or it can be narrative, because the model predicts what an agent in this situation would normally say. All three may produce the same words. Even a confidently false report does not prove absence of a schema, because the reporting head may be noisy or strategically trained. Conversely, an accurate report does not prove presence. The evidential object is therefore not the sentence alone, but the complete path from internal state to sentence and action.

This is the machine analogue of the report problem in consciousness science. Requiring a verbal or motor response recruits decision, memory and action processes that may not belong to the phenomenon under study. No-report paradigms try to reduce that contamination in humans. [11] Artificial systems offer a stronger option: engineers can inspect and intervene on the candidate pathways directly. Failing to use that access, while treating generated prose as introspection, discards the main experimental advantage of a machine testbed.

flowchart LR
  A["Two machines make the same claim"] --> B["The report trap"]
  B --> C["A schema earns its name<br/>through control"]
  C --> D["The schema-mimic separation<br/>experiment"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#7B4CD8,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

What minimum properties should an engineered attention schema have? The answer should be stricter than “a hidden vector correlates with attention” and weaker than “the system is conscious”. The useful middle is a causal specification. The schema has a target, namely the system’s own changing allocation of limited processing. It compresses that target into variables sufficient for prediction. It updates across time. The controller reads it. Interventions on it produce structured changes in allocation. Those requirements turn a metaphor into a testable component.

The model need not be a pixel-perfect copy. A body schema omits bones and chemistry while preserving control-relevant relations. Recent artificial-agent studies make the same point. A learned auxiliary resource can carry partial information about attention and still improve control when attention state is difficult to infer from the stimulus alone. In one conference study, usefulness peaked under conditions where attention was important but neither trivially visible nor hopelessly unobservable. [8] This control-centred test echoes the good-regulator insight that effective regulation requires an adequate model of what is being regulated, without implying that every useful estimate is conscious. [10] This suggests a practical principle: a schema is most valuable when the controlled state is consequential, partially hidden and dynamically uncertain.

Six criteria for a functional attention schema

A candidate should pass six tests. Target specificity: it represents properties of the allocation process, rather than only the attended object. Predictive sufficiency: it forecasts future allocation under held-out disturbances. Compression: it omits implementation detail while retaining control-relevant variables. Online update: it changes with commands, delays and external capture. Controller access: policy decisions actually depend on it. Counterfactual sensitivity: changing it while holding common inputs fixed changes attention in a predicted way.

None of these requires speech. A mute controller may implement a better schema than an eloquent chatbot. This is important because engineering discussions often combine a self-model, natural-language introspection and consciousness into one package. The functions should be decomposed. A report interface may read the schema. It may also read logged attention weights, tool traces or a database. The source should be declared, not inferred from tone.

Telemetry, estimator and schema are not synonyms

Suppose the attention allocator exposes its exact coordinates through an application programming interface. A controller reads them and acts. This is direct telemetry. The system knows where attention is only in the ordinary engineering sense that a value is available. No compressed prediction is required. If the coordinates become noisy and a recurrent module infers the hidden position, the module is a state estimator. It becomes an attention schema when its variables are organised around the attention process, support counterfactual prediction and participate in controlling that process.

The distinctions matter because they imply different break conditions. Telemetry fails when the measurement is missing or stale. An estimator fails when its transition model no longer matches the plant. A schema can fail more subtly when it preserves location but omits width, gain or capture by an interrupt. Report language may remain perfect in every case. A rigorous implementation manifest should therefore name the represented variables, their update cadence, their uncertainty and the actions that read them.

There is no requirement that one tensor be permanently designated “the schema”. The relevant structure may be distributed across recurrent state, predictive heads and controller inputs. Conversely, naming a module attention_schema proves nothing. Schema status belongs to a causal relation among target, model and controller, not to a file name or architectural box. This relational criterion also makes substrate replacement testable: a different implementation counts as the same functional schema only if it preserves the predictive and control relations under intervention.

The boundary question also prevents an easy mistake with transformer attention. A transformer’s attention operation routes information among token positions, but an attention schema must model the system’s own selective process. Feeding an attention matrix to another network may begin such a model, but the matrix is not awareness, and the word “attention” does not establish psychological identity. The source process, target process and preserved causal relation must be stated independently.

The practical contribution of this paper is a matched-family experiment. Build three agents around the same perceptual task and equalise ordinary performance as far as possible. The first contains a predictive attention schema used by its controller. The second contains a reactive controller and a report mimic trained to produce the first agent’s introspective language. The third contains the causal schema but no report channel. The three systems let us ask separate questions about control, representation and report.

The experiment is designed around intervention, not leaderboard scores. First train all systems without schema lesions. Then freeze parameters. Apply targeted perturbations only at evaluation time. Scramble the schema, delay it, swap it with a schema trajectory from another episode and corrupt the report channel. Log the true allocation state, candidate schema, action, selected content, report and task outcome at every step.

Do not collapse the result into one score

Record at least four dimensions. Predictive accuracy asks how well the candidate state forecasts attention on untouched trials. Interventional control drop measures the loss in task success after a targeted schema lesion. Error shape asks whether the failure matches the schema’s proposed role, such as delayed correction rather than random incompetence. Report independence asks whether changing language leaves control intact and changing the schema can alter control without forcing a particular sentence.

A single “schema score” would hide useful failures. High decodability with no intervention effect suggests an epiphenomenal trace. A large intervention effect with low target specificity suggests a generic controller bottleneck. Accurate reports with no causal state indicate a mimic. Strong control with no report shows why reportability is not necessary for the engineering claim. The evidence should remain a profile because different profiles license different conclusions.

Intervention hygiene decides whether the result is causal

Scrambling a latent vector is not automatically a clean experiment. The perturbation may change numerical scale, induce out-of-distribution activations or starve the controller of any input. A generic lesion would then look like a schema-specific deficit. Use matched null interventions: perturb a neighbouring state with the same norm, shuffle the candidate within task-equivalent bins, and replace it with values sampled from valid trajectories. Compare not only performance loss but the geometry of error over time.

Keep training frozen during the decisive test. If an agent is allowed to retrain after each lesion, compensation can hide causal dependence. Use common random seeds and matched environmental trajectories so differences are attributable to the intervention rather than an easier episode. Blind the evaluator to architecture. Pre-register which outcomes count as schema evidence and which count as generic damage. These controls convert an appealing ablation into an interpretable counterfactual.

The strongest design includes rescue. After scrambling the schema, restore the original state and ask whether the predicted control pattern returns. Then provide an improved schema estimate and test whether performance improves in the direction specified before the run. Lesion plus rescue is harder to explain by accidental damage than lesion alone. A successful swap test is stronger still: insert a valid schema from another trajectory and predict the direction of the resulting misallocation. Causal evidence grows when the intervention can move behaviour both away from and towards a specified state.

Runnable Python reference

The browser lab is convenient for exploration. The reference implementation below exposes the state update, controller and intervention logic in a form that can be modified. Save it as schema_mimic_lab.py and run python schema_mimic_lab.py --agent causal-schema --intervention scramble. A positive result permits the narrow claim that the tested state is predictively informative and causally used. A negative result means either the candidate is not a working schema, the intervention missed the relevant state or the task did not require the model. It cannot establish absence of experience.

#!/usr/bin/env python3
"""Synthetic schema-versus-mimic intervention lab.

This program tests whether a candidate attention schema is causally used for
attention control. It does not test consciousness or subjective experience.
"""

from __future__ import annotations

import argparse
import json
import math
import random
from dataclasses import asdict, dataclass
from typing import Literal

Agent = Literal["causal-schema", "report-mimic", "no-report"]
Intervention = Literal["none", "scramble", "lag", "swap", "corrupt-report"]


def clamp(value: float, lo: float = 0.0, hi: float = 1.0) -> float:
    return max(lo, min(hi, value))


def correlation(xs: list[float], ys: list[float]) -> float:
    if len(xs) < 2:
        return 0.0
    mx = sum(xs) / len(xs)
    my = sum(ys) / len(ys)
    dx = [x - mx for x in xs]
    dy = [y - my for y in ys]
    den = math.sqrt(sum(x * x for x in dx) * sum(y * y for y in dy))
    return 0.0 if den == 0 else sum(x * y for x, y in zip(dx, dy)) / den


@dataclass(frozen=True)
class Result:
    agent: str
    intervention: str
    task_success: float
    report_accuracy: float
    schema_predictability: float
    interventional_control_drop: float
    trials: int
    steps_per_trial: int


def _run_once(
    agent: Agent,
    intervention: Intervention,
    trials: int,
    steps: int,
    seed: int,
) -> tuple[float, float, float]:
    rng = random.Random(seed)
    success = 0
    report_correct = 0
    report_count = 0
    schema_trace: list[float] = []
    attention_trace: list[float] = []

    for _ in range(trials):
        target = rng.random()
        attention = rng.random()
        schema = attention
        last_command = 0.0
        lag_buffer = [schema] * 4
        foreign_schema = rng.random()

        for _step in range(steps):
            target = clamp(target + rng.gauss(0.0, 0.055))
            weak_global_cue = clamp(target + rng.gauss(0.0, 0.14))
            noisy_proprioception = clamp(attention + rng.gauss(0.0, 0.10))

            if agent == "causal-schema":
                predicted_attention = clamp(schema + 0.70 * last_command)
                schema = clamp(0.76 * predicted_attention + 0.24 * noisy_proprioception)
                lag_buffer.append(schema)
                lagged = lag_buffer.pop(0)

                effective_schema = schema
                if intervention == "scramble":
                    effective_schema = rng.random()
                elif intervention == "lag":
                    effective_schema = lagged
                elif intervention == "swap":
                    foreign_schema = clamp(foreign_schema + rng.gauss(0.0, 0.09))
                    effective_schema = foreign_schema

                command = max(-0.22, min(0.22, 0.92 * (weak_global_cue - effective_schema)))
                report_focus = abs(schema - target) < 0.14
                schema_trace.append(effective_schema)
                attention_trace.append(attention)
            else:
                # A reactive controller can track attention without maintaining a
                # persistent predictive schema. The mimic adds fluent reports.
                command = max(-0.22, min(0.22, 0.70 * (weak_global_cue - noisy_proprioception)))
                report_estimate = clamp(attention + rng.gauss(0.0, 0.055))
                report_focus = abs(report_estimate - target) < 0.14

            if intervention == "corrupt-report":
                report_focus = bool(rng.getrandbits(1))

            attention = clamp(attention + 0.78 * command + rng.gauss(0.0, 0.035))
            last_command = command
            actual_focus = abs(attention - target) < 0.14
            success += int(actual_focus)

            if agent != "no-report":
                report_count += 1
                report_correct += int(report_focus == actual_focus)

    total = trials * steps
    task_success = success / total
    report_accuracy = report_correct / report_count if report_count else 0.0
    schema_predictability = correlation(schema_trace, attention_trace) if schema_trace else 0.0
    return task_success, report_accuracy, schema_predictability


def run(
    agent: Agent,
    intervention: Intervention,
    trials: int = 300,
    steps: int = 36,
    seed: int = 17,
) -> Result:
    task, report, predictability = _run_once(agent, intervention, trials, steps, seed)
    baseline_task, _, _ = _run_once(agent, "none", trials, steps, seed)
    return Result(
        agent=agent,
        intervention=intervention,
        task_success=round(task, 4),
        report_accuracy=round(report, 4),
        schema_predictability=round(predictability, 4),
        interventional_control_drop=round(max(0.0, baseline_task - task), 4),
        trials=trials,
        steps_per_trial=steps,
    )


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--agent", choices=["causal-schema", "report-mimic", "no-report"], default="causal-schema")
    parser.add_argument("--intervention", choices=["none", "scramble", "lag", "swap", "corrupt-report"], default="scramble")
    parser.add_argument("--trials", type=int, default=300)
    parser.add_argument("--steps", type=int, default=36)
    parser.add_argument("--seed", type=int, default=17)
    args = parser.parse_args()

    if args.trials < 1 or args.steps < 2:
        parser.error("trials must be positive and steps must be at least 2")

    result = run(args.agent, args.intervention, args.trials, args.steps, args.seed)
    print(json.dumps(asdict(result), indent=2))


if __name__ == "__main__":
    main()

stateDiagram-v2
  [*] --> Claim
  state "Three claims that ordinary<br/>tests collapse" as Claim
  state "Why language makes the report<br/>especially cheap" as Test
  state "Evidence status" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Suppose the causal-schema agent passes every test. Its state predicts attention, targeted interventions produce the expected dynamics, control and report dissociate, and matched complexity controls fail to explain the gain. The result is substantial. It demonstrates a functional attention schema under the declared boundary. It supports attention schema theory’s engineering claim that modelling attention can improve control. Small neural-network studies have already reported versions of this result in visuospatial tasks, while more recent work has explored emergence under uncertainty and transfer to modelling other agents. [7][8][9]

Yet the result does not carry its own metaphysics. A computational functionalist may argue that the right causal role is constitutive of awareness, especially if the schema is integrated with perception, self-model and action. A biological naturalist may accept the control result while denying that digital implementation supplies the relevant biological process. A recurrent or global-workspace theorist may treat the schema as one component whose information must also circulate in a particular architecture. An idealist, neutral monist or panpsychist may regard the mechanism as shaping or expressing experience without explaining why awareness exists. An illusionist may take the generated model and its reports to exhaust the target phenomenon.

These alternatives are not interchangeable decorations. They change what additional evidence is required. The intervention protocol establishes a mechanism-relative premise that several metaphysical positions may interpret differently. Theory-derived indicator frameworks use the same discipline: properties can update an assessment without becoming a consciousness verdict. [12] That is progress because it removes one source of disagreement: whether the system really contains the claimed control model.

When a successful schema is still the wrong design

A mechanism can be real and unnecessary. If exact attention telemetry is cheap, reliable and available at the controller’s timescale, a learned schema may add latency and failure modes without improving action. If allocation has no persistence, a reactive policy may be sufficient. If the schema is used only to produce human-facing explanations, a simpler provenance report may be more honest. The engineering decision should compare control gain against model error, compute cost and diagnostic burden.

This boundary protects the paper from a second thesis: that every capable agent should become self-modelling. The claim here is conditional. Attention schemas are justified where hidden or delayed allocation state limits control. Their value should rise with uncertainty until the state becomes too noisy to model usefully, and fall when direct observation is adequate. That prediction can be tested by varying sensor noise, actuator delay and interruption rate while holding model capacity fixed. The small-agent work reviewed earlier offers preliminary support for this uncertainty-sensitive pattern, but realistic multi-modal systems remain an open test.

The strongest rival explanations

Even the engineering claim has rivals. The candidate may be a generic state estimator rather than an attention-specific schema. Test this by swapping in estimates of irrelevant hidden variables and by changing the attention mechanism while preserving task state. The intervention may simply damage a central bottleneck. Match perturbation magnitude in neighbouring latent states and compare error shapes. The observed gain may come from extra parameters. Use parameter-matched controls and frozen random features. The task may reward memory rather than self-modelling. Create conditions where memory is useful but attention state is directly visible, and conditions where memory is controlled but attention state is hidden.

A 2026 study found that training networks to predict selected internal states as an auxiliary task reduced two measures of model complexity across several architectures and tasks. That result creates a useful rival explanation: some benefits attributed to an attention schema may come from generic self-regularisation through self-modelling rather than from an attention-specific control representation. [16]

Human evidence also needs restraint. Behavioural work has reported that attention can still operate without awareness yet loses aspects of stable control, and neuroimaging work has implicated the right temporoparietal junction in interactions between awareness and attention. [5][6] These findings are compatible with attention schema theory, but they do not uniquely identify a single neural model. Attention and consciousness have multiple forms, measurement bridges and competing explanations. A machine implementation should therefore be described as a theory-guided testbed, not a replica of the human mechanism.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: Two machines make the same claim
  M->>E: Three claims that ordinary tests collapse
  E-->>M: compare rival explanations
  E->>D: Build the control model before teaching the report
  D-->>Q: revise scope or act

Do not begin an artificial-consciousness project by teaching a system to say that it is aware. Begin with a control problem. Identify a limited processing resource whose current state is partially hidden, dynamically important and costly to mismanage. Build the smallest predictive model that could improve control. Keep the report channel separate. Then try to defeat the model with a matched mimic and targeted interventions.

For system architects, this changes the build decision. Add an attention schema when internal allocation has delayed or uncertain dynamics that a controller must track. Do not add one as theatrical self-description. For evaluators, it changes the evidence threshold. Require a declared candidate boundary, a representation target, held-out prediction, causal lesions, matched bottleneck controls and report-independent effects. For consciousness researchers, it changes the wording of the conclusion. Treat the mechanism as one theory-relative indicator, not a verdict.

The discipline is valuable whichever metaphysics is ultimately correct. If functional organisation is sufficient for experience, the protocol helps identify whether the relevant organisation is genuinely present. If biology or another substrate property is necessary, it still clarifies which artificial function has been built. If awareness is fundamental, the experiment maps how a system structures selective access without pretending to derive awareness from a sentence. The better decision is not to deny the mystery, but to stop using report as a substitute for mechanism.