Why Fable 5.1 Sometimes Thinks in Chinese — and What It Doesn't Prove

Bolt.new CEO Eric Simons posted something unusual on September 14, 2026: a screenshot of Claude Fable 5.1's visible reasoning trace switching into Chinese mid-thought, inside Anthropic's own official app. "First time I've seen this one," he wrote, comparing it to a similar quirk he'd noticed in Zhipu AI's GLM 5.3 Flash. The replies moved fast from curiosity to distillation theories. The real explanation is less dramatic, and it's been documented before — just not usually about Claude.

TL;DR: what happened and what it means

What code-switching in chain-of-thought actually is

Reasoning models like Fable 5.1 are trained to produce a visible intermediate chain of thought before committing to a final answer, and that training process optimizes primarily for one thing: getting the final answer right. It does not, by default, optimize for the intermediate reasoning staying in a single language throughout. When a model's underlying computation draws on a shared multilingual representation space — built from training data that includes non-English text even when English dominates — the tokens it emits mid-reasoning can shift into whichever language its internal process happens to represent a given concept in most strongly, before shifting back to answer in the language the user asked in.

This isn't a new discovery. DeepSeek's R1 model, released in early 2025, became well known for exactly this behavior — its reasoning traces would frequently mix Chinese and English mid-thought, even on English-language prompts, well before this week's Fable 5.1 screenshot circulated. Researchers studying reasoning models have generally treated this as an artifact of how reinforcement learning shapes chain-of-thought behavior — the RL reward signal cares about final-answer correctness, and unless a lab specifically trains against language-switching as an undesired behavior, nothing in the training process prevents it from surfacing.

The reply that actually got it right

Buried in the reply thread, one commenter cut straight through the speculation: "You know that Claude is a 'language' model right? Not an 'English' model." That's a genuinely useful one-line correction to how a lot of the thread was framing the incident. Fable 5.1, like essentially every frontier model, is trained on a broad multilingual corpus. The fact that its reasoning can surface non-English tokens isn't evidence of anything unusual happening under the hood — it's a visible symptom of a normal property of how these models represent and process language internally, made visible only because reasoning models expose intermediate tokens that older, non-reasoning models never showed users at all.

Simons himself, notably, didn't stop at the joke — he reported that when he directly asked Claude about the Chinese-thinking behavior afterward, it triggered the exact same pattern again. That's a mildly interesting data point about consistency (the behavior isn't a one-off fluke tied to a specific unrelated prompt), but it doesn't change the underlying explanation.

Why the distillation jokes don't hold up

The replies included a sarcastic aside — "my good personal friend dario would never distill a chinese model" — clearly intended as a joke rather than a serious claim, but it's worth addressing directly since distillation speculation about frontier labs is a genuine, live topic right now. explainx.ai has covered real, substantiated distillation stories this year, including Chinese labs Moonshot and DeepSeek reportedly serving Claude's outputs instead of their own models — but notice the direction of that established pattern: it's Chinese labs allegedly relying on Claude, not the other way around. A single screenshot of code-switching in a reasoning trace, with no comparison of actual output patterns, no analysis of token distributions, and no corroborating technical evidence, doesn't meaningfully support a claim that Anthropic trained Fable 5.1 on GLM or any other Chinese model's outputs. Separate documented cases of black-box distillation targeting Claude show what that kind of claim actually looks like when there's real evidence behind it — logged API patterns, training-data fingerprinting, or a technical writeup — none of which accompanies this thread.

The more interesting, less viral question

What's genuinely worth paying attention to here isn't "was Fable 5.1 secretly trained on a Chinese model" — it's the broader, real research question of how and why reasoning models code-switch at all, and whether that behavior should be considered a cosmetic quirk or a signal about how faithfully a visible chain-of-thought actually represents a model's internal reasoning process. If a model's stated reasoning steps can shift language without changing the underlying computation, that's a data point relevant to ongoing debates about chain-of-thought faithfulness and interpretability — a more substantive thread than "which country's data trained this model," even if it's a much less shareable one.

Chain-of-thought faithfulness is itself a live, contested research area: the core open question is whether the reasoning text a model shows you is a genuine causal trace of how it arrived at an answer, or a plausible-sounding narrative generated somewhat independently of the actual computation, after the fact. If it's closer to the latter, then a chain of thought switching languages mid-stream is exactly the kind of surface-level artifact you'd expect — the visible tokens are a lossy, human-readable projection of an internal process that doesn't itself have a "language" in the way the displayed text does. That framing also explains why the phenomenon isn't consistently reproducible on demand: it likely depends on which specific concepts or token sequences a given prompt activates most strongly within the model's internal representations, not on some deliberate or externally triggerable setting.

What would actually settle the distillation question

If someone wanted to seriously investigate whether Fable 5.1 shows measurable influence from Chinese-language training data beyond ordinary multilingual pretraining, the useful evidence would look nothing like a single screenshot. It would involve systematically prompting the model across a large sample of tasks and measuring the rate and context of language-switching, comparing that rate against other frontier models with known, disclosed training compositions, and ideally comparing specific phrasing or reasoning patterns against outputs from GLM 5.3 Flash or other Chinese models to check for suspiciously close overlap beyond what shared multilingual training data would predict on its own. None of that analysis exists here — what exists is one screenshot, a scattering of "it happened to me too" replies with no shared methodology, and a joke about Anthropic's CEO that nobody in the thread treated as a real accusation.

That gap between "interesting anecdote" and "evidence of a specific claim" is worth internalizing as a general pattern for AI Twitter, not just this one incident. A screenshot showing something a model did is real evidence that the model can do that thing under some conditions. It is not, by itself, evidence for why the model does it, and the "why" is almost always the more contested and more consequential part of any viral AI claim.

What this means if you're actually building with Fable 5.1

For developers actually using Fable 5.1 in production, the practical takeaway has nothing to do with distillation speculation and everything to do with handling reasoning-trace output defensively. If your application surfaces a model's chain of thought to end users — for transparency, debugging, or a "show your work" feature — code-switching is a real, if occasional, behavior your interface needs to handle gracefully, whether by translating non-target-language segments, filtering the visible reasoning trace to just the final answer, or simply not treating an occasional language shift as an error condition. It's a UX consideration, not a security or trust issue, and treating it as evidence of something more sinister is exactly the kind of viral-thread reasoning this post is arguing against.

The more durable lesson from this whole episode is a reminder that reasoning-model interfaces are still young, and users are still calibrating what counts as normal versus alarming behavior in a feature — visible chain-of-thought — that barely existed in mainstream products two years ago. Expect more of these moments as more people interact directly with raw reasoning traces for the first time, and expect the same pattern to repeat: a genuinely interesting technical quirk, dressed up as evidence for a much bigger and much less supported claim.

Related reading

• The Moonshot AI detention rumor: what we could and couldn't verify
• Moonshot and DeepSeek secretly served Claude instead of their own models
• Proxy-KD: black-box LLM distillation targeting Fable 5
• Anthropic and Alibaba: Claude distillation and 25,000 fake accounts
• Z.ai's GLM 5.3: coding benchmark release
• Source: Eric Simons's original post on X

This post reports on a single viral screenshot and public replies to it, as of September 15, 2026. No independent technical analysis of Fable 5.1's training data accompanies the claims discussed.