Why do autonomous LLM agents fail in predictable ways?

When LLMs interact autonomously without human supervision, they fail in ways that are distinct from human conversational failures. The CAMEL framework (2023) catalogs four specific failure modes:

Role flipping: The assistant agent starts providing instructions instead of following them, or the user agent starts executing instead of directing. This happens because LLMs have no stable sense of role identity — they predict the next likely token given context, and if the context starts resembling a different role's typical output, they drift into that role. Asking questions contributes to flipping, because questions signal the instructor role.

Flake replies: The assistant responds with "I will do X" instead of actually doing X. The promise-without-execution pattern reflects how LLMs model cooperative language — they have seen many examples of helpful-sounding commitments in training data and reproduce the form without the substance.

Infinite loops: Agents enter meaningless cycles of "Thank you" / "You're welcome" / "Goodbye" without progressing the task. Without a task-grounded termination signal, social politeness patterns dominate once the task-oriented signal weakens.

Conversation deviation: The conversation drifts away from the assigned task entirely. Without persistent goal representation, local token prediction optimizes for conversational coherence rather than task completion.

Inception prompting (explicit role assignment, termination tokens, format constraints) partially mitigates these but doesn't fully solve them. The core problem is that LLMs lack the persistent goal representation and role stability that humans bring to collaborative tasks through embodied social experience.

These failure modes connect to Why can't conversational AI agents take the initiative?: the passivity problem manifests differently in human-AI interaction (passivity) versus AI-AI interaction (role confusion and deviation), but the root cause — absence of stable goal-directed behavior — is shared.

MAST extends to 14 empirically grounded failure modes (from Arxiv/Agents Multi Architecture): The MAST taxonomy (Multi-Agent System Failure Taxonomy) systematically extends CAMEL's 4 modes to 14, organized into 3 overarching categories: specification issues (under-specified goals, ambiguous role boundaries), inter-agent misalignment (communication breakdowns, conflicting sub-goals), and task verification failures (incomplete validation, cascading error propagation). Critically, MAST draws from 5 popular MAS frameworks across 150+ tasks with 6 expert annotators — providing empirical breadth that CAMEL's single-framework analysis lacked. The categories are orthogonal failure surfaces: improving inter-agent communication doesn't fix specification issues, better verification doesn't fix misalignment. See Why do multi-agent LLM systems fail more than expected?.

A three-tier 19-cause failure taxonomy extends the CAMEL four-mode framework. An empirical study across three open-source agent frameworks (2025) achieves ~50% task completion and develops a comprehensive taxonomy: (1) Task planning failures — improper decomposition (logically incorrect steps), failed self-refinement (inability to learn from past errors, causing infinite loops of the same failed sub-task), and unrealistic planning (plausible steps exceeding downstream agent capabilities). (2) Task execution failures — failure to exploit external tools, flawed code generation (syntax errors, functionality errors, incorrect API usage), and improper environment setup. (3) Response generation failures — context window constraints causing disconnected responses, formatting issues, and maximum rounds exceeded. The planning failures are most critical since "the planner's output directly guides subsequent agents and largely determines the success of the overall framework." Additionally, LiveMCP-101 identifies 7 MCP-specific failure modes where semantic errors dominate (16-25% even in strong models) and overconfident self-solving is common in mid-tier models that skip tool calls because planning remains brittle under large tool pools. Source: Arxiv/Evaluations.