The question behind the study

When an AI agent fails a long task, the usual post-mortem names a symptom. It might be a label from a failure taxonomy, or the name of the agent that gets the blame. Four researchers from Villanova University's Department of Electrical and Computer Engineering think that's too shallow. Shaohuang Wang, Jinghao Wen, Xulei Zhang and Xun Jiao posted their preprint to arXiv on 9 November 2026. Their argument is that a label doesn't tell you when the fault first appeared, how it spread, whether anything in the run contradicted it, or which safeguard could have caught it.

To answer those questions they built what they call an "episode record." Each record follows one fault from where it started, through how it spread, whether anyone noticed, what happened next and how the run ended. It places the fault in one of eight operational phases and six kinds of state, and it tags how the error behaved over time, for example whether it contaminated later steps. Last, it lists which families of controls could have seen or changed the fault.

Where the traces came from

The team didn't run new agents. They reused two public collections of failed runs. The first is Who&When, from a 2025 paper by Shaokun Zhang and colleagues on automated failure attribution. It holds failure logs labelled with the responsible agent and the "decisive" error step, and it was built to test whether models can find who broke a run and when. In that original paper the best method named the right agent 53.5% of the time but found the right step only 14.2% of the time. The second is the human-labelled part of MAD, the data behind the MAST taxonomy from Mert Cemri and colleagues at Berkeley. MAST sorts multi-agent failures into 14 modes across three groups: system design, misalignment between agents, and task verification.

From Who&When, the Villanova team took 29 hand-crafted runs from the Magentic-One system and 59 algorithm-generated runs from AG2's CaptainAgent. They added 8 MAD traces. One MAD run had actually reached the right answer, so it was left out of the outcome numbers. That leaves 95 failed runs from six multi-agent systems. They also dropped seven traces longer than 200,000 characters.

Who did the labelling

This is the part builders should weigh most carefully. A single large language model, Claude from Anthropic, annotated every trace, with one fresh instance per trace. It followed a written protocol of about four pages and 38 fields, which the authors refined after a 20-trace pilot. The model rated its own confidence as high on 38 records, medium on 55 and low on 2.

There's no human agreement check. The authors say so plainly and list it among their limits. They did tie every step field to a line in the trace, validate records against a schema, and compare the model's chosen fault origins with the human decisive-step labels already in Who&When. They also note that deciding what kind of fault each one was proved hardest to get right. So we'd read the numbers below as a careful first map, and we wouldn't treat them as settled measurements.

What they found

Faults show up early. In the Who&When runs, the fault's origin sat at a median of 0.18 of the way through the run. The visible symptom came a median of 5.5 steps later, or 0.67 of the run length. In 37 of 88 Who&When runs, the origin came before the step that human labellers had marked as decisive. The two matched in 40 runs, and the origin came later in 11.

Most faults are bad calls or made-up facts. Wrong decisions made up 42% of origins, fabrications 26% and integration problems 11%. Seventy-one runs had their fault in task and knowledge state, meaning what the agents believed about the job and the world. Contamination of later steps showed up in 74 runs.

The evidence was often sitting there. In 68 runs, or 72%, something in the trace contradicted the error before the failure surfaced. Agents acted on it in just 7 of those runs. Some part of the system flagged a deviation in 29 runs (31%), and 34 runs saw some response, usually a replan or a retry. None of those responses fully cleared out the bad state, and only 4 cleared part of it.

Rolling back often wouldn't help. Restoring an agent's own state to just before the fault would have been enough in 35 of 95 runs. In 56 runs the fault lived in a plan, a brief or a stopping rule, so a restore would simply replay it.

Which safeguards could have reached the faults

The authors scored eleven control families by how many episodes each could plausibly reach. An independent judge that reads the trajectory reached 74%. A task contract fixed when the job is accepted reached 67%. Checking beliefs against the real environment reached 43%, and stall or termination rules reached 40%. Tests reached only 21%, and checkpoints just 1%. When they asked which control was the most direct fix, provenance tracking led with 20 runs, followed by task contracts and environment checks on 17 each.

These are judgments made about the traces. No control was actually switched on and run, and the authors are clear about that.

A bug hiding in a benchmark

The most practical finding is about the test harness. A plain text scan of all 184 raw Who&When failure traces showed that 26 of the 58 hand-crafted runs (45%) hit an HTTP 400 content-filter error from the model provider. In 25 of those, the harness then printed a final answer that no agent had written. The benchmark blamed a non-orchestrator agent for 21 of those 25 and the orchestrator for 4. None of the 126 algorithm-generated runs had the crash. Symptom taxonomies and blame labels can't see this kind of failure, so the authors want harness-ended runs marked and reported apart from agent errors.

Limits worth keeping in mind

  • One AI annotator and no inter-annotator agreement figure.
  • The 96 records were picked by annotation batch, so they aren't a random sample, and the MAD slice is small and leans toward short traces.
  • Every task was question answering or programming. No run touched a shared or outside system, so the study says nothing about real-world side effects or undoing them.

What builders can take from it

There's little extra compute cost in most of these ideas, since they're mostly about reading logs you already have. We'd start here:

  • Scan your own logs for harness failures. If a provider error can end a run and something still prints an answer, your success and blame numbers are off. Checking for it's a grep.
  • Add a reader for ignored evidence. A separate judge that looks for contradictions the worker skipped had the widest reach in this study.
  • Pin the task at intake. Write down what "done" means before work starts, so later steps can be checked against it.
  • Re-check beliefs against the environment. Don't let a fact that a model asserted early on travel unchecked through the run.
  • Pair rollback with replanning. Restoring state without fixing the plan tends to reproduce the loop.
  • Spot-check annotations with people. If you use a model to label failures, as this study did, have humans review a sample.

The protocol, all episode records and the analysis scripts are attached to the arXiv submission as ancillary files, so teams can run the same method on their own traces.

Sources

Build with people working on the same things

Join the Auckland Society for AI: NZ$599 a year with a ForgeBox and the members' projects area. Our Auckland meetups are open to everyone.

Become a member