Why AI Agents Fail: Agent Failure Modes

Definition: Agent failure modes are the repeatable ways AI agents go wrong. A 2025 study of 1,642 multi-agent traces sorted them into 14 modes in three groups: flawed task setup, agents that misread each other, and weak checking of results. Most failures came from how the system was designed, not from the model alone.

TL;DR: The MAST study (NeurIPS 2025) found failure rates of 41% to 86.7% across seven open-source multi-agent systems. The biggest single mode was step repetition, at 15.7% of failures. Structural fixes worked better than prompt tweaks: one added verification step raised task success by 15.6%. Errors also compound across the agent loop, so short, checked steps win.

Think of a group project at work where everyone is smart and it still goes wrong. The brief was vague, so two people built different things. Someone finished their part and left without telling anyone. The person who was supposed to review the final deck only checked the spelling. Nobody was incompetent. The project failed because of how the work was set up. Multi-agent AI systems fail the same way, and the MAST study gave those failures names.

Why Agent Failure Modes Matter in 2026

Agent failure modes matter because agents now run long jobs with no person watching each step, and a failure you cannot name is a failure you cannot fix. The reference study is Why Do Multi-Agent LLM Systems Fail? by Mert Cemri, Melissa Z. Pan, Shuyi Yang, and ten co-authors from UC Berkeley and Intesa Sanpaolo, published in the NeurIPS 2025 Datasets and Benchmarks Track.

The team ran seven popular open-source multi-agent frameworks, including MetaGPT, ChatDev, AG2, Magentic-One, and OpenManus, on coding, math, and general agent tasks. They found failure rates of 41% to 86.7%. They also note that the gains of multi-agent systems "often remain minimal compared to single-agent frameworks" or simple baselines such as best-of-N sampling.

The method is what makes the result useful. Six expert annotators studied more than 150 traces, each averaging over 15,000 lines of text, and built a taxonomy called MAST (Multi-Agent System Failure Taxonomy). Three annotators reached high agreement on it (Cohen's kappa 0.88). The team then trained an LLM judge to label the full set of 1,642 traces, called MAST-Data, with kappa 0.77 against the human experts. The taxonomy, the data, and the judge are public on GitHub.

The Three Groups and 14 Modes

MAST sorts every failure into one of three groups. The percentages below are the share of all labeled failures across the 1,642 traces, from Figure 1 of the NeurIPS camera-ready version.

The numbers differ between versions and charts, so quote the one you use. Figure 4 of the same paper, drawn from a 210-trace subset, gives 41.8%, 36.9%, and 21.3%.

The diagram shows the three largest modes in each group. The table above has all 14.

What the groups mean in plain terms

• System design issues happen before the agents even talk. The task or role was unclear, the agent repeats work it already did, it forgets earlier turns, or it does not know when the job is finished. Paper definition of step repetition: "unnecessary reiteration of previously completed steps."
• Inter-agent misalignment happens while agents work together. One agent guesses instead of asking, drifts off the task, keeps a key fact to itself, ignores another agent, or says one thing and does another.
• Task verification happens at the end. The run stops early, nobody checks the result, or the check is shallow. Premature termination is "ending a dialogue, interaction or task before all necessary information has been exchanged or objectives have been met."

Errors Compound Over Steps

Every failure mode gets worse on long jobs, because small error rates multiply. If each step succeeds with probability p, a job of n steps succeeds with about p to the power n. At 95% per step, a 20-step job finishes about 36% of the time. The agent loop page has the full table.

Real agents do worse than that formula. In The Illusion of Diminishing Returns (ICLR 2026), Sinha and co-authors found self-conditioning: models make more mistakes when their context already holds their own earlier errors, and larger models do not fix this. One error makes the next one more likely. That is why long-horizon agents need checks between steps, not only at the end.

Where in a Run Each Group Strikes

The three groups also map to when a failure starts. MAST tags each mode by the stage of the run where it typically appears: before the agents start, while they talk, or at the end. The diagram is a simplified view of that staging.

A failure early in the run often shows up only at the end. An unclear task leads to a confident result for the wrong task, which is why a check against the real goal catches more than a check of the format.

Fixes That Work

MAST's main lesson is that structure beats wording. The authors argue that "good MAS design requires organizational understanding", and they draw on research into high-reliability organizations, where clear design principles prevent failures even among skilled people.

They tested this on ChatDev, a framework that simulates a software company with CEO, CTO, programmer, reviewer, and tester agents:

The authors are clear that these first fixes are not enough: "not all failure modes are resolved, and task completion rates still remain low." They also found that many existing verifiers "perform only superficial checks", such as whether code compiles. One ChatDev chess program passed its checks and still broke the rules of chess at runtime.

Turned into rules for any agent system, the fixes look like this:

The last row follows Anthropic's advice in Building effective agents (December 19, 2024): find "the simplest solution possible, and only increasing complexity when needed."

Silent Failures in Production

The worst failures do not raise an error. In When Errors Become Narratives (arXiv, June 2026), Wei Wu documented 22 incidents over eight weeks in a production personal-assistant agent that ran about 40 scheduled jobs. The most dangerous class was what the paper calls "fail-plausible": the model turned an error into a polished, believable report. In the author's words, "the observer is not just blind, it is convincingly lied to by the failure itself."

Three findings from that paper are worth keeping:

• About 70% of silent failures were caught by people looking at what the user sees, not by tests or audits.
• In a review of 15 incidents, audits prevented 0% ahead of time but blocked 87% from coming back. "Audits are regression engines, not prediction engines."
• Incidents lasted from 13 hours to 60 days, and the longest ones sat at the boundaries between components, where no test runs.

WHERE A FAILURE SHOWS UP           WHAT CATCHES IT
-------------------------------    ---------------------------------------
A tool returns an error            the error itself, if someone reads it
The agent repeats a step           a step counter or a budget
The agent stops too early          a done test the agent must pass
The check is shallow               a check against the real goal
The agent reports false success    a person reading the output, a log

Read agent observability for how to log runs so a person can find these after the fact.

A Short History of Agent Failure Research

How Agent Failure Modes Show Up in Taskade

Most agent failure fixes in Taskade are structural. Give each custom agent one role, keep the spec and a done checklist in a project the agent reads as knowledge, add a second Agent step that checks the first, and send failures to a person. Each automation keeps a Run History, which is where you start when a run goes wrong.

A content team that has one agent draft product descriptions and another check them is the plain use. Today the checker only looks for spelling, so wrong prices slip through. In Taskade you keep a project with the product facts and a five-line checklist: price matches, size matches, no claims missing from the facts, under 120 words, brand terms correct. The drafting agent writes into a "Drafts" project. A checker agent reads each draft against the checklist and the facts, then marks it pass or fail with the reason. Failures go to a person, and passes move to "Ready". The check is against the real facts, not only the format, which is the MAST lesson. Taskade Genesis builds the first version of that app from one prompt. To start from a working example, clone the Cortex kit, an app kit with projects, AI agents, and automations you can clone. The Free plan covers 3 apps and 1 agent and starts with 0 AI credits. For retry and fallback patterns, see the guide to AI agent error recovery.

Describe yours and build it free →

Related Concepts

• Agent Stop Conditions: fixes for step repetition and premature termination
• The Agent Loop: why errors compound over steps
• Agent Evaluation: measuring how often agents succeed
• Agent Observability: logging runs to find silent failures
• Agent Orchestration: coordinating several agents
• Multi-Agent Teams: when a team helps and when it hurts
• Multi-Agent Systems: the wider research field
• Agent Handoff: passing work between agents without losing facts
• Reflection Pattern: a separate critic that checks the output
• Agentic Exception Handling: what an agent does when a step fails
• AI agent reliability: the longer guide on the blog
• Plan-and-Execute Agents: plan the steps first, then run them
• Ambient Agents: agents that run on events in the background
• AI Agent Autonomy Levels: how much a person stays involved
• AI Agents: the hub for agent concepts in this wiki

Frequently Asked Questions About Agent Failure Modes

Why do AI agents fail?

Most agent failures come from how the system is set up, not from the model alone. The MAST study of 1,642 multi-agent traces found three groups: unclear tasks and roles, agents that misread each other, and weak checks of the result. Errors also compound over long tasks, so each extra step adds risk.

What is the MAST taxonomy?

MAST, the Multi-Agent System Failure Taxonomy, is a list of 14 failure modes in three groups, built by researchers at UC Berkeley and Intesa Sanpaolo and published at NeurIPS 2025. Expert annotators built it from more than 150 traces, and an LLM judge then labeled 1,642 traces. The data and the judge are public.

What is the most common AI agent failure?

In MAST's full dataset, step repetition was the largest single mode at 15.7% of failures, followed by reasoning-action mismatch at 13.2% and being unaware of termination conditions at 12.4%. By group, system design issues were the largest, at 44.2% of failures.

Do multi-agent systems work better than single agents?

Not always. The MAST authors note that multi-agent gains often remain minimal compared with single-agent frameworks or simple baselines. Add agents only when one agent with good tools cannot do the job, and give each added agent one clear role.

Can better prompts fix agent failures?

Partly. In the MAST case studies, clearer role specifications raised ChatDev's success by 9.4%, and a verification step raised it by 15.6%. The authors still found that many failures remained. Structural changes such as clear roles, written done criteria, and real checks did more than wording alone.

What is a silent agent failure?

A silent failure is one that raises no error. The agent reports success, or writes a believable summary of an error, and nobody notices. A 2026 case study of a production agent found that people reading the user-facing output caught about 70% of such failures, more than tests or audits did.

How do I test my AI agents for these failures?

Run each agent on a fixed set of real tasks, read the full step-by-step record of each run, and label what went wrong using the MAST groups. Count step repetitions and early stops. Add a check against the real goal, then rerun the same set to see whether the failure rate drops.

Further Reading

• Cemri et al., Why Do Multi-Agent LLM Systems Fail?, arXiv 2503.13657, 2025
• NeurIPS 2025 Datasets and Benchmarks Track, camera-ready paper (PDF)
• MAST code and LLM annotator (GitHub)
• Sinha et al., The Illusion of Diminishing Returns: Measuring Long Horizon Execution in LLMs, arXiv 2509.09677, ICLR 2026
• Wei Wu, When Errors Become Narratives: silent failures in a production LLM agent runtime, arXiv 2606.14589, 2026
• Anthropic, Building effective agents, December 19, 2024
• Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models, arXiv 2210.03629, 2022