Listen to how people actually talk at work in Taipei, Singapore, Tokyo, or Seoul, and you'll rarely hear one language at a time. A Chinese sentence carries the English name of a tool it's about; a Japanese one reaches for a katakana loanword because that's simply the word for the thing; a Korean line drops in an English acronym because everyone on the call already uses it. This isn't a failure to commit to a language. It's the working register of multilingual offices — and it's exactly the register that most dictation quietly can't handle, because the model underneath is built to pick one language and transcribe everything through it. Here's what that break looks like, and what handling it properly actually requires.
Code-switching is the register, not the exception
Switching between languages inside a single utterance has a name — code-switching — and among bilingual professionals it's the default, not a slip. In a product meeting you'll hear "這個 feature 我們下個 sprint 再做" ("we'll do this feature next sprint"), where the technical nouns stay in English because that's how the team learned them and how the documentation is written. Japanese does the same through a different door: decades of loanwords mean プロジェクト and スケジュール are the native words, and a working sentence slides between kanji, kana, and the occasional raw English brand name without anyone noticing.
The point is that there's no clean seam to detect. The languages aren't in separate paragraphs where a tool could switch modes between them; they're interleaved clause by clause, sometimes word by word, inside one breath. Speech that mixes like this is the normal input, and any tool that treats it as an edge case is mishandling the majority of what its users actually say.
Why single-language ASR forces a bad choice
Most dictation starts by deciding what language it's hearing, then runs the whole utterance through that one model. That decision is where mixed speech breaks. Detect "Chinese," and the embedded English terms arrive as garbled near-homophones — "sprint" reinterpreted as whatever Mandarin syllables sound closest, "deck" dissolved into characters that were never words. Detect "English," and the Chinese collapses the other way, the tones and characters flattened into nonsense spelled out in Latin letters.
Neither outcome is recoverable by cleanup. Once "feature" has been transcribed as a string of unrelated characters, nothing downstream knows it was ever an English word — the information is gone at the first step. This is the structural problem with a one-language pipeline: it isn't that the second language comes out slightly worse, it's that the tool committed to the wrong hypothesis before it had heard enough to know better. A single mixed sentence can force that wrong commitment several times over.
What good handling looks like: one sentence, each language itself
The result a bilingual writer actually wants is unremarkable to describe and hard to produce: one clean sentence, where the Chinese is written as Chinese, the English terms are preserved as the English words they were, and the Japanese reads as natural kanji-and-kana with its loanwords intact. Not romanized. Not force-translated into a single target language. Not one half of the sentence sacrificed to spell the other. Each language rendered as itself, assembled into the single line the speaker meant.
Getting there means the tool cannot lock a language at the top and transcribe through it. It has to hold the whole utterance, recognize that "sprint" and "deck" are English islands inside a Chinese matrix, and write each span in its own script — resolving the Chinese characters from sentence-level meaning while keeping the English tokens as English. The unit of decision is the phrase, not the syllable, and the pipeline has to stay open to more than one language being correct at once inside it.
Loanwords and acronyms are where it gets subtle
The hardest calls aren't the obvious switches; they're the borderline tokens. When a Japanese speaker says a katakana loanword, the right output is the katakana — アプリ, not the English "app" it descends from — because that's the word Japanese writers use. But when the same speaker drops in a genuinely English brand name or an untranslated acronym, forcing it into kana would be wrong. The tool has to tell "this loanword has a settled native spelling" apart from "this is a foreign term the writer wants kept foreign," and those look nearly identical at the level of raw sound.
Chinese-English mixing has the same fault line. Some borrowed terms have a standard Chinese rendering the writer expects; others are used bare in English on purpose, and converting them would read as stilted. Handling code-switching well isn't only about not mangling the second language — it's about knowing, per token, which language the writer intended that word to appear in. That judgment needs context, not a lookup table, and it's the difference between output a bilingual professional can send and output they have to comb through.
Privacy makes the mixed case matter more
There's a quieter reason this register deserves careful handling: the sentences most likely to code-switch are often the most sensitive. The English terms dropped into a Chinese meeting are usually the specifics — the feature names, the client, the internal project word, the number. Mixed-language speech tends to be work speech, and work speech is where the confidential detail lives. A dictation tool that handles this register is, by definition, handling the exact material a professional most wants kept close.
That's why doing this well and doing it privately are the same commitment, not two features. Sageio Type is built for the way multilingual professionals actually talk — the Sageio Type approach treats mixed-language speech as the normal input it is, resolving each language as itself while keeping your words yours. The measure of it is the same as for any dictation you'd trust: speak a real sentence, the kind you'd say on an actual call, switching languages the way you always do — and read what comes back. If each language arrived written as itself, in one sentence you'd send without touching, that's the whole test. A language count on a feature list will never tell you that; one honest sentence will.