acceptodds
Under review as a conference paper at ICLR 2027

MemScope: Evolving Agent Memory Architectures through Localized Code Repair

Abstract

Agent memory architectures define how LLM agents store and reuse experience across tasks, but they are typically fixed after deployment, limiting their adaptability across task types. Recent self-evolving approaches instead adapt these memory architectures using execution feedback, typically represented as evaluation scores or compressed summaries. However, such coarse-grained feedback is insufficient for precise failure localization in current agent systems, where long-horizon task execution involves multiple interacting components. Without a precise failure location, existing approaches lack a clear code-level target for modification, leaving the update scope weakly constrained and often leading to large-scale rewrites of an otherwise capable memory architecture. We propose MemScope, a framework for evidence-grounded, localized evolution of an existing memory architecture. Its tool-using Patch Agent jointly inspects raw execution traces, runtime memory state, and current architecture code to identify repair targets and apply bounded, in-place edits under provider-identity and memory-compatibility constraints. On GAIA, the trace-and-memory inspection variant achieves 86.67% accuracy, compared with 70.00% for trace-only and 63.33% for summary-only feedback. Under xBench tasks, the evolved memory architecture improves over its original version from 49 to 55 correct answers with DeepSeek V3.2 and from 50 to 53 with Kimi K2.7 Code. On disjoint ALFWorld unseen tasks, success rises from 50.75% to 71.64%. Across archived architecture-snapshot transitions, the median code-change ratio is 4.4%. These results support fine-grained execution evidence as a basis for localized, in-place memory-architecture evolution.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
LLM Agents, Agent Memory, Self-Evolving Agents, Memory Architecture Evolution

Reviews

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

Current agent memory architectures are generally based on coarse-grained feedback focusing on an global representation during an execution. MemScope proposes that such coarse-feedback without localization of failure can make the memory updating weakly constrainted and result large revision despite current architecture only needs a small edit at where it failed. To tackle the limitation, MemScope develops a framework that consider trace, memory state and architecture code and produce constrained edit on the memory architecture. With this framework, authors found the agent with various LLM backbones improved notably with small editing rate, which demonstrated MemScope's advantages in in-place edit while keeping notable improvement compared with trace and summary-only feedback.

Critical strengths
  1. Authors propose a very practical and clearly scoped limitation\textbf{very practical and clearly scoped limitation} in agent memory architecture. The paper distinguishes failure triggered by missing memory content (or experience), failed retrieval, and bad downstream reasoning based on retrieved memory. And inspecting trace, memory, and scripts in provider can allow a more targeted and well-scoped revision on the memory architecture.

  2. The ablation is very informative\textbf{ablation is very informative}. The comparison among summary-only, trace-only, and trace+memory directly demonstrates the importance of diagnostic evidence in agent execution. The overall task accuracy improvement margin from 63.33% to 70.00% to 86.67% well supports the strength of inspecting trajectory as well as current memory state.

  3. The localized edit achieved in MemScope is critical\textbf{localized edit achieved in MemScope is critical} to self-evolving agent. This improvement is solid and allows comprehensive evaluation of failure mode and direct ablations for in-place editing in memory architecture.

Critical weaknesses
  1. Insufficient divergence and and novelty\textbf{Insufficient divergence and and novelty} from closely related precedents. The method distinction from earlier evidence-grounded architecture and harness optimization needs a stronger jusification. MemEvolve [1] already proposes trajectory-based diagnosis of memory failure mode and employ constrained memory architecture evolving. Meta-Harness [2] already introduces source code and execution trace inspection as well as targeted edits or rewrites with larger scope. Therefore, evidence-grounded diagnosis and targeted code revision are established ideas. MemScope's contribution lies specifically at dedicated memory-store inspection and local repair, which is easier to track the editing records. Honestly, these improvement are useful, but the benefit of MemScope is not supported by related prior works in comparison.

  2. The epxeriments do not isolate the benefit of localized repair\textbf{isolate the benefit of localized repair}. The ablation only include various evidence source control but no comparison between local editing and unconstraint redesign. Therefore, it only supports richer evidence source makes the agent perform better, but not demonstrate the benefit of local edits.

  3. The comparison does not separate effects of different models and is confounded\textbf{separate effects of different models and is confounded}. Authors uses many different backbone models for various frameworks. For example, when comparing self-evolving memory architecture, MemEvolve uses Kimi K2 but MemScope uses Kimi K2.7 Code. The improvement thus cannot solely be attributed to memory architecture. Even though DeepSeek V3.2 partially address this concern, most architectures still use heterogeneous model families and versions.

[1] Zhang, G., Ren, H., Zhan, C., Zhou, Z., Wang, J., Zhu, H., ... & Yan, S. (2025). Memevolve: Meta-evolution of agent memory systems. arXiv preprint arXiv:2512.18746.

[2] Lee, Y., Nair, R., Zhang, Q., Lee, K., Khattab, O., & Finn, C. (2026). Meta-harness: End-to-end optimization of model harnesses. arXiv preprint arXiv:2603.28052.

Questions for authors
  1. What precisely distinguishes MemScope from earlier MemEvolve's trajectory-based diagnosis and Meta-harness's trace-grounded code editing? How would you describe it?

  2. The ablation supports richer evidence, but does not show the benefit of localized edits. How does localized edit compare with unrestricted revision when both receive identical traces, memory access, initial status and agent budgets?

  3. How would you interpret the effect of various model families and versions on the task result comparison, given most baselines use different models and also change from Kimi K2 to Kimi K2.7 Code?

1 comment
AuthorsOpenReview ↗

Response to Reviewer GMpL

We thank the reviewer for the positive assessment of soundness and the clear questions.

Q1 / W1. Distinction from MemEvolve and Meta-Harness. On evidence, MemScope is close in spirit to Meta-Harness: both let an agent read raw artifacts (code and execution traces) rather than compressed feedback. MemScope applies this to a running memory system, where the Patch Agent also queries the memory store (record statistics, raw records, a replay of the retrieval decision for the failed query) to locate where a failure arises: in what was stored, in what was retrieved, or in how the retrieved content was used; MemEvolve analyses trajectories for design recommendations and does not inspect the store. The main distinctions lie in what is changed and how a change is accepted.

(1) Scope. Meta-Harness and MemEvolve search over whole programs: each step writes a new candidate (a harness; a complete memory system with its own storage). MemScope repairs the one deployed provider in place with bounded replacements: a recorded update changes a median of 4.4% of the provider's lines (14 transitions), the provider keeps its identity, and an update leaves its memory store in place.

(2) Acceptance. Meta-Harness and MemEvolve score candidates by evaluation, so every update costs benchmark executions: in the default MemEvolve round we ran, 110 of 130 task executions served only to choose among candidates (General Response G2). MemScope installs a repair after static and import checks and relies on Patch History instead: the later outcomes of each patch (recovered failures, regressed successes) are recorded during normal task execution and given to subsequent repairs, which can adjust or undo an earlier change.

Q2 / W2. Localized edits vs. unrestricted revision under identical conditions. Table 5 holds editing fixed and varies evidence. For edit scope, General Response G2 runs localized repair and MemEvolve's unrestricted regeneration under identical conditions.

Q3 / W3. Different backbones. Table 2 contains a same-backbone comparison: with DeepSeek V3.2 and Flash-Searcher, both at pass@1, MemEvolve reports 67.88% on GAIA and MemScope reaches 83.64%. Our claim rests on this comparison. The Kimi K2.7 Code row shows that MemScope works with a second backbone; it is not a controlled comparison with MemEvolve's Kimi K2 result, which is quoted as reported by its authors. We will add a comparison with both systems on the same Kimi model. Other rows are quoted with their authors' backbones, as context.

Reviewer_ZPD5OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies how to improve an existing agent memory implementation through localized code repair. A Patch Agent inspects execution traces, the runtime memory store, and provider code, then applies bounded edits that preserve provider identity and memory compatibility. The experiments compare diagnostic interfaces on GAIA and evaluate evolved DynamicCheatsheet providers on xBench and ALFWorld. The most useful evidence is the matched-start xBench comparison and the disjoint ALFWorld evaluation, where success improves from 34/67 to 48/67. The central claim is that fine-grained execution evidence supports useful, small changes to memory-management code.

Critical strengths
  1. The repair interface addresses a practical limitation of memory evolution: the same task failure can come from missing experience, retrieval filtering, or downstream reasoning. Inspecting traces together with the store and code gives the updater a concrete basis for choosing an edit or abstaining. The recorded no-patch decision and contrasting retrieval repairs make this contribution more concrete than a generic reflection loop.

  2. The matched-start experiments provide useful evidence beyond the aggregate leaderboard. On xBench, the evolved provider recovers more failures than it introduces regressions under both backbones. The ALFWorld comparison uses disjoint unseen tasks and a common memory-collection sequence, supporting transfer of an evolved provider beyond its development tasks.

Critical weaknesses
  1. The experiments do not isolate the value of localized repair from the value of richer diagnostic evidence. Table 5 changes the information available to the Patch Agent, but does not compare bounded editing with complete-provider generation given the same traces, memory access, starting code, and evolution budget. Table 2 also mixes backbones and external baseline results; even the same-backbone comparison does not document a matched evolution budget. This leaves the main methodological advantage over architecture-level search unresolved. Appendix B.5 explains the stages qualitatively, but changed-line counts are not a measurement of total evolution cost.

  2. The strongest diagnostic result comes from a small 30-task comparison, and the separation between tasks used for repeated evolution, repair selection, and reporting that ablation is unclear. The matched xBench gains are six and three additional successes out of 70, and the ALFWorld advantage over ALMA is three out of 67; no uncertainty over evolution runs or task order is reported. I find the original-versus-evolved results encouraging, but the evidence is not yet strong enough to establish a reliable advantage for this particular evolution procedure. These identification and evaluation issues lead me to lean toward rejection.

Questions for authors
  1. Please specify the exact development and evaluation task IDs for GAIA, including Table 5, when code is frozen, and whether any reported tasks or their correctness feedback are revisited during provider evolution.

  2. With the same initial provider, diagnostic tools, and total evolution budget, how does localized editing compare with complete-provider regeneration? Please include diagnosis, patch generation, validation, and benchmark execution in the cost accounting.

  3. How stable are the matched xBench and ALFWorld gains across independent evolution runs or task orders? Paired outcome uncertainty would help establish which conclusions the current sample sizes support.

1 comment
AuthorsOpenReview ↗

Response to Reviewer ZPD5

We thank the reviewer for the precise questions.

Q1. Exact task IDs and when code is frozen. Development set: the first 30 tasks of the GAIA validation metadata file, in file order; held-out set: the remaining 135. Table 5 is computed on the development tasks, which are revisited over five episodes with correctness feedback. Held-out tasks are never seen during evolution. Provider code is fixed after episode five, before any held-out task runs; the memory bank keeps updating during evaluation, following MemEvolve's sequential online protocol. Results per group are in General Response G1.

Q2 / W1. Localized editing vs. complete-provider regeneration, with cost accounting. The table gives the budget for one installed update. Both columns: the same 30 xBench development tasks, initial provider (391 lines, 3,233 tokens) and backbone (DeepSeek V3.2). A task execution is one run of one task; both procedures revisit the 30 tasks several times. MemScope: the evolution run of the submission, 30 tasks × 5 episodes = 150 task executions, 3 installed updates (values are totals divided by 3). MemEvolve: one default round run for this response, with 20 executions of the incumbent for analysis, 80 for the incumbent and three candidates on a 20-task batch, and 30 for two finalists on 15 tasks: 130 executions, 1 installed update.

MemScopeMemEvolve
Budget per installed update
Task executions50130
of which run only to choose among candidate systems0110
Input tokens of task executions25.6M47.7M
Cost of task executions (USD)5.469.49
Diagnosis and code generationPatch Agent: 25 calls, 0.9M input tokens, 0.16 USD3 analysis runs (43 agent steps) + 3 generation calls: ≈ 1.1M input tokens, ≈ 0.3 USD
Total cost (USD)5.62≈ 9.8
What the update changes
Code written1–5 lines, 9–56 tokens608 lines, 4,983 tokens (entire provider)
Accumulated memory storeretainednot carried over (new system starts empty)

Notes. Costs are logged tokens at public API prices (USD per 1M tokens: 0.26 input, 0.13 cached input, 0.374 output), excluding search-API and judge calls. Accuracy under identical conditions is in General Response G2. For Table 2, see our response to Reviewer GMpL (Q3).

W2 / Q3. Stability across runs. The submission reports one evolution run per setting. Its evidence on robustness is across settings rather than seeds: two backbones on GAIA, both with held-out accuracy matching development accuracy (General Response G1), and three benchmarks with different task types and executors. Variance over repeated runs is not reported in the submission.

Reviewer_HZdJOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

Existing agent frameworks rely on the definition and the usage of memories. Different from recent self-evolving-based methods that update the memory based on coarse-grained signals, this work is designed to improve an agent’s memory system through targeted edits to its executable memory provider, which is at a more fine-grained level. The proposed MemScope method utilizes a tool-using patch agent to inspect these three things: raw execution traces, runtime memory state and code which are then used to locate the things needed to be edited. Experimental results across multiple datasets validate the effectiveness of the proposed MemScope method.

Critical strengths

This submission has the following Critical Strengths:

  • The motivation of this work is clear: updating the memory based on outcome-level feedback might result in sub-optimal edits while fine-grained signals could guide better edits.
  • The proposed MemScope method is easy to follow. And this design of some modules makes sense. For example, combining inspection with explicit patch manifests enhances the transparency and auditability of proposed interventions.
  • The results on multiple datasets look promising which show its effectiveness in editing agent's memory.
Critical weaknesses

This submission has the following Critical Weaknesses:

  • I have some doubts about some experimental settings: Section 4.1 Experimental Setup writes that evolution on 30 development tasks followed by evaluation on the full validation set. However, it is not clear how these two evaluation sets are disjoint. Consequently, the result cannot confidently be interpreted as performance on entirely unseen tasks. Besides, Flash-Searcher in this work employs GPT-4o for visual inspection and GPT-4o-mini for answer evaluation on GAIA and xBench. This setup raises concerns about potential evaluation bias and the fairness of comparisons.
  • Improved diagnostic evidence and a restricted editing strategy constitute two distinct interventions. However, current results do not show their respective contributions.
Questions for authors

I have the following questions and suggestions:

  • Could the authors explain my concerns in weakness 1?
  • It would be better to conduct a controlled ablation study to disentangle of effects of improved evidence and restricted editing.
  • Would it be possible to add some full traces in the case study?
  • Some minor suggestions about words and format:
    • It would be better to first use Large Language Models to define LLMs. For example, it would be better to change the sentence at the beginning of Introduction 'An LLM agent' to 'A large language model (LLM) agent.
    • The table 5 is above table 4. It would be better to adjust the placement.

I would be willing to reconsider my score if the authors could address the concerns raised above.

3 comments
AuthorsOpenReview ↗

Response to Reviewer HZdJ

We thank the reviewer for the constructive comments and for the willingness to reconsider the score.

W1a. Are development and evaluation tasks disjoint? Yes. Evolution uses only the first 30 validation tasks; the other 135 are never used for triggering, diagnosis or repair. The 165-task number pools the two groups. Reported separately, MemScope obtains 83.33% on the 30 development tasks and 83.70% on the 135 held-out tasks with DeepSeek V3.2, and 80.00% and 77.78% with Kimi K2.7 Code (General Response G1). Held-out accuracy matches development accuracy, so the result reflects performance on tasks that evolution never used.

W1b. GPT-4o and GPT-4o-mini. This is the standard configuration of Flash-Searcher and MemEvolve, which we keep unchanged so that our numbers are directly comparable with theirs. GPT-4o is called only by the executor's visual-inspection tool on tasks with image inputs. GPT-4o-mini only compares the final answer with the reference answer. It is a different model from the executor backbones (DeepSeek V3.2, Kimi K2.7 Code), so no model grades its own output, and every system we run is judged by the same model.

W2. Disentangling evidence from restricted editing. Table 5 varies the evidence while holding the editing strategy fixed: Summary-only, Trace-only and Trace + Memory Inspection all use bounded in-place edits and differ only in what the Patch Agent can inspect (63.33%, 70.00% and 86.67% on the 30 development tasks). This isolates the contribution of the evidence. For the editing restriction, General Response G2 runs localized repair and MemEvolve's whole-provider regeneration from the same initial provider under identical conditions: On 27 development tasks, localized repair achieved 74.07% accuracy versus 59.26% for regeneration, retained memory, and used fewer lines (1–5 vs. 608), fewer validation executions (0 vs. 110), and less money ($5.62 vs. ≈$9.80) per update.

Minor. Thank you for the two presentation points (defining "LLM" at first use and the order of Tables 4 and 5).

Dear Authors,

Thanks for the rebuttal. I noticed that Table 5. I am curious about why MemScope achieves lower accuracy than Inspection.

Besides, as mentioned by reviewer GMpL about novelty, Meta-Harness is an ealier work and some of it core ideas are quite simiar. However, it is only simply discussed in the submission. And would it be possible to include the results of Meta-Harness?

Thank you very much for the follow-up!

Table 5. The two rows differ by one task, which we do not read as a difference. History is not meant to raise accuracy within one pass; it replaces validation runs: a repair is installed after static and import checks, and its later outcomes are recorded during normal task execution and given to subsequent repairs (Section 4.4, Appendix B.5). This removes the per-update evaluation that search-based methods pay: 0 vs. 110 validation task executions against MemEvolve (General Response G2).

Meta-Harness. What the two share is one design choice: the agent reads raw artifacts rather than summaries. What is done with that evidence differs. Meta-Harness, like MemEvolve, is a search method: each iteration writes new candidate programs and benchmarks every candidate. MemScope is a repair method: it edits a few lines of a deployed memory provider in place and installs the edit without a benchmark run. Meta-Harness reports no results on GAIA, xBench or ALFWorld, and adapting it to our memory providers is not feasible in the time left; MemEvolve, the closest search-based method in our setting, is the one we compare with. We will expand the discussion of Meta-Harness in the paper.

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

This paper proposes MemScope, a framework for evolving agent memory architectures through localized code repair. A Patch Agent analyzes execution traces, memory states, and provider code to identify failures and apply targeted modifications. Experiments on GAIA, xBench, and ALFWorld demonstrate performance improvements, while ablation studies highlight the benefits of fine grained diagnostic evidence.

Critical strengths

The paper presents a well motivated framework for localized memory architecture repair, supported by promising results across multiple benchmarks and ablation studies.

Critical weaknesses

Weaknesses

W1. Unreliable repair triggering and failure attribution.
The repair trigger relies on accuracy drops over small task segments, which may reflect task difficulty or randomness rather than memory defects. Moreover, the Patch Agent lacks systematic validation of its ability to distinguish storage, retrieval, and executor-related failures.

W2. Dependence on Patch Agent capability.
The framework heavily relies on the Patch Agent's reasoning and coding abilities, but its model configuration and robustness to weaker models are insufficiently explored.

W3. Insufficient patch level validation.
The paper shows improvements between the original and final providers but lacks systematic evaluation of individual patches, including improvement and regression rates.

W4. Limited cross domain generalization.
It remains unclear whether a provider evolved on one task distribution can transfer to another without further modification.

W5. Presentation issues.
Page 5 contains excessive whitespace, which affects the visual continuity of the Method section.

Questions for authors

My main questions and concerns are outlined in the Weaknesses section. Please refer to that section for details.

1 comment
AuthorsOpenReview ↗

Response to Reviewer pKju

We thank the reviewer for the detailed comments and respond to each point below.

W1. Trigger reliability and failure attribution. The trigger is a lightweight signal for when to inspect the memory system; it is not meant to detect memory defects by itself. It fires when a segment's accuracy falls more than 0.05 below the best accuracy of previous episodes on the same task window, using accuracy that execution already produces. A drop that comes from harder tasks is a useful signal too: those are the tasks on which the current memory helps least, so they are where the memory system has the most to adapt to. The design favours efficiency: the evolution budget goes to task execution, and the question of what actually went wrong is left to the diagnosis step.

Deciding whether the memory system is at fault is the Patch Agent's job. It inspects the failed traces, the memory store and the provider code, and it can decline to edit: one xBench proposal in the submission was withdrawn by the Patch Agent itself (Appendix B.2 shows the recorded no-patch decision). In further evolution runs on GAIA and xBench it abstained in four inspections, for example with "failures are execution-level; no memory defect". When it does edit, its diagnoses are not limited to one category: in those runs, 14 installed repairs were attributed to retrieval, 3 to storage and 1 to the executor. Each installed repair comes with a manifest that records the root cause, the evidence consulted, the expected effect and the risk.

W2. Dependence on Patch Agent capability. The Patch Agent is not a stronger model than the agent it repairs: in every run it uses the same backbone as the Agent Executor, and it produced installed repairs with both backbones. The method relies on the evidence interface rather than on model strength: the Patch Agent works through read-only tools over traces, the memory store and the provider code, makes bounded exact replacements, and every update passes static and import checks before it is installed.

W3. Patch-level validation. Patch History records, for every installed patch, the later outcomes of the tasks in the segment that triggered it: how many previously failed tasks are answered correctly when revisited (recovered), and how many previously correct tasks fail (regressed). For the runs in the submission:

RunProposalsInstalledRecovered / revisits of failed tasksRegressed / revisits of correct tasks
GAIA, DeepSeek V3.2113 / 40 / 7
GAIA, Kimi K2.7 Code115 / 121 / 9
xBench, DeepSeek V3.2335 / 191 / 9
xBench, Kimi K2.7 Code213 / 51 / 2
ALFWorld, DeepSeek V3.25513 / 506 / 22
Total121129 / 90 (32%)9 / 49 (18%)

Patches are installed after static and import checks, without a performance gate, so these rates describe what happened after each installation. They are also the records that later repairs consult: in the xBench DeepSeek run, a later repair read the recovery and regression outcomes of an earlier threshold change, recognised over-filtering and adjusted the threshold (Section 4.4, "How Patch History informs subsequent repair").

W4. Cross-domain generalization. The submission applies the same repair procedure, without modification, to three domains that differ in task type and in executor: open web question answering (GAIA), deep-search tasks (xBench), and embodied household tasks with a text-action executor (ALFWorld). ALFWorld is the closest analogue to the transfer setting the reviewer describes: the same kind of provider used for web tasks is repaired on embodied tasks, and success on the unseen split, which is disjoint from the evolution tasks, improves from 50.75% to 71.64%. Freezing a provider evolved on one benchmark and evaluating it on a different benchmark is a complementary experiment that we leave to future work.

W5. Presentation. Thank you for pointing out the whitespace on page 5; it is fixed in the revised PDF.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers

We thank all reviewers. Two questions shared across the reviews are answered here.

G1. Development and held-out tasks, reported separately. Evolution uses only the first 30 tasks of the GAIA validation set (the development tasks). The remaining 135 tasks are never used for triggering, diagnosis or repair. The 165-task accuracy in the submission pools the two groups; reported separately, the same runs give:

BackboneDevelopment (30)Held-out (135)All (165)
DeepSeek V3.225 (83.33%)113 (83.70%)138 (83.64%)
Kimi K2.7 Code24 (80.00%)105 (77.78%)129 (78.18%)

Held-out accuracy matches development accuracy for both backbones. Provider code is fixed after the fifth episode; as in MemEvolve, evaluation is sequential and online, starting from the memory bank left by evolution.

G2. Evidence vs. edit scope. These are two factors. Table 5 isolates the first: all three settings use the same bounded in-place edits and differ only in what the Patch Agent can inspect (Summary-only 63.33%, Trace-only 70.00%, Trace + Memory Inspection 86.67% on the 30 development tasks). For the second, we ran both procedures for this response under identical conditions: the same initial provider, the same 30 xBench development tasks (3 probes + 27 execution tasks), the same executor, backbone and judge. MemScope uses the settings of the submission (five episodes), repeated in three independent runs; MemEvolve is one round of its released pipeline under the default configuration.

MethodAccuracy (%), 27 execution tasksUpdates installedCode written per updateMemory store after an updateTask executions to accept an updateCost per update (USD)
MemEvolve (regeneration), one default round59.26 (16/27)1608 lines, 4,983 tokensnot carried over110≈ 9.8
MemScope (localized repair)74.07 (20/27)31–5 lines, 9–56 tokensretained05.62

Accuracy on the development tasks is comparable (the difference is within the spread of the three runs); the localized procedure reaches it without validation runs, at under a third of the cost per update, and without discarding the memory store. The full accounting is in our response to Reviewer ZPD5 (Q2).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.