Chain-of-Thought Language Mismatch: Reasoning in One Language, Answering in Another

A model working through a problem in English and then answering in Norwegian is doing two different jobs, and they have different requirements. Treating the reasoning language as a single setting that is either right or wrong is what makes this confusing.

Two questions, not one

There are two independent decisions hiding inside “what language should the model think in”.

• Which language gives the better derivation? This is about the model’s competence at multi-step work — arithmetic, constraint tracking, legal or medical inference — and it is a question about where that competence lives in the model’s training data.
• Which language must the answer be in? This is fixed by your product. It is not negotiable and it is not a quality trade-off.

Because they are separate, the interesting configuration is the mixed one, and the interesting failures are at the seam between them: a correct derivation rendered into an answer full of English terminology, or a fluent answer resting on a derivation that lost the thread.

What the published work found

There is real published evidence here, and it is worth stating with its scope rather than as a slogan. In 2022 a team at Google published Language Models are Multilingual Chain-of-Thought Reasoners, introducing MGSM — a set of grade-school maths problems translated into ten languages including Bengali, Swahili, Telugu, Thai, Japanese, Chinese, Russian, German, French and Spanish. The paper is at arXiv 2210.03057.

The paper compares several prompting configurations, including reasoning in the problem’s own language and reasoning in English about a non-English problem. The finding that matters here is that the English-reasoning configurations were competitive with or better than native-language reasoning, and that the gap was largest for the languages with the least representation in training data. It was not a uniform result across all ten languages, and it was measured on mathematical word problems, which is a narrow task. Both of those qualifications are load-bearing: this is evidence that reasoning competence is unevenly distributed across languages, not a rule that English is always the right trace language for every task.

Related work on cross-lingual prompting reaches the same shape of conclusion — that routing the reasoning through a high-resource language helps most exactly where the target language is weakest. The mechanism is straightforward. The material that teaches multi-step derivation — textbooks, worked solutions, competition problems, code, technical documentation — is overwhelmingly English. A model’s ability to hold a chain together is concentrated where that material is.

Language mixing in reasoning traces

Models trained specifically to produce long reasoning traces surface a related problem, and it is documented by the people who built one. In the DeepSeek-R1 paper, published January 2025 and available at arXiv 2501.12948, the authors describe language mixing in the reasoning of their reinforcement-learning-only model — traces that switch between languages mid-derivation — and report adding a language consistency reward during training specifically to address it, noting that doing so came at some cost.

That is a useful fact to have when you see a trace that starts in your target language and finishes in English. It is a known behaviour with a known cause: nothing in the reasoning objective rewards staying in one language, and the model drifts toward the language its reasoning competence sits in. It is also a reminder that the fix is a training-time intervention with a price, not something a prompt guarantees.

What each side costs

Reasoning in English and answering in the target language buys derivation quality and costs you at the render step. The specific failure modes are consistent and checkable:

• Terminology calques. The derivation established a term in English; the final answer translates it literally rather than using the field’s actual term in that language.
• Locale leakage. The reasoning computed 1,234.56 and the answer keeps the English separators when the target uses 1.234,56. Dates, units, currency placement and week numbering leak the same way.
• Untranslated fragments. A unit, a label, a header, a hedge left in English inside otherwise clean target-language prose.
• Translationese in the answer. The final paragraph reads as a translation of an English answer, because that is what it is — the mechanism argued in writing prompts natively.

Reasoning in the target language buys a natural answer and costs you on the derivation, more so the thinner the language’s coverage. It also costs tokens: the same reasoning in a heavily fragmented script can be several times the token count of the English equivalent, and reasoning tokens are billed as output.

Controlling it

1. State both languages separately in the prompt. “Work through the problem in English. Then write the final answer in Finnish, and nothing else in the final answer.” Two instructions, because they are two decisions.
2. Delimit the answer. Ask for the final answer inside a fixed marker or a JSON field, so you can extract it without the trace. This also gives you a place to run the checks.
3. Add the locale constraints to the render step, explicitly. Decimal separator, date format, unit system, currency placement, quotation marks. The derivation will not have used them.
4. Use two calls when the answer really matters. Call one reasons in English and emits a structured result — numbers, decisions, citations. Call two renders that structure into the target language with a native example and the locale rules, and never sees the English prose. This eliminates translationese in the answer entirely, because there is no English prose to translate.
5. Check for leakage mechanically. Assert the final answer contains no Latin-script runs above a threshold for a non-Latin target, and validate number and date formats. The specific case of the model ignoring the output-language instruction is covered in when the model ignores your output-language instruction.