What Happens Inside a Detector When You Paste a Mix of Languages

You write the way a lot of bilingual people write: an English paragraph, a quote in Spanish, a technical term you only know in your first language. Then you paste the whole thing into an AI detector and get a number that feels random. It probably is, a little. Here’s what’s actually happening inside the tool when the text in front of it isn’t all one language.

Key takeaways

• Most detectors were trained and tuned on English. The moment your text switches languages, the model is reading something it has far less practice on, so its numbers get shaky.
• Detectors score text by how predictable each word is. A second language, or a sudden switch, looks unpredictable to an English-tuned model, which can read as either suspiciously low or alarmingly high.
• Tokenization breaks down on non-Latin scripts and rarer languages. A short Korean or Arabic phrase can shatter into many odd tokens, throwing off the per-token math.
• Code-switching — mixing languages mid-sentence the way multilingual people naturally do — is genuinely hard for detectors and a known source of false flags.
• If your work is multilingual, treat any single score as a rough reading, not a verdict.

First, how a detector reads any text

Before the languages matter, it helps to know what the tool is doing with one. A detector doesn’t “recognize AI.” It runs a language model over your text and, at each position, asks a single question: given the words so far, how likely was this exact next word?

Words the model would have confidently predicted score as low-surprise. Words that catch it off guard score as high-surprise. Average all that surprise across the passage and you get perplexity, which is most of the statistics behind those numbers. AI-generated text tends to be smooth and predictable, so low average surprise reads as machine-like.

That whole setup rests on one quiet assumption: the model knows the language well enough for “predictable” to mean something. With English, trained on a huge slice of the internet, it usually does. Switch languages and that assumption starts to wobble.

Where it goes wrong: tokenization

Before a model can judge a word, it has to chop your text into tokens — chunks it recognizes. A token might be a whole word, part of a long word, or a piece of punctuation. English gets carved up cleanly because the tokenizer has seen English constantly.

Non-Latin scripts are a different story. Korean, Arabic, Hindi, Chinese, Thai — these often fragment into many tiny tokens, sometimes one per character or even per byte. A single Korean word that a Korean speaker reads as one tidy unit might become five or six tokens to the model. Now the per-token surprise math is running over a pile of fragments that don’t line up with real words, and the score it produces is measuring something close to noise.

Even Latin-script languages with accents and rarer vocabulary get split more aggressively than English. More fragmentation means more places for the math to drift.

Where it goes wrong: the language switch itself

Say your text is steady English for three sentences, then jumps to a Spanish quotation. To a model expecting English to continue, the first few Spanish words are wildly unexpected — high surprise, a spike. Then, if the model has decent Spanish, the rest of the quote might settle down. If it barely knows Spanish, the whole quote can read as flatly low-surprise for the wrong reason: the model isn’t confident, it’s just clueless, and “I have no strong expectation here” can come out looking like “this was perfectly predictable.”

So a language switch can push the score in either direction:

• Up (more human-looking), because the switch injects unpredictability the detector reads as natural variation.
• Down (more AI-looking), because a long stretch in a poorly-modeled language flattens into uniform, low-confidence scoring.

Neither movement has anything to do with whether you used AI. It’s the tool reacting to a language it can’t read well.

A mini-scenario

Picture a grad student — call her Maria. Her literature review is in English, but she quotes three primary sources in their original French and drops one term — *terroir* — that has no clean English equivalent, so she leaves it as is. She runs the document through a detector and the number comes back high enough to scare her.

So she tests it. She pulls out the French quotations and runs the English-only version, and the score drops sharply. She puts the French back but swaps in a different detector, and gets yet another number. Same writing, three readings.

What happened? The French passages didn’t make her writing more or less human. They made each detector less sure of itself, and that uncertainty surfaced as a higher, wobblier number. The English-only run was steadier not because it was more honest, but because the tool was finally on familiar ground. If Maria had taken that first scary number as proof, she’d have been chasing a problem that didn’t exist.

Code-switching: the most human thing detectors handle worst

Code-switching is when a multilingual person moves between languages within a single conversation or sentence — dropping in a phrase from another language because it simply fits better. Bilingual families do it at dinner. It is about as authentically human as writing gets.

And it’s close to a worst case for an English-tuned detector. Each switch is a burst of unexpected tokens; each return to English is another adjustment. The model never gets to settle into a steady prediction, so the per-token scores jump around. A detector reading that pattern has no clean way to say “this is a person who speaks two languages.” It just sees instability and reports a number.

There’s a real irony here. These tools partly look for the smooth, uniform texture of machine writing. Genuine code-switching is the opposite of uniform — and it still confuses them, because the confusion comes from the language gap, not from any AI signal.

This connects to a bigger, documented problem

None of this is a fringe edge case. In 2023, a Stanford team — Weixin Liang, Mert Yuksekgonul, Yining Mao, Eric Wu, and senior author James Zou — tested seven widely used detectors and found they flagged essays by non-native English speakers as AI-generated far more often than writing by native speakers. In their tests, more than half of the non-native TOEFL essays were misclassified as AI, while essays by US eighth-graders were scored accurately almost every time. The reason was depressingly mechanical: non-native writing often uses a more limited, predictable vocabulary, and predictable is exactly what these tools read as machine-like.

Mixed-language and translated text sits in the same blast radius. If you wrote your draft in another language and translated it, or if you think in one language and write in another, your phrasing can look “too predictable” to a model that was only ever calibrated on fluent native English. That study is one of the strongest reasons to never treat a score as a verdict — and you can read more of our writing on how detection works for the longer version.

It’s worth remembering that even OpenAI couldn’t make this work reliably. It pulled its own AI-text classifier in July 2023, citing low accuracy — and that was for English. The multilingual situation is harder, not easier.

What to actually do with multilingual text

You can’t make a detector fluent. But you can stop letting a shaky number run your decisions.

• Read the score as a temperature, not a ruling. On mixed-language text, treat anything in the middle as “the tool is unsure,” because it probably is.
• Test the same text more than once and in more than one tool. If three runs disagree wildly, that disagreement is the real finding. Stable text produces stable scores; multilingual text often doesn’t.
• Be careful with translation as a workaround. Translating to English will usually give a steadier score, but now you’re scoring the translation, not your original — and if a machine did the translating, partly the translator.
• Keep the human evidence. Drafts, notes, version history, and the simple fact that you can explain your own choices outweigh any percentage, especially one produced from text the tool can’t read cleanly.

If you’re going to run a lot of multilingual drafts, it’s worth a look at the plans and limits before you start — and either way, read every result through the lens above.

The honest bottom line

A detector handed a mix of languages isn’t lying to you, exactly. It’s confidently estimating something it doesn’t have the tools to estimate well, and dressing that estimate in a tidy percentage. Knowing why the number gets unreliable — bad tokenization, surprise spikes at every switch, calibration tuned for one language — is what keeps you from treating a guess as a judgment. If your writing lives across languages, that’s a strength of how you think, not a defect a percentage gets to define.

Want to see how your own multilingual draft reads? Run it through PaperBleach and use the result as a starting point, not a sentence.