AI Agent Failure Modes: Classify Each Error Before You Fix It
A practical taxonomy for AI agent failures: classify each error by cause (input, context, reasoning, tool, authority or process) before choosing a fix.

An AI agent failure is any run where the outcome misses the job's success criterion, whether the error is visible to a customer or hidden in a record. The most useful first step is to classify each failure by cause (input, context, reasoning, tool, authority or process) before anyone edits a prompt, switches a model or changes a permission. Teams that skip this step usually fix the symptom they saw, and the same failure returns in a different form.
Key takeaways
- Give every failure one primary cause from a short, fixed list before choosing a fix.
- Many errors that look like prompt problems are really input, context, tool or authority problems.
- Silent failures need their own checks, because nothing in the interface reports them.
- Write the cause into the same record as the outcome so patterns become visible over weeks, not guesses.
- Change the earliest layer that was wrong, not the layer that was easiest to edit.
What counts as an agent failure?
A failure is a gap between what the job required and what the agent produced or did. Visible failures are the easy kind: an error message, a refusal, a reply sent to the wrong person. Silent failures are harder to catch: a task marked complete with a wrong total, a record updated from stale data, or a draft that reads well but ignores the policy that applies. A useful taxonomy has to cover both, because the cause determines the fix and the loudness of the failure does not.
The unit of analysis should be one run of one task. For each run, keep the input, the memory or documents the agent used, every tool call with its arguments and responses, the output, and the final status. Without that record, classification turns into opinion. The silent failure detection approach relies on the same record, because you cannot check a quiet error you did not capture.
The NIST AI Risk Management Framework organizes AI risk work into govern, map, measure and manage functions. A failure taxonomy is a small, practical piece of the measure and manage work: it tells you where risk actually shows up in your operation.
Six causes that cover most agent failures
Most failures fit one of six causes. The list is short on purpose, so that two people reviewing the same run reach the same label.
- Input: the request was incomplete, malformed, ambiguous, or in a format the agent was not set up to read. Example: a scanned document with a missing page.
- Context: the agent held the wrong, stale or missing information, whether from memory, retrieved documents or earlier messages.
- Reasoning: the input and context were correct, but the model drew a wrong conclusion, skipped a step or misapplied a rule.
- Tool: an external system failed, timed out or returned unexpected data, or the agent called it with wrong arguments.
- Authority: the agent acted beyond what it was allowed to do, or was blocked from an action it should have been able to take.
- Process: the task was poorly defined, with no clear success criterion, conflicting instructions, or no defined handoff to a person.
Two rules keep the labels consistent. First, assign the earliest layer in the chain that was wrong. If the tool returned a wrong price and the agent then wrote a correct sentence about it, the primary cause is tool. Second, when two causes genuinely apply, record both and mark the first as primary. The secondary cause often points to a control you still need.
How do you classify a failure step by step?
Run the checks in this order. The order matters because reasoning is the label people reach for first and the one that is most often assigned too early.
- Step 1: Pull the full run record, not only the final message. If the record is missing parts, note that gap as an observability problem before classifying.
- Step 2: Compare the input with what the task expects. If the input was already wrong or incomplete, classify as input and stop.
- Step 3: Compare the context the agent used with the source of truth. A stale price table or a memory note about an old policy is a context failure, even when the reasoning looked sound.
- Step 4: Replay the tool calls. Confirm the external system returned what the agent reported. If the system timed out, returned an error the agent ignored, or received wrong arguments, the cause is tool. Your retry policy should define what the agent does in each of those cases.
- Step 5: Check the permission record. Did the agent attempt something outside its scope, or was it blocked from something it was meant to do? Either is an authority failure.
- Step 6: Only when steps 1 to 5 do not explain the error, classify as reasoning. Then look at the instructions and examples the agent was given.
- Step 7: Ask whether a competent person reading the task could have produced a correct result from it. If two reviewers would disagree on the right output, classify as process.
Write the label, the primary cause, any secondary cause and one sentence of evidence. That sentence is what makes the record useful to someone who was not in the review.
Which fix follows each cause?
The value of classification is that it narrows the fix. Each cause points to a different layer, and changing the wrong layer rarely removes the error.
- Input: tighten intake rules, add a format check, or have the agent ask one clarifying question before it starts. Leave the reasoning instructions alone.
- Context: correct the source document, narrow the retrieval scope, or remove the outdated memory note. Confirm the change in the next run record.
- Reasoning: add a clearer rule, a worked example, or a failing case to the evaluation set, then rerun those cases. Changing the model is a later option, not the first move.
- Tool: fix the integration, set timeouts, and make writes safe to repeat. Anthropic's guidance on building effective agents favors simple, well-defined tools, and a tool with unclear behavior often produces failures that look like reasoning errors.
- Authority: review the grant. Narrow it if it was too broad, or add an approval step for consequential actions. Do not widen permissions to clear an error.
- Process: rewrite the success criterion, name who decides edge cases, and define the handoff to a person. A human escalation rule should send the decision, not the raw mess.
What does a classified failure look like? (Illustrative scenario)
This is an illustrative scenario, not a report of a real case. A sales operations team uses an agent to draft quotes from a request form and a price table. One quote goes out with a discount that does not match the approved list.
The form was complete, so the input is not the problem. The price lookup returned the current value, so the tool is not the cause. The agent's memory still held an discount table from an earlier quarter, so the primary cause is context. The agent also had permission to send quotes without review, which is a secondary authority issue because it let the wrong number reach a customer.
The fix follows the order. First, the agent reads discounts only from the system of record, and the stale memory note is removed. Second, quotes above an agreed discount level go to a person for approval. The record now shows one primary cause, one secondary cause, and a control that would catch the next error even if the context fails again.
How does a managed approach keep the classification reliable?
In Be Human's managed model, each agent runs with an operating record that captures inputs, memory references, tool calls, permission checks and outcomes, so the cause can be read from the run instead of reconstructed from memory. Monitoring and recurring evaluations look for silent failures that no one reported, and permission reviews check whether each agent's authority still matches its role. Changes go through controlled improvements that name the cause they address, so the team can see whether a fix moved the layer it was meant to move. The details of what to capture are covered in what to log for AI agent observability.
Where should a team start?
Pick one agent that already has real work and write down its last ten failures, even if they were minor. Classify each one with the six causes and the steps above, then look for the cause that appears most often and the fix that would have prevented the most errors. That single change is usually a better first project than a broad rewrite. If you are not sure which task is worth handing to an agent in the first place, take the free Be Human AI diagnostic to find the first task worth handing to an agent.
Frequently asked questions
How is a failure taxonomy different from a bug list? A bug list records what went wrong, while a taxonomy records why it went wrong in a fixed vocabulary. The fixed vocabulary lets different people classify the same run the same way, which is what makes trends visible. A bug list can grow indefinitely, but a taxonomy with six causes stays small enough to use every day.
Can one failure have more than one cause? Yes, and the method handles it by asking for a primary cause and, where it applies, a secondary one. The primary cause is the earliest layer in the chain that was wrong, and it determines the first fix. The secondary cause is often a missing control, such as an approval step, that would have contained the damage.
Who should classify failures? The person who owns the agent's outcomes should review each classification, because they can judge whether the business impact and the cause are right. Engineers or operators can draft the label from the run record, but the owner decides whether the fix is worth making. Reviewing a sample of runs each week keeps the work proportionate, and a weekly sampling method can set how many runs to read.
Do I need special tooling to start classifying failures? No. A shared spreadsheet or document with one row per failed run, the six cause labels, a primary and secondary field, and one sentence of evidence is enough to begin. Tooling becomes useful later, once you have enough labeled runs to see patterns, and it should make the same record easier to read rather than replace the habit of classifying before fixing.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


