Concept circuits,
explained.

The first thing you learn probing a real network is that individual neurons are polysemantic — a single unit lights up for a jumble of unrelated concepts. It's tempting to read that as the model being messy. It isn't. The model simply isn't storing "one concept per neuron." It's storing concepts as directions in the activation space, and those directions are spread across many neurons at once.

So a neuron isn't a concept — it's one coordinate that many concept-directions happen to use. Ask "what does neuron 4,182 mean?" and you get nonsense; ask "which directions does the model use, and what does each mean?" and you get features. The reason there are more features than neurons is the mechanism worth understanding.

A space with d dimensions holds only d perfectly orthogonal directions. But it holds vastly more directions that are almost orthogonal — and "almost" is good enough. Superposition is the model exploiting this: give each feature its own direction, let those directions be near-orthogonal, and accept a little interference between them.

Three unit vectors in 2-D can't be orthogonal, but at 120° apart their pairwise dot is only −0.5 — bounded interference, and three features in a two-dimensional home.

If superposed features interfere, why doesn't the model turn to mush? Because features are sparse — only a handful are active on any given input. "This text is legal," "this token is a date," "the topic is grief" don't all fire at once. When just one feature is active, reading it back is clean; the interference terms are dormant because the features they'd collide with aren't switched on.

So superposition is a bet on sparsity: pack in many features cheaply, and rely on the fact that they rarely co-activate, so the rare collisions cost little. That's exactly why embedding-style geometry can carry so much meaning in modest dimensions — and why sparse-feature methods (sparse autoencoders) can pull the individual features back out of the tangle.

Once you can name features, you can ask the real question: which features produced this output, and how? An attribution graph measures each feature's contribution to a target — how strongly the output direction reads each active feature direction — and chains those contributions across layers into a circuit: the path of intermediate features the model actually used.

That's the leap from "the model answered Austin" to "it answered Austin because the Texas feature activated the state-capital feature, which drove the Austin output." Recent work adds a self-explanation twist — the model translating its own internal features into natural language — but the backbone is the same: attribution turns a forward pass into a readable causal graph. The runnable below builds the simplest version: contribution as the dot product between a feature and the output direction.

Mechanistic interpretability is what turns a model from a black box into something you can debug. If you can name a model's features and trace the circuit behind a behaviour, you can find why it hallucinates, spot the feature a jailbreak exploits, or catch it leaning on a spurious cue — and sometimes steer it by editing the feature directly. That's a different kind of control than prompting: surgery, not persuasion.

Superposition is the reason it's hard (features hide across neurons) and the reason it's possible (they're still linear directions you can recover). This breakdown is the foundation; the engineering playbook — what you can actually inspect and fix in production — is the natural next step, and it's the same geometry-of-meaning idea that word2vec first made visible.