Reasoning-action mismatch

Reasoning-action mismatch is the failure mode in which an agent writes one plan and executes another. It states what it is about to do, the statement is coherent and frequently correct, and then the tool call it issues, the argument it passes, or the value it writes does something else. The divergence between the two is the defect. What makes the mode distinctive is that the reasoning half of the pair is sound, so an auditor reading the trace’s stated intent finds a well-formed plan at every step and no turn where the agent argued for the wrong thing.

That places the mode awkwardly for the standard containment lever. The usual move against coordination failures is a typed, verified handoff at the edge between agents, which catches a message that says less than the receiver needed or carries a claim the receiver should not trust. A mismatch produces no such message. The plan and the action both belong to one agent, and the handoff downstream carries the result of the action, correctly serialized and structurally valid, with the plan it contradicts sitting one turn earlier in a separate record. This mode and an agent that guesses instead of asking share that trap: each is a failure of a single agent’s own discipline, so a typed handoff between agents catches neither. The lever our taxonomy pillar pairs with this mode is a peer cross-check, which surfaces the divergence at the hop where the claim would become a shared premise.

MAST, the empirical taxonomy of multi-agent LLM failures, files it as FM-2.6 under inter-agent misalignment (Cemri et al., Why Do Multi-Agent LLM Systems Fail?, arXiv:2503.13657, v3, NeurIPS 2025 spotlight poster). In the distribution that revision publishes it is the largest of the category’s six modes, at 13.2% of annotated failures, ahead of task derailment at 7.40% and failure to ask for clarification at 6.80%. Read those as shares of what a labeling pipeline annotated rather than as incidence rates for your own system. MAST built 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 the per-category distribution is attributed to an analysis of 1,642 execution traces with no confidence interval attached to any of the figures. The number also moves with the revision: the April 2025 version described an analysis across seven frameworks and over 200 tasks, while the October 2025 one reports 1,642 traces. Every percentage on this page comes from the October 2025 revision.

Downstream the damage is ordinary. The action’s result enters the next agent’s context as an authoritative return, which is error propagation with clean-looking provenance, and working back from a wrong final answer to the turn where plan and action parted is a failure attribution problem made harder by the fact that the stated plan at that turn reads correct.

How to measure reasoning-action mismatch

The measurement needs two records per step and a rule for comparing them. Capture the agent’s stated intent, which in most stacks is the reasoning field or the message immediately preceding the call, and capture the call as issued, with its name and its resolved arguments. A step counts as a mismatch when the executed call is not the one the stated intent describes, a definition that has to cover the right tool invoked with the wrong arguments and the right arguments applied to the wrong object, since those are the common shapes and the flagrant case of calling an entirely different tool is the rare one.

The denominator is steps that stated an intent. A step that announced nothing has no plan to diverge from, and folding those into the denominator rewards an agent for reasoning less. Report the count and its denominator together. The result is a proportion, so it wants an interval rather than a lone percentage, for the same reason behind any eval confidence interval, and the pass-rate interval calculator returns Wilson and Clopper-Pearson bounds from k of n.

Judging the comparison is the expensive part. Deciding whether a call matches a plan written in prose is itself an act of judgment, and handing it to a model makes your mismatch rate partly a function of that judge’s reliability. Score a sample by hand first and publish the agreement between two annotators, so the rate has something underneath it before an automated judge scales it across a suite.

Reasoning-action mismatch vs specification violation

The two modes compare the same action against different documents. A specification violation measures the action against the brief the agent was given. A reasoning-action mismatch measures it against the plan the agent itself just stated. A step can fail either one on its own.

An agent can execute exactly the plan it announced and have that plan violate the brief, which is a planning fault with perfect follow-through, visible by holding the output against the original contract. It can also state a plan that satisfies the brief in every respect and then issue a call that does something else, in which case a spec-level check can still pass whenever the result happens to land inside the allowed envelope. The repairs sit in different places, which is the practical reason to keep the two apart: disobeying the specification is answered by making the contract checkable and re-asserting it through the run, and a mismatch is answered at the seam where an intent becomes a call, by logging the pair and comparing them.

Reasoning-action mismatch vs verification failure

A verification failure is a check that ran and returned the wrong verdict, or a check that never ran at all, on work the system actually produced. It is a defect in the gate. A mismatch is a divergence upstream of any gate, and its usual relationship to verification is that nothing in the pipeline was looking for it, because the reasoning trace and the action log are typically read by different people at different times, if they are compared at all.

That matters for where the fix lands. Strengthening the verifier catches a wrong final answer whatever produced it, so it does bound the consequences of a mismatch. It does nothing about the rate. A system that only gates the exit learns that a run failed, and the verifier side of that problem is a separate category with separate levers. Counting mismatches at the step is what tells you an agent’s plans and calls are coming apart while its answers are still landing correct.

Where a mismatch does the most damage

Our topology table names reasoning-action mismatch among the modes that bite hardest in a debate or voting arrangement, where the dominant propagation behavior is convergence on a shared error: a confident wrong agent herds the panel, and the majority vote launders the mistake. A mismatch is unusually well suited to that. The agent brings a correct-sounding argument to the panel, because the argument is the half of the pair that is sound, and what it actually did is not the thing the other agents are weighing. A vote conducted over stated reasoning scores the plans while the system ships the actions.

Independence is the property a panel needs before its agreement means anything, and agreement over stated plans satisfies it in appearance only. Where debate stops improving accuracy at all is worked through in the measured limits of multi-agent debate, and how much a majority actually lowers a fault’s odds of reaching the output turns on the same condition.

An agent whose trace reads correct at every step while its behavior is wrong is the case that makes trace review look more reassuring than it is, and the answer is to log the executed call beside the intent that preceded it rather than to read the trace more carefully. The other terms in this family sit in the term-by-term index for multi-agent failures, and how a coordination fault travels a topology, with the containment lever that bounds each one, is worked through in the multi-agent failure taxonomy.