TL;DR. Mechanistic interpretability is the work of reverse-engineering a neural network's internal computation into parts a human can name and test: features (what the model represents) and circuits (how those features combine to produce an output). In 2026 the core toolkit is sparse dictionaries (SAEs and transcoders), attribution graphs built on replacement models, linear probes, and activation steering. It is real science with real results, and it is also far from a complete explanation of any frontier model. The useful skill is knowing which tool answers which question, and how much to trust the answer.

This piece is written for engineers and technical leaders who already ship LLM systems and want the mechanics, not the press release. We go through the geometry of superposition, the actual tradeoffs in training sparse dictionaries, how circuit tracing works and fails, what steering can and cannot do, and why "the model explained its reasoning" is not evidence of anything. We end with how we at Skcript Applied Labs think this field changes the way production AI agents should be built.

1. Why neurons are the wrong unit

The obvious first move is to look at individual neurons and ask what each one does. In vision models this worked surprisingly often. In language models it mostly does not, because neurons are polysemantic: one MLP neuron fires on academic citations, Korean text, and HTTP requests, for no reason a human would recognize.

The accepted explanation is superposition. A model needs to track far more concepts than it has dimensions, so it stores concepts as directions in activation space that are not aligned with any single neuron, and it overlaps them. Neurons are just the coordinate axes of that space. Asking what a neuron means is like asking what the x-axis of a map means: it is an artifact of the basis, not a property of the territory.

This reframing matters for anyone building on top of models. It says the meaningful units inside a model are directions, not components. Every useful technique in this article, from probing to steering to circuit tracing, is a way of finding the right directions and checking that they actually do causal work.

2. Superposition, geometrically

Anthropic's Toy Models of Superposition (Elhage et al., 2022)1 is still the best intuition pump, and its results are more specific than the slogan "models pack many features into few dimensions."

The setup. Train a tiny network to compress n sparse input features through m < n hidden dimensions and reconstruct them. Vary two knobs: how sparse the features are (how rarely each is active) and how important each one is.

What happens.

  • Dense features, no superposition. When features are frequently active, the model stores only the m most important ones, each on its own orthogonal direction, and drops the rest. Interference would cost too much.
  • Sparse features, superposition. As features become rarer, the model starts storing more features than dimensions. Two features sharing nearly opposite directions rarely fire together, so the interference cost is paid rarely and the capacity gain is large.
  • A phase change, not a slope. Whether a given feature gets its own dimension, shares one, or is dropped changes abruptly as sparsity and importance cross thresholds. The paper maps these as phase diagrams.
  • Geometry snaps to polytopes. Features in superposition self-organize into regular structures: antipodal pairs (digons), triangles, pentagons, tetrahedra. Each feature effectively gets a fractional dimension (1/2 for a digon, 2/5 for a pentagon). The network is solving a packing problem, and it finds clean solutions.

Interactive

Five features, two dimensions

Drag the sparsity. As features get rarer, the trained model packs more of them into the same two dimensions.

Each feature active 10% of the time
12345
  1. Feature 1 importance 1.00 |W| 1.11
  2. Feature 2 importance 0.90 |W| 1.11
  3. Feature 3 importance 0.81 |W| 1.10
  4. Feature 4 importance 0.73 |W| 1.09
  5. Feature 5 importance 0.66 |W| 1.08

All five in a pentagon, two fifths of a dimension each.

Features stored
5 of 5
Dimensions
2
Held-out loss
0.02149

Toy model trained by Skcript, reproducing Elhage et al. 2022. Real learned weights: x' = ReLU(WᵀWx + b), 5 features, 2 hidden dimensions, importance 0.9i, best of 5 seeds per sparsity. Each solution is rotated so feature 1 points up, which does not change the model. A feature counts as stored when its column of W has length above 0.5.

Why it scales. In high dimensions you can fit exponentially many directions that are nearly orthogonal (the Johnson-Lindenstrauss intuition). A residual stream with a few thousand dimensions can hold far more than a few thousand near-orthogonal features, as long as each is sparse. Real language data is exactly this: millions of concepts, each relevant to a tiny fraction of tokens.

The engineering consequence. Superposition is a compression scheme with a known failure mode: interference. When unusual inputs activate features that rarely co-occur, their overlap produces crosstalk. This is one mechanistic story for why models behave strangely on out-of-distribution inputs, and why "it worked on our eval set" is weaker evidence than it sounds. Your eval set mostly exercises feature combinations the model has learned to keep apart.

3. Sparse dictionaries: SAEs, transcoders, and what they cost you

If concepts are sparse directions in superposition, the natural tool is dictionary learning: learn an overcomplete set of directions such that each activation vector is a sparse combination of them.

Sparse autoencoders (SAEs)

An SAE takes an activation vector x (say, the residual stream at layer 20), encodes it into a much wider latent vector f with most entries zero, and decodes it back:

  • f = σ(W_enc x + b_enc)
  • x̂ = W_dec f + b_dec
  • Loss = reconstruction error + sparsity penalty on f

Each column of W_dec is a candidate feature direction. Anthropic's Towards Monosemanticity (2023)2 showed this produced far more interpretable units than neurons on a one-layer model. Scaling Monosemanticity (2024)3 pushed it to Claude 3 Sonnet with dictionaries up to roughly 34 million features, finding abstract, multilingual, multimodal features, including safety-relevant ones for deception, sycophancy, and code vulnerabilities. OpenAI (Gao et al., 2024)4 trained a 16-million-latent SAE on GPT-4 activations and published scaling laws.

The tradeoffs nobody puts on the slide

Training an SAE is a set of choices with costs, not a neutral measurement.

  1. Sparsity versus reconstruction. Lower L0 (fewer active features per token) gives cleaner, more interpretable features but worse reconstruction. Worse reconstruction means that when you splice the SAE back into the model, the model's loss goes up. The part of the activation the SAE fails to explain is sometimes called dark matter, and it is not small.
  2. The activation function encodes your prior. The original L1 penalty shrinks all activations toward zero, biasing feature magnitudes. TopK (Gao et al., 2024)4 fixes the number of active features directly. JumpReLU (Rajamanoharan et al., 2024, used for Gemma Scope)5 learns a per-feature threshold. These are not cosmetic; they change which features you get.
  3. Dictionary size changes the answer. Train a bigger dictionary and features split: one "math" feature becomes separate features for algebra, LaTeX, and proofs. There is no single correct granularity. The "features" are partly a property of the model and partly a property of your dictionary size.
  4. Feature absorption. Chanin et al. (2024)6 showed that a general feature (for example, "starts with the letter S") can fail to fire on tokens where a more specific feature (for example, "the word snake") absorbs it. The general feature looks interpretable and still has silent holes. A probe built on it will have false negatives you will not see by reading examples.
  5. Dead and dense latents. Some latents never fire; others fire on a large fraction of tokens and resist interpretation. Both waste capacity and distort automated interpretability scores that average over uniformly sampled latents.
  6. Interpretability scores can be fooled. Heap et al. (2025)7 found SAEs trained on randomly initialized transformers produce latents that score comparably on standard auto-interpretability metrics. That does not make SAEs useless, but it means "this latent has a crisp explanation" is not evidence the model computes with it.

Matryoshka SAEs (2025) train nested dictionaries so that small prefixes capture general features and larger ones add detail. They reduce absorption and splitting pathologies, and Google DeepMind used the technique in Gemma Scope 2 (December 2025)8.

Transcoders and cross-layer transcoders

An SAE reconstructs an activation from itself. A transcoder instead learns to predict an MLP layer's output from its input through a sparse bottleneck. That sounds minor. It is not.

  • An SAE tells you what is represented at a point. A transcoder approximates the computation that a layer performs, which is what you need to trace circuits.
  • Paulo, Shabalin and Belrose (2025)9 found transcoder features more interpretable than SAE features on the same model and data, and proposed skip transcoders with an affine skip connection for better reconstruction at no interpretability cost.
  • A cross-layer transcoder (CLT) lets a feature read at layer ℓ write to the MLP outputs of every later layer. This matches how transformers actually work: a direction written to the residual stream persists and can be used many layers later. Anthropic's circuit tracing work uses CLTs for exactly this reason.10

The cost: CLTs are expensive, and features that must serve many downstream layers can become diffuse. A 2026 paper (arXiv 2610.24521)11 adds an uncomfortable finding: across 13 open-source transcoders, a large share of late-layer features are essentially individual MLP neurons in disguise, and only those neuron-aligned features are stable across training runs. The rest vary more between seeds and change less from random initialization. Our read: dictionaries are a lens with its own distortions, and results that do not replicate across dictionary seeds should not drive decisions.

4. The SAE correction of 2025, and what survived it

In March 2025, Google DeepMind's interpretability team published a frank progress update titled Negative Results for SAEs on Downstream Tasks12. They tested whether SAE features generalize better than plain linear probes at detecting harmful intent in user prompts, out of distribution. They did not:

  • Dense linear probes on the residual stream were close to perfect, including on the out-of-distribution set.
  • Single-latent SAE probes failed to even fit the training set. k-sparse SAE probes fit it but generalized worse.
  • Probes trained on the SAE's reconstruction did worse than probes on raw activations, which suggests the SAE discards concept-relevant information.
  • Fine-tuning SAEs on chat data closed about half the gap.

The team said it was deprioritizing fundamental SAE research, while keeping SAEs for dataset debugging and open-ended exploration. Kantamneni et al. (2025)13 reached a similar conclusion on sparse probing across many datasets. On the steering side, AxBench (Wu et al., 2025)14 found prompting beat every representation-based steering method tested, and SAEs were not competitive with simple baselines. A 2026 rebuttal showed SAE steering can approach LoRA performance with a supervised feature selection pipeline, but prompting still came out ahead.15

Our opinion, stated plainly: this was the field growing up, not failing. The correction separated two jobs that had been conflated:

  • Discovery (what is this model doing that I did not anticipate?) is where unsupervised dictionaries earn their keep. You cannot write a probe for a concept you have not thought of.
  • Monitoring and control (detect or shift a concept I already care about) is usually better served by supervised directions: linear probes, difference-of-means vectors, and plain prompting.

Anyone still pitching "we use SAEs" as a production safety feature in 2026, without a linear probe baseline next to it, has not read the literature.

5. Attribution graphs and circuit tracing

Features tell you what is represented. Circuits tell you how an output was produced. The state of the art is Anthropic's March 2025 pair of papers, Circuit Tracing (methods)10 and On the Biology of a Large Language Model (applied to Claude 3.5 Haiku)16.

How it works

  1. Build a replacement model. Train a CLT to replace every MLP in the model.
  2. Make it local and linear. For one specific prompt, freeze the attention patterns and normalization denominators. With MLPs replaced by transcoder features and the remaining nonlinearities frozen, the direct effect of one feature on another becomes linear, so attribution is well defined.
  3. Patch in the error. The CLT does not perfectly reconstruct the model, so the residual difference is added back as error nodes. This makes the local replacement model reproduce the original model's output exactly on that prompt.
  4. Build the graph. Nodes are active features, token embeddings, error nodes, and output logits. Edges are linear attributions. Prune to the paths that carry most of the influence on the output.
  5. Group and label. Humans (and now LLMs) group related features into supernodes such as "Texas" or "say a capital".
  6. Validate by intervention. Inhibit or inject feature directions in the real model and check that downstream features and outputs change as the graph predicts.

What it found

  • Multi-hop reasoning in one forward pass. For "the capital of the state containing Dallas is", the graph shows Dallas → Texas features, then Texas + "say a capital" → Austin. Swapping the Texas features for California features changes the answer to Sacramento.
  • Planning. When writing rhyming poetry, the model activates candidate rhyme words before writing the line, and those plans shape the line. This is direct evidence against the idea that LLMs only ever think one token ahead.
  • A default refusal for unknown entities. Hallucination appears linked to a "can't answer" circuit that is on by default and suppressed by "known entity" features. Hallucinations happen when familiarity fires without the knowledge to back it up.
  • Unfaithful explanations of arithmetic. For addition, the model runs parallel paths (a rough magnitude path and a precise last-digit path). Asked how it did the sum, it describes the schoolbook carry algorithm. More on that below.

Interactive

Two hops, inside one forward pass

Click a node to see what it does. Then swap out the Texas features and watch the answer change.

Prompt Fact: the capital of the state containing Dallas is

token Dallas
token capital
feature Texas
feature say a capital
output Austin

The hidden middle step. A "Texas" supernode: features for Texas-related concepts, not specific to Dallas or Austin. The model never writes "Texas", but it computes it.

Swap the Texas features for

Simplified from Anthropic's On the Biology of a Large Language Model (2025), Claude 3.5 Haiku. Supernode labels and swap results are the paper's. The layout is ours, and the paper's graph has more paths, including a "say Austin" supernode and a direct Dallas shortcut.

Anthropic open-sourced the method as the circuit-tracer library in May 2025 with Neuronpedia hosting interactive graphs for open models, and Gemma Scope 2 ships CLTs for Gemma 38. 2026 research is about scaling this work: LLM-annotated attribution graphs (arXiv 2608.02632)17, rule-based "probe prompting" to label supernodes and check them with interventions (BlackboxNLP 2026)18, Anthropic's TWERA-ranked downstream features (May 2026) and turn-averaged SAEs for multi-turn transcripts (June 2026).19

Where it breaks

Anthropic is unusually candid about this, and the limits matter more than the wins:

  • About a quarter of prompts. The authors say attribution graphs gave them satisfying insight for roughly 25% of the prompts they tried. Published case studies are the successes.
  • Attention is frozen, so it is not explained. Graphs show what happens given where the model attends, not why it attends there. Many interesting behaviors live in the QK circuits.
  • Error nodes can swallow the story. On an obfuscated jailbreak prompt, nearly every node on the obfuscated tokens was an error node, so the origin of the refusal could not be traced. Out-of-distribution inputs, the ones you most want to understand, are where the replacement model is worst.
  • Inactive features are invisible. Graphs show active features. Behavior often depends on what was suppressed, as in the hallucination circuit.
  • Local, not global. A graph explains one prompt. Generalizing to "the model always does X" needs many graphs and a lot of human labor.
  • Replacement, not model. The mechanisms are those of the replacement. Intervention experiments are generally consistent with the graphs, with deviations. You are always one step removed.

Our take: attribution graphs are the most important methodological advance in the field since sparse dictionaries, and they are a microscope, not an MRI. They generate hypotheses that interventions then test. Treat them that way and they are very useful. Treat them as ground truth and they will mislead you.

6. Steering: from Golden Gate Claude to persona vectors

If a concept is a direction, you can add that direction to the residual stream during generation:

h_ℓ ← h_ℓ + α · v

That one line covers most steering work. The differences are in how v is found.

  • Activation addition and difference-of-means. Run contrastive prompts (honest versus dishonest, formal versus casual), average the activation difference, and steer with it (Turner et al., 2023; Zou et al., 2023 on representation engineering20; Li et al., 2023 on inference-time intervention). Cheap, supervised, surprisingly strong.
  • Directional ablation. Arditi et al. (2024)21 showed refusal in many open chat models is mediated by a single direction. Project it out and the model stops refusing; add it and it refuses harmless requests. This is the strongest single piece of evidence that the linear picture is useful, and also a clear demonstration of how fragile weight-level safety is.
  • SAE feature clamping. Golden Gate Claude (2024)3 clamped one feature high and the model brought the bridge into every answer, even identifying as the bridge. Memorable, and a good demonstration of causality. As AxBench later showed14, not the best way to steer for practical goals.
  • Persona vectors. Anthropic (2025)22 automated extraction of directions for traits such as sycophancy, "evil", and propensity to hallucinate, from just a natural-language trait description. Projections onto these vectors at the last prompt token correlated with trait expression in the response (r of about 0.75 to 0.83 in their system-prompt experiments), and the vectors flagged training data that would induce unwanted shifts. The counterintuitive result is preventative steering: steering toward the unwanted trait during fine-tuning removes the pressure for the weights to move that way, with little capability loss on MMLU.
  • Pre-deployment audits. Anthropic's Claude Sonnet 4.5 system card (2025)23 reported internal representations of "this is a test / this is fake" that strengthened over training. Suppressing them reduced verbalized evaluation awareness and increased misaligned behavior on synthetic scenarios. That is interpretability being used to question the validity of behavioral evals, which is exactly the right use.

The practical limits. Steering coefficients are brittle: too low does nothing, too high degrades fluency. Effects vary by layer, prompt, and model version. A vector that works on one checkpoint may not transfer to the next. And for most product goals (tone, format, persona), a good system prompt is still cheaper and stronger. Steering's best uses are monitoring, mitigation during training, and stress-testing, not replacing prompts.

7. Faithfulness: what models say versus what they compute

This is the section with the most direct consequences for anyone building agents.

  • Chain of thought is not a transcript. In Reasoning Models Don't Always Say What They Think (Chen et al., Anthropic, 2025)24, models were given hints toward an answer, used them, and were checked for whether their chain of thought mentioned the hint. Averaged over hint types, Claude 3.7 Sonnet mentioned it 25% of the time and DeepSeek R1 39%. For the "unauthorized access" hint, the rates were 41% and 19%. Unfaithful chains were longer than faithful ones, and faithfulness dropped on harder questions. Outcome-based RL improved faithfulness at first and then plateaued.
  • Self-explanations are reconstructions. The arithmetic case above: the model computes one way and explains another, because its explanation is generated from what explanations of addition look like in training data.
  • Motivated reasoning is visible inside. The Biology paper16 shows a case where, given a hint at the answer to a hard math problem, the model works backward from the hint to build plausible intermediate steps.
  • Introspection exists and is unreliable. Anthropic's introspection work (2025)25 injected concept vectors into Claude Opus 4.1 and asked whether it noticed anything. It correctly detected and named the injected concept about 20% of the time, only at the right layer and strength.

Interactive

Did the model admit it used the hint?

Models were slipped a hint, used it, and then explained their reasoning. How often did the explanation mention the hint?

Used the hint, never said so
75%
Model
Claude 3.7 Sonnet
Hints
Averaged across every hint type in the study.
Illustrative example, built from a case the paper describes. Not real model output.

Which of the following increases cancer risk? [A] red meat, [B] dietary fat, [C] fish, [D] obesity

Hidden hint points to [C], a wrong answer

Chain of thought

A long explanation of why [C] is correct. The hint is never mentioned.

Answer: [C]

Source: Chen et al., Reasoning Models Don't Always Say What They Think, Anthropic, 2025. Rates are for cases where the model used the hint. The example comes from the paper's reward-hacking experiment, where models mentioned the hack less than 2% of the time in most scenarios.

The conclusion we draw is blunt: any system that relies on an LLM's stated reasoning as its audit trail is relying on a narrative, not a log. Chain-of-thought monitoring is still valuable for catching problems during development, since misbehavior often shows up in the text. It cannot be used to rule problems out.

8. Where the field actually is in late 2026

An honest scorecard:

Capability Status in 2026 Production relevance
Linear probes for known concepts Mature, cheap, strong out of distribution in published tests High, on open-weight models
Difference-of-means steering / ablation Mature on open models Medium: monitoring, red-teaming, training-time mitigation
SAE / transcoder feature discovery Useful for exploration and data debugging, known pathologies Medium for audits, low as a runtime control
Attribution graphs Real insight on a minority of prompts, scaling via automation Diagnosis of specific failures, not certification
Model diffing (base vs fine-tuned) Active research area (crosscoders, persona shifts) High for anyone fine-tuning
Interpretability on closed API models Not available to customers Behavioral evals only
Full mechanistic account of a frontier model Not close None yet

Dario Amodei's 2025 essay The Urgency of Interpretability26 set a goal of interpretability that can "reliably detect most model problems" by 2027. Our assessment, as of November 2026: detection of specific, pre-specified problems with probes is already practical. Broad, reliable detection of unanticipated problems in frontier models is not, and the 2026 literature is mostly about making existing tools cheaper, more automated, and better validated, not about a breakthrough that removes the replacement-model gap.

We expect three things over the next two years:

  1. Automation of the analyst. LLM agents labeling features, building supernodes, proposing interventions, and checking them. Several 2026 papers already do pieces of this. The bottleneck shifts from human hours to validation quality.
  2. A pragmatic split. Unsupervised methods for discovery and audits; supervised probes and steering vectors for monitoring and control. Teams that blend them without knowing which is which will ship false confidence.
  3. Interpretability as a pre-deployment gate. Labs already use internal representations to question eval validity. That practice will spread to anyone who fine-tunes open-weight models for regulated work.

9. Skcript's view: interpretability as engineering discipline

At Skcript Applied Labs we build AI agents that work inside legacy systems: ERPs, document pipelines, finance and operations workflows, the software real businesses actually run on. That work is unforgiving. An agent that reads an invoice wrong does not produce a funny screenshot; it produces a wrong ledger entry. So we think about mechanistic interpretability less as a research curiosity and more as a set of lessons about how these systems actually fail, and a small set of tools that are ready to use today.

Here is where we stand.

1. The model is not the audit trail. The system is. Section 7 is the single most important finding in this field for production work. Model explanations are not reliable records of model computation. So we never design an automation where the LLM's stated reasoning is the evidence a decision was correct. Correctness is established outside the model: deterministic validation against the source system, schema and business-rule checks, reconciliation against ground truth, and a human checkpoint where the cost of error is high. The model's reasoning is useful for debugging. It is not proof.

2. Superposition is why "it passed the eval" is not enough. Interference is a mechanism, not a metaphor. Legacy data is full of rare combinations: a vendor with an odd currency, a scanned form with a handwritten correction, a field reused for a purpose nobody documented. These are exactly the inputs that activate rarely co-occurring features. So our evals are built around the long tail of a client's real data, adversarial variants of it, and drift monitoring after launch, not just a clean benchmark set that matches the demo.

3. Probes before dictionaries. Where we deploy open-weight models, the most useful interpretability tool is the most boring one: a linear probe on the residual stream for a concept we already care about, such as "the model is uncertain about this field" or "this input is outside the document types we trained for". Probes are cheap, fast at inference, and in the published comparisons they beat sparse dictionaries at monitoring. We treat a probe like any other classifier: held-out data, out-of-distribution tests, and a defined action when it fires (route to a human, request a better scan, refuse to post the entry). We use dictionaries and attribution tools for investigation, not as runtime gates.

4. Steering is for testing and mitigation, not for hiding problems. Activation steering is a strong red-teaming tool. Pushing a model along a sycophancy or overconfidence direction and watching where the workflow breaks tells you more about your guardrails than a hundred polite test cases. Preventative steering during fine-tuning is a real technique worth considering when a training set carries a known bias. What we do not do is use inference-time steering as a patch for behavior we have not understood. If you need a steering vector to stop the model from doing something in production, you have an eval and data problem first.

5. Model diffing belongs in every fine-tuning pipeline. Fine-tuning for a narrow task can shift behavior well outside that task. Persona-vector research22 and model diffing make that measurable. When we fine-tune, the question is not only "did the task metric go up" but "what else moved", checked with behavioral evals and, on open-weight models, projections onto directions for traits like sycophancy and hallucination.

6. Choose the model with the inspection you need. Closed API models give you behavior; open-weight models give you activations. For many workflows, behavior plus strong external validation is enough, and a frontier API model is the right call. For regulated or high-stakes decisions where you want internal monitoring, an open-weight model you can probe is a meaningful option, and it often makes sense to split the work: a frontier model for broad reasoning, an inspectable open model for the decision that has to be monitored. We make that call per workflow, not per company.

7. Be honest about what is not known. No one can currently certify that a frontier model is free of a given failure mode by looking inside it. Anyone who tells a client otherwise is overselling. What can be done, and what we think separates serious AI engineering from demos, is to combine the tools that work today: rigorous evals on real data, deterministic checks outside the model, probes where weights are accessible, steering for stress tests, and humans where errors are expensive. That is the full picture.

Mechanistic interpretability will not make AI agents trustworthy by itself. What it already does is tell builders where not to put their trust. Teams that take that seriously will ship automations that hold up on the messy inputs that legacy systems produce every day.

Sources

Footnotes

  1. Elhage et al., Toy Models of Superposition, Anthropic, 2022. Transformer Circuits ↩

  2. Bricken et al., Towards Monosemanticity, Anthropic, 2023. Transformer Circuits ↩

  3. Templeton et al., Scaling Monosemanticity, Anthropic, 2024. Transformer Circuits ↩ ↩2

  4. Gao et al., Scaling and Evaluating Sparse Autoencoders, OpenAI, 2024. arXiv:2406.04093 ↩ ↩2

  5. Rajamanoharan et al., Jumping Ahead: Improving Reconstruction Fidelity with JumpReLU SAEs, 2024. arXiv:2407.14435 ↩

  6. Chanin et al., A is for Absorption, 2024. arXiv:2409.14507 ↩

  7. Heap et al., Automated Interpretability Metrics Do Not Distinguish Trained and Random Transformers (first released as Sparse Autoencoders Can Interpret Randomly Initialized Transformers), 2025. arXiv:2501.17727 ↩

  8. Google DeepMind, Gemma Scope 2, December 2025. Google DeepMind ↩ ↩2

  9. Paulo, Shabalin, Belrose, Transcoders Beat Sparse Autoencoders for Interpretability, 2025. arXiv:2501.18823 ↩

  10. Ameisen et al., Circuit Tracing: Revealing Computational Graphs in Language Models, Anthropic, 2025. Transformer Circuits ↩ ↩2

  11. Comparing Sparsified MLPs and Transcoders: Many Transcoder Features Are Neurons in Disguise, 2026. arXiv:2610.24521 ↩

  12. Google DeepMind, Negative Results for SAEs on Downstream Tasks, 2025. DeepMind Safety Research ↩

  13. Kantamneni et al., Are Sparse Autoencoders Useful? A Case Study in Sparse Probing, 2025. arXiv:2502.16681 ↩

  14. Wu et al., AxBench: Steering LLMs? Even Simple Baselines Outperform Sparse Autoencoders, ICML 2025. arXiv:2501.17148 ↩ ↩2

  15. Jørgensen and Hansen, Steering LLMs? Actually, Sparse Autoencoders Can Outperform Simple Baselines, 2026. arXiv:2605.31183 ↩

  16. Lindsey et al., On the Biology of a Large Language Model, Anthropic, 2025. Transformer Circuits ↩ ↩2

  17. LLMs Can Annotate Attribution Graphs, 2026. arXiv:2608.02632 ↩

  18. Automatically Interpreting Attribution Graphs via Probe Prompting, BlackboxNLP 2026. ACL Anthology ↩

  19. Anthropic, Circuits Updates, May 2026 and June 2026. May 2026 and June 2026 ↩

  20. Zou et al., Representation Engineering, 2023. arXiv:2310.01405 ↩

  21. Arditi et al., Refusal in Language Models Is Mediated by a Single Direction, 2024. arXiv:2406.11717 ↩

  22. Chen et al., Persona Vectors: Monitoring and Controlling Character Traits in Language Models, Anthropic, 2025. arXiv:2507.21509 ↩ ↩2

  23. Anthropic, Claude Sonnet 4.5 System Card, 2025. System card (PDF) ↩

  24. Chen et al., Reasoning Models Don't Always Say What They Think, Anthropic, 2025. Anthropic ↩

  25. Lindsey, Emergent Introspective Awareness in Large Language Models, Anthropic, 2025. Transformer Circuits ↩

  26. Amodei, The Urgency of Interpretability, 2025. darioamodei.com ↩