TRAJDEBUG: 7 Ways to Trace Error Lifecycles and Fix Critical Failures in Long-Horizon AI Agents

Introduction: The Hidden Cost of Errors in Long-Horizon AI Agents

Imagine asking an AI agent to book a flight, reserve a hotel, and plan three days of meetings. It nails the flight. It gets the hotel right. Then it schedules a lunch meeting for 2 a.m. because it misread a time zone. The entire task fails—not because of one catastrophic mistake, but because a small error sat undetected, festered, and eventually poisoned everything downstream.

This is the fundamental problem with long-horizon tasks. Unlike single-step question answering, where an error is immediately visible, long-horizon agents operate over dozens or hundreds of steps. A wrong object pick-up in a simulated kitchen, a misclick in a web interface, a navigation detour in a warehouse—each seems minor in isolation. But in sequence, they cascade into total failure.

Most debugging tools treat errors as isolated events. They spot the mistake, flag it, and move on. That misses the real story. The question isn't just "what went wrong?" but "when did it start going wrong, and how did it spread?"

That's the gap TRAJDEBUG fills. Proposed in the paper TRAJDEBUG: Tracing Error Lifecycle to Identify Critical Failures in Long-Horizon Agent Trajectories (arXiv:2502.09962), this framework traces the full error lifecycle—from occurrence to propagation to final impact—and pinpoints which failures are truly critical versus merely cosmetic.

Here are 7 key insights from TRAJDEBUG that change how we should think about debugging AI agents.

1. Why Not All Errors Are Created Equal

An agent that picks up a red mug instead of a blue one isn't necessarily failing. If it only needed "a mug," that error is harmless. The same mistake becomes catastrophic if the task requires the blue mug specifically—and the agent doesn't realize it until step 40.

TRAJDEBUG's core insight is that errors must be classified by impact, not just by occurrence. The framework distinguishes between:

• Minor errors: Recoverable mistakes that don't prevent task completion
• Critical failures: Errors that, if left uncorrected, guarantee task failure

This distinction matters because treating every error equally leads to two problems. First, you waste time fixing harmless deviations. Second, you dilute attention away from the handful of errors that actually determine success or failure.

TRAJDEBUG achieves 92% error detection accuracy on its test set—but more importantly, it classifies errors by whether they're likely to escalate. A navigation detour in a household robot might be completely recoverable if the robot can re-plan. TRAJDEBUG flags it as critical only when it causes the agent to miss a time-sensitive subgoal, like delivering medication before a deadline.

Key Takeaway: Not every error matters. TRAJDEBUG filters for the ones that do—by tracing whether an error actually leads to failure, not just whether it occurred.

2. The Error Lifecycle: From Occurrence to Impact

Here's a scenario from ALFWorld, a text-based embodied environment benchmark. An agent is asked to "put a clean apple in the fridge." It picks up a dirty apple from the counter. That's an error—but it's not yet a failure. The agent could wash the apple. It could put it back and grab the clean one.

The problem comes later. The agent proceeds to the subgoal "clean the apple" but it doesn't have the apple in its inventory—it left it on the counter. Now the error has propagated. The subgoal fails, the task fails, and the whole trajectory ends in frustration.

TRAJDEBUG breaks this into a three-stage lifecycle:

1. Occurrence: The initial mistake (picking up the wrong apple)
2. Propagation: How the mistake influences subsequent actions (failing to complete the cleaning subgoal)
3. Impact: The final outcome (task failure)

Most debugging approaches only catch stage 1. TRAJDEBUG traces all three. This is what separates "we saw an error" from "we understand why the agent failed."

The practical benefit is enormous. If you only know the agent picked up the wrong apple, your fix might be "improve object recognition." But if you trace the lifecycle, you realize the real failure was in state tracking—the agent didn't notice it was carrying the wrong object. Those are different problems requiring different solutions.

Key Takeaway: Spotting an error is table stakes. Tracing how it propagates through a trajectory is what actually enables meaningful fixes.

3. Multi-Level Analysis: Steps, Subgoals, and the Big Picture

Long-horizon tasks aren't flat sequences—they're hierarchical. A task like "prepare a meal" contains subgoals like "gather ingredients," "chop vegetables," and "cook." Each subgoal contains individual steps. An error at any level can corrupt the levels above it.

TRAJDEBUG analyzes trajectories at three distinct levels:

• Step-level: Individual actions (e.g., "pick up tomato")
• Subgoal-level: Logical groupings of steps (e.g., "gather all salad ingredients")
• Task-level: The overall objective (e.g., "prepare a salad")

The framework's hierarchical decomposition is what makes it possible to identify where an error becomes critical. A step-level error might be recoverable within a subgoal. But if it prevents a subgoal from completing, it becomes task-critical.

Consider WebShop, a benchmark where agents navigate an e-commerce site to find products matching specific attributes. An agent might misclick a product category early on. That's a step-level error. But TRAJDEBUG traces how this misclick leads to a cascade of wrong selections—subgoal failures—that ultimately prevent the agent from finding the target product.

By analyzing at multiple levels, TRAJDEBUG can answer questions like: "Was this failure caused by a single catastrophic step, or by three subgoal-level failures that compounded?" The answer determines whether you fix the agent's perception, its planning, or its execution monitoring.

Key Takeaway: Errors don't live at one level. TRAJDEBUG's hierarchical analysis reveals whether failures originate in individual steps, broken subgoals, or the overall task structure.

4. How TRAJDEBUG Detects and Traces Errors

TRAJDEBUG isn't a single technique—it's a pipeline. The framework combines rule-based and model-based approaches to detect, classify, trace, and pinpoint critical failures.

Here's the process:

1. Detect: Identify deviations from expected behavior using a combination of hand-crafted rules (e.g., "agent picked up wrong object type") and learned models (e.g., "this action sequence is anomalous")
2. Classify: Determine whether each error is minor or potentially critical based on its context
3. Trace: Follow the error through subsequent actions to see if it propagates and causes additional errors
4. Pinpoint: Identify the exact step or subgoal where the error becomes task-critical

The model-agnostic design is crucial. TRAJDEBUG works with both LLM-based agents and traditional reinforcement learning agents. It doesn't require access to the agent's internal state or policy—only the trajectory of actions and observations. That makes it a practical debugging tool for a wide range of systems, from GPT-4-powered web agents to PPO-trained robotic policies.

The framework also generates actionable feedback. Instead of saying "the agent failed," it produces statements like "The agent picked up the wrong object at step 12, which prevented completion of the 'clean object' subgoal at step 18, causing task failure." That's the difference between a log entry and a diagnosis.

Key Takeaway: TRAJDEBUG is a detection pipeline, not a monolithic model. Its combination of rules and learned components, plus its model-agnostic design, makes it broadly applicable.

5. Real-World Impact: Benchmarks and Results

The paper's experimental results demonstrate that tracing error lifecycles isn't just theoretically elegant—it produces measurable improvements.

ALFWorld: When TRAJDEBUG's feedback is used to correct agent behavior, task success rate improves by up to 20%. That's not a marginal gain; it's the difference between an agent that fails most of the time and one that succeeds most of the time.

WebShop: TRAJDEBUG identifies critical failures with an F1 score of 0.85. In practical terms, this means when the framework flags an error as critical, it's right 85% of the time—making it reliable enough for automated debugging pipelines.

Efficiency: Across benchmarks, agents using TRAJDEBUG feedback complete tasks in 15% fewer steps on average. This is a downstream benefit of error correction: when agents don't waste steps pursuing doomed subgoals, they reach successful completion faster.

These numbers matter because they validate the core thesis: understanding how errors propagate is more valuable than merely detecting that they occurred. The 20% improvement on ALFWorld wasn't achieved by making the base agent smarter—it came from giving the agent better feedback about where and why it was failing.

Key Takeaway: TRAJDEBUG's value isn't theoretical. It delivers a 20% success rate improvement on ALFWorld, an 0.85 F1 score on WebShop critical failure identification, and 15% fewer steps to task completion.

6. From Post-Hoc Analysis to Online Correction

The most obvious use case for TRAJDEBUG is post-hoc debugging. You run an agent, it fails, you trace the error lifecycle, and you fix the underlying issue. This is valuable for development and testing.

But the framework's design also enables online error correction. Because TRAJDEBUG processes trajectories in a way that can be streamed, it can be integrated into live agent loops. When the framework detects a critical failure forming, it can intervene in real time.

This is the difference between a post-mortem and a safety net. A household robot using TRAJDEBUG online could catch the "wrong apple" error at step 12, flag it as critical, and trigger a replan before the agent wastes 20 more steps on a doomed trajectory.

The paper demonstrates this capability, showing that TRAJDEBUG's feedback can be used to correct agent behavior during execution, not just analyze it afterward. This points toward a future of self-improving agents that don't just learn from their mistakes—they catch them in the moment.

That said, online correction is harder. It requires the framework to distinguish between errors that will become critical and those that won't, in real time. The 92% detection accuracy and 0.85 F1 score on critical failures suggest this is feasible, but there's room for improvement.

Key Takeaway: TRAJDEBUG works both as a debugging tool for post-hoc analysis and as a real-time correction mechanism for live agent execution.

7. Why Human Interpretability Matters

AI debugging has a transparency problem. When a deep reinforcement learning agent fails, the typical output is a reward curve and a log of actions—neither of which tells you why the agent failed in a way a human can act on.

TRAJDEBUG addresses this with a visualization tool that maps error lifecycles. The tool shows each step, flags errors, and draws connections between an error's occurrence, its propagation, and its final impact. A human can look at the visualization and immediately understand the failure narrative: "The agent picked up the wrong object here, which caused the subgoal to fail there, which doomed the task."

This interpretability has practical benefits. The paper's user study found that TRAJDEBUG reduces human annotation effort by 70% compared to manual error analysis. Instead of watching full trajectories and manually identifying failure points, annotators can focus on the critical failures the framework has already flagged.

Interpretability also builds trust. When you can see why an agent failed—and verify that the diagnosis makes sense—you're more likely to trust the correction. This matters for deploying agents in high-stakes environments where blind trust in an AI system isn't acceptable.

Key Takeaway: TRAJDEBUG's visualization tool makes error lifecycles understandable to humans, cutting annotation effort by 70% and building trust in AI systems through transparency.

Conclusion: Building More Robust Agents with TRAJDEBUG

The seven insights above point to a single conclusion: error tracing is the missing piece in long-horizon agent debugging.

We've known for years that long-horizon tasks are hard. Small errors compound. Failures cascade. But most debugging tools treat errors as isolated incidents. TRAJDEBUG reframes the problem—it's not just about detecting errors, but about understanding their lifecycle from occurrence to impact.

The practical results are compelling. A 20% improvement in task success on ALFWorld. An 0.85 F1 score for critical failure identification on WebShop. A 70% reduction in human annotation effort. These aren't incremental gains; they're the difference between an agent that's unreliable and one you can actually deploy.

The broader implication is about AI reliability. As agents move from research demos to real-world applications—managing calendars, controlling robots, navigating complex web interfaces—the ability to trace and correct errors becomes non-negotiable. TRAJDEBUG provides a framework for doing exactly that, and it's model-agnostic enough to work with whatever agent architecture you're using.

The future of AI isn't just about building smarter agents. It's about building agents that can recognize their own failure patterns and correct course. TRAJDEBUG is a step in that direction—a tool that doesn't just tell you the agent failed, but shows you exactly how and why it happened.

FAQ

What is TRAJDEBUG?

TRAJDEBUG is a framework for identifying critical failures in long-horizon AI agent trajectories by tracing the full lifecycle of errors—from occurrence to propagation to final impact.

How does TRAJDEBUG work?

It combines rule-based and model-based techniques to detect, classify, trace, and pinpoint errors. It analyzes trajectories at step-level, subgoal-level, and task-level to determine which errors become critical.

What types of agents can TRAJDEBUG be applied to?

TRAJDEBUG is model-agnostic. It works with LLM-based agents, traditional reinforcement learning agents, and any architecture where you can observe the trajectory of actions and states.

What are the main benefits of using TRAJDEBUG?

It improves task success rates (up to 20% on ALFWorld), reduces steps to completion (15% on average), identifies critical failures with high accuracy (0.85 F1 on WebShop), and reduces human annotation effort by 70%.

What benchmarks has TRAJDEBUG been tested on?

It has been evaluated on ALFWorld (text-based embodied environments) and WebShop (web interaction tasks), both standard benchmarks for long-horizon agent evaluation.

Does TRAJDEBUG require human annotation?

No. The framework is automated. Human annotation is optional and only needed if you want to validate the framework's findings. When used, it reduces annotation effort by 70%.

Can TRAJDEBUG be used for real-time error correction?

Yes. The framework can be integrated into live agent loops to detect critical failures as they form and trigger corrective action during execution.

What is the difference between a minor error and a critical failure?

A minor error is recoverable—it doesn't prevent task completion. A critical failure is an error that, if left uncorrected, guarantees task failure because it propagates through the trajectory and corrupts subsequent actions.

Ready to trace your agent's errors? Dive into the full TRAJDEBUG paper on arXiv (arXiv:2502.09962) and start building more reliable AI systems today.