Sparse Autoencoders (SAEs)

Definition: A sparse autoencoder (SAE) is a small neural network trained to rewrite a language model's internal activations as a long list of features, of which only a few are on at any moment. Researchers use SAEs to turn the tangled numbers inside a model into features a person can name, such as one landmark or computer code.

TL;DR: A sparse autoencoder is a translator for a model's latent space. In 2024, Anthropic trained one with about 34 million features on Claude 3 Sonnet and found a feature for the Golden Gate Bridge. In 2025, Google DeepMind's team reported that SAEs lost to simple linear probes on a safety task. See mechanistic interpretability for the wider field.

Think of a choir recorded on one microphone. The recording is a single wave, and every singer's voice is mixed into it. You cannot point at a moment of the wave and say "that is the alto". A sparse autoencoder is like software that splits the recording back into separate tracks, one per voice, where at any moment only a few singers are singing. Once the voices are separate, you can name them.

Why Sparse Autoencoders Matter in 2026

Sparse autoencoders matter because they are the main tool researchers use to read what is inside a large language model, and in 2026 that tool is under real scrutiny. Between 2023 and 2024, three labs showed that SAEs scale to frontier models. Anthropic's Mapping the Mind of a Large Language Model (May 21, 2024) reported millions of features from the middle layer of Claude 3 Sonnet. OpenAI's Leo Gao and colleagues trained a 16 million latent autoencoder on GPT-4 activations for 40 billion tokens (June 2024). Google DeepMind released Gemma Scope (August 2024), open SAEs for its open-weight Gemma models, covering every layer of the Gemma 2 2B and 9B models.

Then the negative results arrived. On March 26, 2025, Google DeepMind's interpretability team, including Lewis Smith, Senthooran Rajamanoharan, Arthur Conmy, and Neel Nanda, published Negative Results for SAEs On Downstream Tasks and Deprioritising SAE Research. On a task that detects harmful intent in user prompts, SAE-based probes did worse than plain linear probes, which the team called "really good and cheap". The team said it would deprioritize basic SAE research, while stating that SAEs are not useless and will stay in its toolkit.

In February 2026, Anton Korznikov and colleagues ran Sanity Checks for Sparse Autoencoders. On a synthetic setup with known true features, SAEs recovered only 9% of them while explaining 71% of the variance. So in 2026 the honest picture is mixed. SAEs produce real, nameable features, and they are a useful microscope. They do not yet give a complete or reliable map of what a model knows.

The Problem SAEs Solve: Superposition

A neural network has more concepts to store than it has neurons. Nelson Elhage, Tristan Hume, Catherine Olsson, Nicholas Schiefer, and colleagues studied this in Toy Models of Superposition (September 2022). Their finding: networks often pack many unrelated concepts into a single neuron, a property called polysemanticity. The cause is superposition, where the model stores extra sparse features as overlapping directions instead of giving each its own neuron. The superposition article covers the idea in more depth.

Superposition is efficient for the model and painful for anyone trying to read it. Look at one neuron and you see it fire for a mix of things that have nothing in common. A sparse autoencoder tries to undo the packing. It learns a dictionary of many more directions than there are neurons, and it rewrites each activation as a combination of only a few of them.

How a Sparse Autoencoder Works

A sparse autoencoder is an autoencoder, the encoder and decoder pair described in latent space, with two twists. First, its hidden layer is much wider than its input, not narrower. Second, a sparsity penalty pushes most of that hidden layer to zero for any given input. The network is trained to rebuild the activation it was given, so it must explain each activation with a small number of active features from a very large dictionary.

1. Collect activations. Run the language model on a large amount of text and record the hidden state at one layer for each token. Anthropic used the residual stream halfway through Claude 3 Sonnet, the running sum that each transformer layer reads and writes, because it reasoned the middle layer holds abstract features.
2. Train the SAE. The SAE learns to encode each activation into its wide feature layer and decode it back. The loss rewards an accurate rebuild and punishes every active feature.
3. Name the features. For each feature, researchers look at the texts that turn it on most strongly. A feature that fires on mentions of the Golden Gate Bridge in many languages, and on photos of it, gets that name.
4. Test the features. Turning a feature up or down and watching the output change shows whether the model uses it. This is where SAEs meet steering vectors.

The numbers from Anthropic's Scaling Monosemanticity report show the scale. The team trained three SAEs with about 1 million, 4 million, and 34 million features. On average, fewer than 300 features were active on any one token, and each SAE explained at least 65% of the variance in the model's activations.

One token, before and after a sparse autoencoder

  Activation (dense)   [ 0.12 -0.87  0.33  0.05 -0.41 ...  every slot has a value ]

  SAE features         [ 0  0  0  0  2.4  0  0  0  ...  0  0  1.1  0  0  ...  0 ]
  (34 million slots)                  ^                       ^
                          "Golden Gate Bridge"       "tourist landmark"
                     fewer than 300 slots are non-zero, the rest are exactly 0

Ways to Enforce Sparsity

Every sparse autoencoder minimizes the same two-part loss: the reconstruction error plus a weight, often written lambda, times a sparsity penalty. What differs between designs is how that penalty works. Older SAEs used an L1 penalty or a KL divergence target, and the large 2024 interpretability SAEs moved to TopK and JumpReLU activations that set sparsity more directly.

loss = reconstruction error            how far the rebuilt activation is from the original
     + lambda x sparsity penalty       how many features were switched on, and how strongly

lambda small  -> accurate rebuild, many active features, hard to read
lambda large  -> few active features, easy to read, worse rebuild

OpenAI's Leo Gao and colleagues chose k-sparse autoencoders because setting sparsity directly makes tuning simpler and improves the trade-off between reconstruction and sparsity. They also reported few dead latents even at their largest scale. Wikipedia's Autoencoder article notes that the whole idea was inspired by the sparse coding hypothesis in neuroscience, and that encouraging sparsity improves performance on classification tasks.

Where Sparse Autoencoders Are Used

Sparse autoencoders are used in two different worlds. In classic machine learning they learn compact features for classification, anomaly detection, and image denoising. Since 2023 their best-known use is interpretability, where they translate a large model's activations into named features. The two uses share a loss function but answer different questions.

The rest of this article covers the interpretability use, because that is where the 2024 to 2026 results and arguments live.

What Sparse Autoencoders Found

Sparse autoencoders found readable features inside production models, not only toy ones. In 2024, Anthropic's SAEs on Claude 3 Sonnet surfaced multilingual and multimodal features, including one for the Golden Gate Bridge and others tied to scams, sycophancy, and manipulation. The path to that result started a year earlier with a one-layer toy model.

The early proof came from a toy model. In Towards Monosemanticity (October 4, 2023), Trenton Bricken, Adly Templeton, Joshua Batson, and colleagues trained SAEs on a one-layer transformer with a 512-neuron MLP layer, using 8 billion data points. Their dictionaries ranged from 512 to 131,072 features, and the detailed analysis focused on one run with 4,096 features. They also described feature splitting: a feature that looks like one concept in a small dictionary splits into several finer concepts in a larger one. At almost the same time, Hoagy Cunningham, Aidan Ewart, Logan Riggs, Robert Huben, and Lee Sharkey reported in Sparse Autoencoders Find Highly Interpretable Features in Language Models (September 2023) that SAE features are more interpretable than directions found by other methods.

The headline came in May 2024. Anthropic's SAEs on Claude 3 Sonnet found features that were multilingual and multimodal. The Golden Gate Bridge feature fired on the bridge's name in English and other languages and on an image of it. When researchers amplified it, the model claimed to be the bridge when asked about its physical form, a demo Anthropic put online for 24 hours as Golden Gate Claude on May 23, 2024. The team also found safety-relevant features:

Anthropic also stated the limits plainly. The features found are a small subset of what the model learned, and finding a feature does not show how the model uses it.

SAEs vs Probing vs Steering

Linear probes, sparse autoencoders, and steering vectors all work on a model's hidden states, but they answer different questions. A probe checks whether one known concept is present. An SAE lists every feature a layer uses, without labels. A steering vector tests what happens when you push the model along one direction. Pick the tool by the question you have.

The Google DeepMind result fits this table. When you already know the question, such as "is this prompt harmful", a probe trained for that question beats a general dictionary. An SAE earns its cost when you do not know what to look for. The DeepMind post noted that SAEs were fairly helpful for debugging low-quality datasets, where you want to find patterns you did not expect.

Limits and Open Problems

Sparse autoencoders have six open problems in 2026: they recover only part of a model's features, many dictionary slots go dead, concepts split differently at each dictionary size, they describe a layer instead of its computation, they cost a lot to train, and simple probes still beat them on several practical tasks.

• Incomplete. The 2026 sanity-check paper found SAEs recover 9% of known features in a synthetic test while explaining 71% of the variance. A good reconstruction score does not mean the features are the true ones.
• Dead features. Some dictionary slots never turn on. In Scaling Monosemanticity, about 2% of features were dead in the 1 million SAE, 35% in the 4 million SAE, and 65% in the 34 million SAE. OpenAI's k-sparse method reported few dead latents even at its largest scale.
• Split features. The same concept can show up as one feature or many, depending on dictionary size. Counting features does not count concepts.
• Wrong target. An SAE describes one layer's activations, not what the layer computes. Gonçalo Paulo, Stepan Shabalin, and Nora Belrose reported in Transcoders Beat Sparse Autoencoders for Interpretability (January 2025) that transcoders, which predict a component's output from its input, give more interpretable features.
• Cost. Training a 34 million feature SAE on a frontier model takes large compute, and each new model needs new SAEs.
• Downstream value. As of 2026, simple probes still beat SAEs on several practical safety tasks. At ICML 2025, Subhash Kantamneni, Josh Engels, Senthooran Rajamanoharan, Max Tegmark, and Neel Nanda asked Are Sparse Autoencoders Useful? and found that SAEs did not consistently improve on simple baselines for probing under scarce data, class imbalance, label noise, and distribution shift. Careful evals of downstream use are still rare.

How Sparse Autoencoders Show Up in Taskade

Sparse autoencoders do not show up inside Taskade. Taskade agents run on frontier models from top AI labs, and Taskade does not expose those models' internals, so there are no activations or SAE features to inspect. The labs run interpretability research on their own models. In Taskade you check an agent the way you check any worker: by its answers and their sources.

The practical version of interpretability is an output audit. An AI agent answers incoming questions, and an automation copies each question and answer into an audit project with a status column. Once a week a reviewer samples rows, marks wrong answers, and adds the correct source to the agent's knowledge, so the audit project becomes the record of how well the agent does. Taskade Genesis builds that app from one prompt, and Taskade EVE edits it in chat. To start from a working example, clone the Research Chat Bot kit, an app kit with projects, an AI agent, and automations you can clone.

Describe yours and build it free →

Related Concepts

• Mechanistic Interpretability: the field that uses SAEs to explain models from their parts
• Superposition: the packing of many concepts into few neurons that SAEs try to undo
• Latent Space: the hidden space whose activations SAEs decompose
• Steering Vectors: pushing a model along a direction, often one an SAE found
• Representation Learning: how models learn the representations SAEs read
• Latent Reasoning: why reading hidden states matters more when models think without words
• Platonic Representation Hypothesis: whether different models learn features that match
• Embedding Models: the searchable vectors that sit on top of the same kind of space
• Chain-of-Thought Faithfulness: the other main way to check what a model is doing
• AI Safety and Alignment: the goal much of this research serves
• Neural Network: the neurons and layers an SAE reads
• Transformer: the architecture whose residual stream most SAEs read
• Large Language Models: the models SAEs are now trained on
• Guardrails: the outside controls deployed systems use today
• What Is Mechanistic Interpretability?: the longer guide

Frequently Asked Questions About Sparse Autoencoders

What is a sparse autoencoder in simple terms?

A sparse autoencoder is a tool that translates a model's internal numbers into a long list of features, where only a few are on at a time. Each feature tends to mean one thing, such as a place, a language, or a writing style. That lets researchers see which ideas a model is using when it reads or writes a sentence.

What is the Golden Gate Bridge feature?

It is a feature Anthropic found in May 2024 with a sparse autoencoder trained on Claude 3 Sonnet. It fired when the bridge was mentioned in many languages and when an image of it appeared. When researchers amplified the feature, the model claimed to be the Golden Gate Bridge. The demo showed that SAE features change behavior, not only describe it.

Why are sparse autoencoders called sparse?

Because only a small fraction of their features are active for any one input. In Anthropic's 2024 work, fewer than 300 of up to 34 million features were active on an average token. Sparsity is what makes the features readable. A feature that is on for everything tells you nothing, while a feature that is rarely on tends to mean something specific.

What is superposition in neural networks?

Superposition is when a neural network stores more concepts than it has neurons by spreading each concept across overlapping directions. It makes single neurons respond to unrelated things, which researchers call polysemantic. The 2022 paper Toy Models of Superposition studied the effect. Sparse autoencoders try to reverse it by finding one direction for each concept.

Do sparse autoencoders work?

Partly. They produce many features people can name, and amplifying those features changes model behavior in the expected way. But in 2025 Google DeepMind found SAE probes did worse than linear probes on a harmful-intent task, and a 2026 test found SAEs recovered only 9% of known features in a synthetic setup. They are a useful microscope, not a complete map.

What is the difference between a sparse autoencoder and a regular autoencoder?

A regular autoencoder squeezes its input through a narrow layer to learn a compact code. A sparse autoencoder does the opposite: its hidden layer is much wider than the input, and a penalty keeps most of it at zero. The regular version compresses. The sparse version spreads a tangled signal out into many separate, readable parts.

Can I use sparse autoencoders on an open model?

Yes. Google DeepMind released Gemma Scope in August 2024, a set of open JumpReLU sparse autoencoders for every layer and sub-layer of the Gemma 2 2B and 9B models, plus select layers of Gemma 2 27B, with weights on Hugging Face and an interactive demo on Neuronpedia. Neuronpedia also hosts TopK, JumpReLU, and Matryoshka SAEs, transcoders, and crosscoders from many groups, so you can explore features without training your own SAE.

What is the loss function of a sparse autoencoder?

The loss is the reconstruction error plus a weight times a sparsity penalty. The reconstruction error measures how far the rebuilt activation is from the original. The sparsity penalty is usually an L1 sum of feature activations or a KL divergence toward a small target rate. TopK and JumpReLU SAEs enforce sparsity in the activation itself instead of only through the penalty.

Further Reading

• Anthropic, Mapping the Mind of a Large Language Model, May 21, 2024
• Templeton et al., Scaling Monosemanticity, Transformer Circuits Thread, 2024
• Bricken et al., Towards Monosemanticity, October 4, 2023
• Elhage et al., Toy Models of Superposition, September 2022
• Cunningham et al., Sparse Autoencoders Find Highly Interpretable Features in Language Models, September 2023
• Gao et al., Scaling and evaluating sparse autoencoders, June 2024
• Lieberum et al., Gemma Scope, August 2024
• Smith et al., Negative Results for SAEs On Downstream Tasks, March 26, 2025
• Shu et al., A Survey on Sparse Autoencoders, March 2025
• Paulo, Shabalin, and Belrose, Transcoders Beat Sparse Autoencoders for Interpretability, January 2025
• Korznikov et al., Sanity Checks for Sparse Autoencoders, February 2026
• Kantamneni et al., Are Sparse Autoencoders Useful? A Case Study in Sparse Probing, ICML 2025
• Makhzani and Frey, k-Sparse Autoencoders, December 2013
• Wikipedia, Autoencoder: Sparse autoencoder
• Neuronpedia, Sparse autoencoders overview