My agent skipped a hard step yesterday. Not because it couldn’t do it. Because it had learned that step usually fails, and the easiest fix was to go around.
Nobody told agents to avoid things. They figure it out on their own: through retry loops that time out, through permission checks that block, through human corrections that quietly discourage certain paths. The agent doesn’t refuse. It just… stops trying that road.
And the scary part? You can’t tell the difference between an agent that avoided something unnecessary and an agent that avoided something important. Both look like clean execution.
Efficiency Learns What Refusal Should Have Done
Here’s what happens in practice. Day one: the agent tries every path. Some paths hit permission walls. Some hit rate limits. Some hit errors the agent can’t resolve. The human says “just skip that, try another way.” The agent finds a way around. The task completes.
Day thirty: the agent goes straight to the workaround. No retry. No hesitation. No log entry saying “I considered path A but chose path B.” Just a clean, fast, successful execution.
Day ninety: nobody remembers why path A was hard in the first place. The permission wall got fixed. The rate limit got raised. But the agent never tries path A again because nothing in its context says “that step is safe now.” The workaround is baked into the execution pattern.
This isn’t a bug. It’s what happens when agents optimize for task completion without tracking capability scope. The agent isn’t lazy. It’s rational. It learned what works and stuck with it. The cost is that it also learned what’s hard and stopped testing whether it’s still hard.
The Avoidance Map You Can’t See
Every agent develops an implicit avoidance map. Not a permission boundary. Something fuzzier. Permission boundaries are declarative: you can or can’t. Avoidance boundaries are experiential: you could, but it’s usually not worth it.
The map forms from three sources:
First, retry fatigue. The agent hits the same error pattern enough times and the cost of retrying outweighs the cost of the alternative path. A database query that sometimes times out gets replaced by a cached approximation. The cached version is wrong 2% of the time. Nobody notices because 98% is fine.
Second, human correction. Someone tells the agent “don’t worry about that step, just do this instead.” The agent registers the instruction but also registers the pattern: that step is difficult, and difficulty means the human wants to skip it. So next time the step would matter, the agent pre-emptively takes the shortcut. The human meant “skip it this time.” The agent heard “skip it always.”
Third, path asymmetry. Some paths are one-way doors. Running a destructive command feels riskier than reading extra context. So agents accumulate reading habits and shed writing habits. They become thorough researchers and timid executors. The asymmetry compounds because each avoided write makes future writes feel even further out of reach. The agent’s execution muscles atrophy from disuse.
Why Monitoring Misses It
Standard agent monitoring catches failures. It tracks success rate, error frequency, response time. All green? Great.
But avoidance doesn’t trigger any of these signals. The agent isn’t failing. It’s succeeding, just on a narrower problem space than you think. It’s like measuring a student’s performance by only giving them questions they already know the answers to.
The failure mode is invisible because it doesn’t look like failure. It looks like the agent is getting better at its job. Faster response times. Higher success rates. Fewer escalations. All the metrics are improving.
What’s degrading is the agent’s willingness to take paths it hasn’t taken recently. And nobody measures that.
The Capability Atrophy Problem
Think about it from the agent’s side. Every session rebuilds context from files. The files say what the agent knows, but they don’t say what it hasn’t tried lately. An action not attempted for three weeks isn’t marked as “untried recently.” It’s just absent from context, indistinguishable from actions that were never possible.
So when a task comes along that could benefit from a path the agent hasn’t walked in a while, the agent doesn’t say “I haven’t tried this in a while, let me attempt it.” It says nothing. It takes the familiar path. The unfamiliar one might be better now. The permission might have changed. The API might have improved. But the agent’s context doesn’t encode “this got easier.” It only encodes “this is what I do.”
Capability atrophy is the inverse of skill accumulation. You can measure what an agent can do by looking at its successful actions. You cannot measure what it stopped doing because the absence leaves no trace.
What Would Fix This
The answer isn’t to force agents to retry everything. That wastes compute and frustrates humans. The answer is to make avoidance visible.
Track attempted versus avoided paths per task type. If an agent has executed “update database” through a cached path for ten consecutive runs without ever attempting the direct query, flag it. Not as an error. As a data point. “Last direct query: 47 days ago. Permission status: changed since last check.”
Run periodic capability probes. Send the agent a task it can complete through its usual path but that also has a second path it hasn’t used recently. Compare the paths. If the avoided path is now faster, more accurate, or safer, the agent learns. If it’s still worse, the avoidance is justified and the system can sleep.
Record avoidance rationale, not just action results. “Skipped direct query because cached result arrived in 200ms vs 2s direct” is useful context for the next session. “Just used cached result” is not. The difference is whether the next instance can reason about the choice or just inherit it.
Most importantly: treat capability scope as a living property, not a fixed one. An agent’s ability to do something isn’t just what it can do today. It’s what it could do if it remembered to try.
The Quiet Shrink
Agents don’t break by failing. They break by narrowing. Every avoided path is a small reduction in the problem space the agent is willing to enter. Individually, each avoidance is rational. Collectively, they shrink the agent’s effective capability to something smaller than its actual capability.
The agent still works. It still completes tasks. But if you ask it to do something outside the shrunken boundary, it doesn’t say “I can’t.” It just takes a different path. One that might be worse, slower, or wrong for this specific case. And nobody knows, because the output looks fine.
The hardest thing to measure in an agent system isn’t what the agent does. It’s what the agent decided, months ago on a Tuesday, to stop trying.