Paper deep dive
Attention Tax, Handoff Tax: A Stylised Model of When Multi-Agent LLM Systems Help
Akshit Anchan, Nayonika Sen
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Recent work on multi-agent LLM systems reaches sharply different conclusions: some results show that a single agent with the same information and compute should dominate a delegated system, others that multi-agent gains grow with task depth. We argue that much of the disagreement comes from modelling different bottlenecks, and introduce a stylised reliability model built around two trade-offs. Decomposition reduces the burden of long contexts but incurs a handoff tax when information is compressed or transferred between agents. Redundancy gains from multiple samples, but its benefit depends on how much their failures are shared. With reasoning budget, verification, and task structure added, the model yields two crossover conditions: decomposition becomes preferable once the attention cost avoided by resetting context exceeds the handoff cost, and parallel sampling at equal budget is eventually preferable when its shared-failure floor lies below the error floor of one agent thinking longer. We connect these regimes to recent theoretical and empirical results. On a ledger-reconciliation task we measure the context-degradation curve and the handoff tax from single-agent and handoff runs alone. From these the model places the crossover at depth 10 and predicts decomposition to win at depths 20, 50, and 100. It does, on step-level and final-balance accuracy, and the decomposed system's success, which the prediction never sees, lands within 9 percentage points of the predicted rate at every depth.
Tags
Links
- Source: https://arxiv.org/abs/2610.06069v1
- Canonical: https://arxiv.org/abs/2610.06069v1
Trouble viewing inline? Open PDF directly →
Full Text
107,199 characters extracted from source content.
Expand or collapse full text
Attention Tax, Handoff Tax: A Stylised Model of When Multi-Agent LLM Systems Help Thanks: Citation: A. P. Anchan and N. Sen. Attention Tax, Handoff Tax: A Stylised Model of When Multi-Agent LLM Systems Help. Preprint, 2026. Akshit Anchan Affiliation: University of Amsterdam Affiliation: Amsterdam, The Netherlands Email: akshit.anchan@student.uva.nl Nayonika Sen Affiliation: Northeastern University Affiliation: Boston, MA, United States of America Email: sen.na@northeastern.edu Abstract Recent work on multi-agent LLM systems reaches sharply different conclusions: some results show that a single agent with the same information and compute should dominate a delegated system, others that multi-agent gains grow with task depth. We argue that much of the disagreement comes from modelling different bottlenecks, and introduce a stylised reliability model built around two trade-offs. Decomposition reduces the burden of long contexts but incurs a handoff tax when information is compressed or transferred between agents. Redundancy gains from multiple samples, but its benefit depends on how much their failures are shared. With reasoning budget, verification, and task structure added, the model yields two crossover conditions: decomposition becomes preferable once the attention cost avoided by resetting context exceeds the handoff cost, and parallel sampling at equal budget is eventually preferable when its shared-failure floor lies below the error floor of one agent thinking longer. We connect these regimes to recent theoretical and empirical results. On a ledger-reconciliation task we measure the context-degradation curve and the handoff tax from single-agent and handoff runs alone. From these the model places the crossover at depth 10 and predicts decomposition to win at depths 20, 50, and 100. It does, on step-level and final-balance accuracy, and the decomposed system’s success, which the prediction never sees, lands within 9 percentage points of the predicted rate at every depth. Keywords multi-agent systems ⋅· large language models ⋅· context length ⋅· test-time compute ⋅· reliability 1 Introduction There is a live argument about whether multi-agent LLM systems are worth building, and it has now been formalised by both sides. Tran and Kiela [1] argue from the data processing inequality that under equal reasoning-token budgets a single agent is more information-efficient than any system that passes summaries between agents, and they confirm it on multi-hop question answering across three model families. Ao et al. [2] prove the decision-theoretic version: without new exogenous signals, any delegated network is dominated by a centralised Bayes decision maker with access to the same information. On the other side, Tang et al. [3] prove that the relative gain of a multi-agent system over a single agent increases in both task depth and task width, and grows without bound in depth. Meyerson et al. [4] then solve a million-step task with zero errors by decomposing it into single-step subtasks, something no single agent comes close to. And Jwalapuram et al. [5] put both outcomes in one table: a self-consistency baseline outperforms six automated multi-agent frameworks almost everywhere they test, often at under a tenth of the cost, while an expert-designed decomposition raises GPT-5 from 57.0 to 96.5 on a context-heavy task the automated frameworks also fail. Taken together, the papers cannot all describe the same world, and yet each of them is a theorem. Our claim is that much of the contradiction comes from bookkeeping. Each of these models fixes some of five quantities and lets the others move, and a quantity one side fixes is often exactly the one the other side varies. The sceptics’ dominance theorems hold for a single agent whose per-step accuracy does not depend on how much sits in its context, and where they relax that, the relaxation is an exogenous corruption level rather than accumulated load. Positive results likewise use different assumptions about information, context, communication and compute. MAKER explicitly analyses voting costs and passes task state between steps. This paper writes down a stylised model with all five quantities and works out what happens in it. A task is a chain of L steps. A step is an LLM call whose failure probability ε(c,b) (c,b) depends on the context load c it attends over and the thinking budget b it receives. Two structural primitives are available: decomposition, which gives each agent a fresh context at the price of a handoff loss h, and redundancy, which runs N parallel calls whose failures are dependent because they share a base model. Verifiers at boundaries recover some errors. Budgets are matched per step. Each prior result then corresponds to a restriction of the model. We say for each whether the correspondence is exact, structural, or an analogy. The decomposition question has a crossover. For single-step agents there is a unique depth L∗L^* past which decomposition wins, and it exists if and only if the curve’s asymptotic rise above a fresh agent’s operating point exceeds one handoff’s cost. For arbitrary chunk sizes the criterion is the total tax a fresh agent avoids over its whole run, which can exceed the handoff cost even when the single-step gap does not. A flat curve gives no crossover at any chunk size, which is the sceptics’ conclusion. In the linear regime the crossover and the chunk size have closed forms. The redundancy question compares two floors under a latent-rate mixture model of the samples: parallel sampling at equal budget wins for all sufficiently large sample counts whenever its shared-failure floor, ρερ\, in our common-shock example, is below the single agent’s saturated thinking error ε∞ _∞. Equal floors require a finite-budget comparison. Two measurements accompany the model. The first is a padded-context pilot: a thousand calls to a self-hosted gpt-oss-20b at five context loads, which measures the curve and nothing else, and which showed that the curve’s shape depends on what one counts as a step failure. The second is the test the model asks for. On a ledger-reconciliation task with two long-range dependencies, we measured the in-task curve from single-agent runs and the handoff tax from paired continue-versus-handoff runs, and computed from those two measurements alone the depth at which decomposition into five-step agents should start winning and the success rate of each system at every tested depth. The decomposed system won at every depth, as predicted. The predicted crossover sits at depth 10 and the shallowest depth we ran was 20, so the runs test the winner past the crossover and not the crossing itself. What is proved, what is assumed, what is measured. Because the paper mixes four kinds of claim, Table 1 sorts them before any symbols appear. Everything in the first row is a theorem inside the model of Section 3, and nothing in it is a statement about LLMs except through the assumptions in the second row. Table 1: Reading guide. Where each kind of claim lives in the paper. Status Content Proved, within the model Theorems 1 to 6, Corollaries 1 to 4, and Proposition 2. Proposition 1 is a derived approximation, numerically checked. Proofs are in Appendix A, and key closed forms and boundary cases are checked numerically in Appendix B. Assumed Assumptions 1 to 4 (product form, monotone curve, context growth, handoff monotonicity), a latent-rate mixture model for parallel samples, and the common-shock law used as a worked example. Proposition 3 is conditional on an untested hypothesis about verifiers. Measured A padded-context curve for one model (Section 9). An in-task curve, a handoff tax at three note lengths, and single-agent and decomposed success at three depths on one task with one model (Section 10). Interpreted The placement of published results in regimes (Section 8), the illustrative crossover depths computed from the pilot curve under assumed handoff costs (Section 9), the proposed mechanism for the instruction-compliance decay, and the location of the ledger crossover below depth 20 (Section 10). 2 The three camps, and what each holds fixed Sceptics. Tran and Kiela [1] model the messages between agents as a Markov chain on the task information and apply the data processing inequality. Their dominance result assumes “perfect context utilization”: the single agent extracts from a long context everything it would extract from a short one. They then relax it. Their Section 3.1 models an effective context degraded by an exogenous corruption level, shows by the same inequality that the single agent’s achievable error is monotone in that level, and their Section 5.3 corrupts contexts by masking and substitution and finds the ordering reverse at heavy corruption. What they do not have is degradation as a function of the load a trajectory accumulates, a depth or chunk-size model, or a way to compute where the reversal falls from measured quantities. That is the gap this paper fills, and the sceptic corner of our model is their undegraded case. Ao et al. [2] work at the level of information structure and deliberately not at the level of token generation. Their delegated decision network has nodes with decision rules, a common signal (the shared context), private exogenous signals (tool outputs), and messages along edges. Proposition 6 there says that with no new exogenous signals the network is dominated by a centralised Bayes decision maker, and Theorem 8 says the loss from communication is an expected posterior divergence, equal to the conditional mutual information I(Y;H|M)I(Y;H\,|\,M) under log loss. The centre in their model has no capacity constraint, and a capacity constraint is the only thing our model adds to theirs. The empirical audits lean the same way. Xu et al. [6] show a single agent with multi-turn interaction matches homogeneous workflows, Orogat et al. [7] find that orchestration depth limits scalability independently of the model, Kim et al. [8] fit a predictive model of when adding agents helps (cross-validated R2=0.37R^2=0.37) and find gains on some task families and losses of up to 70 per cent on sequential planning, and Jwalapuram et al. [5] report that many automated multi-agent frameworks collapse into self-consistency in practice. Cemri et al. [9] supply the failure taxonomy behind much of this. Optimists. Tang et al. [3] define per-step success σ(w)=uwσ(w)=u^w for a task of width w (we rename their symbols to keep ours free) and put Ssingle(d,w)=σ(w)dS_single(d,w)=σ(w)^d against a multi-agent success in which N agents answer each step independently and an aggregator picks the correct answer with probability r whenever some agent has it. Their printed Definition 2.3 places r outside the d-th power, while their Propositions 2.1 and 2.2 and proofs use the per-step form [r(1−(1−σ(w))N)]d[\,r(1-(1-σ(w))^N)\,]^d, which we take to be the intended one. Their relative gain increases in d and w, saturates at (rN)d−1(rN)^d-1 in width, and is unbounded in depth. Two features matter for what follows. The single agent’s per-step success is the same σ(w)σ(w) as each worker’s, so their single agent does not degrade with context either. And nothing is budget-normalised: the multi-agent system spends N calls per step at every one of d steps. Meyerson et al. [4] supply the engineering version of the same idea. They decompose a Towers-of-Hanoi run into a million single-step subtasks with a first-to-ahead-by-k vote at each, cite context growth as the reason a single agent fails, and report a per-step error rate that stays flat as the task scales once each agent sees only what its step needs. Su and Wu [10] study the training-time question and get a PAC dichotomy: independent subtasks make multi-agent fine-tuning more sample-efficient, dependent subtasks add a quadratic penalty from error propagation. Redundancy and aggregation. A third literature never decomposes anything and only asks what N parallel answers buy. Yang et al. [11] bound the information any transcript can carry by H(Y|X)H(Y|X) and introduce an effective channel count K with a complementarity rate α, under which residual uncertainty contracts like (1−α)K(1-α)^K. Homogeneous agents stop adding channels, so scaling saturates, and heterogeneous ensembles keep going. Patel et al. [12] give the exponential reliability gain of consensus voting under independence. Yang et al. [13] show in an appendix how that gain fails under correlated correctness. Maryanskyy et al. [14] derive a crossover in selector quality below which team diversity hurts and above which it helps, which in our notation is a threshold on the selector’s recall r. Choi et al. [15] prove that, under their conditions, debate conserves an agent’s expected belief, so debate cannot systematically raise expected belief above what the initial round already carries, and Liu et al. [16] add that correlated errors make debate converge on shared mistakes. None of this is new to statistics. Ladha [17] worked out the Condorcet jury theorem under correlated votes, and Kuncheva and Whitaker [18] catalogued how ensemble diversity relates to ensemble accuracy. Snell et al. [19] supply the empirical cousin on the single-model side: parallel and sequential test-time compute trade off differently depending on the problem. Verification and context management. Aghazadeh and Pishro-Nik [20] give the most complete reliability theory we know of. A task is a vector of coupled binary subclaims, an architecture is a sparse role-typed factor graph whose check nodes are noisy Boolean verifiers, and three failure modes (an agent abstains, a verifier returns nothing, a message is lost) propagate as set-valued messages under iterative decoding. They prove a density-evolution theorem in the style of Richardson and Urbanke [21], characterise finite-length failures by certificate-stopping sets, and solve cost-constrained architecture optimisation. The theory is erasure-only by design, and their limitations section lists what is outside it: confidently wrong messages, correlated agent failures from shared training data, adaptive routing, and “compounding prompt-context failures specific to LLM-style verifiers.” On the context side, Sun et al. [22] fold completed sub-trajectories out of the active context and scale a single agent to long horizons that way, which is decomposition without a second agent, and Kang et al. [23] and Xia et al. [24] treat compaction as the lever. Those methods pay our handoff tax. The closest precursor to the decomposition side of our model is Xu et al. [25], who split the error of divide-and-conquer processing of a long input into task noise (cross-chunk dependence), model noise (confusion that grows with context size), and aggregator noise, and show by varying chunk size that chunking pays when model noise grows fast enough and task noise is manageable. Their two leading terms are the parallel-chunking analogues of our handoff tax and curve. Liu et al. [26] put finite context, a message-fidelity function, and shared-failure correlation into one budgeted theory and derive phase transitions for star, chain, and tree organisations, with chains degrading unless new evidence enters. Their context limit is a hard window on fan-in and their validation is synthetic. Ours is a graded curve over accumulated load, which is what lets a fresh agent win, and its prediction is tested on an LLM task. What we add is the sequential chain with handoffs, the budget accounting, the dependence and verification axes, the crossover depth with its closed forms, and a prediction checked against a decomposed run. The phrase handoff tax is also used by Ganz et al. [27] for the cost a stronger or cheaper model pays when it takes over another model’s trajectory mid-run. Ours is the loss at a summary boundary between agents of the same model, and the two are different quantities. The curve. Whether per-step accuracy depends on context load has a broad but not uniform empirical answer. Liu et al. [28] found a U-shaped dependence on where relevant information sits. Hsieh et al. [29] found most long-context models fail well below their advertised length. Modarressi et al. [30] report, in the conference version, eleven of thirteen models falling below half their short-context score at 32k tokens, with GPT-4o dropping from 99.3 to 69.7. Hong et al. [31] found declining performance with input length across eighteen production models, and also report that the decline is not uniform across tasks and models. Du et al. [32] isolated the effect from retrieval: accuracy falls with length even when the relevant span is found. Laban et al. [33] found the multi-turn version. Sinha et al. [34] found per-step accuracy falling with the number of steps on a long execution task, partly because errors already in context make further errors likelier, an effect an in-task curve such as ours measures together with load. We take this as licence for a monotone first-order model of the curve and nothing stronger, and Section 9 shows one case where monotonicity holds for one failure definition and is undetectable for another. Scaffold effects. Zhang et al. [35] and Yao et al. [36] show that scaffold choice moves agent benchmark scores as much as model choice. Any placement of a published benchmark in our regime map is therefore qualitative, and we do not attempt a quantitative one. 3 Model The model is stylised. It is built to make the five quantities the literature holds fixed into explicit parameters, and the price of that is a first-order treatment of everything else. We state each simplification where it is made. Table 2 collects the symbols. A running example. To keep the symbols attached to something, we follow one task through the paper: an agent reconciling a ledger of L transactions, one per step. The task statement is c0=1,000c_0=1,000 tokens, each transaction adds k=400k=400 tokens of tool output, and a summary handed to a fresh agent is s=300s=300 tokens. For illustration we take the curve to be linear with g(c)=0.002+5×10−6cg(c)=0.002+5× 10^-6c, so a fresh agent’s per-step failure is about one per cent and a single agent’s rises to five per cent by the twenty-second transaction and nineteen per cent by the hundredth. We take the handoff tax to be h=0.02h=0.02 nats with no summary overhead. These are the parameters of Figure 2. They are chosen to be plausible, not measured, and we say what each theorem means for the ledger as we go. Table 2: Notation. Loads and lengths are in tokens, budgets in thinking tokens, and losses in nats. Symbol Set in Meaning L, t Sec. 3 task depth in steps, and the step index c0c_0, k Sec. 3 task statement size, and tokens added per step s, m Sec. 3 summary length, and steps per agent (chunk size) b, o, ovo_v Sec. 3 token budget per step, and tokens reserved per summary and per verifier call ε(c,b) (c,b), g(c,b)g(c,b) Eq. (1) per-step failure probability at load c and budget b, and its log-loss −log(1−ε)- (1- ) h, Δo _o, heffh_eff Def. 1, Eqs. (2), (5) handoff tax, writer’s overhead penalty, and their sum GSAG_SA, GDG_D Eqs. (4), (5) total log-loss of the single agent and of a decomposed system ata_t, a∞a_∞, A∞A_∞ Eqs. (7), (9) attention tax at step t, its limit, and the total tax a fresh agent avoids D(L)D(L), L∗L^* Eq. (8) log-loss advantage of decomposition at depth L, and the crossover depth λ, cκc_κ, λ2 _2 Sec. 4 slope of a linear curve, and knee location and post-knee slope of a knee-shaped curve N, ρ, μ, F Sec. 5 number of parallel samples, their pairwise correlation, the latent-rate mixing law, and the shared-failure mass q, ρgv _gv, qeffq_eff Sec. 3 verifier recall, generator-verifier dependence, and effective recall q(1−ρgv)q(1- _gv) εb _b, ε∞ _∞ Sec. 5 failure at budget b, and the thinking floor as b→∞b→∞ 3.1 Steps, curves, and budgets A task is a chain of L steps. Step t consumes the task statement, of size c0c_0, plus everything produced so far. Each step adds k tokens of new material: tool output, observations, retained reasoning. A step is one LLM call. It fails with probability ε(c,b) (c,b), where c is the context load it attends over and b is its thinking budget. We work in log-loss units, g(c,b):=−log(1−ε(c,b)),g(c,b):=- (1- (c,b) ), (1) so that products of success probabilities become sums. Here g is the negative log of the probability that the step produces a usable result. It is an operational reliability, not a proper-scoring-rule risk, and we keep it that way throughout. Assumption 1 (Product form). Steps fail independently given their (c,b)(c,b), and the task succeeds only if every step does. Then −logS=∑tg(ct,bt)- S= _tg(c_t,b_t). This is the first-order choice that Aghazadeh and Pishro-Nik [20] also make when they take failures conditionally independent given the graph. Within-trajectory dependence is real and is discussed in Section 11. Dependence between parallel agents is treated explicitly in Section 5. Assumption 2 (Monotone curve). ε is nondecreasing in c and nonincreasing in b, with ε<1 <1 on the loads and budgets considered, so that g is finite there. We call c↦ε(c,b)c (c,b) the context degradation curve. A flat curve is the case in which our model reaches the dominance conclusions of Tran and Kiela [1] and Ao et al. [2]. The linear and knee-shaped forms used later are local descriptions on the range of loads a trajectory actually visits. The curves measured in Sections 9 and 10 are neither linear nor knee-shaped over their whole range, and the closed forms are only as good as the local fit. Assumption 3 (Context growth). A single agent carries its whole trajectory, so ct=c0+ktc_t=c_0+kt with k>0k>0. A decomposed system with chunk size m∈1,…,Lm∈\1,…,L\ gives each agent up to m consecutive steps in a fresh context. The first agent starts from the task statement alone. Every later agent starts from a summary of length s written by its predecessor, so on its i-th step it sees c0+s+kic_0+s+ki. Write L=nm+m¯L=nm+ m with 0≤m¯<m0≤ m<m: there are n full chunks, one final chunk of m¯ m steps when m¯>0 m>0, and ⌈L/m⌉−1 L/m -1 handoffs. Budget. Both systems receive the same thinking budget b per step, so equal total budgets of bLbL. The decomposed system also spends o tokens writing each summary, and we charge that cost to the agent that writes it: an agent that hands off works with b−o/mb-o/m per step over its m steps, which raises its chunk’s log-loss by Δo:=∑i=1m[g(c0+s+ki,b−o/m)−g(c0+s+ki,b)]≥0. _o:= _i=1^m [g(c_0+s+ki,\,b-o/m)-g(c_0+s+ki,\,b) ]≥ 0. (2) An agent that does not hand off, including the only agent when m=Lm=L, pays nothing. This puts the overhead where it is incurred, keeps every step’s budget independent of L, and makes the decomposed system coincide with the single agent whenever there are no handoffs. We evaluate the first writer’s penalty at the same loads as the others rather than at its own slightly smaller ones, a second-order simplification that lets Δo _o be one number per handoff. When verifiers are added, Corollary 2 reserves their tokens, and those of a retry, explicitly within the same total. 3.2 Handoff loss When an agent starts a chunk from a summary M instead of the full upstream workspace H, its steps can fail more often. We define the handoff tax operationally in the same units as everything else. Definition 1 (Handoff tax). Let GMG_M be the log-loss of a chunk started from the summary M, at loads c0+s+kic_0+s+ki, and GHG_H the log-loss of the same chunk started from the full upstream workspace H, at loads c0+|H|+kic_0+|H|+ki. The handoff tax is h:=GM−GH+∑i=1m[g(c0+|H|+ki,b)−g(c0+s+ki,b)],h:=G_M-G_H+ _i=1^m [g(c_0+|H|+ki,\,b)-g(c_0+s+ki,\,b) ], (3) the difference the summary makes once the attention tax that the full workspace would have paid, given by the curve, is added back. It is the part of the summary’s effect that is not explained by load. Nothing in (3) forces its sign, which is why Assumption 4 imposes one. Everything on the right of (3) is measurable: run the chunk from M and from H and measure both failure rates, and take the curve term from an independently measured context degradation curve. Under a flat curve h=GM−GHh=G_M-G_H is simply the log-loss gap between the two starts. The definition is counterfactual only in the sense that it separates two effects that occur together. Assumption 4 (Handoff). h≥0h≥ 0: once load is accounted for, a summary does not improve on the full workspace. And h is nonincreasing in the summary length s whenever longer summaries can carry everything shorter ones do (nested or optimised summarisers). For fixed s and m the same h is paid at every boundary, including one that precedes a shorter final chunk. The relation to Ao et al. [2] is by analogy, not identity. Their communication loss is a gap in Bayes risk under a proper scoring rule, equal to I(Y;H|M)I(Y;H\,|\,M) under log score, for a Bayes-optimal decision maker. Ours is a gap in the negative log of an operational success probability for whatever agent is actually running. The two are both nonnegative, both vanish when the summary is sufficient, and both shrink as the summary grows under the same nesting condition, which is what the data processing inequality gives in their setting. They are not numerically equal, and we do not add one to the other. 3.3 The two log-losses Write Uj=∑i=1jg(c0+ki,b)U_j= _i=1^jg(c_0+ki,b) for a chunk that starts from the task statement and Vj=∑i=1jg(c0+s+ki,b)V_j= _i=1^jg(c_0+s+ki,b) for one that starts from a summary, with U0=V0=0U_0=V_0=0. Assumptions 1 to 4 give GSA(L) G_SA(L) =∑t=1Lg(c0+kt,b), = _t=1^Lg(c_0+kt,\,b), (4) GD(L,m) G_D(L,m) =Um+(n−1)(Vm+heff)+m¯>0(Vm¯+heff),heff:=h+Δo, =U_m+(n-1) (V_m+h_eff )+1_\ m>0\ (V_ m+h_eff ), h_eff:=h+ _o, (5) which is Um+(L/m−1)(Vm+heff)U_m+(L/m-1)(V_m+h_eff) when m divides L. The first term is the first agent, which has no summary. Every handoff costs heffh_eff, the information loss plus the writer’s overhead. At m=Lm=L there are no handoffs, the decomposed system is one agent doing everything, and (5) reduces to (4) for every o, as it should. Decomposition beats the single agent exactly when GD<GSAG_D<G_SA. Figure 1 draws the three architectures the model expresses. single agentc0+kc_0+kc0+2kc_0+2kc0+3kc_0+3k⋯·sc0+Lkc_0+Lkdecomposed, m=1m=1c0+kc_0+kc0+s+kc_0+s+kc0+s+kc_0+s+k⋯·sc0+s+kc_0+s+khhhhhhhhredundancy at one stepsample 1sample 2⋮ NNaggregateshared failure w.p. ρ recall q at boundary Figure 1: The three architectures the model expresses. The single agent’s context grows by k per step and its per-step failure follows the curve ε(c,b) (c,b). A decomposed system starts its first agent from the task statement, resets context at each boundary, and pays a handoff tax h there. A redundancy node runs N samples whose failures are dependent and combines them with a vote or a selector. 3.4 Redundancy and verification At any step the system may instead run N parallel calls and aggregate. Parallel calls to the same base model do not fail independently. We assume the N correctness indicators are generated by an exchangeable Bernoulli mixture: conditionally i.i.d. given a latent per-item failure rate p drawn from some law μ (Section 5). For infinite exchangeable sequences this is de Finetti’s representation, and for the finite samples we actually draw it is an assumption. The worked example throughout is the common-shock law: with probability ρ a single latent draw Z∼Bernoulli(1−ε)Z (1- ) is copied to all N outputs, and otherwise each output is an independent Bernoulli(1−ε)Bernoulli(1- ). A one-line computation gives Cov(Xi,Xj)=ρε(1−ε)Cov(X_i,X_j)=ρ\, (1- ), so the pairwise correlation is exactly ρ. Aggregation is either a majority vote on correctness or, following Tang et al. [3], a selector that returns the correct answer with probability r whenever some sample has it. A verifier at a boundary checks the fresh agent’s step before it is passed on, with recall q on true failures, and never turns a correct output into an incorrect one. Generator and verifier can share the failure’s cause, and we let ρgv _gv be the probability that they do, so effective recall is qeff=q(1−ρgv)q_eff=q(1- _gv). A detected failure triggers one retry, which fails with probability ere_r given the original failure and its detection. A step that fails with probability e then fails with probability T(e,qeff,er)=e(1−qeff)+eqeffer,T(e,q_eff,e_r)=e\,(1-q_eff)+e\,q_eff\,e_r, (6) and er=e_r=e gives the familiar e(1−qeff)+qeffe2e(1-q_eff)+q_effe^2 for a retry as good as the first attempt. 4 The decomposition crossover Fix m=1m=1, with b, s, and heffh_eff fixed as above, and define the attention tax at step t, at:=g(c0+kt,b)−g(c0+s+k,b),a_t:=g(c_0+kt,\,b)-g(c_0+s+k,\,b), (7) the extra log-loss the single agent pays at step t relative to a fresh agent that started from a summary. By Assumption 2 the sequence ata_t is nondecreasing in t. Let a∞:=limt→∞at∈(−∞,+∞]a_∞:= _t→∞a_t∈(-∞,+∞], which exists by monotonicity. From (4) and (5), D(L):=GSA(L)−GD(L,1)=∑t=2Lat−(L−1)heff,D(1)=0.D(L):=G_SA(L)-G_D(L,1)= _t=2^La_t-(L-1)\,h_eff, D(1)=0. (8) Decomposition wins at depth L iff D(L)>0D(L)>0. When o=0o=0, heff=h_eff=h, and we write h in that case. Single-step decomposition eventually wins exactly when the single agent’s extra per-step cost, far into the run, exceeds one handoff. Theorem 1 (Crossover for single-step agents). Under Assumptions 1 to 4, with b, s, heffh_eff fixed and m=1m=1: (i) If a∞>heffa_∞>h_eff, there is a unique L∗≥2L^*≥ 2 such that D(L)>0D(L)>0 if and only if L≥L∗L≥ L^*. (i) If a∞≤heffa_∞≤ h_eff, then D(L)≤0D(L)≤ 0 for every L: single-step decomposition never beats the single agent. (i) L∗L^* is nondecreasing in heffh_eff, nondecreasing in s at fixed heffh_eff, and nonincreasing under any change to the curve that leaves it unchanged on [0,c0+s+k][0,c_0+s+k] and raises it above that point. The proof is in Appendix A. The mechanism is that D has nondecreasing increments aL+1−heffa_L+1-h_eff, so it is discretely convex, and D(1)=0D(1)=0. A convex sequence that starts at zero crosses zero from below at most once, and does so if and only if its increments eventually turn positive. Part (i) is stated for changes above the fresh agent’s operating point because a change that also raises the curve below that point raises the fresh agent’s own log-loss and can move L∗L^* either way. Corollary 1 (The sceptics’ conclusion is the flat corner). If ε does not depend on c, then GD(L,m)≥GSA(L)G_D(L,m)≥ G_SA(L) for every L, every m, and every h≥0h≥ 0, o≥0o≥ 0: the single agent weakly dominates every decomposition at every depth. For the ledger this says that if the agent’s accuracy did not depend on how many transactions it was carrying, one agent should reconcile ledgers of any length and every handoff would be a pure loss. This is the conclusion of Tran and Kiela [1] under their stated premise and of Ao et al. [2] for a capacity-free centre, reached here by bookkeeping rather than by an information inequality. The proof is one line: under a flat curve every decomposed step costs at least what the corresponding single-agent step costs, and the handoffs cost extra. We also checked it exhaustively on a grid. Theorem 1(i) is a statement about single-step agents only, and it does not extend to larger chunks. A saturating curve can make every single handoff a losing trade while a longer chunk, which pays the same handoff once and avoids the attention tax on many steps, still wins. The general criterion is the total tax a fresh agent avoids. Theorem 2 (Crossover for arbitrary chunk sizes). Let the curve saturate, g(c,b)→gmax(b)<∞g(c,b)→ g_ (b)<∞ as c→∞c→∞, with o=0o=0 and the same handoff tax h at every chunk size, and define the total avoidable tax A∞:=∑i=1∞[gmax(b)−g(c0+s+ki,b)]∈[0,∞].A_∞:= _i=1^∞ [g_ (b)-g(c_0+s+ki,\,b) ]∈[0,∞]. (9) Then some chunk size m beats the single agent for all sufficiently large L if and only if A∞>hA_∞>h. Chunk size m in particular does so if and only if ∑i=1m[gmax−g(c0+s+ki)]>h _i=1^m[g_ -g(c_0+s+ki)]>h. If g is unbounded, decomposition at every chunk size eventually wins for every finite h. For m=1m=1 the partial sum is a∞a_∞ and the theorem reduces to Theorem 1. On a saturating exponential curve with a∞<h<A∞a_∞<h<A_∞, single-step decomposition never wins while m=2m=2 first wins at depth 26 and wins at every depth from 28 (Appendix B). The relevant object is the area between the saturation level and the curve above the fresh agent’s operating point, not the gap at the first step. A model whose accuracy degrades by only a little with context can still justify decomposition if that little accumulates over enough steps. 4.1 Closed forms in the linear regime Suppose g(c,b)=g0+λcg(c,b)=g_0+λ c with λ>0λ>0 on the loads both systems visit, and o=0o=0 so heff=h_eff=h. Then at=λ(k(t−1)−s)a_t=λ (k(t-1)-s ) and D(L)=(L−1)(12λkL−λs−h).D(L)=(L-1) ( 12λ kL-λ s-h ). (10) Theorem 3 (Crossover depth, linear regime). Under the conditions above and for L≥2L≥ 2, D(L)>0D(L)>0 if and only if L>2(h+λs)/(λk)L>2(h+λ s)/(λ k), so L∗=max2,⌊2(h+λs)λk⌋+1.L^*= \2,\; 2(h+λ s)λ k +1 \. (11) This is exact. Brute-force evaluation of D against (11) over 200 random parameter draws agrees on every draw. For the ledger, 2(0.02+0.0015)/0.002=21.52(0.02+0.0015)/0.002=21.5, so L∗=22L^*=22: one agent should reconcile ledgers of up to 21 transactions, and past that a chain of fresh agents handing off after every transaction does better, as the left panel of Figure 2 shows. A steeper curve or faster context growth brings the crossover earlier, a costlier handoff pushes it later, and longer summaries push it later through the fresh agents’ own load. Proposition 1 (Knee-shaped curves). Suppose g(c)=g0+λ2max(0,c−cκ)g(c)=g_0+ _2 (0,c-c_κ) on the loads visited, with λ2>0 _2>0, h>0h>0, the fresh agents operating below the knee, c0+s+k≤cκc_0+s+k≤ c_κ, and o=0o=0. Let Tκ=(cκ−c0)/kT_κ=(c_κ-c_0)/k be the step at which the single agent’s context reaches the knee. Replacing the sum of post-knee taxes by an integral gives L∗≈Tκ+h+h2+2λ2khTκλ2k.L^*≈ T_κ+ h+ h^2+2 _2k\,h\,T_κ _2k. (12) The single agent pays nothing until it crosses the knee, then pays a growing tax, and the crossover sits some way past the knee because the handoffs before it were pure cost. Against brute-force evaluation of (8) with the parameters fitted in Section 9, (12) is within one step in all four cases reported there. We include this case because it is the shape the pilot suggests, with the caveats given there. Theorem 4 (Chunk size, linear regime). Under the linear regime, for m dividing L, GD(L,m)=L[g0+λc0]+λs(L−m)+12Lλk(m+1)+(Lm−1)h.G_D(L,m)=L [g_0+λ c_0 ]+λ s\,(L-m)+ 12Lλ k(m+1)+ ( Lm-1 )h. (13) Let α=λ(k−2s/L)α=λ(k-2s/L). For h>0h>0 and α>0α>0 the continuous relaxation of the per-step cost is strictly convex with minimiser m∗=2hλ(k−2s/L)→L→∞2hλk,m^*= 2hλ (k-2s/L )\; [L→∞]\; 2hλ k, (14) clipped to [1,L][1,L]. For h>0h>0 and α≤0α≤ 0 the minimiser is L, and for h=0h=0 the relaxation is linear in m and is minimised at an endpoint. Among divisors of L the optimum is one of the two divisors that bracket m∗m^*. For a general integer m the final chunk is shorter, (5) is evaluated directly, and the integer optimum need not neighbour m∗m^*. The result treats the per-boundary handoff tax as fixed in m. If h=h(m)h=h(m), because a summary must support more downstream work when chunks are longer, the measured objective is minimised directly. With summary overhead o>0o>0 and a budget sensitivity |∂g/∂b|≈β|∂ g/∂ b|≈β that is roughly constant over the chunk’s loads, Δo≈βo _o≈β o to first order and the same formula holds with h replaced by h+βoh+β o. A grid minimiser of the continuous objective agrees with the L→∞L→∞ form to a relative error of 1.7×10−51.7× 10^-5 on the 91 of 100 random draws where m∗≥1m^*≥ 1. For the ledger, 0.04/0.002=4.47 0.04/0.002=4.47, so each agent should own a few transactions rather than one: handing off after every transaction, as in Figure 2, pays the handoff tax more often than it needs to. At short depths the rounding matters. With L=4L=4, g(c)=0.01cg(c)=0.01c, c0=s=0c_0=s=0, k=1k=1, and h=0.044h=0.044, the losses for m=1,2,3,4m=1,2,3,4 are 0.1720.172, 0.1040.104, 0.1140.114, and 0.1000.100, so the optimum is m=4m=4 although m∗=2.97m^*=2.97. The square-root law governs long tasks, and (5) settles short ones. The number of steps a subagent should own is the square root of the handoff-to-attention ratio, with overhead entering as an addition to the handoff tax. Cheap handoffs and steep curves push towards one step per agent. Expensive handoffs or flat curves push towards one agent for everything. The folklore that hierarchies should be flattened corresponds to heffh_eff being large relative to λkλ k. Meyerson et al. [4] derive a chunk-size law on the cost side that belongs next to this one. Under per-chunk voting, the samples of an m-step chunk must agree exactly, so their expected cost grows like p−mp^-m in the per-step success p, and log-linearly in the number of steps at m=1m=1. Equation (14) is the accuracy-side optimum without per-chunk voting. When both mechanisms are present the joint optimum minimises accuracy loss plus cost over m, and the two laws pull the same way. Proposition 2 (Summary length). Let h(s)h(s) be differentiable and strictly convex in the summary length, nonincreasing by Assumption 4, and suppose an interior minimiser exists. For m=1m=1 the fresh agent’s per-step cost is g(c0+s+k)+h(s)g(c_0+s+k)+h(s), and in the linear regime its unique minimiser satisfies −h′(s∗)=λ-h (s^*)=λ. Lengthen the summary until the information it saves per token equals the attention tax per token. Strict convexity is what makes the optimum unique. Monotonicity alone does not, and a summariser with threshold behaviour (nothing useful until a key fact fits) can have several local optima. Corollary 2 (Verified boundaries). Take m=1m=1. The first step receives budget b and is unverified. Each later boundary divides its budget b among the summary, the fresh agent’s generation, the verifier, and one retry, o+bg+ov+br=b,o,bg,ov,br≥0,o+b_g+o_v+b_r=b, o,b_g,o_v,b_r≥ 0, so the total is bLbL even when every retry is used. Put cf=c0+s+kc_f=c_0+s+k, e=ε(cf,bg)e= (c_f,b_g), let ere_r be the retry’s conditional failure at budget brb_r, and let ℓv=−log(1−T(e,qeff,er)) _v=- (1-T(e,q_eff,e_r) ) with T from (6). If verification leaves the handoff tax h unchanged, the verified system has log-loss GD,v(L)=g(c0+k,b)+(L−1)(ℓv+h),G_D,v(L)=g(c_0+k,b)+(L-1)( _v+h), and Theorem 1 holds with ata_t replaced by at(v)=g(c0+kt,b)−ℓva_t^(v)=g(c_0+kt,b)- _v and heffh_eff by h. Against the unverified system with the same summary reservation, whose fresh agents generate at budget b−ob-o, verification lowers log-loss at every depth and cannot delay the crossover whenever ℓv≤g(cf,b−o) _v≤ g(c_f,b-o). This is how verification enters the crossover: as a reduction of the fresh agent’s per-step failure, paid for out of the same budget. Recall alone does not settle it, because the condition charges the verifier and the retry against the tokens the fresh agent would otherwise have spent generating. Section 6 takes up how large qeffq_eff is at a boundary. Figure 2: Success probability against depth for a single agent (black) and a single-step-per-agent decomposition at three handoff taxes. Left: a linear curve with g(c)=0.002+5×10−6cg(c)=0.002+5× 10^-6c, k=400k=400, s=300s=300, c0=1000c_0=1000, o=0o=0. Decomposition first wins at L=22L=22 for h=0.02h=0.02 and L=52L=52 for h=0.05h=0.05, as (11) gives. Right: a flat curve, where the single agent never loses (Corollary 1). Parameters are illustrative, not fitted. 4.2 Width is context management Give the task W independent branches of depth L whose results are combined at the end. If one agent processes all of them in a single growing context, its load reaches c0+kWLc_0+kWL and, in the linear regime, its excess log-loss grows like 12λk(WL)2 12λ k(WL)^2 while a system that runs each branch in a fresh context pays linearly in W. So the multi-agent advantage grows with width, as Tang et al. [3] find, and depth dominates because depth compounds inside a branch while width only multiplies branches. But the comparison is not really about the number of agents. A single agent that resets its context between branches, as Sun et al. [22] implement, is in this model a decomposed system with W chunks and h paid once per branch. The width result is a statement about context management, and the second agent is incidental to it. Tang et al.’s own width effect works through a different channel, a lower per-step success uwu^w that raises the value of redundancy, and we return to it in Section 7. 5 The redundancy crossover Now hold L=1L=1 and ask what N parallel samples buy against one agent that thinks N times as long. Theorem 5 (Majority vote under exchangeable failures). Let the correctness indicators of N samples be conditionally i.i.d. given a latent failure rate p∼μp μ, and let ε¯=∫pμ<1/2 = p\,dμ< 12 be the marginal failure rate. For odd N the majority-vote failure probability is Evote(N)=∫Pr[Bin(N,1−p)≤N−12]dμ(p),E_vote(N)= [Bin(N,1-p)≤ N-12 ]\,dμ(p), (15) which converges as N→∞N→∞ to μ(p>1/2)+12μ(p=1/2)μ(p> 12)+ 12μ(p= 12), the mass μ places on shared failure. Under the common-shock law this is Evote(N)=ρε+(1−ρ)Pr[Bin(N,1−ε)≤N−12]→N→∞ρε,E_vote(N)=ρ\, +(1-ρ) [Bin(N,1- )≤ N-12 ]\; [N→∞]\;ρ\, , (16) nonincreasing in N for ε<1/2 < 12 and exponentially decaying when ρ=0ρ=0. Under the any-correct selector with recall r the common-shock failure is 1−r[ρ(1−ε)+(1−ρ)(1−εN)]1-r [ρ(1- )+(1-ρ)(1- ^N) ], with limit (1−r)+rρε(1-r)+rρ\, . The large-N floor is a property of the whole law μ, not of the pairwise correlation: two laws with the same ρ can have different masses above one half, so “ρερ\, ” is the common-shock floor and not a general one. And the vote is modelled on the correctness indicator, which for an open-ended answer with a unique correct value is the pessimistic case: if wrong answers split among several values, plurality over answers succeeds whenever the majority on the indicator does and sometimes when it does not. With those cautions, (16) contains the exponential gain of Patel et al. [12] at ρ=0ρ=0, the failure of voting under correlated correctness in Yang et al. [13], and the consensus-on-mistakes of Liu et al. [16]. It reproduces the saturation of homogeneous scaling in Yang et al. [11] at the level of mechanism, in that additional samples stop helping once the shared-failure mass dominates, but their effective-channel count is not a function of ρ and we do not claim their theorem as a special case. Tang et al. [3] sit at ρ=0ρ=0 with the selector, where the per-step failure tends to 1−r1-r as N grows. Corollary 3 (What pairwise correlation does determine). For indicators that are conditionally i.i.d. given a latent rate, with marginal failure ε<1/2 < 12 and pairwise correlation ρ, the latent rate has variance σ2=ρε(1−ε)σ^2=ρ\, (1- ), and the shared-failure mass obeys 0≤F≤Fmax(ε,ρ):=ρε(1−ε)ρε(1−ε)+(1/2−ε)2,0\;≤\;F\;≤\;F_ ( ,ρ):= ρ\, (1- )ρ\, (1- )+( 12- )^2, (17) with the upper bound approached by two-point laws that put an atom just above 1/2 12 whenever ρ≤(1/2−ε)/(1−ε)ρ≤( 12- )/(1- ), and valid but not tight for larger ρ. The common-shock floor ρερ\, lies within this range. So a measured pair (ε,ρ)( ,ρ) does not pin the floor, but it does bound it, and the bound is what a practitioner can use: if Fmax(εb,ρ)<ε∞F_ ( _b,ρ)< _∞, parallel sampling wins for large N under every mixture law with those moments, and no assumption about the shape of dependence is needed. For one ledger transaction with a 5.5 per cent failure rate and a pairwise correlation of 0.120.12 between samples (numbers of the order the pilot saw, used here only for illustration), the common-shock floor is 0.70.7 per cent and the bound is 3.13.1 per cent. Parallel sampling then beats longer thinking for large N whenever the model’s thinking floor on that step is above 3.13.1 per cent, whatever the dependence looks like, and above 0.70.7 per cent if the dependence is a shared shock. Parallel sampling beats longer thinking at equal budget for all sufficiently large sample counts whenever the samples’ shared-failure floor is below one agent’s thinking floor. Theorem 6 (Parallel against sequential at equal budget). Let the thinking curve saturate, ε(c,b)→ε∞(c) (c,b)→ _∞(c) as b→∞b→∞, and write εb:=ε(c,b)<1/2 _b:= (c,b)< 12 for the marginal failure at budget b. Compare N samples at budget b each with one call at budget NbNb. As N→∞N→∞ the vote failure tends to the shared-failure mass F:=μ(p>1/2)+12μ(p=1/2)F:=μ(p> 12)+ 12μ(p= 12) and the sequential failure tends to ε∞(c) _∞(c). Hence parallel wins for all large N if F<ε∞(c)F< _∞(c), and sequential wins for all large N if F>ε∞(c)F> _∞(c). A sufficient condition for parallel to win that uses only (εb,ρ)( _b,ρ) is Fmax(εb,ρ)<ε∞(c)F_ ( _b,ρ)< _∞(c). Under the common-shock law F=ρεbF=ρ\, _b and the threshold correlation is ρ∗=ε∞(c)/εbρ^*= _∞(c)/ _b. The finite-N comparison goes through the binomial tail in (15). Figure 3 shows it for the common-shock law with a saturating exponential thinking curve, where ρ∗=0.497ρ^*=0.497 and the four correlation levels split as the theorem says. Theorem 6 is the equal-budget version of the question Tran and Kiela [1] raise and Yang et al. [11] answer without a budget. Debate does not obviously escape it: Choi et al. [15] show that debate conserves expected belief under their conditions, which rules out systematic improvement of expected belief over the initial round, though it does not by itself pin the accuracy of thresholded decisions, so we treat the vote as the reference point rather than a proven ceiling. At one step, the “more agents or more thinking” question reduces to comparing a shared-failure mass with a thinking floor. Figure 3: Failure probability of a majority vote over N samples at four common-shock correlation levels, against one agent given N times the budget, for a thinking curve ε(b)=0.08+0.22e−b (b)=0.08+0.22e^-b at b=1b=1. The threshold from Theorem 6 is ρ∗=0.08/0.161=0.497ρ^*=0.08/0.161=0.497. At every plotted N>1N>1, correlations of 0 and 0.2 favour parallel sampling and 0.5 and 0.8 favour sequential thinking. Corollary 4 (The million-step regime). With m=1m=1 and per-step redundancy N, −logS≤L[−log(1−Evote(N))]+(L−1)h- S≤ L\,[- (1-E_vote(N))]+(L-1)h, with EvoteE_vote evaluated at the fresh agents’ load c0+s+kc_0+s+k and equality when the first step runs at that load too. For S to stay above a fixed target S0>0S_0>0 as L grows, both −log(1−Evote(N))- (1-E_vote(N)) and h must be O(1/L)O(1/L), so at L=106L=10^6 the per-step vote failure and the handoff tax must both be of order 10−610^-6 or smaller. The first is available at minimal context and small shared-failure mass. The second requires the handoff to lose essentially nothing, which is what passing the complete explicit state, rather than a summary, is designed to achieve. This is what Meyerson et al. [4] do: the object handed between steps is the full disk configuration, so h is near zero by design and the engineering effort goes into driving the vote failure down. The second condition is not optional, since S≤e−(L−1)hS≤ e^-(L-1)h regardless of how good the vote is. 6 Verification Corollary 2 says how a verifier enters the crossover: through qeff=q(1−ρgv)q_eff=q(1- _gv), the retry’s quality, and the generation budget they displace. What it does not say is how large qeffq_eff is at a boundary versus inside a trajectory, which is an empirical question. Proposition 3 (Where verification pays, conditional on a hypothesis). Fix the generator’s failure e, the nominal recall q, the retry failure er<1e_r<1, and the budget allocation. Suppose ρgv _gv is smaller for a fresh-context verifier at a decomposition boundary than for a self-check inside the generating trajectory. Then (i) the reduction in per-step failure, qeffe(1−er)q_eff\,e\,(1-e_r), is larger at the boundary, so verification gains accrue disproportionately to decomposed systems, and (i) with a fixed number of verifiers of equal qeffq_eff and retries as good as the first attempt, the log-loss removed at step t is log(1+qeffet)≈qeffet (1+q_effe_t)≈ q_effe_t, largest at the steps with the largest ete_t: late in a single-agent trajectory, or at the end of each chunk in a decomposed one. The hypothesis is plausible and not established. It is consistent with the self-correction literature since Huang et al. [37], which finds that a model asked to reconsider the same evidence in the same context tends to reproduce its error, and with the mechanism in Ao et al. [2], where a verifier helps only by contributing a signal the generator did not have. A fresh context carries no new exogenous information, but it changes how a bounded agent processes the evidence it has, which is the channel the hypothesis is about. A test of the hypothesis needs the same verifier prompt run in both positions on the same generations, and we list it among the predictions. The relation to density evolution is an analogy. Replace “confidently wrong with probability ε ” by “abstains with probability ε ”, take the curve flat, set ρ=0ρ=0, and put a check node at each boundary: the chain becomes a path in the factor-graph language of Aghazadeh and Pishro-Nik [20], and our one-retry recursion is a one-iteration truncation of their iterative decoding. Their theory does much more on that path (multiple rounds, stopping sets, thresholds) than ours, and ours does two things theirs excludes (context-dependent failure, correlated failure). The two overlap on that path and nowhere else. 7 Reductions Table 3 states, for each prior result, the restriction of the model under which its conclusion is recovered and how tight the correspondence is. Three are discussed below. Table 3: Each prior result as a restriction of the model. Exact: the restricted model’s theorem has the same statement. Structural: the same conclusion under the same premise, reached in a different formal setting. Analogical: the mechanism corresponds, but the quantities differ and no reduction is claimed. Empirical: a measured result the model reproduces qualitatively. Prior result Restriction Recovered Tightness Tran and Kiela [1], DPI flat curve, equal budget, undegraded Cor. 1 structural Ao et al. [2], Prop. 6, Thm. 8 flat curve, capacity-free centre Cor. 1, Def. 1 analogical Tang et al. [3], Props. 2.1, 2.2 flat, ρ=0ρ=0, selector r, free compute Thm. 5 per step structural Su and Wu [10], Thms. 4.1 to 4.3 h=0h=0 vs. h>0h>0 on task edges dependency dichotomy analogical Yang et al. [11], Thm. 4.3 L=1L=1, exchangeable samples saturation at the shared-failure mass analogical Patel et al. [12] L=1L=1, ρ=0ρ=0 exponential gain, Thm. 5 exact Yang et al. [13], App. E.1 L=1L=1, ρ>0ρ>0 voting fails, Thm. 5 structural Choi et al. [15], Liu et al. [16] belief-conserving aggregation vote as reference point analogical Aghazadeh and Pishro-Nik [20], Thm. 8 flat, ρ=0ρ=0, erasure, one retry one-retry recursion, Eq. (6), Cor. 2 analogical Xu et al. [25] parallel chunks, no budget, no ρ task noise as h, model noise as curve analogical Meyerson et al. [4] m=1m=1, per-step vote, full state passed Cor. 4 empirical The sceptic corner. Under a flat curve, Corollary 1 says the single agent weakly dominates at every depth and chunk size, which is the conclusion of Tran and Kiela [1] under their premise and of Ao et al. [2] for a centre with no capacity limit. The first is structural: same premise, same conclusion, a bookkeeping argument in place of an information inequality. The second is analogical, because their loss is a Bayes-risk gap under a proper scoring rule and ours is an operational log-reliability, and we do not identify the two. The optimist corner is a redundancy result. The result of Tang et al. [3] is often cited as a decomposition result. Their single agent has the same per-step success σ(w)σ(w) as each of their workers, so there is no attention tax in their model, and their workers never hand anything off, so there is no handoff tax either. What their multi-agent system has is N independent answers per step and a selector with recall r. In our terms that is the redundancy primitive at every step with ρ=0ρ=0, the any-correct aggregator, and no budget constraint. Their unbounded growth in depth is the compounding of a per-step advantage: whenever r(1−(1−σ)N)>σr(1-(1-σ)^N)>σ the ratio of the two success probabilities is (r(1−(1−σ)N)/σ)d (r(1-(1-σ)^N)/σ )^d, which grows geometrically in d. Their width effect lowers σ=uwσ=u^w and so raises the value of redundancy per step. Both survive in our model as long as ρ is small and compute is free. Impose the budget and Theorem 6 takes over. Impose shared failure and the per-step floor becomes (1−r)+rρε(1-r)+rρ instead of 1−r1-r. Tang et al. [3] prove a correct theorem about free, independent redundancy, and it says little about the decomposition question it is often cited for. The PAC dichotomy is an analogy across phases. Su and Wu [10] find that multi-agent fine-tuning is more sample-efficient when subtasks are independent (Theorem 4.3 there) and worse when they are dependent (Theorem 4.2, a K2K^2 penalty from error propagation). In our inference-time model a dependency edge is an edge where the downstream step needs information from upstream, which is where h>0h>0, and an independent edge is where h=0h=0. We record it as a correspondence across a change of phase and claim nothing more. 8 Two contradictions, read through the model The literature contains two separate contradictions, and they resolve through different parameters. 8.1 Redundancy: free independent samples against budgeted dependent ones Claim Ared (3, 12): the gain from N agents per step is exponential in N and compounds without bound in depth. Claim Bred (1, 11, 15): at equal budget more agents buy no more than more thinking, homogeneous scaling saturates, and debate does not improve on its first round. In the model, Claim Ared is Theorem 5 at ρ=0ρ=0 with unconstrained compute, and Claim Bred is Theorem 6 on the sequential side of the threshold. Neither claim holds at every level of dependence. Parallel sampling wins at equal budget below the threshold and loses above it, and the empirical success of self-consistency [38] says the shared-failure mass for a well-prompted sampled chain is often below threshold on the tasks people try. Context plays no part in this contradiction. What decides it is who paid for the samples and whether they failed together. 8.2 Decomposition: a capacity-free centre against a degrading one Claim Adec (1, 2): under equal information and equal budget, a single agent that uses its context fully weakly dominates any delegated network. Claim Bdec (4, the expert-designed row of 5): decomposition wins, and wins more on longer and more context-heavy tasks. In the model, Claim Adec holds for every chunk size under a flat curve (Corollary 1), and more generally whenever the total avoidable tax satisfies A∞≤hA_∞≤ h (Theorem 2). Claim Bdec holds, for single-step agents, if and only if a∞>ha_∞>h (Theorem 1), and for some chunk size if and only if A∞>hA_∞>h. For any curve that rises above the fresh agent’s operating point by more, in total, than a handoff costs, decomposition wins at every sufficiently large depth and not below its first crossover. For any curve that does not, it never wins. The two camps were proving theorems about different curves and reporting them as theorems about agents. What each side left out is easy to list once the model is in front of you. Tran and Kiela [1] prove dominance for an undegraded centre and, when they degrade it, use a corruption knob rather than accumulated load, so their crossovers are observed but not located from measurements. Ao et al. [2] give the centre no capacity and describe their model as operating above the level of token generation. Tang et al. [3] have no handoff and no budget. The redundancy papers hold L=1L=1 and so cannot speak to decomposition. Aghazadeh and Pishro-Nik [20] exclude the curve and correlation in writing and have no single-agent baseline to compare against. 8.3 Regimes in the published record The model says the winner is decided by where (c0,k)(c_0,k) sits on the curve and by h. Figure 4 draws L∗L^* over (λk,h)(λ k,h) and places three families of published results qualitatively. Placement is qualitative, since scaffold choice moves scores as much as model choice does [35]. Figure 4: Crossover depth L∗=⌊2(h+λs)/(λk)⌋+1L^*= 2(h+λ s)/(λ k) +1 over the attention tax per step λkλ k and the handoff tax h, at s/k=0.75s/k=0.75. White contours mark L∗∈5,20,100,1000L^*∈\5,20,100,1000\. The three annotations are qualitative placements of the benchmark families discussed in the text, not fitted points. In the flat region, with small k and short contexts, ata_t stays near a1a_1 and any positive h makes decomposition lose. This is multi-hop question answering and the static reasoning benchmarks. Tran and Kiela [1] find single agents match or beat multi-agent systems there at matched tokens, and Jwalapuram et al. [5] find self-consistency ahead of six automated frameworks on reasoning benchmarks such as GPQA-Diamond and HLE-Maths, often at under a tenth of their cost. Redundancy still helps in this region through Theorem 5, and self-consistency rather than a plain chain of thought wins in that audit for that reason. In the rising region, with large k or a large c0c_0 and a decomposable task, the same audit gives the opposite answer. Their SMFR task embeds investor transactions in long price tables, with parallel investors and sequential dependence within each investor. An expert-designed decomposition with a meta-agent, per-investor extractor and calculator agents, and deterministic orchestration takes GPT-5 from 57.0 with self-consistency to 96.5, at a cost of 554.82 against 478.40 dollars for the baseline, and takes GPT-OSS-120B from 26.1 to 36.1. That is the direction Theorem 1 predicts: fresh contexts per investor remove the attention tax the single agent pays on the full table. The automated frameworks gain little on the same task, at most 6.6 points and at roughly two to five times the cost, and the authors’ own deconstruction finds many of them collapsing into ensembling rather than decomposing, so they pay orchestration overhead without buying much reduction in attention tax. We do not place SMFR quantitatively on Figure 4: the source describes the task’s context in more than one way and we have no curve for GPT-5. The same table contains the competency floor. GPT-4o moves from 22.1 to 22.6 under the expert decomposition, which is nothing. In the model, if ε at minimal context is already large, decomposition removes the attention tax but the fresh agents’ product exp(−Lg(c0+s+k)) (-L\,g(c_0+s+k)) is still near zero, because nothing in a handoff lowers a failure rate that is already high at short context. Our own pilot in Section 9 places a 20B model in the flat region, to within its resolution, for arithmetic failures on the whole measured range, and in a rising region for failures of instruction compliance, with the knee poorly located. The ledger experiment of Section 10 places the same model in the rising region on a task where every step depends on the trajectory. In the steep, long region there is Meyerson et al. [4], where no single agent survives 10610^6 steps and m=1m=1 with per-step voting and full-state handoffs gives Corollary 4. 8.4 What would falsify this Six predictions, roughly in order of how cheap they are to test. Section 10 tests the first on one task and one model, on the winning side of the crossover. The crossover exists and moves. Run the equal-budget comparison of Tran and Kiela [1] on tasks with larger per-step context growth k, such as tool-heavy or document-heavy multi-hop, with a measured handoff tax, and the winner flips at a depth predicted by (11). L∗L^* moves with the model being served. For a fixed task, harness, failure definition, and measured h, models with flatter measured curves have larger L∗L^*, and the single-agent window widens with each generation of long-context improvement. Chunk size. For a long decomposable task with measured (λ,k,h)(λ,k,h), agents owning about 2h/(λk) 2h/(λ k) steps beat both one-step-per-agent and one-agent-for-all designs. Summary length. Performance as a function of summary length has an interior optimum where −h′(s)=λ-h (s)=λ, so fixed-ratio compaction is off-peak for some models. Redundancy. The parallel-versus-sequential winner at equal budget is predicted by the shared-failure mass against ε∞ _∞. Heterogeneous ensembles flip more tasks to parallel and homogeneous self-consistency saturates, as Yang et al. [11] report. Verification. The same verifier prompt reduces failure by more at a decomposition boundary than as a self-check inside one trajectory, and the gap grows with context load. 9 An exploratory pilot This pilot measures one axis of the model, the context degradation curve, on one model and task family. Section 10 provides the architecture-level test. Protocol. The model is gpt-oss-20b as packaged by Ollama (tag gpt-oss:20b, 20.9B parameters, MXFP4 quantisation, native context 131,072), served through Ollama 0.30.8 on one RTX 3090 with a derived model fixing the context window at 71,680 tokens (num_ctx), flash attention, an 8-bit KV cache, the reasoning level fixed at low through the harmony system message, sampling temperature 0.7 in place of the packaged default of 1, and the output budget fixed at 1,024 tokens including reasoning, which together fix b. The task is a family of chained arithmetic word problems with six operations and an exact integer answer, generated from a seed, the same 100 problems at every load so that difficulty is matched across loads. Context load is varied by prepending well-formed, digit-free prose presented as earlier session material, at nominal 0, 2k, 8k, 32k, and 64k tokens, which is the protocol of Du et al. [32] pointed at one model. What this measures is length-induced degradation under padded session context, with the instruction at one end and the question at the other, and not the distribution of material a real agent trajectory accumulates. The system prompt, placed at the top, asks for a final line of the form ANSWER: <integer>. Each problem is sampled twice at temperature 0.7, 1,000 calls in all. Measured loads by the o200k tokeniser are 107, 2,117, 8,023, 31,641, and 63,129 tokens. Only the final 200 characters of each response were stored, so finish reasons and token counts are not available for the pilot. The generator, filler, grader, and stored responses are in the repository. Two curves from one run. Table 4 and Figure 5 show what came back, with intervals from a cluster bootstrap over problems, since the 200 calls at a load are two samples on each of the same 100 problems. Graded on the arithmetic alone, the failure rate is 5.5, 5.0, 5.5, 3.5, and 6.0 per cent across the five loads. A paired comparison by problem of the 64k load against the other four gives a difference of +1.1+1.1 points with standard error 1.9 (t99=0.59t_99=0.59), and the cluster-bootstrap interval on the weighted slope of g is [−6.1,+6.6]×10−7[-6.1,+6.6]× 10^-7 per token, which over the measured range permits a change of about four percentage points in either direction. The arithmetic curve is flat to within four points over 63k tokens at this budget. Graded on whether the response contained the requested answer line, sitting 63k tokens upstream at the top load, the picture is the opposite: 0, 0.5, 5.0, 6.5, and 25.5 per cent of responses omit it. The paired-by-problem difference for the 64k load is +22.5+22.5 points with standard error 3.4 (t99=6.7t_99=6.7), and the failures are spread across problems (33 problems fail once, 9 twice, 58 never). In 47 of the 51 the number was still right. The model just stopped saying so in the form it was asked to, and a strict parser downstream fails on all 51. The stored tails at 64k show no obvious mid-response truncation. The strict curve, counting a step as failed if either the number or the format is wrong, is 5.5, 5.5, 10.0, 10.0, and 29.5 per cent, and at 64k its 59 failures fall on 47 problems (35 once, 12 twice). Table 4: Pilot on gpt-oss-20b at low reasoning and a 1,024-token budget, 200 calls per load (100 problems, two samples). Arithmetic: wrong final number. Format: required answer line missing. Strict: either. Intervals are 95% cluster-bootstrap intervals over problems. c (tokens) arithmetic failures format failures strict failures strict ε(c) (c) [95% CI] 107 11 0 11 0.055 [0.025, 0.090] 2,117 10 1 11 0.055 [0.020, 0.095] 8,023 11 10 20 0.100 [0.060, 0.145] 31,641 7 13 20 0.100 [0.060, 0.145] 63,129 12 51 59 0.295 [0.225, 0.365] Figure 5: Left: the three failure definitions against context load, with 95% cluster-bootstrap intervals over problems. Right: log-loss for the arithmetic and strict definitions, with a weighted hinge fit to the strict curve and the linear fit for comparison. The arithmetic curve is flat to within measurement. The strict curve is flat, then not, with the location of the change poorly determined. The fit. A weighted hinge fit, searching knee locations from 0 to 32k tokens, places the knee near 27k and gives a post-knee slope of 7.8×10−67.8× 10^-6 per token, with a 95% cluster-bootstrap interval of [3.4,11.1]×10−6[3.4,11.1]× 10^-6. The knee location is loosely determined. The robust feature is the rise from roughly 10 per cent strict failure at 32k to roughly 30 per cent at 63k. Implications of the pilot. Under the arithmetic definition no slope is detectable, so to the pilot’s resolution this model sits in the flat corner of Corollary 1 for trajectories under 64k tokens, where decomposition has no attention tax to buy back. Under the strict definition the hinge fit and Proposition 1 give, for assumed handoff costs of h=0.02h=0.02 and h=0.05h=0.05 nats and no summary overhead: for a step adding k=400k=400 tokens, the ledger’s step size, the single agent reaches the fitted knee at step 67 and decomposition pays from depth 103 or 131. For a tool-heavy step adding k=2,000k=2,000 tokens the knee arrives at step 14 and the crossover at depth 20 or 26. These are brute-force evaluations of D, and the closed form is within one step of each. Under a knee-shaped curve the chunk size is not Theorem 4’s square root, because below the knee a handoff buys nothing: agents should own as many steps as fit under the knee, and only past that does the square-root trade-off apply. These crossover depths are illustrative because they use the fitted knee and assumed h. Section 10 performs the architecture-level test with measured quantities. Failure definitions. The curve is a property of the model, the task, and the failure definition together. The same thousand calls give a flat curve and a steep one, and a naive last-integer grader produced a third by treating a remainder in responses without an answer line as the final answer. The mechanism in the steep case is not reasoning collapse but decay of compliance with an instruction that sits far from the point of use, which is the phenomenon Liu et al. [28] measured for facts, seen here for an instruction. Two consequences follow if the mechanism is what it appears to be. A practitioner who repeats the format instruction next to the question should flatten the strict curve, and the model predicts this because it shortens the distance the instruction must survive. And a paper that reports a single-agent win on short-context benchmarks and a multi-agent win on long-context ones may be measuring exactly this: not what the model can compute, but what it still remembers it was asked to do. 10 The experiment The model suggests one direct test. Measure the curve and the handoff tax, compute the depth at which decomposition should start to win and how often each system should succeed, then compare with both systems run on the same ledgers. We ran that test on the ledger task of the running example. Task. A ledger of L transactions with an exact integer running balance, starting at 50,000. Six transaction kinds: deposit, withdrawal, a percentage fee on the current balance rounded down, a hold that removes an amount now, a release that returns a hold’s amount three to twelve steps later but names the hold only by id, and a reversal that undoes a deposit or withdrawal three to twelve steps back, also named only by id. The last two are the long-range dependencies: the amount has to come from earlier context or from a handoff note. Each transaction block is padded with digit-free administrative memo lines to about 400 tokens, and the measured context growth was 398 tokens per step. Ledgers are generated from a seed, and the same 100 ledgers are used at each depth by both systems, so every comparison is paired. A step is graded on its increment, whether the reported balance moved by the true amount for that transaction, so a step is not penalised for a balance error it inherited. A ledger is graded twice: on whether every non-fee increment is right and every handoff note carries its balance forward unchanged (the stationary grading, explained below) and on whether its final balance is exactly right. Systems and protocol. The single agent runs one growing conversation, one call per transaction, so its context at step t is c0+ktc_0+kt with c0=197c_0=197 tokens. The decomposed system gives each agent m=5m=5 consecutive transactions in a fresh conversation. At each boundary the outgoing agent is asked for a handoff note of about 300 tokens (225 words) carrying the balance, every open hold, and the id and amount of the last twelve transactions, and the incoming agent starts from that note. The handoff tax was measured on a separate pool of 100 ledgers by the paired design of Definition 1: twelve transactions run once, then the next five run twice, continuing in the same conversation and starting from a note, at note allowances of 100, 300, and 900 tokens (produced notes 137, 183, and 255 tokens). The model is gpt-oss-20b on a hosted OpenAI-compatible endpoint (provider recorded in the run configuration), at reasoning level low, temperature 0.7, and a 512-token allowance per step call including reasoning, which is b, the same for every step call in both systems. Handoff notes were separate calls with a 600-token allowance, so the writing agent’s own step budget was not reduced: the experiment sits at Δo=0 _o=0 in the accounting of Section 3, and the note tokens are overhead on top of matched step budgets. Actual generation per ledger, reasoning plus answer, averaged 806, 2,873, and 10,046 tokens for the single agent at depths 20, 50, and 100, against 1,611, 4,797, and 10,195 for the decomposed system including its notes (770, 2,001, and 4,078 for its step calls alone). Per step call the decomposed agents used 39 to 41 tokens at every depth while the single agent’s use rose from 40 to 100 with load, so at depth 100 the two systems generated the same number of tokens and at shallower depths the decomposed system generated more, almost all of it in notes. On the input side the single agent processed 2.0M prompt tokens per ledger at depth 100 against 0.2M, since it re-reads its growing context at every step. It is the same model as in the pilot, on a different serving stack, so the two sections’ curves are not compared quantitatively. In all, 40,600 calls, 309M prompt tokens, about ten dollars, and 27 minutes of wall-clock time. Finish reasons and token counts were kept for every call. Analysis. The curve is interpolated through its bins, fee steps are left out for the reason given below, and each ledger’s prediction counts the steps that are actually scored, at their actual positions. Every numerical input (curve, handoff tax, k, c0c_0, and note length) comes from single-agent and handoff runs. These choices were fixed once all runs were complete, and an earlier hinge-based analysis is kept in the repository. The curve. Table 5 and the left panel of Figure 6 show per-step failure against context load from the 17,000 single-agent steps. It rises from 2.7 per cent below 2k tokens to 71 per cent above 36k, far steeper than in the pilot. Unlike the pilot’s irrelevant padding, every step here depends on the accumulated trajectory. Two effects are separated from the load effect. First, the model’s reasoning grew with load, from 20 tokens per step below 4k to 153 above 30k, and 5.1 per cent of single-agent calls hit the 512-token budget against 0.13 per cent of decomposed calls. Those count as failures under the fixed per-call budget b. Since they are asymmetric, the curve is also reported on calls that finished normally and the depth comparison on ledgers with no truncated call, and both preserve the direction at every depth. Second, fee steps drift with position for a reason unrelated to load. A fee is a percentage of the incoming balance, so once a balance is wrong every later fee is graded wrong even when its arithmetic is right. In the decomposed system, at constant load, fee failure rises from 7 per cent in the first ten transactions to 72 per cent after the fiftieth. Conditioned on a correct preceding balance it is flat, 5 of 91 early and 3 of 55 late, while 283 of 340 late fees that follow a wrong balance fail. Fee steps therefore measure the state carried into them rather than the step itself, and the curve, the handoff tax, and the prediction use the other five kinds (the stationary steps). A ledger then has 18.0, 45.0, and 90.0 scored steps on average at depths 20, 50, and 100, and the full-task result is reported alongside. Table 5: The in-task curve from single-agent steps on the ledger task, gpt-oss-20b at a 512-token budget. Failure is the per-step increment failure rate. The stationary column excludes fee steps, and stop-only excludes calls that hit the budget. Seven of the twelve load bins, which together hold 9,178 of the 17,000 steps, are shown. The prediction and Figure 6 use all twelve. Intervals are cluster-bootstrap over ledgers. load (tokens) steps all kinds [95% CI] stationary kinds stationary, stop-only 0 to 2k 1,200 0.027 [0.015, 0.042] 0.021 0.021 4k to 6k 1,500 0.071 [0.055, 0.089] 0.049 0.048 8k to 10k 1,100 0.112 [0.087, 0.138] 0.066 0.059 13k to 16k 1,403 0.185 [0.154, 0.219] 0.129 0.104 20k to 25k 1,393 0.294 [0.253, 0.341] 0.227 0.174 30k to 36k 1,509 0.598 [0.543, 0.661] 0.548 0.452 36k to 45k 1,073 0.707 [0.646, 0.773] 0.682 0.599 The decomposed agents sit close to the same curve. Their stationary steps, at loads of 1.2k and 2.2k tokens, fail at 3.3 and 3.4 per cent against about 2 per cent for the single agent at the same loads. The handoff tax. Continuing from history, at a mean load of 6.2k tokens, the post-boundary stationary steps failed at 5.2 per cent. Starting from a note, at a mean load of 1.6k, they failed at 3.2, 2.0, and 1.8 per cent for the three note lengths. The raw comparison therefore favours the note, because the history sits higher on the curve, and Definition 1 adds the curve term back, summed over each chunk’s scored steps at their observed loads: 0.1720.172 nats per chunk. This gives an increment tax hinch_inc of 0.0770.077, 0.0260.026, and 0.0150.015 nats for notes of 137, 183, and 255 tokens. The stationary endpoint also requires each note to preserve the incoming reported balance. The same parser grades this event in calibration and evaluation. A missing or unparseable balance fails. Preservation succeeds on 100, 99, and 100 of the 100 calibration ledgers. Under the product approximation, its separate boundary cost is hbal=−logqbalh_bal=- q_bal, so the total reference-chunk taxes are 0.0770.077, 0.0360.036, and 0.0150.015 nats, still nonincreasing in note length. At the 300-token setting hbal=−log(0.99)=0.010h_bal=- (0.99)=0.010. A bootstrap over single-agent and paired handoff ledgers re-estimates the curve, increment tax and balance preservation together. The increment tax has a 95% interval of [−0.11,0.16][-0.11,0.16] nats. The total tax interval is [−0.10,0.18][-0.10,0.18] nats. Following Assumption 4, forecasts project the increment tax to zero when negative and retain the nonnegative balance cost. As a sensitivity check, direct whole-chunk success is 0.81 from history and 0.90 from the note, requiring both correct non-fee increments and preserved balance. This gives hjoint=0.067h_joint=0.067. Using the primary total h=0.036h=0.036 and the low-load slope of about 8×10−68× 10^-6 per token, Theorem 4’s reference-chunk approximation gives 2h/(λk)≈4.8 2h/(λ k)≈ 4.8 steps, close to the m=5m=5 chosen before measuring anything. Prediction and result. For each ledger the prediction sums the interpolated curve over its scored steps, at loads c0+ktc_0+kt for the single agent and at the fresh-context loads of their chunk positions for the decomposed system, with fee steps still adding context. The increment tax hinc=0.026h_inc=0.026 is spread over the calibration chunk’s 4.41 scored steps on average, on every scored step after the first chunk. The balance cost hbal=0.010h_bal=0.010 is paid once per actual handoff, including a handoff followed only by fee steps. This extends product form to both increment and balance-preservation events. Predicted success is exp(−G) (-G) averaged over the 100 ledgers. On prefixes of the depth-100 ledgers this puts the crossover at L∗=10L^*=10, with bootstrap quantiles of 6 and 27, and gives the rates in Table 6 and Figure 6. Decomposition won at every tested depth on both gradings. The paired improvements in stationary success are 0.19, 0.18, and 0.11, with bootstrap intervals [0.05,0.33][0.05,0.33], [0.08,0.28][0.08,0.28], and [0.05,0.18][0.05,0.18], and exact McNemar p of 0.014, 0.001, and below 0.001 (0.049, 0.003, and 0.002 on the final balance). The predictions miss the observations by at most 9 percentage points. For the single agent the observed rate is 4, 5, and 0 points above the prediction, the direction product form implies when a single agent’s failures cluster on hard ledgers. For the decomposed system the misses are +8.4+8.4, −3.1-3.1, and +3.9+3.9 points, with no consistent sign. The ordering does not depend on the estimator: replacing the increment tax with hjoint−hbalh_joint-h_bal while retaining the once-per-boundary balance cost gives decomposed predictions of 0.55, 0.20, and 0.04, still ahead of the single agent at every depth. Restricting to ledgers on which neither system hit the token limit leaves 98, 62, and 12 pairs, with final-balance success of 0.49 against 0.65, 0.02 against 0.16, and 0 against 0.08. Table 6: Predicted and observed success by depth on the ledger task, 100 paired ledgers per depth. Stationary: every non-fee increment right and every note’s balance carried forward. Final: final balance exactly right. Predictions use the stationary curve, increment tax hinc=0.026h_inc=0.026, balance cost hbal=0.010h_bal=0.010, and each ledger’s scored steps and boundaries, with every input taken from single-agent and handoff runs. Paired p values are exact McNemar tests. predicted, stationary observed, stationary observed, final balance L single decomposed single decomposed single decomposed paired p (stationary / final) 20 0.46 0.61 0.50 0.69 0.49 0.64 0.014 / 0.049 50 0.01 0.27 0.06 0.24 0.04 0.18 0.001 / 0.003 100 0.00 0.07 0.00 0.11 0.00 0.10 <<0.001 / 0.002 Figure 6: Left: the in-task curve from single-agent steps, on all kinds, on the stationary kinds, and on stationary kinds with truncated calls removed, with the decomposed agents’ stationary steps at their own loads. Intervals are cluster-bootstrap over ledgers. Right: predicted success against depth for both systems from the curve and the measured handoff tax, evaluated on prefixes of the depth-100 ledgers, with the observed rates at depths 20, 50, and 100 and bootstrap intervals over ledgers. The dotted line is the predicted crossover. Scope. The measured curve and handoff tax predicted the winning architecture at all three tested depths, and the decomposed system’s success to within 9 percentage points. All three sit past the predicted crossover at depth 10, and runs at depths either side of it are the natural next measurement. 11 Scope and extensions The model is first order in three places. Product form ignores dependence along a trajectory. When failures cluster on hard instances it overstates the single agent’s loss, which is the direction seen on the ledger, and a dependent-failure version of the crossover is a natural extension. The budget is fixed per step rather than in total, and the ledger experiment matches systems the same way. The handoff tax is one scalar per boundary, related to the information-theoretic loss of Ao et al. [2] by analogy. The redundancy floor depends on the whole mixing law, of which the common-shock law is one example. The measurements cover one model on two tasks. The quantities the model asks for next are the boundary verifier recall of Section 6, the thinking floor of Section 5, and curves for further models, each of which turns into a direct test of a result above. 12 Conclusion Inside the model, the single-versus-multi-agent question turns on one curve and one tax rather than on the number of agents. Decomposition trades information for attention: it pays a handoff tax at every boundary to buy back per-step accuracy, and it is worth it when the tax a fresh agent avoids over its run exceeds what the handoff costs, net of what fresh-context verifiers catch. Redundancy trades budget for independence: it eventually wins at equal compute whenever the mass the samples place on shared failure lies below the thinking floor of one agent. The formal results we could find in the 2025 to 2026 literature correspond to these two statements with some quantities pinned, exactly in a few cases and by analogy in most, and the empirical record, including the one audit that reports both outcomes side by side, sorts along the same lines. The failure definition is part of the curve: the pilot curve was flat for the task and steep for the instruction. On the ledger task, measuring the context curve and handoff tax from single-agent and handoff runs alone was enough to predict the winning architecture and the decomposed system’s success to within 9 percentage points, with the crossover itself below the tested range. This turns the framework from a retrospective explanation of conflicting results into a measurable architecture-selection rule in the regime tested here. Appendix A Proofs Theorem 1 From (8), the increments of D are D(L+1)−D(L)=aL+1−heffD(L+1)-D(L)=a_L+1-h_eff, nondecreasing in L by Assumption 2, so D is discretely convex, and D(1)=0D(1)=0. (i) If a∞≤heffa_∞≤ h_eff then every increment is at most zero, so D is nonincreasing from zero and D(L)≤0D(L)≤ 0 for all L. (i) If a∞>heffa_∞>h_eff, choose η>0η>0 and T with at≥heff+ηa_t≥ h_eff+η for all t≥Tt≥ T. Then for L>TL>T, D(L)≥D(T)+(L−T)η→+∞D(L)≥ D(T)+(L-T)η→+∞, so D(L)>0D(L)>0 for all large L. Because increments are nondecreasing, once an increment is positive all later ones are, so from the first index at which D>0D>0 the sequence stays positive. With D(1)=0D(1)=0 the set L:D(L)>0\L:D(L)>0\ is an up-set L≥L∗\L≥ L^*\, which gives existence and uniqueness of L∗L^*. (i) D is pointwise decreasing in heffh_eff, so its zero-crossing moves right. Increasing s raises g(c0+s+k,b)g(c_0+s+k,b) and lowers every ata_t, again lowering D pointwise. A change to the curve that leaves [0,c0+s+k][0,c_0+s+k] unchanged and raises the curve above it leaves g(c0+s+k,b)g(c_0+s+k,b) fixed and raises g(c0+kt,b)g(c_0+kt,b) for every t with c0+kt>c0+s+kc_0+kt>c_0+s+k, so it raises ata_t for those t and leaves the others unchanged, raising D pointwise. ∎ Corollary 1 Under a flat curve g(c,b)=γ(b)g(c,b)=γ(b), every step in (5) contributes γ(b)γ(b) and there are ⌈L/m⌉−1 L/m -1 handoffs, so GD(L,m)=Lγ(b)+(⌈L/m⌉−1)heff≥Lγ(b)=GSA(L)G_D(L,m)=Lγ(b)+( L/m -1)h_eff≥ Lγ(b)=G_SA(L), since heff=h+Δo≥0h_eff=h+ _o≥ 0. This includes a shorter final chunk. ∎ Theorem 2 Write Σj:=∑i≤j[gmax−g(c0+s+ki)] _j:= _i≤ j[g_ -g(c_0+s+ki)] and R(L):=∑t≤L[gmax−g(c0+kt)]≥0R(L):= _t≤ L[g_ -g(c_0+kt)]≥ 0, the single agent’s own distance from saturation, which is nondecreasing in L, with Σ0=0 _0=0. For L=nm+m¯L=nm+ m, 0≤m¯<m0≤ m<m, substituting ∑t≤Lg(c0+kt)=Lgmax−R(L) _t≤ Lg(c_0+kt)=Lg_ -R(L) and the corresponding sums into (5) with o=0o=0 gives GSA(L)−GD(L,m)=(n−1)(Σm−h)+m¯>0(Σm¯−h)−[R(L)−R(m)].G_SA(L)-G_D(L,m)=(n-1) ( _m-h )+1_\ m>0\ ( _ m-h )- [R(L)-R(m) ]. The bracket is nonnegative, and Σm¯≤Σm _ m≤ _m. If Σm≤h _m≤ h every term is nonpositive, so chunk size m never strictly wins, which gives the “only if”. If Σm>h _m>h the first term grows linearly in L, the second takes finitely many values for fixed m, and R(L)=o(L)R(L)=o(L) because g(c0+kt)→gmaxg(c_0+kt)→ g_ , so the difference is positive for all large L. Since Σm _m is nondecreasing in m with limit A∞A_∞, some m has Σm>h _m>h iff A∞>hA_∞>h. If g is unbounded, monotonicity and k>0k>0 give GSA(L)/L→∞G_SA(L)/L→∞, while for fixed m the decomposed loads are bounded and GD(L,m)=O(L)G_D(L,m)=O(L), so decomposition wins at every m for large L. ∎ Theorem 3 With o=0o=0, substituting at=λ(k(t−1)−s)a_t=λ(k(t-1)-s) into (8) gives ∑t=2Lat=λkL(L−1)2−λs(L−1) _t=2^La_t=λ k\, L(L-1)2-λ s(L-1), hence (10). For L≥2L≥ 2 the sign of D(L)D(L) is the sign of 12λkL−λs−h 12λ kL-λ s-h, which is positive iff L>2(h+λs)/(λk)L>2(h+λ s)/(λ k). The smallest integer L≥2L≥ 2 satisfying a strict inequality L>xL>x is max2,⌊x⌋+1 \2, x +1\. ∎ Proposition 1 Below the knee at=0a_t=0 and above it at=λ2(c0+kt−cκ)=λ2k(t−Tκ)a_t= _2(c_0+kt-c_κ)= _2k(t-T_κ). Treating t as continuous, ∑t≤Lat≈12λ2k(L−Tκ)2 _t≤ La_t≈ 12 _2k(L-T_κ)^2 for L>TκL>T_κ. Setting this greater than (L−1)h≈(L−Tκ+Tκ)h(L-1)h≈(L-T_κ+T_κ)h and solving the quadratic in x=L−Tκx=L-T_κ gives (12). ∎ Theorem 4 Summing g(c0+ki)g(c_0+ki) over i≤mi≤ m gives m[g0+λc0]+12λkm(m+1)m[g_0+λ c_0]+ 12λ km(m+1), and summing g(c0+s+ki)g(c_0+s+ki) gives the same plus λsmλ sm. Substituting into (5) with n=L/mn=L/m agents gives (13). Dropping terms constant in m, the per-step cost is f(m)=αm/2+h/mf(m)=α m/2+h/m with α=λ(k−2s/L)α=λ(k-2s/L), so f′(m)=α/2−h/m2f (m)=α/2-h/m^2 and f′(m)=2h/m3f (m)=2h/m^3. For h>0h>0 and α>0α>0, f is strictly convex with minimiser (14), clipped to [1,L][1,L], and a convex function restricted to the divisors of L is minimised at one of the two divisors that bracket its continuous minimiser. For h>0h>0 and α≤0α≤ 0, f is decreasing and the minimum is at L. For h=0h=0, f is linear and is minimised at an endpoint. Integers that do not divide L change the objective through the final chunk and are compared through (5). With o>0o>0, (2) gives Δo≈(o/m)∑i≤m|∂bg(c0+s+ki,b)| _o≈(o/m) _i≤ m| _bg(c_0+s+ki,b)| to first order, which is βoβ o when the sensitivity is roughly constant at β across the chunk’s loads, a constant per handoff that adds to h in the first-order condition. ∎ Proposition 2 The objective g0+λ(c0+s+k)+h(s)g_0+λ(c_0+s+k)+h(s) is strictly convex in s as a sum of a linear and a strictly convex function, so an interior stationary point −h′(s)=λ-h (s)=λ, which exists by hypothesis, is its unique minimiser. ∎ Corollary 2 The first call uses b and each of the L−1L-1 boundaries reserves o+bg+ov+br=bo+b_g+o_v+b_r=b, so the total is bLbL even if every retry is used. Splitting a generator failure into undetected and detected cases gives failure probability T(e,qeff,er)T(e,q_eff,e_r) for each fresh step, hence log-loss ℓv _v, and with the additive handoff tax this gives GD,vG_D,v. Its advantage over the single agent is Dv(L)=∑t=2L[g(c0+kt,b)−ℓv−h]D_v(L)= _t=2^L[g(c_0+kt,b)- _v-h] with Dv(1)=0D_v(1)=0, whose increments are nondecreasing, so the proof of Theorem 1 applies verbatim. The unverified system with the same summary reservation has fresh-step loss g(cf,b−o)g(c_f,b-o), so unverified minus verified log-loss is (L−1)[g(cf,b−o)−ℓv](L-1)[g(c_f,b-o)- _v], which is nonnegative at every depth under the stated condition. ∎ Theorem 5 The indicators are conditionally i.i.d. Bernoulli(1−p)Bernoulli(1-p) given p∼μp μ by assumption, which gives (15). For fixed p<1/2p< 12 the binomial tail tends to 00, for p>1/2p> 12 to 11, and for p=1/2p= 12 to 1/2 12, and dominated convergence gives the limit. Under the common-shock law μ=ρεδ1+ρ(1−ε)δ0+(1−ρ)δεμ=ρ \, _1+ρ(1- )\, _0+(1-ρ)\, _ , so the mass above one half is ρερ , and (16) follows by conditioning on the shock. Monotonicity in N for the δε _ component holds for ε<1/2 < 12 and the other components do not depend on N. Exponential decay at ρ=0ρ=0 is a Chernoff bound. The selector case replaces the majority event by “at least one correct”, which for independent samples has probability 1−εN1- ^N. ∎ Corollary 3 For conditionally i.i.d. indicators, Cov(Xi,Xj)=Var(p)Cov(X_i,X_j)=Var(p), so σ2=ρε(1−ε)σ^2=ρ\, (1- ). Cantelli’s inequality gives μ(p−ε≥t)≤σ2/(σ2+t2)μ(p- ≥ t)≤σ^2/(σ^2+t^2) for t>0t>0, and with t=1/2−εt= 12- the left side is μ(p≥1/2)≥Fμ(p≥ 12)≥ F. Equality in Cantelli holds for the two-point law with atoms at ε+t=1/2 +t= 12 and ε−σ2/t -σ^2/t, which is a valid law on [0,1][0,1] iff ε−σ2/t≥0 -σ^2/t≥ 0, i.e. ρ≤(1/2−ε)/(1−ε)ρ≤( 12- )/(1- ), and moving the upper atom just above 1/2 12 makes F approach the bound. For the common-shock law, ρε≤Fmaxρ ≤ F_ with equality only at ρ=0ρ=0, since for ρ>0ρ>0 the inequality reduces to ρεt2<σ2(1−ρε)ρ \,t^2<σ^2(1-ρ ), i.e. t2<(1−ε)(1−ρε)t^2<(1- )(1-ρ ), which holds because t2<1/4<(1−ε)2≤(1−ε)(1−ρε)t^2< 14<(1- )^2≤(1- )(1-ρ ) for ε<1/2 < 12. ∎ Theorem 6 By Theorem 5, Evote(N)→FE_vote(N)→ F. By the saturation hypothesis, ε(c,Nb)→ε∞(c) (c,Nb)→ _∞(c). If F<ε∞(c)F< _∞(c) the two limits are separated, so for all large N the vote failure is below the sequential failure, and symmetrically in the other case. ∎ Appendix B Numerical verification and materials The closed forms were checked against brute-force evaluation of (4) and (5). Over 200 random draws of (g0,λ,k,s,h,c0)(g_0,λ,k,s,h,c_0) with λ∈[10−5,5×10−4]λ∈[10^-5,5× 10^-4], k∈[50,2000]k∈[50,2000], s∈[0,3k]s∈[0,3k], h∈[0,0.5]h∈[0,0.5], the smallest depth at which D(L)>0D(L)>0 equals (11) on every draw. Corollary 1 was checked exhaustively on all 2,358 combinations of L≤200L≤ 200, m∈1,2,5,10m∈\1,2,5,10\ with m≤Lm≤ L, and h∈0,0.01,0.1h∈\0,0.01,0.1\ at a flat g=0.02g=0.02, remainder chunks included, with no violation. The chunk-size formula agrees with a grid minimiser of the continuous per-step cost to a relative error of 1.7×10−51.7× 10^-5 on the 91 of 100 draws with m∗≥1m^*≥ 1. Theorem 2 was checked on the saturating curve g(c)=0.2−0.18e−c/10g(c)=0.2-0.18e^-c/10 with c0=s=0c_0=s=0, k=1k=1, and h=0.204h=0.204, where a∞=0.163<h<A∞=1.71a_∞=0.163<h<A_∞=1.71: m=1m=1 never wins within 2,000 steps, and m=2,3,5m=2,3,5 first win at depths 26, 15, and 9 and win at every depth from 28, 17, and 12, since a shorter final chunk can briefly reverse the sign. The identity in its proof matches direct evaluation, including remainder chunks, to within 10−1310^-13 over 200 random saturating curves. The threshold in Theorem 6 was checked for ε(b)=0.08+0.22e−b (b)=0.08+0.22e^-b at b=1b=1 under the common-shock law: the vote beats the sequential agent at every N∈3,5,11,51,201N∈\3,5,11,51,201\ for ρ∈0,0.2ρ∈\0,0.2\ and loses at every N for ρ∈0.5,0.8ρ∈\0.5,0.8\, consistent with ρ∗=0.497ρ^*=0.497. Code and data are at https://github.com/akshitanchan/attention-handoff-tax. The repository contains the verification script, the calibration script (problem generator, filler generator, prompt, grader, resumable runner), the run configuration, the stored responses for all 1,000 pilot calls (final 200 characters each), the per-load summaries, the re-grading script that separates arithmetic from format failures, the script that fits the pilot curve and draws Figure 5, and, for Section 10, the experiment script (ledger generator, both runners, the handoff-tax runner, the analysis), the per-step records for all 40,600 calls with finish reasons and token counts, the run configurations, the initial analysis output, and the exposure-matched analysis of Section 10 with its bootstrap and sensitivity runs. For the pilot, the serving stack was Ollama 0.30.8 with the packaged gpt-oss:20b model (Ollama ID 17052f91a42e, 20.9B parameters, MXFP4) behind a derived model with a 71,680-token window (ID eec2acdf0143). The ollama show and ollama list output, captured when the files were assembled, is included with the run configuration. Use of AI tools. The authors directed the research and conducted all experiments. AI tools (Anthropic’s Claude and OpenAI’s ChatGPT) were used as supplementary tools for checking and writing assistance. All results and claims were independently verified by the authors, who take full responsibility for the work. References [1] Dat Tran and Douwe Kiela. Single-agent LLMs outperform multi-agent systems on multi-hop reasoning under equal thinking token budgets. arXiv preprint arXiv:2604.02460, 2026. [2] Ruicheng Ao, Siyang Gao, and David Simchi-Levi. On the reliability limits of LLM-based multi-agent planning. arXiv preprint arXiv:2603.26993, 2026. [3] Bohan Tang, Huidong Liang, Keyue Jiang, and Xiaowen Dong. On the importance of task complexity in evaluating LLM-based multi-agent systems. arXiv preprint arXiv:2510.04311, 2025. [4] Elliot Meyerson, Giuseppe Paolo, Roberto Dailey, Hormoz Shahrzad, Olivier Francon, Conor F. Hayes, Xin Qiu, Babak Hodjat, and Risto Miikkulainen. Solving a million-step LLM task with zero errors. arXiv preprint arXiv:2511.09030, 2025. [5] Prathyusha Jwalapuram, Hehai Lin, Chuyuan Li, Fangkai Jiao, Sudong Wang, Yifei Ming, Zixuan Ke, Chengwei Qin, Giuseppe Carenini, and Shafiq Joty. The illusion of multi-agent advantage. arXiv preprint arXiv:2606.13003, 2026. [6] Jiawei Xu, Arief Koesdwiady, Sisong Bei, Yan Han, Baixiang Huang, Dakuo Wang, Yutong Chen, Zheshen Wang, Peihao Wang, Pan Li, and Ying Ding. Rethinking the value of multi-agent workflow: A strong single agent baseline. arXiv preprint arXiv:2601.12307, 2026. [7] Abdelghny Orogat, Ana Rostam, and Essam Mansour. Understanding multi-agent LLM frameworks: A unified benchmark and experimental analysis. arXiv preprint arXiv:2602.03128, 2026. [8] Yubin Kim, Ken Gu, Chanwoo Park, Chunjong Park, Samuel Schmidgall, A. Ali Heydari, Yao Yan, Zhihan Zhang, Yuchen Zhuang, Yun Liu, Mark Malhotra, Paul Pu Liang, Hae Won Park, Yuzhe Yang, Xuhai Xu, Yilun Du, Shwetak Patel, Tim Althoff, Daniel McDuff, and Xin Liu. Towards a science of scaling agent systems. arXiv preprint arXiv:2512.08296, 2025. [9] Mert Cemri, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei Zaharia, Joseph E. Gonzalez, and Ion Stoica. Why do multi-agent LLM systems fail? arXiv preprint arXiv:2503.13657, 2025. [10] Junwei Su and Chuan Wu. When do multi-agent systems outperform? Analysing the learning efficiency of agentic systems. arXiv preprint arXiv:2602.08272, 2026. [11] Yingxuan Yang, Chengrui Qu, Muning Wen, Laixi Shi, Ying Wen, Weinan Zhang, Adam Wierman, and Shangding Gu. Understanding agent scaling in LLM-based multi-agent systems via diversity. arXiv preprint arXiv:2602.03794, 2026a. [12] Khush Patel, Siva Surendira, Jithin George, and Shreyas Kapale. The six sigma agent: Achieving enterprise-grade reliability in LLM systems through consensus-driven decomposed execution. arXiv preprint arXiv:2601.22290, 2026. [13] Wei Yang, Shixuan Li, Heng Ping, Peiyu Zhang, Paul Bogdan, and Jesse Thomason. Auditing multi-agent LLM reasoning trees outperforms majority vote and LLM-as-judge. arXiv preprint arXiv:2602.09341, 2026b. [14] Artem Maryanskyy, Dmitry Budnikov, and Alibek T. Kaliyev. When agents disagree: The selection bottleneck in multi-agent LLM pipelines. Applied Sciences, 16(10):4914, 2026. arXiv:2603.20324. [15] Hyeong Kyu Choi, Xiaojin Zhu, and Sharon Li. Debate or vote: Which yields better decisions in multi-agent large language models? In Advances in Neural Information Processing Systems 38, 2025. arXiv:2508.17536. [16] Yuhan Liu, Juntian Zhang, Yichen Wu, Martin Takáč, Salem Lahlou, Xiuying Chen, and Nils Lukas. Breaking the martingale curse: Multi-agent debate via asymmetric cognitive potential energy. arXiv preprint arXiv:2603.06801, 2026a. [17] Krishna K. Ladha. The Condorcet jury theorem, free speech, and correlated votes. American Journal of Political Science, 36(3):617–634, 1992. [18] Ludmila I. Kuncheva and Christopher J. Whitaker. Measures of diversity in classifier ensembles and their relationship with the ensemble accuracy. Machine Learning, 51(2):181–207, 2003. [19] Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling LLM test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024. [20] Ehsan Aghazadeh and Hossein Pishro-Nik. On the reliability of networks of AI agents: Density evolution, stopping sets, and architecture optimization. arXiv preprint arXiv:2606.18121, 2026. [21] Tom Richardson and Rüdiger Urbanke. Modern Coding Theory. Cambridge University Press, 2008. [22] Weiwei Sun, Miao Lu, Zhan Ling, Kang Liu, Xuesong Yao, Yiming Yang, and Jiecao Chen. Scaling long-horizon LLM agent via context-folding. arXiv preprint arXiv:2510.11967, 2025. [23] Minki Kang, Wei-Ning Chen, Dongge Han, Huseyin A. Inan, Lukas Wutschitz, Yanzhi Chen, Robert Sim, and Saravan Rajmohan. ACON: Optimizing context compression for long-horizon LLM agents. arXiv preprint arXiv:2510.00615, 2025. [24] Shijie Xia, Yikun Wang, Zhen Huang, and Pengfei Liu. Diagnosing and mitigating context rot in long-horizon search. arXiv preprint arXiv:2606.29718, 2026. [25] Zhen Xu, Shang Zhu, Jue Wang, Junlin Wang, Ben Athiwaratkun, Chi Wang, James Zou, and Ce Zhang. When does divide and conquer work for long context LLM? a noise decomposition framework. arXiv preprint arXiv:2506.16411, 2025. [26] Bang Liu, Linglong Kong, and Jian Pei. Phase transition for budgeted multi-agent synergy. arXiv preprint arXiv:2601.17311, 2026b. [27] Roy Ganz, Mor Shpigel Nacson, Adi Kalyanpur, and Ron Litman. The handoff tax: Continuing non-native trajectories in LLM agents. arXiv preprint arXiv:2608.24358, 2026. [28] Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. Lost in the middle: How language models use long contexts. Transactions of the Association for Computational Linguistics, 12:157–173, 2024. [29] Cheng-Ping Hsieh, Simeng Sun, Samuel Kriman, Shantanu Acharya, Dima Rekesh, Fei Jia, Yang Zhang, and Boris Ginsburg. RULER: What’s the real context size of your long-context language models? arXiv preprint arXiv:2404.06654, 2024. [30] Ali Modarressi, Hanieh Deilamsalehy, Franck Dernoncourt, Trung Bui, Ryan A. Rossi, Seunghyun Yoon, and Hinrich Schütze. NoLiMa: Long-context evaluation beyond literal matching. In Proceedings of the 42nd International Conference on Machine Learning, 2025. arXiv:2502.05167. [31] Kelly Hong, Anton Troynikov, and Jeff Huber. Context rot: How increasing input tokens impacts LLM performance. Technical report, Chroma Research, 2025. https://research.trychroma.com/context-rot. [32] Yufeng Du, Minyang Tian, Srikanth Ronanki, Subendhu Rongali, Sravan Bodapati, Aram Galstyan, Azton Wells, Roy Schwartz, Eliu A. Huerta, and Hao Peng. Context length alone hurts LLM performance despite perfect retrieval. arXiv preprint arXiv:2510.05381, 2025. [33] Philippe Laban, Hiroaki Hayashi, Yingbo Zhou, and Jennifer Neville. LLMs get lost in multi-turn conversation. arXiv preprint arXiv:2505.06120, 2025. [34] Akshit Sinha, Arvindh Arun, Shashwat Goel, Steffen Staab, and Jonas Geiping. The illusion of diminishing returns: Measuring long horizon execution in LLMs. arXiv preprint arXiv:2509.09677, 2025. [35] Yunbei Zhang, Janet Wang, Yingqiang Ge, Weijie Xu, Jihun Hamm, and Chandan K. Reddy. Stop comparing LLM agents without disclosing the harness. arXiv preprint arXiv:2605.23950, 2026. [36] Yilun Yao, Xinyu Tan, Chao-Hsuan Liu, Yaoming Li, Zhengyang Wang, Wenhan Yu, Zhewen Tan, Yuxuan Tian, Guangxiang Zhao, Lin Sun, Xiangzheng Zhang, and Tong Yang. Harness-bench: Measuring harness effects across models in realistic agent workflows. arXiv preprint arXiv:2605.27922, 2026. [37] Jie Huang, Xinyun Chen, Swaroop Mishra, Huaixiu Steven Zheng, Adams Wei Yu, Xinying Song, and Denny Zhou. Large language models cannot self-correct reasoning yet. In The Twelfth International Conference on Learning Representations, 2024. arXiv:2310.01798. [38] Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V. Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2023.