In-Language Reasoning Transfers Without In-Language Reasoning Data

A 3.35B model called Tiny Aya L2-Thinker reasons in the language it was prompted in more than 93% of the time, across 60 languages and six benchmarks. Those are the authors' own numbers on their own benchmarks. The part worth reading is the recipe underneath: an English reasoning backbone, mixed with multilingual text that carries no reasoning traces, and no requirement for reasoning supervision in every target language.

"L2 reasoning" is the paper's term for a model reasoning consistently in the language of the user's prompt, building an in-language bridge between the prompt and the answer. The paper's framing of the problem is that models primarily reason in English regardless of the language they are prompted in. The pivot is what L2 reasoning is defined against, and the paper argues it risks losing the intent of the original question and forgoes knowledge more readily expressed in the target language.

The assumption the paper tests

The obvious fix for the pivot is reasoning supervision in every language you care about. The paper tests whether you can skip it.

These findings indicate that reasoning is a language-agnostic behavior that can be transferred across typologically diverse languages through careful data mixing and without requiring reasoning supervision in every target language.

Side by side, the two approaches differ on almost every axis:

What it changes if you are building

If the result generalises, you tune mixing ratios over multilingual corpora you already have instead of commissioning chain-of-thought traces in each language. That is a different kind of project: data composition and scheduling rather than data collection.

• Language of the reasoning trace is the variable. The paper reports an L2 reasoning rate above 93%. The abstract does not define how that rate was computed, so it is a headline number rather than a metric you can lift.
• Scheduling may matter as much as ratio. The work is framed as data composition and scheduling in SFT, which points at the order in which languages and data types arrive during fine-tuning. The abstract does not give the schedule, so this is the part you cannot copy out of it.

The practical shift is in what you collect. Chain-of-thought traces in 60 languages are expensive, slow to produce, and hard to quality-check when nobody on the team reads the language. Ordinary multilingual text is not. If the mechanism really is language-agnostic reasoning behaviour, the scarce resource stops being annotation and becomes coverage: how many languages you hold text for, and how much English reasoning data sits behind them.

The weights and the multilingual reasoning data are released. That is what turns the claim into something you can vary and re-run rather than quote.

How you would check it yourself

The claim is about the mix, so the experiment worth running is one where you set it yourself. Take the released weights and data, fix a prompt set in a single language, and vary only what goes into SFT. Everything else stays put.

Three runs. Backbone only, with the English reasoning set and no multilingual non-reasoning data. Backbone plus the multilingual mix, approximating what the paper describes. Backbone plus a mix with your target language deliberately excluded, which tests the generalisation claim directly rather than inheriting it.

Score two things separately: whether the final answer is correct, and whether the reasoning sits in the prompt language. The paper treats those as distinct questions, and collapsing them into one number hides the failure you care about, where the answer is right and the thinking is English. A single aggregate accuracy figure would let you claim success while the model never left English.

Scoring the reasoning language needs a definition before you run anything. The cheapest version classifies the intermediate text by script or language ID and counts how often it matches the prompt. That is a proxy, and it will disagree with the paper's number wherever a trace switches language partway through, which is where the interesting cases sit.

One scored sample, the shape you want:

{"prompt_lang": "ta", "reasoning_lang": "en", "answer_lang": "ta", "correct": true}

If the third run holds up, the recipe carried into a language with no reasoning supervision behind it. If it falls apart, the 93% belongs to the particular set of 60 languages rather than to the recipe.

What the abstract does not say

How the 93% was measured, for a start. The abstract does not define what counts as reasoning in the target language: whether it scores the intermediate tokens, the final answer, or both. Nor does it say which languages fall outside the 93%, and for a paper about accessibility that tail is the interesting part. A rate averaged over 60 languages can sit above 90% while the languages you actually care about sit well below it.

On held-out languages the abstract describes a route rather than a result. The path it names runs through broader language coverage, multilingual non-reasoning data that is readily available, and a sufficient English reasoning backbone. It does not report how many held-out languages were tried or what the transfer cost was. "Keeping performance strong" is the only description of the accuracy cost, and it is not quantified.

There is a scale question. The results are reported at one size, 3.35B, and the abstract does not discuss larger ones. A mixing ratio tuned at 3.35B is untested above it, and nothing in the abstract suggests the same ratio would carry.

What the released data lets you test

The abstract reports one mix and one outcome. The artefacts let you separate them. Hold the English backbone fixed, change only the composition of the multilingual portion, and watch whether the L2 rate follows the recipe or follows the presence of a particular language in the mix. That is the question a paper cannot answer about itself, because a paper reports the one mix it chose.