What is causal trace localization?

Causal trace localization reduces an agent's long execution trace to the few steps that actually caused a failure, rather than to the steps where the error became visible or simply the most recent steps. STRACE, posted to arXiv in July 2026, does it by building a dependency graph over the run and walking backward from the failure along those edges to keep the steps that explain it, then naming the module to fix. The output is a pointer at a root cause, not just a shorter log.

How is STRACE different from just trimming a trace to fit the context?

Length-based trimming keeps the most recent steps or whatever fits the budget, but the step that broke a long-horizon run can sit early, so trimming can delete the cause and keep its downstream symptoms. STRACE cuts by cause instead: at the batch level it mines failure patterns and keeps one representative per pattern, then within each trace it uses a dependency graph and causal localization to keep the steps that explain the failure. On VeruSAGE-Bench it lifts a human-designed formal-verification agent from 42.5% to 58.5% success.

Why does localizing the cause matter for improving an agent?

Because you optimize whatever the reduced trace points at. If the trace points at the tail — a symptom — you tune the wrong module and the real bug survives. Localizing the causal step and its module means the feedback you train on names the thing that actually needs to change, which is the Evals & Diagnostics principle that you cannot fix what you cannot locate. STRACE reports a 1.4x success-rate gain from making the traces causal rather than recent.

STRACE extracts causal root causes from noisy agent traces — Causal trace localization

Jargon

Execution trace: The full ordered log of everything an agent did on a task — every tool call, observation, and intermediate thought. It is what you replay to debug, and for a long task it can run long, full of noisy, irrelevant steps.
Long-horizon agent: An agent that works a task over many steps rather than answering in one shot — so its trace is long, and a single early mistake can compound through everything after it.
Causal localization: Finding the step (or few steps) whose mistake caused the failure — not just the step where the error became visible. STRACE does this by tracing dependency edges back from the failure to its root.
Dependency graph: A graph where each step points to the earlier steps it depended on. STRACE builds a textual one over a trajectory so it can walk backward from the failure along real cause-and-effect links.
Failure-pattern mining: Grouping many failed runs by how they failed and keeping one representative per group, so near-identical failures don't all get re-analyzed. STRACE runs this at the batch level, before touching any single trace.
Root-cause module: The specific component of the agent — a tool, a prompt, a sub-routine — that the localized step blames. Naming it is the point: it turns a failed run into a concrete thing to fix.

The news. In July 2026, researchers posted STRACE to arXiv. It targets a plumbing problem in improving long-horizon agents from their own runs: the execution traces you'd learn from are redundant, heterogeneous, and full of irrelevant steps. STRACE reduces each trace to the steps that causally explain a failure and points at the module to optimize. On VeruSAGE-Bench, it lifts human-designed formal-verification agents from 42.5% to 58.5% success — about a 1.4× gain. Read the paper →

Picture the detective's cork board. A hard case leaves you with a wall of pinned clues — statements, receipts, camera stills — and most of them lead nowhere. The mistake a rookie makes is to read only the last few pages of the file, because that's where the body turned up; but the act that doomed the case happened early, and every later clue only inherited it. An agent's execution trace is that wall. When a long-horizon agent fails a task, its trace is a long, noisy trail — searches, tool calls, dead ends — and if you want to learn from the failure to improve the agent, you first have to cut that wall down to what matters.

The tempting cut is by length: keep the most recent N steps, or whatever fits the context budget, and throw the rest away. That is exactly the rookie's move — it optimizes for recency, and the step that actually broke the run can sit early, far from the tail. A misparsed table early in the run quietly poisons every step after it; trim to only the most recent steps and you've deleted the cause while keeping its inherited symptoms. Feed that back into training and you'll "fix" the wrong module. This is the error-analysis gap the Evals & Diagnostics module keeps hammering: you cannot fix what you cannot locate, and length is not location.

STRACE cuts by cause instead, in two passes. First, at the batch level, it mines failure patterns across many runs and keeps one representative per pattern — the near-identical witness statements collapse to a single card, so redundant traces don't all get re-analyzed. Then, within each kept trajectory, it builds a textual dependency graph — the red string linking each step to the ones it depended on — and performs causal localization: it walks backward from the failure along those edges, keeps the steps that explain it, and names the module to fix. The output isn't a shorter log; it's a pointer at a root cause.

Way to shrink a trace	What it keeps	What it loses
Length-based trimming	the most recent steps / whatever fits the budget	a causal step that isn't recent
Dedup by similarity	one copy of each look-alike step	still answer-blind — no cause, no module
STRACE (causal localization)	the causal steps + the module to optimize	redundant & irrelevant steps (kept the cause: 42.5% → 58.5% on VeruSAGE-Bench, paper)

Here is why the causal cut is worth the trouble. Picture one failed run of, say, 40 logged steps where the true culprit is step 6 (illustrative step counts; the paper's per-trace lengths vary). Length-based trimming keeps the last 10 to fit a budget, so step 6 is gone, and you'd tune whatever module ran near step 35 while the real bug survives. STRACE instead follows the dependency edges back, keeps the handful of steps on the causal path, and discards the rest as redundant. Fed those causally-reduced traces, a human-designed formal-verification agent's success rate climbs from 42.5% to 58.5%, about 1.4× (only the 42.5% → 58.5% and 1.4× figures on VeruSAGE-Bench come from the paper). The lever is the traces themselves: causally reduced instead of length-trimmed.

Goes deeper in: AI Agents → Evals & Diagnostics → Error Analysis First

Continue in trackObservability: replaying an agent's trace to find where it broke

Related explainers

TELBench — span-level error localization — the sibling move: point at the first-error span in one deep-research run, instead of grading only the final answer
FAPO — failure-attribution-gated optimization — once you've attributed the failure, gate the optimizer on it — the step after STRACE names the module
PreAct — compiled trajectory replay — a different lens on the same raw material: turn agent runs into replayable programs you can rerun
Agentic CLEAR — system/trace/node eval granularity — why grading agents at the trace and node level, not just the system level, is the broader trend STRACE rides

Frequently Asked Questions

Check what you knowMap your AI & GPU knowledge across every track — free, role-based