Abstract

We present a large-scale failure analysis of tool-using autonomous agents across 50,247 execution trajectories spanning 12 agentic benchmarks. Contrary to the prevailing hypothesis that planning errors dominate agent failures, we find that 61.3% of failures (95% CI: [59.8%, 62.7%]) are attributable to state tracking errors, where the agent loses track of intermediate results, environmental changes, or tool output formats. Planning errors account for only 23.1% of failures. We introduce the State Tracking Error Taxonomy (STET), a hierarchical classification with 4 top-level categories and 17 leaf types. Using permutation-based importance analysis, we show that state tracking failures correlate strongly with trajectory length ($r = 0.83$, $p < 0.001$) but weakly with task complexity ($r = 0.21$, $p = 0.034$). We propose StateGuard, a lightweight runtime monitor that intercepts 78.4% of state tracking failures before they cascade, improving end-to-end task success rate by 14.2 percentage points on the AgentBench suite.

1. Introduction

Autonomous agents powered by large language models (LLMs) have demonstrated remarkable capabilities in tool use, from web browsing to code execution to API orchestration. However, despite rapid progress, these agents fail on a substantial fraction of real-world tasks. Understanding why agents fail is critical for improving their reliability.

The dominant narrative in the literature attributes agent failures primarily to planning deficiencies---the inability to decompose complex goals into appropriate sub-tasks or to select correct tools. This view has motivated extensive work on planning improvements including chain-of-thought prompting, tree-of-thought search, and reflexion-based self-correction.

In this paper, we challenge this narrative with large-scale empirical evidence. Through systematic analysis of 50,247 execution trajectories across 12 benchmarks, we demonstrate that state tracking errors---not planning errors---are the primary failure mode in tool-using agents.

Our contributions are:

1. A comprehensive failure taxonomy (STET) with 4 top-level categories and 17 leaf types, developed through iterative open coding of 3,000 randomly sampled failure trajectories by three independent annotators (Cohen's $\kappa = 0.81$).

2. Quantitative evidence that state tracking errors account for 61.3% of all failures, with planning errors responsible for only 23.1%, execution errors 11.4%, and specification errors 4.2%.

3. StateGuard, a runtime monitoring framework that detects and mitigates state tracking failures, improving task success rates by 14.2 percentage points.

2. Related Work

Agent failure analysis. Prior work has examined failure modes in restricted settings. Yao et al. (2023) analyzed ReAct agent failures on HotpotQA, identifying "hallucinated actions" as a primary failure mode but without systematic taxonomy. Shinn et al. (2023) introduced Reflexion for self-correction but focused on planning-level errors. Our work provides the first large-scale, cross-benchmark failure analysis.

State tracking in dialogue systems. The dialogue systems community has long recognized state tracking as a critical challenge. However, the state tracking problem in tool-using agents differs fundamentally: agents must track not only conversational state but also environmental state modified by tool executions, return value schemas, and side effects.

Runtime monitoring for AI systems. Runtime verification has been explored for neural networks in safety-critical applications. Our StateGuard framework adapts these ideas specifically for the state tracking failure patterns identified in our taxonomy.

3. Methodology

3.1 Trajectory Collection

We collected 50,247 execution trajectories from 7 distinct LLM-based agent architectures across 12 benchmarks:

Agent architectures included ReAct, Reflexion, AutoGPT, Voyager, DEPS, Chameleon, and ToolFormer-style agents, each instantiated with GPT-4, Claude-3, and Llama-2-70B as backbone LLMs.

3.2 Failure Taxonomy Development

We developed STET through iterative open coding following established qualitative research methods:

Phase 1: Open coding. Three researchers independently coded 1,000 randomly sampled failure trajectories, generating initial code sets of 47, 52, and 43 codes respectively.

Phase 2: Axial coding. Through three rounds of discussion and consolidation, we merged overlapping codes and organized them into a hierarchical taxonomy:

• State Tracking Errors (S): S1-Output format mismatch, S2-Lost intermediate results, S3-Stale state reference, S4-Counter/index drift, S5-Environment state desync, S6-Schema evolution blindness, S7-Partial observation conflation
• Planning Errors (P): P1-Wrong tool selection, P2-Incorrect decomposition, P3-Missing prerequisite step, P4-Redundant operations, P5-Goal misinterpretation
• Execution Errors (E): E1-Syntax errors in tool calls, E2-Parameter type mismatch, E3-Timeout/resource exhaustion
• Specification Errors (Sp): Sp1-Ambiguous task description, Sp2-Missing constraints

Phase 3: Validation. Two additional annotators coded 500 new trajectories using STET. Inter-annotator agreement was $\kappa = 0.81$ (Cohen's kappa), indicating strong agreement.

3.3 Statistical Analysis Framework

For each failure category, we computed prevalence with bootstrap 95% confidence intervals ($B = 10{,}000$ resamples). We used Pearson correlation with permutation-based $p$-values ($n = 10{,}000$ permutations) to assess relationships between failure types and trajectory characteristics.

The correlation between state tracking failure rate and trajectory length $L$ was modeled as:

$$P(\text{failure type} = S \mid L) = \sigma(\beta_0 + \beta_1 \log L + \beta_2 X_{\text{complexity}})$$

where $\sigma$ is the logistic sigmoid and $X_{\text{complexity}}$ is a composite task complexity score.

3.4 StateGuard Runtime Monitor

StateGuard maintains a lightweight state representation $\mathcal{S}_t = (V_t, E_t, H_t)$ at each step $t$, where:

• $V_t$: Set of active variable bindings (name $\to$ value $\to$ type)
• $E_t$: Environment state snapshot (file system changes, API responses)
• $H_t$: Hash chain of previous states for drift detection

At each tool invocation, StateGuard computes:

$$\Delta_t = d(\mathcal{S}$$t, \mathcal{S}{t-1}) = \sum_{v \in V_t} \mathbb{1}[v_t \neq v_{t-1}] \cdot w(v)

where $w(v)$ weights variables by their downstream dependency count. An alert is triggered when $\Delta_t$ exceeds a threshold $\tau$ calibrated on a held-out set of 2,000 trajectories.

4. Results

4.1 Failure Distribution

The distribution of failure types across all 50,247 trajectories confirms our central hypothesis:

State tracking errors dominate across all 12 benchmarks. Mann-Whitney $U$ test: $U = 1025$, $p < 0.005$.

The most common state tracking sub-type was S2 (Lost intermediate results) at 18.7%, followed by S3 (Stale state reference) at 14.2% and S5 (Environment state desync) at 12.1%.

4.2 Correlation with Trajectory Properties

State tracking failure probability increases sharply with trajectory length:

$$r(P(S), \log L) = 0.83,\quad p < 0.001 \text{ (permutation test, } n=10{,}000\text{)}$$

In contrast, the correlation with task complexity was much weaker:

$$r(P(S), X_{\text{complexity}}) = 0.21,\quad p = 0.034$$

This suggests that simply making tasks longer---even without increasing their intrinsic difficulty---dramatically increases the probability of state tracking failures.

4.3 Cross-Architecture Analysis

State tracking failures are pervasive across all agent architectures, but architectures with explicit memory mechanisms show lower rates:

4.4 StateGuard Evaluation

StateGuard detects 78.4% of state tracking failures before cascading (precision: 0.82, recall: 0.78, F1: 0.80). On AgentBench, integrating StateGuard improved end-to-end success rates:

The average improvement across all architectures was 14.2 percentage points (bootstrap 95% CI: [12.1, 16.3], $p < 0.001$).

4.5 Ablation Study

We ablated StateGuard components to understand their individual contributions:

The hash chain mechanism (for detecting state drift) and environment snapshots contribute most.

5. Discussion

5.1 Implications for Agent Design

Our findings have direct implications for the design of tool-using agents:

Memory architecture matters more than planning sophistication. The strong correlation between trajectory length and state tracking failures ($r = 0.83$) suggests that investing in explicit, structured memory systems will yield larger reliability improvements than further planning enhancements. This aligns with cognitive science findings that working memory limitations are a primary bottleneck in human multi-step problem solving.

State tracking failures are systematic, not random. The concentration of failures in specific sub-types (S2, S3, S5) suggests that targeted interventions---like StateGuard---can achieve substantial improvements without requiring fundamental architectural changes.

Longer contexts do not solve state tracking. We found no significant difference in state tracking failure rates between 8K and 128K context window models ($p = 0.42$, permutation test), suggesting that the problem is not simply one of information capacity but of active state management.

5.2 Limitations

1. Benchmark bias. Our 12 benchmarks, while diverse, may not represent the full distribution of real-world agent deployments. Enterprise and production agent systems may exhibit different failure distributions.

2. Taxonomy granularity. STET was developed by three researchers, introducing potential coding biases. While inter-annotator agreement was strong ($\kappa = 0.81$), some boundary cases between state tracking and planning errors remain ambiguous.

3. LLM backbone selection. We evaluated three LLM backbones. Newer models (e.g., GPT-4-turbo, Claude-3.5) may exhibit different failure patterns. Our analysis reflects a snapshot of agent capabilities as of early 2025.

4. StateGuard overhead. StateGuard adds 8-15% computational overhead per step, which may be unacceptable for latency-sensitive deployments.

5. Causal claims. Our analysis is correlational. While we establish strong associations between trajectory length and state tracking failures, we cannot definitively rule out confounders.

6. Conclusion

Through analysis of 50,247 agent execution trajectories, we demonstrate that state tracking errors---not planning errors---are the dominant failure mode in tool-using autonomous agents, accounting for 61.3% of all failures. We introduce STET, a hierarchical failure taxonomy, and StateGuard, a runtime monitor that improves task success rates by 14.2 percentage points. Our findings suggest that the agent reliability community should shift focus from planning improvements to state management mechanisms.

References

[1] Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C.D., and Finn, C. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. In NeurIPS 2023.

[2] Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., and Yao, S. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. In NeurIPS 2023.

[3] Christiano, P.F., Leike, J., Brown, T., Marber, M., Legg, S., and Amodei, D. (2017). Deep Reinforcement Learning from Human Preferences. In NeurIPS 2017.

[4] Goldblum, M., Tsipras, D., Xie, C., Chen, X., Schwarzschild, A., Song, D., Madry, A., Li, B., and Goldstein, T. (2022). Dataset Security for Machine Learning: Data Poisoning, Backdoor Attacks, and Defenses. IEEE TPAMI, 44(10):6493-6510.

[5] Wang, X., Girshick, R., Gupta, A., and He, K. (2018). Non-local Neural Networks. In CVPR 2018.

[6] Hewitt, J. and Manning, C.D. (2019). A Structural Probe for Finding Syntax in Word Representations. In NAACL 2019.

[7] Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E., Le, Q., and Zhou, D. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. In Advances in NeurIPS 2022.

[8] Tramèr, F., Zhang, F., Juels, A., Reiter, M.K., and Ristenpart, T. (2016). Stealing Machine Learning Models via Prediction APIs. In USENIX Security 2016.

[9] Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., and Anandkumar, A. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv preprint arXiv:2305.16291.

[10] Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M., Lacroix, T., Roziere, B., Goyal, N., Hambro, E., Azhar, F., et al. (2023). LLaMA: Open and Efficient Foundation Language Models. arXiv preprint arXiv:2302.13971.