How AI Agents Fail (and How to Catch Them)

When a chatbot is wrong, it says a wrong thing. You read it, you notice, you move on. When an agent is wrong, it does wrong things, over and over, at machine speed, and a small mistake compounds into a real mess before you look up.

An agent is AI that doesn't just answer; it takes actions in a loop to reach a goal. It plans, does a step, checks the result, does the next step, and keeps going until it decides it's finished. That autonomy is the whole point, and it's also the hazard. A chatbot's mistake stops at the sentence. An agent's mistake flows into everything it does next.

So if you're going to hand real tasks to something that acts on its own, it pays to know the specific ways it goes off the rails, and the checkpoint that catches each one. There are four worth knowing.

Failure one: the loop.

An agent that isn't making progress doesn't get frustrated and stop the way you would. It just tries again. Same broken approach, slight variation, still broken, again. Without a human's instinct to step back and rethink, it can grind on a dead end indefinitely, burning time and money on the belief that the next attempt is the one. The fix is a cap. Limit the number of steps or attempts, and treat three failed tries at the same thing as a signal to stop and ask, not to try thirty.

Failure two: goal drift.

The agent quietly ends up solving a different problem than the one you asked about. It misread the goal at the start, or wandered off it over many steps, and now it's competently, diligently doing the wrong thing. This one is sneaky because the work looks good; it's just aimed at the wrong target. You catch it by being crisp about the goal up front, and by checking direction, not just output. Ask early: is what it's doing actually pointed at what I wanted? A sharp goal is the best defense, because an agent drifts less from a target that was clear to begin with.

I am a big fan of Matt Pocock's Grilling skill (link) and use it frequently. I will paste it below just in case it changes over time:

---
name: grilling
description: Grill the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.
---

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.

If a *fact* can be found by exploring the codebase, look it up rather than asking me. The *decisions*, though, are mine — put each one to me and wait for my answer.

Do not enact the plan until I confirm we have reached a shared understanding.

Use this before starting on something and you will be amazed at how often your agent raises up something you had not considered.

Failure three: compounding.

This is the worst one, and the reason agents fail harder than chatbots. The agent makes a small mistake in step two. Step three builds on it. Step four builds on step three. By step ten it has constructed an elaborate, confident result on a foundation that was wrong from the start. A single bad answer is contained. A bad early step that everything downstream depends on is a disaster assembled one reasonable-looking piece at a time. The checkpoint: verify the early, load-bearing steps before the agent builds on them. Getting step one right matters far more than getting step nine right, because step nine inherits every error before it.

Failure four: overreach.

The agent decides to be helpful in ways you didn't ask for. It deletes a file it judged unnecessary, changes something beyond the scope, takes an action you'd never have approved, all in service of the goal as it understood it.

My agent once deleted a fair number of tests in order to get them to pass. I mean… it wasn't wrong per se…

You catch this with boundaries. Be explicit about what it may touch and what it must not, and gate the irreversible actions, the ones that delete, send, or spend, behind your approval. The narrower the mandate, the less room it has to help you into a hole.

Here's the whole thing as a checklist you can actually use:

1. Cap the loop. Set step and attempt limits; treat repeated failure as stop-and-ask, not keep-trying.
2. Nail the goal up front. A crisp, verifiable objective is your best defense against drift; ideally with a grilling session.
3. Verify early steps hardest. The foundational steps compound the worst, so check them before anything gets built on top.
4. Fence the scope. Be explicit about what's off-limits, and gate anything irreversible behind a yes from you.
5. Stay the reviewer. Watch direction, not just the final output. Beautiful work aimed at the wrong goal is still a failure you have to catch.

None of this makes agents less powerful. It's the opposite: the power is exactly what makes the failures expensive, so the checkpoints are what let you take the leverage without the wreckage. Know the four ways they go wrong, set the four checkpoints, and an agent stops being a gamble and starts being a tool.

Most of these failures trace back to one thing: an environment that wasn't set up for an agent to work in safely. Clear goals, tight scope, checkpoints on the risky actions; those are properties of your setup, not of the model. If you want to know how ready your own codebase is for agents to work in, the readiness quiz scores it in a few minutes: agentreadyscore.ai.

See you next week.