Could an AI discover an alphabet it was never shown?

What distillation really is

Call this capability distillation: collapsing a mountain of instances down to the compact rule-set that generates them. Not "predict the next word" — abstract the standard. From thousands of words containing t, conclude that t is a unit. From the whole vocabulary, conclude that there is a finite alphabet, and name its members — including the ones no single word makes obvious.

The hard half of distillation is the negative half. To truly know an alphabet you must know not only which letters are in it, but which letters are not — and that a particular run of symbols is not a legal letter even though it looks plausible. Knowing the boundary is the difference between mimicking the language and modelling it.

Why English is the easy case

For English, a model never actually has to perform this feat — because the standard was handed to it. The 26 letters are explicit, taught, printed on the first page of a million books, recited by every child. The abstraction the thought experiment demands is everywhere in the data, stated outright. The model inherits the alphabet for free; it is never made to discover one.

So with English we never find out whether the model can do the hard thing. The test is rigged in its favour. To actually probe the capability, you need a language where the corpus exists but the standard was never published — where the only way to have the alphabet is to distill it. That language family is sitting in plain sight.

The languages where no one wrote the alphabet

There are more than 500 Bantu languages, spoken by roughly 400 million people. They have been written, at any meaningful scale, for only the last 80–100 years. And for almost none of them has the operating alphabet ever been written down completely — not in CommonCrawl, not cleanly in academia, not anywhere a model could have read it.

So Bantu is the thought experiment made real. The words exist; the model has ingested them. The standard underneath was never stated. If a model genuinely possessed the distillation capability, this is where it would show — it would recover each language's operating alphabet from the words alone. Here is the uncomfortable sentence: the most capable models ever built cannot name the alphabet of a language 400 million people speak. Not "struggle with" — cannot produce a complete, verified one, for even one of the 500+. Two minutes proves it on your own model.

The operating alphabet of a Bantu language

First, a correction that matters: a Bantu language's alphabet is not its letters. You sound out a Bantu word syllable by syllable — ba, be, bi — and the syllable, not the letter, is the basic unit. The operating alphabet is therefore the complete, closed set of legal syllables: the Full Syllable Inventory, or FSI. No native word can be written without them.

And the FSI has two layers, which matter enormously here:

• The NSI — the Native Syllable Inventory. The closed native core: the syllables the language is built from. This is the language's identity.
• The ASI — the Augmented Syllable Inventory. The open, growing layer of syllables that entered through contact — loanwords from English, Swahili, trade, technology. This is the language's biography.

That split is not bookkeeping. It is the line between what a language is and what it has encountered — and, as we'll see, it is exactly the line frontier models cannot draw.

The two things the model doesn't do

When a frontier model fails this test, it fails on two levels at once — and the second is the deeper one.

One: it never distilled the alphabet from the words. It has read mfumu ("chief") and mfula ("rain") a thousand times. The evidence that mf is a unit is sitting in its training data. But it never ran the inversion — words back to inventory, instances back to the closed standard underneath. It has the words and never abstracted the alphabet.

Two: it doesn't know there is an alphabet to distill toward. For English the existence of a fixed, closed alphabet is given; for Bantu it was never stated, so the model treats the language as open surface text — an unbounded stream to imitate, not a system with a finite operating core to converge on. It isn't aiming at the standard and missing. It doesn't know the standard is the target.

The missing published alphabet causes both failures at once. There is nothing in the data telling the model "this language has a fixed operating set — converge on it." So it doesn't.

The knowledge that leaves no trace

Here is the reason distillation from text alone can never fully succeed — and it is structural, not a matter of scale.

Positive facts leave traces. Absences do not. A model can learn that ba exists because it appears in the corpus. But it cannot learn that Bemba has no z — because the absence of z leaves nothing in the text to learn from. You cannot read what was never written. The negative space of a language — the syllables it systematically excludes — is invisible in its own corpus.

This is why models confidently produce za, xa, bare da for Bemba: they carry a generic, high-resource prior in which those exist, and nothing in the Bemba data ever contradicts it, because contradiction would require a record of an absence. The boundary of the language — the part that most defines it — is exactly the part the model's method cannot acquire. It can only be handed the boundary, in the form of the inventory that states it explicitly.

The fingerprint

Once you see the NSI as the boundary, a sharper description follows: the NSI is the language's fingerprint.

It is unique. Each language draws its own boundary — which letters occur freely, which only in clusters, which never. Bemba forbids q, x, z and allows the voiced stops d, g, j only after a nasal (nd, ng, nj). Its neighbour Nyanja allows those stops bare; Makonde uniquely forbids f. The same letter is legal in one Bantu language and illegal in the next — and the only place that fact is recorded is each language's own inventory.

It is stable. A language's native core barely moves; identity persists. It is the loan layer (the ASI) that accretes over time. It is compact — a handful of rules generates the whole legal space — and yet complete enough to pin the language exactly. And it is more than a fingerprint: a fingerprint only identifies; the NSI also generates (its rules build every legal syllable) and carries meaning (in Bantu, pitch rides the syllable, and a syllable said high or low can be a different word). It is fingerprint and blueprint at once.

A frontier model can reproduce a language's face — fluent-looking surface text. It cannot forge its fingerprint — the closed inventory and the negative space — and it does not know a fingerprint exists to be matched. It can fake the appearance. It cannot fake the identity.

Distillation, caught in the act

Watch the capability the models lack, performed once, deliberately. Bemba has mfula ("rain") and mfumu ("chief"). From those words you can distill that mf is a real unit of the language — instances inverted back to an operating primitive. That is the exact move a model should make and doesn't.

Now the twist that turns a weakness into a tool. When we ran the Alphabet Test across the frontier, several independent frontier models — from different labs — each produced mf-syllables that scored as "fabrications" against our Bemba inventory. But independent minds inventing the same non-member is not a coincidence of identical hallucinations. It is a signal: the syllable is real, and the inventory was incomplete. The models, precisely because they lack the alphabet, became unwitting instruments for completing it. We confirmed mf as a genuine Bemba onset, opened a change request, and published a new version of the inventory — sourced, audited, traceable. The labs' blindness fed the standard.

That is the discovery loop in one stroke: a model's convergent error is a candidate; native and owner review is the filter; and what survives becomes the next version of the standard. The test does not just measure the gap. It helps close it.

The family resemblance

There is one more layer of understanding the models miss — the one that separates "knows Bantu words" from "understands the family." Bemba's mfula has a cousin: in Chewa and Nyanja, "rain" is mvula. Same ancient root; Bemba resolved it with f, Chewa with v. That f↔v swap is not a coincidence — it is a regular correspondence that holds across the vocabulary. Each language has consistent preferences: Bemba leans f where Chewa leans v. The family is systematic variation on a shared theme — drifted, but lawfully, each daughter keeping the essence and stamping its own signature.

This is why mv “leaked” into one model's Bemba answer: not because the model invented it from nothing, but because it imported a neighbour's real form. It holds a blurred, pan-Bantu average and has no model of which language prefers which — so it cannot keep the signatures apart. The blur is the failure. A mind that truly understood Bantu would hear both at once: the unity of the root and the signature of each tongue.

And that higher structure is itself an asset. The 459 inventories, read together, form a correspondence map of the family — a phylogeny in which the differences are regular, predictable, and mutually reinforcing. From Bemba's mf and a known correspondence you can predict Chewa's mv, fill a thinly-documented language from its relatives, and flag inconsistencies. The standard is not 459 disconnected files. It is one connected object.

The promise meets the gap

So the dream is worth naming plainly: an AI that, given only the raw words, could distill the operating alphabet of any language — even one no human ever standardised — drawing the boundary, separating the native core from the borrowed, and hearing each language's signature against its family. That would be understanding, not mimicry. It is one of the most beautiful things we could build.

Today's models cannot do it. But the same test that exposes the gap also makes it measurable — for the first time you can score exactly how much of a language's alphabet a model recovered, how much it invented, and which rules it violates — and it makes the gap closable, because the one thing a model cannot distill for itself can be handed to it: the inventory, with its boundary stated, its loans separated, and its provenance attached.

A standard, kept alive

The English alphabet took centuries to settle. The Bantu operating alphabets are being established now — deliberately, quickly, and under governance — because they have to be established, not handed down complete. BantuNomics maintains the 459 FSIs as a living, versioned standard: native-curated, split into native and borrowed layers, reviewed by speakers, traced line by line, and improved through an audited change-management engine. The mf addition above is that engine in motion — a real gap, surfaced by model convergence, confirmed by native authority, and shipped as a new, citable version.

That is what a frontier lab is actually offered: not 459 datasets to consume, but the baseline operating alphabet no one should have to rediscover — plus the standards process and the convergence engine that keep establishing it. And because even the models' failures feed the standard, the moat widens the more the test is used.

The bottom line

The promise of AI is to find the standard hidden in the surface — to distill the alphabet from words that never name it. For English, the standard was handed over, so the capability was never tested. For the languages of 400 million people, the standard didn't exist to be found — which is why the most capable models on earth cannot name their alphabets, and don't know there are alphabets to name.

That standard exists now. It is native-curated, versioned, and growing — and it is the foundation a model can finally be built on. The dream of a machine that distills an unwritten alphabet is worth chasing. Until it arrives, the alphabet can be handed over. Start by seeing the gap on your own model.

Run the Alphabet Test Read: the case for the FSI See the measured gap Initiate Partnership