An early hope of interpretability was one neuron = one concept: find the “cat neuron,” read the model like a labeled diagram. Reality refused. Single neurons routinely fire for cats, and car grilles, and the number 7 — polysemanticity — and for years nobody was sure whether that was noise or strategy.

Anthropic’s 2022 answer: it’s strategy, and it’s forced. Models have far more useful concepts to represent than dimensions to hold them, so gradient descent packs concepts into shared space — superposition — accepting a little interference between them as the price of fitting more in.

The panel isn’t a diagram of that result: it’s the actual experiment, 15 parameters small, retrained live every time you move the slider. Five features must survive a squeeze through a 2-dimensional bottleneck. Each arrow is where one feature lives in that space. The slider controls sparsity — how rarely each feature shows up in the data:

• Dense (0%) — features are always present, so overlaps always collide. The model triages: two features get clean axes, the rest get dropped.
• Sparse (90%+) — features rarely co-occur, so collisions are rare. Now the model keeps all five, spacing the arrows into a near-perfect pentagon — 72° apart, each feature slightly interfering with its neighbors, none abandoned.

That pentagon is gradient descent choosing to overlap concepts because the data made it cheap. Real language is exactly this kind of sparse — “Golden Gate Bridge” and “medieval falconry” almost never co-occur — which is why a 40,000-dimension model can represent millions of concepts.

The catch: superposed concepts can’t be read off one neuron at a time. To un-mix them, researchers train sparse autoencoders to recover the true feature directions — that’s how the steerable features in Step 4 were found.

In the LLM tracks you met attention as a mechanism — every token queries every earlier token. But mechanism isn’t purpose. What did training actually use attention to build? Here’s the first complete answer anyone extracted: the induction head, a tiny algorithm for continuing patterns:

If you’ve seen [A][B] before, and you’re looking at [A] again — predict [B].

Once “Mr Dursley” has appeared, the next “Mr D” should continue “ursley”. No grammar, no meaning — pure pattern completion. The panel shows the attention map in the same rows-look-at-columns language as the attention scene. Read the bottom row: the head finds the previous occurrence of the current token and locks onto the token right after it — the teal-ringed cell. That target is what gets copied into the prediction.

Under the hood it’s a genuine two-part circuit: one head in an earlier layer marks each token with “what came before me,” and the induction head in a later layer uses that marking to find the match-and-look-ahead cell. Two learned parts, composing into one legible algorithm — discovered in the weights, not designed into them.

Now toggle trained off. That smear is what attention looks like before the circuit forms. In real training runs the flip happens abruptly — a sudden drop in loss early in training (the “induction bump”) right when these heads snap into place. And their reach goes far beyond literal copying: induction heads are a leading candidate for why LLMs can do in-context learning — following patterns from your prompt that they were never trained on. Fuzzier versions match [A*][B*]…[A]→[B-ish], completing analogies rather than echoes.

One legible circuit, found. The uncomfortable news: a frontier model likely contains millions of interacting circuits, and this is among the very few fully mapped. That’s the gap the next two panels start to close from other angles.

The transformer scenes told you a token’s vector gets “refined at every layer.” Refined how? Here’s a trick that lets you watch: the model’s final step converts its last internal vector into next-word probabilities — but nothing stops you from applying that same conversion to the vector at every layer along the way. It’s called the logit lens: eavesdropping on a thought before it’s finished.

The panel reads out GPT-2-small’s twelve layers for a simple prompt. The pattern is the finding:

• Early layers offer generic filler — the, a, punctuation. The prompt’s meaning hasn’t been assembled yet.
• Middle layers get the category before the answer: cities and place names surface, wrong ones included. The model has computed “a city goes here” but not yet which.
• Late layers lock in — the right answer takes the lead and then simply grows more certain, layer after layer.

That trajectory reframes what depth is. Eighty stacked blocks aren’t eighty repetitions of one act — they’re a pipeline from syntax, to semantics, to commitment. It also explains a practical trick: since late layers often just sharpen an already-decided answer, you can sometimes exit early and skip the remaining layers — a real inference optimization in production models.

Honest asterisk: this panel’s numbers are curated to match the published shape of logit-lens readings, not measured live (the repo ships an optional script that regenerates them from a real GPT-2). And the lens itself is a simplification — middle layers aren’t literally “trying to answer”; we’re forcing a final-layer interpretation onto intermediate states. Successors like the tuned lens correct for that. The crystallization story survives.

Superposition (Step 1) said concepts live as directions smeared across many neurons. Sparse autoencoders un-smear them: trained on a model’s internal activity, they recover millions of clean, mostly-monosemantic features — one for the Golden Gate Bridge, one for code bugs, one for insincere flattery. In 2024, Anthropic pulled 34 million of them out of Claude 3 Sonnet.

Reading features is one thing. The jaw-dropper was writing: clamp a feature’s activation to a high value during generation, and the concept invades the model’s behavior. Crank “Golden Gate Bridge” and Claude didn’t just mention bridges more — it identified as the bridge, working its orange towers into any answer. Suppress a feature and the concept recedes.

Slide the dial in the panel to feel the dose-response: suppressed → normal → topical obsession → full identity takeover. (The outputs are our written imitations of the published behavior, clearly labeled — no model is being steered in your browser. The load a real feature dashboard button pulls in a live Neuronpedia page for an actual GPT-2 feature, evidence these features exist outside of papers.)

Why this matters more than the party trick:

• It’s causal proof. Correlation (“this feature fires near bridge text”) could be coincidence. Turning the knob and changing the behavior shows the feature genuinely implements the concept.
• It’s a safety handle. Among those millions of features are ones for deception, sycophancy, dangerous knowledge, even “AI assistants talking about themselves.” Dialing such features up in testing — or down in deployment — is a research path toward steering what models are, not just what they say.
• It’s editing without retraining. No gradient descent, no new data — just a vector added at inference time.

The knobs gradient descent built, we’re finally learning to label — and turn.