Samuel Yeh, Yiwen Zhu, Shaleen Deep, Sharon Li
5 min
As LLM-based agentic systems become more complex, diagnosing why a specific task failed has become a major bottleneck. Existing methods for failure attribution—identifying which steps in a trajectory caused a failure—typically require either expensive, latency-heavy prompting of frontier models or large-scale, costly human annotations of failure trajectories. This paper asks: can we perform accurate failure attribution without any failure-specific training data or step-level annotations?
The authors propose OAT (One-class Agent Tracing), an unsupervised framework that learns only from successful trajectories. By treating agent behavior as a continuous dynamic process, OAT uses Neural Controlled Differential Equations (Neural CDEs) to model the latent path of successful task execution. At inference time, OAT calculates an anomaly score for each step in a failure trajectory by measuring its deviation from the learned "normal" flow. To improve robustness against out-of-distribution inputs, the authors introduce a gated control path that suppresses spurious signals. Finally, the model uses either a top-k selection or conformal prediction to identify the specific steps that contributed to the failure.
OAT demonstrates that it is possible to diagnose agent failures effectively without ever seeing a failure during training. Experiments show that OAT is 200–5000x faster than prompting-based baselines because it avoids the need for repeated LLM inference. Despite its lightweight architecture (a 3-layer MLP), OAT consistently outperforms frontier models like GPT-5, achieving +20% higher F1 scores on in-domain data and +7% on out-of-distribution datasets. The results suggest that modeling the latent dynamics of successful trajectories is a highly efficient and scalable way to audit agentic systems.
This approach shifts the paradigm of agent debugging from manual, expensive, and slow human-in-the-loop or prompt-based methods to a lightweight, automated, and unsupervised process. By eliminating the need for step-level error labels, OAT makes real-time failure attribution practical for high-stakes deployments in fields like scientific research and software engineering.
Failure attribution for LLM-based agentic systems, i.e., identifying which steps in a failure trajectory caused the task to fail, is critical for debugging and improving these systems. Existing approaches either rely on prompting-based pipelines, which are computationally expensive, or require post-training on failure trajectories with step-level error annotations, which are costly to collect and difficult to scale. We argue that a practical failure attribution model should be lightweight and trainable without step-level supervision on failure data. To this end, we address unsupervised failure attribution, i.e., training exclusively on successful trajectories and identifying error steps at inference time given a failure trajectory. We propose OAT, which casts this problem as one-class learning with neural controlled differential equations, modeling the dynamical pattern of successful trajectories in latent space. At inference time, each step in a failure trajectory is assigned an anomaly score based on its deviation from the dynamics learned on successful trajectories, which is then used to form a set of error steps. With training on only 100 successful trajectories, experiments show that OAT is 200--5000 $\times$ faster than prompting-based baselines, and, at the same time, consistently outperforms them in both in-domain and out-of-distribution datasets with +20% and +7% F1 scores, respectively, demonstrating that OAT is a promising and efficient direction for diagnosing agentic system failures.
Sam: What if the AI is doing something genuinely new—something outside what it's seen in training? Could the system get confused and flag normal behaviour as a problem?
Alex: That's a real concern, and the authors address it. They added what they call a "gated control path"—think of it as a filter. If a signal looks so unusual that it's likely just noise or an edge case the model has never encountered, the gate dampens its influence. It keeps the model from overreacting to things that are merely unfamiliar rather than genuinely wrong.
Sam: So it's designed to stay stable even in unusual situations. How does it actually perform compared to the older, more expensive methods?
Alex: The study reports that OAT is significantly faster than approaches that rely on prompting large AI models—by a factor of hundreds to thousands in some cases. And it does this while identifying errors more accurately. A diagnostic tool that takes seconds is far more useful in practice than one that takes hours.
Sam: Though I imagine there's a catch. If the whole system is built around learning what "normal" looks like, it's only as good as the examples of success you give it.
Alex: That's the central limitation the paper acknowledges. If your training data only shows one narrow way of doing a task successfully, the model's baseline will be rigid. A failure that looks superficially similar to a successful run—subtle, quiet—might not trigger the alarm. It's a bit like a security system trained only on footage of one type of customer. If someone unusual walks in but behaves calmly, the system might not react.
Sam: So the trade-off is: you avoid the enormous cost of labelling failures, but you take on the responsibility of making sure your "success" examples are genuinely diverse and representative.
Alex: Exactly. And that's a meaningful trade-off, because collecting successful examples is generally far easier than cataloguing every possible failure mode. The paper's argument is that this makes the approach practical at scale in a way that previous methods aren't.
Sam: It also changes the whole framing of the problem. Instead of asking "what went wrong and why," you're asking "at what point did things stop looking right?" That's a much more tractable question.
Alex: And it opens the door to something more significant down the line. If this kind of lightweight, continuous monitoring can be built directly into AI agents as they run—rather than applied after the fact—you could catch errors before they cascade. A small deviation at step twenty doesn't have to become a total failure at step two hundred.
Sam: So the contribution here isn't just a faster diagnostic tool—it's a different way of thinking about how we keep complex AI systems accountable.
Alex: That's a fair summary. By showing that you don't need to see failures to learn how to diagnose them, the research points toward agents that are easier to monitor, easier to correct, and ultimately more reliable. Thanks for listening to ResearchPod.