Quick Answer: Generative AI often uses more energy on non-English text because most large language models break words into tokens using vocabularies built mainly from English. A sentence in a less-represented language can become several times as many tokens, and the model does compute work for each one. Energy use scales with that token count, so the same request can cost more in Hindi, Arabic, or Thai than in English.

Ask a chatbot the same question in English and in Swahili, and the answers may be equally good. The electricity bill behind them may not be. New research from the University of Michigan, reported in its news release on generative AI and non-English text, points at a cost that most users never see. Generative AI energy use depends heavily on language, and that is a problem for a technology that claims to serve everyone.

Why the Same Question Costs More in Some Languages

Language models don't read letters or words. They read tokens, chunks of text produced by a tokenizer before the model ever runs. Most widely used tokenizers, including the byte-pair encoding (BPE) schemes behind OpenAI's tiktoken library, learn their vocabulary from a training corpus. When that corpus is dominated by English, common English words become single tokens while other words get split into fragments.

Here's the practical effect. Imagine a sentence that takes 10 tokens in English. The same meaning in a language with a non-Latin script, or with heavy inflection and fewer training examples, might take 20 or 30 tokens. That's illustrative, not a measured benchmark, but it matches what developers see when they paste text into a token counter.

The model then processes every token. Each one passes through the transformer's layers, and during generation each new output token requires another forward pass. More tokens means more floating-point operations, more memory traffic, and more GPU time. Energy follows compute.

Most people assume a query has a roughly fixed cost. That's the lazy mental model, and it's wrong in a specific way: the cost tracks the tokenized length of the text, not the meaning you intended to convey.

What the Michigan Research Points To

The University of Michigan release frames the central finding simply: generative AI consumes more energy when the input is non-English. I won't invent figures for the study's measurements, and you should read the original release for the exact methodology, languages tested, and reported numbers. The core claim is consistent with the tokenization mechanism above, which is why it's believable.

That said, a finding like this has real nuance. Energy use depends on the model architecture, the hardware (an NVIDIA H100 and an older accelerator behave differently), the batch size, the data center's cooling and power mix, and whether the system uses caching or speculative decoding. A result measured on one stack doesn't transfer cleanly to another. Treat the direction of the effect as well supported and the magnitude as something to check for your own workload.

Here's the part most coverage skips: the gap isn't only about input. Long, verbose outputs in some languages can add to the cost too, because the model generates tokens one at a time.

The Counter-Intuitive Part: Translating to English Isn't a Free Fix

The obvious workaround is to translate prompts into English before sending them to the model. It sounds efficient. In many cases it isn't.

First, translation itself is computation. If you run a separate translation model or call an API, you pay for those tokens too. Second, translation can lose nuance, especially for legal, medical, or culturally specific text, and a wrong answer that's cheap to generate is still expensive to fix. Third, the output usually has to come back in the user's language, so you may be paying a translation cost on the response as well.

This is where practitioners get burned. A team routes Portuguese customer messages through English to save tokens, then discovers that the translation step adds latency, the bill for two model calls exceeds the original, and tone errors are generating escalations. Translating to English reduces input tokens in some cases and increases total cost in others.

That said, if your workload is narrow and repetitive, such as classifying short support tickets, a single well-tested translation step can win. Measure the total pipeline, not just the prompt.

How the Options Compare

The right approach depends on what you're optimizing. Here's a practical comparison:

ApproachInput token countCompute per answerMain risk
English prompt, English-centric modelLowest for EnglishBaselineUsers in other languages pay a higher token cost indirectly
Native-language prompt, standard tokenizerOften 2–3× English for non-Latin scripts (illustrative)Higher, scales with tokensHigher bills and slower responses
Translate to English first, then answerLower for the model callAdds a translation passNuance loss and a second inference cost
Model with a multilingual tokenizerCloser to parity across languagesDepends on vocabulary size and modelLarger vocabularies can increase model size and memory

Notice that no row is free. The question is which cost you can measure and control.

Who Actually Pays for the Gap

Token-based pricing makes this concrete. Most commercial APIs bill per token, so a user writing in a less-tokenized language can cost the provider and the deployer more per equivalent request. Whether that gets passed to users depends on the business model. A consumer chatbot with a flat subscription absorbs it. A pay-per-token enterprise integration shows it in the invoice.

Consider a multilingual support assistant handling thousands of conversations a day across English, Hindi, and Korean. If you only watch aggregate token spend, you'll see a bill that looks reasonable and miss that the non-English queries are the expensive ones. Break spend down by language and the pattern usually appears within a week.

This is also a fairness question. If a model is cheaper and faster for English speakers, the people most likely to be underserved are the ones who already get the least from the technology. That's not a reason to panic, but it's a reason to make the cost visible.

What to Do About It

Here's a sequence that works for teams building on these models today:

  1. Measure tokens per language on your real traffic, using the provider's tokenizer or tiktoken. Don't guess from character counts.
  2. Track cost and latency per language, not just in aggregate.
  3. Test translation-first pipelines against native-language prompts on accuracy, latency, and total cost. Use the numbers, not intuition.
  4. Ask your provider which tokenizer and model family you're using, and whether a multilingual variant exists.

And here's the bulleted list of pitfalls to check in your own deployment:

  • Verbose system prompts written in English add tokens to every non-English request.
  • Retrieval-augmented generation can pull English documents into a non-English query, inflating context length.
  • Output length limits that look fine for English may truncate answers in other languages.

Most people stop after step one. Don't. The measurement only becomes useful when you compare it against quality, because a cheaper answer that's wrong costs more.

Frequently Asked Questions

What is generative AI energy use for non-English text?

Generative AI energy use for non-English text is the electricity a model consumes when processing prompts and producing responses in languages other than English. It's typically higher because tokenizers trained mainly on English split other languages into more tokens, and the model does more computation for each one. The exact difference depends on the model, hardware, and language.

How can I reduce the energy cost of multilingual AI prompts?

Start by measuring tokens per language with your provider's tokenizer, then cut unnecessary text from prompts and system instructions. Test whether a translation step lowers total cost without hurting accuracy. Choose models with multilingual tokenizers when your workload is heavily non-English.

Why does AI use more energy for some languages than others?

AI uses more energy for some languages because tokenizers learn their vocabulary from training data, and English usually dominates that data. Common English words become single tokens, while other scripts and word forms are split into several pieces. Since the model processes each token, more tokens means more computation and more energy.

Is translating prompts to English always cheaper?

No. Translation adds its own compute cost, can lose meaning, and often requires translating the response back. It can reduce cost for narrow, repetitive tasks, but it frequently increases total spend for conversational or high-stakes use. Always measure the full pipeline.

Does the University of Michigan research mean all AI is wasteful for non-English users?

No. The research highlights a measurable gap, not a fixed penalty for every system. Better tokenizers, multilingual training, and efficient inference can narrow it. Check the original University of Michigan release for the study's specific scope and findings.

If you run a multilingual product, pull last month's usage logs and split token counts by language today. Find the one language where your cost per conversation is highest, then pass this article to whoever owns that pipeline. Generative AI energy use is an engineering problem you can measure, and the first measurement usually reveals something worth fixing.