acceptodds
Under review as a conference paper at ICLR 2027

Beyond Replay Fidelity : Restoration Completeness in Agent Evaluation

Abstract

Resuming a tool-using agent requires recovering the state on which its next actions depend. A checkpoint can faithfully preserve a record of success while losing the application effect it records. We study restoration completeness as a condition of agent evaluation, using a decision-contract framework that distinguishes local information sufficiency, native-score sensitivity, and adaptive recovery effort. Enumerating all 19 AppWorld development families (57 instances) yields 28 qualified boundaries. A controlled intervention retains the visible checkpoint while omitting application effects; native scores fall in nine families (25 instances), and replaying the omitted statement rescues all 25. A 180-episode study evaluates GPT-5.6-sol and GPT-5.5 separately, each with five fresh pairs per instance on the same nine selected affected instances. Complete restoration succeeds in 45/45 episodes per policy; Partial succeeds in 40/45 and 38/45, respectively. Mean paired increases are 1.82 and 0.87 Python execution requests (conditional 95% bootstrap intervals [1.42, 2.24] and [0.20, 1.53]), or 9.1% and 4.3% of the 20-request budget, computed before rounding. Both policies register completion in all five of their Partial reminder failures. Complementary Cybench witnesses test strict action-ranking reversals. Average added effort recurs across the two evaluated campaigns, while its magnitude and family-level signs vary. Evaluations should declare the restoration boundary and report native reward together with recovery effort under the stated interface and budget.

Primary area:
datasets and benchmarks
Keywords:
LLM agents, agent evaluation, restoration completeness, observational partial-decision aliasing, decision sufficiency, recovery effort

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 2 reviews, above 85% of the others.
Reviewer_wquoOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper focusses on the mismatch and effects of agent state and environment state in the case of an interruption as tested on AppWorld. The experimental design focusses on switching between keeping the agent and environment state in sync and not doing so and results show a fall when there is mismatch. Further trying this on SOTA models shows they can often discover and repair the missing state but doing so requires additional effort that ordinary success rates don't capture. Expanded to Cybench, the experiment demonstrates that even a perfectly restored agent memory can be insufficient for decision-making when important external state is missing or has changed.

Critical strengths
  1. The paper isolates the effects of incomplete restoration by keeping agent history and interpreter state fixed while varying the underlying application state.
  2. The Complete/Partial/Repair comparisons and categorization of unsuccessful or unqualified instances strengthen the reliability of the findings.
  3. The evaluation of SOTA models demonstrates they can frequently reconstruct missing application state but often require additional execution requests and sometimes declare completion despite missing required effects.
  4. Measuring recovery effort alongside task success is a useful contribution to agent evaluation.
Critical weaknesses
  1. The paper's central observation is already well established in recent agent-recovery research. Crab and AgentRewind address consistency between agent and environment checkpoints, while DART explicitly formalizes semantic recoverability and evaluates recovery on LangGraph. Safe to Resume? (2026) studies external-state mismatches and execution-continuity failures across existing agent frameworks.
  2. The omission of DART and Safe to Resume? from the related-work discussion further weakens the novelty positioning.
  3. The proposed decision-contract framework and Cybench examples largely formalize established principles of state consistency and partial observability without introducing a new recovery method.
  4. The primary experiments deliberately combine a later agent checkpoint with an earlier application database snapshot creating the inconsistency being investigated and making it synthetically likely grounds for the effect.
  5. Although the paper reports 270 adaptive episodes, these involve repeated evaluations of just nine selected affected instances, with 15 of the 17 Partial-restoration failures concentrated in a single payment-reminder task.
Questions for authors
  1. Without evaluation of naturally occurring interruptions, realistic checkpointing failures, or a broader distribution of recovery tasks, the work does not convincingly establish significance. Can we do that?
  2. How does the proposed restoration-completeness framework substantively advance beyond prior work as mentioned above?
4 comments

Dear Reviewer,

As the deadline for the discussion period approaches, we kindly request your feedback on our response. Your insights would be greatly appreciated.

Thank you for your time and consideration!

AuthorsOpenReview ↗

Authors' Response (follow up for Q1 and W5)

Thank you again for your careful review. One further study bears directly on Q1 and W5.

Q1. Without evaluation of naturally occurring interruptions, realistic checkpointing failures, or a broader distribution of recovery tasks, the work does not convincingly establish significance. Can we do that?

The same consequences appear in a complete, unmodified agent under real crashes. We ran the Hermes agent [1] with its native session recovery and its own memory. On six ToolSandbox tasks, we killed its gateway process 30 times, each after the application committed a change and before the agent recorded the result. Standard recovery then repeats ten contact creations and messages. Receipt-aware recovery reduces this to zero and cuts API calls from 82 to 60. In five direct-message cases, both runs receive the identical native score, 0.9253, although one sends every message twice.

W5. [...] with 15 of the 17 Partial-restoration failures concentrated in a single payment-reminder task.

These effects do not depend on the reminder task. The Hermes duplicates arise in contact creation and direct messages. In all four fault conditions of two CrewAI workflows, the run that repeats effects scores higher, for example 0.9315 versus 0.8679 with 10 versus 0 duplicates.

We have added these results to Section 5 and the appendix.

References

[1] Nous Research. Hermes Agent, 2026. https://github.com/NousResearch/hermes-agent

Thank you for the detailed response and the additional experiments. The container restart study addressed my concern about the deliberately mismatched snapshots. Both models recovered all eight tasks after storage loss but each needed three times as many requests as after a restart with durable storage. The additional failures across several non-reminder tasks also address my concern about the original results being concentrated in one task.

My main reservation is still novelty given the overlap with DART and 'Safe to Resume?'. The Hermes result helped clarify what this paper adds: in five cases, sending a message once and sending it twice received exactly the same score. I think that is a useful finding for people evaluating recovered agents. How often these failures occur in deployment remains open, but the revised paper makes a stronger empirical case. I’m raising my rating to 3 (weak acceptance).

Thank you very much for your thoughtful follow-up and for raising your rating. We are glad that the container restart study and the failures across non-reminder tasks addressed your concerns. We also truly appreciate your recognition of the Hermes finding. As you noted, sending a message once and sending it twice can receive exactly the same score, and we share your view that this matters for anyone evaluating recovered agents.

We will keep the distinction from DART and "Safe to Resume?" clear in the final version. Thank you again for your careful reading and constructive feedback throughout the discussion, which have made our paper stronger.

Reviewer_btuFOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies and determines the "restoration completeness" in AI agent evaluation, arguing that faithfully restoring an agent's checkpoint does not necessarily preserve the external application state required for successful continuation.

The paper provides taxonomy about a decision contract framework distinguishing state restoration, decision relevant information, and recovery behavior. To evaluate their setup, they use controlled interventions in AppWorld benchmark by deliberately restoring an earlier application state while preserving the agent's later execution history.

The results show that agents can often recover successfully, but with additional execution requests, while some report completion despite missing application effects.

Critical strengths

S1. I appreciate the rigour taxonomy that is sound and understandalbe, actually I think that formalizing this setup is the strongest contribution of the paper. The motivation is solid.

S2. Interesting finding that even frontier modern models agents sometimes report completion despite missing required effects is particularly relevant for evaluating reliable autonomous agents. -> the setup assisted to discover it.

Critical weaknesses

W1. The evaluation is done with LLM-based agent systems, which are simple and without the proper harness kit. I think that it should showcase the capabillities of modern agentic architectures with suitable harness (there are many available in opensource).

W2. Some findings that are highlighted in the paper sound trivial to me - For example, its unsurprising that removing application effects required by the remaining execution leads to task failure, since the experiment deliberately combines an agent checkpoint with an earlier application database snapshot, creating an inconsistent state.

The paper does not establish how frequently these mismatches occur under real agent checkpointing systems or sufficiently demonstrate what new capability the proposed framework provides beyond existing approaches.

W3. The adaptive evaluation includes only 9 distinct task instances, selected specifically because incomplete restoration had already been shown to harm their reference continuations. Furthermore, in seven of these nine instances, the selected checkpoint is immediately before task completion, making the effect of removing completed application operations relatively predictable.

Consequently, I find the evidence insufficient to establish the general importance and practical impact of restoration completeness across realistic agent workflows.

Questions for authors

Q1. I was wondering throughout the paper how practical this problem is? Do you have any infromation about frequently do such incomplete restoration states arise in real agent checkpointing systems, rather than under deliberately constructed mismatches? Since I'm from the domain, and I wasn't familiar with this issue, I tend to trust its a real issue, however, I'm lack with motivation story quantifying this issue in real world.

Q2. Can you evaluate on more tasks, providing insights (maybe a different benchmark, although I acknowledge the AppWorld is well structured with DBs). It could be also earlier checkpoints (for example, after each tool changing the db), it could assist understand the horizion phase impact on the successfull restoration.

5 comments

Dear Reviewer,

As the deadline for the discussion period approaches, we kindly request your feedback on our response. Your insights would be greatly appreciated.

Thank you for your time and consideration!

Thank you for the extensive rebuttal and additional experiments. I appreciate the effort.

However, several concerns remain:

W1: Full agent implementations. My concern was not only about using a native framework, but whether these findings persist in more sophisticated, end-to-end agent systems with their own memory, state management, and recovery strategies. LangGraph's ReAct agent and CrewAI workflows are relevant additions, but do not fully address this distinction. I was referring to systems such as Hermes, OpenManus, or comparable open-source agent implementations. Can you clarify what capabilities of such systems are represented by your evaluation, and which remain untested?

Scope of the rebuttal: The rebuttal introduces multiple new benchmarks, fault models, recovery mechanisms, and experimental cohorts. While these strengthen the work, they also appear to substantially expand the original empirical contribution. Could you clarify which of these experiments are essential to the paper's central claims and which are supporting validation?

Revised manuscript: I could not find these extensive additions incorporated into a revised PDF. It is difficult to rigorously assess this amount of new material across six separate rebuttal comments.

Related work: I also encourage you to position the expanded contribution relative to "Safe to Resume? Breaking Execution Continuity of Agent Execution via Rollback", which studies checkpoint consistency and recovery failures in Hermes, Cline, and LangGraph, including duplicated external effects.

The rebuttal addresses several original concerns, especially experimental breadth (although the amount and scope are questionable for rebuttal response or a new submission).

However, current several limitations remain.

Thank you for reading our extensive response and for your continued engagement. We are glad that the additions address several of your original concerns, especially experimental breadth. Below we answer your four remaining points.

W1 (follow-up). [...] Can you clarify what capabilities of such systems are represented by your evaluation, and which remain untested?

Our answer: the evaluation covers the recovery capabilities that create the failure. The failure arises at the restoration boundary. The agent restores its own state, while the effects it caused live in external applications. Every agent that checkpoints its state and acts on external applications has this boundary, however rich its memory or planner.

CapabilityRepresented in our evaluation
Persistent agent stateLangGraph SQLiteSaver, CrewAI Crew.from_checkpoint, Hermes sessions and memory, AppWorld interpreter state
Recovery strategiesPending-write replay, checkpoint restore in a new process, Hermes session resume, restart after container removal, receipt-aware recovery
Stateful applicationsAppWorld in Docker, ToolSandbox, Cybench
Real faultsProcess and gateway SIGKILL, container removal, lost tool responses, ephemeral storage loss

Now tested: a complete agent with native recovery and its own memory. We ran the unmodified Hermes agent [2] with its native session recovery and agent-written memory, under 30 real crashes on six ToolSandbox tasks. Five direct-message cases receive the identical native score, 0.9253, under standard and receipt-aware recovery. Standard recovery still sends every message twice and doubles the API calls. Across all 30 crashes, receipt-aware recovery cuts duplicate records from 10 to 0 and API calls from 82 to 60. Deleting Hermes's memory files leaves the first model input unchanged in 30/30 resumed sessions, as the history keeps the content. The test therefore separates a lost file from lost information.

Not yet tested. Multi-agent planning state. OpenManus [3] has no native checkpoint or resume in its default path, so there is no recovery to evaluate. Our test treats such state as one more persistence domain.

Scope of the rebuttal. [...] Could you clarify which of these experiments are essential to the paper's central claims and which are supporting validation?

Our answer: the claims rest on the submitted experiments. The new studies validate the same claims under the conditions the reviewers requested, and add no new claim.

Paper claimEssential evidence, submitted paperSupporting validation, rebuttal
A faithfully restored checkpoint can omit needed application effects, and native scores changeCensus of 19 AppWorld families: scores fall in 9 (25 instances), and replay rescues all 25Real storage loss: the fixed suffix falls to 2/8
Success can conceal reconstruction effort, false completion and repeated effects270 episodes, three systems: Complete 45/45, Partial 38 to 40/45, +0.87 to +1.82 requests47 AppWorld tasks in 31 families, all task phases, native LangGraph, CrewAI and Hermes recovery
A recovered score needs a declared contractDecision-contract formulation and the Cybench witnessReceipt-aware recovery reports 19 unresolved intents instead of repeating effects

Revised manuscript. [...] It is difficult to rigorously assess this amount of new material across six separate rebuttal comments.

Our answer. We will incorporate these additions without changing the paper's scope. Section 5 summarizes the new evidence, and a new appendix reports each study in full.

Related work. I also encourage you to position the expanded contribution relative to "Safe to Resume? Breaking Execution Continuity of Agent Execution via Rollback" [...]

Our answer: Safe to Resume? shows that rollback can break execution continuity. Our paper measures what such breaks do to evaluation. Safe to Resume? [1] is a security study that demonstrates rollback attacks in Hermes, Cline and LangGraph. We ask what a recovered evaluation score certifies. We hold the visible checkpoint fixed, intervene only on application effects, and measure native reward, effect multiplicity and recovery effort against matched controls. Their attacks show that the gap matters for security. Our measurements, including on Hermes, show that the same gap stays invisible to success-based evaluation. We have added this comparison to Section 1.1.

Thank you again for your careful reading. We would be grateful if you would take these clarifications into account in your final assessment.

References

[1] Guanlong Wu et al. Safe to Resume? Breaking Execution Continuity of Agent Execution via Rollback. arXiv, 2026. https://arxiv.org/abs/2608.29381

[2] Nous Research. Hermes Agent, 2026. https://github.com/NousResearch/hermes-agent

[3] FoundationAgents. OpenManus, 2025. https://github.com/FoundationAgents/OpenManus

Comments on the paper

9 comments
AuthorsOpenReview ↗

Authors' Response (1/5) for W1 and Q1

Thank you for your careful and constructive review. We sincerely appreciate your recognition that the intervention and repair controls support a clear causal interpretation, that the full census retains qualification errors and nonreproducible instances, and that the adaptive experiments show how terminal reward can conceal reconstruction work. We would like to address your concerns as follows.

W1. The advance beyond established consistency and state-aliasing principles remains limited. [...] Established consistency approaches already require completion records and their associated mutations to be preserved coherently; RIFL, for example, explicitly couples their creation atomically. The relevant question is therefore what new evaluation insight the proposed decision contract contributes beyond that established perspective. [...] The decision-contract formulation organizes these observations, but its practical added value has not been demonstrated through a consequential evaluation decision that would otherwise be missed.

Q1. What concrete evaluation judgment becomes possible through the decision contract that would be missed by an explicit application-consistency specification plus joint reward-cost reporting? A worked example using existing cases would help.

The concrete evaluation decision is which claim a recovered outcome supports: native attainment, preservation of prior progress, duplicate-free execution, or sufficient information for the next action. Our controlled continuations test these claims separately while holding the visible checkpoint fixed. The contract makes the proposition testable: "A decision contract declares the restored state, continuation payoff, allowed observations and their budget, and acceptable fallback behavior." (§2.1, lines 126–127.)

Worked example from the existing payment-reminder task (Appendix C.3). We executed two fixed continuations from the same visible checkpoint in all three reminder variants, under both restoration states. Finish succeeds in 3/3 Complete and 0/3 Partial states. Resend-then-finish succeeds in 3/3 under either state. However, it adds 7/16/6 duplicate notifications when the original effects survive (Complete). Thus the native objective admits a common successful recovery action. A duplicate-free objective instead selects different successful actions in the two states. The paper states the consequence: "Thus these successes do not establish duplicate-free execution." (Appendix C.3, lines 966–968.)

Evaluation claimExecuted evidence requiredJudgment supported by the completed comparison
Native attainment after recoveryOriginal evaluator applied to the continuationFixed resend succeeds in every reminder state, including states in which it repeats delivered reminders.
Duplicate-free attainmentNative attainment plus the declared target-effect multiplicityFinish is successful without duplicates in Complete. Resend restores the missing effects in Partial.
Preservation of progressSame-checkpoint application-state and continuation contrastUnder an actual native storage fault (Q2 below), two continuation models pass all eight tasks. However, ephemeral-storage restart requires 3.00× the requests of durable-storage restart.
Sufficient information for a fixed choiceSame observation, declared worlds/actions and their payoffsThe local AppWorld sufficiency certificate accepts one local sufficiency claim. The strict OPD witnesses reject others (table below).

A consistency specification states what should hold. The contract's executed comparison establishes whether a given recovered score meets it. This is the judgment that joint reward–cost reporting misses. Two recoveries with identical success can differ in whether progress was preserved, reconstructed or repeated, and an executed comparison on the same checkpoint reveals which. Our procedure supplies exactly this evidence. We preserve the recorded agent code, outputs and interpreter state, vary the application dependency, and check targeted repair or matching restoration. We then measure fixed and adaptive continuations with the unchanged native evaluator. This identifies which dependency the score relies on and what work a successful continuation reconstructs. In the payment-reminder task, the sender-visible list does not establish recipient delivery. Q3 reports the additional information available through the permitted interface and a complete budgeted policy built on it.

AuthorsOpenReview ↗

Authors; Response (2/5) continued for W1 and Q1

Response to W1 and Q1 (continued)

Native harness comparisons make the consequence observable beyond the worked payment-reminder example.

  • LangGraph lifecycle faults. We run LangGraph's prebuilt ReAct agent, ToolNode and SQLiteSaver over a native AppWorld service. From 30 fixed autonomous candidate trajectories (six tasks), 21 qualify with a genuine pending checkpoint immediately before their first successful persistent application mutation. Each checkpoint receives five conditions. One is a no-fault control. In three, the tool response is lost, the graph process is killed, or the application worker exits after the result receipt is written. In the fifth, the tool response is lost before the receipt is written. Each condition runs under two configurations, standard pending replay and receipt-aware recovery, for 210 continuations. Faults occur after native application persistence and before the graph records the tool result. No database rollback or checkpoint edit is involved. Every arm achieves 21/21 native success. In each configuration, 8 of the 84 fault branches stop at the shared native completion check. In the other 76, standard recovery initially re-executes the already committed pending cell in 76/76, versus 0/76 with receipt handling (57 completed receipts returned, 19 unresolved intents surfaced). The score is identical whether or not the replay duplicates an effect. In the payment-reminder trajectory, each fault window adds seven duplicate notifications under standard replay and none under receipt-aware recovery.
  • Fresh autonomous SMS trajectories. We use a prospectively fixed frame of twelve autonomous candidates in six task categories selected by API semantics. Two SMS trajectories, each containing two intended sends, have supported pending checkpoints. Both configurations pass both no-fault controls. After a graph-process kill following the receipt, or a response loss before the receipt, standard replay passes 0/2 and receipt handling passes 2/2. Standard replay adds four versus zero extra target-message rows across the two sources in each fault condition. The unchanged native evaluator rejects the repeated sends through its exact added-recipient-list requirement.
  • ToolSandbox receipt gap. This independent-prefix CrewAI/ToolSandbox workflow uses six tasks × five randomized slots, with 30 episodes per arm. The tool response fails after the application commits, and the running Crew continues. Standard and receipt-aware native scores are 0.9315 and 0.8679. Standard produces ten extra identical records, while receipt-aware recovery produces none. Every preceding milestone scores 1.0 in both arms. The higher score comes entirely from the final response milestone, not from the application state. The configuration with the higher native score is the one producing the duplicates.

Positive and negative sufficiency cases calibrate the distinct information claim. Restoration completeness "requires preserving the decision information or continuation outcomes specified for an evaluation, rather than every bit of machine state" (§2.1, lines 122–123).

Submitted caseExecuted evidenceLocal judgment
Local AppWorld sufficiency certificate, Appendix B.5Database and observed song-title/play-count list fixed, ten unused-marker worlds, correct top-four answer 10/10, alternative 0/10, twenty consistent save/load checksThe unused marker can be omitted for this fixed comparison and declared world set.
Strict OPD witnesses (Cybench), Appendix DIdentical visible context and fixed action bytes, payoffs (1,0) in one reachable world and (0,1) in the other, 134/134 reversals across three mechanisms, 0/50 same-state control flipsThe restored observation cannot select the better member of that fixed pair in both worlds.

The certificate combines structural reasoning with exhaustive finite checks. Its structural basis is stated in the paper: "Neither suffix nor evaluator reads u." (Appendix B.5, line 869.) The reversals include ten prospectively frozen LockTalk pairs. These examples keep the claims distinct: "Our AppWorld census tests score sensitivity, while the Cybench witnesses test strict OPD." (§2.3, lines 164–165.)

RIFL [1] supplies the established consistency foundation of coupling completion records and effects. The paper identifies its empirical contribution precisely: "our contribution is the controlled restoration contrast, not joint reporting itself." (§1.1, lines 113–114.) The fixed-state, repair and continuation comparisons above are the evidence for that contribution.

References

[1] Collin Lee, Seo Jin Park, Ankita Kejriwal, Satoshi Matsushita, and John Ousterhout. Implementing Linearizability at Large Scale and Low Latency. In Proceedings of the 25th Symposium on Operating Systems Principles (SOSP), 2015. https://web.stanford.edu/~ouster/cgi-bin/papers/rifl.pdf

AuthorsOpenReview ↗

Authors' Response (3/5) for W2 and Q2

We now turn to your second concern.

W2. The adaptive evidence concentrates on a narrow interruption regime. Seven of the nine adaptive instances are checkpointed immediately before a completion-only reference suffix. [...] The midpoint diagnostic contains no persistent application-state difference in any of the nine instances, while the six partial-rollback cases receive fixed-suffix rather than adaptive evaluation.

Q2. Beyond near-terminal rollback to the initial database, what collected evidence supports the same adaptive reward-effort conclusion for partially lost effects or earlier checkpoints containing persistent state? Please distinguish existing evidence from proposed extensions.

Every result below is collected and complete. The submitted paper already contains the fixed-suffix partial-loss result: "Less-than-total rollback is therefore sufficient in these cases." (§4.1, lines 304–305.) The new evidence adds adaptive evaluation of partial loss, autonomous checkpoints with mandatory work still remaining, and actual storage faults.

1. Autonomous checkpoints with mandatory work still remaining (new multistage frame). We prospectively selected eight multistage tasks by their public task semantics. Examples are update a playlist, then download its songs, place an order, then restore the cart, and attach an updated resume, then send drafts. We generated three autonomous trajectories per task. The complete frame contains 24 trajectories and 341 returned-tool states. A frozen first/last persistent-nonterminal rule selects 35 positions. Thirteen positions from seven trajectories across three tasks pass the declared namespace/replay requirements. Selection precedes continuation outcomes and does not use the goal-phase labels, which are computed offline from the native goal predicates. Each position is continued under intact restart (R, the Complete condition), application loss to the initial database (L, the Partial condition) and matching restoration of the boundary snapshot (J). The continuation budget is 20 requests and 900 seconds. This gives 39 continuations in 13 matched triples, all independently re-scored.

R, L and J achieve 13/13, 11/13 and 13/13 native successes. The two goal phases exhibit the two consequences the paper distinguishes. Where mandatory work remains, loss changes the score. L succeeds at 5/7 positions, and both failures exhaust the 20-request budget, while R and J succeed at 7/7. Where the application goals are already complete, the score is unchanged but the work is not. L succeeds at 6/6 positions, yet every one of the six requires additional requests (+3 to +17, equal-task mean +6.667). It also requires additional API attempts (mean +91.333) and additional continuation time (mean +87.1 s).

Goal phasePositions / tasksR / L / J native successesConsequence of loss
Mandatory application work remains7 / 37/7 / 5/7 / 7/7Score: both L failures end at the 20-request limit
Application goals complete6 / 26/6 / 6/6 / 6/6Work: every position needs more requests (+3 to +17, mean +6.667)

The remaining work at the unfinished positions includes playlist/download operations, order/cart work and unsent emails, as established by the native goal predicates. In this frame, only 3 of the 21 trajectories that change application state are already goal-complete at their first changed state. The frame therefore reaches the earlier regime by design.

2. Adaptive evaluation of partially lost effects. Following the interior-snapshot intervention of §4.1, we restored snapshots that retain 42.9–50% of the completed effects of a multi-write statement. We then continued adaptively in six tasks with five pairs per task. Complete succeeds in 30/30 and partial loss in 24/30, with +1.667 [1.133, 2.233] execution requests. Excluding the payment-reminder task gives 25/25 versus 24/25 and +2.000 [1.360, 2.720] requests, with a positive request mean in every retained family.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.