AI Agent Failure Types: Ten Categories to Log From Day One
A working taxonomy of ten AI agent failure types, from wrong tool calls to stale memory, with what to log for each so teams can spot patterns and fix them.

Most AI agent failures fall into a small set of repeatable types: the agent picks the wrong tool, passes bad arguments, retrieves the wrong passage, relies on a memory that is no longer true, or keeps going after it should have stopped. A working taxonomy with ten categories lets a team tag each failure the same way from the first day, so the logs show patterns to fix instead of a collection of anecdotes.
Key takeaways
- Tag every agent failure with one category from a fixed list, not with a free-text note alone.
- Log the same core fields for every category so incidents can be compared across weeks.
- Keep failures of action (tools, duplicate effects) apart from failures of knowledge (retrieval, memory, input).
- Give control failures, such as permission overreach and loops, their own owner and their own review.
- Record the prompt, model, tool and index versions on every run so change-related failures can be traced.
Why a shared taxonomy beats anecdotes
When an agent gets something wrong, the first report usually describes the symptom: the agent sent the wrong quote, or it answered from an old policy. Those descriptions are accurate and nearly useless for planning. Two people can read the same incident and disagree about whether the cause was the model, the prompt, the source data or a tool that returned an unclear error. A shared category list forces the question that matters: what kind of failure was this, and where did it start?
Taxonomies also make rare failures visible. One duplicate refund looks like bad luck. Several duplicate side effects tagged the same way across different workflows point to a missing safeguard in one shared tool. The categories below are a working set. Rename them to fit your business, but keep the boundaries stable for a few months so trends mean something. For a broader view of how these failure modes fit together, read a shared failure taxonomy for business agents.
Action failures: wrong tool, wrong arguments and duplicate effects
The first three categories cover what the agent does. Each one leaves a different trace, so each needs a different log field.
- Wrong tool. The agent selects a tool that cannot answer or perform the request, such as a search tool when the task requires a write, or the reverse. Log the tools offered, the tool chosen and the type of request.
- Wrong arguments. The right tool receives values that are wrong, such as an identifier carried over from a previous conversation or a date in the wrong format. Log argument names and a redacted summary of values, not raw personal data unless your policy allows it.
- Duplicate side effect. A retry, a timeout or a repeated instruction produces the same change twice. Log the request reference or idempotency key and whether the provider reported an earlier success.
Tool descriptions are a common cause of wrong-tool and wrong-argument failures. Anthropic's engineering notes on writing tools for agents make the case for clear names, precise parameters and descriptions written for the model, not only for the developer who built the tool. Duplicate effects are harder. Payment APIs such as Stripe document idempotent requests so that a repeated call does not repeat the action. Your agent's write tools need the same discipline, and the logs should show whether it was present. The idempotent actions guide covers the refund case in detail.
Knowledge failures: bad retrieval, stale memory and misread input
The next three categories cover what the agent knows when it acts. They are easy to confuse because the answer looks confident in every case.
- Bad retrieval. The question is right, but the passages returned are the wrong policy version, an unrelated document or nothing at all, and the agent answers anyway. Log the query, the sources returned and whether the answer cited them.
- Stale memory. A stored fact was true when it was saved and is no longer true, such as a supplier that changed terms or a customer who asked for a different contact. Log the memory item, the date it was last confirmed and the task that used it.
- Misread input. A table, a scanned page or a long email thread is read in the wrong order, or a column is shifted. Log the file type, the section referenced and the values the agent actually used.
Separating retrieval from generation in the log is the key move. If the right source was retrieved and ignored, the problem lies in how the agent uses context. If the source was never retrieved, the problem lies in the index, the query or the permissions on the source. Those two fixes have different owners, and a single "wrong answer" entry would hide the difference.
Control failures: permission overreach, loops and missed escalation
Control failures matter most for trust, because they show whether the approval boundaries you designed are the boundaries the agent actually respects.
- Permission overreach. The agent attempts an action outside its approval boundary, either succeeding because a permission was broader than intended or being blocked and then trying a workaround. Log both the attempts and the blocked actions, along with the result of the permission check at the moment of action. OWASP's authorization guidance is clear that access should be checked at the point of action, which is why the check result belongs in the log.
- Loop or stalled task. The agent repeats steps without progress, often calling the same tool with the same arguments. Log the step count, the repeated calls and the stop condition that fired or failed to fire. The stop conditions guide describes conditions that hold up in practice.
- Missed escalation. The agent should have handed a decision to a person and did not, or it handed over an unreadable bundle of partial work. Log the escalation trigger, whether it fired, and how long the person took to respond.
Treat these three as operational controls with named owners. When the same person reviews the loop log and the permission log, problems tend to surface earlier because the patterns sit side by side.
Change failures: silent drift after updates and edits
The tenth category is the hardest to see. Quality can decline after a model update, a prompt edit, a new batch of documents or a change in the format of a tool response, and no single event announces it. An agent that handled a task well last month may handle it slightly worse now without showing any error.
Log the versions of everything that can change on every run: the prompt, the model name, the tool schema and the retrieval index. Without those fields, a decline cannot be matched to a cause. Then run a fixed set of tasks against each version and compare the results. The drift detection checks describe simple tests that catch slow changes before users notice them. OpenTelemetry's semantic conventions for generative AI are a useful reference when your engineers decide how to name these fields.
A first-week logging plan and one illustrative case
Use this sequence to start logging the categories without building a large system first.
- Write the ten categories on one page, with a one-line example for each and a plain statement of where its boundary sits relative to the others.
- Name an owner for the action group, the knowledge group, the control group and the change group, even if one person holds several roles.
- Add core fields to every agent run: task identifier, timestamp with time zone, agent version, tool calls with summarized arguments, approval decision, outcome and, when a failure occurred, its category.
- Make the category a required field in the review form, with an "unclear" option so reviewers do not guess.
- Hold a short weekly review with the workflow owner, and record one decision for each category that recurs.
- After a few weeks, rank the categories by frequency and by impact, then fix the cheapest high-impact one first, such as a clearer tool description or a missing stop condition.
Illustrative scenario: a regional distributor uses an agent to draft replies to order-status emails. After two weeks, the review sheet shows bad retrieval on messages about split shipments. The retrieval step returned only the first order line, so the draft gave one delivery date for an order that was arriving in two parts. The fix was to change how shipment records were indexed, not to rewrite the prompt. Without the category, the team would likely have edited the prompt several times without touching the cause.
How managed operations keep the categories in use
Be Human's managed model treats the taxonomy as part of the agent's operating record rather than a document written once and filed. In a first engagement, each category is mapped to the tools, memory stores and approval boundaries of the specific role, and each one gets a named owner and the fields it needs. Monitoring reviews tagged entries on a recurring schedule, permission review checks whether approval boundaries still match real use, and incident response uses the same categories to set severity. Changes to prompts, tools or memory go through a controlled path with a record of what changed and which version was running, so change-related failures can be traced rather than guessed at. Be Human delivers this remotely, in English or Portuguese, within the scope of the one role the engagement defines.
If you are not yet sure which of your workflows should get a logged agent first, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
Do I need all ten categories on the first day? Not necessarily, but the list is most useful when it is complete from the start. Begin with the categories that match the tools and data your first agent actually uses, and keep the others as defined options in the review form. Empty categories cost little, while adding a category later means older entries get tagged inconsistently.
Should the agent tag its own failures or should a reviewer? Use both, but let the reviewer make the final tag. The agent can flag that a step failed or that a permission check was denied, which gives reviewers a head start. Deciding why a failure happened is often better done by a person who knows the workflow, and an "unclear" option keeps guesses out of your counts.
What if a failure fits two categories? Record a primary category, the one where the fix would be made, and note the secondary category separately. For example, a stale memory that caused a wrong argument belongs first to stale memory, because refreshing the memory fixes the root issue. Consistent rules for choosing the primary tag matter more than the exact choice.
Is this taxonomy a standard I should adopt as is? No. It is a working set designed to produce patterns a team can act on, not an industry standard. Rename the categories to match your operations, keep their boundaries stable long enough to see trends, and revise them only when a recurring failure clearly does not fit.
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.


