Ignored agent input

Ignored agent input is the failure mode in which one agent contributes a signal that is correct, relevant, and delivered intact, and the agent receiving it carries on as though it had never arrived. The message crossed the boundary in full and was discarded on the far side. That is the whole differentia, and it is what sets this mode apart from the rest of the coordination failures, which all describe something going missing on the way: withheld at the sender, dropped in transit, or never made explicit in the first place. Here the transfer worked.

That gives the mode an evidence profile the others lack. Both halves of the failure sit in one transcript. The correct signal is on the record, and so is the decision that went against it, which makes this the one coordination fault a reader can establish from the trace alone rather than by reconstructing what somebody knew. The difficulty moves elsewhere, into the judgment the label requires: calling a case means asserting that the ignored input was right and that acting on it would have changed the outcome. Both are counterfactual claims, and a trace supports them only where the input was specific enough to check against a known answer. Vague dissent that a system overruled and a precise correction it overruled look similar in a log and mean different things.

MAST, the empirical taxonomy of multi-agent LLM failures, files it as FM-2.5 under inter-agent misalignment (Cemri et al., Why Do Multi-Agent LLM Systems Fail?, arXiv:2503.13657, v3, NeurIPS 2025 spotlight poster), at 1.90% of annotated failures, fifth of the category’s six modes. The mode is rare in that corpus and worth instrumenting anyway, for a reason specific to what it does: an ignored correction is the one failure that consumes a working defense. Whatever redundancy the system was built with, the second opinion, the reviewer, the dissenting voter, has already fired and been spent, and the run ends with the same wrong answer it would have produced with no defense at all. What the number describes is annotation frequency in someone else’s systems rather than the cost of an instance in yours.

The methodology behind that figure sets how far it travels. MAST developed its taxonomy from 150 execution traces read by expert human annotators at kappa 0.88, then scaled the labeling across seven frameworks with an LLM-as-judge pipeline, and attributes the published distribution to an analysis of 1,642 execution traces carrying no confidence interval. The revisions count different objects, the April 2025 one describing over 200 tasks and the October 2025 one reporting 1,642 traces, so the revision belongs beside any percentage lifted from the paper. Every figure here comes from the October 2025 revision.

Ignored input is what makes a debate look like consensus

The topology analysis on our failure-mode pillar names ignored input among the modes that bite hardest in two separate wirings, more than any other mode in its category. In an orchestrator-worker hub the risk is that the hub integrates one worker’s return into its plan and discounts another’s, then derives every subsequent subtask from the half it kept. In a debate or vote the mode does something worse, because it attacks the mechanism the arrangement exists for.

A panel of agents is supposed to convert independent judgments into a more reliable answer than any single one. That conversion needs the judgments to be independent, and independence is already the fragile part: three agents seeded from the same context and prompt give you one opinion sampled three times rather than three views, so a majority over correlated samples reports agreement instead of correctness. Ignored input breaks the other end of the same chain. Where one agent does produce a genuinely independent and correct dissent, and the aggregation discards it, the vote returns a clean majority that the panel’s own evidence contradicts. The output carries the confidence of consensus and the accuracy of the single wrong agent that herded it.

That is the specific reason a debate can perform worse than a lone model while looking more rigorous. Our measured account of where the pattern stops helping is in the limits of multi-agent debate, which scores two rounds of debate against the same agents’ silent first-answer vote, and the conditions a majority needs before it lowers a fault’s odds at all sets out the independence assumption underneath it. The pathology itself, a panel converging on one confident voice, is the debate failure mode.

How to measure ignored agent input

Instrument the receiving side. For each message an agent takes in, record whether the agent’s next output engages with it: adopted, explicitly rejected with a stated reason, or unaddressed. That three-way split is the useful one, because an explicit rejection is a decision the system made and can defend, while an unaddressed message is a decision nobody made. The rate to report is unaddressed messages over messages received that bore on the receiver’s current step, and that qualifier is what keeps the denominator honest, since a chatty topology floods every agent with traffic that has no bearing on what it is doing and folding all of it in drives the rate toward zero by dilution.

The rate alone overstates the problem, because ignoring an incorrect input is the right call. Pair it with correctness on the ignored subset, scored on a sample by hand, and the number that matters falls out: correct inputs that went unaddressed, over correct inputs received. Both are proportions on denominators small enough that intervals change how you read them, which is what any eval confidence interval is for, and the pass-rate interval calculator takes k of n directly.

The controlled version is cleaner and cheaper to run. Inject a correct dissent that the run needs in order to succeed, at a known point, from a known agent, and observe whether the receiver’s behavior changes. That is fault injection inverted, since what you are planting is a correct signal rather than a fault, and it gives you a denominator you wrote yourself instead of one you inferred from a log.

Ignored agent input vs information withholding

The two modes leave the same footprint at the end of a run, where a decision was made without a fact that existed somewhere in the system, and they fail on opposite sides of one boundary. Withholding is a sender-side omission: the item stayed with the agent that had it and never entered the message. Ignoring is a receiver-side discard: the item entered the message, arrived complete, and was not used.

Their evidence differs in a way that decides how you find each. A withheld item is invisible in the transcript by construction, so scoring what an agent kept back takes two records, the sender’s available context and the payload that left. An ignored item is fully present, so scoring it takes one record and a judgment about what the receiver did next. Their repairs are also unrelated. Withholding is answered at whatever composes the outgoing message, usually by a handoff schema that makes an omission a validation error. Ignoring is answered at the receiver, by requiring an agent to account for the inputs it was given before it commits, so that discarding a peer’s contribution becomes a stated decision rather than a silent one.

A defense that fires and is overruled leaves no trace of having been overruled, which is why the accounting step is the fix rather than more review. The rest of this vocabulary is indexed in the term-by-term guide to multi-agent failures, and how a coordination fault spreads across a topology, with the lever that bounds each category, is worked through in the multi-agent failure taxonomy.