From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization | Ying Chang et al. | ResearchPod

Transcript: From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization

Alex: Welcome to another episode of ResearchPod. Today, we're looking at how modern AI agents—the kind that can plan and manage long projects—learn from their own mistakes.

Sam: That's right. We're discussing a framework called STRACE—Structural Trajectory Analysis and Causal Extraction. The core claim is that AI agents often fail because of a small, hidden logical error made early on, but they struggle to find it because they get buried in the noise that happens afterward.

Alex: So this paper is arguing that when an AI project fails, we're usually looking at the wrong part of the story?

Sam: Exactly. Think of a mistake made on Monday. By the time things fall apart on Friday, the system blames the Friday task—because that's where the crash happened. STRACE acts like a detective that ignores the irrelevant footage and jumps straight to that Monday mistake.

Alex: Okay, I follow. Why is that so difficult for current AI systems to do on their own?

Sam: It's a genuine trade-off. If you show an AI the entire log of everything that happened, it gets overwhelmed by irrelevant steps and starts inventing fixes that don't address the real problem. But if you only give it a tiny snippet from the end, it misses the cause entirely. The system needs to know which parts of the history actually matter—and right now, most systems can't make that judgment.

Alex: So how does STRACE decide what matters?

Sam: It builds what the paper calls an Execution Dependency Graph. Think of it like a detailed floor plan of a building's plumbing. If a pipe bursts in the basement, the map tells you exactly which valve in the kitchen caused the pressure change—without you having to inspect every room in the house.

Alex: Oh—so it's literally mapping the cause-and-effect chain of everything the software did.

Sam: Precisely. And once it has that map, it performs what's called "backward slicing." It starts at the point of failure and traces the path backward through the map, stripping away any steps that had no influence on the final outcome. What's left is a clean, minimal account of exactly what went wrong and why.

Alex: That sounds much more efficient than reading the whole log. Does it actually improve how well the agent performs afterward?

Sam: The results the paper reports are notable. On complex, multi-step tasks, they saw a significant improvement in success rates compared to agents that learned from unfiltered logs. The agents trained with STRACE were able to identify and correct the actual source of their errors, rather than patching the symptoms.

From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization

Ying Chang, Jiahang Xu, Xuan Feng, Chenyuan Yang, Peng Cheng, Yuqing Yang

Jul 8, 2026·5:04·arxiv·Original Paper

STRACECausal LocalizationCompound Agent SystemsReflection-based OptimizationContext-Noise Trade-offReflexive Optimization

Listen

5 min

Briefing

Research Question

As compound agent systems become more complex, they generate massive, noisy execution traces that are difficult to use for automated optimization. Existing methods often struggle with a context-noise trade-off: either including too much irrelevant information, which leads to spurious correlations, or truncating traces, which discards the long-range causal dependencies necessary to identify why a failure occurred. This paper asks: how can we effectively distill these noisy, heterogeneous logs into high-quality diagnostic signals to improve agent policies?

The STRACE Approach

STRACE (Structural Trajectory Analysis and Causal Extraction) treats execution logs as structured causal graphs rather than linear text. The framework operates in four phases:

Structural Modeling: It parses the agent's codebase to build an Execution Dependency Graph (EDG), mapping data and control dependencies between functional modules.
Failure Pattern Mining and Trace Filtering: It compresses large batches of failure logs by clustering them based on statistical severity and structural path patterns, retaining only a diverse, representative set of exemplars.
Causal Localization: For each selected trace, the system performs a backward slice through the EDG. Starting from the manifestation of an error, it prunes irrelevant steps to isolate the specific 'root cause' module where the logical defect originated.
Inductive Policy Optimization: It synthesizes generalized heuristics from these localized causal slices and injects them directly into the instructions of the identified root-cause modules.

Why It Matters

By shifting the focus from repairing downstream symptoms to addressing upstream root causes, STRACE enables more precise and stable agent evolution. In empirical evaluations, including the challenging VeruSAGE-Bench formal verification task, STRACE significantly outperformed standard context-filtering and prompt-optimization baselines, delivering a 16% absolute improvement in success rates. This demonstrates that structural awareness is critical for scaling the optimization of complex, long-horizon agent systems.

Key Terms and Definitions

Execution Dependency Graph (EDG) — A textual representation of an agent's internal modules and their data/control relationships, used as a structural prior for causal analysis.
Manifestation Node — The specific step in an execution trace where a failure (such as a runtime exception or task timeout) becomes visible.
Root Cause Node — The upstream module where the logical error or incorrect decision actually originated, which may be several steps removed from the manifestation node.
Causal Slice — A distilled subset of an execution trace containing only the steps that structurally influenced the failure, obtained by traversing the EDG backward.
Inductive Policy Optimization — The process of abstracting generalized, reusable heuristics from multiple localized failure episodes to update agent instructions.

Abstract

The optimization of long-horizon agents increasingly relies on reflection-based mechanisms, where a large language model (LLM) acts as an optimizer to diagnose agent failures and improve agent policies. However, real execution traces are difficult to use directly for optimization: large trace collections are often redundant and heterogeneous, making optimization inefficient and prone to overfitting to low-value failures; meanwhile, each individual trajectory also contains many irrelevant steps, while naive context reduction methods such as truncation or sliding windows can discard causally important evidence and produce misleading optimization signals. To resolve this dilemma, we introduce STRACE (Structural TRajectory Analysis and Causal Extraction), a framework that constructs high signal-noise optimization contexts for more precise and effective optimization. At the batch level, STRACE mines failure patterns to filter redundant traces and retain representative failures; within each selected trace, it performs causal localization over a textual dependency graph to remove non-causal steps and identify the true root-cause module for optimization. Empirical results demonstrate that STRACE significantly outperforms standard context-filtering baselines. Notably, on a challenging formal verification task (VeruSAGE-Bench), it successfully optimizes human-expert designed agents, delivering $1.4\times$ success-rate improvement (42.5% to 58.5%). The code is available at https://github.com/moomight/STRACE .

From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization: Research Paper Podcast