MemGovern: Enhancing Code Agents through Learning from Governed Human Experiences

Abstract: While autonomous software engineering (SWE) agents are reshaping programming paradigms, they currently suffer from a "closed-world" limitation: they attempt to fix bugs from scratch or solely using local context, ignoring the immense historical human experience available on platforms like GitHub. Accessing this open-world experience is hindered by the unstructured and fragmented nature of real-world issue-tracking data. In this paper, we introduce MemGovern, a framework designed to govern and transform raw GitHub data into actionable experiential memory for agents. MemGovern employs experience governance to convert human experience into agent-friendly experience cards and introduces an agentic experience search strategy that enables logic-driven retrieval of human expertise. By producing 135K governed experience cards, MemGovern achieves a significant performance boost, improving resolution rates on the SWE-bench Verified by 4.65%. As a plug-in approach, MemGovern provides a solution for agent-friendly memory infrastructure.

• The paper introduces a structured pipeline that curates noisy human debugging experiences into standardized experience cards for code agents.
• It employs hierarchical selection, experience standardization, and checklist-based quality control to ensure memory fidelity and transferability.
• Empirical validation shows a 4.65% improvement in resolution rates, highlighting robustness across diverse LLM backbones and complex repair tasks.

MemGovern: Large-Scale Governance for Agent-Friendly Experiential Memory in Code Agents

Introduction and Motivation

The paper "MemGovern: Enhancing Code Agents through Learning from Governed Human Experiences" (2601.06789) addresses the open-world limitation of current autonomous software engineering (SWE) agents. While recent LLM-based agents have demonstrated strong code reasoning and generation abilities, LLM-based debugging agents typically operate in a closed world—fixing issues from scratch or using local context—ignoring the vast repository of human expert debugging experience found in real-world collaborative development artifacts such as GitHub issues and pull requests. The central challenge lies in the unstructured, noisy, and heterogeneous nature of these records, which impedes direct ingestion and reuse by code agents.

MemGovern introduces a systematic pipeline for governing raw human experience into agent-friendly, verifiable, and transferable memory. This framework supports the construction of large-scale "experience cards" and an agentic search interface that enables agents to leverage cross-repository repair knowledge in a principled, logic-driven manner.

Figure 1: MemGovern comparison with existing methods; it distills raw open-source data into agent-compatible experiential memory.

Architecture: Experience Governance and Agentic Experience Search

Experience Governance Pipeline

MemGovern's governance pipeline consists of three major phases: hierarchical selection, experience standardization, and checklist quality control.

• Hierarchical Selection: MemGovern first selects repositories using a metadata-driven scoring that combines repository popularity and maintenance intensity. Within each repository, only ‘closed-loop’ $(Issue, PR, Patch)$ triplets—i.e., those with explicit evidence chains and high technical-content density—are retained, minimizing information pollution.
• Experience Standardization: Each selected triplet is converted into a structured ‘experience card’ following a unified schema. This schema explicitly separates the Index Layer (retrieval signals: problem summary, diagnostic signals) from the Resolution Layer (causal chains, abstract fix strategy, patch digest), promoting reusability independent of repository-specific nomenclature.
• Checklist-Based Quality Control: To ensure factuality and informativeness, standardized cards undergo structured evaluation by LLMs along critical axes (completeness, clarity, causal correctness). Deficiencies prompt targeted regeneration in a refine-loop mechanism to guarantee memory fidelity.

  Figure 2: MemGovern's pipeline transforms noisy human experiences into standardized cards accessible to agents via agentic search.

This multi-stage process produces an experiential memory of 135,000 high-fidelity, cross-repository experience cards, setting a new scale benchmark for knowledge-augmented agent memory systems.

Agentic Experience Search: Dual-Primitives and Progressive Retrieval

MemGovern provides a dual-interface ‘search’ and ‘browse’ API:

• Searching retrieves a symptom-similar subset of Index Layer cards via embedding-based similarity ranking.
• Browsing enables focused inspection of Resolution Layers for logic transfer.

This design allows for progressive agentic search—agents iteratively alternate retrieval and evidence review, recognizing when more context is needed and revising queries. Unlike static RAG, agents dynamically control the depth and breadth of search, closely mirroring how human engineers explore past cases.

Figure 3: Standard RAG retrieves semantically irrelevant frontend cases; MemGovern’s agentic workflow enables logic-driven retrieval of backend repair knowledge.

Empirical Validation

Main Results Across LLM Backbones

On SWE-bench Verified, MemGovern consistently yields 4.65% higher resolution rates compared to the SWE-Agent baseline, with pronounced gains for weaker LLM backbones and robust model-agnostic improvements.

Figure 4: MemGovern consistently improves success rates over the SWE-Agent baseline across diverse LLMs.

Ablations: Memory Size, Quality, and Retrieval Dynamics

MemGovern’s task performance scales monotonically with experiential memory size; no abrupt jumps suggest that cumulative aggregation of real-world experience, rather than a few key exemplars, drives improvement.

Figure 5: MemGovern resolution rates as a function of experiential memory coverage and retrieval depth.

Crucially, the performance advantage derives from the governance process: raw, unfiltered experience records both degrade stability and reduce success rates compared to MemGovern’s curated cards.

Figure 6: Raw experiences provide unstable improvements; governed cards deliver robust, LLM-independent gains.

Retrieval and Action Composition Analysis

Progressive agentic search outperforms static or single-shot RAG, particularly by reducing the cognitive overload incurred by indiscriminate context injection. Empirical action traces reveal more efficient navigation and fewer spurious editing attempts in MemGovern-equipped agents.

Figure 7: MemGovern shifts agent action composition towards more targeted code editing and effective self-testing steps.

Qualitative Case Studies

Case analyses underscore the superiority of governed memory and progressive analogical transfer. For example, MemGovern’s agent retrieves explicit root cause and fix guidance and produces a semantically correct patch, whereas the baseline agent applies a superficial patch that violates the API contract.

Figure 8: With MemGovern, the agent follows historically validated logic; the baseline applies shortsighted, error-prone heuristics.

Further, when exposed to standard RAG noise or unprocessed experience, agents often pursue irrelevant patch strategies. Structured memory and browsing are critical for effective analogical transfer in non-trivial developer workflows.

Figure 9: Governed experience isolates core repair logic, unlike raw experience, which entangles the agent in noisy, incomplete solutions.

Implications and Future Directions

MemGovern provides a scalable recipe for constructing agent-friendly experiential memory from noisy, heterogeneous real-world data. The separation of retrieval and reasoning enables both better analogical transfer and robustness to memory size and heterogeneity. Beyond code agents, this governance paradigm has immediate implications for other domains requiring high-fidelity, cross-task experience abstraction, such as scientific workflow automation and multi-agent collaborative reasoning.

On the theoretical axis, MemGovern reinforces that effective agent memory should not be treated as mere context extension or parametric recall. Rather, memory governance must focus on noise reduction, logic isolation, and analogical transfer—issues at the intersection of software repositories, knowledge engineering, and retrieval-augmented reasoning.

Potential future directions include amortized retrieval via case-based memory clustering, adaptive memory compression, and integration with self-improving continual learning agents. Compression of memory length and more advanced, active-memory shaping—such as extracting human utility preferences from issue discussion meta-signals—are promising avenues to further align human software engineering strategies with LLM agent capabilities.

Conclusion

MemGovern demonstrates that governed, large-scale experience memory yields robust and significant improvements in autonomous code agent performance. Through a scalable governance pipeline and a logic-driven agentic search interface, it enables principled analogical transfer and overcomes the limitations of static, noisy, or ad-hoc memory augmentation. These insights make MemGovern a critical step towards knowledge-centric, collaborative AI agents for real-world software engineering (2601.06789).