The shared channel mistake

Residual connections were introduced to make deep networks easier to optimise. Instead of asking a block to replace its input, the block learns an update that is added back to the current state.1 Transformers use this pattern around attention and feed-forward sublayers.2 For one token position, a stripped-down update is:

Mechanistic interpretability often describes this residual stream as a communication channel. Attention heads and feed-forward components read from it and write to it; later components can respond to directions written earlier.3 That description is useful. It is also weaker than “global workspace”.

The hidden leap becomes clearer if we separate three meanings of “available”. A direction may be present in an activation. It may be decodable by an external probe. Or it may be causally consumed by the model’s own components. Presence does not guarantee decodability. Decodability does not guarantee use. Use by one component does not guarantee broad use.

Where selection could hide

The distinction does not imply that an ordinary transformer cannot develop workspace-like organisation. It says that the organisation must be found rather than inferred from the architecture diagram. Selection could be realised by a low-dimensional subspace whose directions are preferentially written and read. It could appear as a transient layer band in which competing concepts suppress one another. It could depend on attention, feed-forward updates and normalisation acting together, even though no component is labelled “gate”. In each case, the candidate is a pattern inside the residual computation, not the entire residual state.

This gives a useful search strategy. Begin with a content that several later operations need. Trace where a small edit first changes those operations coherently. Then ask whether rival content changes entry into that region and whether load produces displacement rather than diffuse degradation. A workspace candidate is discovered at the intersection of selective pressure and causal reach. Looking only for high decodability finds representations. Looking only for high downstream influence finds control points. The workspace hypothesis requires both, plus evidence that the same content survives a change of operation.

This replacement test matters because a transformer can be unrolled into a directed acyclic computation graph. The residual notation compresses many potential component-to-component paths into one additive state. The notation is excellent for analysis, but a compressed description must not be mistaken for the mechanism it merely makes convenient to see.

flowchart LR
  A["The river and the theatre"] --> B["The shared channel mistake"]
  B --> C["Four commitments inside one<br/>metaphor"]
  C --> D["The commitment intervention"]
  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

Four commitments inside one metaphor

Global workspace theories differ across cognitive and neuronal formulations. Their common functional core is still stronger than “many things can read the same state”. In broad terms, specialist processes operate locally; some content gains privileged access; that content becomes widely available for report, reasoning, control and memory-related operations; access is limited enough to create competition.457

The word “global” can distract us. No real system needs every component to receive an identical copy at the same instant. “Global” is an operational claim: the selected content crosses boundaries that normally keep specialist processes partly independent. The word “workspace” can also distract us. It is not just storage. It is a regime in which selected content becomes a common argument to several operations.

Commitment one: competition changes admission

Suppose a model represents both the door is locked and the corridor is clear. Raise the salience of the corridor signal while holding all other inputs fixed. In a competitive workspace, the intervention should alter whether the door content gains privileged access. One candidate should sometimes displace another. In a simple residual channel, both writes can coexist. Their later effects may interfere, but no admission event has been shown.

The crucial word is admission. A fall in task accuracy after adding noise is not evidence of workspace competition. It may be ordinary representational interference. The target must cross a declared boundary, such as entry into a privileged subspace, gate or ignition regime.

Commitment two: capacity pressure has a specific signature

A narrow workspace cannot carry arbitrary unrelated content at full fidelity. Increase the number of equally relevant proposals while keeping the channel width, task and readout fixed. A workspace should show structured pressure: displacement, chunking, serialisation or compression. A residual stream may also saturate, but width-limited superposition is not yet the same phenomenon. We need to know what is scarce: dimensions, norm, attention mass, selected slots, processing time or access to downstream consumers.

Commitment three: broadcast is causal reach, not common location

Broadcast means that the selected representation becomes an input to multiple consumers that would otherwise lack that information. To test it, alter the candidate content while preserving unrelated state. Then measure consequences in several downstream operations. A report head, planner and error monitor count as different consumers only if their computations are independently characterised. Three linear probes attached to the same final state do not.

A simple reach statistic is useful:

This metric is not sufficient on its own. A residual stream may affect many later blocks simply because they all read the channel. Broadcast becomes workspace-like only when the affected content also passed competition and capacity tests. Wide causal reach without selective entry is plumbing, not yet a workspace.

Commitment four: broad use preserves the content across operations

A representation is broadly usable when the system can bring the same content to bear on operations not fixed in advance by the producer. The door specialist should not need a bespoke message for reporting, another for route planning and a third for inhibition. The selected content should enter a common format that each operation can consume.

“Same content” is an intervention claim. Swap locked for open in the candidate representation. A report should change its word, a planner its route and a veto process its permission. If each operation changes only after a different internal edit, no common workspace object has been identified. If a single edit changes all of them in content-appropriate ways, the broad-use commitment gains support.

The commitment intervention

The practical contribution of this paper is a test protocol that refuses a single workspace score. It returns a four-part evidence vector and a list of failed controls. A system may show broadcast without competition, capacity without broad use, or flexible use without a stable candidate representation. Those are different architectures and should remain different conclusions.

Step 1: configure the candidate family

Begin with at least three matched systems. The first is the model under study. The second is a rival with the same task performance but no explicit access bottleneck, such as a wide residual channel. The third includes a declared workspace mechanism, such as top-k proposals broadcast to specialist modules. Matching output quality matters because a weak rival can make any internal property look necessary.

Declare the boundary: model weights, token context, key-value cache, recurrent state, external tools and readouts. Name the candidate representation, its layer or time range and its proposed consumers. Do not call every downstream block a consumer. A consumer needs a distinct operation with a measurable output.

Step 2: locate a candidate without promoting a probe to a mechanism

Use a probe, sparse feature dictionary, Jacobian-derived direction or circuit analysis to propose where content lives. Then intervene. A probe is a detector built by the researcher; the model’s own weights may ignore what the probe can decode. Activation patching, coordinate swaps and causal scrubbing move the claim from “information is present” towards “this representation mediates the behaviour”.

Step 3: run the four interventions

For competition, boost a semantically matched rival while preserving task evidence. Measure target admission, rather than only final accuracy. For capacity, add unrelated and related items separately. Related items may compress into a category, while unrelated items expose slot pressure. For broadcast, ablate or swap the target and measure causal effects across independently characterised consumers. For broad use, alter the same representation while changing the requested operation. The content-specific consequences should follow the operation.

Step 4: report a commitment vector and its receipts

For each commitment, retain the intervention, matched control, effect size, confidence interval, preregistered threshold and known bypasses. A compact result might read: competition supported; capacity supported only for unrelated content; broadcast supported across report and planning but not veto; broad use inconclusive because the representation had to be edited at two layers. This is more informative than “three out of four indicators”.

The table is a receipt template, not a scoring rubric. A positive result licenses only the wording in its row. A negative result can lower confidence in the mechanism, but it can also expose a weak intervention or a misplaced boundary. Reporting the control and the alternative interpretation prevents the four commitments from being converted into a ceremonial checklist.

The simulator encodes one deliberate asymmetry. A residual channel can have high causal reach and broad use because many consumers can read it. It receives no competition or capacity credit merely because added proposals dilute a signal. The gated and hybrid mechanisms receive those commitments only when a boosted rival or heavier load changes admission to the privileged route. This prevents generic interference from masquerading as workspace scarcity.

from __future__ import annotations

from dataclasses import dataclass
from math import sqrt
from random import Random
from statistics import mean
from typing import Literal

Mode = Literal["residual", "gated", "hybrid"]


@dataclass(frozen=True)
class Config:
    mode: Mode = "hybrid"
    slots: int = 3
    distractors: int = 10
    consumers: int = 6
    recurrence: int = 1
    trials: int = 600
    seed: int = 164


@dataclass(frozen=True)
class Metrics:
    competition: float
    capacity_pressure: float
    broadcast: float
    broad_use: float

    def passed(self, thresholds: tuple[float, float, float, float] =
               (0.35, 0.25, 0.60, 0.60)) -> dict[str, bool]:
        values = (
            self.competition,
            self.capacity_pressure,
            self.broadcast,
            self.broad_use,
        )
        names = ("competition", "capacity", "broadcast", "broad_use")
        return {name: value >= threshold
                for name, value, threshold in zip(names, values, thresholds)}


def top_k_contains_target(target: float, rivals: list[float], k: int) -> bool:
    ranked = sorted([target, *rivals], reverse=True)
    return target >= ranked[min(k, len(ranked)) - 1]


def boundary_target(rivals: list[float], slots: int) -> tuple[float, int | None]:
    """Place the target just inside the top-k boundary.

    Returns the target salience and the index of the matched rival whose boost
    would move the target just outside the admitted set. If all proposals fit,
    no diagnostic rival exists and the index is None.
    """
    k = max(1, min(slots, len(rivals) + 1))
    if not rivals:
        return 0.75, None
    ranked = sorted(rivals, reverse=True)
    if k >= len(rivals) + 1:
        return min(0.98, ranked[0] + 0.05), None
    if k == 1:
        target = min(0.98, ranked[0] + 0.03)
        return target, rivals.index(ranked[0])
    upper = ranked[k - 2]
    lower = ranked[k - 1]
    target = (upper + lower) / 2.0
    return target, rivals.index(lower)


def target_state(mode: Mode, target: float, rivals: list[float],
                 slots: int, recurrence: int) -> tuple[float, float]:
    """Return (workspace admission, downstream target weight).

    Residual mode has no selective admission mechanism. Hybrid mode keeps a
    full residual route but gives top-k content a privileged amplified route.
    """
    slots = max(1, min(slots, len(rivals) + 1))
    selected = top_k_contains_target(target, rivals, slots)
    persistence = 1.0 + 0.08 * max(0, recurrence)

    if mode == "residual":
        weight = 1.0 / sqrt(len(rivals) + 1)
        return 1.0, weight
    if mode == "gated":
        return (1.0, persistence / slots) if selected else (0.0, 0.0)

    base_route = 0.12 / sqrt(len(rivals) + 1)
    privileged = (0.88 * persistence / slots) if selected else 0.0
    return (1.0 if selected else 0.0), base_route + privileged


def simulate(config: Config) -> Metrics:
    rng = Random(config.seed)
    baseline_admission: list[float] = []
    rival_boost_admission: list[float] = []
    loaded_admission: list[float] = []
    broadcast_reach: list[float] = []
    broad_use_rate: list[float] = []

    for _ in range(config.trials):
        rivals = [0.82 * rng.random() for _ in range(config.distractors)]
        target, matched_rival = boundary_target(rivals, config.slots)

        admitted, target_weight = target_state(
            config.mode, target, rivals, config.slots, config.recurrence
        )
        baseline_admission.append(admitted)

        boosted = rivals.copy()
        if matched_rival is not None:
            boosted[matched_rival] = min(1.2, target + 0.08)
        rival_boost_admission.append(
            target_state(config.mode, target, boosted,
                         config.slots, config.recurrence)[0]
        )

        extra = [0.82 * rng.random() for _ in range(max(8, config.distractors * 2))]
        loaded_admission.append(
            target_state(config.mode, target, rivals + extra,
                         config.slots, config.recurrence)[0]
        )

        sensitivities = [0.45 + 0.65 * rng.random()
                         for _ in range(config.consumers)]
        deltas = [2.0 * target_weight * s for s in sensitivities]
        broadcast_reach.append(mean(delta > 0.24 for delta in deltas))

        # Five distinct operations consume the same candidate representation.
        operation_gains = (0.62, 0.78, 0.94, 1.10, 1.28)
        flips = []
        for gain in operation_gains:
            bias = rng.uniform(-0.34, 0.34)
            positive = bias + gain * target_weight
            negative = bias - gain * target_weight
            flips.append((positive >= 0) != (negative >= 0))
        broad_use_rate.append(mean(flips))

    b = mean(baseline_admission)
    competition = max(0.0, min(1.0, (b - mean(rival_boost_admission)) / max(b, 1e-9)))
    capacity = max(0.0, min(1.0, (b - mean(loaded_admission)) / max(b, 1e-9)))

    return Metrics(
        competition=competition,
        capacity_pressure=capacity,
        broadcast=mean(broadcast_reach),
        broad_use=mean(broad_use_rate),
    )


if __name__ == "__main__":
    for mode in ("residual", "gated", "hybrid"):
        metrics = simulate(Config(mode=mode))
        print(f"{mode:8s}", metrics, metrics.passed())

stateDiagram-v2
  [*] --> Claim
  state "Where selection could hide" as Claim
  state "Commitment one: competition<br/>changes admission" as Test
  state "Commitment two: capacity<br/>pressure has a specific<br/>signature" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

What current evidence licenses

The test becomes more useful when applied to what is actually known rather than to an abstract transformer. On the neuroscience side, GNW proposes that selected content undergoes widespread amplification and availability through a distributed, recurrent network. Experimental traditions have linked conscious access with threshold-like changes, long-range interaction and flexible report, but the mapping from these observations to the theory remains contested.67

On the machine side, the whole residual stream clearly satisfies a weak availability claim. Components write into a shared state; later layers can read earlier contributions. Explicit shared-workspace architectures go further by imposing bandwidth limits and competition among specialist modules.1112 Until recently, the interesting open question was whether ordinary language-model training could produce a privileged workspace-like subspace without that mechanism being designed in advance.

Several findings map onto this paper’s commitments. J-space content emerges across an intermediate layer band rather than simply occupying the whole residual stream. The reported occupancy is on the order of tens of active token-aligned concepts and explains a small fraction of activation variance. Related list items appear to compress around a shared category; category switches rapidly evict the old family. Rival tasks can interfere, especially when one requires multi-step arithmetic. J-space-aligned directions are reported to be preferentially amplified and broadly composed with downstream components. Swapping a concept can alter later report and internal reasoning.

This supports a learned candidate subspace, not the proposition that “the residual stream is the global workspace”. Most computation remains outside the J-space as characterised. The lens is constrained by vocabulary-aligned, often single-token directions. The distinction between intermediate workspace content and imminent motor output is partly empirical and not yet fully principled. The forward pass lacks the recurrent long-range loops used in biological GNW implementations, and whether depth preserves the relevant function remains open.14

The strongest rival explanation

A language model acts through tokens. A representation aligned with possible words is therefore unusually convenient: it can influence internal computation and future output with little translation. The reported workspace-like J-space may arise because input, internal supervision and action all share a linguistic geometry. That would explain verbalizability, broad read/write compatibility and even some capacity effects without implying a domain-general workspace of the human kind.

This rival makes a discriminating prediction. Give a model a genuinely different output space, such as continuous motor control or image generation, while preserving language as only one modality. If the privileged subspace remains purely token-aligned, the “global” claim weakens. If distinct verbal, visual and motor contents enter a common limited-capacity format and one intervention reroutes several modalities, the workspace interpretation strengthens.

The consciousness boundary

Functionalists can treat the four commitments as part of a computational account of access consciousness. If a system preserves the relevant causal roles, different physical implementations may be acceptable. Recurrent-processing theorists can object that a single feed-forward sweep lacks the return interactions constitutive of conscious processing. Biological naturalists can hold that the right functional pattern is insufficient without specific living mechanisms. Causal-structure theories can ask whether the physical implementation has the intrinsic organisation their accounts require. A consciousness-primary or idealist view can accept the functional findings while denying that they decide where awareness is present.

These positions disagree about what further bridge is needed. They agree on one restraint: workspace-like access is not identical to phenomenal consciousness. A transformer can satisfy a functional indicator without transformer attention being awareness, residual addition being experience or verbal reports establishing an inner point of view. The commitment intervention narrows a computational question. It does not remove the metaphysical remainder.13

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The river and the theatre
  M->>E: Where selection could hide
  E-->>M: compare rival explanations
  E->>D: Make a workspace candidate win the four-part assay
  D-->>Q: revise scope or act

Make a workspace candidate win the four-part assay

Do not decide whether a transformer “has a global workspace” by inspecting its block diagram. Decide whether a declared representation earns the name through intervention. Start with the configured system boundary. Identify a candidate subspace or state transition. Boost a rival to test admission. Increase unrelated load to expose capacity pressure. Swap the candidate to measure causal reach. Change the requested operation to test whether the same content remains usable.

For researchers, this changes the unit of comparison. The honest comparison is not residual stream versus brain-wide workspace. It is a set of preserved relations: selective entry, bounded occupancy, broad causal reach and operation-general reuse. Recurrence, biological substrate, intrinsic causal structure and phenomenal status remain separate questions. A result can therefore be strong without pretending to be complete.

For engineers, the distinction changes architecture choice. A shared residual channel is excellent when many components should accumulate partial results. An explicit bottleneck is justified when specialists must coordinate around a small common state, when access needs to be inspectable or when overload should produce controlled displacement rather than diffuse interference. A learned candidate subspace may offer the benefits of both, but only after its boundaries and failure modes are measured.

It also changes how negative evidence should guide design. Failure on competition does not demand a wider stream; it may demand an admission mechanism. Failure on broadcast does not demand a stronger gate; it may reveal that consumers never received the selected state. Failure on broad use may show that the system uses efficient specialist messages instead of a common representation. Those can be good engineering choices. The assay is valuable because it tells us which coordination problem the architecture actually solves.

The question to carry forward is therefore precise: Which representation wins access, what does it displace, who causally consumes it, and which operations change when it is swapped? Once those answers are visible, the metaphor has done its work and can be replaced by a mechanism.