Multi-agent failure vocabulary: the eight terms, defined

“The agent got confused” is the sentence a multi-agent postmortem falls back on when nothing in the trace explains the outcome. It names a mood. No column holds it, no check can be written against it, and the distinct things that actually went wrong all arrive at the caller in one shape: a run that finished and reported success.

Those cases separate by which boundary the fault crossed, and nothing downstream of that boundary reports which one it was. Our own three-model reliability study planted a single corrupted, load-bearing value in documents the models were asked to work over, in two variants that put the same bad number in two different places. Catch rates were low across the board: one model flagged it on 5 of the 29 items that reached it, 17.2 [6.9, 27.6] on 90% bootstrap intervals, with seven of its 36 items blocked upstream by its provider’s safety classifier and never delivered; the other two flagged none of their 36, 0.0 [0.0, 0.0] each.

This page rests on the split by location. All five catches fell on the variant where the corrupted value came in across a handoff from an earlier step. Where the same value sat in a labeled field of the document, all three models took it on every item. Five catches is a thin base, so it supports a claim about place and nothing finer: one planted fault, catchable at one boundary and invisible at the other.

Pick the term by the boundary you can watch: the output held against the brief, the turn series, the traffic between agents, or the exit. Each of the eight names below resolves to a point inside one of those four, and to a proportion you can count there. Skip that step and the postmortem produces a story where a measurement belonged.

MAST annotated real traces before it named anything

The vocabulary keys to MAST, which its authors present as the first empirically grounded taxonomy of multi-agent LLM failures. Cemri and colleagues had expert annotators read executions from seven popular multi-agent frameworks, and published fourteen failure modes in three categories: system design issues, inter-agent misalignment, and task verification (Cemri et al., Why Do Multi-Agent LLM Systems Fail?, arXiv:2503.13657, spotlight poster at NeurIPS 2025). The taxonomy itself was built from 150 traces read by hand at inter-annotator agreement of kappa 0.88, then scaled across a 1,642-trace dataset by an LLM-as-judge pipeline.

Two properties of that provenance decide how far the names can be pushed. MAST annotated other people’s systems, so a prevalence you read there is a prior about how popular frameworks wire agents together, and your own graph is under no obligation to match it. The per-mode shares are also annotation counts published without confidence intervals, which is enough to order the modes and no more. The failure-mode pillar works through the taxonomy and the containment levers it implies; this page is the index over the names.

The eight terms sort by where you can see them

Seven of the eight name a single failure mode in the taxonomy. The eighth, inter-agent misalignment, names a whole category, which is why it reads differently from its neighbors: it is the family the message-level failures belong to, sitting one level up from those in this list. One of the seven, role drift, stretches across a pair of modes, and the table gives both.

This index adds the third column. MAST sorts by where a defect originates in a system’s design, which is the right axis for a paper asking why these systems fail. An engineer holding a trace needs the other axis: the place in a running system where the fault stops being invisible.

The two axes part company in two rows.

MAST files loss of conversation history under system design, on the reasoning that a truncating context window is an architectural choice. The loss itself surfaces at a handoff, which is where this index puts it, because a handoff is where a check can sit. Role drift splits the other way: its two MAST modes sit in different categories, FM-1.2 under system design and FM-2.3 under inter-agent misalignment, while this index reads both off the same turn series.

The rest of this page works down that third column in the order the boundaries fall: what a brief and a turn series settle, what crosses the wire during the run, and what leaves at the end.

Two of the eight are judged against a standard written before the run

The yardstick for both is written before anything executes: the instruction, and the role that instruction assigned. The standard is settled in the brief, and only the breach happens at runtime. Work that breaks a constraint the instruction stated is scored against that instruction rather than against the truth of the answer, so a perfectly correct result that ignores the stated output schema still counts as a violation. The slow erosion of an agent’s remit is the same fault stretched across a long run: register and format stay intact while the territory the agent is working in slides, and no individual turn reads as a breach.

They separate on what a single output can tell you. Hold one output against the brief and a specification violation is decidable from it. Drift needs a series. One bad turn and a downward slope leave identical evidence at the end of a run. That is also why role drift is the only term here spanning two MAST modes. We read the end state as disobeying a role and the slide toward it as task derailment; the paper defines those two modes separately and does not join them, and the slope is what joins them here.

Misalignment lives in the traffic between agents

Move from the brief to the wire and the failures change character. The category MAST gives to coordination faults takes its name from where the defect lives, out in the exchange between agents. Three of the eight terms sit inside or beside it, and they part on which end of the wire holds the defect.

An agent that keeps a detail its peer needed is a defect in the sender. It holds something that would change what the receiver does next, and the message it emits leaves that out, so the repair is upstream, in what the sender is required to say. Context that did not survive the crossing is a defect in transport or representation. The sender committed the detail, the receiver still read a shorter brief, and the mechanism in between was a window eviction, a compaction pass, a serialization that dropped a field, or a summary written to a length budget instead of a contract. A dialogue that restarts mid-task is blunter than either. The whole exchange reverts, and the agreements and corrections made since the opening turn go with it.

None of the three raises an error, and that shared silence is why they group. The receiver has no way to learn a gap exists, so it fills the space with something plausible and carries on, and the run lands on the caller as a success nobody earned.

Verification and termination decide what leaves the system

The last two terms sit at the exit, where a fault either stays inside the system or gets certified on the way out. A check that returned a pass on work that does not satisfy the task sends the wrong result downstream carrying a confirmation, and every agent after it treats the work as already checked. A stop that lands with objectives still unmet hands back the partial state on the ordinary success path, so the shortfall never surfaces as an error.

Both are conditional quantities. Read the denominator before the rate. A verification failure rate counts wrong results among verifier passes, so its denominator moves with how much bad work the verifier was handed in the first place. A premature termination rate counts only runs that terminated, so a suite that culls its hangs at a timeout has quietly changed the population it describes, and publishing answer coverage beside the rate keeps that change in view. Early stopping also cuts two ways against containment. It bounds one agent’s error becoming another’s trusted input, because the fault gets no further hop to travel. At the same time it pushes the shortfall out to the boundary where a person acts on the result, with no further step left to catch it.

Which half of the pair are you looking at?

Terms in one taxonomy drift into each other wherever their symptoms overlap, and three pairs in this list overlap enough to get used for one another.

Information withholding against context handoff loss is the closest of the three. Both end with a receiver acting on a smaller brief than the sender held, and they part on whether the sender ever committed the detail to the handoff at all. Compare what the sending agent emitted against what the receiver read, and the answer falls out; guess, and you’ll rewrite a prompt when a message format was at fault.

Role drift against rubric drift shares a word and almost nothing else. Role drift moves an agent away from its remit over a long run. Rubric drift moves an LLM judge’s effective scoring standard while the rubric text it is sent stays fixed, which makes it a measurement problem living in the eval rather than a coordination problem living in the system.

Premature termination and a run that will not stop are opposite failures with a shared ending, since each one tends to finish with a person deciding the run is over. Hangs, timeouts, and the agent that never comes back covers the other direction, and the two want separate instrumentation, because the timeout that culls a hang is the same mechanism that biases a termination rate.

Four more of MAST’s modes have entries of their own

Two of the eight terms above, conversation reset and information withholding, are single modes lifted out of the inter-agent misalignment category. That category holds six. The remaining four now have glossary entries as well, so every mode in FC2 is defined somewhere on this site, while the index here stays at eight.

Reasoning-action mismatch is FM-2.6: the agent’s stated plan and its executed step diverge. Failure to ask for clarification is FM-2.2: a brief that allowed two readings gets settled by a silent guess. Task derailment is FM-2.3: the objective moves a little at each hop until the system is solving a neighboring problem. It appears above inside role drift’s pairing and now carries an entry of its own. Ignored agent input is FM-2.5: a correct signal arrives intact and gets discarded anyway. Each of the four gives a definition and a measurement section, the same two things every term above resolves to.

Where the vocabulary stops

A named mode is an annotation label, and every number hung on one inherits whatever the annotators agreed on. MAST publishes the human agreement statistic for the 150 traces its annotators read by hand, which is the right thing to do. Check which corpus a prevalence you borrow was labeled on before you quote that statistic beside it, because the scaled shares came off an LLM-as-judge pass rather than off those annotators. The per-mode shares also arrive without intervals, so they’ll support an ordering and nothing finer.

The taxonomy is fixed, and its own authors have already moved on. Failure codes induced from a system’s own traces run alongside the hand-authored list rather than displacing it: on that paper’s own numbers, coded feedback beats free text wherever the two were compared, and the adaptive codes add roughly one to five points over a fixed taxonomy. That margin starts to matter once your system’s vocabulary has grown past these fourteen names. A fixed taxonomy also says nothing about which wirings produce which modes. For that, the map of orchestration patterns to the failures each one amplifies does the work. What two rounds of debate actually measured is the worked case, where a coordination step fell below a plain vote of the same agents’ first answers in 21 of the 30 task-by-composition cells that paper reports, on three small 2024-era models.

Every name here has to become a number

Naming the failure is the first half of the job. The second is measuring it, and this cluster hands that work to the containment vocabulary next door: propagation radius for how far a fault reached, containment rate for how much of it was held at the first boundary. Failure attribution runs the other way, backwards from a wrong final answer to the node that produced it. Every runtime quantity in the table above is a proportion you compute yourself, so each of them goes out with a confidence interval, and the Wilson and Clopper-Pearson interval calculator turns a k of n into that interval directly. The one borrowed quantity, MAST’s category prevalence, arrives without an interval of its own.

The last column of the table names a quantity for every term, and every one of them is a proportion measured on a running system. The flagship profiler is designed to produce them from the other side: seed a chosen fault at one of these boundaries, then report the share held there with its interval. The profiler is not a shipped instrument yet, so no containment share at these boundaries is ours to publish. The failure modes we have been able to run ourselves are written up in our published studies, and that is where this last column will start being filled in. You can borrow MAST’s prevalence today, and a share annotated on other people’s frameworks tells you how those frameworks were wired. A containment number for your own system has to come off your own system.

If you arrived with a symptom instead of a name, start one level up: the taxonomy pillar works through the failure modes and the containment lever each one answers to. The definitional hub defines a multi-agent system from its failure surface. And every term above has its own entry in the glossary, with the calculation, the neighbors it gets confused with, and the argument for why it is worth counting at all.