💬 NLP

Tracing Agentic Failure from the Flow of Success

The paper proposes OAT, a lightweight, unsupervised failure attribution model that uses one-class learning with neural controlled differential equations to identify error steps in LLM-based agentic systems by modeling successful trajectory dynamics, achieving significantly higher speed and accuracy than existing prompting-based or supervised methods.

Original authors: Samuel Yeh, Yiwen Zhu, Shaleen Deep, Sharon Li

Published 2026-07-15

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Samuel Yeh, Yiwen Zhu, Shaleen Deep, Sharon Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're watching a team of robot helpers try to build a treehouse. They talk to each other, grab tools, and measure wood. Suddenly, the roof collapses. The big question is: Which specific move caused the disaster? Did they forget to measure the wood? Did they use the wrong hammer? Or did they argue about the design too long?

Finding that one bad step is like trying to find a single dropped needle in a haystack of a thousand robot actions. Usually, to solve this, experts have to sit down and manually label every single mistake in every failed attempt, teaching a super-smart AI (like a giant brain) to spot the errors. But this is slow, expensive, and requires a lot of human labor.

The Paper's Big Idea: Learning from Success Only
The authors, Samuel Yeh and his team, say: "Wait a minute. Why do we need to study the failures to find the mistakes? What if we just study the perfect treehouses?"

They propose a new way called OAT (One-class Agent Tracing). Instead of feeding the AI a library of broken robots and asking it to learn what "wrong" looks like, they feed it only the successful, perfect trajectories. The AI learns the "rhythm" or the "flow" of a perfect job. It learns how a robot should move, think, and act when everything goes right.

The Magic Trick: The Invisible River
Here is where it gets cool. The team treats the robot's actions like a river flowing through time. They use a mathematical tool called Neural Controlled Differential Equations (Neural CDEs). Think of this as a super-precise map that draws the "ideal path" a robot should take.

When a robot fails, it's like the river suddenly hitting a rock or swirling into a whirlpool. Because the AI knows exactly what the smooth, successful river looks like, it can instantly spot where the water gets choppy. It assigns a "weirdness score" (anomaly score) to every single step. If a step looks too different from the perfect flow, the AI flags it as the culprit.

What They Ruled Out
The paper explicitly argues against two common methods:

The "Ask the Giant Brain" Method: Using massive, expensive AI models (like GPT-5) to read the whole story and guess the mistake. The authors show this is too slow and costs too much money.
The "Label Everything" Method: Trying to collect thousands of examples of broken robots and manually labeling every single error step. The authors say this is too hard and ambiguous to scale up.

The Results: Fast, Cheap, and Surprisingly Good
The team tested their idea on real data. They trained OAT on just 100 successful robot journeys. Then, they threw it into a test with broken journeys it had never seen before.

Speed: OAT is 200 to 5,000 times faster than asking the giant AI models. It costs zero extra money in "token" fees because it doesn't need to chat with a big model to solve the problem.
Accuracy: Even though it only saw 100 perfect examples, OAT beat the giant AI models. In tests on similar tasks, it was 20% better at finding the errors. On totally different, tricky tasks, it was still 7% better.
The "Gatekeeper": They added a special "gate" to their math model. This gate helps the system stay calm when it sees a robot acting in a totally weird, new way (like a robot from a different planet). This gate made the system much better at handling new, unfamiliar situations without getting confused.

How Sure Are They?
The authors are very confident in these numbers because they ran the tests multiple times with different random seeds and got consistent results. They measured the performance using standard math scores (like F1 scores and AUROC) and found OAT consistently outperformed the competition.

However, they are careful to note that while the system works great, it's not perfect. In some cases, it might miss the very first mistake but still catch the steps where the error becomes obvious. They suggest that with a few tweaks, it could get even better, but for now, they have proven that learning from success is a powerful, practical, and fast way to diagnose failure.

The Bottom Line
Instead of studying the wreckage to find out what went wrong, OAT learns the blueprint of a perfect building. When something falls apart, it instantly knows exactly which brick was laid incorrectly, and it does it lightning-fast without needing a supercomputer. It's a new, efficient way to debug the robots of the future.

Technical Summary: Tracing Agentic Failure from the Flow of Success

Problem Statement

The paper addresses failure attribution in LLM-based agentic systems: the task of identifying which specific steps in a failure trajectory caused the system to fail. Existing approaches rely on either:

Prompting-based pipelines: Using frontier LLMs to analyze trajectories, which incurs high token costs and latency.
Supervised learning: Training models on failure trajectories with step-level error annotations. This is costly to scale due to the difficulty of collecting high-quality, unambiguous step-level labels.

The authors propose a new problem setting: Unsupervised Failure Attribution. The goal is to train a model exclusively on successful trajectories (which are easy to collect as byproducts of normal operation) and use it to identify error steps in failure trajectories at inference time, without any step-level supervision on failure data.

Methodology: OAT (One-class Agent Tracing)

The authors propose OAT, a lightweight model that frames failure attribution as a one-class learning problem in the latent representation space of an LLM.

1. Latent Representation

For a trajectory $\tau = (Q, a_1, s_1, \dots, a_T)$ , each step $t$ is represented by a latent vector $h_t$ extracted from the hidden states of the LLM agent generating action $a_t$ . The query $Q$ is also represented as $h_Q$ .

2. Continuous Trajectory Modeling via Neural CDEs

Instead of treating steps as discrete events (as in RNNs or Transformers), OAT models the trajectory as a continuous latent path.

Neural Controlled Differential Equations (Neural CDEs): The model treats the sequence of step representations as irregularly sampled observations of an underlying continuous function. A Neural CDE learns the dynamics of successful trajectories by conditioning the latent state evolution on the observed trajectory path $X(u)$ .
Gated Control Path: To handle out-of-distribution (OOD) inputs where the control signals (derivatives of the trajectory) might be spurious, OAT introduces a gating function. This function adaptively suppresses control signals that deviate significantly from the training distribution, improving robustness without sacrificing in-domain expressiveness.

3. Anomaly Detection

At inference time, given a failure trajectory:

The model predicts the expected latent state $\hat{h}(u_t)$ for each step based on the learned dynamics of successful trajectories.
An anomaly score $e_t$ is calculated as the squared reconstruction error: $e_t = \|h'_t - \hat{h}(u_t)\|^2_2$ .
Detection Strategies:
- Top-k: Selects the $k$ steps with the highest anomaly scores.
- Conformal Prediction (CP): Uses a calibration set of successful trajectories to set a threshold $\delta$ that controls the false positive rate, flagging steps where $e_t > \delta$ .

Key Contributions

Problem Formulation: Introduced Unsupervised Failure Attribution, eliminating the need for costly step-level annotations on failure data by training solely on successful trajectories.
Model Architecture (OAT): Proposed a continuous-time one-class learning approach using Neural CDEs with a novel gated control path to model agent dynamics and detect localized deviations.
Empirical Validation: Demonstrated that OAT outperforms prompting-based baselines (including GPT-4o and GPT-5) in both in-domain and OOD settings while being significantly faster and cheaper.

Experimental Results

The model was trained on 100 successful trajectories from the MCP-Atlas dataset and evaluated on failure trajectories from MCP-Atlas (in-domain) and Who&When (OOD).

Performance:
- In-domain (MCP-Atlas): OAT outperformed prompting-based baselines by +20% F1 score and +10% AUPRC.
- Out-of-Distribution (Who&When): OAT outperformed baselines by +7% F1 score and +5% AUPRC, despite significant structural and model differences between the training and test datasets.
Efficiency:
- OAT requires zero token cost at inference time.
- It is 200–5000× faster than prompting-based approaches (latency of ~7ms vs. ~4000ms+).
- It can be deployed on less than 1 GB of VRAM.
Ablation Studies:
- Neural CDE vs. ODE: CDEs significantly outperformed Neural ODEs, confirming the importance of conditioning on observed trajectory steps.
- Gating: The gated control path significantly improved OOD performance (+0.172 AUROC) with a minor trade-off in in-domain performance.
- Layer Selection: Representations from later layers of the LLM provided stronger signals for anomaly detection than earlier layers.

Significance and Claims

The paper claims that OAT offers a practical, efficient, and effective direction for diagnosing agentic system failures. By shifting from supervised failure learning to unsupervised learning on success, the approach removes the annotation bottleneck. The authors emphasize that their method makes real-time failure attribution practical for the first time, enabling the deployment of diagnostic tools in high-stakes settings (e.g., coding, scientific research) without the prohibitive costs of running frontier LLMs for every diagnostic query. The work suggests that the "flow of success" contains sufficient signal to identify and localize the "flow of failure."