Asking the Same Question in English and Chinese on One Key: Where Translation Drift Enters the Answer

Why the same question in two languages can yield different answers

When you send the same query in English and Chinese through a single API key to multiple model backends, you may notice subtle differences in the facts or emphasis of the responses. This phenomenon, translation drift, arises because each model handles language differently at three stages: tokenization, system prompting, and decoding. Understanding these stages helps you design prompts and validation that keep your bilingual app consistent.

Tokenization: where the input diverges

Tokenizers split text into subword units. Chinese and English have different tokenization behaviors:

• English words are often split into whole words or common subwords, while Chinese characters may be tokenized individually or in pairs, depending on the model's vocabulary.
• This affects the number of tokens and how the model perceives word boundaries, which can influence attention and the model's internal representation of the query.
• Some models use a shared tokenizer for both languages, while others have language-specific tokenizers or additional preprocessing.

Because tokenization affects the model's input, the same semantic content can be represented differently, leading to variations in the generated answer.

System prompts: instructions that shape the response

System prompts set the context and constraints for the model. When you use the same system prompt for both languages, the model must interpret it in the context of the user's language. This can cause:

• Ambiguity if the system prompt is only in one language; the model may follow it differently when the user query is in another language.
• Cultural or linguistic biases embedded in the system prompt that affect how the model prioritizes information.
• Inconsistent adherence to formatting or style instructions across languages.

To reduce drift, consider language-agnostic system prompts or explicitly instruct the model to maintain factual consistency regardless of the user's language.

Decoding: how the output is generated

Decoding strategies (e.g., greedy, sampling with temperature) influence the variability of responses. Even with identical inputs, different decoding parameters can lead to different outputs. When comparing across languages:

• The model's probability distribution over the next token may differ because the context (including tokenization and system prompt) is different.
• Some models may have language-specific decoding behaviors or biases.
• The length and structure of the answer can vary due to differences in common phrasing or cultural expectations.

A side-by-side probe across six backends

To understand how each backend handles bilingual queries, run a controlled probe:

1. Select a set of factual questions that have unambiguous answers (e.g., "What is the capital of France?").
2. For each question, prepare an English version and a Chinese version that are direct translations.
3. Use the same system prompt (preferably language-agnostic) and decoding parameters (e.g., temperature=0) for all calls.
4. Send both versions to each of the six backends (Claude, GPT, DeepSeek, Qwen, GLM, Kimi) using your single API key.
5. Compare the factual content of the responses, not the wording.

Record where answers diverge in facts, not just phrasing. This will reveal backend-specific tendencies.

Forcing agreement on facts despite wording differences

To ensure your bilingual app gives consistent factual answers, adopt these strategies:

• Use a language-agnostic system prompt: Write instructions that explicitly state the assistant should provide factual answers regardless of the user's language, and avoid language-specific idioms.
• Normalize the query: Before sending to the model, translate the user query into a pivot language (e.g., English) and include both the original and translated query in the prompt, asking the model to answer based on the pivot.
• Post-process for facts: Extract factual claims from responses (e.g., using a secondary model or rule-based method) and compare them across languages. If discrepancies arise, re-query with a clarification or fallback to a default language.
• Set decoding to deterministic: Use temperature=0 and top-p=1 to minimize randomness.
• Validate with a cross-lingual consistency check: For critical facts, ask the model to confirm the answer in both languages within the same session and flag inconsistencies.

Practical implementation with a single API key

Our platform lets you access all six backends with one API key, topping up with USDC on Base without KYC. You pay the official price times 1.3, and key contributors are credited official price times 1.1 (or 1.2 for premium) in USDC. This makes it cost-effective to run bilingual probes across multiple models.

When implementing, keep in mind:

• Use the same system prompt and decoding parameters across languages.
• Log both queries and responses for analysis.
• Consider caching responses to reduce costs during experimentation.

By understanding where translation drift enters, you can design your app to deliver consistent facts, no matter the language.