We trained and released Sparse Autoencoders on all four Tiny Aya regional variants and asked what an SAE sees inside a model built for 70+ languages: a representational-density gap, a mostly-shared feature basis, and an identity-versus-quality null.
Part of Expedition Tiny Aya, with teammates Matthew Nguyen and Tra My (Chiffon) Nguyen.
Ask Tiny Aya, Cohere Labs’ purpose-built multilingual model, an open-ended question in Thai, and it will happily answer in fluent, grammatical Thai. Sometimes the answer is right; sometimes it invents the facts wholesale. Ask it about Ayutthaya, Thailand’s former royal capital, and in one of our probes it confidently described “an Indian TV actress, born 21 May 1988 in Kolkata,” complete with a fabricated Hindi series, made-up parents, and a fake alma mater — every sentence flawless, every fact invented. We wanted to know what the model’s internal representation of Thai looks like at a moment like that, and whether it looks any different from when the model gets the answer right.
That question is hard to ask of most language models, because most are multilingual only by accident: English-first, with the other languages along for the ride. Tiny Aya is multilingual by design: 70+ languages, and four regional variants that share a single base. That makes it a rare, controlled setting for a basic question. When one 3.35B-parameter model holds 70+ languages at once, does it build separate machinery for each, or one shared system that bends to fit?
To look inside, we trained Sparse Autoencoders, which decompose a model’s internal activations into discrete, interpretable features
All numbers come from the four open SAEs run on the full FLORES-200 devtest split (~1,000 sentences × 61 languages × 4 variants) at layer 28; code and weights are linked below.
Farseen0/tiny-aya-saes.What we expected vs what surprised us. Our prior, shared with the team up front, was that a balance-_by-design_ model would mostly share features across languages. The ~76% universal fraction confirms that, and echoes Deng et al.
Most multilingual interpretability runs on Gemma or Llama, models that are multilingual by accident. Tiny Aya (Cohere Labs, 3.35B)
Prior multilingual interpretability has mostly worked at the level of individual neurons: locating language-specific neurons
| SAE architecture | BatchTopK (k=64) → JumpReLU at inference |
| Width / input | 16,384 (8×) / 2,048 |
| Hook | model.layers.28 (final third of 36) |
| Training | balanced CulturaX, 61 languages |
| Variants | Global, Fire, Earth, Water |
Why layer 28? It sits in the final third of the model’s 36 layers, a late-middle depth where SAE features tend to be most abstract and monosemantic: past raw token identity, before the network commits to next-token logits. It is also the layer at which we trained and released the SAEs.
A word on SAE health, since good reconstruction is what makes the features trustworthy:
| variant | explained var | mean L0 | dead features |
|---|---|---|---|
| global | 0.950 | 139.6 | 0.1% |
| fire | 0.943 | 153.9 | 0.0% |
| earth | 0.950 | 142.3 | 0.1% |
| water | 0.947 | 143.2 | 0.1% |
A note on sparsity (it matters below): these SAEs were trained using BatchTopK
with k=64 but are saved as JumpReLU , whose learned thresholds run looser at inference, so a healthy SAE shows L0 ≈ 140, not 64. EV ≈ 0.95 and ~0% dead confirm reconstruction is sound, but the looser operating point means the absolute “features per token” and the universal/specific split below are measured at L0 ≈ 140; cross-language ratios (same SAE, same threshold) are the part to trust.
Define a language’s activation density as the mean number of SAE features that fire per token of that language, averaged over FLORES-200
The model encodes some languages with a far denser feature code than others:
| highest density (features/token) | lowest density | ||
|---|---|---|---|
| Irish (ga) | ~645 | Gujarati (gu) | ~90 |
| Welsh (cy) | ~398 | Marathi (mr) | ~101 |
| Malagasy (mg), Yoruba (yo) | ~218 | Hindi (hi) | ~103 |
| Maltese (mt), Polish (pl) | ~215 | Nepali (ne) | ~105 |
Is this just tokenization? Mostly not, and we checked, because it’s the obvious objection. Across the 61 languages, density is, if anything, weakly anti-correlated with how finely the tokenizer splits text (Spearman −0.16): the most fragmented languages, the Indic scripts, are among the least dense. Two caveats keep us from over-claiming the rebuttal. First, if we instead count features per character, the ordering reshuffles: heavily-fragmented Gujarati climbs from last (~90/token) toward mid-pack (~74/char), while the European languages stay cheap (~30/char) and Irish stays high (~223/char). Second, Irish, our headline, is itself slightly more fragmented per character than English, so for that one language tokenization isn’t fully ruled out. The effect we’d actually stand behind is the gradient across the other 59 languages: even after dropping Irish and Welsh, density still spans ~2.4× (Yoruba/Malagasy ~218 vs Gujarati ~90), and that gradient does not track tokenizer fragmentation.
What does it mean? We don’t yet know, and we’re careful not to dress the measurement up as a verdict on the model. A denser code could reflect genuine representational effort, or redundancy, or simply that the SAE reconstructs some languages with more, weaker features. Our own vignette below shows that feature engagement does not track output quality, so we explicitly do not claim that low-density languages are served worse. These numbers also come entirely from FLORES-200, parallel news-wire text that injects the same named entities and Latin technical tokens into every language, which is a domain confound worth naming. What’s solid is the measurement, and that it isn’t a tokenizer artifact. Why the gradient exists, and whether closing it would change anything, is what we want to chase next.
We classify each feature from its per-language firing profile: language-specific if its firing concentrates in one language, script-specific if in one writing system, universal if it fires broadly (high cross-script entropy).
| variant | language | script | universal | mixed |
|---|---|---|---|---|
| global | 226 | 975 | 12,504 | 2,640 |
| fire | 233 | 717 | 12,909 | 2,504 |
| earth | 197 | 844 | 12,631 | 2,680 |
| water | 203 | 832 | 12,518 | 2,791 |
The overwhelming majority of features (~76%) are universal: shared machinery that fires across scripts and languages. Only ~1.4% are tied to a single language and ~6% to a single script. Multilinguality, at this layer, is mostly shared, which matches our expectations and prior work, so we treat it as confirmation rather than discovery. One caveat on the exact number: at L0 ≈ 140, looser than the trained k = 64, some low-activation features fire broadly and land in “universal,” so the precise 76% is operating-point-dependent. The dominance of shared features is the claim to trust.
Methods note: a reality check on “language-specific.” A naïve “≥60% of a feature’s firing is in language L” rule is badly biased by activation density. Because Irish fires ~645 features per token, Irish alone captured 80% of all “language-specific” features (752 of 941) before correction, an artifact rather than a finding. We give each language an equal firing budget before measuring selectivity, a base-rate correction in the spirit of LAPE
. Even after correction, Irish still accounts for 93 of Global’s 226 language-specific features (41%), Irish + Welsh for 52%, and 40 of 61 languages have ≤1. So “language-specific,” at this layer, largely means “a lot of Irish and Welsh.” We therefore lean on the script-level and aggregate structure and read single-language counts with care. Thresholds (lang τ=0.60, script τ=0.50, entropy ≥0.70) are not swept here; that sensitivity analysis is for the paper.
We ran a thin Cohere command-a auto-interpreter over each feature’s top-activating FLORES sentences. Some features get a clean, concrete label. Here are four we hand-checked, each with a real top-activating example in the original script:
| feature | type | what it detects | example (top-activating context) |
|---|---|---|---|
| #100 | language · jv | Javanese relative pronoun sing | …cara sing padha karo materi liyane sing katon |
| #10734 | language · de | German pronouns & particles (sie, die, zu) | …damit sie ihren Träumen… |
| #2529 | language · ne | Nepali verb-conjugation endings | …थियो भनेर भन्नुभ… |
| #15 | script · Thai | Thai-script detection (fires on ~all Thai) | …ระหว่างการพูดคุย… |
One caveat worth stating plainly: auto-interp is noisy here. It’s a single quick pass, and for a meaningful fraction of features the top-activating example doesn’t actually match the label (for example, a “Japanese politeness” feature whose strongest activation is on a Tamil token). So we only foreground labels we verified by hand, and treat the auto-labels as a starting point, not ground truth. The verified ones, at least, are discrete and nameable, not directions lost in a soup.
The most interesting question Tiny Aya enables: when you specialize a model for a region, does it invent new language features or redistribute existing ones? Our SAEs give a suggestive answer, redistribution, but they cannot give a rigorous one, and it’s worth being precise about why. After density correction, the four variants have near-identical feature inventories (language counts 197–233; universal ~76% across the board). That’s consistent with redistribution, but it’s equally consistent with four separately-trained SAEs independently rediscovering similar structure; counting unaligned dictionaries can’t tell those apart. The earlier impression that Global was far more “differentiated” turned out to be the Irish density artifact, and vanished once corrected. We also see no clean regional specialization in dedicated-feature counts, but that test is itself crippled here. Earth is the African/West-Asian variant, and 6 of its flagship African languages (ha, ig, sn, wo, xh, zu) were absent from the SAE training data, so “Earth doesn’t lead on its own languages” is provisional for exactly the region where it matters most.
Why this needs a follow-up. Four separately trained SAEs have unaligned dictionaries: feature #N in Global is unrelated to #N in Fire, so counting and comparing them is suggestive, not conclusive. We make no per-feature invent-vs-redistribute claim from this alone. The rigorous tool is a crosscoder trained base-vs-variant, a shared dictionary across models, which is the subject of our follow-up paper.
Tiny Aya Global’s Thai is a useful stress test: prompt it with open-ended Thai instructions and it stays in Thai (29/30 of our probes) but its answers range from fluent to badly hallucinated. At one point it turned Ayutthaya, Thailand’s former royal capital, into a fictional “Indian TV actress born in Kolkata,” in perfectly grammatical Thai.
Do the SAE’s Thai features expose this failure? We measured whether Thai-feature engagement tracks an independent quality score, using a single Cohere command-a judge (with the usual LLM-as-judge caveats) plus LaBSE, across 30 model-generated Thai outputs. It doesn’t. Engagement is essentially flat across quality (Spearman 0.05, n = 30; 95% CI [−0.31, 0.41]). This is an underpowered null: we can rule out a strong effect, not a weak one. Human FLORES Thai sits in the same engagement band. The features fire at full strength whether the Thai is fluent or hallucinated; they drop only when the model switches out of Thai.
One readout does catch something, though. The diversity of the feature code, its entropy, falls when the Thai degenerates into repetition: a −0.41 correlation with an objective 4-gram repetition rate, no judge involved. So the SAE does register the looping failure mode, just through the dynamics of the code rather than the identity features’ engagement, and not the factual errors at all.
In sum, at this layer, language-identity features encode which language is produced, not how well; the code’s dynamics partially expose one specific failure, repetition. Surface fluency hides the rest, and so does feature engagement. Pinning down where quality lives needs causal, cross-variant tools, and more than n = 30.
We initially set out to reproduce a reported “Thai → Vietnamese collapse,” an instance of the documented “language confusion” failure mode
, traced to final-layer neurons by Nie et al. . It did not reproduce on GPU at either bf16 or fp16, and appears to have been a hardware/decoding artifact, so we don’t report it. The question above turned out to be the better one.
from sae_lens import SAE
sae = SAE.from_pretrained(release="Farseen0/tiny-aya-saes",
sae_id="tiny-aya-global/layer_28", device="cuda")
features = sae.encode(hidden_states) # [batch, seq, 16384]
Next up is a crosscoder-based model-diffing study (base vs each regional variant, a shared dictionary; see Lindsey et al.
This work is part of Expedition Tiny Aya, Cohere Labs’ open-science program. We thank our Expedition mentors Tom Hosking and Marzieh Fadaee for their constant support and guidance, Alejandro Rodríguez Salamanca for his feedback on the visualizations, and Madeline Smith and Brittawnya P. for stewarding the Expedition and its community. We’re grateful to the wider Cohere Labs Open Science Community for making this kind of open, collaborative research possible. We also build on our team’s shared data-preparation and evaluation harness. Tiny Aya and its regional variants are the work of the Cohere Labs Tiny Aya team; this study is only possible because they built and released a model family designed for 70+ languages.
SAEs: Farseen0/tiny-aya-saes · Code: github.com/FarseenSh/Inside-Tiny-Aya