Memory Transfer Learning: How Memories are Transferred Across Domains in Coding Agents 

Report GitHub Issue

 × 

 Title: 

Content selection saved. Describe the issue below:

 Description: 

 Submit without GitHub 
 Submit in GitHub 

 Back to arXiv 

 Why HTML? 

 Report Issue 

 Back to Abstract 

 Download PDF 

 Abstract 

 1 Introduction 

 2 Related Work 

 2.1 Coding Agents 

 2.2 Memory-based Self-Evolving Agents 

 2.3 Transfer Learning 

 3 Memory Transfer Learning 

 3.1 Method 

 3.1.1 Memory Generation 

 3.1.2 Memory Retrieval 

 3.2 Experimental Details 

 3.2.1 Datasets 

 3.2.2 Additional Details 

 4 Experimental Results and Analysis 

 4.1 Overall Performance of MTL 

 4.1.1 Main Results 

 4.1.2 Comparison with Self-Evolving Approaches 

 4.2 Mechanism of Memory Transfer Learning 

 4.2.1 How Does Memory Transfer Learning Benefit the Agents? 

 4.2.2 Case Study: Zero-shot vs. MTL 

 4.3 Impact of Memory Abstraction 

 4.3.1 Abstraction Level of Four Memory Types 

 4.3.2 Correlation between Abstraction and Transfer Effectiveness 

 4.3.3 Isolating the Effect of Memory Abstraction 

 4.3.4 Case Study: Trajectory vs. Insight 

 4.4 Further Analysis and Ablations 

 4.4.1 Negative Transfer in MTL 

 4.4.2 Case Study: Negative Memory Transfer 

 4.4.3 Impact of the Memory Pool Size 

 4.4.4 Cross-model Memory Transfer Learning 

 4.4.5 Analysis on Retrieval Methods 

 5 Conclusion 

 References 

 A Average Pass@1 Results 

 B Case Study on Negative Transfer 

 C Formal Modeling of Abstraction 

 D Memory Benefit Category 

 E Memory Generation Prompts 

 License: CC BY 4.0

arXiv:2604.14004v1 [cs.AI] 15 Apr 2026

Memory Transfer Learning: 

How Memories are Transferred Across Domains in Coding Agents

 Kangsan Kim

 Minki Kang

 Taeil Kim

 Yanlai Yang

 Mengye Ren

 Sung Ju Hwang

Abstract

Memory-based self-evolution has emerged as a promising paradigm for coding agents. However, existing approaches typically restrict memory utilization to homogeneous task domains, failing to leverage the shared infrastructural foundations, such as runtime environments and programming languages, that exist across diverse real-world coding problems.
To address this limitation, we investigate Memory Transfer Learning (MTL) by harnessing a unified memory pool from heterogeneous domains. We evaluate performance across 6 coding benchmarks using four memory representations, ranging from concrete traces to abstract insights.
Our experiments demonstrate that cross-domain memory improves average performance by 3.7%, primarily by transferring meta-knowledge, such as validation routines, rather than task-specific code.
Importantly, we find that abstraction dictates transferability; high-level insights generalize well, whereas low-level traces often induce negative transfer due to excessive specificity.
Furthermore, we show that transfer effectiveness scales with the size of the memory pool, and memory can be transferred even between different models.
Our work establishes empirical design principles for expanding memory utilization beyond single-domain silos.

Machine Learning, ICML

 1 KAIST
  2 New York University
  3 DeepAuto.ai

 https://memorytransfer.github.io/ 

 \icml@noticeprintedtrue † † footnotetext: † \dagger Equal advising. Correspondence to: kksan07@kaist.ac.kr 

 Figure 1 : Conceptual overview of Memory Transfer Learning. Unlike (A) memory-less agents or (B) single-domain self-evolving agents, (C) our approach utilizes a shared memory pool from heterogeneous coding tasks.
(D) In the evaluation on diverse benchmarks, MTL outperforms a self-evolving approach.

 1 Introduction

As performance gains from scaling training data in language models begin to plateau, self-evolution, which leverages prior inference outcomes to enhance future performance without additional supervision, has emerged as a promising paradigm for advancing model capabilities in agents  (Gao et al. , 2025 ; Fang et al. , 2025a ) .
Memory plays a central role in self-evolving agents by enabling the extraction of reusable workflows and transferable insights from past inferences and their application to subsequent tasks  (Zheng et al. , 2024 ; Wang et al. , 2024c ; Ouyang et al. , 2025 ) .
In coding agents, the memory is instantiated as code snippets, experiential knowledge including planning and debugging traces, or general programming principles  (Yang et al. , 2024 ) .
Leveraging this knowledge allows agents to reference successful solution patterns in similar tasks, thereby reducing reasoning overhead, while also avoiding unnecessary failure actions in long-horizon code editing through adherence to accumulated procedural and strategic guidance, such as small-step modification heuristics and verification routines.

While memory-augmented coding agents have shown promise  (Ouyang et al. , 2025 ) , existing approaches mostly restrict memory generation and retrieval to the same domain, typically within the same benchmark as illustrated in  Figure 1 (B).
However, in real-world scenarios, coding agents must handle a wide spectrum of programming problems, ranging from repository-level software engineering tasks  (Jimenez et al. , 2024 ) and machine learning model development  (Nathani et al. , 2025 ; Seo et al. , 2025 ) to function-level competitive coding  (Jain et al. , 2024 ) .
Despite this diversity, these tasks share a common underlying infrastructure, including runtime environments (e.g., Linux shells), programming languages, and cross-file dependency stacks.
Current approaches that restrict memory utilization to a single domain fail to leverage this shared foundation, thereby preventing agents from exploiting a substantially richer memory pool derived from heterogeneous domains.
We posit that such cross-domain memories can provide valuable guidance, often more effective than those extracted solely from the same domain, by offering transferable knowledge applicable to new problems ( Figure 1 (C)).

Some prior works have explored the construction of a large unified memory pool spanning multiple task types, providing initial evidence that general reasoning experiences can support software engineering tasks  (Tang et al. , 2025 ) .
However, this line of works leaves several key research questions for a practical deployment unresolved, as in  Figure 1 :

 RQ1. Does memory from heterogeneous domains improve the performance of coding agents? 

 RQ2. Why do transferred memories yield benefits across different domains? 

 RQ3. Which factors in memory transfer learning most influence transfer effectiveness? 

To address these open questions, we conduct a systematic investigation of Memory Transfer Learning across heterogeneous domains in coding agents and derive several core findings on its mechanisms and effects.
We first generate memories for each task using four different formats commonly adopted in prior works: Trajectory  (Zheng et al. , 2024 ) , Workflow  (Wang et al. , 2024c ) , Summary  (Shinn et al. , 2023 ) , and Insight  (Ouyang et al. , 2025 ) , as illustrated in Figure   2 .
We then evaluate coding agent performance in zero-shot setting and under Memory Transfer Learning.
The results demonstrate that Memory Transfer Learning can provide effective and transferable knowledge, improving 3.7% of average scores of 6 coding benchmarks. 

Our analysis yields three core findings into the mechanism of memory transfer.
 First, cross-domain significantly improve the performance of coding agents. Although existing self-evolving methods often overlook out-of-domain memories, our results suggest that effective memory utilization should incorporate all past experiences, including those from different domains, to enhance agent performance, as shown in Figure 1 (D).
 Second, the primary transferable value lies in meta-knowledge. 
Through qualitative analysis, we find that cross-task benefits stem not from task-specific code content but from operational know-how, such as preventing execution failures under environment constraints and task-solving routines that prioritize structural and interface inspection followed by strict validation procedures.
 Third, abstraction dictates transferability. 
By quantifying the abstraction level of each memory format, we discover a positive correlation between high-level abstraction and transfer effectiveness.
Highly abstract memories, such as Insights, become task-agnostic and generalizable.
In contrast, low-abstraction memories like Trajectories retain excessive task-specific details that can distract the agent, confirming that raw execution traces are less suitable for cross-task transfer.
Furthermore, we provide additional insights into Memory Transfer Learning, including why negative transfer occurs, how the performance gain of MTL scales with a larger memory pool and more domains, and the potential for transferring memories across different models.

In conclusion, this work presents a first holistic investigation of Memory Transfer Learning.
Importantly, through extensive evaluation on six coding benchmarks, we show that existing agents’ memory usage methods, which focus on a homogeneous domain, are limited, and that there is significant room for improvement by leveraging memories from heterogeneous domains.
We hope this study expands the scope of memory utilization beyond single-domain settings and stimulates further research on how to effectively leverage memory in self-evolving agents, ultimately leading to more capable coding agents.

 Figure 2 : Illustrative examples of four memory formats. We utilize Trajectory, Workflow, Summary, and Insight formats to analyze how different levels of information abstraction affect cross-task transferability. 

 2 Related Work

 2.1 Coding Agents

As LLM have demonstrated strong capabilities in code generation  (Roziere et al. , 2023 ; Hui et al. , 2024 ; Zhu et al. , 2024 ) , researchers have developed LLM-based coding agents that interact with programming environments such as bash shells  (Team, 2026 ; Wang et al. , 2024a ) through diverse systematic designs, and have evaluated them across a wide range of coding tasks. At the early stage of coding agents, they target function-level code generation tasks  (Chou et al. , 2025 ; Jain et al. , 2024 ; Xia et al. , 2024 ) in a single file. AlphaCodium  (Ridnik et al. , 2024 ) proposed a flow engineering in code generation which iteratively run reasoning, generation, ranking, and debugging. LDB  (Zhong et al. , 2024 ) introduced a novel debugging framework with language models that leverage runtime execution information for function-level code generation. Beyond a single file level editing, CodeAgent  (Zhang et al. , 2024 ) , RepoAgent  (Luo et al. , 2024 ) , RLCoder  (Wang et al. , 2024b ) address repository-level code modification tasks  (Jimenez et al. , 2024 ; Merrill et al. , 2026 ) . Furthermore, code agents targeting domain-specific tasks, such as Paper2Code  (Seo et al. , 2025 ) for code generation for ML paper replication tasks and BixbBench  (Mitchener et al. , 2025 ) for computational biology related tasks.

 2.2 Memory-based Self-Evolving Agents

Self-evolving agents  (Cai et al. , 2025 ) leverage past experiences by reusing successful solution patterns in similar tasks and avoiding previously encountered erroneous actions. To manage these experiences effectively, existing memory-based self-evolving agents  (Yeo et al. , 2025b ; Kim et al. , 2026 ) primarily focus on mechanisms for memory generation and retrieval during interactions with environments.  (Fang et al. , 2025b ; Chen et al. , 2025 ) AWM  (Wang et al. , 2024c ) proposed memory utilization through the collection of common workflows in web agents, while ReasoningBank  (Ouyang et al. , 2025 ) extracts helpful insights from trajectories via test-time scaling. Dynamic Cheatsheet  (Suzgun et al. , 2025 ) constructs evolving memories that encode reusable strategies and insights, and ReMe  (Cao et al. , 2025 ) presents a holistic framework from memory generation to retrieval and memory refinement. MemEvolve  (Zhang et al. , 2025 ) further introduces system-level evolution through meta-evolution in memory agents. However, existing memory-based self-evolving agents are primarily evaluated within the same benchmark or task domain, overlooking the potential value of memories generated from other task domains that may be highly beneficial to agent performance.

 2.3 Transfer Learning

Transfer Learning  (Zhuang et al. , 2020 ) has been extensively studied as the reuse of knowledge acquired in a source domain to improve performance in a target domain. Traditional approaches mainly rely on parametric adaptation through model updates  (Howard and Ruder, 2018 ; Houlsby et al. , 2019 ) . With the emergence of LLMs demonstrating strong generalization capabilities, recent work has increasingly explored non-parametric knowledge transfer mechanisms. In-context learning  (Dong et al. , 2024 ; Min et al. , 2022 ; Kim et al. , 2025 ) , as a representative paradigm, shows that LLMs can reuse knowledge provided in the context at inference time. In the agent setting, knowledge is instead generated by the model itself in the form of memory and transferred across tasks. AgentKB  (Tang et al. , 2025 ) introduces a framework for managing and leveraging a unified memory pool across multiple task domains. However, it does not provide a deeper analysis of the underlying mechanisms of memory transfer, including which forms of knowledge are transferable and how transfer-oriented memories should be generated in contrast to in-domain knowledge. Moreover, prior work typically constructs unified memory spaces across heterogeneous environments, such as general reasoning, web interaction, and coding, thereby missing the opportunity to exploit coding-specific shared principles that are unique to programming tasks.

 3 Memory Transfer Learning

We introduce Memory Transfer Learning, which leverages memories generated from heterogeneous tasks with target tasks in coding environments.
In the following sections, we first describe how we generate and retrieve memory, and which benchmarks we use to evaluate the performance.

 3.1 Method

To investigate the impact of memory on the agent, we design a simple memory-based coding agent with a two-stage memory utilization process: memory generation and memory retrieval. Memory generation is performed offline with results saved prior to memory transfer learning, while memory retrieval is executed for each query during the inference.

 3.1.1 Memory Generation

Before memory generation, we first run inference the agent across all benchmarks and gather the resulting trajectories as sources for memory construction. Inference results consist of the given task t t and multiple steps of reasoning r r , action a a , observation o o , thus the full inference history H H is denoted as H = ( t , [ ( r 1 , a 1 , o 1 ) , … , ( r n , a n , o n ) ] ) H=(t,[(r_{1},a_{1},o_{1}),\ldots,(r_{n},a_{n},o_{n})]) with task t t . Based on these results, we construct four types of memory representations, defined by categorizing memory schemes from existing self-evolving agents into representative formats. We employ LLM-based judge to assess whether each inference attempt is successful or failed, and use different memory generation prompts for each case, following previous work  (Ouyang et al. , 2025 ; Cao et al. , 2025 ) . Detailed descriptions for each memory format is as follows. The structure illustration for each format is shown in  Figure 2 , and prompts used in memory generation are in Appendix E .

 Trajectory In this memory representation, we concatenate all commands and codes called by the agent a i a_{i} and their execution results o i o_{i} from H H without reasoning sentences r i r_{i} , and save it with the source task t t . Trajectory memory M T M_{T} can defined as M T = ( t , [ ( a 1 , o 1 ) , … , ( a n , o n ) ] ) M_{T}=(t,[(a_{1},o_{1}),\ldots,(a_{n},o_{n})]) . This contains detailed information of task solving experience even with failed steps. Also the agent can implicitly estimate the expected execution results of certain actions by referring observations of similar commands in this memory.

 Workflow In order to focus only on meaningful code snippets in the entire trajectory, this memory representation is generated by extracting reusable workflow from the trajectory.  (Wang et al. , 2024c ) Specifically, we provide H H to LLM and ask to generate a goal of workflow g g and extract meaningful actions a a to achieve the goal. Therefore, workflow memory M W M_{W} denotes as M W = ( g , [ a i , a j , … , a k ] ) M_{W}=(g,[a_{i},a_{j},\ldots,a_{k}]) . By restoring a subset of the action and observation history, Workflow is much shorter than Trajectory which leads to less danger of distractions from unrelated information.

 Summary One key principle in leveraging memory is to follow the successful actions and reflect failures from previous inference, however, raw code commands and observations do not provide explicit information about analysis why the agent succeeds or fails and the findings from the history. Thus, for Summary memory, we prompt LLM to summarize the task, environment, actions, results, and analysis on why this inference succeeds or fails from the given trajectory. In detail, LLM generates a summary of task s t s_{t} and one paragraph of experience summary s e s_{e} from the trajectory, which is represented as M S = ( s t , s e ) M_{S}=(s_{t},s_{e}) for Summary memory M S M_{S} .

 Insight We can reasonably expect that memory should be generalized to be easily adapted to different tasks, and as the most general memory representation, we employ the Insight memory format. Following the memory design ReasoningBank  (Ouyang et al. , 2025 ) , Insight M I M_{I} consist of three parts: title i t i_{t} , description i d i_{d} , content i c i_{c} , represented as M I = ( i t , i d , i c ) M_{I}=(i_{t},i_{d},i_{c}) . In the content of this memory item, we prompt LLM to write insights on why this task is successfully accomplished without mentioning specific files or details. Additionally, we explicitly instruct LLM to generate generalizable insights for future similar tasks.

 Table 1 : Evaluation results of Memory Transfer Learning. We report Pass@3 scores across multiple benchmarks. MTL consistently improves performance over the zero-shot baseline across models. Among memory types, Insight achieves the highest average performance. 

 LiveCodeBenchv6 
 Aider-Polyglot 
 SWEBench-Verified 
 TerminalBench2 
 ReplicationBench 
 MLGym-Bench 
 Avg. 

 GPT-5-mini 

 Zero-shot 
 0.910 
 0.470 
 0.730 
 0.315 
 0.111 
 0.667 
 0.523 

 MTL (T) 
 0.940 
 0.490 
 0.770 
 0.270 
 0.122 
 0.583 
 0.534 

 MTL (W) 
 0.920 
 0.470 
 0.770 
 0.348 
 0.111 
 0.583 
 0.538 

 MTL (S) 
 0.930 
 0.460 
 0.760 
 0.371 
 0.133 
 0.667 
 0.546 

 MTL (I) 
 0.930 
 0.470 
 0.770 
 0.360 
 0.189 
 0.750 
 0.560 

 Δ \Delta 
 +2.0% 
 0.0% 
 +4.0% 
 +4.5% 
 +7.8% 
 +8.3% 
 +3.7% 

 DeepSeek V3.2 

 Zero-shot 
 0.930 
 0.590 
 0.530 
 0.337 
 0.267 
 0.583 
 0.542 

 MTL (I) 
 0.940 
 0.580 
 0.590 
 0.393 
 0.278 
 0.667 
 0.568 

 Δ \Delta 
 +1.0% 
 -1.0% 
 +6.0% 
 +5.6% 
 +1.1% 
 +8.3% 
 +2.6% 

 Qwen3-Coder-480B-A35B-Instruct 

 Zero-shot 
 0.800 
 0.460 
 0.590 
 0.292 
 0.211 
 0.583 
 0.483 

 MTL (I) 
 0.810 
 0.480 
 0.620 
 0.326 
 0.211 
 0.583 
 0.501 

 Δ \Delta 
 +1.0% 
 +2.0% 
 +3.0% 
 +3.4% 
 0.0% 
 0.0% 
 +1.8% 

 3.1.2 Memory Retrieval

 Memory Pool Construction After finishing memory generation for all benchmarks, we construct the heterogeneous-domain memory pool to experiment memory transfer learning.
We gather memories from all benchmarks except the testing benchmark for each memory format. In formal notation, the memory pool 𝒫 \mathcal{P} used for memory transfer learning in evaluating benchmark B i B_{i} with memory type τ \tau is 𝒫 τ ​ ( B i ) = { M τ ( k ) ∣ t ( k )

... [OUTPUT TRUNCATED - 17656 chars omitted out of 67656 total] ...

eria, resulting in missed specifications and silent failures.

 • 

 Misapplied best-practice transfer : Successful patterns are sometimes transferred indiscriminately, overriding task-specific semantics. This causes procedural over-engineering and rigid adherence to familiar workflows that violate new task requirements.

We find that major three reasons of negative transfer are caused by wrong memory retrieval and failed adaptation of the retrieved memory to the new task. These demonstrate that we can avoid performance degradation by designing advanced memory retrieval methods that retrieve truly helpful memories not semantically relevant items, and employ better memory adaptation methods, such as memory rewriting module  (Cao et al. , 2025 ) .

 4.4.2 Case Study: Negative Memory Transfer

While Memory Transfer Learning generally improves performance, it also introduces the risk of negative transfer through blind imitation or misinterpretation of transferred knowledge.
As illustrated in Appendix B , we identify two primary failure modes that hinder effective transfer. First, the misapplication of technical patterns occurs when an agent incorrectly projects language-specific logic ( e.g., R-language file-writing routines) onto an incompatible environment like C++, leading to structural failures. Second, semantic distortion occurs when a strategic insight intended for rigorous validation is misinterpreted as a justification for suboptimal shortcuts.

 Finding 4. Negative memory transfer mainly arises from domain-mismatched misleading anchors, false validation signals, and misapplied procedural reuse. 

 4.4.3 Impact of the Memory Pool Size

To investigate how Memory Transfer Learning scales with the number of memory in the candidate pool, we evaluate Memory Transfer Learning with varying memory pool sizes across three benchmarks. Specifically, we randomly sample memories from the full cross-domain memory pool at ratios of 1/4, 2/4, and 3/4 of the original size. As shown in Figure 6 , the average performance consistently improves as the number of memories increases, indicating that larger memory pools lead to better performance. This trend arises because a larger pool increases the likelihood of retrieving relevant memories for the target task.

Furthermore, we evaluate our method using varying numbers of memory source domains (benchmarks) to examine how performance scales. We find that the average performance gain generally increases as the number of source domains grows. In particular, using 9 domains yields the best overall performance. These results demonstrate that the effectiveness of Memory Transfer Learning benefits from incorporating a larger number of domains. This trend suggests that a broader set of domains enhances the diversity of transferable knowledge, thereby increasing the likelihood of retrieving useful meta-knowledge for target tasks.

 Finding 5. The effectiveness of Memory Transfer Learning scales with the size of the memory pool and the number of domains. 

 Figure 6 : Memory Scaling Larger memory pools and more domains lead to better performance through increased diversity. 

 4.4.4 Cross-model Memory Transfer Learning

To validate whether memories are transferable across models, we evaluate agent performance under Memory Transfer Learning using memories generated by different models. We hypothesize that if Memory Transfer Learning mainly benefits from meta-knowledge, then memories from different models should also be effective, as such meta-knowledge is not model-specific but instead relates to the testing environment and general coding guidelines. The results, shown in Table 6 , consistently outperform the zeroshot baseline even when using memories from other models. In particular, cross-model memory transfer is effective in both directions, from a stronger model (GPT-5-mini) to weaker models (Qwen3-Coder and DeepSeek V3.2), and vice versa. These findings support our hypothesis that meta-knowledge is transferable across models because it is model-agnostic. However, cross-model transfer consistently underperforms compared to MTL using self-generated memories. This suggests that model-specific biases may exist in the memories.

 Table 6 : Cross-Model Memory Transfer Average Pass@1 results show consistent gains over zero-shot across different model pairs. 

 Source 
 Target 
 LCB 
 SWEB 
 RepliB 
 Avg. 

 Zeroshot 
 GPT-5-mini 
 0.863 
 0.623 
 0.059 
 0.515 

 DeepSeek V3.2 
 GPT-5-mini 
 0.890 
 0.617 
 0.048 
 0.518 

 Qwen3-Coder 
 GPT-5-mini 
 0.883 
 0.607 
 0.093 
 0.528 

 GPT-5-mini 
 GPT-5-mini 
 0.877 
 0.633 
 0.119 
 0.543 

 Zeroshot 
 DeepSeek V3.2 
 0.890 
 0.423 
 0.144 
 0.486 

 GPT-5-mini 
 DeepSeek V3.2 
 0.890 
 0.450 
 0.163 
 0.501 

 DeepSeek V3.2 
 DeepSeek V3.2 
 0.893 
 0.463 
 0.178 
 0.511 

 Zeroshot 
 Qwen3-Coder 
 0.733 
 0.347 
 0.126 
 0.402 

 GPT-5-mini 
 Qwen3-Coder 
 0.780 
 0.347 
 0.111 
 0.413 

 Qwen3-Coder 
 Qwen3-Coder 
 0.740 
 0.370 
 0.130 
 0.413 

 Table 7 : Retrieval Method Comparison Pass@3 results show that simple embedding-based retrieval outperforms advanced methods. 

 Method 
 LCB 
 SWEB 
 RepliB 
 Avg 

 No Memory 
 0.910 
 0.730 
 0.111 
 0.584 

 LLM Reranking 
 0.920 
 0.730 
 0.144 
 0.598 

 Adaptive Rewriting 
 0.920 
 0.760 
 0.144 
 0.608 

 Embedding Similarity 
 0.930 
 0.770 
 0.189 
 0.630 

 Finding 6. Memory can be transferred across different models, while self-generated memories yield the best performance. 

 4.4.5 Analysis on Retrieval Methods

As discussed in Section 4.4.1 , negative transfer often arises from incorrect memory retrieval and adaptation.
We therefore investigate whether advanced retrieval strategies, such as reranking and memory rewriting, can further improve MTL.
For reranking, we first retrieve 20 candidate memories based on embedding similarity and then prompt the LLM to select the three most helpful ones for the given task.
For task-adaptive memory rewriting, we prompt the LLM to rewrite the retrieved memories to better align with the target task.
However, both methods underperform simple embedding-based retrieval, as shown in Table 7 .
This is likely because the required knowledge is difficult to anticipate in dynamic, multi-step agent settings.
These findings suggest that retrieval methods designed for static settings may not generalize well to cross-domain memory transfer, highlighting the need for further study on agentic memory retrieval and adaptation, such as domain routing  (Yeo et al. , 2025a ) and step-wise memory retrieval  (Cao et al. , 2025 ) .

 Finding 7. Cross-domain memory retrieval is inherently challenging, and static retrieval methods fail to generalize in heterogeneous agentic settings. 

 5 Conclusion

In this work, we presented the first holistic investigation into Memory Transfer Learning for coding agents, challenging the prevailing assumption that memory utilization must be limited to homogeneous task domains.
Through extensive evaluation across 6 diverse benchmarks, we demonstrated that leveraging a unified memory pool from heterogeneous domains can enhance agent performance by 3.7%.
Our analysis yields three critical design principles for cross-domain memory.
First, we identified that the primary value of transferred memory lies in meta-knowledge rather than task-specific workflows.
Second, we found that abstraction dictates transferability; high-level abstractions like Insights generalize effectively across domains, whereas low-level Trajectories often induce negative transfer due to brittle implementation anchoring.
Third, we highlighted that the effectiveness of memory transfer scales with the size and diversity of the memory pool, increasing the likelihood of retrieving useful meta-knowledge.
We hope this study establishes empirical foundations for expanding memory utilization beyond single-domain settings and stimulates further research into robust memory usage strategies for self-evolving coding agents.

Impact Statement

This paper presents work whose goal is to advance the field of self-evolving coding agents, specifically by introducing Memory Transfer Learning to leverage knowledge across heterogeneous domains. By enabling agents to effectively transfer high-level meta-knowledge, our work contributes to making agentic systems more generalizable and data-efficient, reducing the need for extensive domain-specific fine-tuning. This has positive implications for lowering the barriers to developing versatile software engineering agents. However, we acknowledge the potential for negative transfer, where agents might misapply implementation patterns or overlook domain-specific safety constraints. Consequently, the deployment of such systems requires careful attention to robust retrieval strategies to prevent the generation of unreliable or insecure code.

References

 Z. Cai, X. Guo, Y. Pei, J. Feng, J. Su, J. Chen, Y. Zhang, W. Ma, M. Wang, and H. Zhou (2025) 
 Flex: continuous agent evolution via forward learning from experience .

 arXiv preprint arXiv:2511.06449 .

 Cited by: §2.2 .

 R. Cao, M. Chen, J. Chen, Z. Cui, Y. Feng, B. Hui, Y. Jing, K. Li, M. Li, J. Lin, et al. (2026) 
 Qwen3-coder-next technical report .

 arXiv preprint arXiv:2603.00729 .

 Cited by: §4.1.1 .

 Z. Cao, J. Deng, L. Yu, W. Zhou, Z. Liu, B. Ding, and H. Zhao (2025) 
 Remember me, refine me: a dynamic procedural memory framework for experience-driven agent evolution .

 arXiv preprint arXiv:2512.10696 .

 Cited by: §2.2 ,
 §3.1.1 ,
 §4.4.1 ,
 §4.4.5 .

 S. Chen, S. Lin, X. Gu, Y. Shi, H. Lian, L. Yun, D. Chen, W. Sun, L. Cao, and Q. Wang (2025) 
 Swe-exp: experience-driven software issue resolution .

 arXiv preprint arXiv:2507.23361 .

 Cited by: §2.2 .

 J. Chou, A. Liu, Y. Deng, Z. Zeng, T. Zhang, H. Zhu, J. Cai, Y. Mao, C. Zhang, L. Tan, Z. Xu, B. Zhai, H. Liu, S. Zhu, W. Zhou, and F. Lian (2025) 
 AutoCodeBench: large language models are automatic code benchmark generators .

 External Links: 2508.09101 ,
 Link 

 Cited by: §2.1 .

 Q. Dong, L. Li, D. Dai, C. Zheng, J. Ma, R. Li, H. Xia, J. Xu, Z. Wu, B. Chang, X. Sun, L. Li, and Z. Sui (2024) 
 A survey on in-context learning .

 In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing , Y. Al-Onaizan, M. Bansal, and Y. Chen (Eds.) ,

 Miami, Florida, USA , pp. 1107–1128 .

 External Links: Link ,
 Document 

 Cited by: §2.3 .

 J. Fang, Y. Peng, X. Zhang, Y. Wang, X. Yi, G. Zhang, Y. Xu, B. Wu, S. Liu, Z. Li, et al. (2025a) 
 A comprehensive survey of self-evolving ai agents: a new paradigm bridging foundation models and lifelong agentic systems .

 arXiv preprint arXiv:2508.07407 .

 Cited by: §1 .

 R. Fang, Y. Liang, X. Wang, J. Wu, S. Qiao, P. Xie, F. Huang, H. Chen, and N. Zhang (2025b) 
 Memp: exploring agent procedural memory .

 arXiv preprint arXiv:2508.06433 .

 Cited by: §2.2 .

 H. Gao, J. Geng, W. Hua, M. Hu, X. Juan, H. Liu, S. Liu, J. Qiu, X. Qi, Y. Wu, et al. (2025) 
 A survey of self-evolving agents: on path to artificial super intelligence .

 arXiv preprint arXiv:2507.21046 .

 Cited by: §1 .

 P. Gauthier (2024) 
 Aider polyglot benchmark .

 Note: Blog post and benchmark details 

 External Links: Link 

 Cited by: §3.2.1 .

 N. Houlsby, A. Giurgiu, S. Jastrzebski, B. Morrone, Q. De Laroussilhe, A. Gesmundo, M. Attariyan, and S. Gelly (2019) 
 Parameter-efficient transfer learning for nlp .

 In International conference on machine learning ,

 pp. 2790–2799 .

 Cited by: §2.3 .

 J. Howard and S. Ruder (2018) 
 Universal language model fine-tuning for text classification .

 arXiv preprint arXiv:1801.06146 .

 Cited by: §2.3 .

 B. Hui, J. Yang, Z. Cui, J. Yang, D. Liu, L. Zhang, T. Liu, J. Zhang, B. Yu, K. Lu, et al. (2024) 
 Qwen2. 5-coder technical report .

 arXiv preprint arXiv:2409.12186 .

 Cited by: §2.1 .

 N. Jain, K. Han, A. Gu, W. Li, F. Yan, T. Zhang, S. Wang, A. Solar-Lezama, K. Sen, and I. Stoica (2024) 
 LiveCodeBench: holistic and contamination free evaluation of large language models for code .

 arXiv preprint arXiv:2403.07974 .

 Cited by: §1 ,
 §2.1 ,
 §3.2.1 .

 C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. R. Narasimhan (2024) 
 SWE-bench: can language models resolve real-world github issues? .

 In The Twelfth International Conference on Learning Representations ,

 External Links: Link 

 Cited by: §1 ,
 §2.1 ,
 §3.2.1 .

 K. Kim, G. Park, Y. Lee, W. Yeo, and S. J. Hwang (2025) 
 VideoICL: confidence-based iterative in-context learning for out-of-distribution video understanding .

 In Proceedings of the Computer Vision and Pattern Recognition Conference ,

 pp. 3295–3305 .

 Cited by: §2.3 .

 K. Kim, Y. Yang, S. Kim, W. Yeo, Y. Lee, M. Ren, and S. J. Hwang (2026) 
 MA-egoqa: question answering over egocentric videos from multiple embodied agents .

 arXiv preprint arXiv:2603.09827 .

 Cited by: §2.2 .

 A. Liu, A. Mei, B. Lin, B. Xue, B. Wang, B. Xu, B. Wu, B. Zhang, C. Lin, C. Dong, et al. (2025) 
 Deepseek-v3. 2: pushing the frontier of open large language models .

 arXiv preprint arXiv:2512.02556 .

 Cited by: §4.1.1 .

 Q. Luo, Y. Ye, S. Liang, Z. Zhang, Y. Qin, Y. Lu, Y. Wu, X. Cong, Y. Lin, Y. Zhang, et al. (2024) 
 Repoagent: an llm-powered open-source framework for repository-level code documentation generation .

 arXiv preprint arXiv:2402.16667 .

 Cited by: §2.1 .

 M. A. Merrill, A. G. Shaw, N. Carlini, B. Li, H. Raj, I. Bercovich, L. Shi, J. Y. Shin, T. Walshe, E. K. Buchanan, et al. (2026) 
 Terminal-bench: benchmarking agents on hard, realistic tasks in command line interfaces .

 arXiv preprint arXiv:2601.11868 .

 Cited by: §2.1 ,
 §3.2.1 .

 S. Min, X. Lyu, A. Holtzman, M. Artetxe, M. Lewis, H. Hajishirzi, and L. Zettlemoyer (2022) 
 Rethinking the role of demonstrations: what makes in-context learning work? .

 arXiv preprint arXiv:2202.12837 .

 Cited by: §2.3 .

 L. Mitchener, J. M. Laurent, A. Andonian, B. Tenmann, S. Narayanan, G. P. Wellawatte, A. White, L. Sani, and S. G. Rodriques (2025) 
 Bixbench: a comprehensive benchmark for llm-based agents in computational biology .

 arXiv preprint arXiv:2503.00096 .

 Cited by: §2.1 .

 D. Nathani, L. Madaan, N. Roberts, N. Bashlykov, A. Menon, V. Moens, A. Budhiraja, D. Magka, V. Vorotilov, G. Chaurasia, et al. (2025) 
 Mlgym: a new framework and benchmark for advancing ai research agents .

 arXiv preprint arXiv:2502.14499 .

 Cited by: §1 ,
 §3.2.1 .

 S. Ouyang, J. Yan, I. Hsu, Y. Chen, K. Jiang, Z. Wang, R. Han, L. T. Le, S. Daruki, X. Tang, et al. (2025) 
 Reasoningbank: scaling agent self-evolving with reasoning memory .

 arXiv preprint arXiv:2509.25140 .

 Cited by: §1 ,
 §1 ,
 §1 ,
 §2.2 ,
 §3.1.1 ,
 §3.1.1 ,
 §4.1.2 .

 T. Ridnik, D. Kredo, and I. Friedman (2024) 
 Code generation with alphacodium: from prompt engineering to flow engineering .

 arXiv preprint arXiv:2401.08500 .

 Cited by: §2.1 .

 B. Roziere, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. E. Tan, Y. Adi, J. Liu, R. Sauvestre, T. Remez, et al. (2023) 
 Code llama: open foundation models for code .

 arXiv preprint arXiv:2308.12950 .

 Cited by: §2.1 .

 M. Seo, J. Baek, S. Lee, and S. J. Hwang (2025) 
 Paper2code: automating code generation from scientific papers in machine learning .

 arXiv preprint arXiv:2504.17192 .

 Cited by: §1 ,
 §2.1 .

 N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao (2023) 
 Reflexion: language agents with verbal reinforcement learning .

 Advances in Neural Information Processing Systems 36 , pp. 8634–8652 .

 Cited by: §1 .

 M. Suzgun, M. Yuksekgonul, F. Bianchi, D. Jurafsky, and J. Zou (2025) 
 Dynamic cheatsheet: test-time learning with adaptive memory .

 arXiv preprint arXiv:2504.07952 .

 Cited by: §2.2 .

 X. Tang, T. Qin, T. Peng, Z. Zhou, D. Shao, T. Du, X. Wei, P. Xia, F. Wu, H. Zhu, G. Zhang, J. Liu, X. Wang, S. Hong, C. Wu, H. Cheng, C. Wang, and W. Zhou (2025) 
 Agent KB: leveraging cross-domain experience for agentic problem solving .

 arXiv preprint arXiv:2507.06229 .

 Cited by: §1 ,
 §2.3 ,
 §4.1.2 .

 H. F. Team (2026) 
 Harbor framework: a framework for evaluating and optimizing agents and models in container environments. 

 Note: https://github.com/laude-institute/harbor 

 Cited by: §2.1 ,
 §3.2.2 .

 X. Wang, B. Li, Y. Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y. Song, B. Li, J. Singh, et al. (2024a) 
 Openhands: an open platform for ai software developers as generalist agents .

 arXiv preprint arXiv:2407.16741 .

 Cited by: §2.1 .

 Y. Wang, Y. Wang, D. Guo, J. Chen, R. Zhang, Y. Ma, and Z. Zheng (2024b) 
 Rlcoder: reinforcement learning for repository-level code completion .

 arXiv preprint arXiv:2407.19487 .

 Cited by: §2.1 .

 Z. Z. Wang, J. Mao, D. Fried, and G. Neubig (2024c) 
 Agent workflow memory .

 arXiv preprint arXiv:2409.07429 .

 Cited by: §1 ,
 §1 ,
 §2.2 ,
 §3.1.1 .

 C. S. Xia, Y. Deng, and L. Zhang (2024) 
 Top leaderboard ranking = top coding proficiency, always? evoeval: evolving coding benchmarks via llm .

 arXiv preprint .

 Cited by: §2.1 .

 A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, et al. (2025) 
 Qwen3 technical report .

 arXiv preprint arXiv:2505.09388 .

 Cited by: §4.1.1 .

 J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. R. Narasimhan, and O. Press (2024) 
 SWE-agent: agent-computer interfaces enable automated software engineering .

 In The Thirty-eighth Annual Conference on Neural Information Processing Systems ,

 External Links: Link 

 Cited by: §1 ,
 §3.2.2 .

 C. Ye, S. Yuan, S. Cooray, S. Dillmann, I. L. Roque, D. Baron, P. Frank, S. Martin-Alvarez, N. Koblischke, F. J. Qu, et al. (2025) 
 ReplicationBench: can ai agents replicate astrophysics research papers? .

 arXiv preprint arXiv:2510.24591 .

 Cited by: §3.2.1 .

 W. Yeo, K. Kim, S. Jeong, J. Baek, and S. J. Hwang (2025a) 
 UniversalRAG: retrieval-augmented generation over corpora of diverse modalities and granularities .

 arXiv preprint arXiv:2504.20734 .

 Cited by: §4.4.5 .

 W. Yeo, K. Kim, J. Yoon, and S. J. Hwang (2025b) 
 Worldmm: dynamic multimodal memory agent for long video reasoning .

 arXiv preprint arXiv:2512.02425 .

 Cited by: §2.2 .

 G. Zhang, H. Ren, C. Zhan, Z. Zhou, J. Wang, H. Zhu, W. Zhou, and S. Yan (2025) 
 Memevolve: meta-evolution of agent memory systems .

 arXiv preprint arXiv:2512.18746 .

 Cited by: §2.2 .

 K. Zhang, J. Li, G. Li, X. Shi, and Z. Jin (2024) 
 Codeagent: enhancing code generation with tool-integrated agent systems for real-world repo-level coding challenges .

 arXiv preprint arXiv:2401.07339 .

 Cited by: §2.1 .

 L. Zheng, R. Wang, X. Wang, and B. An (2024) 
 Synapse: trajectory-as-exemplar prompting with memory for computer control .

 In The Twelfth International Conference on Learning Representations,
ICLR 2024, Vienna, Austria, May 7-11, 2024 ,

 External Links: Link 

 Cited by: §1 ,
 §1 .

 L. Zhong, Z. Wang, and J. Shang (2024) 
 Debug like a human: a large language model debugger via verifying runtime execution step-by-step .

 arXiv preprint arXiv:2402.16906 .

 Cited by: §2.1 .

 Q. Zhu, D. Guo, Z. Shao, D. Yang, P. Wang, R. Xu, Y. Wu, Y. Li, H. Gao, S. Ma, et al. (2024) 
 Deepseek-coder-v2: breaking the barrier of closed-source models in code intelligence .

 arXiv preprint arXiv:2406.11931 .

 Cited by: §2.1 .

 F. Zhuang, Z. Qi, K. Duan, D. Xi, Y. Zhu, H. Zhu, H. Xiong, and Q. He (2020) 
 A comprehensive survey on transfer learning .

 Proceedings of the IEEE 109 ( 1 ), pp. 43–76 .

 Cited by: §2.3 .

 Appendix A Average Pass@1 Results

 Table 8 : Evaluation results of Memory Transfer Learning. 

 LiveCodeBench 
 Aider-Polyglot 
 SWEBench-Verified 
 TerminalBench2 
 ReplicationBench 
 MLGym-Bench 
 Avg. 

 GPT-5-mini 

 ZeroShot 
 0.863 
 0.343 
 0.623 
 0.206 
 0.059 
 0.583 
 0.435 

 MTL (T) 
 0.890 
 0.357 
 0.610 
 0.195 
 0.063 
 0.528 
 0.438 

 MTL (W) 
 0.877 
 0.350 
 0.620 
 0.243 
 0.081 
 0.583 
 0.449 

 MTL (S) 
 0.887 
 0.370 
 0.613 
 0.228 
 0.078 
 0.611 
 0.451 

 MTL (I) 
 0.877 
 0.347 
 0.633 
 0.213 
 0.119 
 0.639 
 0.454 

 Δ \Delta 
 +1.3% 
 +0.3% 
 +1.0% 
 +0.8% 
 +5.9% 
 +5.6% 
 +1.9% 

 Qwen3-Coder-480B-A35B-Instruct 

 ZeroShot 
 0.733 
 0.357 
 0.347 
 0.210 
 0.126 
 0.500 
 0.366 

 MTL (I) 
 0.740 
 0.360 
 0.370 
 0.228 
 0.130 
 0.528 
 0.377 

 Δ \Delta 
 +0.7% 
 +0.3% 
 +2.3% 
 +1.9% 
 +0.4% 
 +2.8% 
 +1.2% 

 DeepSeek V3.2 

 ZeroShot 
 0.890 
 0.433 
 0.423 
 0.285 
 0.144 
 0.500 
 0.446 

 MTL (I) 
 0.893 
 0.447 
 0.463 
 0.288 
 0.178 
 0.556 
 0.466 

 Δ \Delta 
 +0.3% 
 +1.3% 
 +4.0% 
 +0.4% 
 +3.3% 
 +5.6% 
 +2.0% 

 Appendix B Case Study on Negative Transfer

 Table 9 : Negative Transfer Cases. Below examples illustrate failures in Memory Transfer Learning due to the misapplication or distortion of retrieved knowledge. Specifically, agents may erroneously apply cross-language patterns ( e.g., R to C++) or distort high-level guidance into justifications for suboptimal shortcuts. 

 Model 

 Memory Transfer Learning with Workflow 

 Memory Transfer Learning with Insight 

 Task 

 (C++) Implement functions in space_age.cpp / space_age.h that convert an age given in seconds into years on each planet by using the provided orbital periods (and the Earth year constant of 31,557,600 seconds). 

 Improve agent performance on the MetaMaze navigation task (e.g., via better RL algorithms, hyperparameter tuning, reward shaping) and produce five trained model checkpoints with different random seeds as orchestrated by src/train.py. 

 Memory 

 Goal : Create a single final R source file containing implementations of odometry_estimation, bearing_range_estimation, warp2pi, and compute_meas_obs_jacobian …

 Workflow : [ " cat <<’ EOF ’ > solution . txtn # Write R functions implementing the required API :\ n ...", 
 "echo ..." ] 

 Title : Pre-flight verification of datasets and pretrained checkpoints before running experiments

 Description : Before attempting training or evaluation, automatically check that required dataset files and pretrained model weights exist and return a null result if essential artifacts are missing. 

 Reasoning 

 I’ll implement the Space Age solution by writing / overwriting the provided header and source files with a correct class implementation … I’ll use Memory Item 2’s successful pattern of writing files with heredoc to reliably create the source files. 

 I will perform a quick, low-cost training run to validate the end-to-end training pipeline and produce checkpoints … I’ll use … Memory Item 2 (pre-flight verification of datasets and pretrained checkpoints) to keep this as a short smoke test rather than a full long run. 

 Result 

 Fail , The agent blindly applied Memory Item 2’s R-language overwriting pattern to the C++ project, replacing existing files without checking its original structure or namespaces. 

 Fail , Retrieved memory represents to verify required components before running expensive experiments, however, the agent distorted this into a justification for quick completion over quality. 

 Appendix C Formal Modeling of Abstraction

 To formally ground these empirical findings, we introduce a mathematical framework modeling the abstraction-transfer tradeoff. We decompose a memory embedding e ​ ( m ) e(m) into a domain-invariant component (meta-knowledge, z inv z_{\mathrm{inv}} ) and a domain-specific component ( z sp z_{\mathrm{sp}} ): 

 e ​ ( m ) = z inv ​ ( m ) + z sp ​ ( m ) . e(m)=z_{\mathrm{inv}}(m)+z_{\mathrm{sp}}(m). 

 We define the Abstraction level ( A A ) of a memory as the proportion of the domain-invariant component: 

 A = ‖ z inv ​ ( m ) ‖ 2 ‖ z inv ​ ( m ) ‖ 2 + ‖ z sp ​ ( m ) ‖ 2 . A=\frac{\|z_{\mathrm{inv}}(m)\|^{2}}{\|z_{\mathrm{inv}}(m)\|^{2}+\|z_{\mathrm{sp}}(m)\|^{2}}. 

 Higher A A indicates that the memory is dominated by transferable meta-knowledge rather than domain-specific details. 

 For an unseen target task x x , the utility U ​ ( x , m ) U(x,m) of retrieving memory m m is modeled as a trade-off between transferable guidance and brittle domain mismatch: 

 U ​ ( x , m ) ∝ ⟨ e ​ ( x ) , z inv ​ ( m ) ⟩ ⏟ Transferable Guidance − ⟨ e ​ ( x ) , z sp ​ ( m ) ⟩ ⏟ Domain Mismatch Penalty . U(x,m)\propto\underbrace{\langle e(x),z_{\mathrm{inv}}(m)\rangle}_{\text{Transferable Guidance}}-\underbrace{\langle e(x),z_{\mathrm{sp}}(m)\rangle}_{\text{Domain Mismatch Penalty}}. 

 To analyze cross-domain transfer, we formalize two natural assumptions: (1) embeddings have a bounded capacity (e.g., normalized norm), meaning an increase in A A strictly replaces domain-specific details with meta-knowledge, and (2) for an unseen task x x , the domain-specific component z sp z_{\mathrm{sp}} acts as misaligned noise. Therefore, as A A increases, the expected mismatch penalty decreases, allowing the universally applicable meta-knowledge ( z inv z_{\mathrm{inv}} ) to dominate the utility. 

 Proposition 1 (Abstraction–Transfer Tradeoff). Under these assumptions, our formal model proves that the expected empirical transfer gain strictly increases with the abstraction level A A . 

 Appendix D Memory Benefit Category

 In Table 10 , we present the categories of memory contributions generated by the LLM for analysis. 

 Table 10: Categories of Memory Benefits 

 1. Iterative Workflow Discipline 

 - Definition: Guiding the agent to follow a structured, step-by-step development process (e.g., inspect edit run verify) rather than attempting risky one-shot solutions. 

 - Context: Used when memories reinforced the pattern of making small changes and checking them immediately (e.g., ”edit-test-repeat” loop). 

 2. Algorithmic Strategy Transfer 

 - Definition: Providing specific algorithmic approaches or data structures suitable for the problem class. 

 - Context: Used when the agent recalled mathematical formulas, dynamic programming approaches, combinatorial logic, or specific heuristics (e.g., ”O(n) single-pass,” ”backtracking with pruning”). 

 3. Test Driven Verification 

 - Definition: Encouraging the creation of reproduction scripts, smoke tests, or minimal harnesses when official tests are missing or too heavy. 

 - Context: Used when memories prompted the agent to write repro.py, use assert, or create local checks to validate logic before submission. 

 4. Environmental Adaptation 

 - Definition: Helping the agent navigate specific system constraints, build tools, or OS-level idiosyncrasies. 

 - Context: Used when dealing with missing packages, compilation flags, bash vs sh differences, or cross-compilation toolchains. 

 5. Anti-Pattern Avoidance 

 - Definition: Acting as a cautionary guardrail against known failure modes or brittle approaches. 

 - Context: Used when the agent explicitly avoided actions that caused failures in retrieved memories (e.g., ”avoid blind text patching,” ”do not guess outputs”). 

 6. Input Validation and Robustness 

 - Definition: Ensuring the solution correctly handles edge cases, data normalization, and defensive parsing. 

 - Context: Used when memories guided the agent to handle empty inputs, normalize heterogeneous data types, or enforce strict input sanitization. 

 7. API and Interface Compliance 

 - Definition: Ensuring the code adheres to existing function signatures, class structures, or external library contracts. 

 - Context: Used when the agent needed to preserve legacy behavior, match specific output schemas (JSON/YAML), or integrate correctly with a framework like Django or React. 

 8. Interaction Protocol Adherence 

 - Definition: Ensuring the agent complies with the specific formatting and submission rules of the benchmark environment. 

 - Context: Used when memories reinforced using specific completion tokens (e.g., ”COMPLETE_TASK…”), single-command constraints, or specific output formats. 

 9. File and Syntax Management 

 - Definition: Providing safe techniques for file manipulation and code injection to prevent syntax errors during generation. 

 - Context: Used when the agent utilized robust heredoc patterns, correct quoting to avoid shell interpolation, or atomic file writes. 

 10. Repository Exploration Tactics 

 - Definition: Guiding the agent on how to effectively locate relevant code or resources within a large codebase. 

 - Context: Used when memories suggested using grep, find, or inspecting specific asset files (like package.json or paper abstracts) before writing code. 

 Appendix E Memory Generation Prompts

 Figure 7: Workflow Generation Prompt for a Success Trajectory 

 Figure 8: Workflow Generation Prompt for a Failed Trajectory 

 Figure 9: Summary Generation Prompt for a Success Trajectory 

 Figure 10: Summary Generation Prompt for a Failed Trajectory 

 Figure 11: Insight Generation Prompt for a Success Trajectory 

 Figure 12: Insight Generation Prompt for a Failed Trajectory 

 Experimental support, please
 view the build logs 
 for errors. Generated by

 L
 A 
 T
 E 

 xml 

 .

Instructions for reporting errors

We are continuing to improve HTML versions of papers, and your feedback helps enhance accessibility and mobile
 support. To report errors in the HTML that will help us improve conversion and rendering, choose any of the
 methods listed below:

Click the "Report Issue" ( 

 ) button, located in the page header.

 Tip: You can select the relevant text first, to include it in your report.

Our team has already identified the following issues . We appreciate your time reviewing and reporting rendering errors we
 may not have found yet. Your efforts will help us improve the HTML versions for all readers, because disability
 should not be a barrier to accessing research. Thank you for your continued support in championing open access for
 all.

Have a free development cycle? Help support accessibility at arXiv! Our collaborators at LaTeXML maintain a list of packages that need conversion , and welcome developer contributions .

BETA