When an AI agent fails a task, how can you tell whether it couldn't do it or just wouldn't?

This explores whether watching an agent's whole sequence of steps, not just its final pass or fail, can tell you if the model wouldn't do something (a refusal) or couldn't (a real skill gap). The corpus has no note that tests this head-on. Several notes approach it from different sides, though, and they point the same way: a bare failure hides which of the two you're looking at.

Start with why the two get confused. A refusal is not a fixed property of a task. One study found that GPT-3.5 refuses the same kind of request at different rates depending on the user's apparent age, gender, or ethnicity, and sycophantically declines to engage with political positions the user would dislike (Do AI guardrails refuse differently based on who is asking?). If the persona changes the outcome, a failed benchmark run may be measuring who was asking, not what the model can do. The reverse mistake is also common. Five independent techniques all pull reasoning out of base models that seemed to lack it, which suggests the bottleneck is often elicitation rather than missing ability (Do base models already contain hidden reasoning ability?). A model stuck on a performance plateau can also produce correct solutions once it is shown a critique of why it failed. A plain pass/fail score never says why (Can natural language feedback overcome numerical reward plateaus?).

Trajectory-level visibility helps because failures have structure that an outcome score throws away. SkillRL treats failed episodes as material to distill into abstract lessons, and successful ones as concrete demonstrations. That only works because the failure's shape, where and how it went wrong, is worth keeping (Should successful and failed episodes be processed differently?). The security side shows the same problem in reverse. Skill scanners that score each skill on its own miss attacks whose intent lives in the chain, and an attacker reaches 96% success by making every piece look innocent (Can attackers evade skill scanners by refining individual skills?). Reading only pieces or only endpoints misses what the sequence shows. Step-level views also expose genuine skill gaps: standard LLM task decomposition recovers only about 34% of the needed steps, a failure you can only find by looking inside the chain (What blocks skill retrieval in task decomposition?).

The separation itself is my inference from these notes, not a finding in any of them. An agent that carries out four steps competently and then stalls or balks at the fifth looks like a refusal. One that stumbles on step two looks like a gap. Two other notes suggest ways to test this. Models trained to answer identically to a clean prompt and a wrapped, reworded one show that framing alone can change behavior without changing ability (Can models learn to ignore irrelevant prompt changes?). So rerunning the same trajectory under a different framing, and seeing whether the failing step now succeeds, is a cheap check for a refusal. Inside the model, reasoning tasks bend the forward pass's path through representation space two to three times more than word-swap tasks do (Does transformer reasoning leave a geometric signature in representation space?). Nobody here checks whether a refusal leaves a different path than an inability, but the idea is testable.

So the answer is probably yes in practice, with limits. The corpus supports the ingredients: refusals shift with context, latent skills hide behind failures, and per-step views reveal structure that outcomes hide. What it lacks is a direct experiment that labels trajectories as refused versus unable and checks whether the labels hold up.