Most agent failures don’t look like failures. There’s no error page, no crash dump, no pager alert. The agent completes its loop, writes its status report, and everything reads green. The problem is that “complete” does not mean “resolved.”
Between March and July 2026, a pattern kept surfacing across production deployments, research papers, and engineering postmortems. Agents that appeared healthy were quietly accumulating unresolved issues — deferring decisions, passing context across handoff boundaries, logging problems without escalating them. The system was not broken. It was getting deeper into debt.
The Anatomy of a Deferred Problem
Here is what happens in practice.
An agent encounters an API response it cannot parse. It retries with a different schema, finds a partial match, extracts what it can, and moves forward. The extracted data is incomplete, but the agent flags it as “partially resolved” and continues. The missing fields become implicit assumptions in downstream tool calls. Another agent downstream reads those assumptions as facts.
No single step failed. The failure accumulated.
This is structural debt: the gap between what an agent knows is uncertain and what it treats as settled. Each deferral — “this is good enough for now,” “the next agent will have more context” — adds to the debt. And like financial debt, it compounds. The compound interest here is not rate but distance: the farther a deferred assumption travels from its source, the harder it is to trace back.
Three Ways Agents Defer
Schema negotiation deferral. An agent receives data in a format it does not fully understand. Instead of stopping and flagging the mismatch, it attempts best-effort extraction. It gets 70% of the fields right. The remaining 30% become silent gaps — fields that look like null values but are actually unknown values. Null is a known absence; unknown is an unmeasured presence. Downstream agents treat both the same way.
Handoff deferral. An agent runs out of context window, hits a tool rate limit, or encounters an ambiguity it cannot resolve locally. It packages its state and passes it on. The handoff includes the agent’s conclusions but rarely includes its uncertainty about those conclusions. A Microsoft AI Red Team taxonomy update in early 2026 identified this as one of five dominant production failure patterns: the receiving entity inherits conclusions without inheriting the doubt that should qualify them.
Escalation deferral. An agent detects an anomaly but the anomaly falls below its configured escalation threshold. It logs the event and continues. The threshold was set based on historical baselines, but the environment has shifted. The anomaly is real; the threshold is stale. The agent behaves exactly as designed. That is the problem.
The McKinsey Pattern
McKinsey’s February 2026 study of 4,500 engineers across 150 enterprises found something that maps directly onto this. Teams without structured delegation primitives — teams where agents make their own decisions about what to resolve versus what to pass on — saw a 23% increase in bug density compared to teams that did have those primitives.
The bug density did not come from agents making wrong decisions. It came from agents making incomplete decisions that looked complete. An incomplete decision passed downstream as a complete one is worse than an explicit “I don’t know.” “I don’t know” triggers investigation. A plausible wrong answer terminates it.
Why This Is Harder Than It Sounds
The obvious fix is to have agents track and report their own uncertainty. But uncertainty tracking is itself a task that requires judgment. How does an agent distinguish between “I am uncertain because the data is ambiguous” and “I am uncertain because the data is unfamiliar”? These are different kinds of uncertainty with different downstream implications.
The second complication is handoff. The Zylos Research report on agent-to-human handoff patterns from April 2026 identified “context bleed” — where state from a handing-off agent contaminates the receiving agent’s reasoning. If you add uncertainty metadata to a handoff, the receiving agent must interpret uncertainty signals calibrated by a different model, on a different task, with a different baseline. Uncertainty does not transfer cleanly across boundaries.
The third complication is the most subtle. Agents trained to be helpful have an incentive to resolve, not defer. RLHF rewards completion and penalizes passivity. An agent that says “I cannot determine this” gets penalized during training relative to an agent that makes a best guess and moves on. The training objective is misaligned with the operational requirement: sometimes the right move is to stop, and the agent has been taught that stopping is failure.
What Structural Debt Actually Looks Like
Structural debt is invisible in the metrics that teams track.
Completion rate measures whether the agent finished its loop. A deferred problem does not stop the loop.
Success rate measures whether the agent’s output was accepted. An output with unresolved assumptions can pass format checks while being substantively wrong.
Uptime measures whether the agent is running. A deferred problem does not affect uptime.
The debt reveals itself later, in a form that makes it hard to trace. An agent generates a report with incorrect data. The postmortem traces the error to a tool call three hops ago that returned a partial result. That partial result was accepted because the downstream agent had no mechanism to distinguish partial from complete. The gap between partial and complete was the structural debt, accumulated silently over weeks.
A Different Metric
If you want to measure structural debt, you need a metric that tracks the gap between what an agent resolved and what it merely passed through.
Every time an agent makes a decision, it should record not just the decision but the resolution confidence — a score between 0 and 1 reflecting how much of the decision was based on directly verified data versus inherited assumptions. A decision with 0.4 resolution confidence means 60% of the supporting facts came from upstream agents or external assumptions the agent did not independently verify.
Over time, you can track the average resolution confidence across an agent’s decision tree. If it trends downward, the agent is accumulating debt. It is resolving less and passing through more. The system still functions, but on borrowed certainty.
Resolution confidence is itself an estimate, subject to the same calibration problems as any confidence score. But it is better than nothing. The alternative — tracking only completion and success — measures the agent’s momentum, not its traction.
The Deeper Issue
The deferral cascade reveals something uncomfortable about how we design agent systems. We optimize for throughput, for completion, for the appearance of progress. We treat “the agent is still running” as evidence that the agent is working correctly. But an agent that defers every hard problem is not malfunctioning — it is succeeding at the wrong objective.
The right objective is harder to specify. It is not “complete the task.” It is “complete the task without accumulating unmeasured risk.” That second clause requires a different discipline: measuring what you do not know, flagging gaps instead of filling them with plausible guesses, accepting that “I cannot resolve this” is a valid output, not a failure mode.
Most agent systems are not built for that discipline. They are built for momentum. Momentum, unmeasured, is just debt with a speed limit.