Non-English requests usually consume more energy. A model's support for many languages does not mean it processes every language with equal efficiency. This article examines where those costs arise and provides a practical monitoring approach.
What the research found
A University of Michigan News article titled “Generative AI uses more energy on non-english text” reports that generative AI typically consumes more energy when processing non-English text than English.
After publication, the article reached the Hacker News front page. At the time of retrieval, it had 15 points and five comments.
This does not mean non-English requests are necessarily too slow to use, or that models cannot support Chinese, Japanese, Swahili, or other languages. A more accurate conclusion is that the same model may have different computational efficiency across languages.
Many product pages emphasize “support for 100+ languages” and “cross-lingual reasoning.” Those claims describe capability coverage, but they do not answer the cost questions:
- How much does one million tokens cost?
- How long does a request occupy the GPU?
- How many tokens must be generated to achieve the same output quality?
- How much energy does the same task consume?
Ordinary users cannot see these metrics. Engineering teams deploying AI Agents need them to determine whether a product can scale.
Language is not merely an interface dropdown. It affects data processing, tokenization, inference, and generation.
The hidden tax of English training data
Part of the problem comes from training data. Most leading models are trained primarily on English. A common approach is to translate non-English data into English before giving it to the model.
User input: non-English text
↓
Machine translation layer: non-English → English
↓
Target model: understands and reasons using the English input
↓
Machine translation layer: English → non-English
↓
User receives the final response
This means the model performs more than a single inference. Translation is itself a model computation. Translating the input, running the target model, and translating the output can also become several serial steps.
Translation also affects token counts. Tokenizers achieve different character efficiencies across languages. The same idea may require different numbers of tokens in Chinese, Japanese, and English. Similar character counts do not imply similar amounts of computation.
Intermediate translation can also introduce information loss. Colloquial speech, slang, mixed-language code, negation, and regional expressions may appear less often in English corpora. Translating to English before processing subjects the content to a lossy form of compression.
The cost of a non-English path may therefore come from three sources:
- Additional translation computation;
- A longer or more complex context after translation;
- Extra generation, validation, or retries needed to compensate for translation losses.
This is not an add-on feature for language support. It is closer to a per-request language tax.
Multilingual leaderboards can hide costs
A model's ability to translate and answer questions does not mean every language has the same efficiency.
A high score on a Chinese benchmark shows that a model performs well on a particular task. It does not directly reveal the time to first token for a Chinese prompt, the inference price per million tokens, or the GPU time required to produce an answer of the same length.
These differences matter especially for products serving languages with fewer digital resources.
Suppose a multilingual customer-service Agent handles four languages. During testing, each language uses carefully prepared, high-quality short passages. In production, the system receives long messages containing emojis, industry abbreviations, addresses, and dialect. Test results cannot be extrapolated directly to production traffic.
Engineering teams should at least record the following separately for each language:
| Metric | English | Non-English |
|---|---|---|
| Input and output tokens | Tracked by language | Tracked by language |
| Time to first token | P50, P95, P99 | P50, P95, P99 |
| GPU time per request | Separate live workloads from cache hits | Separate live workloads from cache hits |
| Cost per million tokens | Converted to the actual billing model | Converted to the actual billing model |
| Retry rate | Track translation, tool-call, and format errors | Break down by language |
| Energy or compute intensity | Compare on identical hardware and batch settings where possible | Compare on identical hardware and batch settings where possible |
AI Agents make the situation more complex. An Agent may follow this sequence: “translate → plan → call tools → validate the answer → translate back to the original language.” If any step produces more output tokens or triggers a failed request and retry, the additional cost compounds.
Multilingual leaderboards should therefore extend beyond “Did it answer correctly?” to “How many resources did it take to answer correctly?” Accuracy measures quality, while energy efficiency determines deployability. Both are necessary.
Real-time translation keeps increasing the bill
Real-time translation and multilingual customer service make the extra computation more frequent.
Traditional translation tools typically convert sentences one at a time. A generative AI system may instead reason over the entire context: understand the user's intent, retrieve from a knowledge base, generate an answer, and then translate it back into the user's language.
If real-time translation uses streaming output, every turn in a conversation may pass through several models. Before a human escalation, an “unresolved issue” in an Agent may already have triggered multiple retrievals, tool calls, and self-checks.
As usage grows in languages with fewer digital resources, this extra computation may further expand AI's energy footprint. The mechanism is straightforward: more requests mean more translation steps and longer serial inference chains. Scale magnifies otherwise minor language differences.
English usually serves as the system's internal “working language.” A user speaks Chinese, the retrieval tool queries in English, the database returns English, and the result is translated back into Chinese. Every language switch can add latency and tokens.
That is why a model's language-support list is not enough. The more useful question is whether the system can complete an end-to-end task directly in the target language instead of translating at every layer.
How to reduce the tax in production
The first step is to prioritize native-language training data.
If a business has large volumes of Chinese, German, or Arabic logs, it should preserve the original text for training, fine-tuning, or preference optimization. There is no need to translate everything into English immediately. The syntax, terminology, and error patterns in original expressions contain precisely the information a model needs to adapt to the target market.
The second step is to shorten chains that translate to English and back.
End-to-end multilingual models, regional models, or language-based routing to specialized models can reduce intermediate translation. Whether the trade-off is worthwhile must be measured with real requests rather than inferred from a model's marketing page.
The third step is to track GPU time and energy consumption by language.
The least expensive implementation is to add a language field to every call and write the model, token counts, latency, GPU time, and retry count into the same trace.
The following Python example is runnable. It does not measure physical energy consumption, but it establishes a baseline for language-level costs:
import json
import time
from collections import defaultdict
records = []
def record_request(language, model, input_tokens, output_tokens, latency_ms):
records.append({
"language": language,
"model": model,
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"latency_ms": latency_ms,
})
start = time.perf_counter()
# Replace this with real calls; sample data validates the aggregation logic.
for language in ["en", "zh", "ja"]:
record_request(
language=language,
model="your-model-name",
input_tokens=1200,
output_tokens=300,
latency_ms=850,
)
elapsed_ms = (time.perf_counter() - start) * 1000
summary = defaultdict(lambda: {"requests": 0, "tokens": 0, "latency_ms": 0})
for row in records:
item = summary[row["language"]]
item["requests"] += 1
item["tokens"] += row["input_tokens"] + row["output_tokens"]
item["latency_ms"] += row["latency_ms"]
print(json.dumps({
"elapsed_ms": round(elapsed_ms, 2),
"by_language": summary,
}, ensure_ascii=False, indent=2))
Once connected to a real inference service, teams should add GPU utilization, batch size, and deployment details. To compare energy consumption, run a fixed test set on identical hardware with identical batch settings, then integrate NVIDIA DCGM or a cloud provider's energy-monitoring tools.
The fourth step is to incorporate routing and caching into the strategy.
- A cache hit for an English request does not mean a Chinese request can reuse the same cache prefix;
- Different languages may require different embeddings or rerankers;
- Model routing can divide traffic by language, task, and load, but every request should not trigger a translation model;
- If tool results are language-independent, teams can retain a unified structure and convert them only when presenting the final result to a user.
Finally, the budget should list “language” as its own category.
language_budget = {
"en": {"max_cost_per_request": 0.010, "max_p95_latency_ms": 1200},
"zh": {"max_cost_per_request": 0.016, "max_p95_latency_ms": 1600},
"de": {"max_cost_per_request": 0.014, "max_p95_latency_ms": 1500},
}
These thresholds are not universal answers; they should be derived from real traffic and business requirements. They nevertheless force teams to treat non-English requests as distinct workloads rather than secondary entry points for an English-first design.
The original research is available from University of Michigan News: https://news.umich.edu/generative-ai-uses-more-energy-on-non-english-text/.
Engineering perspective
This research deserves attention from engineering teams because multilingual support is becoming an infrastructure requirement rather than merely a product feature. Customer service, AI Agents, voice interfaces, and knowledge bases all face language switching, yet budgets often track only “model” and “tokens” without accounting for language efficiency.
The practical conclusion is somewhat counterintuitive: the most useful multilingual model may not be the one that supports the most languages, but the one that reduces translation and shortens inference chains for the target language. Leaderboards should also report energy use per million tokens, P95 latency, and token consumption at a fixed quality level.
This differs from the older “more parameters, higher leaderboard score” approach. Multilingual capability is no longer just about whether a model produces the right answer; it must also account for computational efficiency. The available material does not provide a complete breakdown of the gaps between languages or an energy curve measured on standardized hardware. The potential gains depend on whether the model was trained on target-language data and whether the system must use English as an intermediary. Measure first rather than assigning a fixed cost label to a language.
Source
https://news.umich.edu/generative-ai-uses-more-energy-on-non-english-text/