A generative model answering a question in Hindi, Swahili, or Bengali does more work than the same model answering the same question in English. That is the finding from a University of Michigan team, reported by Michigan News, and the mechanism is not mysterious once you look at the tokenizer. Most production tokenizers are trained overwhelmingly on English text. When they meet a language they were not built for, they shatter it into smaller fragments, and every fragment is a token the model must embed, attend over, and generate. More tokens means more compute. More compute means more energy.
The headline number matters less than the ratio. A prompt that costs one unit of energy in English can cost several in a lower-resource language, because the same sentence arrives at the model as a longer sequence. The team’s contribution is to trace that penalty back to tokenization rather than treating it as an unavoidable property of “AI.” That distinction is the whole story. Tokenization is a design choice. Design choices can be changed.
The tokenizer is a budget nobody audits
Every model has a vocabulary, typically tens of thousands of subword units, learned from a training corpus. English dominates that corpus at every major lab, so English words and common phrases collapse into single tokens. A language with less representation gets sliced into character-level or near-character-level pieces. The model still answers, but it answers expensively.
This is the part the industry has been slow to say out loud. The cost of a query is not a fixed property of the model. It is a function of how well the tokenizer matches the input language. A user in Nairobi and a user in New York can send semantically identical requests and the first one draws more from the data center. Nobody prices that difference. Nobody surfaces it in a usage dashboard. The tokenizer sits upstream of every cost conversation and almost nobody audits it.
The Michigan work makes the accounting visible. It reframes multilingual support from a fairness talking point into an infrastructure line item. That is a more useful framing, because infrastructure line items get budgets and budgets get owners.
Who pays, and who is told
The energy penalty lands in two places. The first is the operator: a lab or cloud provider running inference at scale pays more per non-English request, whether or not it passes that cost to the user. The second is the user, who may see a higher per-token price or a shorter effective context window without understanding why. A model with a 128,000-token context does not hold the same amount of meaning in every language. In a heavily fragmented script, the same window holds less.
That has downstream effects on products. Retrieval systems, code assistants, and document tools all assume a token budget maps to a roughly constant amount of text. For non-English users that assumption quietly breaks. An agent given a fixed context budget will truncate a Hindi document sooner than an English one of the same length. The degradation is invisible unless someone measures it.
The cost of a query is not a fixed property of the model. It is a function of how well the tokenizer matches the input language.
The fix is unglamorous and that is why it stalls
There are known remedies. Train tokenizers on more balanced multilingual corpora. Expand vocabularies to cover scripts that currently fragment badly. Use byte-level or character-aware schemes that degrade more gracefully on unseen languages. None of these are research breakthroughs. They are engineering chores with a real cost: a bigger vocabulary means a bigger embedding matrix, more parameters tied up in the input layer, and retraining or re-tuning downstream.
That tradeoff is why the problem persists. Labs optimize for the languages that dominate their benchmarks and their revenue. English and a handful of high-resource languages get efficient tokenizers because that is where the evaluation pressure is. The long tail gets whatever the tokenizer happens to do. The Michigan study puts a number on that neglect, and numbers are harder to ignore than principles.
The compute angle sharpens the case. If the industry is serious about energy efficiency, and it says it is, then tokenizer efficiency is low-hanging fruit that gets skipped because it does not demo well. A model that answers in English at some cost and in Swahili at three times that cost is not equally efficient. It is efficient for the users the tokenizer was built for. Efficiency claims that only hold for English are partial claims dressed as universal ones.
What builders should take from this
For anyone shipping a model or a product on top of one, the practical move is to measure the token inflation per language before publishing cost or context claims. A per-language token ratio is a cheap instrument. It tells you where your product silently underperforms and where your energy bill is leaking. It also gives you something to put in front of a procurement team that is starting to ask about compute costs and carbon.
For the labs, the honest step is to report tokenizer coverage alongside benchmark scores. A model card that lists accuracy per language but not tokens-per-word per language is telling half the story. The energy penalty is a direct consequence of a choice made at the very start of the pipeline, and it is the kind of choice that compounds across billions of requests.
The University of Michigan finding is not a scandal. It is a measurement, and a useful one. It says that the cost of generative AI is not one number but a distribution, and that the distribution tilts hard against most of the planet’s languages. The next question is whether any major lab treats that tilt as a bug worth fixing, or as a rounding error it can keep absorbing. Watch the tokenizer vocabularies in the next round of model releases. That is where the answer will show up first.