MEMRES: A Memory-Augmented Resolver with Confidence Cascade for Agentic Python Dependency Resolution

• URL: http://arxiv.org/abs/2604.16941v1
• Date: Sat, 18 Apr 2026 09:52:45 GMT
• Title: MEMRES: A Memory-Augmented Resolver with Confidence Cascade for Agentic Python Dependency Resolution
• Abstract summary: MEMRES is an agentic system for Python dependency resolution.<n>On HG2.9K using Gemma-2 9B (10 GB VRAM) MEMRES resolves 2503 snippets of 2890 snippets.
• Score: 1.6376585841690154
• License: http://creativecommons.org/licenses/by/4.0/
• Abstract: We present MEMRES, an agentic system for Python dependency resolution that introduces a multi-level confidence cascade where the LLM serves as the last resort. Our system combines: (1) a Self-Evolving Memory that accumulates reusable resolution patterns via tips and shortcuts; (2) an Error Pattern Knowledge Base with 200+ curated import-to-package mappings; (3) a Semantic Import Analyzer; and (4) a Python 2 heuristic detector resolving the largest failure category. On HG2.9K using Gemma-2 9B (10 GB VRAM). MEMRES resolves 2503 of 2890 (86.6%, 10-run average) snippets, combining intra-session memory with our confidence cascade for the remainder. This already exceeds PLLM's 54.7% overall success rate by a wide margin.

Related papers

• What Makes Agent Memory Useful for Reliable Unanswerable Question Handling? [51.58639607746329]
  Memory is widely used in agent systems, but its role in reliable UAQ handling remains unclear.<n>We present a systematic study of agent memory for UAQ handling under a unified agentic RAG framework.<n>We find that memory can improve UAQ performance in some settings, but such gains are selective rather than universal and remain fragile under dataset shift.
  arXiv  Detail & Related papers  (2026-08-28T05:00:28Z)
• The Recall Trap: A Recall-Maximizing Retriever Configuration Reduces Issue Resolution in Fixed-Budget Code Context [45.88028371034407]
  We report a controlled case study in code repair, not a new phenomenon.<n>We toggle one flag (one-chunk-perfile deduplication) on an otherwise identical stack.<n>We map where it holds: it reverses on a lexical BM25 (3.2pp, significant cross-paradigm interaction)<n>We show that at a tight fixed budget, do not hard-deduplicate by file, and A/B packing policies against the task, not the metric flag was tuned.
  arXiv  Detail & Related papers  (2026-08-14T19:22:50Z)
• MEMPROBE: Probing Long-Term Agent Memory via Hidden User-State Recovery [58.64329475683699]
  We argue that long-term memory should be evaluated as an auditable post-interaction artifact.<n>We instantiate this view in MEMPROBE, a benchmark in which a memory-equipped agent assists simulated users.<n>We find that successful assistance and recoverable memory behave as distinct capabilities.
  arXiv  Detail & Related papers  (2026-06-23T13:52:46Z)
• CommitDistill: A Lightweight Knowledge-Centric Memory Layer for Software Repositories [0.5872014229110213]
  Software accumulate large amounts of unstructured knowledge in commit messages, pull-request discussions, and issue threads.<n>Recent work on typed-memory architectures for agents (MemGPT, generative agents, and the PlugMem module of Yang et al.) argues that agent memory should be distilled, typed knowledge rather than raw interaction text.<n>We adapt that stance to a software repository's own git history under a constrained regime: deterministic, dependency-free, local-only, no embeddings.
  arXiv  Detail & Related papers  (2026-05-18T12:14:28Z)
• Breaking the Dependency Chaos: A Constraint-Driven Python Dependency Resolution Strategy with Selective LLM Imputation [1.0832844764942349]
  Dependency resolution is the task of selecting package versions that can be installed together without conflicts.<n>Recent work, such as LLMM, tackles this problem by using large language models to infer Python and package versions from code.<n>We present SMT-LLM, a hybrid system that replaces a version guessing with formal constraint solving.
  arXiv  Detail & Related papers  (2026-05-12T08:42:37Z)
• Correct Code, Vulnerable Dependencies: A Large Scale Measurement Study of LLM-Specified Library Versions [52.50730821321986]
  We present the first large-scale measurement study of version-level risk in large language models (LLMs)<n>We evaluate 10 LLMs on PinTrace, a curated benchmark of 1,000 Stack Overflow programming tasks.<n>Our findings reveal LLM version selection as a first-class, previously overlooked risk surface in LLM-based development.
  arXiv  Detail & Related papers  (2026-05-07T13:52:59Z)
• Learning When to Remember: Risk-Sensitive Contextual Bandits for Abstention-Aware Memory Retrieval in LLM-Based Coding Agents [0.0]
  coding agents increasingly rely on external memory to reuse prior experience, repair traces, and repository-local operational knowledge.<n>This paper reframes issue-memory use as a selective, risk-sensitive control problem rather than a pure top-k retrieval problem.<n>We introduce RSCB-MC, a risk-sensitive contextual bandit memory controller that decides whether an agent should use no memory, inject the top resolution, summarize multiple candidates, perform high-precision or high-recall retrieval, abstain, or ask for feedback.
  arXiv  Detail & Related papers  (2026-04-30T00:32:53Z)
• MemEvoBench: Benchmarking Memory MisEvolution in LLM Agents [78.95081012334116]
  Large Language Models (LLMs) with persistent memory enhances interaction continuity and personalization but introduces new safety risks.<n> contaminated or biased memory accumulation can trigger abnormal agent behaviors.<n>MemeEvoBench is the first benchmark evaluating memory safety in LLM agents against adversarial memory injection, noisy tool outputs, and biased feedback.
  arXiv  Detail & Related papers  (2026-04-17T07:29:52Z)
• From Translation to Superset: Benchmark-Driven Evolution of a Production AI Agent from Rust to Python [2.7324157162184157]
  We present a methodology for LLM-assisted continuous code translation in which a large language model translates a production Rust objective into Python.<n>We demonstrate that the Python port resolves 59/80 SWE-bench Verified tasks (73.8%) versus Rust's 56/80 (70.0%), confirming near-parity on real-world agentic tasks.<n>Our evaluation shows that for LLM-based agents where API latency dominates, Python's expressiveness yields a 15.9x code reduction with negligible performance cost.
  arXiv  Detail & Related papers  (2026-04-13T14:21:44Z)
• Evoking User Memory: Personalizing LLM via Recollection-Familiarity Adaptive Retrieval [59.295767860331004]
  RF-Mem is a familiarity uncertainty-guided dual-path memory retriever.<n>It embeds human-like dual-process recognition into the retriever.<n>It consistently outperforms one-shot retrieval and full-context reasoning under fixed budget and latency constraints.
  arXiv  Detail & Related papers  (2026-03-10T06:31:44Z)
• MemCtrl: Using MLLMs as Active Memory Controllers on Embodied Agents [53.44122827359892]
  We propose MemCtrl, a framework that uses Multimodal Large Language Models (MLLMs) for pruning memory online.<n>-augmented MLLMs show an improvement of around 16% on average, with over 20% on specific instruction subsets.
  arXiv  Detail & Related papers  (2026-01-28T18:31:17Z)
• Many Hands Make Light Work: An LLM-based Multi-Agent System for Detecting Malicious PyPI Packages [3.7667883869699597]
  Malicious code in open-source repositories such as PyPI poses a growing threat to software supply chains.<n>This paper presents LAMPS, a multi-agent system that employs collaborative language models to detect malicious PyPI packages.
  arXiv  Detail & Related papers  (2026-01-17T19:43:22Z)
• Agentic Learner with Grow-and-Refine Multimodal Semantic Memory [50.81667005063605]
  ViLoMem is a dual-stream memory framework that constructs compact, schema-based memory.<n>It encodes visual distraction patterns and logical reasoning errors, enabling MLLMs to learn from their successful and failed experiences.
  arXiv  Detail & Related papers  (2025-11-26T18:55:08Z)
• Where LLM Agents Fail and How They can Learn From Failures [62.196870049524364]
  Large Language Model (LLM) agents have shown promise in solving complex, multi-step tasks.<n>They amplify vulnerability to cascading failures, where a single root-cause error propagates through subsequent decisions.<n>Current systems lack a framework that can comprehensively understand agent error in a modular and systemic way.<n>We introduce the AgentErrorTaxonomy, a modular classification of failure modes spanning memory, reflection, planning, action, and system-level operations.
  arXiv  Detail & Related papers  (2025-09-29T18:20:27Z)
• MemGuide: Intent-Driven Memory Selection for Goal-Oriented Multi-Session LLM Agents [46.21840714172862]
  We introduce MemGuide, a two-stage framework for intent-driven memory selection.<n>MemGuide matches current dialogue context with stored intent descriptions in the memory bank.<n>Missing-Aligned Guided Filtering employs a chain-of-thought slot reasoner to enumerate unfilled slots, then uses a fine-tuned LLaMA-8B filter to re-rank the retrieved units.
  arXiv  Detail & Related papers  (2025-05-26T17:10:43Z)
• The Last Dependency Crusade: Solving Python Dependency Conflicts with LLMs [10.800983456810165]
  This paper investigates the use of Large Language Models (LLMs) to automatically repair dependency issues in Python programs.<n>We propose HGM (pronounced "plum"), a novel retrieval-augmented generation (RAG) approach that iteratively infers missing or incorrect dependencies.
  arXiv  Detail & Related papers  (2025-01-27T16:45:34Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.