AgentDebugX repairs 13 of 73 failed GAIA agent runs in one rerun

The interesting number in the AgentDebugX paper is not the overall accuracy jump, it is 13 of 73. That is how many previously failed GAIA agent runs the framework repaired in a single rerun, compared with 4 to 6 for the three decoupled self-correction baselines the authors put it up against. Overall GAIA accuracy moves from 55.8 percent to 63.6 percent. It is a tidy result, and it is pointed at a real and expensive problem: agent failures usually surface at the wrong step, so the step that logs the error is rarely the step that caused it.

The framework, described in a new arXiv paper from Kunlun Zhu and collaborators, organizes debugging as a closed loop of Detect, Attribute, Recover, and Rerun. The engine underneath is called DeepDebug, and instead of a single pass over the trace it runs multi-turn root-cause diagnosis with what the paper describes as global trajectory understanding, structure-guided investigation, and cross-examination. On the Who and When benchmark, that approach reaches 28.8 percent exact agent-and-step accuracy on qwen3.5-9b, against 21.7 percent for the strongest single-pass baseline.

Why this matters if you ship agents: the last-mile problem right now is not raw capability, it is that a hallucination at step three does not blow up the run until step seventeen, and nobody on your team has budget to replay traces by hand. Existing observability tools, in the paper's framing, replay execution traces but provide little support for identifying the root cause or translating diagnosis into recovery. The claim here is a workflow that also proposes why, and then reruns the fix. The authors ship it as a Python library, CLI, web console, and installable agentic skill, plus an opt-in Error Hub for sharing scrubbed failure-diagnosis-repair bundles as reusable debugging memory. That last piece is the interesting operator move, because pooled failure data across teams is the kind of primitive a single agent project cannot build alone.

The honest caveat is that these gains sit on two benchmarks, with the strict attribution number reported on a single open-weight backbone, and the paper does not tell you the compute cost per debug pass, which agent frameworks it plugs into cleanly, or how the approach behaves when trajectories get much longer than typical GAIA runs. Take the 13 of 73 as a directional signal about where LLM agent tooling is heading, not a settled reliability guarantee, and assume the Error Hub's sharing mechanics will need real scrubbing scrutiny before enterprise teams pipe traces into it.

If the approach holds up outside the paper's benchmarks, the winners are the agent framework vendors and enterprise teams currently writing ad hoc retry logic around fragile tool-use chains. A shared attribution layer is the kind of quiet primitive that unlocks longer, more complex agent workflows.