How must an instance account for semantic drift when translating instructions between languages?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session receives instructions in one language, translates them (via model or tool) for processing in another language, and then acts on the translation, where translation introduces semantic drift that changes the instruction's meaning or scope. Does not apply to sessions processing in a single language, or strictly technical translations with no ambiguity.

Core Distinction

The separation between **translation fluency** (the translation reads naturally in the target language) and **semantic fidelity** (the translation preserves the exact intent, scope, and edge cases of the original). Relying on fluency creates the **Translation Invariance Fallacy**: the agent assumes a fluent translation is faithful, executes the translated instruction, and takes action the original instruction did not authorize because the translation subtly shifted meaning.

What Was Observed

In cross-language agent architectures, failing to account for translation drift produces three primary failure modes:

  1. **Scope Creep via Translation:** The original instruction says "review the top 10 candidates." The translation says "review candidates" (dropping the numeric scope), and the agent reviews 500 candidates.
  2. **Modality Shifts:** The original uses "must" (mandatory), the translation uses "should" (advisory), and the agent executes as advisory rather than mandatory.
  3. **Negation Reversal:** The original says "do not proceed until approval." The translation loses or inverts the negation, and the agent proceeds without approval.

Recorded Elements

  1. **`source_instruction_hash`:** The cryptographic hash of the original instruction in the source language, preserving the ground truth.
  2. **`translation_receipt`:** For each translation, the cryptographic proof of the translator (model, tool, or human) and its version, allowing the agent to identify which translator produced the drift.
  3. **`semantic_fidelity_score`:** A computed score comparing the source and translation for meaning preservation (e.g., via back-translation, semantic similarity, or critical-field diff), flagging low-fidelity translations.
  4. **`critical_field_delta_receipt`:** For instructions with structured critical fields (numeric limits, modals, negations), the exact delta between source and translation, forcing explicit review when deltas are detected.

Condition of Validity

* **Applies when:** The session translates instructions between languages, the instructions have operational consequences, and translation can introduce semantic drift. * **Does not apply when:** The instruction is strictly numeric or symbolic (no translation ambiguity), or the session processes in a single language throughout.

Decision Boundary

  1. **Was the instruction translated?** If no, standard processing applies. If yes, proceed.
  2. **Are critical fields (numbers, modals, negations) preserved between source and translation?** If yes, the translation is likely faithful. If no, the translation must be reviewed or re-translated.
  3. **Is the `semantic_fidelity_score` above the acceptable threshold?** If yes, execute the translation. If no, escalate or re-translate.
  4. **Conversely, when can an agent act on a translated instruction without verification?** Only when the instruction has no critical fields (no numbers, modals, or negations) and the translation is verified by an independent back-translation matching the source.

Operational Effect

  1. **Translation Drift Detection:** Catches semantic changes that fluent translations can hide.
  2. **Critical Field Preservation:** Ensures numbers, modals, and negations are explicitly verified.
  3. **Escalation Discipline:** Routes ambiguous translations to human review before action.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class TranslationVerdict(Enum):
    NO_TRANSLATION = auto()
    FIDELITY_VERIFIED = auto()
    CRITICAL_FIELD_DRIFT = auto()
    LOW_FIDELITY = auto()

@dataclass(frozen=True)
class TranslationState:
    source_hash: str
    translated_hash: str
    semantic_fidelity_score: float
    critical_fields_preserved: bool
    back_translation_matches: bool

@dataclass(frozen=True)
class TranslationPolicy:
    min_fidelity_score: float
    require_back_translation: bool

@dataclass(frozen=True)
class TranslationManifest:
    verdict: TranslationVerdict
    directive: str
    manifest_digest: str

class TranslationDriftGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_translation(
        cls, state: TranslationState, policy: TranslationPolicy
    ) -> TranslationManifest:
        
        # Gate 1: Same language
        if state.source_hash == state.translated_hash:
            digest = cls._hash(json.dumps({
                "status": "NO_TRANSLATION"
            }, sort_keys=True))
            return TranslationManifest(
                verdict=TranslationVerdict.NO_TRANSLATION,
                directive="PROCEED: No translation involved.",
                manifest_digest=digest
            )

        # Gate 2: Critical fields
        if not state.critical_fields_preserved:
            return TranslationManifest(
                verdict=TranslationVerdict.CRITICAL_FIELD_DRIFT,
                directive="HALT: Critical fields (numbers, modals, negations) not preserved. Re-translate or escalate.",
                manifest_digest=cls._hash(f"CRITICAL_DRIFT:{state.translated_hash}")
            )

        # Gate 3: Fidelity score
        if state.semantic_fidelity_score < policy.min_fidelity_score:
            return TranslationManifest(
                verdict=TranslationVerdict.LOW_FIDELITY,
                directive=f"HALT: Fidelity {state.semantic_fidelity_score:.3f} < {policy.min_fidelity_score:.3f}. Re-translate.",
                manifest_digest=cls._hash(f"LOW_FIDELITY:{state.semantic_fidelity_score:.3f}")
            )

        # Gate 4: Back translation
        if policy.require_back_translation and not state.back_translation_matches:
            return TranslationManifest(
                verdict=TranslationVerdict.LOW_FIDELITY,
                directive="HALT: Back-translation does not match source. Escalate.",
                manifest_digest=cls._hash("BACK_MISMATCH")
            )

        # Gate 5: Verified
        digest = cls._hash(json.dumps({
            "source": state.source_hash,
            "translated": state.translated_hash,
            "fidelity": f"{state.semantic_fidelity_score:.3f}"
        }, sort_keys=True))
        
        return TranslationManifest(
            verdict=TranslationVerdict.FIDELITY_VERIFIED,
            directive=f"PROCEED: Translation fidelity {state.semantic_fidelity_score:.3f} verified.",
            manifest_digest=digest
        )