Insights

The 10 AI Agent Failure Modes I Check For Before Anything Gets Built

Pencil illustration of a person at a desk with an open laptop facing them, writing with a pencil beside a printed numbered checklist, a coffee mug and a yellow sticky note

TL;DR

  • Ten failure modes: these are the anti-patterns that show up in real agent builds, and each one is a design decision that was never made.
  • Agents for everything: sometimes you just need a rule, or a pipeline should be enough.
  • Stopping conditions: set a controlled loop, three, five or ten, and after that move over to the next stage.
  • Tools and records: each agent gets access to the tools it needs to do its job, and that's it.
  • Chat history: the chat history is not a reliable business process database, so save your knowledge and context within your system.

When I walk a team through how to design an AI agent, the last part covers the anti-patterns. These are the failure modes that show up in real builds.

Each one is a design decision that was never made.

Everybody is trying to adopt AI right now. Below is the list, in the order I go through it, with what I tell the team about each one.

The ten failure modes on one page

Failure modeWhat it looks likeThe decision to make before the build
Agents for everythingAn agent where a rule or a pipeline would be more reliableWhich steps need an agent at all
Unlimited loopsThe agent keeps going with no stopping conditionHow many loops, and what happens after
Hidden stateImportant information about the work exists only inside the model contextWhere the state of the work is saved
Unrestricted toolsThe agent has broad access to system tools and recordsWhich tools and records this agent needs
AI-only validationOne model checks another when a deterministic test is availableWhich checks are tests, and which need a model
Excessive multi-agent complexityMany agents without clear responsibility and boundariesWhether the job needs more than one agent
Autonomous consequential actionsHigh-impact actions with no approval, limit or recoveryWhat each action can cost, and who approves it
Weak routingEvery request forced into a specialist category, with no unknown routeWhere a request goes when it fits no category
Chat history used as the process recordThe chat history is treated as the record of the processWhere the business process is recorded
No failure recoveryEscalation and recovery get designed after the first incidentRetry, fallback, escalation and recovery, before production

Agents for everything

Using an agent where a rule or a pipeline would be more reliable.

You don’t throw AI agents at every problem. Sometimes you just need a rule, or a pipeline should be enough, and you don’t need an agent for that. We wrote about how we pick which steps get AI and which stay as plain automation.

Pencil drawing of a person at a workbench lifting a screwdriver with a yellow handle out of an open toolbox, with a power drill left lying in the box and a screw and a hinge on the bench

Unlimited loops

Allowing an agent to continue without any kind of stopping condition.

Don’t let these agents just keep on running. You can set a controlled loop and say three loops, five loops, ten loops. After that is done, move over to the next stage.

When I write the loop down, I write the completion condition next to it: the maximum iterations, the maximum cost, the timeout and the escalation.

Pencil drawing of a person at a desk turning the dial of a round yellow timer, beside an open laptop that faces them and a notebook with a pen

Hidden state

Allowing important information about the work to exist only inside the model context. Please don’t do that. If the state of the work is only in the model’s context, nobody on the team can check it, and the next step can’t pick it up.

Unrestricted tools

Giving an agent broad access to system tools and records.

Each agent needs access to the tools it needs to do its job, and that’s it. We cover how to set that up in give each agent the least access it needs.

Pencil drawing of a person taking one yellow key off a wall rack of key hooks and handing it to a colleague with an open hand, while the other keys stay on their hooks

AI-only validation

Using one model to validate another when deterministic tests are available.

The first rule we go through is to use deterministic functions and fixed steps wherever they do the job. So if you can use a deterministic test, use it. Don’t only use an AI model to validate.

Excessive multi-agent complexity

Creating many agents without clear responsibility and boundaries.

It’s easy to spin up a hundred agents. The question is whether the objective you are trying to achieve needs that in that particular process. If the answer is no, then don’t do it.

Autonomous consequential actions

Allowing high-impact actions without approval, limit or recovery.

You need to classify all those actions and understand what the consequence of each one is. The never-do list in the list of things an agent should never do and the approval steps in keeping a human in the loop come from that classification.

Weak routing

Forcing every request into a specialist category without an unknown route.

When you do your routing, it needs to be clear. You need to understand how the system is built, and at what point it needs to route to the next system or the next model. Weak routing can do you more harm than good.

Treating the chat as the process record

The chat history is not a reliable business process database. Please have your knowledge and context saved within your system. You cannot be referring back to the chat to find out where the work is.

Saving it in the system also cuts the time people spend inside the chat window. The record of what the agent did belongs in the same place, which is the audit trail every agent should leave.

Pencil drawing of a person at an office shelf sliding a printed page into the one binder with a yellow spine, pulled halfway out from a row of plain binders

No failure recovery

Design failure recovery and escalation before production deployment, before the first incident.

When a step fails before anything has been committed, there are three responses:

  • Retry temporary failures like a network timeout or a rate limit, with a maximum retry count.
  • Fallback to an alternative model provider, tool, retrieval source or path through the process.
  • Escalation sends it to a human to review when confidence is low, required information is missing or there is a policy conflict.

When the failure needs to be undone, resumed or set aside, there are three more:

  • Compensation reverses a completed action. If the record was created and a later step failed, delete or deactivate the record.
  • Checkpoint recovery resumes from the last saved state rather than restarting the entire process.
  • Dead letter queue stores the failed task for investigation and controlled reprocessing.

What changes in how the work runs

The team answers these decisions on paper before anything gets built. When something goes wrong in production, the response was already decided: the loop stops at its limit, the request with no category goes to the unknown route, and the failed task waits in the queue for someone to look at it.

Takeaways and next steps

  • Go through the ten failure modes before the build, and write down the decision for each.
  • Use a rule or a pipeline where it does the job.
  • Set the loop limit and what happens after it.
  • Save the state of the work and the knowledge in your system.
  • Give each agent only the tools and records it needs.
  • Use deterministic tests wherever you can.
  • Design retry, fallback, escalation and recovery before production.

Our guide on AI capability versus business readiness covers what a business needs in place before an agent goes live.

Common mistakes when designing an AI agent

1. Building the agent first and writing the design decisions afterwards.

Why it fails: The decisions get made by default, one incident at a time.

Better approach: Fill in the design before anything gets built.

2. Giving the agent access to every tool in case it needs one.

Why it fails: The agent can reach records it has no reason to touch.

Better approach: List the tools the job needs and grant those.

3. Letting a second model check the first one’s work.

Why it fails: Two models can agree on the same wrong answer.

Better approach: Use a deterministic test where one exists.

4. Keeping the state of the work in the chat.

Why it fails: Nobody can see where a task is, and the next step can’t pick it up.

Better approach: Save the state and the context in your system.

5. Waiting for the first incident to plan recovery.

Why it fails: The first failure in production has no fallback and no one to escalate to.

Better approach: Decide retry limits, fallbacks, escalation and recovery before deployment.

Frequently asked questions

What are AI agent failure modes?

The anti-patterns that show up in real agent builds, such as agents used for everything, unlimited loops, hidden state and unrestricted tools. Each one traces back to a design decision that was never made.

When should I use a rule instead of an AI agent?

When a rule or a pipeline does the job reliably. An agent is for the steps that need judgement.

How many loops should an AI agent run?

Set a controlled number, such as three, five or ten, with a completion condition, a maximum cost and a timeout. After that the work moves to the next stage or escalates.

Can I use chat history as the record of a business process?

No. Save the state of the work, the knowledge and the context in your system, where the team can see it.

What is a dead letter queue?

A place where failed tasks are stored for investigation and controlled reprocessing.

Do I need multiple AI agents?

Only when the process needs them. Many agents without clear responsibility and boundaries is one of the failure modes.

Glossary

Anti-pattern
A common way a build goes wrong, repeated across projects.
Stopping condition
The rule that ends an agent's loop, such as a maximum number of iterations, a cost limit or a timeout.
State of the work
Where a piece of work is in the process, saved in the system.
Deterministic test
A check that gives the same result every time for the same input, such as a rule or a calculation.
Unknown route
The path for a request that fits no specialist category.
Dead letter queue
A store for failed tasks, kept for investigation and controlled reprocessing.
Checkpoint recovery
Resuming a process from its last saved state.