Measuring and Bounding Error Amplification in Multi-Step LLM Reasoning

When a language model answers a question in several steps, whether by hopping between documents or issuing a sequence of shell commands, one wrong intermediate claim becomes context for every later step. Current work mostly watches this happen. It estimates how uncertain each step is, or it attributes failures to upstream causes after the fact. Nobody has measured how strongly each step amplifies an error it inherits, and nobody has used that measurement to decide where to intervene. Control engineers have a precise version of this question for vehicle convoys. In a convoy, a speed disturbance at the lead car must not grow as it passes down the line. This property is called string stability, and it is enforced by bounding the worst-case gain from an incoming disturbance to the outgoing error. That gain bound is the core quantity of $H_\infty$ control, which designs feedback against the worst finite-energy disturbance rather than an average one.

We propose to treat a reasoning chain like a convoy. We would deliberately inject controlled errors at each step and measure the worst-case amplification of each link. Then we would close feedback loops, in the form of re-grounding and verification calls, only on the links whose measured gain exceeds one. The goal is a chain whose end-to-end error amplification is empirically bounded by a target $\gamma$ under a fixed verification budget. The central bet is that the steps that amplify errors are not the same as the steps that look uncertain. If that is true, allocating correction by gain should beat allocating it by uncertainty, especially under adversarial mid-chain corruption.

Core Claim

The evidence that errors compound is already strong. AgentEval models agent workflows as graphs of dependent steps and finds that 63% of step-level failures are inherited from upstream. UProp splits step uncertainty into an intrinsic part and a part propagated from history, and shows that the propagated part dominates as trajectories lengthen. Both are diagnostic. AgentEval works post hoc with an LLM judge, and UProp is a passive detector. Neither measures a step's sensitivity to corrupted input, and neither acts on it. On the control side, Lan enforces string stability in platoons with unknown nonlinear dynamics by embedding an $H_\infty$ gain condition in a convex program learned from data. We supply the method-level idea from that work, a per-link gain condition estimated from data, and not its machinery.

We define the gain of link $k$ operationally. Let $w$ be a sequence of injected corruptions over steps, with per-step magnitude given by a graded corruption level. Let $z$ be the resulting sequence of downstream per-step errors, measured as the excess error rate over the clean run. The empirical worst-case gain from step $k$ onward is

$$\hat\gamma_k = \max_{w \in \mathcal{W}_k} \frac{\|z\|_2}{\|w\|_2},$$

where $\mathcal{W}_k$ is a library of corruption types injected at step $k$ (wrong bridge entity, contradicted fact, distractor passage, false-premise misconception), and the norms sum squared errors over steps. This is a direct analogue of the bound $\|z\|_2 \le \gamma\|w\|_2$. The chain is semantically string stable at level $\gamma$ if $\hat\gamma_k \le \gamma$ for every $k$.

We are explicit that this is an empirical certificate over a finite perturbation library, not a Bounded Real Lemma proof. A transformer is not a linear time-invariant system, and pretending otherwise would be the wrong kind of rigor. The certificate is useful because it is worst-case over the corruption library and not averaged over natural errors, and because a new corruption type can falsify it.

Research Program

The first component is a perturbation-injection harness for multi-hop question answering on HotpotQA, StrategyQA, and AgentBench-OS from AgentBench. The harness runs a model through a fixed decomposition and replaces the output of step $k$ with a graded corruption. It then records whether each later step and the final answer go wrong. In AgentBench-OS, the corruption is a falsified command output. From these runs we estimate $\hat\gamma_k$ per step type, such as bridge-entity lookup, comparison, or command interpretation, so that gains transfer to new questions without re-injecting at test time. At test time, a small classifier predicts the gain class of each step from features that include the step type and the model's attention concentration on prior generated tokens versus source documents. That second feature is motivated by the in-context sharpness signal of Chen et al..

The second component is the feedback controller. A correction operator re-derives a step from the source documents with the prior step's claim masked. It also cross-examines the claim with indirect questions, the probe that Agrawal et al. found exposes fabricated content. We model each correction as reducing a link's gain by a factor measured in calibration. Given a budget of $B$ correction calls per question, the controller chooses which links to close. It minimizes the predicted end-to-end gain, the product of link gains along the dependency path, subject to the budget. This is a small knapsack problem, not an SDP, and we say so plainly. The worst-case framing is borrowed from $H_\infty$ control, but the synthesis is combinatorial.

The third component is analysis. We will test whether gain and uncertainty dissociate. The prediction is that confident steps which faithfully copy their context have high gain and low uncertainty, which is exactly the regime where uncertainty-triggered correction fails. We will also test whether larger models have higher link gains. That would be a chain-level echo of the inverse-scaling finding in TruthfulQA, where more capable models imitate their inputs more faithfully.

Baselines

The naive reference point is the open-loop chain: the same decomposition and model with no corrections. It fixes the clean error rate and the raw amplification profile against which everything else is measured.

The strongest competitor on the actual question, which is where to spend a limited correction budget, is uncertainty-triggered correction. It uses the propagated-uncertainty score of UProp to rank steps and applies the identical correction operator to the top-$B$ steps. UProp reports AUROC gains of 2.3% to 9.2% over seven single-turn uncertainty baselines on AgentBench-OS and 3.5% to 11% on StrategyQA. On HotpotQA, no reported result was found on Lacuna for UProp. We will re-run UProp with the same models, the same sampled trajectories for its uncertainty estimates, and the same number of correction calls. We will also count its sampling cost against the compute budget, since UProp needs multiple trajectories and our gain classifier does not. Beating it means lower final-answer error and lower worst-case $\hat\gamma$ under held-out corruption types at equal budget and compute.

The strongest within-step method is Activation Decoding from Chen et al.. It penalizes candidate tokens with diffuse contextual attention and reports an average 16.1% F1 improvement on HotpotQA across model sizes, with about 23% latency overhead. It is complementary rather than competing, so we run it alone, and combined with both allocation policies, to check that gain-based allocation adds value on top of better decoding.

The upper reference is always-correct: every step is verified, which removes the budget constraint. Two ablations isolate the key ingredient. The first is random allocation at equal budget. The second allocates by gains estimated only from naturally occurring errors, with no injection. That ablation tests whether deliberate worst-case probing matters or whether average-case error statistics suffice.

Why not just…?

Why not just trigger verification when UProp-style uncertainty is high? This is the real threat. If per-step uncertainty and measured gain correlate strongly across step types, our method reduces to UProp with extra steps. The first experiment below measures this correlation directly. If the Spearman correlation between step-type gain and mean propagated uncertainty exceeds about 0.8 and gain-based allocation does not beat uncertainty-based allocation at equal budget, we will report the negative result rather than rescue the idea. The mechanistic reason to expect divergence is that the dangerous failure is confident propagation. A step that trusts a wrong premise can be low-entropy. HaluEval's finding that ChatGPT detects its own hallucinations with only 58.53% accuracy in summarization (Li et al.) suggests that model-internal confidence misses much of this.

Why not just verify every step? Always-correct is included as the upper reference. It is the right answer when calls are free. The question is how much of its benefit a budget of one or two calls per chain recovers. If random allocation already recovers most of it, the allocation problem is uninteresting, and the ablation will show that.

Why not just use retrieval-augmented generation or better prompting? Retrieval does not stop a model from preferring its own earlier claim over a retrieved passage. TRAC notes that retrieval pipelines still hallucinate on noisy contexts. Prompting-based consistency is fragile: Chen et al. report Fleiss kappa from −0.002 to 0.984 across prompts on clinical guideline questions. Our chains already use retrieved documents, so the experiment measures amplification given retrieval.

Proposed Experiments

We use Llama-3-8B and Mistral-7B, the models evaluated in TruthFlow, plus one larger open model to test scaling of link gain. Evaluation covers HotpotQA dev, StrategyQA, and AgentBench-OS. The corruption library is split by type into calibration types and held-out types. The held-out types include false premises drawn from TruthfulQA misconceptions and inserted mid-chain.

The first decisive check is the dissociation test. For each model and dataset, we measure the correlation between step-type gain and UProp uncertainty, and count high-gain, low-uncertainty steps. The second is the allocation comparison: final-answer exact match and F1 at budgets of one, two, and three corrections, for gain-based, uncertainty-based, random, and natural-error allocation. The third is the worst-case test. On held-out corruption types, we compare the maximum downstream error ratio $\hat\gamma$ across policies. Gain-based allocation should achieve a lower worst case even where its average accuracy ties. That would be the signature of the worst-case framing earning its place. The fourth is a transfer check: gains estimated on HotpotQA step types are applied unchanged to StrategyQA, to see whether link gain is a property of step type and model or must be recalibrated per task.

The project succeeds if gain-based allocation beats UProp-based allocation at equal budget and compute on held-out corruption, and if at least one model and dataset reaches $\hat\gamma \le 1$ on every link with two or fewer corrections. It fails, informatively, if gain and uncertainty turn out to be the same signal.