Harnessing LLMs as Agents: What Does It Cost?

1. Introduction

• LAM makes context, persistent storage, state movement, model calls, tools, and verification explicit costs while fixing semantic-oracle power.Its value-provenance principle permits moving, storing, and reusing semantic state but prevents the harness from creating task-relevant content for free.Source: §1 · p. 2
• The theory establishes an instancewise correspondence between LAM execution and red–blue pebbling, preserving feasible call–transfer budgets and the full discrete Pareto frontier.Classical pebbling lower bounds therefore become harness-communication lower bounds.Source: §1 · p. 2
• Random access follows k pointers in k reads, while non-speculative sequential access requires Ω(kn) expected head movements and unrestricted always-correct read-only sequential access retains an Ω(n) lower bound.Equal memory capacity does not guarantee equal access cost.Source: §1 · p. 2
• Θ(n^2/(C+S) + n) model calls are optimal for bit-reversal execution, with linear model-call complexity achievable if and only if C+S is linear in n.Without persistence, the computation incurs a Θ(n/C) multiplicative recomputation overhead when C=o(n).Source: §1 · pp. 2–3
• Stage-local sampling bounds are tight, imperfect verification has an exact error–cost law, and rollback has a closed-form optimal checkpoint interval.The paper states that perfect local verification removes logarithmic amplification overhead.Source: §1 · p. 3
• Held-out chained MATH shows that dependency-aware routing reduces logical input traffic within stepwise execution, while whole-task calls use less input traffic but have lower observed reliability.Checkpoint-cost forecasts identify the observed optimal interval at every tested verification price; the policy-selection test is conditional on a programmatic segment check not priced as a semantic call.Source: §1 · p. 3

2. Related Work

• Prior agent theory asks what models or agentic extensions can compute, while LAM asks what resources a harness spends to realize computation with semantic-oracle power fixed.The framework treats calls, context, persistent storage, memory traffic, and verification as computational resources.Source: §2 · pp. 3–4
• LAM bridges red–blue pebbling to harness execution, preserving simultaneous call and transfer budgets and the full discrete Pareto frontier.Its bit-reversal theorem gives Θ(n^2/(C+S) + n) model calls for active context and persistent memory, with explicit constants and an exact feasibility region.Source: §2 · p. 3
• The memory interface can change asymptotic complexity even when memory capacity is the same.The paper also notes that uncontrolled retrieval can saturate context, motivating adaptive control of which evidence enters it.Source: §2 · p. 3
• LAM prices correctness feedback and derives tight sampling bounds without feedback, exact imperfect-verification error–cost laws, and a closed-form checkpoint optimum under rollback.Unlike deployment-specific accuracy–cost measurements, the theory predicts feasible resource trade-offs and harness choices before execution, which the paper tests prospectively.Source: §2 · p. 4

3. Language Model Agent Machines

• LAM models harness-level execution around a fixed semantic interface rather than the model’s internal computation.The harness manages context construction, persistent state, memory access, tools, verification, and repeated calls.Source: §3 · p. 4
• A semantic block is a fixed-width unit of task-relevant information drawn from an input-size-dependent alphabet.The block width is denoted b(n).Source: §3 · p. 4
• The active context holds at most C blocks for the next call, while persistent memory holds at most S blocks that must be retrieved into context before use.A model call consumes context blocks and inserts its output into context; tools and verification are separate interfaces, and each interface sees only its opcode and argument blocks.Source: §3 · p. 4
• Value provenance requires each semantic block to originate from input, a declared constant, or a charged model or tool call.Copying, movement, and storage preserve origin; recomputation creates a new occurrence, and the controller cannot otherwise create semantic blocks.Source: §3 · p. 4

4. Communication: Moving State Across Bounded Context

• Model-facing traffic counts input and output symbols, while context–memory traffic counts semantic-block transfers between active context X and persistent memory M.Q_blk transfers correspond to Θ(Q_blk b(n)) symbols.Source: §4 · p. 4
• The computation DAG has one semantic block per vertex, with edges recording which predecessor blocks are required to compute an internal vertex.A vertex-granular evaluation charges each semantic call for at most one declared DAG vertex operation and may copy, move, store, retrieve, evict, or recompute values.Source: §4 · p. 4
• The pebbling model represents context blocks as red pebbles and persistent-memory copies as blue pebbles, with capacities C and S and one transfer charged per load or store.Provenance is needed because harness executions can copy and recompute values, so physical block occurrences do not map one-to-one to DAG vertices.Source: §4 · p. 4
• The red–blue pebbling correspondence preserves feasible call–transfer budget pairs and the full discrete Pareto frontier for memory-initialized, vertex-granular evaluations.Each model call corresponds to one Compute move, and each context–memory transfer requires at most one Load or Store move in the induced pebbling.Source: §4 · pp. 4–5
• Every red–blue pebbling lower bound becomes a harness-communication lower bound; for the classical n×n grid, Q_blk = Θ(n^2/C) when 3 ≤ C ≤ n and persistent storage is nonbinding.Weighted cost objectives follow from the same resource-region result.Source: §4 · p. 5

Pointer chasing

• Pointer chasing follows a permutation from a fixed starting index, and the sequential interface is read-only with its head initially at cell 1.The non-speculative restriction requires each read address to be the starting index or an index previously read into context.Source: §5 · p. 5
• Random access follows k pointers with Q_blk = k and Q_move = 0, whereas every always-correct non-speculative sequential LAM has expected Q_mem = Ω(kn) for 2 ≤ k ≤ n/4.The sequential lower bound applies to deterministic and zero-error randomized executions; random access uses C = 1 with address decoding or C = 2 with k oracle calls.Source: §5 · p. 5

One-stack FIFO

• The exact one-stack FIFO frontier holds even with arbitrary write-phase buffering; copy-free streaming requires C ≥ n, while random access works at C = 1 and S ≥ n.A content-blind schedule attains the frontier.Source: §5 · p. 5

Bit-reversal DAG

• The two length-n chains reuse first-chain results in a different order, so intermediate results may leave active context before they are needed again.The DAG connects u_i to w_rev(i), where rev reverses the m-bit representation for n = 2^m.Source: §6 · p. 5

Call complexity

• For input-delivered vertex-granular evaluations of the bit-reversal DAG, model-call complexity is Θ(n^2/(C + S) + n) when C ≥ 3 and C + S ≥ 4.For n ≥ 4, these conditions are also necessary for feasibility; an upper bound is attained with Q_blk ≤ 2n.Source: §6 · p. 5

Linear-call regime

• Within the feasible region, N = Θ(n) if and only if C + S = Ω(n), regardless of how that total capacity is split between context and persistence.The split determines transfer cost.Source: §6 · p. 5

Checkpointing

• For a length-n chain, an undetected error propagates to the end, motivating sampling and verification policies that control overall failure probability.The checkpoint policy verifies every k transitions and rolls a rejected segment back to its last accepted checkpoint.Source: §7 · p. 6

Sampling without feedback

• Stage-local sampling-only strategies need Θ(nγ^-2 log(n/δ)) calls on the binary hard family, and plurality achieves the matching order for bounded numbers of incorrect alternatives.Sampling may adapt at each step, but receives no correctness signal and cannot revise a committed transition; the lower bound assumes hidden labels and sampling only at the current node.Source: §7 · p. 6

Local verification

• With a perfect local verifier and uncapped retries, retry-until-accept has zero error and expected weighted cost n(1 + c_v)/(1 − ε).On the hard family, feedback removes the Θ(log(n/δ)) factor for constant γ and c_v; the gain comes from feedback, not more sampling.Source: §7 · p. 6

Imperfect verification

• With t conditionally independent checks per candidate, imperfect verification gives accepted-error probability q_t = b_t/s_t and expected cost n(1 + t c_v)/s_t under a stationary attempt law.Here a_t = (1 − ε)(1 − p_r)^t, b_t = εp_a^t, and s_t = a_t + b_t; chain failure is exactly 1 − (1 − q_t)^n when the attempt law is the same at every state.Source: §7 · p. 6
• Under the stationary attempt law, choosing the smallest t with n q_t ≤ δ yields Θ(n(n/δ)^α) expected model calls when 0 < p_a < 1 − p_r < 1 and nε > δ.The exponent is α = −log(1 − p_r)/log((1 − p_r)/p_a), and t = Θ(log(n/δ)).Source: §7 · p. 6

Checkpointing

• With independent transition errors and a perfect segment verifier, T(k) = (n/k)(k + c_v)(1 − ε)^−k, with positive-real minimizer k⋆ = 1/2(√(c_v^2 + 4c_v/β) − c_v), where β = −log(1 − ε).When c_vβ → 0, k⋆ is approximately √(c_v/β); if ε also tends to zero, k⋆ ∼ √(c_v/ε).Source: §7 · p. 6

Joint verification and rollback

• A joint local-check and rollback policy is cheaper than either mechanism alone in an explicit regime, with cost T(t, k) = (n/k)(k g_t + c_s)(1 − q_t)^−k.Here g_t is expected weighted cost per locally accepted step, q_t is residual error, and c_s is perfect segment-verifier cost.Source: §7 · p. 6

8. Experiments

• The experiments compare frozen predictions with held-out measurements, while prescribed-schedule accounting checks are reported separately and are not empirical tests of lower bounds.All model-based experiments use the same fixed GPT-6 Astra deployment.Source: §8 · p. 7, §8.2 · p. 8

8.1. Held-out MATH: traffic, success, and granularity

• 70/70 held-out MATH chains had every link correct with dependency-only prompting and verification, versus 64/70 with Direct; Direct used 1,311 input tokens per chain, versus 3,217 for dependency-only prompting with verification.Replay used 35,124 input tokens per chain and achieved 65/70 chains with every link correct; dependency-only prompting with verification reduced replay traffic by 10.9×.Source: §8.1 · p. 7
• Direct can compress many logical dependencies into one call with lower input traffic, while stepwise execution exposes intermediate state to memory management and verification.In the held-out evaluation, stepwise conditions showed higher all-link reliability than Direct.Source: §8.1 · p. 7

8.2. Reliability: checkpoint forecasts and held-out policy selection

• At verifier prices 1, 4, and 16, forecast and measured checkpoint-cost minimizers coincided at k = 4, 8, and 16, respectively.At price 4, the k = 4 cost forecast of 24.4 was measured at 24.2 [22.3, 26.3].Source: §8.2 · p. 7
• On 100 held-out chains per arm at (δ, c_v) = (0.10, 0.874), the frozen rule selected rollback k = 4, also the cheapest certified policy, with 1/100 failures and weighted cost 25.2 [24.1, 26.4].The measured cost matched the frozen forecast of 25.2.Source: §8.2 · p. 8
• The checkpoint-policy tournament tests selection conditional on an implemented segment-check interface, not end-to-end compliance with the vpa restriction.The interface composes public affine constants outside priced semantic execution.Source: §8.2 · p. 8

9. Conclusion

• LAM provides a framework for bounding and optimizing harness resource requirements while semantic capability is held fixed.It characterizes feasible tradeoffs across calls, memory, communication, and reliability.Source: §9 · p. 8
• In stepwise execution, dependency-aware routing sharply reduces logical input traffic, while held-out chained MATH shows whole-task calls can use less input traffic at lower observed reliability.The whole-task comparison lies outside the vertex-granular frontier.Source: §9 · p. 8
• The paper reports exact feasible regions, lower bounds, and closed-form resource tradeoffs across communication, memory access, recomputation, and reliability.Source: §9 · p. 8

AI Use Statement

• The authors developed and evaluated the research questions, framework, theoretical formulation, experiments, and conclusions.Source: AI Use Statement · p. 8
• The authors made substantive research decisions, verified retained mathematical claims and proofs, and took responsibility for the final paper.Source: AI Use Statement · p. 8
• AI assistance supported writing, related-work retrieval, and mathematical proof search and checking, with outputs treated as suggestions and independently reviewed.Source: AI Use Statement · p. 8

Reproducibility statement

• The paper releases simulation code, the frontier-model harness, theorem-target problems, figure scripts, logs, frozen configurations, and result files, alongside experimental protocols and parameters.Source: Reproducibility statement · p. 8

Ethics Statement

• The empirical work uses controlled simulations, a synthetic task, and public benchmark problems to test theoretical accounting and assumptions, not high-stakes deployment.Source: Ethics Statement · p. 8

A. Formal machine semantics

• LAM configurations include finite control, C active block slots, interface-specific persistent memory, registers, and public structural counters.Blocks retain provenance labels through copying, reading, and writing.Source: A. Formal machine semantics · p. 11
• Calls, copies, memory transfers, address operations, and input delivery are explicit machine steps, with memory and call interfaces constrained by the stated semantics.The input stream is not persistent memory and cannot be revisited after consumption.Source: A. Formal machine semantics · pp. 11–12
• The observation counter charges exposure of input blocks outside model-call arguments, including tool or verifier arguments and emitted inputs.Source: A. Formal machine semantics · p. 12
• With no persistent memory, fixed block width and capacity, and no public structural schedule counters, a single deterministic LAM decides exactly the regular languages.Every regular language is decidable with C = 2 under the stated insertion convention.Source: A. Formal machine semantics · p. 12
• A one-tape Turing machine running in time t and space s can be simulated with O(s) RAM, constant context, O(t) oracle calls, and O(t) block movements.The stated construction uses a single deterministic oracle.Source: A. Formal machine semantics · pp. 12–13

B.1. Proof of Theorem 1

• A priced call–traffic objective also has equal minima over LAM evaluations and pebblings for every pair of nonnegative weights.Source: §B.1 · p. 14
• LAM evaluations and red–blue pebblings have the same feasible simultaneous call–transfer budget pairs, and therefore the same nondominated resource vectors.The correspondence covers memory-initialized vertex-granular evaluations and a RAM realization attains feasibility.Source: §B.1 · pp. 13–14
• The correspondence depends on the evaluation class: free constants or streamed outputs can break the stated mapping unless the pebbling game is extended for outputs.The theorem’s converse is not asserted for input-delivered evaluations.Source: §B.1 · p. 14
• Uncharged controller-side value creation can collapse the pebbling-reduction lower-bound direction; for matrix multiplication, the cited example uses zero calls and Θ(n^2) transfers.The comparison is against an I/O lower bound of Ω(n^3/√C).Source: §B.1 · p. 14

B.2. Corollary 11 and Proposition 12: statements and proofs

• For the n × n grid DAG with C ≥ 3 and S ≥ n^2, the minimum transfer count is Θ(n^2/C + n), hence Θ(n^2/C) when C ≤ n.The result is for memory-initialized vertex-granular evaluations.Source: §B.2 · p. 15
• For the ordinary n^3-operation matrix-multiplication DAG with S ≥ 2n^2, transfers are Ω(n^3/√C).Source: §B.2 · p. 15
• For an n-step chain of width-b blocks, full-history replay costs Θ(n^2b) input symbols, while supplying only O(1) dependencies per step costs Θ(nb).For a non-degenerate vertex-by-vertex chain, input traffic cannot be below nb when each call receives the previous block.Source: §B.2 · pp. 15–16

C.1. Proof of Theorem 2

• For non-speculative machines, some permutation requires Eπ[Qmove] ≥ 3/256 kn for k ≥ 2, and the bound also holds for zero-error randomized machines.The proof forces first reads to follow the revealed pointer order. This lower bound is on aggregate memory-interface steps dominated by head motion, not an Ω(knb) bound on transferred symbols; speculative full-table scans are excluded.Source: §C.1 · pp. 16–17
• For bounded-workspace speculative machines, the exhibited expected move bound is O(min{kn, (n^2/C) log C}) for C ≥ 12.The landmark-shortcut algorithm achieves o(kn) when k = ω((n/C) log C); at C = √n and k = n/4 it uses O(n^(3/2) log n) moves versus Θ(n^2) for the non-speculative class. The workspace restrictions close escapes through unbounded control, tags, counters, block width, or writable tape.Source: §C.1 · pp. 17–18
• The bounded-workspace converse remains conjectural: Eπ[Qmove] = Ω(min{kn, n^2/C}) up to polylogarithmic factors.Lemma 13 reduces head moves to communication across a tape cut; proving the conjecture requires a distributional round lower bound for pointer chasing on a uniform permutation. The proof instead exhibits the speculative upper bound and establishes the non-speculative separation.Source: §C.1 · pp. 18–19
• On a read-only linear tape with S=n and the head initially at cell 1, for n≥16 and 2≤k≤n/4, every deterministic always-correct or zero-error randomized stream lam has expected Qmove at least n/9.The stronger bound is Eπ[Qmove] ≥ 243/2048 n for deterministic machines and Eπ,ω[Qmove] ≥ 243/2048 n for zero-error randomized machines.Source: §C.1 · p. 20

C.2. Query bandwidth: adaptive observations (Theorem 16)

• For deterministic LAMs, N(C−1) + Qobs ≥ D(f) on some input; randomized LAMs with per-input error at most 1/3 satisfy max_x E_x[N(C−1) + Qobs] ≥ R1/3(f).Model-call arguments and other observations—including decoded addresses, tool or verifier arguments, and emitted blocks—are charged; a call exposes at most C−1 argument blocks. For a selector, decoding the index and emitting the selected block are the two required observations, while parity requires all m blocks.Source: §C.2 · p. 21
• A content-oblivious schedule with C ≥ 3 needs N ≥ (r(f) − 1)/(C − 2) value-producing calls, a tight bound for group sums.Here r(f) counts globally relevant sources; this call-complexity bound differs from Theorem 16’s observation bound for adaptive schedules, and neither dominates the other pointwise.Source: §C.2 · p. 21
• Theorem 16 bounds deterministic query complexity by N(C−1) + Qobs; adaptive selector execution needs only D(f) = 2 observations despite r(f) = m + 1 globally relevant coordinates.For randomized execution, fixing and averaging over random tapes transfers the worst-input error and expected query bound to a randomized decision tree; the proof charges emitted input blocks and other observations.Source: §C.2 · pp. 21–22

C.3. Exact single-stack FIFO frontier

• Single-stack FIFO requires C ≥ ⌈(n + 1)/2⌉ with buffering, but C ≥ n under copy-free streaming; the exact trade-off also requires S ≥ max{n−C, 0} and 2 max{n−C, 0} pushes and pops.These frontiers assume the read phase follows the full write phase; buffering arrivals or retaining copies recovers the ⌈(n + 1)/2⌉ threshold.Source: §C.3 · pp. 22–23

C.4. Proof of Theorem 3

• For bit-reversal evaluation, (n^2/(C + S) + n)/32 ≤ N ≤ 4(n^2/(C + S) + n) when C ≥ 3 and C + S ≥ 4.The lower bound holds for C ≥ 2 and S ≥ 0; the upper-bound schedule uses checkpoints and at most 2n block transfers, reaching 2n−1 calls when S ≥ n.Source: §C.4 · pp. 24–25

• O(nγ^-2 log(An/δ)) model calls suffice for failure probability at most δ using independent plurality samples at each transition.The bound assumes at most A incorrect alternatives per correct state, each with probability at most p_c−γ.Source: D. Reliable computation · p. 25
• The stage-local sampling lower bound is scoped to settings where later transitions cannot revise earlier commitments or reveal a lookahead signal.The hard tree makes errors absorbing while off-path observations remain locally indistinguishable from the correct trajectory.Source: D. Reliable computation · pp. 25–26
• With perfect local verification, retry-until-accept uses n/(1−ε) model and verifier calls in expectation and has zero error.This removes the Θ(log(n/δ)) sampling overhead on the hard family for constant γ and verifier cost.Source: D. Reliable computation · p. 26
• For imperfect verification, retry-until-accept has per-step wrong-commit probability q_t=b_t/(a_t+b_t), with expected model calls 1/(a_t+b_t).Under the stationary attempt law, chain failure is exactly 1−(1−q_t)^n; false rejects can make the cost grow exponentially with the number of checks.Source: D. Reliable computation · p. 27
• Candidate-dependent or batch checking preserves the retry law through accepted-correct and accepted-wrong probabilities, even when checks within an attempt are dependent.Short-circuit checking reduces expected verifier work without changing acceptance probabilities or model-call counts.Source: D. Reliable computation · pp. 27–28
• For fixed imperfect-verifier rates with false rejects, the model-call count can be Θ(n(n/δ)^α), making it superlinear when p_r stays positive.The reliability target requires enough unanimous checks to control accepted errors, while the resulting false-reject probability reduces the acceptance rate.Source: D. Reliable computation · p. 28
• When k divides n, checkpointing has exact expected cost T(k)=n/k (k+c_v)(1−ε)^−k.This expression relies on independent segment attempts and rollback to the last accepted checkpoint; the displayed formula is not exact when k does not divide n.Source: D. Reliable computation · p. 28
• The continuous checkpoint optimum has a closed form, and the optimal integer interval lies within one of it; its small-error approximation is k⋆≈√(c_v/ε).The approximation is stated for ε→0; the paper relates the first-order optimum to Young–Daly, differing by a factor √2 because failures re-execute a whole segment.Source: D. Reliable computation · p. 29

E. Extensions and deployment mapping

• Deployment traces can charge model, verifier, tool, semantic-memory, and logical input/output events, while runtime KV movement remains a separate systems resource.When event costs vary with call size, cache state, or parallelism, they should be aggregated directly rather than collapsed into one universal coefficient.Source: E. Extensions and deployment mapping · p. 30
• Controller operations that create values can be represented as charged provenance nodes, but their effect on lower bounds depends on which semantic values they can create.The bounds also rely on controller computation not supplying uncharged correctness signals.Source: E. Extensions and deployment mapping · p. 30
• A hybrid of local checks and segment rollback can achieve perfect final correctness at cost 1.407n, below local checking alone at 1.633n and no local check at 1.809n in the stated witness.The witness uses (ε, p_a, p_r, c_v, c_s)=(0.05, 0.01, 0.05, 0.2, 2), n=1020, and t=1, k=51.Source: E. Extensions and deployment mapping · p. 30
• Pricing semantic-block transfers adds λ_blk Q_blk to the joint-policy objective, so the optimal local-check and checkpoint choices must be enumerated together.The transfer term depends on k and cannot be represented simply by replacing the segment-verifier cost with c_s+λ_blk.Source: E. Extensions and deployment mapping · pp. 30–31
• The independent checkpoint cost law extends to dependent errors only when conditional error hazards stay within the stated bounds after every rollback.Marginal error rates alone do not imply the envelope or sampling amplification; perfectly correlated replicas provide a counterexample.Source: E. Extensions and deployment mapping · p. 31

F. Controlled execution checks

• Controlled executions are implementation and scaling checks, not empirical evidence for the communication, access, or recomputation lower bounds.They use deterministic transitions for those checks and prescribed stochastic error laws for reliability.Source: F. Controlled execution checks · p. 31

F.1. Communication and access checks

• Tiled grid execution exhibits Θ(n^2/C) communication scaling, while pointer chasing shows random access avoids the intervening head movement paid by sequential access.On chains, dependency-only prompting and full-history replay reproduce linear and quadratic logical input-accounting laws, respectively.Source: §F.1 · p. 31

F.2. Reliability checks

• Simulated checkpoint retry costs follow the exact T(k) objective, and the observed optimum tracks its closed-form minimizer.The square-root approximation is reported as accurate only in its stated asymptotic regime.Source: §F.2 · p. 31

F.3. Recomputation implementation check

• Across tested capacity regimes, measured schedule counts fall within Theorem 3’s explicit constants for the predicted dependence on total semantic capacity.Figure 3 plots model-call count against C+S and shows the theorem’s bounds.Source: §F.3 · pp. 31–32, Figure 3 · p. 32
• With sufficient persistent storage, the construction uses exactly 2n−1 model calls and has linear call complexity.Its context–memory traffic satisfies Q_blk ≤ 2n.Source: §F.3 · p. 32
• At C=3, execution without persistence fails from insufficient semantic capacity, while adding one persistent block makes the schedule feasible.These runs check capacity use and upper-bound resource accounting, not the lower bound.Source: §F.3 · p. 32

G. GPT-6 Astra evaluation details

• The common GPT-6 Astra protocol counts semantic-state-producing calls as model calls and verdict-only calls as verifier calls.Calibration and held-out data are disjoint, and forecast parameters and policy rules remain fixed on held-out data.Source: G. GPT-6 Astra evaluation details · p. 32

G.1. Communication and cache accounting

• Measured logical input traffic across evaluated synthetic-chain depths reproduces the linear-versus-quadratic separation between dependency-only prompting and full-history replay.The comparison assumes fixed-width state and record encodings and fixed per-step overhead and history-record width.Source: §G.1 · p. 32
• With exact-prefix caching, the replay-to-dependency-only ratio falls from 7.14× to 1.72× on the deepest synthetic setting and from 11.0× to 3.05× on chained MATH.Caching narrows but does not eliminate the communication advantage of dependency-aware prompting.Source: §G.1 · pp. 32–33

G.2. Reliability

• A predeclared m*=15 voting policy solved 6/6 chains with 0/96 wrong plurality decisions despite substantial variation in error rates across chain states.A model preserving state-dependent error structure described held-out failures substantially better than a pooled homogeneous i.i.d. approximation.Source: §G.2 · p. 33
• Verifier acceptance behavior differs for naturally wrong, correct, and synthetically corrupted candidates, motivating candidate-dependent imperfect-verification analysis.The formulation is in Appendix D.Source: §G.2 · p. 33
• The held-out tournament compares unverified execution, sampling, local verification, segment rollback, and their joint policy using disjoint calibration and evaluation chains.Calibration-derived forecast parameters and policy-selection rules remain fixed on held-out data.Source: §G.2 · p. 33
• The segment-rollback tournament tests prospective policy selection conditional on a programmatic segment-check interface, not an end-to-end realization of the vpa restriction.Composing public transition constants within a segment uses controller-side arithmetic and is not charged as a semantic call.Source: §G.2 · p. 33

G.3. Bit-reversal implementation check

• The bit-reversal checks compare recomputing, persistent, and resident schedules with a one-call Direct reference, using analytically determined call, recomputation, and transfer counts.Rule-specific error and token costs are estimated on disjoint calibration data and held fixed during evaluation.Source: §G.3 · p. 33
• Across evaluated bit-reversal instances, prescribed schedules reproduce analytical counts without capacity violations; persistent execution uses linear calls and linear context–memory traffic.Resident execution removes transfer cost when required state fits in context, while recomputing execution incurs additional semantic calls when persistent state is unavailable.Source: §G.3 · p. 33