Computation and Language · arXiv:2610.17544 v2 · submitted 13 Oct 2026
Many Steps into One: Reasoning Contraction and the Limits of Safe Memory Reuse for LLM Agents
The paper says
“Thought templates, skill libraries, agent memories and caches turn many reasoning steps into one. We call this reasoning contraction. A contracted memory saves reasoning steps and errors until its facts change, then quietly answers wrong.”
more of the abstract
Most systems trust memories by counting successes and failures. We prove that such counters are badly tuned change detectors: a symmetric counter notices a partial change only after a power of its false-alarm horizon, and an unclipped one may never notice it. On five LLMs answering multi-hop questions over edited facts, ExpeL- and ACE-style counters serve 7.0-13.5x more stale answers than certified memories given the same information, and on code tasks with an exact verifier 35-73x more. Safety also has a price. When facts change and each memory is judged only by its own verified outcomes, one number, the certification load, sets how much reasoning any safe memory can skip, and under Zipf demand it yields a scaling law. Our recipe weighs each memory's failures by its own likelihood ratio, certifies its utility against live reasoning, and restarts the certificate when facts change, with the likelihood-ratio detector as the safety net for unannounced changes; for large edits it also invalidates the memory.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 14 Oct 2026 · of version 1 of the paper; version 2 is newer · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. A strong theoretical and empirical paper that reframes memory trust as sequential testing, proves counters are suboptimal change detectors, and derives a fundamental limit on safe reasoning contraction together with a practical recipe that validates across five LLMs. This line is wrong
2 major objections · 6 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the references say.
The paper says, at Appendices B–C, Theorem 3, Corollary 4
The review did not quote this passage.
Pith says: Objection 1 of 2 · major
The i.i.d. within-epoch assumption (A4) is load-bearing for the fundamental limit and the scaling law. As the skeptic notes and the Limitations acknowledge (L189–L190), this rules out gradual drift or autocorrelation within an epoch. The paper does not analyze the sensitivity of the lower bound or the scaling law to gradual drift, nor does it test such a scenario empirically (the natural Wikidata edits still treat each year as a constant-rate epoch).
more of objection 1
This gap limits the practical applicability of the guarantees. Please discuss how the lower bound and optimality change when the failure rate drifts smoothly, and consider adding simulations or analytical extensions for gradual drift, or at least clarify the conditions under which the bound is robust.
The paper says, at Section 3, Theorem 1
The review did not quote this passage.
Pith says: Objection 2 of 2 · major
Theorem 1 and the phase diagram assume i.i.d. outcomes before and after a single change. While the empirical evaluation uses step-changes from fact edits, many real-world drifts are gradual. The paper should discuss the extent to which the qualitative regimes (positive drift → logarithmic; zero drift → quadratic; negative drift → power law) persist under gradual drift, and whether the delay expressions derived are still valid as approximations.
6 minor objections
The paper says, at Section 2, Equation (1)
Pith says: minor objection 1 of 6
The break-even reliability r⋆ is defined with L (error price) and m (live cost). The definition assumes all errors incur the same penalty L. It would be helpful to note that this is a simplification and that the paired-utility certificate later avoids needing to know L.
The paper says, at Figure 2 caption
Pith says: minor objection 2 of 6
The Kaplan–Meier share is plotted, but the legend says 'share in service at stream end / restricted mean delay (uses, ≤ 10^4)'. Consider adding explicit x-axis label 'folded uses since fact change' to improve clarity.
show 4 more
The paper says, at Section 6, Table 2 footnote
Pith says: minor objection 3 of 6
The table note says 'Bold: ours.' but the column 'counters' is not bolded. The row labels are already clear, but consider using '—' or separate rows to avoid confusion.
The paper says, at Appendix A, Proof of Theorem 1
Pith says: minor objection 4 of 6
The proof uses Lorden's worst-case delay definition. The argument for the three regimes is clear, but the constant in the zero-drift case (D ≤ [(h + ¯x)^2 + ...]/σ_1^2) could be expanded slightly for readability.
The paper says, at Appendix C.2, Proposition 23
Pith says: minor objection 5 of 6
The statement of Proposition 23(iv) includes the term δ_J K_c; note that K_c is the wealth at the epoch start. It would be helpful to briefly note that K_c ≤ 1/δ_J if the test has not yet crossed the threshold, so the bound becomes δ + δ_J(1/δ_J - 1)_+ = δ + (1 - δ_J)_+.
The paper says, at Appendix D, Experimental details
Pith says: minor objection 6 of 6
The definition of a 'stale episode' in D.3.5 uses a reliability increase of at least 0.1 to identify onset. While reasonable, the sensitivity of the results to this threshold should be briefly noted.
What would settle it
Construct an experiment where each macro's failure rate drifts linearly from q0 to q1 over a fixed number of D queries after each change (e.g., D=1000, q0=0.05 to q1=0.25), instead of jumping. Keep all other settings identical to the KQA-STREAM main experiment (five models, 30 streams). Measure (a) whether the per-memory LR-CUSUM still detects staleness within 1.5× the ideal i.i.d. delay, (b) whether the coverage gap M of the restarted SPRT still lies within 1.1× of Fπ(Θ) for moderate δ (0.01, 0.05), and (c) whether false-certification rates remain below δ. If these degrade significantly, the theoretical guarantees require stronger conditions than the experiments currently test.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 14 Oct 2026
- Reader holds up, with conditions
- Skeptic partly agrees
- Editor wrote the verdict above
- Referee major revision: 2 major objections, 6 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
This paper is worth your time. It introduces the concept of reasoning contraction — compiling multi-step derivations into one-step memories — and shows that the trust mechanisms in systems like ExpeL and ACE are effectively change detectors tuned to the wrong change. The theory is the main event: a clean phase diagram (Theorem 1) proving that equal-vote counters can have power-law delays under partial staleness, and a fundamental limit (Theorem 3) that ties the coverage gap to a single certification load Θ. The scaling law under Zipf demand (Corollary 4) is elegant and matches simulation. The empirical work is thorough: five LLMs, multiple edit sequences, a matched-population analysis, natural Wikidata edits, and code tasks with an exact verifier. The recommended lifecycle — per-memory likelihood-ratio CUSUM, betting-based certification, restart on change — cuts stale answers by 7–13× over counters in the main experiments, and the detection advantage holds up in a matched comparison. The authors are careful about scope: they state assumptions clearly and include a candid Limitations section.
The soft spots are the ones the paper names. The central theorems assume i.i.d. outcomes within an epoch and known change rates. The optimality of the SPRT and the scaling law depend on these idealizations. Temporal drift, correlated failures, or gradual reliability changes are ruled out. The stress-test concern about drift is real but already acknowledged; the paper notes that the experimental setting uses controlled fact edits that cause jumps, not drift. Practical deployment also requires noticing every change of the null (including live reasoning), which is a strong condition; the authors offer discard-on-alarm as an alternative with weaker guarantees. The natural-edit experiments are limited to one domain and treat each year as a new epoch, not a drift within. None of this undermines the central argument under its own axioms, but it does bound the direct applicability to piecewise-constant settings with exact verifiers.
This paper deserves a serious referee. The theoretical framework is novel and well-posed, the experiments are far beyond what most memory-system papers provide, and the recommended methods should be adopted by any LLM agent system that uses an exact verifier. I would bring it to reading group and cite it. Send it to peer review; it will need a revision that addresses generalization of the assumptions, but the core contribution is solid.
The strongest objection
The paper's central limit (Theorem 3) and scaling law (Corollary 4) rely on the assumption (A4) that within an epoch, audited outcomes are i.i.d. Bernoulli with a fixed failure rate, and that changes are Poisson events that reset the failure rate to a constant. This rules out temporal drift within an epoch (e.g., gradual concept drift, decaying LLM calibration) or correlated outcomes (e.g., burst failures from a shared context change). If the failure rate drifts, the KL divergence between 'healthy' and 'stale' is not constant, and the log-likelihood ratio increments are no longer i.i.d. The lower bound in Theorem 3 uses a change of measure that requires the likelihood ratio to be a product of i.i.d. factors; with drift, the Wald identity and the uniform bound on unfolded queries may fail. The paper acknowledges this in the Limitations ("the theorems assume that each audit reveals one verified outcome whose law is set by the memory's current reliability, and that facts change at random times") and notes that the experimental setting uses controlled fact edits that cause a jump in failure rate, consistent with the model. However, real-world streams often exhibit gradual performance changes (e.g., an LLM's accuracy on a task may degrade smoothly as knowledge becomes outdated). The empirical validation on natural Wikidata edits (Appendix D.4.4) tests small, partial changes but still treats each year as a new epoch with a constant failure rate; it does not test gradual drift within an epoch. The concern is therefore that the practical applicability of the optimality and scaling results may be limited to scenarios with piecewise-constant failure rates, which are not always realistic.
The reader's weakest assumption correctly identified the i.i.d. outcome assumption and Poisson change times as key idealizations. My concern focuses on the i.i.d. part more specifically: the assumption that within an epoch, outcomes are i.i.d. with a constant failure rate. This is a standard assumption in change-point theory, but it rules out gradual drift or autocorrelation. The paper acknowledges this limitation in the Limitations section and the experimental design uses jumps, which is consistent with the model. However, real-world scenarios may involve gradual drift, and the paper does not test this regime. The central theorems (Theorem 1, Theorem 3, Corollary 4) are proved under the stated assumptions, so they remain mathematically correct. The concern is about external validity: how robust are the recommended methods when the assumptions are violated? The paper provides the discard-on-alarm alternative (Proposition 25) as a fallback for unannounced changes, but gradual drift within an epoch is a different kind of violation. Despite this, the experimental validation on synthetic jumps and natural small edits is substantial, and the primary recommendations (weight outcomes by likelihood ratio, restarted certificates) are still likely to be beneficial even under mild drift. Therefore the CONDITIONAL verdict remains appropriate.
The referee's report
If the results hold, the paper provides a principled theoretical framework for memory trust in LLM agents, unifying change detection, sequential testing, and coverage analysis. The phase diagram of counter maintenance and the certification-load limit are conceptually novel and practically relevant: they show that popular vote-based memory systems use badly tuned change detectors and that safe contraction has a fundamental price. The scaling law under Zipf demand connects the coverage gap to the demand tail, which is testable. The empirical evaluation is thorough (five LLMs, multiple edit sequences, matched-population analysis, natural edits, code) and supports the theory. The recipe is actionable. The paper also corrects a prior theoretical claim about infinite delay in mismatched CUSUM. Its main weakness is the reliance on the i.i.d. within-epoch assumption, which is acknowledged but not fully addressed for gradual drift.
Pith's reading of the paper (a machine's summary, not the authors')
LLM agents compress multi-step reasoning into one-step memories (macros). The paper proves that the vote counters used by ExpeL and ACE are provably suboptimal change detectors: under partial staleness a symmetric counter's detection delay grows as a power of its false-alarm horizon, and an unclipped counter may never retire a stale memory (Theorem 1). It derives a fundamental limit on safe reasoning contraction — a certification load Θ = ν ln(1/δ)/(p KL) that sets how much reasoning any safe memory can skip — and shows that a restarted sequential test achieves this limit with a Zipf scaling law (Theorem 3, Corollary 4). The recommended recipe weighs a memory's failures by its own likelihood ratio, certifies utility by betting on paired shadow evaluations, and restarts the certificate at every change notice; on five open LLMs it reduces stale answers 7–13× against counters under identical information.
What carries the argument. The certification load Θ = ν ln(1/δ)/(p KL) is the central object that organizes the fundamental limit of safe reasoning contraction. It combines the rate of fact changes (ν), the risk tolerated (δ), the audit rate (p), and how much one verified outcome reveals (KL). The limit states that every safe policy must leave a share F_π(Θ) of queries to multi-step reasoning, and a restarted sequential probability ratio test reaches it. The second key mechanism is the per-memory Bernoulli likelihood-ratio CUSUM, which weighs each failure against its own healthy and stale failure rates, making it the optimal detector for that change.
Core claim. The paper establishes that every trust decision for a reasoning memory (a macro) is a sequential test, bound by the limits of change detection and certification. It proves that the vote counters used by ExpeL and ACE are Cumulative Sum (CUSUM) change detectors tuned to the wrong alternative: under partial staleness (e.g. reliability 0.95→0.75), a symmetric counter waits a power of its false-alarm horizon, not its logarithm, and an unclipped counter may never notice the change. The correct detector weights failures by the Bernoulli log-likelihood ratio; for that change the weight is about 7 successes per failure. The paper then derives a fundamental limit on safe contraction: no δ-safe policy can achieve a coverage gap smaller than (1−ε_δ)F_π(Θ), where Θ = ν ln(1/δ)/(p KL) is the certification load that combines change rate, risk, audit rate, and how informative a single outcome is. A restarted sequential probability ratio test achieves this limit, and under Zipf demand it yields a scaling law κ_s $Θ^{{1−1/s}}$. The recipe installs a per-memory likelihood-ratio CUSUM for retirement, a betting test for certification that needs no estimate of live accuracy, and restarts the test at every change notice; on five open LLMs it reduces stale answers 7–13× against counters under identical information.
The premise it rests on. The safety guarantees depend on the assumption that each audit reveals exactly one verified outcome whose failure rate is constant within an epoch (i.i.d. outcomes and Poisson change times). This rules out temporal drift within an epoch, correlated failures, and verifiers with noise beyond a known flip rate. The theorems also require that the paired-utility null changes only when noticed, so unannounced changes of live reasoning or cost can break per-epoch safety unless the detector triggers restarts (Proposition 23).
If the paper is right (Pith's inferences, not the authors')
Memory systems should adopt the per-memory likelihood-ratio weighting for retirement, which detects staleness 3.7–6.1× faster than symmetric rules at matched false-alarm rates.
The certification load Θ provides a principled way to price how much reasoning any safe system can contract; templates with popularity well above Θ will be quickly certified, rare ones may never be.
Benchmarks that evaluate memory reuse must edit facts and count stale answers, not just loss metrics that can hide stale outcomes behind higher coverage.
The betting certificate allows safe certification without knowing live accuracy, avoiding the pitfall of plug-in tests that can exceed δ at break-even.
Restarting certification at each change notice (including changes of live reasoning) is essential for per-epoch safety; without restarts, carried-over evidence can defeat the guarantee.
The paradigm shift from heuristic counters to sequential-test-driven memory management can be applied to any caching system where cached values can become partially stale, not just LLM reasoning memories. Web caches, database query caches, and compiled code caches face similar tradeoffs.
The scaling law κ_s Θ^{1−1/s} suggests that the Zipf exponent s of the query distribution determines how much caching helps: popular items can be cached safely, long-tailed rare items change before they can be trusted. Infrastructure serving long-tailed workloads may need to accept higher risk or live computation for rare queries.
The per-memory likelihood-ratio tuning requires knowing the healthy and stale failure rates for each memory. In practice these are unknown and must be estimated; the paper proposes estimation from the stream itself and shows first-order minimax optimality when only an interval is known, but the robustness of the guarantees when q0 drifts within an epoch remains an open question.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Thought templates, skill libraries, agent memories and caches turn many reasoning steps into one. We call this reasoning contraction. A contracted memory saves reasoning steps and errors until its facts change, then quietly answers wrong. Most systems trust memories by counting successes and failures. We prove that such counters are badly tuned change detectors: a symmetric counter notices a partial change only after a power of its false-alarm horizon, and an unclipped one may never notice it. On five LLMs answering multi-hop questions over edited facts, ExpeL- and ACE-style counters serve 7.0-13.5x more stale answers than certified memories given the same information, and on code tasks with an exact verifier 35-73x more. Safety also has a price. When facts change and each memory is judged only by its own verified outcomes, one number, the certification load, sets how much reasoning any safe memory can skip, and under Zipf demand it yields a scaling law. Our recipe weighs each memory's failures by its own likelihood ratio, certifies its utility against live reasoning, and restarts the certificate when facts change, with the likelihood-ratio detector as the safety net for unannounced changes; for large edits it also invalidates the memory.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-10-14
The authors' main claim, as the classifier picked it out 0.52
“When facts change and each memory is judged only by its own verified outcomes, one number, the certification load, sets how much reasoning any safe memory can skip, and under Zipf demand it yields a scaling law.”
How the main claim is stated: asserted 1.00
What the abstract itself states, as probabilities: claims first 0.06 · states limitation 0.73 · human participants 0.04 · controlled comparison 0.75 · randomized assignment 0.02 · states quantitative result 0.98 · compares with prior results 0.94 · mentions code or data availability 0.03
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Thought templates, skill libraries, agent memories and caches turn many reasoning steps into one. | background 0.93 | 0.11 | 0.04 | asserted 1.00 |
| We call this reasoning contraction. | contribution 0.76 | 0.33 | 0.04 | asserted 0.91 |
| A contracted memory saves reasoning steps and errors until its facts change, then quietly answers wrong. | background 0.59 | 0.22 | 0.16 | asserted 1.00 |
| Most systems trust memories by counting successes and failures. | background 0.99 | 0.06 | 0.03 | asserted 1.00 |
| We prove that such counters are badly tuned change detectors: a symmetric counter notices a partial change only after a power of its false-alarm horizon, and an unclipped one may never notice it. | result 0.50 | 0.83 | 0.22 | asserted 0.99 |
| On five LLMs answering multi-hop questions over edited facts, ExpeL- and ACE-style counters serve 7.0-13.5x more stale answers than certified memories given the same information, and on code tasks with an exact verifier 35-73x more. Safety also has a price. | result 1.00 | 0.93 | 0.30 | asserted 1.00 |
| When facts change and each memory is judged only by its own verified outcomes, one number, the certification load, sets how much reasoning any safe memory can skip, and under Zipf demand it yields a scaling law. | result 0.69 | 0.83 | 0.43 | asserted 1.00 |
| Our recipe weighs each memory's failures by its own likelihood ratio, certifies its utility against live reasoning, and restarts the certificate when facts change, with the likelihood-ratio detector as the safety net for unannounced changes; for large edits it also invalidates the memory. | method 0.91 | 0.84 | 0.30 | asserted 1.00 |
What kind of paper the classifier reports this is: theoretical result 0.54 · evidence from observation or experiment 0.67
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-14: 1 request, 6,305 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (10)
Showing 9 of the paper's 10 figures. Figures are the authors', reproduced from the paper.
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment