acceptodds
Under review as a conference paper at ICLR 2027

Local Tests, Long Horizons: What Memory-Compaction Tests Identify

Abstract

Short reset tests can be reused to assess repeated memory updates, but a precise local test need not identify long-horizon risk. We study which output statistics a test must retain, which uncertainty a computable bound actually covers, and when the resulting test is affordable. Complete marginal tables can admit nearly unit stationary risk ambiguity. A support-aware continuation criterion characterizes exact identification for all initial states, while quantitative examples show why small first-horizon ambiguity is not a deployment-horizon guarantee. Across 330 geometries, certified frozen-kernel brackets reveal discrepancies that a two-step diagnostic misses. We then select among candidate output features using simultaneously calibrated observations, without supplying the generator's influential feature. Selection improves some matched-budget certification decisions but loses at the smallest budget because of its statistical correction. Established random-set and robust dynamic programming (DP) methods provide propagation; we make their information, temporal, and sampling relaxations explicit. The supported operating regime is cheap resettable software with declared small-block structure, not unrestricted language-model compaction.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
memory compaction, reliability certification, partial identification, robust dynamic programming, statistical calibration

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_h8C1OpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposes a framework for evaluating long-horizon risks in repeated memory-compaction systems using short reset tests. Its novelty compared with the state of the art is a criterion that determines whether retained output statistics are sufficient to identify future risk. To achieve this, the framework models memory errors as a finite-state Markov process. Evaluation on synthetic processes shows that accurate short-horizon tests may fail to identify long-horizon risk, while richer statistics sometimes improve risk analysis but require very large testing budgets.

Critical strengths
  • Problem of determining long-horizon risks is interesting and relevant
Critical weaknesses
  • The paper is poorly written and very difficult to follow.
  • The research problem, practical objective, and intended use case are not defined clearly enough.
  • The evaluation is difficult to understand, including what is being measured and which baseline is the main comparison.
  • The experiments use only synthetic processes and do not evaluate a real memory-compaction system.
  • The technical novelty is limited because the method mainly combines established random-set and robust dynamic-programming techniques.
  • The required testing budgets reach millions of calls, which makes the approach impractical for the motivating LLM use case.
Questions for authors

No question whose answer could affect my assessment.

1 comment
AuthorsOpenReview ↗

Response to Reviewer h8C1

Thank you for the review.

W1: the paper is hard to follow. We agree, and we rewrote the abstract and introduction in plain language (pages 1–2). Section 3 now defines the core terms before the analysis uses them, with a two-record example (pages 2–3). Sections 3–6 open by saying what they show, and the captions of Figures 1–2 and Tables 1–2 explain every axis and column.

W2: problem, objective and use case. The introduction now states all three (pages 1–2), and a box in Section 3 restates them (page 3). A one-step reset test sets the memory to a chosen, possibly corrupted, state, runs one update, and keeps a statistic of the output. The problem is to decide when that statistic determines R_H, the probability that a query fails after H updates. The objective is a certificate: an upper bound on R_H that holds with probability at least 1 − δ (δ = .05) for all horizons at once. The paper has two intended uses. It warns anyone who summarizes one-step tests that per-record error rates, error counts, clean-input results and two-step checks can leave long-horizon risk undetermined, even with unlimited samples. It also gives certificates for cheap resettable software whose small error state is fixed in advance from how it works, but it is not a practical test for large language model (LLM) memory.

W3: what is measured, and the main baseline. The Protocol paragraph of Section 7 now answers both under separate labels (page 8). Each synthetic experiment reports the mean upper bound on R_H over independent datasets and compares it with the exact risk, while the LLM pilot compares the bounds from one reset dataset with a rollout estimate. The main baseline is direct testing, which spends the same number of calls on runs of H updates and bounds their mean final loss. It fills the last column of Tables 1 and 2 and all of Appendix M. Direct testing gives tighter bounds for every 8- and 12-record design in Table 2. At 12 records, 2,097,152 calls and H = 128, for example, its bound is 4.69 × 10⁻³, against 4.95 × 10⁻² for our certificate built from error counts. At H = 128, direct testing is looser in every 4-record design, in the two rows of Table 1 where the evaluator is told the mechanism's structure, and in our added experiment on a third-party cache library (Section 7.3).

W4: synthetic processes only. We agree that this was the main gap. The revision adds a pilot with a real LLM, run under a protocol written before the main runs (Section 7.4, Appendix O), and our general response summarizes it.

W5: limited novelty. We agree that the bound computation uses established random-set and robust dynamic-programming tools, and that one direction of Theorem 2 follows from value-equivalence reasoning in reinforcement learning, as Sections 1 and 2 say. Our new results concern what test summaries can determine: an exact risk range that per-record error rates can leave open (Theorem 1), the converse of Theorem 2's identification criterion when some transitions are known to be impossible, and the counterexample of Section 4.3. In that counterexample, two processes share every error-count statistic and their two-step risk, yet reach risks of 0.52 and 1 − 1.87 × 10⁻³ (nearly 1) at step 128.

W6: budgets of millions of calls. Such budgets are impractical for LLM updates, and at these budgets direct testing also gives tighter bounds than our certificates (Appendix M). The results on what a test can determine (Theorems 1–2 and Section 4.3) involve no sampling, so they hold whatever the budget. In the LLM pilot, the reset test used 2,048 calls, and direct testing with the same calls was again tighter (0.56 against 0.73 at H = 32).

Reviewer_CoAnOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces a diagnosis of the memory compaction test of long horizon agents. An agent may drop an important condition during a compaction step and corrupt the instruction. The corrupted instruction may be carried over to subsequent steps or it may get repaired. Cost of testing all updates directly by running each of them is high and the authors argue that a one-step test on a clean input can be cheaper but may miss later updates. The reason is that a test may retain a summary of the update in form of some statistics which are not enough to detect errors. Therefore, they ask the questions, what is identifiable in each update step, at which horizon, and what is the cost of this one-step test strategy. The proposed one-step test can only recover long run risk if retained error states can present the current loss and expected loss of the next update. The paper does not propose a better compactor or new test. Instead, it reasons about what a one-step test can tell the evaluator.

Critical strengths
  • The paper addresses an important and timely problem, i.e., losing information during memory compaction, in agent systems.

  • The paper presents a formal analysis of the subject problem. They answer the questions formally with relevant theorems and propositions (but I cannot fully understand the proofs).

Critical weaknesses
  • The presentation is difficult to follow. The paper did not provide the necessary context and definitions of certain terms. For example, “the upper kernel” is mentioned in theorem 1, but it was not clear which part of the whole frozen-kernel is defined as “upper” part. Also, the theorem proofs did not provide information about what they are trying to achieve. As a result, it is difficult to understand them. For example, in section 4.2, theorem 2, to my understanding, aims to prove that at least one next step risk is required to identify a risk. But this is not clearly stated in the proof.

  • The evaluations in section 8 help support the questions asked in section 1, but they are done in a synthetic setting setup by the authors. Using a real-world agent to show usefulness of retaining correct information and how it assesses long horizon risk would make the paper stronger.

Questions for authors
  1. Section 7 demonstrates the validity of the claims made in the paper through a simulation created by the authors. Is there any evidence of support that this will hold true for real-world agents?
1 comment
AuthorsOpenReview ↗

Response to Reviewer CoAn: definitions, Theorems 1–2, and evidence from a real model

Thank you for the careful reading. Our reset tests can start from any chosen error state, including a corrupted one, and the paper warns against testing only the clean input (Proposition 13).

Missing definitions. We agree. Section 3 now defines each core term before the analysis uses it, with a two-record example (pages 2–3): the error state (which records are wrong), the kernel (the error state's transition matrix), frozen kernels (the same at every update), compatible kernels (those matching the kept statistics and using only allowed transitions) and identification (all compatible kernels give the same risk). Section 4.3 first defines the width at a horizon as the range of risks over compatible kernels (page 4).

"The upper kernel" in Theorem 1. The upper kernel is a whole kernel, named for attaining the upper end of the risk interval in Eq. (4). From each state it makes all records wrong together or none of them, like a common shock. The kernel at the lower end has the same per-record error rates but never makes all records wrong from a clean start. Per-record rates cannot tell the two apart at any sample size, whereas the full output vector can. Theorem 1 now names both kernels (pages 3–4).

What Theorem 2 proves. Theorem 2 gives an exact condition under which the test determines the risks from every starting state up to horizon H. For each j < H, the expected loss after j more updates, as a function of the state, must be a linear combination of the kept statistics on the next states allowed from each state. Your reading is close to the case H = 2: the loss and the one-step expected loss must both be computable from the kept statistics, although neither has to be kept itself. If the condition first fails at some j, two compatible kernels give different (j + 1)-step risks from at least one starting state. For example, two kernels on two records with the same error-count law in every state give three-step risks of 0.5 and 0.75 from a clean start (page 4, after Theorem 2). Theorem 2 is now followed by a plain-language paragraph and a "Proof idea" for both directions (page 4). The main proofs now open with their goal and strategy, and Appendix A indexes them (page 16).

Question 1: evidence from real agents. The submitted paper had none, so the revision adds a small pilot with a real language model, run under a protocol written in advance (Section 7.4, Appendix O). Because calls are stateless, the memory can be reset exactly. The pilot tests the mechanism in your summary: an instruction such as "Deploy configuration B only after test C passes" is corrupted and then carried over or repaired. Both our reset-based upper bounds cover the measured 32-step risk (0.74 and 0.73 against 0.41). A test on the clean memory predicts only 0.05, and a two-step check 0.10, because neither captures persistence: in reset tests, filler messages that concern no record never repaired a wrong record. Testing corrupted inputs mattered more than which statistics the test kept: from the same resets, per-record error rates and the full reset frequencies both predict 0.35, and error counts alone predict 0.41 (exploratory).

The pilot also showed a weakness: after a message restating the correct value, our hand-written errors in the release-gate record (a condition like "only after test C passes") were repaired more often than the model's own (76% of resets against 51% of rollout steps; exploratory). Treated as exact, the reset frequencies predict a risk of only 0.35, which the 0.74 bound would approach with unlimited resets. That bound therefore stays above the measured 0.41 only through its allowance for sampling error. With errors taken from the model's own outputs, the reset-based prediction rose to 0.40, close enough to the 0.43 of held-out rollouts to pass a pre-specified check. The rise from 0.35 is not statistically significant, however. With the same number of calls, direct testing on full rollouts gave tighter bounds.

One small model with three records cannot show how large the simpler tests' underestimates are for larger agents. Section 2 now cites Sinha et al. (2025), who inject errors into chat histories at a chosen rate and find that later turns of non-thinking models become more error-prone, but do not bound long-horizon risk.

Reviewer_hTB9OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies what a resettable one-step test can establish about long-horizon endpoint risk for a frozen finite-state memory-update rule. The key distinction is between observing every input state and retaining enough information about joint outputs. Compatible kernels can share marginal or count summaries while producing different future risks.

The theoretical contributions include an exact dependence-ambiguity construction, a support-aware continuation-space identification criterion, and delayed examples showing that zero two-step ambiguity need not imply small uncertainty at deployment horizons. The paper separately analyzes frozen-kernel and time-varying uncertainty, one-sided statistical relaxations, and simultaneous finite-sample coverage. Several studies enclose stationary widths across a small geometry family and evaluate selection among predefined output features without revealing the generator's influential bit.

The experiments use synthetic finite-state processes under stated assumptions about sufficient states, reset access, transition supports, and block structure. They compare count-based certification, selection among additional output features, and direct testing under different sampling budgets.


Overall, as I stated in the strengths/weaknesses boxes, I like the paper at a conceptual level, the observations that motivate the work make a lot of sense and resonate with me (particularly that agreement over a short horizon does not guarantee similar long-horizon behavior). However, the experimental shortcomings (being realistic enough and showing enough benefits) make me much less enthusiastic about the paper.

Critical strengths
  1. The paper studies a relevant question. Testing individual memory updates is an appealing alternative to repeatedly running long trajectories. The paper asks whether the information collected by those tests is sufficient to assess later errors. This is a useful question because accurate one-step measurements can still miss dependencies that affect repeated updates. The distinction gives the work a clear motivation beyond improving the precision of an existing local test.

  2. The analysis shows the information a local test should preserve. Within the described finite-state setting, the theorem characterizes when the retained output statistics determine future risk, taking the allowed transitions into account. This provides a way to describe why a test summary may be insufficient. It also connects the choice of statistics to the future quantity being evaluated, which is a more informative objective than measuring local error rates alone.

  3. The counter-examples show the limitations of short tests. Section 4.3 especially give processes that agree on the tested error-count distributions and on their two-step risk, yet have substantially different risks after repeated updates. These examples support the central observation that agreement over a short horizon does not guarantee similar long-horizon behavior. They also show why the identitis of the affected records can matter even when the error counts look the same.

Critical weaknesses
  1. The experiments do not show the connection to practical memory compaction. The study is limited to constructed finite-state processes. No experiment shows that the chosen error-state representation is sufficient for a natural-language compactor or another concrete memory-compaction system. In such systems, two summaries with the same number of missing or incorrect facts may lead to different future behavior for reasons that the tested state representation does not capture. The synthetic examples do illustrate the theoretical issue, but they leave the application evidence incomplete. A small example using an actual compaction task, with a justified state representation, would help establish whether the proposed test identifies failures that existing evaluation would miss.

My main reservation is that the paper motivates its analysis through memory systems without demonstrating that the resulting procedure can evaluate one. I find the concept interesting, but the current evidence does not make its significance for the intended application sufficiently clear.

  1. The benefit is unclear. The method assumes reset access to specified states and prior justification of the structural assumptions used in the analysis. Section 6 and Table 1 show that reducing the testing cost depends on additional knowledge of the process. The reported budgets can otherwise reach millions of resets. It is unclear how an evaluator would obtain the required structure, or when the total cost would be preferable to directly testing repeated updates. Also, the feature-selection experiment in Section 7.1 is also constructed so that candidate family contains the influential bit. Hiding which bit is influential tests selection within that family, but does not establish how to choose an adequate family for an unfamiliar system. Together, these requirements limit what the current experiments demonstrate about an affordable testing workflow. A concrete use case showing how the assumptions are obtained and how the test changes an evaluation decision would make the contribution more convincing.
Questions for authors
  1. Can the approach be demonstrated on a small memory-compaction task where the state representation and reset procedure are justified independently of the synthetic generator? In particular, what failure would the proposed test detect that a simpler evaluation would miss?

  2. How would an evaluator obtain the structural assumptions and candidate statistics for that task, and what would the total testing cost be compared with directly evaluating repeated updates? (I am unsure whether this question could be answered without another study)

2 comments
AuthorsOpenReview ↗

Response to Reviewer hTB9 (1/2): a small compaction task, and what simpler evaluations miss

Thank you for a careful, accurate review.

Weakness 1 and Question 1: a small compaction task. The revision adds one (Section 7.4, Appendix O). A public model we did not train, Qwen2.5-1.5B-Instruct, updates a three-record memory (release gate, owner, rollback window) from filler messages, distractors and authoritative restatements. Each call sees only the memory text and one message, so writing it is an exact reset, and deployment is the same loop fed with the model's own output. The 3-bit error state marks the records that a fixed rule-based scorer judges wrong, and it comes from the memory's schema and the query loss rather than from our generator. The certificates assume that this state carries all the past that matters for the next update, and the protocol, written in advance, tests that assumption. It checks whether the wording of planted errors matters, whether reset and rollout transitions agree in each state, and whether states with the same error count behave alike (Table 12). Both certificates cover the deployment risk at every step up to 32 (0.74 and 0.73 against 0.41 at H = 32, with 95% bootstrap interval [0.38, 0.44]). The full-row certificate, which bounds each next-state probability separately, stays above 0.41 only through its allowance for sampling error, as the plug-in chain below shows.

What the test detects that a simpler evaluation misses. A direct evaluation misses nothing at its own horizon, so we compare our test with simpler one- and two-step summaries at H = 32, where the deployment risk is 0.41.

Simpler evaluationPredictionWhat it misses
Clean-input one-step test0.05Errors persist: in resets, filler never repaired a wrong record (0 of 1,525).
Two-step check0.10Errors keep accumulating after step 2.
Per-record error rates0.35It misses no more than the full reset frequencies do, since both predict 0.35.
Error count only0.41One-error states with different wrong records have different distributions of the next error count (Holm-corrected p < .001), although at H = 32 the count-only prediction still exceeds the 0.35 of the full reset frequencies (exploratory).

For the 32-step risk, how the model responded to corrupted inputs mattered more than which record was wrong.

Your concern, observed. States with the same error count did have different futures. With one wrong record, a wrong owner gained a second error in 20% of resets, but a wrong gate or window in only 7–9%. Our certificates test each error pattern as a separate input, so this does not affect them. Our added experiment on a third-party cache library is a documented instance of the same problem, because tracking only which keys the cache holds misses which key it evicts next (Section 7.3). A subtler case came from who wrote the errors: after a restatement, our hand-written wrong gates were repaired in 76% of resets, but the model's own in only 51% of rollout steps (exploratory). Treating the reset frequencies as exact (the plug-in chain) therefore predicted 0.35, against a measured 0.41. The checks specified in advance did not catch this, but an exploratory rate check did. A follow-up, specified before we saw its results, took error texts from the model's own outputs in half of the rollouts, planted them in new reset tests, and kept the other half as a held-out reference. At H = 32, the held-out mean (0.43) then fell inside the 95% band of the new plug-in prediction (0.40). The rise from 0.35 to 0.40 is not statistically significant, however (exploratory 95% interval [−0.02, 0.13]).

Limits. The pilot has one small model, three records, a fixed message mix and a rule-based scorer. Checks can reject the assumptions behind the certificates but cannot establish them.

AuthorsOpenReview ↗

Response to Reviewer hTB9 (2/2): where the structure comes from, cost against direct testing, and a decision that changes

Weakness 2. We agree that the experiments, including the pilot, do not show an affordable workflow for an unfamiliar system.

Question 2: where the structure comes from. In the pilot, the records and the loss come from the memory's schema (three keyed fields) and a per-record query. The reset writes memory text into a stateless call, which needs no access beyond the deployed interface. No candidate statistics were needed, because with only 8 error states the full-row certificate keeps the whole next state. The reset is exact; the hard part was mapping error states to realistic memory texts. Our hand-written wrong gates were repaired too easily. Errors taken from the system's own scored outputs passed a held-out check, but obtaining them needs deployment logs. In the synthetic experiments, we wrote the generator that supplied the structure. Section 6 now names inspectable properties that supply such structure (page 7). For example, permutation symmetry of the record slots makes the next error count depend only on the current one (count-lumpability, Proposition 21), and in the third-party cache the documented eviction rule gives the recency state, the order in which keys were last used (Section 7.3). In Table 1, declared structure is given to the evaluator as mechanism knowledge, not inferred from data, and the caption now says what each row declares.

Total cost against direct testing. In the pilot, the reset test used 2,048 calls, and checking its error state against deployment used another 8,192 calls (the 256 reference rollouts). The follow-up's certificates used 6,144 calls: 2,048 new resets plus 4,096 calls from the 128 reference rollouts that supplied their errors. Those 128 rollouts alone give a direct bound of 0.50 at H = 32 (exploratory), tighter than both follow-up certificates. At the same 2,048 calls, direct testing is tighter at the tested horizon: 0.33 against 0.53 at H = 8, and 0.56 against 0.73 at H = 32. In the synthetic experiments without declared structure, direct testing is tighter at the shortest tested horizon in every benchmark, and at every tested horizon for the 8- and 12-record designs (Appendix M). Reset-based testing is tighter mainly at long horizons with few tested inputs, and for both rows of Table 1 that declare structure at H = 128. It covers every horizon with one confidence statement but needs resets to chosen states and a justified error state, while direct testing needs only restarts and covers one horizon per bound.

A decision that changes. In the pilot, an evaluator with a risk budget of .15 at H = 32 would accept the updater on a clean-input test (0.05) or a two-step check (0.10). Neither reset certificate (0.74 and 0.73) certifies the updater, and the rollouts (0.41) show that it should not be accepted. Direct testing with the same 2,048 calls (0.56) does not certify it either (Section 7.4, page 10). In Section 7.1, corrected feature selection certifies target .05 in 24 rather than 14 of 24 datasets at 12 records and 2,097,152 calls. At four records and 2,048 calls, however, it certifies target .08 in only 12 rather than 17 of 24. At the larger budget, direct testing certifies target .005 in all 24 tests, while neither reset-based bound certifies any.

Candidate family. We agree. Section 7.1 tests selection within a family that contains a sufficient bit by construction, and the paper now states that this experiment does not show how to choose a family for an unfamiliar system (page 8). The bound stays valid without an adequate family, because Proposition 4 holds for any finite set of binary features of the declared state fixed before data collection. Its usefulness does need one, and even with an adequate family the correction for multiple candidates made the bound worse at the smallest budget (four records, 2,048 calls).

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response: summary of the revision

We thank the reviewers. Three concerns recur, and we agree with all of them: the paper evaluated no real memory-compaction system, its budgets of millions of calls are impractical for large language model (LLM) updates, and it was hard to follow.

Clarity. We rewrote the abstract and the introduction in plain language, defined the core terms in Section 3 before the analysis uses them, and made every main-text figure and table caption self-contained.

Evidence from a real model. We added a small pilot in which a public LLM, Qwen2.5-1.5B-Instruct, updates a three-record memory (Section 7.4, Appendix O). Its protocol was written before the main runs. Both upper bounds we compute from one-step reset tests (our certificates) cover the measured 32-step risk, while a test on the clean memory and a two-step check underestimate it four- to ninefold. The pilot also exposed a weakness: the model repaired our hand-written errors more easily than its own, so the reset tests understated how long errors last, and one of the two bounds stays above the measured risk only through its allowance for sampling error.

Cost. Every experiment in Section 7 now compares our bounds with direct testing, which spends the same number of calls on full rollouts to the tested horizon (Tables 1–2, Appendix M, and Section 7.4 for the pilot). Direct testing is often tighter, including in the pilot, and the replies to h8C1 and hTB9 say where each approach wins.

Scope. The paper analyzes what one-step tests can determine about long-horizon risk. It is not a practical test for LLM memory (page 2), and a pilot with one small model and three records shows feasibility and failure modes, not general suitability.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.