AI/ML Deep Dive: Verbalizable Representations & the Global Workspace

An intermediate-layer activation is like a table in an old schema version; the final layer is the new schema. The logit lens assumes the column names match and just runs SELECT; the J-lens first derives an average migration script, moves the old table into the new schema, then looks it up in the model's own "dictionary" (the unembedding).

Every Transformer layer reads from and writes to the same residual stream (the vector passed between layers — think of it as a shared state bus). To see what layer l is "thinking", the naive approach is the logit lens (nostalgebraist 2020): multiply the intermediate activation directly by the final vocabulary matrix and see which words score highest. The problem: early and middle layers don't share the final layer's coordinate system, so the readout is often commas and spaces. The tuned lens (Belrose et al. 2023) trains an affine translator per layer to match the final output — but what it learns is "what looks most like the next token", so the translator itself may read out things the model doesn't actually use.

Anthropic's July 2026 paper Verbalizable Representations Form a Global Workspace in Language Models asks a different question: not "what word does this resemble?" but "if I nudge this, which words become more likely for the model to say later?"

lens_l(h) = unembed( J_l · h ),   J_l = E[ ∂h_final / ∂h_l ]

• h: the activation at some position in layer l; h_final: the final-layer activation;
• ∂h_final/∂h_l: the Jacobian (a sensitivity table: "if each input dimension wiggles, how much does each output dimension move");
• E[·]: averaged over lots of ordinary text, all source positions, and the current and all future target positions — so it captures "will say now or later", not just the next token;
• unembed: the model's own output layer, turning a final-layer vector into vocabulary scores.

Intuition: the real network is nonlinear, but the averaged Jacobian is its first-order linear approximation — an "average influence map" from each layer to the output. It is derived from the model's own derivatives rather than fitted to a decoding objective, so it is less prone to "speaking for the model". The official companion code notes the lenses were fit on about 1000 sequences of 128 tokens of generic web text, and about 100 is already usable.

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
tok = GPT2Tokenizer.from_pretrained("gpt2"); m = GPT2LMHeadModel.from_pretrained("gpt2").eval()
L = 6  # inspect layer 6
def tail(h):  # run from layer L to the end (incl. final LayerNorm)
    for blk in m.transformer.h[L:]:
        out = blk(h); h = out[0] if isinstance(out, tuple) else out
    return m.transformer.ln_f(h)
def hidden(text):
    ids = tok(text, return_tensors="pt").input_ids
    return m(ids, output_hidden_states=True).hidden_states[L].detach()
J, corpus = torch.zeros(768, 768), ["The weather today is", "In 1905 Einstein", "My favorite food is"]
for text in corpus:  # toy: last position → last position only; the real lens also sums future positions
    hs = hidden(text)
    def f(v): h = hs.clone(); h[0, -1] = v; return tail(h)[0, -1]
    J += torch.autograd.functional.jacobian(f, hs[0, -1], vectorize=True) / len(corpus)
h = hidden("The capital of France is")[0, -1]
with torch.no_grad():
    for name, v in [("logit", m.transformer.ln_f(h)), ("J", J @ h)]:
        print(name, [tok.decode(i) for i in m.lm_head(v).topk(5).indices])

The residual stream is a server's entire memory; J-space is the handful of topics on a shared message bus. Most data is each module's local state; only a small part is published to the bus, where any downstream consumer — including the module that "says it out loud" — can subscribe.

With the J-lens, you can find, for every word in the vocabulary, the direction that "pushes the model to say it later". The space spanned by these directions is called J-space. The paper reports three geometric findings:

• Concentrated in middle layers: early layers mostly hold surface features, late layers are busy formatting the next token; the middle layers are the concept-level "workbench";
• Small share of variance: J-space accounts for less than about 10% of total activation variance — most of the "energy" is spent elsewhere;
• Limited capacity: it holds roughly k≈25 distinguishable concepts at once — a small register file, not a big memory.

The key point: low variance ≠ unimportant. Within a concept's representation, it is precisely that small J-space component that determines whether it can be reported. This challenges a common default — "the high-variance directions carry the main information" (the PCA intuition). Here, behavior is driven by an inconspicuous low-variance subspace.

import numpy as np
rng = np.random.default_rng(0)
d, k, n = 512, 25, 2000                        # dims / verbalizable rank / samples
Q = np.linalg.qr(rng.normal(size=(d, d)))[0]   # random orthonormal basis
J_dirs, other = Q[:, :k], Q[:, k:]              # first k dims play the role of J-space
# simulated activations: small J component, larger elsewhere (surface, position noise)
acts = rng.normal(size=(n, k)) * 1.0 @ J_dirs.T + rng.normal(size=(n, d - k)) * 1.3 @ other.T
var_J = ((acts @ J_dirs) ** 2).sum() / (acts ** 2).sum()
print(f"J-space variance share: {var_J:.1%}")   # ~3%: PCA would drop it first
# if "saying it" reads only the J component, variance-based reduction deletes the key signal
top_pc = np.linalg.svd(acts - acts.mean(0), full_matrices=False)[2][:50]
print("J energy kept in top 50 PCs:", round(float(((top_pc @ J_dirs) ** 2).sum() / k), 3))

Audit log vs. primary table: in many systems the "report" is a separately written log that can drift from the real business data. The paper argues J-space is more like a report that reads the primary table directly — when the model reports "what I'm thinking", it reads the very rows its reasoning is using.

Day 55 showed that chain-of-thought (CoT) can be unfaithful: the written reasons are not necessarily the real ones. What about reasoning that is never written? The paper uses causal interventions — change one thing, see whether behavior changes — to argue three points:

• Report: ask the model "what are you thinking about?" and the answer comes from J-space; swap the representation of "soccer" there for "rugby" and the model says it's thinking about rugby — the report is driven by this representation, not merely correlated with it;
• Directed modulation: tell the model to copy an unrelated sentence while "thinking about citrus fruits", and orange and lemon appear in J-space; ask it to do arithmetic silently, and intermediate results surface in J-space in sequence — without a word spoken;
• Silent reasoning: in a multi-hop question (e.g. "what color is Mars?"), "Mars" and "color" light up in the middle layers before the model outputs red. Swapping the J component of an intermediate with another problem's flips the answer noticeably more often than swapping the far higher-variance non-J component.

Taken together, the claim is: the reportable representations and the representations used in internal reasoning are the same ones. The other side matters just as much — selectivity: automatic tasks like fluent continuation barely rely on J-space, while flexible reasoning and "reporting experience" do. That is what a "global workspace" should look like: not all computation goes over the bus, only what multiple modules need to use together.

import numpy as np
rng = np.random.default_rng(1)
d, k = 64, 8
Q = np.linalg.qr(rng.normal(size=(d, d)))[0]; J, R = Q[:, :k], Q[:, k:]
w = J @ rng.normal(size=k)                 # the downstream "answer" reads only the J subspace
def make(c):                                # c = concept vector; non-J part has larger variance
    return J @ c + R @ rng.normal(size=d - k) * 3
def swap(a, b, P):                         # replace a's component in subspace P with b's
    return a - P @ (P.T @ a) + P @ (P.T @ b)
flips_J = flips_R = 0
for _ in range(1000):
    a, b = make(rng.normal(size=k)), make(rng.normal(size=k))
    if np.sign(w @ a) == np.sign(w @ b): continue    # only pairs whose answers differ
    flips_J += np.sign(w @ swap(a, b, J)) == np.sign(w @ b)
    flips_R += np.sign(w @ swap(a, b, R)) == np.sign(w @ b)
print("flips via J swap:", flips_J, " flips via non-J swap:", flips_R)  # the latter is 0 in this toy

Engineering counterpart → super-individual D10 (Hallucination Governance)

Global Workspace Theory sees the brain as many parallel microservices plus a capacity-limited broadcast bus: information that gets onto the bus is subscribed to network-wide and becomes "conscious". Stronger versions also require entry to be all-or-none, like a distributed commit that either takes effect entirely or not at all, rather than gradually.

Global Workspace Theory (GWT) was proposed by Bernard Baars in 1988 and later developed into a neural version by Dehaene and others. It aims to explain access consciousness (the kind of "being aware" where information can be reported and used by reasoning): most processing runs unconsciously in parallel, and only a small amount wins the competition, enters the global space, and is broadcast. The neural version also emphasizes ignition: once information crosses a threshold, it spreads abruptly and nonlinearly across the brain.

The paper lists five "workspace-like" properties J-space satisfies:

"Flexible generalization" means the same J vector can serve as an argument to many different downstream operations — like one message on the bus that different services each consume in their own way. The paper itself acknowledges that the architectural correspondence to GWT is loose: capacity limits and selectivity show up, but the full "ignition" mechanism has not been found.

Public commentary centers on three points. First, functional access ≠ phenomenal experience — philosopher Ned Block long ago distinguished access consciousness from phenomenal consciousness, and J-space corresponds at most to the former. Second, some commentators argue that many GWT requirements were relaxed to make the definition fit; strip away that framing and it is a finding about computational organization, not about minds. Third, the small-model replication failure mentioned above suggests the scope of the result needs more independent testing. The paper does not claim machine consciousness, but its wording leaves room for imagination.

import numpy as np
# compare two ways of "entering the workspace": linear/gradual vs ignition (all-or-none)
def linear_access(s):
    return s / s.sum()                     # share the bus in proportion to strength
def ignition_access(s, k=3, theta=0.6, gain=8):
    top = np.argsort(s)[-k:]                 # capacity limit: only the top k compete
    out = np.zeros_like(s)
    act = 1 / (1 + np.exp(-gain * (s[top] - theta)))  # steep sigmoid ≈ threshold
    out[top] = np.where(act > 0.5, 1.0, 0.0)    # above threshold → full broadcast, else silence
    return out
s = np.array([0.2, 0.55, 0.65, 0.9, 0.1, 0.58])  # activation strengths of 6 candidate concepts
print("linear:", linear_access(s).round(2))
print("ignition:", ignition_access(s))   # 0.58 and 0.65 are close, yet one ends at 0, the other at 1

• Anthropic Interpretability, Verbalizable Representations Form a Global Workspace in Language Models, 2026-07, transformer-circuits.pub/2026/workspace (arXiv:2607.15495) — the main thread of this issue: J-lens definition, the five properties, and the intervention experiments
• anthropics/jacobian-lens (GitHub) — official reference implementation for HuggingFace open-weight models; fit and apply lenses yourself
• nostalgebraist, interpreting GPT: the logit lens, LessWrong 2020 — the origin of "plug an intermediate layer straight into the output layer"
• Belrose et al., Eliciting Latent Predictions from Transformers with the Tuned Lens, arXiv:2303.08112 (2023) — learns an affine translator per layer; the reference point for understanding the J-lens trade-off
• Nelith Bandularatne, J-Lens: A Failed Replication on GPT-2, LessWrong 2026 — counter-evidence on small models and metric pitfalls; read alongside the main paper