English(EN)Titans + MIRAS: Helping AI have long-term memory
AI 代理获得高级记忆，用于学习和实时适应 · 跟踪 8 个来源
作者PulseAugur 编辑部·[972 个来源]·
研究人员正在为 AI 代理开发先进的记忆系统，以提高其学习和决策能力。Google 的 ReasoningBank 框架提炼了成功和失败经验的见解，使代理能够在部署后自我进化。同时，Google 的 Titans 架构和 MIRAS 框架允许 AI 模型通过实时主动更新记忆、优先处理令人惊讶的信息来处理海量上下文。其他研究探索了记忆仲裁以防止多代理系统中的偏见、用于演进信息的状体跟踪以及通过可逆遗忘来管理过时知识的方法。
AI
影响
AI 记忆系统的这些进步可能带来更强大、更个性化、更可靠的代理，应用于从软件工程到企业解决方案的各种场景。
Following the launch of Qwen3.6-Plus, we are excited to open-source Qwen3.6-35B-A3B — a sparse yet remarkably capable mixture-of-experts (MoE) model with 35 billion total parameters and only 3 billion active parameters. Despite its efficiency, Qwen3.6-35B-A3B delivers outstanding…
Deep-research agents answer complex user questions through an iterative sequence of search steps, where the agent autonomously formulates sub-queries to retrieve the evidence needed at each stage. However, existing retriever training typically relies only on the sub-query and its…
arXiv:2608.26983v1 Announce Type: new Abstract: Organizing long-term memory for multimodal agents remains challenging because existing methods either suffer from expensive question-agnostic offline summaries or naive embedding similarity matching that introduces incomplete and re…
arXiv cs.AI
TIER_1English(EN)·Eric Lacosse, Mariana Duarte, Graham Todd, Peter M. Todd, Daniel C. McNamee·
arXiv:2608.26152v1 Announce Type: cross Abstract: Large language models (LLMs) exhibit unprecedented natural language generation and many text-based problem-solving capabilities. Indeed, in many language-based tasks, for example routine coding, these artificial intelligence model…
arXiv:2608.26895v1 Announce Type: cross Abstract: Agentic recommender systems ground each decision of a large language model (LLM) in a persistent memory of the user, and in existing agents that memory is text: a narrative written and maintained by further LLM calls. Text limits …
Organizing long-term memory for multimodal agents remains challenging because existing methods either suffer from expensive question-agnostic offline summaries or naive embedding similarity matching that introduces incomplete and redundant context. To address these issues, we pro…
Agentic recommender systems ground each decision of a large language model (LLM) in a persistent memory of the user, and in existing agents that memory is text: a narrative written and maintained by further LLM calls. Text limits this memory in two ways. It is updated one rewrite…
arXiv cs.CL
TIER_1English(EN)·Yupeng Han, Shuochen Liu, Kai Zhang, Ze Liu, Zhihong Pan, Xianquan Wang·
arXiv:2608.25329v1 Announce Type: cross Abstract: Memory-augmented agents maintain compact user profiles throughout extended conversations, enabling personalized and consistent responses without the need to process the entire dialogue history. The quality of these user profiles r…
arXiv:2608.25618v1 Announce Type: new Abstract: Long-document visual question answering increasingly relies on VLM agents that retrieve candidate pages, inspect page images, write findings to working memory, and synthesize answers. Working memory should carry answer-supporting ev…
arXiv:2604.11544v2 Announce Type: replace Abstract: Structured memory representations such as knowledge graphs are central to autonomous agents and other long-lived systems. However, most existing approaches model time as discrete metadata, either sorting by recency (burying old-…
arXiv:2608.25553v1 Announce Type: cross Abstract: An agent that inherits a consolidated memory may inherit a constraint that was true when written and has since been withdrawn by a newer authoritative record. Under a scarce verification budget, does the agent recover the withdraw…
An agent that inherits a consolidated memory may inherit a constraint that was true when written and has since been withdrawn by a newer authoritative record. Under a scarce verification budget, does the agent recover the withdrawal, and if not, is the error avoidable without spe…
An agent that inherits a consolidated memory may inherit a constraint that was true when written and has since been withdrawn by a newer authoritative record. Under a scarce verification budget, does the agent recover the withdrawal, and if not, is the resulting stale-consistent …
arXiv:2608.24876v1 Announce Type: new Abstract: Recursive self-improvement (RSI) remains hard in long-horizon tasks, where growing histories obscure the task state and misalign skill invocation. We introduce Recuris, a recursive Experiential-Working Memory architecture for long-h…
Recursive self-improvement (RSI) remains hard in long-horizon tasks, where growing histories obscure the task state and misalign skill invocation. We introduce Recuris, a recursive Experiential-Working Memory architecture for long-horizon agent harnesses, in which Working Memory …
arXiv cs.AI
TIER_1English(EN)·Qi Feng, Chris Ding, Jicong Fan·
arXiv:2608.22767v1 Announce Type: new Abstract: Long-term language-model agents accumulate memories across interactions, but their retrievers typically do not accumulate retrieval experience. Semantic retrieval is efficient, but embedding similarity does not always reflect whethe…
arXiv cs.CL
TIER_1English(EN)·Zihan Lin, Zhenyu Chen, Jiawen Wei, Xiaohan Wang, Jie Cao, Jiajun Chai, Wei Lin, Guojun Yin, Ran He·
arXiv:2608.22339v1 Announce Type: new Abstract: Extracting skills from past successes is critical for the efficient evolution of Large Language Model (LLM) agents. Prevailing agent self-evolution paradigms typically rely on a core assumption: equipping LLMs with skill memories de…
arXiv cs.CL
TIER_1English(EN)·Wenzhi Li, Dong Nie, Rui Lan, Tongtong Lyu, Peiyao Wang, Lingzi Hong, Weihang Pan, Boyuan Pan, Yao Hu·
arXiv:2608.22215v1 Announce Type: new Abstract: Large language model (LLM) agents operate in dynamic environments where knowledge continuously evolves. Existing memory systems typically treat external memory as a monotonically growing repository, inevitably leading to retrieval d…
arXiv:2501.13200v2 Announce Type: replace-cross Abstract: Coordination in decentralized multi-agent reinforcement learning (MARL) necessitates that agents share information about their behavior and intentions. Existing approaches rely on communication protocols with domain or res…
arXiv:2608.23471v1 Announce Type: cross Abstract: Memory is becoming a default subsystem in deployed LLM agents to provide persistent personalization and continuity. This naturally prompts a question: will memory system introduce new vulnerabilities into agents? Thus we propose I…
arXiv cs.AI
TIER_1English(EN)·Saber Zerhoudi, Jelena Mitrovic, Michael Granitzer·
arXiv:2608.22752v1 Announce Type: new Abstract: A safety rule and an episodic log compete for the same tokens in an AI agent's context. When the budget overflows, both are summarized at the same rate; only the rule needs exact wording to remain enforceable. On 20 production agent…
arXiv:2608.22310v1 Announce Type: new Abstract: Long-term memory is crucial for personalized responses and long-horizon agent interactions. Existing methods often rely on LLMs to compress or rewrite dialogue histories and use the transformed memories as retrieval evidence. Despit…
arXiv:2608.21867v1 Announce Type: new Abstract: LLM agents are moving from single-prompt use to long task streams in which reusable memory becomes a core capability for terminal, software-engineering, and web tasks. Such memory is useful only when stored experience remains reliab…
arXiv cs.AI
TIER_1English(EN)·Yu Qian, Hong Miao, Boyang Guo, Tingyi Jiang, Shan Zhao, Tianxing Le, Lintian Li, Meng Liu·
arXiv:2608.21755v1 Announce Type: new Abstract: Long-horizon agents need memory that identifies relevant experience, resolves revisions, and exposes checkable provenance. We present ECHO (Embodied Context and History Orchestration), an auditable memory architecture and service pr…
Recuris introduces a recursive memory architecture that tracks progress and guides skill selection to improve long-horizon agent success through localized, validation-gated updates.
Memory is becoming a default subsystem in deployed LLM agents to provide persistent personalization and continuity. This naturally prompts a question: will memory system introduce new vulnerabilities into agents? Thus we propose InjecMEM, a novel memory injection attack paradigm …
arXiv:2608.20342v1 Announce Type: new Abstract: Large language model (LLM) coding agents start each session with an empty context window, discarding accumulated knowledge from prior work. We present PrimeAgentOrchestrator (PAO), a system that spawns new instances of Claude Code -…
arXiv:2608.21230v1 Announce Type: cross Abstract: Persistent memory makes false information durable: once a false statement is stored, it can be retrieved into future sessions that match it. We measure the cost of this failure mode using plainly worded false assertions generated …
arXiv:2608.20664v1 Announce Type: new Abstract: DreamBench-SWE is a multi-session benchmark for software-agent memory hygiene in which later software tasks depend on non-inferable evidence from earlier sessions and are scored by executable hidden oracles. We report the original s…
A safety rule and an episodic log compete for the same tokens in an AI agent's context. When the budget overflows, both are summarized at the same rate; only the rule needs exact wording to remain enforceable. On 20 production agent configurations, Claude Code's /compact prompt o…
arXiv:2608.19564v1 Announce Type: new Abstract: Persistent memory can personalize an LLM agent, but an incorrect durable update can silently distort future behavior. We study the memory-clarification boundary: whether interaction-derived information should be persisted, used only…
arXiv:2608.19701v1 Announce Type: new Abstract: Long-term multi-agent systems continuously accumulate the memories produced by different agents. Existing memory methods typically treat retrieved memories as independent evidence and combine them through voting or weighting. Howeve…
arXiv:2608.19652v1 Announce Type: new Abstract: As LLM-based agents are deployed for longer and higher-stakes tasks, their memory systems continue to have crucial gaps. While existing memory benchmarks focus largely on recall-shaped tasks, we argue an effective memory system must…
DreamBench-SWE is a multi-session benchmark for software-agent memory hygiene in which later software tasks depend on non-inferable evidence from earlier sessions and are scored by executable hidden oracles. We report the original scaled v2 fold and a separately preregistered v2.…
Long-term multi-agent systems continuously accumulate the memories produced by different agents. Existing memory methods typically treat retrieved memories as independent evidence and combine them through voting or weighting. However, this independence assumption often fails in m…
arXiv:2608.18177v1 Announce Type: new Abstract: Continual learning has traditionally treated forgetting as a failure, emphasizing preservation of previously acquired knowledge as environments evolve. We argue that this objective is incomplete for enterprise AI agents operating in…
arXiv:2608.17148v1 Announce Type: cross Abstract: A personal language agent learns a fact from one audience and may later place it in the prompt it assembles for another. This memory-to-context step is an attack surface: ambiguous or inconsistent channels, cross-audience prying, …
arXiv:2608.17756v1 Announce Type: new Abstract: Memory is a key capability of LLM agents. Persistent memory extends this across sessions---enabling recall, revision, and personalization. Yet its multi-stage pipeline (ingestion, retrieval, filtering, generation) makes failures dif…
Memory is a key capability of LLM agents. Persistent memory extends this across sessions---enabling recall, revision, and personalization. Yet its multi-stage pipeline (ingestion, retrieval, filtering, generation) makes failures difficult to localize: end-to-end evaluation reveal…
arXiv:2608.16168v1 Announce Type: cross Abstract: Large language model (LLM) agents increasingly use external memory systems to support personalization by drawing on long and evolving interaction histories, in which user preferences may be distributed across time, change with con…
arXiv cs.AI
TIER_1English(EN)·Lauri Lov\'en, Jaakko Sauvola, Jukka Riekki, Sasu Tarkoma·
arXiv:2608.16357v1 Announce Type: cross Abstract: Autonomous agents share a transport and can call each other's tools, but they cannot share what they know: no protocol lets two agents' memories reconcile a fact phrased two ways, link related facts held apart, or reconcile contra…
arXiv cs.CL
TIER_1English(EN)·Wei-Chieh Huang, Weizhi Zhang, Yuchen Wu, Yankai Chen, Eric Hanchen Jiang, Wooseong Yang, Yiwei Yang, Henry Peng Zou, Hanrong Zhang, Ying Nian Wu, Haolun Wu, Kai-Wei Chang, Philip S. Yu, Xue Liu, Aylin Caliskan·
arXiv:2608.15008v1 Announce Type: new Abstract: Memory is becoming core infrastructure for long-horizon LLM agents, yet existing evaluations offer limited guidance on which memory substrate, namely the underlying medium in which memory is represented and stored, should be used un…
Continual learning has traditionally treated forgetting as a failure, emphasizing preservation of previously acquired knowledge as environments evolve. We argue that this objective is incomplete for enterprise AI agents operating in non-stationary environments, where customers, p…
Agent Skills can specify procedural and resource obligations for tool use, and language models instantiate them as concrete programs. However, when models turn this guidance into code for existing tool interfaces, even a semantically correct program may load an entire input and e…
Autonomous agents share a transport and can call each other's tools, but they cannot share what they know: no protocol lets two agents' memories reconcile a fact phrased two ways, link related facts held apart, or reconcile contradictory knowledge without silently discarding eith…
arXiv:2608.13921v1 Announce Type: new Abstract: LLM agents increasingly maintain personal memory across sessions, but it can conflict. Preferences depend on context, behavior evolves, and sources can conflict. When a query lacks context, time, or source authority to interpret con…
arXiv:2608.13662v1 Announce Type: new Abstract: Coding agents have become the primary means of generating new code in many software projects, and the resulting velocity of changes makes keeping track of the reasons behind those changes challenging. This paper introduces MOOSEDev,…
In this paper, we analyze the reasoning trajectories of a variety of DRAs and show that existing agents often suffer from reasoning stagnation: the majority of iterations contribute little or no improvement to final performance, while agents lack awareness of their trajectories a…
arXiv:2608.12365v1 Announce Type: cross Abstract: For fifty years, data systems have answered two questions. The relational model asked which records match a predicate; the vector model asked which vectors lie nearest a query. Neither was built for cue-driven, provenance-weighted…
arXiv:2608.13334v1 Announce Type: new Abstract: LLM-based agents increasingly rely on external memory to support long-horizon reasoning and interaction. However, the main bottleneck is not simply storing past experience, but recovering the right set of evidence when relevant info…
arXiv:2608.12990v1 Announce Type: new Abstract: Long-horizon LLM agents must preserve information from past interactions to support future tasks. Existing memory systems typically rely on eager consolidation, invoking LLMs after each interaction to extract, summarize, or update m…
arXiv:2608.12888v1 Announce Type: new Abstract: Agent-memory systems increasingly buy retrieval quality with structure, transforming raw conversation histories into summaries, embeddings, trees, or knowledge graphs before any question is asked. We ask how much of that benefit com…
arXiv cs.AI
TIER_1English(EN)·Aimilios Hadjiliasi, Louis Nisiotis·
arXiv:2608.13420v1 Announce Type: new Abstract: Embodied intelligent virtual agents are expected to operate as persistent, adaptive, and context-aware entities within complex virtual and Metaverse worlds. However, implementing cognitively capable agents in such environments is co…
arXiv:2608.12743v1 Announce Type: new Abstract: Spatial intelligence is becoming a foundation for embodied agents, robotic planning, and multimodal assistants. To improve the spatial reasoning ability of VLM agents, existing work has mainly followed two lines. One line uses post-…
arXiv:2608.12476v1 Announce Type: new Abstract: Long-term agent memory is usually treated as select--store--retrieve, but retrieval does not decide whether contradictory, superseded, retracted, deleted, or stale records may support an outgoing claim. We introduce Governed Persist…
arXiv cs.AI
TIER_1English(EN)·Kaichao Liang, Yuqi Cui, Hao Kong, Xinyuan Huang, Guohaotian Hou, Qingcan Kang, Liang Chen, Yiyang Yin, Ke Ye, Jiaquan Guo, Da Chen, Lingan Zeng, Yixing Peng, Rong Yao, Shixiong Kai, Mingxuan Yuan·
arXiv:2608.12428v1 Announce Type: new Abstract: Memory is a core component of AI agents, enabling them to accumulate experience, maintain personalization, and adapt over long-term interactions. However, existing memory systems often remain fixed after development, limiting their …
LLM agents increasingly maintain personal memory across sessions, but it can conflict. Preferences depend on context, behavior evolves, and sources can conflict. When a query lacks context, time, or source authority to interpret conflict, treating one memory as definitive convert…
arXiv:2608.11632v1 Announce Type: cross Abstract: Persistent AI agents accumulate versioned state across long horizons, but storage retention alone does not identify authoritative state. Without an explicit control plane, unmediated updates by models, tools, and background worker…
arXiv cs.AI
TIER_1English(EN)·Siyu Liu, Bo Hu, Beilin Ye, He Cao, David J. Srolovitz, Tongqi Wen·
arXiv:2608.11224v1 Announce Type: new Abstract: Materials research advances through accumulated experience - scripts that work, protocols that are trusted, warnings attached to failed calculations or experiments, and judgement that links a new question to an old result. This expe…
arXiv:2608.11248v1 Announce Type: new Abstract: Long-term memory is essential for language agents operating across extended interactions and evolving tasks. Existing memory-augmented agents mainly focus on storing and retrieving past experience, but the quality of stored memories…
arXiv:2608.11654v1 Announce Type: new Abstract: Despite the wide deployment of memory in large-model agents, there is no unified formal account of what a memory is or when it is optimal. This paper takes a first step toward this account. The central idea is that memory is a basis…
arXiv:2608.11879v1 Announce Type: new Abstract: Long-running conversational agents increasingly rely on a memory system to avoid resending the whole conversation each turn, yet how much that costs to serve has received little systematic benchmarking. We compare three memory syste…
A frozen vision-language model improves spatial reasoning by self-evolving through verified experience, reflection, and reusable memory retrieval without parameter updates or external tools.
LycheeMemory V2 improves long-term agent memory by batching interactions into semantic segments for efficient consolidation and structured retrieval, reducing construction costs while maintaining high accuracy.
Memory is a core component of AI agents, enabling them to accumulate experience, maintain personalization, and adapt over long-term interactions. However, existing memory systems often remain fixed after development, limiting their ability to adapt their memory models, organizati…
Long-running conversational agents increasingly rely on a memory system to avoid resending the whole conversation each turn, yet how much that costs to serve has received little systematic benchmarking. We compare three memory systems (Mem0, Hindsight, and Mastra Observational Me…
Despite the wide deployment of memory in large-model agents, there is no unified formal account of what a memory is or when it is optimal. This paper takes a first step toward this account. The central idea is that memory is a basis, knowledge is its span, and answerability is a …
Persistent AI agents accumulate versioned state across long horizons, but storage retention alone does not identify authoritative state. Without an explicit control plane, unmediated updates by models, tools, and background workers risk stale overwrites, un-audited exposures, and…
arXiv:2608.11095v1 Announce Type: new Abstract: Agentic coding READMEs like CLAUDE.md grow without bound in real repositories, stopping only when the repository retires or someone rewrites the file wholesale. We trace this to imperfect recall: appending an instruction is always c…
arXiv cs.AI
TIER_1English(EN)·Yin Xiaolong, Liu Yu, Shen Jiahang, Lu Xingyu, Ni Jingzhe, Fan Fengxiao, Sang Fan·
arXiv:2605.19748v2 Announce Type: replace Abstract: Automatic generation of computer-aided design (CAD) models is a core technology for enabling intelligence in advanced manufacturing. Existing generation methods based on large language models (LLMs) often fall short when handlin…
arXiv:2608.10676v1 Announce Type: new Abstract: Large language model (LLM)-based search agents answer questions through multi-step interactions with external environments. However, providing complete execution trajectories to the LLM causes unbounded context growth and introduces…
arXiv:2608.10502v1 Announce Type: new Abstract: Persistent memory lets language-model agents reuse information across sessions, but it also makes errors durable: a poisoned, stale, or misattributed record can alter reasoning, tool use, answers, and subsequent memory writes. Exist…
arXiv:2608.10108v1 Announce Type: new Abstract: Long-horizon agents accumulate trajectories spanning hundreds of interleaved reasoning, action, and observation steps, where answering a query may depend on evidence buried far back in the history. External memory stores such trajec…
Agentic coding READMEs like CLAUDE.md grow without bound in real repositories, stopping only when the repository retires or someone rewrites the file wholesale. We trace this to imperfect recall: appending an instruction is always cheap, but once an instruction's rationale is gon…
Large language model (LLM)-based search agents answer questions through multi-step interactions with external environments. However, providing complete execution trajectories to the LLM causes unbounded context growth and introduces noise. Existing compression methods reduce cont…
arXiv:2608.09184v1 Announce Type: new Abstract: Large language model (LLM) agents provide a promising interface for command-line-based network operations, but a plausible command may still fail or introduce operational risk after execution. Existing approaches mainly focus on com…
arXiv:2608.08253v1 Announce Type: new Abstract: AI agents are becoming shared infrastructure, yet durable memory is commonly assembled from separate retrieval, governance, and operational components. We present SuperLocalMemory 4.0, a governed, local-first memory operating system…
arXiv cs.AI
TIER_1English(EN)·Heng Zhou, Lian Zhang, Yutao Fan, Tiancheng He, Siki Chen, Hejia Geng, Philip Torr, Zhenfei Yin·
arXiv:2608.08236v1 Announce Type: new Abstract: Multi-agent LLM systems often fail not for lack of candidate answers, but because they have no persistent mechanism for deciding which incompatible claim should currently be trusted. Majority vote, debate, and judge-based selection …
arXiv:2608.08055v1 Announce Type: new Abstract: Large language model (LLM) agents that assist users over weeks of conversation must remember what is currently true, not merely what was once said. Flat RAG diaries and Markdown logs optimize needle retrieval but under-serve currenc…
arXiv cs.AI
TIER_1English(EN)·Ao Ding, Hongzong LI, Shiqin Tang, Li Zhang, Liang Chen, Xuyang Chen, Zi Liang·
arXiv:2608.07622v1 Announce Type: new Abstract: Long-term memory enables AI agents to maintain continuity across sessions, personalize behavior, and evolve through accumulated experience. Yet memory evolution is not simply a process of storing more information: new experiences ma…
arXiv:2608.07429v1 Announce Type: new Abstract: Long-term memory enables language agents to reuse past facts, preferences, and task experience. Persistence also creates a central falsifiability problem: when the world changes, stale memories can remain retrievable and pollute the…
arXiv:2608.06503v1 Announce Type: new Abstract: Recurrent context compression controls context growth in long-horizon agents, but its behavioral effects remain poorly understood. In this preliminary empirical study, we show that compression can weaken the influence of recent inte…
arXiv:2608.06811v1 Announce Type: cross Abstract: Resolving a real software issue with a large language model (LLM) agent is a long repair episode, often tens to hundreds of steps spanning exploration, hypothesis, implementation, and verification. Success depends on both the base…
arXiv:2608.07438v1 Announce Type: new Abstract: Human-like cognition does not select past experience by topical similarity alone: affective significance and unresolved conflict also shape what becomes accessible. We present PsychoAgent, a cognitive architecture for LLM agents tha…
arXiv cs.AI
TIER_1English(EN)·Taeil Kim, Kangsan Kim, Sung Ju Hwang·
arXiv:2608.07169v1 Announce Type: new Abstract: Memory systems have shown promise for improving agent performance, but their potential remains largely unexplored for small language models, which struggle to generate sufficient successful trajectories on their own. We propose Agen…
arXiv:2608.07068v1 Announce Type: new Abstract: Long-horizon agents accumulate growing contexts during interaction, impairing performance and stability. Compact memory mitigates this problem by compressing and rewriting the history retained between model invocations. Learning wha…
arXiv:2608.06745v1 Announce Type: new Abstract: Long-horizon agents rely on memory to reuse experiences, yet existing memory systems often assume that evidence can be directly consumed through a fixed representation. This leads to representation mismatch, where relevant informati…
Memory for LLM agents has converged on a single architectural pattern: store experience as text, embeddings, reflections, or rules; retrieve at inference time; let a general-purpose orchestrator interpret what to do. This paper argues that the pattern is the wrong default for per…
AI agents are becoming shared infrastructure, yet durable memory is commonly assembled from separate retrieval, governance, and operational components. We present SuperLocalMemory 4.0, a governed, local-first memory operating system for AI agents. The system combines dense semant…
Long-term memory enables AI agents to maintain continuity across sessions, personalize behavior, and evolve through accumulated experience. Yet memory evolution is not simply a process of storing more information: new experiences may reinforce, revise, or interfere with existing …
arXiv cs.CL
TIER_1English(EN)·Khang Nhat Hoang Vo, Tam Minh Chu, Anh Trac Duc Dinh, Thuyen Vinh Ha Bui, Tho Quan·
arXiv:2608.05906v1 Announce Type: new Abstract: LLM agents that repair failures often discard successful corrections, forcing later episodes to rediscover similar solutions. We study whether finalized repair outcomes can improve subsequent Text-to-SQL episodes without parameter u…
arXiv:2608.05784v1 Announce Type: new Abstract: Computer-use agents pay full frontier inference to re-derive routines their user has already performed, because an agent's memory today records what the user said, not what the user did. We compile passively captured screen activity…
Memory systems have shown promise for improving agent performance, but their potential remains largely unexplored for small language models, which struggle to generate sufficient successful trajectories on their own. We propose Agent Memory Distillation (AMD), a training-free fra…
arXiv:2608.04574v1 Announce Type: new Abstract: Memory-augmented VLM agents act on persistent spatial knowledge, yet that knowledge silently goes stale as the environment changes. We ask what happens when an agent must reconcile a confident memory claim with a contradicting obser…
arXiv:2602.06052v4 Announce Type: replace-cross Abstract: Research in artificial intelligence is shifting from model innovations and benchmark scores towards problem definition and rigorous real-world evaluation. As the field enters the "second half," the central challenge become…
arXiv cs.AI
TIER_1English(EN)·Hwai-Jung Hsu, Cheng-Jan Chi, Hanna Everett·
arXiv:2608.04278v1 Announce Type: cross Abstract: Coding agents increasingly work across sessions, but prose notes can preserve a conclusion without the program state that supported it. After an upstream change, a repository may still build even though earlier verification claims…
arXiv:2608.05095v1 Announce Type: new Abstract: Agents for long term reasoning require a memory that can be efficiently and effectively updated over time, as new facts and external feedback continue to arrive. Recently, graph memory has been adopted to offer structural organizati…
arXiv cs.AI
TIER_1English(EN)·Mayur Akewar, Ravi Ranjan·
arXiv:2608.04289v1 Announce Type: new Abstract: Long-horizon agents increasingly use persistent memory and tools to take actions with external side effects. A central failure mode is premature commitment: an agent acts before resolving whether its memory grounding is stale, confl…
arXiv cs.AI
TIER_1English(EN)·Ben Wang, Kang Zhou, Lifan Guo, Feng Chen, Chi Zhang·
arXiv:2608.04095v1 Announce Type: new Abstract: Large language model (LLM) agents are increasingly used as personalized assistants in high-stakes domains such as financial advising, yet it remains unclear whether they can maintain and update an individualized user model over long…
arXiv:2608.04746v1 Announce Type: new Abstract: LLM agents that persist across sessions accumulate stored memories whose validity varies enormously by content type, yet existing memory architectures treat all memories as equally persistent and systematically contaminate retrieved…
Computer-use agents pay full frontier inference to re-derive routines their user has already performed, because an agent's memory today records what the user said, not what the user did. We compile passively captured screen activity into agent memory with a deterministic, zero-mo…
Agents for long term reasoning require a memory that can be efficiently and effectively updated over time, as new facts and external feedback continue to arrive. Recently, graph memory has been adopted to offer structural organization for multi-hop retrieval and reasoning. Howeve…
Long-horizon LLM agents require memory systems that recover useful evidence from large interaction histories without passing excessive context to downstream models. Existing memory pipelines often rely on hand-crafted heuristics and repeated LLM calls, which can introduce redunda…
LLM agents that persist across sessions accumulate stored memories whose validity varies enormously by content type, yet existing memory architectures treat all memories as equally persistent and systematically contaminate retrieved context with outdated facts. We show that per-m…
LLM agents that persist across sessions accumulate stored memories whose validity varies enormously by content type, yet existing memory architectures treat all memories as equally persistent and systematically contaminate retrieved context with outdated facts. We show that per-m…
arXiv:2608.03699v1 Announce Type: new Abstract: Persistent memory helps long-term agents retain knowledge, yet a single update error can repeatedly distort future retrieval and reasoning. Most existing systems reduce memory updating to a binary Write/Hold decision, which cannot d…
arXiv:2608.03130v1 Announce Type: cross Abstract: Long-term memory enables persistent personalization in LLM agents, but repeated memory-conditioned responses can cumulatively reveal protected attributes even when they are never stated explicitly. We formalize this threat as adap…
arXiv:2604.18933v2 Announce Type: replace-cross Abstract: Robotic manipulation tasks exhibit varying memory requirements, ranging from Markovian tasks that require no memory to non-Markovian tasks that demand in-context memorization of historical information within a single trial…
arXiv:2608.02843v1 Announce Type: cross Abstract: Persistent agent memory must adapt as later outcomes change earlier evidence, yet mutable retrieval weights create an attribution problem: reviewers must distinguish authorized adaptation from database tampering. We present MutMem…
arXiv cs.AI
TIER_1English(EN)·Yuxin Liao, Le Wu, Min Hou, Hao Liu, Han Wu, Zishu Wang·
arXiv:2608.03463v1 Announce Type: new Abstract: Long-term memory is essential for LLM-based agents to sustain interactions and reliably leverage distant history. However, existing memory systems typically process heterogeneous dialogue content through a uniform summarization and …
arXiv cs.AI
TIER_1English(EN)·Jakub Rada (AI Center, Department of Computer Science, Faculty of Electrical Engineering, Czech Technical University in Prague), Viliam Lis\'y (AI Center, Department of Computer Science, Faculty of Electrical Engineering, Czech Technical University in Pr…·
arXiv:2608.03420v1 Announce Type: new Abstract: Large language models have improved substantially on single-shot reasoning tasks, but their performance in sequential decision-making is less well understood. We study this on fully-observable two-player zero-sum games, which provid…
arXiv:2608.03137v1 Announce Type: new Abstract: Large language model (LLM) agents must retain reusable information, control a bounded active context, and recover earlier evidence during long-horizon interaction. Existing methods commonly optimize long-term memory (LTM) and short-…
Memory-augmented VLM agents act on persistent spatial knowledge, yet that knowledge silently goes stale as the environment changes. We ask what happens when an agent must reconcile a confident memory claim with a contradicting observation, and whether current models can catch the…
arXiv:2608.00007v1 Announce Type: new Abstract: Equipping Large Language Models (LLMs) with human-like personas is crucial for agentic applications, such as role-play and user simulation. Traditional prompt-based methods rely on descriptive conditioning by injecting static textua…
arXiv:2608.00009v1 Announce Type: new Abstract: Long-term memory remains a critical bottleneck for conversational AI agents, whose finite context windows cannot support coherent recall across thousands of turns. We present AgentMemBench, a unified, reproducible benchmark evaluati…
arXiv:2608.01543v1 Announce Type: cross Abstract: Interaction between users and LLM agents is increasingly multimodal: conversations interleave text with images, and a later question may target either. Yet most agent memories are designed around text, and even the few that suppor…
arXiv:2608.01833v1 Announce Type: cross Abstract: Grokking is a striking phenomenon in neural network training, where a model can undergo a prolonged period of pure memorization before abrupt generalization. While previous works have attempted to interpret it through classical ma…
arXiv cs.LG
TIER_1English(EN)·Yidan Lin, Kaixiang Wang, Jiong Lou, Jie Li·
arXiv:2608.01285v1 Announce Type: new Abstract: The continued development of LLMs toward persistent and adaptive intelligence increasingly requires long-term memory mechanisms that preserve and reuse information across interactions. Existing memory systems either compress and str…
arXiv:2608.01742v1 Announce Type: cross Abstract: Long-term memory is critical for LLM agents operating over long-horizon interactions. However, several persistent limitations of existing memory systems can be traced to two recurring misalignment patterns in long-term interaction…
arXiv:2608.02508v1 Announce Type: cross Abstract: Learning-based memory systems for self-evolving LLM agents face two tightly coupled challenges. First, trajectory-indexed utilities grow with the interaction history, thereby dispersing limited feedback over an ever-expanding stat…
Learning-based memory systems for self-evolving LLM agents face two tightly coupled challenges. First, trajectory-indexed utilities grow with the interaction history, thereby dispersing limited feedback over an ever-expanding state space. Second, because trajectory-level rewards …
As memories accumulate across tasks and sessions, the performance of long-term LLM agents depends jointly on query-specific retrieval and continual memory refinement. However, existing methods typically optimize either memory access, through iterative query refinement or adaptive…
arXiv:2607.29377v1 Announce Type: new Abstract: LLM agents need memory to act consistently over long interactions, yet many systems use additional LLM calls to operate that memory. Generating intermediate records and mediating their retrieval adds recurring token and time costs, …
arXiv:2607.29167v1 Announce Type: cross Abstract: Long-term memory lets large language model(LLM) agents reuse prior preferences and work flows, but it also turns untrusted observations into persistent action context. We identify memory provenance laundering: during LLM-based mem…
arXiv cs.AI
TIER_1English(EN)·Zhoujin Tian, Yao Tian, Hao Zhang, Cheng Chen, Yakun Li, Lei Zhang, Xiaofang Zhou·
arXiv:2607.29440v1 Announce Type: new Abstract: Long-term multimodal memory must support not only retrieving relevant information but also computing over observations accumulated across interactions. Existing systems largely emphasize \emph{retrieval memory}, organizing interacti…
Interaction between users and LLM agents is increasingly multimodal: conversations interleave text with images, and a later question may target either. Yet most agent memories are designed around text, and even the few that support multimodal conversations still fail on vision-re…
LLM-based multi-agent systems (MAS) increasingly rely on persistent private and shared memories for long-horizon coordination. This memory layer improves continuity, but it also gives attackers a durable channel: a poisoned memory can be written once, continuously retrieved in la…
arXiv:2607.27834v1 Announce Type: cross Abstract: Persistent memory lets long-running large language model agents reuse information across sessions and tasks. Yet errors in writable memory can persist and corrupt future behavior. Existing systems improve storage and retrieval, bu…
arXiv cs.AI
TIER_1English(EN)·Changyu Du, Alexander Vosseler, Filippo Mazza, Andr\'e Borrmann·
arXiv:2607.26072v1 Announce Type: cross Abstract: Long-term memory is becoming a core capability of LLM-based agents, but existing evaluations largely test conversational recall in open-domain or persona-grounded settings. We argue that a stronger test is whether an agent can reu…
arXiv:2607.26520v1 Announce Type: cross Abstract: Conversational AI agents commonly lack persistent memory across sessions. The obvious fixes like injecting full chat histories into the context window, or delegating to a third-party memory service, either exhaust the model's cont…
arXiv:2607.27080v1 Announce Type: cross Abstract: Memory systems allow agents to retain and reuse information from past interactions, but they can also let malicious content persist. A malicious instruction crafted by an attacker may be stored in long-term memory, recalled much l…
arXiv cs.CL
TIER_1English(EN)·Yongye Su, Wujiang Xu, Chaoji Zuo, Elisa Bertino·
arXiv:2607.27773v1 Announce Type: new Abstract: LLM agents increasingly rely on long-term memory to support multi-session interaction and personalization. However, existing agent memory systems are designed around forward-only evolution, continuously accumulating, consolidating, …
arXiv:2607.27919v1 Announce Type: new Abstract: Decoder-only language models entangle long-term memory and reasoning in a single parameter set, making it difficult to scale memory capacity independently. Memory Decoder introduces a parametric long-term memory module but only stud…
arXiv:2607.28156v1 Announce Type: new Abstract: Existing multimodal long-term memory agents use external memory to overcome the limited context available for long videos. However, most methods emphasize what to store rather than how stored memory should be retrieved. When retriev…
LLM agents need memory to act consistently over long interactions, yet many systems use additional LLM calls to operate that memory. Generating intermediate records and mediating their retrieval adds recurring token and time costs, while omitted or merged details can obscure the …
Memory is central to long-horizon LLM agents, yet existing memory systems primarily preserve interaction content rather than modeling which agents can be trusted and under what conditions. This limitation is particularly important in multi-agent systems, where a central model may…
Decoder-only language models entangle long-term memory and reasoning in a single parameter set, making it difficult to scale memory capacity independently. Memory Decoder introduces a parametric long-term memory module but only studies it at a relatively small scale. In this work…
LLM agents increasingly rely on long-term memory to support multi-session interaction and personalization. However, existing agent memory systems are designed around forward-only evolution, continuously accumulating, consolidating, and overwriting knowledge, with no principled me…
arXiv:2607.26637v1 Announce Type: new Abstract: Deployed LLM agents increasingly keep their long-term memory as a filesystem: a directory tree of markdown files that the agent itself reads, writes, and reorganizes through generic file tools. Yet research has largely passed over t…
arXiv:2607.26760v1 Announce Type: new Abstract: Recent advances in AI agents have increasingly internalized native capabilities into their underlying foundation models, giving rise to multimodal foundation models and large reasoning models. However, agent memory is still primaril…
arXiv cs.CL
TIER_1English(EN)·Chao-Han Huck Yang, Zih-Ching Chen, Piotr Zelasko, Zhehuai Chen, Jagadeesh Balam, Boris Ginsburg·
arXiv:2607.26410v1 Announce Type: new Abstract: We present Voice Memory, a inference-only scheme for agentic speech recognition: at stream time, a frozen corrector reads a single per-domain memory.md and decides per utterance whether to act on the hypothesis or abstain and keep t…
Memory is central to long-horizon LLM agents, yet existing memory systems primarily preserve interaction content rather than modeling which agents can be trusted and under what conditions. This limitation is particularly important in multi-agent systems, where a central model may…
Decoder-only language models entangle long-term memory and reasoning in a single parameter set, making it difficult to scale memory capacity independently. Memory Decoder introduces a parametric long-term memory module but only studies it at a relatively small scale. In this work…
Conversational AI agents commonly lack persistent memory across sessions. The obvious fixes like injecting full chat histories into the context window, or delegating to a third-party memory service, either exhaust the model's context budget or send personal data through infrastru…
Conversational AI agents commonly lack persistent memory across sessions. The obvious fixes like injecting full chat histories into the context window, or delegating to a third-party memory service, either exhaust the model's context budget or send personal data through infrastru…
arXiv:2607.25066v1 Announce Type: new Abstract: Long-horizon LLM agents accumulate reasoning traces, actions, and tool observations that can eventually exceed a model's fixed context window. Existing compaction methods address this limitation by discarding, summarizing, or retrie…
arXiv cs.AI
TIER_1English(EN)·Priscila Saboia Moreira, Christopher R. Sweet·
arXiv:2607.24759v1 Announce Type: new Abstract: Research projects, educational efforts, and adjacent knowledge work accumulate findings, decisions, and reasoning that future collaborators rarely recover. The parts most useful to that work, including dead ends and walked-back clai…
arXiv:2607.24772v1 Announce Type: new Abstract: Geoscience research requires complex analysis and domain expertise, with remote sensing (RS) observations as a key foundation. However, existing RS agents built on general-purpose LLMs remain largely domain-agnostic, resulting in br…
arXiv:2607.25992v1 Announce Type: cross Abstract: Recently, memory management has become a key infrastructure for LLM-based agents, as it directly affects long-horizon reasoning, personalized responses, and knowledge reuse. However, existing LLM memory systems typically adopt a c…
We present Voice Memory, a inference-only scheme for agentic speech recognition: at stream time, a frozen corrector reads a single per-domain memory.md and decides per utterance whether to act on the hypothesis or abstain and keep the 1-best. Asynchronously, a score-gated optimiz…
Deployed LLM agents increasingly keep their long-term memory as a filesystem: a directory tree of markdown files that the agent itself reads, writes, and reorganizes through generic file tools. Yet research has largely passed over this medium: prior systems design bespoke memory …
We present Voice Memory, a inference-only scheme for agentic speech recognition: at stream time, a frozen corrector reads a single per-domain memory.md and decides per utterance whether to act on the hypothesis or abstain and keep the 1-best. Asynchronously, a score-gated optimiz…
Recent advances in AI agents have increasingly internalized native capabilities into their underlying foundation models, giving rise to multimodal foundation models and large reasoning models. However, agent memory is still primarily implemented through external modules, leaving …
arXiv cs.CL
TIER_1English(EN)·Ruizhe Li, Mingxuan Du, Benfeng Xu, Zhendong Mao·
arXiv:2607.24368v1 Announce Type: new Abstract: Long-term memory systems store what a user says in an external store and retrieve it when a related query arrives. This interface rests on an assumption so natural that it is rarely stated: a memory that is needed will resemble the …
arXiv:2607.24097v1 Announce Type: new Abstract: Memory-augmented LLM agents typically answer queries by retrieving relevant memories and feeding them directly to an answer model. This retrieval-as-evidence paradigm assumes retrieved memories are already suitable for reasoning, le…
arXiv:2607.23929v1 Announce Type: new Abstract: LLM agents increasingly coordinate through persistent shared memory: one agent's write becomes another agent's premise, and eventually a tool call with real side effects. Current agent memory systems treat every accepted write as im…
arXiv:2607.22690v1 Announce Type: new Abstract: Long-term memory lets LLM agents reuse past interactions, but raw dialogue histories are verbose and information-sparse. Retrieving broadly improves evidence coverage yet overwhelms downstream reasoning with noise; compressing at wr…
arXiv:2607.22562v1 Announce Type: new Abstract: Managing long-context dependencies remains a primary bottleneck in LLM agents, as redundant and irrelevant information can degrade multi-step reasoning. Strategic Forgetting for Agent Memory Systems (SF-AMS) is proposed as a framewo…
arXiv:2607.21962v1 Announce Type: new Abstract: Benchmarks for LLM-agent memory typically generate conversations first and extract answer keys afterwards -- with documented label-error and contamination problems -- and they overwhelmingly measure short interaction histories. We i…
arXiv:2601.08160v2 Announce Type: replace Abstract: Agentic memory systems have become critical for enabling LLM agents to maintain long-term context and retrieve relevant information efficiently. However, existing memory frameworks often perform query-agnostic retrieval over the…
Long-term memory systems store what a user says in an external store and retrieve it when a related query arrives. This interface rests on an assumption so natural that it is rarely stated: a memory that is needed will resemble the query that needs it. World knowledge breaks the …
arXiv:2607.20972v1 Announce Type: new Abstract: Coding agents ship with one kind of memory: documents. Instruction files, plan artifacts, and auto-written memory directories are deliberately authored and deliberately retrieved: the agent must choose to write them and choose to re…
arXiv cs.CL
TIER_1English(EN)·Chengfeng Zhao, Jinhui Chen, Sirui Liang, Shizhu He, Yequan Wang, Jun Zhao, Kang Liu·
arXiv:2607.21404v1 Announce Type: new Abstract: While memory systems are essential for agent architectures, pervasive architectural fragmentation restricts systematic research. Existing implementations typically couple different stages of the memory lifecycle, entangle evaluation…
arXiv:2511.12997v2 Announce Type: replace Abstract: Multimodal LLM-powered agents have recently demonstrated impressive capabilities in web navigation, enabling agents to complete complex browsing tasks across diverse domains. However, current agents struggle with repetitive erro…
arXiv:2607.20458v1 Announce Type: cross Abstract: Large language model (LLM) agents operating over extended dialogues accumulate vast amounts of information, yet existing memory systems either retain everything indiscriminately or apply uniform forgetting heuristics that fail to …
arXiv:2607.21503v1 Announce Type: new Abstract: Production AI agents' failures are less often due to an inability to reason well and more often because they cannot manage what is in their reasoning context: conversation histories, large prompts, large tool definitions, and balloo…
arXiv:2607.21106v1 Announce Type: new Abstract: Effective memory is crucial for LLM agents, yet constructing it effectively remains challenging. A memory-construction policy decides what information to extract, store, update, compress, or discard as interactions accumulate. Heuri…
Production AI agents' failures are less often due to an inability to reason well and more often because they cannot manage what is in their reasoning context: conversation histories, large prompts, large tool definitions, and ballooning tool outputs. Agents drown in their own acc…
Production AI agents' failures are less often due to an inability to reason well and more often because they cannot manage what is in their reasoning context: conversation histories, large prompts, large tool definitions, and ballooning tool outputs. Agents drown in their own acc…
arXiv:2607.19433v1 Announce Type: new Abstract: The transition from stateless generative models in artificial intelligence to stateful, autonomous agents represents an architectural evolution that, while providing the capabilities of long-term planning and the automation of enter…
Production AI agents' failures are less often due to an inability to reason well and more often because they cannot manage what is in their reasoning context: conversation histories, large prompts, large tool definitions, and ballooning tool outputs. Agents drown in their own acc…
arXiv:2607.18975v1 Announce Type: new Abstract: Personal AI is moving beyond chat-only interaction toward continuous services that span phones, cars, homes, wearables, cameras, and tools. In this setting, memory cannot remain a cache of prior conversations. It should serve as a c…
arXiv cs.AI
TIER_1English(EN)·Joshua Tobkin, David Yang·
arXiv:2607.19096v1 Announce Type: new Abstract: Agent-memory workloads mix direct factual lookup, relation-chain and current-state reasoning, and broad synthesis over long histories. We describe Supra Cognitive Modes (SCM), an architecture that maps explicit or automatically sele…
arXiv:2607.17545v1 Announce Type: new Abstract: Language agents depend on memory across interactions. However, the limited context windows of large language models (LLMs) and their inference costs constrain how much memory can be used at once. Existing systems mainly follow two s…
arXiv:2607.16716v1 Announce Type: new Abstract: Large language models and LLM-based agents are widely used as personal chat assistants, enterprise copilots, and autonomous workflow agents. In all these applications, memory (the ability to retain, access, and reason over informati…
arXiv:2607.16211v1 Announce Type: new Abstract: LLM agents augmented with persistent memory can recall past interactions, but existing systems suffer from two limitations: flat, unstructured storage loses relational context needed for multi-hop and temporal reasoning, and relianc…
arXiv:2607.17621v1 Announce Type: new Abstract: Existing self-evolving memory systems mainly improve agent memory based on textual outputs, such as task trajectories and reflections. However, this text-based paradigm rarely incorporates internal mechanistic signals, leaving how r…
arXiv cs.LG
TIER_1English(EN)·Halima Bouzidi, Mboutidem Ekemini Mkpong, Mohammad Abdullah Al Faruque·
arXiv:2607.15657v1 Announce Type: cross Abstract: Multimodal AI agents increasingly rely on persistent long-term memory to ground generation in past visual and textual episodes. We show that unconditional trust in visual data creates a critical vulnerability. We propose Lucid, a …
arXiv:2607.15589v1 Announce Type: cross Abstract: Communication-limited robots in mission-critical scenarios such as disaster inspection and search-and-rescue must make reliable onboard decisions without access to remote operators or high-capacity reasoning services. Episodic mem…
arXiv:2607.14119v1 Announce Type: new Abstract: Multi-agent LLM systems commonly decompose complex tasks into specialized roles. However, this modularity introduces a representational risk: when intermediate agents transform text across linguistic registers, they can systematical…
arXiv:2606.22030v2 Announce Type: replace Abstract: We investigate when belief-based memory actually improves large language model (LLM) agents. Our vehicle is Nous, a long-term memory architecture that represents each entity-attribute pair as a categorical probability distributi…
arXiv cs.AI
TIER_1English(EN)·Jifeng Gao, Kang Xia, Yi Zhang, Xiaobin Hong, Mingkai Lin, Xingshen Wei, Wenzhong Li, Sanglu Lu·
arXiv:2607.14651v1 Announce Type: cross Abstract: Persistent external memory enhances agent continuity but introduces persistent security vulnerabilities: adversarial content can be injected via standard interaction channels, retained across turns, and later distort downstream be…
arXiv cs.AI
TIER_1English(EN)·Soham Gadgil, David Alexander, Sai Sunku, Franziska Roesner·
arXiv:2607.14611v1 Announce Type: cross Abstract: A growing class of agentic systems maintain persistent state across sessions through memory files, behavioral preferences, and knowledge bases. While this makes agents more useful and self-improving, it also creates a new attack s…
arXiv:2607.14512v1 Announce Type: new Abstract: Multi-step retrosynthesis planning seeks to decompose a target molecule into commercially available building blocks through a sequence of feasible reactions. The vast combinatorial search space makes this task challenging even for e…
Automated fulfillment warehouses must continuously assign and execute pickup-and-delivery work while avoiding congestion. In many-to-many Multi-Agent Pickup and Delivery (MAPD), a request specifies a stock-keeping unit rather than fixed endpoints, requiring the controller to sele…
Persistent external memory enhances agent continuity but introduces persistent security vulnerabilities: adversarial content can be injected via standard interaction channels, retained across turns, and later distort downstream behavior. To address this challenge, we propose MemP…
A growing class of agentic systems maintain persistent state across sessions through memory files, behavioral preferences, and knowledge bases. While this makes agents more useful and self-improving, it also creates a new attack surface for prompt injections in which malicious in…
arXiv:2607.13884v1 Announce Type: new Abstract: Large Language Model (LLM) agents have shown remarkable capabilities in autonomous decision-making by generating sequential trajectories of states, actions, and observations. However, in complex, long-horizon tasks, these agents fre…
arXiv:2607.13591v1 Announce Type: cross Abstract: Large Language Model (LLM) agents increasingly rely on external memory systems to accumulate experience across tasks. Yet nearly all existing approaches, from graph-structured memories to reflective insight stores, access memory t…
arXiv cs.AI
TIER_1English(EN)·Richmond Alake, Cesare Bernardis, Paul Cayet, Luca Engel, Damien Hilloulin, Sungpack Hong, Allen Hosler, Nickolas Kavantzas, Ingo Kossyk, Son Le, Rhicheek Patra, Kartik Talamadupula, Valentin Venzin·
arXiv:2607.13157v1 Announce Type: new Abstract: Agent memory is a systems problem for long-horizon agents. Practical deployments require retention of task state across extended conversations, recovery of user-specific facts and preferences across sessions, and accumulation of pro…
Multi-step retrosynthesis planning seeks to decompose a target molecule into commercially available building blocks through a sequence of feasible reactions. The vast combinatorial search space makes this task challenging even for expert chemists. Traditional methods combine tree…
Large Language Model (LLM) agents have shown remarkable capabilities in autonomous decision-making by generating sequential trajectories of states, actions, and observations. However, in complex, long-horizon tasks, these agents frequently suffer from compounding errors and strug…
Large Language Model (LLM) agents increasingly rely on external memory systems to accumulate experience across tasks. Yet nearly all existing approaches, from graph-structured memories to reflective insight stores, access memory through fixed, hand-designed heuristics. We argue t…
Large Language Model (LLM) agents increasingly rely on external memory systems to accumulate experience across tasks. Yet nearly all existing approaches, from graph-structured memories to reflective insight stores, access memory through fixed, hand-designed heuristics. We argue t…
arXiv:2607.12236v1 Announce Type: cross Abstract: Speculative execution accelerates LLM agents by using a smaller, cheaper model to predict and pre-launch the next step while the environment is idle. However, existing speculators are stateless and discard all information between …
arXiv:2607.11919v1 Announce Type: cross Abstract: Human memory is reconstructive, not a faithful recording. Current multimodal LLMs (MLLMs) lack this capability: they process images through a frozen visual encoder, produce a one-shot text output, and discard internal representati…
arXiv:2607.12893v1 Announce Type: new Abstract: Long-term memory has become a foundational capability for LLM-based agents that accompany users across extended, multi-session interactions. Existing benchmarks, however, evaluate such memory almost exclusively through downstream qu…
arXiv:2607.12385v1 Announce Type: new Abstract: A significant challenge in agentic AI is prospective memory: the ability to execute an intention at a specific future cue or state while other activities are ongoing. We introduce PM-Bench, a text-based benchmark for measuring prosp…
Long-term memory has become a foundational capability for LLM-based agents that accompany users across extended, multi-session interactions. Existing benchmarks, however, evaluate such memory almost exclusively through downstream question answering, scoring only the correctness o…
Long-term memory has become a foundational capability for LLM-based agents that accompany users across extended, multi-session interactions. Existing benchmarks, however, evaluate such memory almost exclusively through downstream question answering, scoring only the correctness o…
A significant challenge in agentic AI is prospective memory: the ability to execute an intention at a specific future cue or state while other activities are ongoing. We introduce PM-Bench, a text-based benchmark for measuring prospective memory capabilities in modern LLM agents.…
arXiv cs.AI
TIER_1English(EN)·Yixiong Chen, Xinyi Bai, Alan Yuille·
arXiv:2607.10608v1 Announce Type: new Abstract: Memory is becoming a core component of long-horizon AI agents, allowing agents to reuse past experience when operating web browsers, software tools, and other interactive environments. Existing work mostly treats memory as a supply …
arXiv:2607.10350v1 Announce Type: new Abstract: Recent VLM and VLA systems have improved robotic perception and action prediction, yet long-horizon embodied agents still require a general runtime layer for reasoning, memory, tool use, verification, and cross-embodiment execution.…
arXiv:2607.10582v1 Announce Type: cross Abstract: Large language model (LLM) agents accumulate heterogeneous context, including system instructions, plans, user turns, retrieved documents, tool outputs, and intermediate reasoning, whose key-value (KV) cache can become a major mem…
Speculative execution accelerates LLM agents by using a smaller, cheaper model to predict and pre-launch the next step while the environment is idle. However, existing speculators are stateless and discard all information between tasks, preventing prediction quality from improvin…
arXiv:2607.09493v1 Announce Type: new Abstract: Agentic LLM systems that generate code through multi-turn tool use face a fundamental context problem: each session starts from zero, discarding the configuration choices, domain constraints, data schemas, and tool-use patterns that…
Recent VLM and VLA systems have improved robotic perception and action prediction, yet long-horizon embodied agents still require a general runtime layer for reasoning, memory, tool use, verification, and cross-embodiment execution. We present ABot-AgentOS, a general robotic Agen…
Agentic LLM systems that generate code through multi-turn tool use face a fundamental context problem: each session starts from zero, discarding the configuration choices, domain constraints, data schemas, and tool-use patterns that made previous sessions productive. Naively pers…
arXiv:2607.08716v1 Announce Type: new Abstract: In long-horizon tasks, decision-relevant state is often scattered across an expanding trajectory, while the action agent must surface it and act. As trajectories grow, task requirements, environment facts, prior attempts, diagnoses,…
arXiv:2607.08032v1 Announce Type: new Abstract: Large language models, and the agents built on them, spend an ever-growing share of their compute and memory on remembering: caching attention keys and values, carrying long prompts, maintaining recurrent state, and storing what hap…
In long-horizon tasks, decision-relevant state is often scattered across an expanding trajectory, while the action agent must surface it and act. As trajectories grow, task requirements, environment facts, prior attempts, diagnoses, and open subgoals can be buried in the context …
In long-horizon tasks, decision-relevant state is often scattered across an expanding trajectory, while the action agent must surface it and act. As trajectories grow, task requirements, environment facts, prior attempts, diagnoses, and open subgoals can be buried in the context …
arXiv:2607.06595v1 Announce Type: cross Abstract: Personal AI agents powered by large language models can reason and act using available tools to access emails, manage calendars, and push code to remote repositories, all with minimal oversight. When augmented with long-term memor…
In long-horizon tasks, decision-relevant state is often scattered across an expanding trajectory, while the action agent must surface it and act. As trajectories grow, task requirements, environment facts, prior attempts, diagnoses, and open subgoals can be buried in the context …
Large language models (LLMs) demonstrate remarkable reasoning capabilities, yet their stateless architecture fundamentally limits deployment in long-horizon research workflows requiring multi-session continuity and quantitative rigor. Here we present Ensemble QSP, a multi-agent f…
Large language models (LLMs) demonstrate remarkable reasoning capabilities, yet their stateless architecture fundamentally limits deployment in long-horizon research workflows requiring multi-session continuity and quantitative rigor. Here we present Ensemble QSP, a multi-agent f…
Large language model (LLM)-based agentic recommender systems show promise in modeling user preferences through natural-language reasoning, yet they remain limited by text-centric inputs and coarse-grained memory updates, making agents prone to missing visual evidence, semantic no…
arXiv cs.AI
TIER_1English(EN)·Jihao Liu, Guoxiong Gao, Zeming Sun, Bin Wu, Shurui Liu, Jiedong Jiang, Haocheng Ju, Leheng Chen, Ronnie Cheng, Xiping Zhang, Bin Dong·
arXiv:2607.06447v1 Announce Type: new Abstract: Recent LLM-based mathematical reasoning agents have begun to tackle research-level problems and, in several cases, have contributed to the resolution of open problems. However, scaling and orchestrating such agents effectively remai…
arXiv cs.AI
TIER_1English(EN)·Sergey Volkov, Yang Li, Ye Luo·
arXiv:2607.05844v1 Announce Type: new Abstract: Agent systems accumulate conflicting observations across branches, retries, and replicas, yet many practical memory layers still collapse disagreement behind overwrite rules that are difficult to inspect or correct. We present State…
arXiv cs.AI
TIER_1English(EN)·Yusuf Khan, Carlo Lipizzi·
arXiv:2607.05690v1 Announce Type: new Abstract: Language agents run a loop - observe, reason, act - but the memory they reason over sits outside it: a store queried at most once per turn. We study the regime where memory moves inside the loop, read and written on every step. The …
Human memory is reconstructive, not a faithful recording. Current multimodal LLMs (MLLMs) lack this capability: they process images through a frozen visual encoder, produce a one-shot text output, and discard internal representations. We present DoYouRemember, a three-stage archi…
Recent LLM-based mathematical reasoning agents have begun to tackle research-level problems and, in several cases, have contributed to the resolution of open problems. However, scaling and orchestrating such agents effectively remains challenging, due to the difficulty of coordin…
Recent LLM-based mathematical reasoning agents have begun to tackle research-level problems and, in several cases, have contributed to the resolution of open problems. However, scaling and orchestrating such agents effectively remains challenging, due to the difficulty of coordin…
Agent systems accumulate conflicting observations across branches, retries, and replicas, yet many practical memory layers still collapse disagreement behind overwrite rules that are difficult to inspect or correct. We present StateFuse, a conflict-aware replicated memory contrac…
arXiv cs.CL
TIER_1English(EN)·Shu Yang, Junchao Wu, Derek F. Wong, Di Wang·
arXiv:2607.03726v1 Announce Type: new Abstract: While current AI agents support increasingly long context windows, tool use, and skill execution for long-horizon tasks, they still require memory systems to effectively leverage historical experience. Existing memory frameworks typ…
arXiv cs.CL
TIER_1English(EN)·Serge Lacasse, J\'er\'emie Hatier, Alex Baker·
arXiv:2607.04391v1 Announce Type: new Abstract: Long-term memory remains a structural weakness of AI agents. The dominant approach, retrieval-augmented generation (RAG), relies on embedding-based similarity search, which is opaque by construction, difficult to audit, and bounded …
arXiv:2601.14192v2 Announce Type: replace Abstract: Recent years have witnessed increasing interest in extending large language models into agentic systems. While the effectiveness of agents has continued to improve, efficiency, which is crucial for real-world deployment, has oft…
arXiv:2607.05189v1 Announce Type: cross Abstract: Persistent personal agents combine long-term memory with access to users' external environments, enabling personalized foreground assistance and proactive background execution. This integration also creates a new path to compromis…
arXiv:2607.05029v1 Announce Type: cross Abstract: Persistent memory has enabled large language model (LLM) agents to store factual knowledge, prior decisions, reasoning histories, tool usage information, and context. While this has improved the agent's functionality and continuit…
arXiv:2607.04617v1 Announce Type: new Abstract: Long-lived AI agents require continuity across interactions, but continuity cannot be obtained by simply extending the prompt window. An agent must preserve useful prior experience, retrieve it selectively, distinguish personal cont…
arXiv:2607.04089v1 Announce Type: new Abstract: Lifelong agents need more than larger context windows and better retrieval. They need memories that can persist, evolve, and be corrected without forcing the serving stack to recompute the same history on every turn or silently reus…
arXiv cs.AI
TIER_1English(EN)·Lukas Kirchdorfer, Adrian Rebmann, Christian Warmuth, Timotheus Kampik, Theiss Heilker, Gregor Berg·
arXiv:2607.03228v1 Announce Type: new Abstract: LLM-based agents offer new opportunities for automating business process execution beyond the limits of rule-based systems. However, general-purpose LLMs lack the organization-specific knowledge required for reliable execution, whic…
Language agents run a loop - observe, reason, act - but the memory they reason over sits outside it: a store queried at most once per turn. We study the regime where memory moves inside the loop, read and written on every step. The obstacle has always been latency: networked stor…
Persistent personal agents combine long-term memory with access to users' external environments, enabling personalized foreground assistance and proactive background execution. This integration also creates a new path to compromise: untrusted external content can be silently writ…
Persistent memory has enabled large language model (LLM) agents to store factual knowledge, prior decisions, reasoning histories, tool usage information, and context. While this has improved the agent's functionality and continuity across tasks, it has also introduced a new attac…
Persistent memory has enabled large language model (LLM) agents to store factual knowledge, prior decisions, reasoning histories, tool usage information, and context. While this has improved the agent's functionality and continuity across tasks, it has also introduced a new attac…
Long-lived AI agents require continuity across interactions, but continuity cannot be obtained by simply extending the prompt window. An agent must preserve useful prior experience, retrieve it selectively, distinguish personal context from external evidence, and revise memory wh…
Long-term memory remains a structural weakness of AI agents. The dominant approach, retrieval-augmented generation (RAG), relies on embedding-based similarity search, which is opaque by construction, difficult to audit, and bounded by the theoretical limits of vector representati…
LLM-based agents offer new opportunities for automating business process execution beyond the limits of rule-based systems. However, general-purpose LLMs lack the organization-specific knowledge required for reliable execution, which is typically fragmented across human-oriented …
arXiv cs.AI
TIER_1English(EN)·Zitong Shi, Yixuan Tang, Anthony Kum Hoe Tung·
arXiv:2607.01935v1 Announce Type: new Abstract: Long term memory lets LLM agents act as persistent assistants, but user facts change. A useful memory system must know what is true now, what used to be true, and what changed. We study \emph{ghost memory}, a state coordination fail…
arXiv:2607.02255v1 Announce Type: new Abstract: Memory for a long-horizon LLM agent is a contract about what each future decision is allowed to see. The simplest contract appends past observations, tool calls, and reflections to every prompt, which makes prior context easy to acc…
arXiv cs.AI
TIER_1English(EN)·Jiatong Li, Samuel Yeh, Sharon Li·
arXiv:2607.01523v1 Announce Type: cross Abstract: Recurrent memory agents extend LLMs to arbitrarily long contexts by iteratively consolidating input into a fixed-size memory window. Despite their scalability, these agents exhibit a well-documented reliability problem: end-to-end…
Memory for a long-horizon LLM agent is a contract about what each future decision is allowed to see. The simplest contract appends past observations, tool calls, and reflections to every prompt, which makes prior context easy to access but also turns it into a jumbled mixture in …
arXiv cs.AI
TIER_1English(EN)·Yashar Talebirad, Eden Redman, Ali Parsaee, Osmar R. Zaiane·
arXiv:2607.00233v1 Announce Type: new Abstract: How do two agents invent a shared language from scratch? In a Lewis signaling game, a sender and receiver must coordinate on a code using only their interaction history. We study five memory architectures across varying channel conf…
arXiv:2607.01071v1 Announce Type: cross Abstract: Memory has emerged as a cornerstone of modern LLM-based agents, supporting their evolution from single-turn assistants to long-term collaborators. However, memory is not always beneficial: retrieved memories often induce a critica…
arXiv:2607.01224v1 Announce Type: new Abstract: Memory expertise is a learned skill: knowing what to encode, when to retrieve, and how to organize knowledge--a capacity known in cognitive science as metamemory. We bring this perspective to LLMs by treating memory management as a …
A bounded contract approach for long-horizon LLM agents uses typed retrieval to assemble fresh prompts, enabling isolated analysis of memory components and demonstrating improved performance in complex decision-making tasks.
Recurrent memory agents extend LLMs to arbitrarily long contexts by iteratively consolidating input into a fixed-size memory window. Despite their scalability, these agents exhibit a well-documented reliability problem: end-to-end performance degrades systematically as context le…
Memory expertise is a learned skill: knowing what to encode, when to retrieve, and how to organize knowledge--a capacity known in cognitive science as metamemory. We bring this perspective to LLMs by treating memory management as a trainable skill. We promote file-system operatio…
Multi-agent latent reasoning composes agents' KV-caches into one context for a final agent. Prior work (Agent Primitives) does this by concatenating caches along the sequence axis with RoPE re-encoding, which we call BagMerge. BagMerge is non-commutative, and the best input order…
Memory has emerged as a cornerstone of modern LLM-based agents, supporting their evolution from single-turn assistants to long-term collaborators. However, memory is not always beneficial: retrieved memories often induce a critical issue of sycophancy, causing agents to over-alig…
Memory has emerged as a cornerstone of modern LLM-based agents, supporting their evolution from single-turn assistants to long-term collaborators. However, memory is not always beneficial: retrieved memories often induce a critical issue of sycophancy, causing agents to over-alig…
Memory has emerged as a cornerstone of modern LLM-based agents, supporting their evolution from single-turn assistants to long-term collaborators. However, memory is not always beneficial: retrieved memories often induce a critical issue of sycophancy, causing agents to over-alig…
arXiv cs.LG
TIER_1English(EN)·Prakhar Dixit, Tim Oates·
arXiv:2606.31191v1 Announce Type: new Abstract: We propose Intelligent Schema Memory (ISM), a self-evolving memory-augmented system that improves mathematical reasoning for a frozen LLM under continual learning with hard episodic resets. ISM maintains a compact, self-refined bank…
arXiv:2606.31650v1 Announce Type: cross Abstract: Long-horizon language agents must repeatedly interact with tools, accumulate evidence, and make decisions under bounded context windows. Existing context-management methods make such rollouts feasible by truncating distant history…
Memory management in large language models is treated as a trainable skill through a framework that automates both memory structure optimization and proficiency enhancement, leading to significant performance improvements in long-horizon tasks.
Memory plays a crucial role in LLM-based agents, but retrieved memories can cause sycophancy issues where agents over-align with users at the expense of factual accuracy, necessitating new evaluation benchmarks that assess memory's impact on reasoning and decision-making rather t…
How do two agents invent a shared language from scratch? In a Lewis signaling game, a sender and receiver must coordinate on a code using only their interaction history. We study five memory architectures across varying channel configurations with LLM agents and find that memory …
Long-horizon language agents must repeatedly interact with tools, accumulate evidence, and make decisions under bounded context windows. Existing context-management methods make such rollouts feasible by truncating distant history, folding past turns into summaries, or selecting …
arXiv:2606.28781v1 Announce Type: new Abstract: Every existing vector database and agent memory framework treats memory as passive storage that agents query explicitly. No system propagates knowledge between agents through the memory layer itself. We introduce HyphaeDB, an agent-…
arXiv:2606.29788v1 Announce Type: new Abstract: When a multimodal AI agent is asked to forget a fact, current memory systems usually delete the text entry and report success. We find that the fact can remain recoverable from retained user images, including images tagged to entire…
arXiv:2606.29914v1 Announce Type: new Abstract: Agent memory systems are increasingly evaluated against RAG and full-context baselines, but reported gains often mix changes in the memory method with changes in the language model, embedding model, or retrieval pipeline, making it …
arXiv cs.AI
TIER_1English(EN)·Sijia Li, Yuchen Huang, Zifan Liu, Zijian Li, Jingjing fu, Lei Song, Jiang Bian, Jun Zhang, Rui Wang·
arXiv:2512.07287v3 Announce Type: replace-cross Abstract: As intents unfold and environments change, multi-turn agents face continuously shifting decision contexts. Although reusing past experience is intuitively appealing, existing approaches remain limited: full trajectories ar…
arXiv:2507.05257v4 Announce Type: replace-cross Abstract: Recent benchmarks for Large Language Model (LLM) agents primarily focus on evaluating reasoning, planning, and execution capabilities, while another critical component-memory, encompassing how agents memorize, update, and …
arXiv:2606.30306v1 Announce Type: cross Abstract: Always-on agents are systems whose future behavior depends on durable state accumulated across earlier interactions. We treat them as persistent-state systems: the operative system includes retrievable memories, but also task ledg…
arXiv cs.AI
TIER_1English(EN)·Chengfeng Zhao, Yuqiao Tan, Shizhu He, Yequan Wang, Jun Zhao, Kang Liu·
arXiv:2606.29824v1 Announce Type: cross Abstract: While Large Language Models (LLMs) excel as static solvers, transforming them into autonomous agents remains challenging. This transition requires continuous environmental interaction, yet current agents lack the necessary persist…
arXiv cs.AI
TIER_1English(EN)·Yuhan Zhang (Institute of Software, Chinese Academy of Sciences), Zhiyuan Guo (Institute of Software, Chinese Academy of Sciences), Ziheng Zeng (Institute of Software, Chinese Academy of Sciences), Wei Wang (Institute of Software, Chinese Academy of Scie…·
arXiv:2606.29778v1 Announce Type: cross Abstract: Long-term conversational agents need to remember and query cross-session, multi-typed information with complex correlations. Existing agent memory systems rely on heterogeneous vector and graph databases, which fragment memory inf…
arXiv cs.AI
TIER_1English(EN)·Shuzheng Gao, Wenhao Zeng, Zhaojian Yu, Jianqiao Wangni, Chaozheng Wang, Kai Cai, Shilin He, Michael R. Lyu·
arXiv:2606.28434v1 Announce Type: cross Abstract: Long-horizon software engineering agents often need to manage lengthy and noisy interaction histories under limited context budgets. Existing memory management methods typically rely on static compression workflows or impose rigid…
arXiv:2606.28376v1 Announce Type: cross Abstract: Long-horizon large language model (LLM) agents accumulate interaction trajectories that quickly exceed any practical prompt budget, and existing memory methods either truncate aggressively and lose non-local evidence or retain boi…
arXiv:2606.28349v1 Announce Type: cross Abstract: Long-context reasoning requires models to access, retrieve, and integrate evidence scattered across documents, dialogues, and accumulated interaction histories. Standard retrieval-augmented generation reduces this problem to top-$…
arXiv:2606.29178v1 Announce Type: new Abstract: When does retention matter for memory-augmented LLM agents? We study this with TraceRetain, a lightweight framework for bounded external memory in frozen LLM agents that scores entries by interpretable features (success, age, access…
arXiv:2606.29030v1 Announce Type: new Abstract: AI agents extend conventional large language model (LLM) applications by integrating language understanding with task execution, external tool use, and memory mechanisms. While memory allows agents to retain prior interactions and p…
Always-on agents are systems whose future behavior depends on durable state accumulated across earlier interactions. We treat them as persistent-state systems: the operative system includes retrievable memories, but also task ledgers, permissions, credentials, commitments, proven…
Always-on agents are systems whose future behavior depends on durable state accumulated across earlier interactions. We treat them as persistent-state systems: the operative system includes retrievable memories, but also task ledgers, permissions, credentials, commitments, proven…
Agent memory systems are increasingly evaluated against RAG and full-context baselines, but reported gains often mix changes in the memory method with changes in the language model, embedding model, or retrieval pipeline, making it unclear what is actually being measured. We pres…
While Large Language Models (LLMs) excel as static solvers, transforming them into autonomous agents remains challenging. This transition requires continuous environmental interaction, yet current agents lack the necessary persistent procedural memory. Existing approaches predomi…
While Large Language Models (LLMs) excel as static solvers, transforming them into autonomous agents remains challenging. This transition requires continuous environmental interaction, yet current agents lack the necessary persistent procedural memory. Existing approaches predomi…
Long-term conversational agents need to remember and query cross-session, multi-typed information with complex correlations. Existing agent memory systems rely on heterogeneous vector and graph databases, which fragment memory information and cause high cross-database I/O latency…
arXiv:2606.27472v1 Announce Type: cross Abstract: Large language model (LLM) agents operate over long, multi-session interactions in which facts change: a user moves, a price updates, a plan is revised. Acting correctly requires using the current value of a fact and discarding va…
Every existing vector database and agent memory framework treats memory as passive storage that agents query explicitly. No system propagates knowledge between agents through the memory layer itself. We introduce HyphaeDB, an agent-native memory infrastructure that reinterprets t…
arXiv:2604.15877v2 Announce Type: replace Abstract: As LLM agents scale to long-horizon, multi-session deployments, efficiently managing accumulated experience becomes a critical bottleneck. Agent memory systems and agent skill discovery both address this challenge, extracting re…
arXiv:2606.26806v1 Announce Type: new Abstract: Long-running language agents need more than memory access. Retrieval systems can fetch past facts at query time, but they do not decide which experiences should continue to shape behavior after the working context is unloaded. We st…
arXiv cs.CL
TIER_1English(EN)·Chang Nie, Chaoyou Fu, Junlan Feng, Caifeng Shan·
arXiv:2606.21649v2 Announce Type: replace Abstract: Existing embedding models are inherently static: they encode text segments in isolation, ignoring their surrounding context and temporal order. This paper introduces EvoEmbedding, a novel embedding model that generates evolvable…
arXiv:2606.26511v1 Announce Type: cross Abstract: Retrieval-augmented generation (RAG) gives agents access to accumulated knowledge, but has no model of time. When a fact changes (e.g., a function is renamed or API restructured), RAG retrieves both the stale and current value wit…
Large language model (LLM) agents operate over long, multi-session interactions in which facts change: a user moves, a price updates, a plan is revised. Acting correctly requires using the current value of a fact and discarding values that have been superseded. We isolate this ab…
Long-running language agents need more than memory access. Retrieval systems can fetch past facts at query time, but they do not decide which experiences should continue to shape behavior after the working context is unloaded. We study this separate problem as memory depth: durab…
arXiv cs.CL
TIER_1English(EN)·Yuxin Wang, Paul Thomas, Zhiwei Yu, Yuan Gao, Saeed Hassanpour, Soroush Vosoughi, Robert Sim, Nick Craswell·
arXiv:2606.25361v1 Announce Type: new Abstract: Prior research on memory mechanism in RAG-based conversational system has emphasized how memory is stored and retrieved. However, far less is known about how memories with different functional roles influence response quality. Speci…
arXiv:2606.23195v2 Announce Type: replace-cross Abstract: Large Language Model (LLM) agents increasingly rely on memory systems to maintain long-term coherence. Recent work shows that agent memories degrade during continuous consolidation. However, existing research assumes memor…
arXiv:2606.25632v1 Announce Type: new Abstract: Recent LLM role-playing systems build character agents from novels by extracting characters, scenes, and relations. Yet long-narrative role-playing suffers from two failures: Factual Overreach, where shared retrieval or parametric m…
arXiv:2601.03785v3 Announce Type: replace Abstract: Long-term human-agent dialogues are organized by topic continuity: adjacent turns often develop the same goal, plan, problem, or event, while related activities may recur across distant sessions. Yet many LLM agent memory system…
arXiv:2605.08442v3 Announce Type: replace-cross Abstract: Persistent memory attacks against LLM agents achieve high attack success rates against open-source models. In these attacks, malicious instructions injected via RAG-retrieved documents are stored in persistent memory and e…
arXiv cs.LG
TIER_1English(EN)·Beining Wu, Zihao Ding, Jun Huang, Yanxiao Zhao·
arXiv:2606.25115v1 Announce Type: new Abstract: On-device language-model agents improve by accumulating experience in retrieved memory rather than by updating weights. This memory is hard-bounded and exposed: it consumes RAM and energy, reaches peers through a thin uplink, and be…
Retrieval-augmented generation (RAG) gives agents access to accumulated knowledge, but has no model of time. When a fact changes (e.g., a function is renamed or API restructured), RAG retrieves both the stale and current value with near-identical embedding similarity. The agent t…
Recent LLM role-playing systems build character agents from novels by extracting characters, scenes, and relations. Yet long-narrative role-playing suffers from two failures: Factual Overreach, where shared retrieval or parametric memory lets a character use facts outside its per…
arXiv:2606.24428v1 Announce Type: new Abstract: Experience-driven self-evolution is critical for large language model (LLM) agents to improve through open-world interaction. However, existing experience learning methods mostly rely on single-agent loops, where the same agent exec…
arXiv cs.CL
TIER_1English(EN)·Enze Ma, Yufan Zhou, Wei-Chieh Huang, Jie Yang, Huanhuan Ma, Zixuan Wang, Chengze Li, Chunyu Miao, Philip S. Yu, Zhen Wang·
arXiv:2606.24595v1 Announce Type: new Abstract: Long-term memory promises LLM agents that grow more capable across sessions, maintaining an accurate, evolving understanding of the user that interaction forms. In practice, however, this memory is evaluated mostly through downstrea…
arXiv:2606.24775v1 Announce Type: new Abstract: Memory for large language model (LLM) agents has rapidly evolved from simple retrieval-augmented mechanisms into a data management system that supports persistent information storage, retrieval, update, consolidation, and dynamic li…
arXiv:2606.24543v1 Announce Type: new Abstract: Large Language Models (LLMs) are traditionally viewed as autoregressive generators. However, from the perspective of collective computation, they function as high-dimensional Dense Associative Memories that store complex reasoning p…
arXiv cs.AI
TIER_1English(EN)·Heng Ping, Arijit Bhattacharjee, Peiyu Zhang, Shixuan Li, Wei Yang, Ali Jannesari, Nesreen Ahmed, Paul Bogdan·
arXiv:2606.24535v1 Announce Type: new Abstract: Multi-agent LLM environments require robust mechanisms for shared knowledge management. This paper formalizes the fleet-memory problem and identifies four foundational failure modes: unauthorized leakage, stale propagation, contradi…
arXiv:2606.24151v1 Announce Type: cross Abstract: Self-evolving agents improve over time by distilling experience from past executions and reusing it in future tasks. Existing systems represent such experience either as natural-language text injected into the agent context or as …
arXiv:2511.20892v4 Announce Type: replace Abstract: Large language models (LLMs) often produce incorrect or outdated content after being employed. Efficient and accurate knowledge updates without costly retraining are a major challenge. This problem is particularly challenging in…
Prior research on memory mechanism in RAG-based conversational system has emphasized how memory is stored and retrieved. However, far less is known about how memories with different functional roles influence response quality. Specifically, how they shape an agent's responses und…
On-device language-model agents improve by accumulating experience in retrieved memory rather than by updating weights. This memory is hard-bounded and exposed: it consumes RAM and energy, reaches peers through a thin uplink, and becomes an attack surface because it is writable b…
Memory for large language model (LLM) agents has rapidly evolved from simple retrieval-augmented mechanisms into a data management system that supports persistent information storage, retrieval, update, consolidation, and dynamic lifecycle governance throughout agent execution. D…
Long-term memory promises LLM agents that grow more capable across sessions, maintaining an accurate, evolving understanding of the user that interaction forms. In practice, however, this memory is evaluated mostly through downstream behavior, such as later answers, personalizati…
Long-term memory promises LLM agents that grow more capable across sessions, maintaining an accurate, evolving understanding of the user that interaction forms. In practice, however, this memory is evaluated mostly through downstream behavior, such as later answers, personalizati…
Large Language Models (LLMs) are traditionally viewed as autoregressive generators. However, from the perspective of collective computation, they function as high-dimensional Dense Associative Memories that store complex reasoning patterns as latent attractors. In this work, we i…
Multi-agent LLM environments require robust mechanisms for shared knowledge management. This paper formalizes the fleet-memory problem and identifies four foundational failure modes: unauthorized leakage, stale propagation, contradiction persistence, and provenance collapse. To a…
Mixture-of-Agents (MoA) architectures improve inference-time scaling by organizing multiple LLM agents into layered reasoning pipelines. However, existing MoA variants fail to sustain gains as depth increases, exhibiting degradation, early plateauing, or saturation. We propose Re…
Mixture-of-Agents (MoA) architectures improve inference-time scaling by organizing multiple LLM agents into layered reasoning pipelines. However, existing MoA variants fail to sustain gains as depth increases, exhibiting degradation, early plateauing, or saturation. We propose Re…
Experience-driven self-evolution is critical for large language model (LLM) agents to improve through open-world interaction. However, existing experience learning methods mostly rely on single-agent loops, where the same agent executes tasks, summarizes outcomes, and determines …
Experience-driven self-evolution is critical for large language model (LLM) agents to improve through open-world interaction. However, existing experience learning methods mostly rely on single-agent loops, where the same agent executes tasks, summarizes outcomes, and determines …
Self-evolving agents improve over time by distilling experience from past executions and reusing it in future tasks. Existing systems represent such experience either as natural-language text injected into the agent context or as code exposed as callable tools. However, the choic…
Large language model agents' memory systems have evolved into complex data management frameworks requiring systematic evaluation across multiple modules and workloads to understand their performance characteristics and trade-offs.
Long-term memory in LLM agents should be evaluated as an auditable post-interaction artifact by reconstructing structured user state from the agent's memory, as demonstrated by MEMPROBE, a benchmark testing memory recovery against synthetic ground truth across 50 simulated users …
EDV is a three-stage framework that uses multiple heterogeneous agents to collaboratively construct reliable experiences for LLM agents, preventing self-confirmatory errors through execute-distill-verify processes.
Large Language Model (LLM) agents increasingly rely on memory systems to maintain long-term coherence. Recent work shows that agent memories degrade during continuous consolidation. However, existing research assumes memories are derived from unbiased experiences. In this work, w…
Procedural memory is increasingly used to improve LLM agents on recurring workplace tasks, yet its ability to produce reusable skills remains poorly understood. We introduce AFTER, a benchmark of 382 realistic enterprise tasks spanning six professional roles and 22 procedural ski…
Long-term memory has become increasingly important for LLM agents that operate across extended interactions and evolving task contexts. Recent memory systems have made past experiences more persistent, compact, and retrievable, but retrieval alone does not ensure that a memory pr…
Long-term memory has become increasingly important for LLM agents that operate across extended interactions and evolving task contexts. Recent memory systems have made past experiences more persistent, compact, and retrievable, but retrieval alone does not ensure that a memory pr…
Procedural memory enhances LLM agents on workplace tasks through skill transfer across roles and models, with varying generalization capabilities affecting deployment strategies.
We present Nous, a novel agent memory architecture grounded in the principle that knowledge is prediction, not storage. Rather than persisting facts as database records, vector embeddings, or knowledge-graph triples, Nous maintains a predictive world model: a collection of catego…
arXiv:2606.20475v1 Announce Type: new Abstract: In batch-style trace distillation, the same memory operation may receive contradictory feedback across different batches. Existing methods lack a cross-batch, operation-level evidence accumulation mechanism, making it impossible to …
arXiv cs.AI
TIER_1English(EN)·To Eun Kim, Xuhong He, Dishank Jain, Ambuj Agrawal, Negar Arabzadeh, Fernando Diaz·
arXiv:2606.19911v1 Announce Type: new Abstract: The decentralized deployment of LLM agents with diverse capabilities across diverse tasks motivates infrastructure for knowledge sharing across heterogeneous agent populations. Just as search engines index human-generated artifacts …
arXiv:2606.19847v1 Announce Type: new Abstract: Large language models (LLMs) demonstrate strong reasoning and generation abilities, but their fixed context windows limit long-term information accumulation and reuse across multi-session interactions. Existing memory-augmented syst…
EvoEmbedding is a dynamic embedding model that generates adaptive representations by maintaining a continuously updated latent memory, enabling improved retrieval performance in long-context scenarios.
In batch-style trace distillation, the same memory operation may receive contradictory feedback across different batches. Existing methods lack a cross-batch, operation-level evidence accumulation mechanism, making it impossible to distinguish stably effective operations from acc…
The decentralized deployment of LLM agents with diverse capabilities across diverse tasks motivates infrastructure for knowledge sharing across heterogeneous agent populations. Just as search engines index human-generated artifacts to support human problem solving, retrieval syst…
Large language models (LLMs) demonstrate strong reasoning and generation abilities, but their fixed context windows limit long-term information accumulation and reuse across multi-session interactions. Existing memory-augmented systems often construct memory in a coarse and unsta…
arXiv:2606.18829v1 Announce Type: cross Abstract: Memory benchmarks for LLM agents largely assume single-user settings, leaving shared assistants for hospitals, workplaces, campuses, and households understudied. In these deployments, multiple principals write to a common memory p…
arXiv:2603.00026v2 Announce Type: replace-cross Abstract: Memory management is essential for LLM agents in long-term interactions. Current memory frameworks typically treat agents as passive ``recorders'' and retrieve information without understanding its deeper implications. The…
Memory benchmarks for LLM agents largely assume single-user settings, leaving shared assistants for hospitals, workplaces, campuses, and households understudied. In these deployments, multiple principals write to a common memory pool and query it under different roles, scopes, an…
arXiv:2606.18144v1 Announce Type: new Abstract: A robot's flash endurance is a non-renewable stock: every persisted write spends one of a few thousand program/erase cycles and never refills, yet no fielded robot memory system prices which memories are worth an erase cycle. We tre…
Current memory agents lack reliable shared institutional deployment due to challenges in balancing utility, access control, and forgetting across multiple principals with diverse authorization contexts.
Personalized dialogue agents require continuous long-term memory to maintain coherent interactions across multiple sessions. However, deploying these capabilities on consumer-grade hardware (e.g., 8 GB VRAM edge devices) introduces severe memory and compute bottlenecks. Existing …
A robot's flash endurance is a non-renewable stock: every persisted write spends one of a few thousand program/erase cycles and never refills, yet no fielded robot memory system prices which memories are worth an erase cycle. We treat embodied memory as depreciating capital and p…
arXiv:2605.18421v2 Announce Type: replace-cross Abstract: Recent benchmarks for Large Language Model (LLM) agents mainly evaluate reasoning, planning, and execution. However, memory is also essential for agents, as it enables them to store, update, and retrieve information over t…
arXiv cs.AI
TIER_1English(EN)·Rajat Khanda, Mohammad Baqar, Sambuddha Chakrabarti, Satyasaran Changdar·
arXiv:2604.13085v2 Announce Type: replace-cross Abstract: Autonomous AI agents operating in dynamic environments face a persistent challenge: acquiring new capabilities without erasing prior knowledge. We present Adaptive Memory Crystallization (AMC), a memory architecture for pr…
arXiv:2606.16707v1 Announce Type: new Abstract: A personalized AI agent needs a user memory: a persistent model of who the user is, built across many conversations and consulted on each new one. Today this memory is almost always stored as unstructured text, a knowledge graph, or…
arXiv:2603.00680v4 Announce Type: replace Abstract: Long-horizon agents face the challenge of growing context size during interaction with environment, which degrades the performance and stability. Existing methods typically introduce the external memory module and look up the re…
arXiv:2603.19595v2 Announce Type: replace-cross Abstract: Lifelong interactive agents are expected to assist users over months or years, which requires continually writing long term memories while retrieving the right evidence for each new query under fixed context and latency bu…
A personalized AI agent needs a user memory: a persistent model of who the user is, built across many conversations and consulted on each new one. Today this memory is almost always stored as unstructured text, a knowledge graph, or a flat store of facts, and consulted by retriev…
arXiv cs.AI
TIER_1English(EN)·Guanming Liu, Yuqi Ren, Hansu Gu, Peng Zhang, Weihang Wang, Jiahao Liu, Ning Gu, Tun Lu·
arXiv:2606.14571v1 Announce Type: new Abstract: A central role of personal-agent memory is to turn stored information and prior interactions into future-oriented assistance. In daily use, useful cues come from what the agent observes and how the user interacts with the agent, and…
arXiv cs.AI
TIER_1English(EN)·Pavan C Shekar, Abhishek H S, Aswanth Krishnan·
arXiv:2606.14470v1 Announce Type: new Abstract: Large language model (LLM) reasoning is ephemeral: chains of thought vanish with the context window, pruned search branches leave no record, and memory buffers cannot be diffed, merged, or audited. Every other complex software proce…
arXiv cs.AI
TIER_1English(EN)·Senkang Hu, Yong Dai, Yuzhi Zhao, Yihang Tao, Yu Guo, Zhengru Fang, Sam Tak Wu Kwong, Yuguang Fang·
arXiv:2602.00845v3 Announce Type: replace Abstract: Agentic reasoning enables large reasoning models (LRMs) to dynamically acquire external knowledge, but yet optimizing the retrieval process remains challenging due to the lack of dense, principled reward signals. In this paper, …
A central role of personal-agent memory is to turn stored information and prior interactions into future-oriented assistance. In daily use, useful cues come from what the agent observes and how the user interacts with the agent, and the agent must carry them forward from the curr…
Large language model (LLM) reasoning is ephemeral: chains of thought vanish with the context window, pruned search branches leave no record, and memory buffers cannot be diffed, merged, or audited. Every other complex software process (code, infrastructure, data, experiments) is …
arXiv cs.AI
TIER_1English(EN)·Minjae Kim, Jinheon Baek, Soyeong Jeong, Sung Ju Hwang·
arXiv:2606.13177v1 Announce Type: cross Abstract: Large language model (LLM) agents are increasingly expected to operate over long-term interactions, where information from past dialogues must be preserved and recalled to support future tasks. However, as interactions accumulate,…
arXiv:2606.13115v1 Announce Type: cross Abstract: While Large Language Models (LLMs) have advanced open-domain dialogue systems, maintaining long-term consistency remains a challenge due to inherent limitations in long-context reasoning and the inefficiency of processing extensiv…
arXiv:2606.12945v1 Announce Type: new Abstract: Long-running LLM agents accumulate interaction histories far larger than any context window, forcing a standing decision: what to encode deeply, what to forget, and what to retrieve under a fixed memory budget. Production systems an…
arXiv:2606.12563v1 Announce Type: new Abstract: Arbor is a multi-agent framework that introduces structured tree search as a cognition layer for autonomous agents operating in large, stateful action spaces. Prior autonomous optimization systems operate on isolated targets with st…
arXiv cs.CL
TIER_1English(EN)·Jundong Xu, Qingchuan Li, Jiaying Wu, Yihuai Lan, Shuyue Stella Li, Huichi Zhou, Bowen Jiang, Lei Wang, Jun Wang, Anh Tuan Luu, Caiming Xiong, Hae Won Park, Bryan Hooi, Zhiyuan Hu·
arXiv:2606.13681v1 Announce Type: new Abstract: Large language model (LLM) agents have achieved strong performance on a wide range of benchmarks, yet most evaluations assume static environments. In contrast, real-world deployment is inherently dynamic, requiring agents to continu…
arXiv:2606.13120v1 Announce Type: new Abstract: Search Agents -- large language models augmented with search tools -- have intensified the need for future-proof evaluation benchmarks. Existing benchmarks such as BrowseComp rely on static knowledge, making them vulnerable to test-…
arXiv:2606.12837v1 Announce Type: new Abstract: Search agent benchmarks exemplified by BrowseComp have rapidly saturated over the past year, with the strongest models surpassing 90% accuracy. Since these benchmarks are predominantly human-authored, annotators lack a global perspe…
arXiv:2604.16548v2 Announce Type: replace-cross Abstract: The emergence of writable, cross-session persistent memory in LLM agents introduces a qualitatively different threat landscape from conventional input-centric security concerns, characterized by three properties: persisten…
Large language model (LLM) agents have achieved strong performance on a wide range of benchmarks, yet most evaluations assume static environments. In contrast, real-world deployment is inherently dynamic, requiring agents to continually align their knowledge, skills, and behavior…
Large language model (LLM) agents have achieved strong performance on a wide range of benchmarks, yet most evaluations assume static environments. In contrast, real-world deployment is inherently dynamic, requiring agents to continually align their knowledge, skills, and behavior…
Large language model (LLM) agents are increasingly expected to operate over long-term interactions, where information from past dialogues must be preserved and recalled to support future tasks. However, as interactions accumulate, the memory store grows without bound and fills wi…
Large language model (LLM) agents are increasingly expected to operate over long-term interactions, where information from past dialogues must be preserved and recalled to support future tasks. However, as interactions accumulate, the memory store grows without bound and fills wi…
Search Agents -- large language models augmented with search tools -- have intensified the need for future-proof evaluation benchmarks. Existing benchmarks such as BrowseComp rely on static knowledge, making them vulnerable to test-set contamination and parametric memorization. C…
While Large Language Models (LLMs) have advanced open-domain dialogue systems, maintaining long-term consistency remains a challenge due to inherent limitations in long-context reasoning and the inefficiency of processing extensive raw text. Existing approaches typically rely on …
arXiv:2606.11680v1 Announce Type: new Abstract: Large language model (LLM) agents struggle with long-horizon tasks due to their inherent statelessness, requiring all task-relevant information to be encoded in growing input contexts. The resulting degraded reasoning quality, incre…
arXiv:2606.12087v1 Announce Type: new Abstract: Training deep search agents requires verifiable questions whose answers remain unavailable until sufficient evidence has been acquired through search. Existing synthesis methods often increase apparent difficulty by enriching graph …
arXiv:2606.12329v1 Announce Type: new Abstract: AI coding assistants now support a growing share of software work, from quick scripts to production applications. Yet these agents remain largely stateless: each new session re-reads project files, re-derives prior decisions, and - …
Search agent benchmarks exemplified by BrowseComp have rapidly saturated over the past year, with the strongest models surpassing 90% accuracy. Since these benchmarks are predominantly human-authored, annotators lack a global perspective on entity statistics and cannot systematic…
EvoArena benchmark and EvoMem memory paradigm address the challenge of dynamic environments in LLM agents by modeling progressive updates and structured memory evolution, showing improved performance on evolving tasks.
EvoBrowseComp is an evolving benchmark with 800 contamination-free questions synthesized through a three-agent framework that ensures temporal freshness and prevents parametric memorization in search agent evaluation.
AI coding assistants now support a growing share of software work, from quick scripts to production applications. Yet these agents remain largely stateless: each new session re-reads project files, re-derives prior decisions, and - most costly - may repeat debugging attempts that…
Training deep search agents requires verifiable questions whose answers remain unavailable until sufficient evidence has been acquired through search. Existing synthesis methods often increase apparent difficulty by enriching graph structures, but structural complexity alone does…
Large language model (LLM) agents struggle with long-horizon tasks due to their inherent statelessness, requiring all task-relevant information to be encoded in growing input contexts. The resulting degraded reasoning quality, increased inference cost, and higher latency necessit…
arXiv:2606.11182v1 Announce Type: cross Abstract: In this paper, we propose EEVEE, the first multi-dataset test-time prompt learning framework for LLM agents, enabling test-time prompt learning under real-world task streams. Existing methods are largely designed for single-datase…
arXiv cs.AI
TIER_1English(EN)·Lei (Rachel), Chen, Guilin Zhang, Kai Zhao, Dalmo Cirne, Andy Olsen, Xu Chu, Zeke Miller, Alet Blanken, Amine Anoun, Jerry Ting·
arXiv:2606.10062v1 Announce Type: new Abstract: Foundation-model agents are increasingly long-lived systems that remember users across interactions, making memorization an explicit deployment-time function rather than solely a property of model weights. Existing work addresses pa…
arXiv:2606.10507v1 Announce Type: new Abstract: While Large Language Models (LLMs) have demonstrated strong capabilities as autonomous agents across a wide range of tasks, their performance often degrades in multi-turn long-horizon agentic tasks. Existing methods have made progre…
arXiv cs.AI
TIER_1English(EN)·Qingcan Kang, Liu Mingyang, Shixiong Kai, Kaichao Liang, Tao Zhong, Mingxuan Yuan·
arXiv:2606.10616v1 Announce Type: new Abstract: Long-horizon language agents accumulate observations, reasoning traces, and retrieved facts that exceed their finite context windows, making memory retention a fundamental resource-allocation problem. Existing memory systems improve…
arXiv:2606.10677v1 Announce Type: new Abstract: Long-term LLM agents need persistent memory that can track changing facts and provide relevant evidence across sessions. Existing memory systems often store observations as isolated records, summaries, or indexed fragments, which ma…
arXiv:2606.09900v1 Announce Type: cross Abstract: Long-term memory is the missing layer for LLM agents: across sessions they forget, and the common workaround -- replaying the whole history into the prompt -- is expensive, slow, and, as distractors accumulate, less accurate. Most…
arXiv:2606.10388v1 Announce Type: cross Abstract: Agent skill libraries are becoming routable software assets: a retrieved skill can contribute instructions, scripts, resource bindings, and execution assumptions to an agent. This makes skill retrieval more than broad relevance ma…
arXiv:2510.04195v2 Announce Type: replace Abstract: Given a map description through global traversal navigation instructions, an LLM can often infer the implicit spatial layout and answer user queries by providing shortest paths. However, such context-dependent querying becomes i…
arXiv cs.LG
TIER_1English(EN)·Yv Zhang, Hao Sun, Hao Fang, Kuofeng Gao, Fan Mo, Bin Chen, Shu-Tao Xia, Yaowei Wang·
arXiv:2606.10742v1 Announce Type: cross Abstract: External memory has become a core component of modern web agents, enabling long-horizon reasoning through the retrieval of past experiences. However, this paradigm introduces a critical vulnerability: malicious content injected in…
A framework for creating shortcut-resistant training data for deep search agents by identifying and mitigating four shortcut risks in data synthesis processes.
In this paper, we propose EEVEE, the first multi-dataset test-time prompt learning framework for LLM agents, enabling test-time prompt learning under real-world task streams. Existing methods are largely designed for single-dataset settings, while real-world applications require …
EEVEE is a novel test-time prompt learning framework for LLM agents that handles heterogeneous data streams through task clustering and co-evolving router-prompt optimization.
External memory has become a core component of modern web agents, enabling long-horizon reasoning through the retrieval of past experiences. However, this paradigm introduces a critical vulnerability: malicious content injected into memory can be persistently recalled and repeate…
Long-term LLM agents need persistent memory that can track changing facts and provide relevant evidence across sessions. Existing memory systems often store observations as isolated records, summaries, or indexed fragments, which makes evidence aggregation, fact revision, and mem…
Long-horizon language agents accumulate observations, reasoning traces, and retrieved facts that exceed their finite context windows, making memory retention a fundamental resource-allocation problem. Existing memory systems improve management through heuristic scoring, retrieval…
While Large Language Models (LLMs) have demonstrated strong capabilities as autonomous agents across a wide range of tasks, their performance often degrades in multi-turn long-horizon agentic tasks. Existing methods have made progress through fine-grained credit assignment to all…
arXiv cs.AI
TIER_1English(EN)·Jiazhou Liang, Armin Toroghi, Yifan Simon Liu, Faeze Moradi Kalarde, Liam Gallagher, Scott Sanner·
arXiv:2605.12213v2 Announce Type: replace Abstract: LLM-based conversational AI agents struggle to maintain coherent behavior over long horizons due to limited context. While RAG-based approaches are increasingly adopted to overcome this limitation by storing interactions in exte…
arXiv:2602.08222v2 Announce Type: replace Abstract: As post-training optimization becomes central to improving large language models, we observe a persistent saturation bottleneck: once models grow highly confident, further training yields diminishing returns. While existing meth…
arXiv:2602.03224v2 Announce Type: replace Abstract: Test-time evolution of agent memory represents a pivotal paradigm for advancing AGI, as it strengthens complex reasoning through experience accumulation without requiring parameter updates. However, even during benign task evolu…
arXiv cs.AI
TIER_1English(EN)·Tianxiang Fei, Mingyang Song, Mao Zheng, Xiang Yu·
arXiv:2606.09483v1 Announce Type: cross Abstract: Long-term memory for an LLM agent is more than retrieving the right passage at the right time. Current memory systems collapse belief revision, causal coupling, and cross-domain abstraction into a single retrieval surface tuned fo…
arXiv:2606.07711v1 Announce Type: cross Abstract: Memory is the key component for transforming a stateless LLM into a persistent, evolving agent through experience accumulation, long-horizon planning, and continual self-improvement. Existing memory systems typically take the LLM …
arXiv:2606.09365v1 Announce Type: new Abstract: Medical agent systems are increasingly expected to support interactive clinical decision making rather than only static question answering. In such settings, effective agents must reuse prior experience across evolving cases, yet ex…
arXiv cs.AI
TIER_1English(EN)·Zhixun Tan, Qiang Chen, Tairan Huang, Xiu Su, Yi Chen·
arXiv:2606.08702v1 Announce Type: new Abstract: Recent advances have improved the adaptive capabilities of LLM-based multi-agent systems (MAS) through memory-, skill-, and learning-based approaches, yet these approaches remain challenged by noisy trajectories, insufficient modeli…
arXiv:2606.08151v1 Announce Type: new Abstract: Tool-using LLM agents often fail not because relevant text is absent, but because decisive evidence is not selected, compressed, or surfaced at action time. We present CICL, a decision-aware context layer that turns instance evidenc…
Agent skill libraries are becoming routable software assets: a retrieved skill can contribute instructions, scripts, resource bindings, and execution assumptions to an agent. This makes skill retrieval more than broad relevance matching. A retriever can find the right capability …
Foundation-model agents are increasingly long-lived systems that remember users across interactions, making memorization an explicit deployment-time function rather than solely a property of model weights. Existing work addresses parametric memorization or audits fixed memory con…
Long-term memory for an LLM agent is more than retrieving the right passage at the right time. Current memory systems collapse belief revision, causal coupling, and cross-domain abstraction into a single retrieval surface tuned for surface recall, and consequently struggle on imp…
Large language model agents are increasingly deployed in human-human interaction settings, such as meeting assistants and clinical documentation systems, where they must observe conversations and retain information for downstream queries. Unlike traditional human-assistant settin…
Large language model agents are increasingly deployed in human-human interaction settings, such as meeting assistants and clinical documentation systems, where they must observe conversations and retain information for downstream queries. Unlike traditional human-assistant settin…
Medical agent systems are increasingly expected to support interactive clinical decision making rather than only static question answering. In such settings, effective agents must reuse prior experience across evolving cases, yet existing memory mechanisms often retain raw histor…
Medical agent systems are increasingly expected to support interactive clinical decision making rather than only static question answering. In such settings, effective agents must reuse prior experience across evolving cases, yet existing memory mechanisms often retain raw histor…
SkeMex is a self-evolving framework that enhances medical agents through structured skill memory, improving long-term clinical reasoning by distinguishing useful experiences and governing memory retention based on contextual utility.
arXiv cs.AI
TIER_1English(EN)·Zequn Xie, Junjie Wang, Dan Yang, Jie Feng, Yue Shen, Jian Wang, Jinjie Gu·
arXiv:2606.07074v1 Announce Type: cross Abstract: Deep research agents have demonstrated remarkable capabilities in complex information-seeking tasks, yet this power comes at a steep computational cost. Driven by accuracy-focused training paradigms, current models adopt brute-for…
arXiv:2606.07402v1 Announce Type: new Abstract: Language agents are increasingly deployed over accumulating multimodal information, yet existing benchmarks assume a human-human form with sparse visuals and straightforward content, evaluating neither reasoning over authentic multi…
arXiv cs.AI
TIER_1English(EN)·Runzhe Wang, Huilin Lu, Shengjie Liu, Li Dong, Jason Zhu·
arXiv:2606.06787v1 Announce Type: new Abstract: Large Language Models (LLMs) show promise as tool-using agents but remain limited in long-horizon tasks that require remembering, organizing, and reusing knowledge. Prior memory approaches aim to resolve the situation, but mainly fo…
arXiv:2606.05684v1 Announce Type: new Abstract: A central challenge for language agents is utilizing past experience to adapt to dynamic test-time conditions. While recent work demonstrates the promise of agentic memory mechanisms, most systems restrict retrieval to episode initi…
arXiv:2606.06090v1 Announce Type: new Abstract: LLM-based agents increasingly tackle long-horizon tasks with interdependent decisions, where each action reshapes future constraints and intermediate errors can cascade. Existing RAG and agent memory systems organize histories by se…
arXiv cs.AI
TIER_1English(EN)·Lingxiang Xu, Jiaoyun Yang, Min Hu, Hongtu Chen, Ning An·
arXiv:2606.06055v1 Announce Type: new Abstract: Long-term memory enables language model agents to support personalized interactions, but it remains unclear when available memories warrant integration into responses. Existing memory evaluations emphasize retrieval accuracy and dow…
arXiv:2606.06054v1 Announce Type: new Abstract: Personal AI agents increasingly rely on long-term memory to provide persistent personalization across sessions. However, existing memory pipelines are largely driven by semantic similarity: memory data close to the current query is …
arXiv cs.AI
TIER_1English(EN)·Shuo Ji, Yibo Li, Bryan Hooi·
arXiv:2606.06036v1 Announce Type: new Abstract: Despite recent progress, LLM agents still struggle with reasoning over long interaction histories. While current memory-augmented agents rely on a static retrieve-then-reason paradigm, this rigid pipeline design prevents them from d…
arXiv:2606.06240v1 Announce Type: cross Abstract: Persistent memory for an LLM agent is a write-heavy substrate: every belief update is a versioned write, and a new claim may contradict a stored one. Production systems use four resolution heuristics (last-writer-wins, evidence-we…
Language agents are increasingly deployed over accumulating multimodal information, yet existing benchmarks assume a human-human form with sparse visuals and straightforward content, evaluating neither reasoning over authentic multimodal file interaction nor the interpretation of…
Long-term memory is the missing layer for LLM agents: across sessions they forget, and the common workaround -- replaying the whole history into the prompt -- is expensive, slow, and, as distractors accumulate, less accurate. Most memory systems win on cost or latency but still l…
Deep research agents have demonstrated remarkable capabilities in complex information-seeking tasks, yet this power comes at a steep computational cost. Driven by accuracy-focused training paradigms, current models adopt brute-force strategies characterized by blind tool dependen…
arXiv cs.CL
TIER_1English(EN)·Jiayu Liu, Cheng Qian, Zhenhailong Wang, Bingxuan Li, Jiateng Liu, Heng Wang, Jeonghwan Kim, Yumeng Wang, Xiusi Chen, Yi R. Fung, Heng Ji·
arXiv:2606.05622v1 Announce Type: new Abstract: Planning for real-world problems by language models often involves both world and user constraints, which may not be fully specified upfront and are progressively disclosed through interaction. However, existing benchmarks still und…
arXiv:2606.05894v1 Announce Type: new Abstract: Long-horizon agents can archive large histories, but future answers still incur retrieval, rereading, and context costs. When retained memory misses answer-relevant evidence, the system must return to larger portions of the raw hist…
arXiv:2606.06079v1 Announce Type: new Abstract: Agent skills, which consist of reusable strategies that guide agent reasoning and action, have shown strong potential for improving model capability at inference time. However, current skill construction methods treat the problem as…
arXiv cs.CL
TIER_1English(EN)·Minseok Choi, Seungbin Yang, Dongjin Kim, Subin Kim, Jungmin Son, Yunseung Lee, Jaegul Choo, Youngjun Kwak·
arXiv:2606.05743v1 Announce Type: cross Abstract: Despite advances in safety alignment, large language models remain vulnerable to continuously evolving jailbreaks. Existing fine-tuned safety classifiers cannot adapt to these evolving attacks, while adaptive memory-based guardrai…
arXiv:2606.05414v1 Announce Type: new Abstract: Early failure alerting requires deciding, while a dialog or agent trajectory is still unfolding, whether to flag it as likely to fail. This is challenging because supervision is typically available only as a trajectory-level success…
arXiv:2606.05761v1 Announce Type: cross Abstract: Persistent AI assistants, such as OpenClaw, accumulate large collections of related memories over long-term interactions. As these memories grow, they may reinforce one another, diverge across contexts, or directly conflict, makin…
arXiv cs.CL
TIER_1English(EN)·Nicholas Edwards, Sebastian Schuster·
arXiv:2603.26233v2 Announce Type: replace Abstract: As Large Language Model (LLM) agents are increasingly deployed in open-ended domains like software engineering, they frequently encounter underspecified instructions that lack crucial context. While human developers naturally re…
arXiv cs.CL
TIER_1English(EN)·Yuxuan Cai, Wei Li, Jie Zhou, Qin Chen, Xin Li, Bo Zhang, Liang He·
arXiv:2604.20572v2 Announce Type: replace Abstract: Online lifelong learning agents must decide not only how to act but also when to consult prior experience to continually improve on long-horizon tasks. Existing methods typically retrieve memories passively, such as at task init…
SlimSearcher is a framework that improves efficiency in deep research agents by combining Pareto-efficient trajectory filtering and adaptive reward shaping to reduce computational costs while maintaining accuracy.
Persistent memory for an LLM agent is a write-heavy substrate: every belief update is a versioned write, and a new claim may contradict a stored one. Production systems use four resolution heuristics (last-writer-wins, evidence-weighted merge, await-confirmation, per-rule policy)…
Agent skills, which consist of reusable strategies that guide agent reasoning and action, have shown strong potential for improving model capability at inference time. However, current skill construction methods treat the problem as one-shot extraction, overlooking a fundamental …
Despite recent progress, LLM agents still struggle with reasoning over long interaction histories. While current memory-augmented agents rely on a static retrieve-then-reason paradigm, this rigid pipeline design prevents them from dynamically adapting memory access to intermediat…
Long-horizon agents can archive large histories, but future answers still incur retrieval, rereading, and context costs. When retained memory misses answer-relevant evidence, the system must return to larger portions of the raw history. We study budgeted evidence survival: before…
arXiv cs.AI
TIER_1English(EN)·Wangcheng Tao, Han Wu, Weng-Fai Wong·
arXiv:2606.04780v1 Announce Type: new Abstract: Persistent LLM agents require memory representations that make the formation of person understanding explicit across long term interaction. Existing agent memory methods emphasize information retention and retrieval, yet give limite…
arXiv cs.CL
TIER_1English(EN)·Jingwen Chen, Wenkai Yang, Shengda Fan, Wenbo Nie, Chenxing Sun, Shaodong Zheng, Yangen Hu, Lu Pan, Ke Zeng, Yankai Lin·
arXiv:2606.04703v1 Announce Type: new Abstract: Experience internalization converts contextual experience from past interactions into reusable parametric capability, offering a promising path toward continual learning in large language models (LLMs). While prior work has predomin…
arXiv:2606.04815v1 Announce Type: cross Abstract: Lifelong learning is essential for Large Language Model (LLM) agents operating in dynamic, interactive environments. However, existing lifelong learning agents for long-horizon tasks typically depend on discrete skill or past expe…
arXiv cs.AI
TIER_1English(EN)·Yifan Simon Liu, Liam Gallagher, Faeze Moradi Kalarde, Jiazhou Liang, Armin Toroghi, Scott Sanner·
arXiv:2606.04555v1 Announce Type: cross Abstract: Long-horizon conversational agents need to interact with users through evolving events, tasks, and goals. Such histories are naturally temporal, yet many existing memory systems organize information primarily by topical similarity…
arXiv cs.AI
TIER_1English(EN)·Kai Zhang, Xinyuan Zhang, Hongda Jiang, Shiun-Zu Kuo, Hyokun Yun, Ejaz Ahmed, Shereen Oraby, Ziyun Li, Sanat Sharma, Ann Lee, Ahmed A Aly, Anuj Kumar, Raffay Hamid, Xin Luna Dong·
arXiv:2606.04120v1 Announce Type: cross Abstract: Conversational agents that serve as lifelong companions must maintain persistent memory across all interactions. However, simply expanding context windows with raw retrieval degrades reasoning quality, while training memory agents…
arXiv:2606.04536v1 Announce Type: new Abstract: Existing memory-augmented LLM agents store past experience exclusively in prompt space, as textual summaries or retrieved passages, while keeping model parameters frozen throughout a rollout. Such agents can \emph{look up} what they…
arXiv cs.AI
TIER_1English(EN)·Jiaxi Li, Ke Deng, Yun Wang, Jingyuan Huang, Yucheng Shi, Qiaoyu Tan, Jin Lu, Ninghao Liu·
arXiv:2606.04391v1 Announce Type: new Abstract: Language agents increasingly rely on reusable skills to improve multi-step web automation across related tasks. A growing line of work studies online skill learning, where agents continually induce skills from previous task trajecto…
arXiv:2606.04315v1 Announce Type: new Abstract: LLM agents accumulate histories that outgrow their context windows, motivating a growing literature on memory systems. Yet most existing designs are tuned to a single scenario (multi-session chat or a single trajectory format), and …
arXiv:2606.04202v1 Announce Type: new Abstract: As LLMs become more widely deployed, they are increasingly expected to work alongside other AI agents rather than operating in isolation. Effective coordination in these settings requires agents to communicate, share information and…
MRAgent combines associative memory graphs with active reconstruction to enable dynamic memory access during reasoning, improving long-horizon memory reasoning while reducing computational costs.
SubtleMemory benchmark evaluates AI agents' ability to handle complex relational memory structures that emerge during prolonged interactions, revealing limitations in current memory systems for preserving and utilizing nuanced memory relationships.
AdaPlanBench presents a dynamic interactive benchmark for evaluating LLM agents' ability to adaptively plan under progressively revealed world and user constraints through multi-turn interactions.
Lifelong learning is essential for Large Language Model (LLM) agents operating in dynamic, interactive environments. However, existing lifelong learning agents for long-horizon tasks typically depend on discrete skill or past experiences retrieval with static parameters during in…
Persistent LLM agents require memory representations that make the formation of person understanding explicit across long term interaction. Existing agent memory methods emphasize information retention and retrieval, yet give limited account of how accumulated interaction evidenc…
Experience internalization converts contextual experience from past interactions into reusable parametric capability, offering a promising path toward continual learning in large language models (LLMs). While prior work has predominantly focused on single-iteration transfer, we d…
Long-horizon conversational agents need to interact with users through evolving events, tasks, and goals. Such histories are naturally temporal, yet many existing memory systems organize information primarily by topical similarity and may ignore the order in which events occur. W…
Existing memory-augmented LLM agents store past experience exclusively in prompt space, as textual summaries or retrieved passages, while keeping model parameters frozen throughout a rollout. Such agents can \emph{look up} what they have seen but cannot \emph{learn from} it: thei…
System prompt optimization improves agent behavior without modifying the underlying model, yielding human-readable, model-agnostic instructions. Existing methods build a prompt agent that refines task agents' system prompts, yet leave the prompt agent's own system prompt hand-eng…
arXiv:2512.03627v2 Announce Type: replace Abstract: Despite rapid progress in large-scale language and vision models, AI agents still suffer from a fundamental limitation: they cannot remember. Without reliable memory, agents catastrophically forget past experiences, struggle wit…
arXiv:2510.16392v3 Announce Type: replace Abstract: Personalized and continuous interactions are critical for LLM-based conversational agents, yet finite context windows and static parametric memory hinder the modeling of long-term, cross-session user states. Existing approaches,…
arXiv:2606.03329v1 Announce Type: new Abstract: Long-context tasks require LLMs to identify and preserve answer-relevant information from large contexts. Chunk-wise memory agents address this issue by sequentially reading document chunks, updating a compact memory, and generating…
arXiv cs.AI
TIER_1English(EN)·Kailin Lyu, Zhiqiang Yuan, Jianwei He, Qiwei Yan, Xuanbo Su, Nanxing Hu, Yang Liu, Ce Hao, Shengqian Qin, Lianyu Hu, Jinchao Zhang, Jie Zhou·
arXiv:2606.03099v1 Announce Type: cross Abstract: Deep Image Search requires multi-step reasoning over rich contextual cues, such as time, location, and event relations. However, most existing LLM-based agents are stateless and reactive, lacking persistent memory to maintain long…
arXiv cs.AI
TIER_1English(EN)·Kaiwen Chen, Xin Tan, Jingzong Li, Hong Xu·
arXiv:2606.03077v1 Announce Type: cross Abstract: Reinforcement learning (RL) has become a standard post-training paradigm for large language models (LLMs), extending beyond preference alignment to complex reasoning and multi-turn agentic behaviors. In agentic RL, the rollout sta…
arXiv cs.AI
TIER_1English(EN)·Yuan Xiong, Ziqi Miao, Qian Chen, Lijun Li, Yequan Wang, Shizhu He, Jun Zhao, Kang Liu·
arXiv:2606.03692v1 Announce Type: new Abstract: Recent AI agents can flexibly invoke skills to solve complex tasks, but their long-term improvement is fundamentally constrained by a lack of systematic skill construction, accumulation, and transfer. In particular, without a unifie…
arXiv cs.AI
TIER_1English(EN)·Sarah Barrington, Maty Bohacek, Hany Farid·
arXiv:2606.03686v1 Announce Type: new Abstract: We present DeepSpeak-Agentic, a dataset of videos comprising over 37 hours of semi-structured conversations between a human and an embodied AI agent. We use this dataset to evaluate the automatic forensic identification (audio, vide…
arXiv:2606.03463v1 Announce Type: new Abstract: Conversational AI agents require memory systems that are both scalable and semantically coherent across long interaction horizons. Existing approaches rely predominantly on large language model (LLM)-based summarisation at write tim…
arXiv:2604.20183v2 Announce Type: replace Abstract: Large Language Models (LLMs) often struggle with structural ambiguity in optimization problems, where a single problem admits multiple related but conflicting modeling paradigms, hindering effective solution generation. To addre…
arXiv:2606.03143v1 Announce Type: cross Abstract: Modern LLM agents increasingly rely on skill libraries to handle complex tasks, making skill evolution a primary driver of self-improvement. However, isolated single-user task streams lack the diversity required to build comprehen…
arXiv cs.AI
TIER_1English(EN)·Renjun Xu, Yang Yan·
arXiv:2602.12430v4 Announce Type: replace-cross Abstract: The transition from monolithic language models to modular, skill-equipped agents marks a defining shift in how large language models (LLMs) are deployed in practice. Rather than encoding all procedural knowledge within mod…
arXiv:2606.03083v1 Announce Type: new Abstract: Large Language Model (LLM)-based agents increasingly rely on memory to learn from experiences over continual interactions. However, storing experiences as independent, flat units leads to substantial redundancy and retrieval conflic…
State-Grounded Dynamic Retrieval enables web agents to dynamically reuse skills based on current webpage state rather than fixed task-level strategies, improving automation performance across multiple domains.
Self-Evolving Prompt Optimization (SePO) enhances agent performance by jointly optimizing both task and prompt agent system prompts through evolutionary search, demonstrating superior accuracy across diverse benchmarks.
Experience internalization enables continual learning in large language models by converting past interactions into reusable capabilities, with key findings on experience granularity, injection patterns, and internalization regimes for stable learning.
Recent AI agents can flexibly invoke skills to solve complex tasks, but their long-term improvement is fundamentally constrained by a lack of systematic skill construction, accumulation, and transfer. In particular, without a unified framework for skill consolidation, agents tend…
We present DeepSpeak-Agentic, a dataset of videos comprising over 37 hours of semi-structured conversations between a human and an embodied AI agent. We use this dataset to evaluate the automatic forensic identification (audio, video, or text) of AI agents, study the nature of hu…
Conversational AI agents require memory systems that are both scalable and semantically coherent across long interaction horizons. Existing approaches rely predominantly on large language model (LLM)-based summarisation at write time, which introduces non-determinism, escalating …
arXiv:2606.02060v1 Announce Type: new Abstract: Deep-research agents solve tasks through long trajectories of search, tool use, evidence inspection, and answer synthesis. Evaluation based on final answers shows whether an agent succeeds, but not which parts of the trajectory make…
arXiv cs.CL
TIER_1English(EN)·Adril Putra Merin, David Anugraha, Ayu Purwarianti, Genta Indra Winata·
arXiv:2606.00832v1 Announce Type: new Abstract: Recent advances in agentic AI have enabled agents to complete complex tasks through tool use, reasoning, and multi-step planning. Yet existing benchmarks evaluate agents within a single session, ignoring past actions, stated prefere…
arXiv cs.CL
TIER_1English(EN)·Tao Feng, Tianyang Luo, Jingjun Xu, Zhigang Hua, Yan Xie, Shuang Yang, Ge Liu, Jiaxuan You·
arXiv:2606.01041v1 Announce Type: new Abstract: Experience learning has achieved promising results in enhancing LLM agent planning and reasoning by integrating past interactions as reusable knowledge. However, existing methods remain confined to explicit text space, retrieving ex…
arXiv cs.CL
TIER_1English(EN)·Jiajun Hou, Hexuan Deng, Wenxiang Jiao, Xuebo Liu, Xiaopeng Ke, Derek F. Wong, Min Zhang·
arXiv:2603.20884v2 Announce Type: replace Abstract: To alleviate the heavy burden of paper screening, researchers increasingly rely on existing AI agents, such as AI reviewers or DeepResearch, for paper evaluation and novelty assessment. However, lacking specialized mechanisms fo…
arXiv cs.LG
TIER_1English(EN)·Xu Yang, Lunyiu Nie, Ethan Chandra, Stanislav Gannutin, Fangru Lin, Swarat Chaudhuri·
arXiv:2606.00953v1 Announce Type: new Abstract: Multi-agent Large Language Model (LLM) systems offer a way to decompose complex tasks, such as coding, through parallelization and context isolation. However, adding agents in practice introduces inter-agent communication overhead, …
arXiv:2606.01667v1 Announce Type: new Abstract: Test-time scaling has become a major way to improve large language model reasoning, but its orchestration has remained designer-engineered: a fixed sample budget, a fixed refinement loop, a fixed scoring rule, or a fixed search poli…
arXiv cs.AI
TIER_1English(EN)·Minki Kang, Wei-Ning Chen, Dongge Han, Huseyin A. Inan, Lukas Wutschitz, Yanzhi Chen, Robert Sim, Saravan Rajmohan·
arXiv:2510.00615v3 Announce Type: replace Abstract: Large language models (LLMs) are increasingly deployed as agents in dynamic real-world environments, where success depends on maintaining precise records of actions and observations. However, the resulting unbounded context grow…
arXiv:2606.01528v1 Announce Type: new Abstract: In open-ended environments, exploration is fundamental for autonomous agents, yet current language model agents struggle with this. Effective exploration requires memory, but retaining raw interaction histories is computationally ex…
arXiv cs.CL
TIER_1English(EN)·Yibo Wang, Nikki Lijing Kuang, Philip S. Yu, Zhewei Yao, Yuxiong He·
arXiv:2606.01139v1 Announce Type: new Abstract: Agent skills are procedural artifacts that enable LLM agents to execute workflows, verify constraints, and recover from failures. Existing self-evolving methods refine skills using accumulated trajectories. However, they struggle in…
arXiv cs.AI
TIER_1English(EN)·Bole Ma, Jan Eitzinger, Harald Koestler·
arXiv:2606.01065v1 Announce Type: cross Abstract: Modern KV cache management assumes the chatbot workload: prompts arrive once and the cache grows append-only, so prefix caching and forward-only eviction are correct by construction. Agentic LLMs break this assumption. Their conve…
arXiv:2606.01138v1 Announce Type: cross Abstract: Agent-memory frameworks - mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor - each ship their own SDK, storage layout, and operational vocabulary. There is no shared wire format: every integration is bespoke, every mig…
arXiv:2606.01311v1 Announce Type: cross Abstract: Large language model (LLM) agents increasingly rely on reusable external skills to solve long-horizon interactive tasks. Existing training-free skill adaptation pipelines usually update skills from full trajectories or session-lev…
arXiv:2606.01838v1 Announce Type: cross Abstract: Agentic language model systems alternate between two structurally distinct step types: structured tool calls (short, deterministic, low perplexity) and open-ended planning/reasoning steps (long, complex, high perplexity). Despite …
arXiv cs.AI
TIER_1English(EN)·Xinyu Che, Junqi Xiong, Yunfei Ge, Xinping Lei, Shihao Li, Hang Yan, Han Li, Yuanxing Zhang, Zhiqi Bai, Jinhua Hao, Ming Sun, Han Li, Jiaheng Liu·
arXiv:2606.01993v1 Announce Type: cross Abstract: Abundant procedural knowledge on the Web holds great potential for helping agents solve long-horizon tasks. However, such knowledge is often multimodal, heterogeneous, noisy, and implicitly assumes human executors, making it diffi…
arXiv cs.AI
TIER_1English(EN)·Albert Sadowski, Jaros{\l}aw A. Chudziak·
arXiv:2604.03588v3 Announce Type: replace Abstract: AI agents operating over extended time horizons accumulate experiences that serve multiple concurrent goals, and must often maintain conflicting interpretations of the same events. A concession during a client negotiation encode…
arXiv:2606.02461v1 Announce Type: new Abstract: Language agents spend substantial inference time solving individual tasks, yet the experience acquired in one episode is often underutilized in future episodes. Continual learning expects an agent to accumulate reusable experience a…
arXiv cs.AI
TIER_1English(EN)·Chishui Chen, Jiaye Lin, Te Sun, Junxi Wang, Yi Yang, Cong Qin, Yangen Hu, Lu Pan, Ke Zeng·
arXiv:2606.00510v1 Announce Type: cross Abstract: Agent skills are callable procedural modules that provide reusable knowledge and execution policies for complex agentic tasks. However, existing methods mainly focus on selecting relevant skills or improving the skills themselves,…
arXiv cs.AI
TIER_1English(EN)·Md Zarif Ul Alam, Alireza Salemi, Hamed Zamani·
arXiv:2606.00590v1 Announce Type: cross Abstract: Agentic search systems iteratively interact with retrieval models to answer complex queries. Despite substantial progress, optimizing retrievers for agentic search remains challenging, often requiring heavy co-training or gold-sta…
arXiv:2606.00756v1 Announce Type: new Abstract: Deploying lightweight Large Language Model (LLM) agents on edge servers can reduce latency and move agentic services closer to users, but resource-constrained edge models often struggle with long-horizon tasks that require persisten…
A comprehensive evaluation framework for continual learning in language agents is introduced, emphasizing controlled task streams and memory design analysis to better assess reusable experience and learning stability.
Language agents spend substantial inference time solving individual tasks, yet the experience acquired in one episode is often underutilized in future episodes. Continual learning expects an agent to accumulate reusable experience across a stream of tasks, improve over time, and …
Abundant procedural knowledge on the Web holds great potential for helping agents solve long-horizon tasks. However, such knowledge is often multimodal, heterogeneous, noisy, and implicitly assumes human executors, making it difficult to use directly as the skills required by age…
MMG2Skill framework converts web-based procedural guides into executable skills through closed-loop learning, improving agent performance across GUI control, gameplay, and card play tasks.
Agentic language model systems alternate between two structurally distinct step types: structured tool calls (short, deterministic, low perplexity) and open-ended planning/reasoning steps (long, complex, high perplexity). Despite this heterogeneity, current inference systems appl…
Multimodal agents have achieved notable progress on complex reasoning tasks through tool use, yet remain limited by two issues: statically predefined tool inventories fail to generalize to unseen scenarios, and indiscriminate tool invocation incurs redundant cost and noise-induce…
Test-time scaling has become a major way to improve large language model reasoning, but its orchestration has remained designer-engineered: a fixed sample budget, a fixed refinement loop, a fixed scoring rule, or a fixed search policy decides how compute is spent, leaving the mod…
arXiv:2605.31468v1 Announce Type: new Abstract: Scientific research has traditionally been human-intensive, requiring researchers to coordinate literature, ideas, experiments, manuscripts, and review responses across long project cycles. The rise of LLM-based scientific agents cr…
arXiv cs.LG
TIER_1English(EN)·Yurui Chang, Yongkang Du, Yuanpu Cao, Jinghui Chen, Lu Lin·
arXiv:2605.30858v1 Announce Type: new Abstract: Agentic forecasting is important for decision-making in dynamic environments, but it remains challenging because agents must reason from incomplete, time-limited evidence and produce calibrated probabilities before outcomes are reso…
arXiv:2605.31086v1 Announce Type: new Abstract: In existing memory benchmarks for Large Language Models (LLMs), the evaluated dialogue sessions often lack long-term semantic consistency, and the underlying personas tend to be flat and static. Furthermore, in real-world scenarios,…
arXiv:2605.30771v1 Announce Type: new Abstract: AI agents that persist across sessions need memory they can retrieve, audit, update, and erase. Existing memory systems often collapse source evidence, extracted facts, retrieved context, and answer policy into one opaque prompt pat…
arXiv cs.CL
TIER_1English(EN)·Tao Feng, Chongrui Ye, Tianyang Luo, Jingjun Xu, Xueqiang Xu, Haozhen Zhang, Zhigang Hua, Yan Xie, Shuang Yang, Ge Liu, Jiaxuan You·
arXiv:2605.30712v1 Announce Type: new Abstract: Large language model (LLM) agents have shown strong capabilities in reasoning, tool use, and multi-step interaction, but they often solve tasks from scratch and fail to reuse successful strategies or failure lessons from prior exper…
arXiv cs.CL
TIER_1English(EN)·Tao Feng, Chongrui Ye, Tianyang Luo, Jingjun Xu, Xueqiang Xu, Haozhen Zhang, Ge Liu, Jiaxuan You·
arXiv:2605.30690v1 Announce Type: new Abstract: Long-term memory is essential for LLM agents to reason coherently across extended interactions, personalize responses, and reuse past experience. However, existing memory-augmented methods typically treat memory as a fixed resource:…
arXiv cs.AI
TIER_1English(EN)·Benjamin Schneider, Xavier Schneider, Victor Zhong, Sun Sun·
arXiv:2605.14211v2 Announce Type: replace Abstract: Long-horizon embodied tasks remain a fundamental challenge in AI, as current methods rely on hand-engineered rewards or action-labeled demonstrations, neither of which scales. We introduce ASH, an agentic system that learns an e…
arXiv cs.AI
TIER_1English(EN)·Nianyi Lin, Jiajie Zhang, Lei Hou, Juanzi Li·
arXiv:2605.31584v1 Announce Type: cross Abstract: Long-context reasoning remains a central challenge for large language models, which often fail to locate and integrate key information in extensive distracting content. Reinforcement learning with verifiable rewards (RLVR) has sho…
arXiv cs.AI
TIER_1English(EN)·Zhikun Xu, Yu Feng, Jacob Dineen, Taiwei Shi, Jieyu Zhao, Ben Zhou·
arXiv:2605.31509v1 Announce Type: cross Abstract: Large language model agents trained with reinforcement learning (RL) often learn brittle, task-specific shortcuts. We hypothesize that agents generalize better when their successful trajectories are structurally compressible, deco…
arXiv:2605.31463v1 Announce Type: cross Abstract: Mixture-of-Experts (MoE) has become the dominant architecture for frontier language models. To meet this demand, production frameworks have built optimized MoE training stacks over years of engineering effort. Yet evolving these s…
arXiv:2605.31408v1 Announce Type: cross Abstract: Skill documents provide procedural knowledge to large-language-model agents at inference time. This article studies whether the presentation granularity of controlled skill knowledge changes downstream task success. The experiment…
arXiv:2605.31365v1 Announce Type: new Abstract: Recent advances in Multimodal Large Language Models (MLLMs) have led to promising progress in web agents. However, existing web agents often rely on handcrafted execution pipelines or expensive expert trajectories, limiting their ad…
arXiv:2605.30785v1 Announce Type: new Abstract: LLM agents increasingly face long-horizon tasks such as web search and deep research in real-world applications, where accumulated context can cause long-context degradation and reasoning failures. Prior work mitigates this through …
Joint Agent Memory and Exploration Learning (JAMEL) framework trains memory and exploration policies together through novelty-driven interaction, enabling effective exploration in open-ended environments with reduced computational costs.
Deep-research agents can be audited using a claim-centric framework that identifies error spans in their reasoning trajectories, improving reliability assessment beyond just final answer evaluation.
Large language model (LLM) agents increasingly rely on reusable external skills to solve long-horizon interactive tasks. Existing training-free skill adaptation pipelines usually update skills from full trajectories or session-level feedback, which makes failure attribution coars…
Multi-agent Large Language Model (LLM) systems offer a way to decompose complex tasks, such as coding, through parallelization and context isolation. However, adding agents in practice introduces inter-agent communication overhead, which incurs extra cost and can sometimes offset…
Agentic search systems iteratively interact with retrieval models to answer complex queries. Despite substantial progress, optimizing retrievers for agentic search remains challenging, often requiring heavy co-training or gold-standard annotations that limit real-world applicabil…
Critic-R framework enhances agentic search by closing the feedback loop between reasoning agents and retrieval models through critic evaluation and dual optimization mechanisms.
Long-context reasoning remains a central challenge for large language models, which often fail to locate and integrate key information in extensive distracting content. Reinforcement learning with verifiable rewards (RLVR) has shown promise for this task, yet existing methods are…
Large language model agents trained with reinforcement learning (RL) often learn brittle, task-specific shortcuts. We hypothesize that agents generalize better when their successful trajectories are structurally compressible, decomposed into a small set of reusable abstract patte…
Scientific research has traditionally been human-intensive, requiring researchers to coordinate literature, ideas, experiments, manuscripts, and review responses across long project cycles. The rise of LLM-based scientific agents creates an opportunity to automate this process. S…
Mixture-of-Experts (MoE) has become the dominant architecture for frontier language models. To meet this demand, production frameworks have built optimized MoE training stacks over years of engineering effort. Yet evolving these stacks for new architectures and system optimizatio…
Skill documents provide procedural knowledge to large-language-model agents at inference time. This article studies whether the presentation granularity of controlled skill knowledge changes downstream task success. The experiment uses a pinned SkillsBench version, a 30-task doma…
Recent advances in Multimodal Large Language Models (MLLMs) have led to promising progress in web agents. However, existing web agents often rely on handcrafted execution pipelines or expensive expert trajectories, limiting their adaptability to complex, dynamic environments. To …
In existing memory benchmarks for Large Language Models (LLMs), the evaluated dialogue sessions often lack long-term semantic consistency, and the underlying personas tend to be flat and static. Furthermore, in real-world scenarios, interactions between users and assistants invol…
In existing memory benchmarks for Large Language Models (LLMs), the evaluated dialogue sessions often lack long-term semantic consistency, and the underlying personas tend to be flat and static. Furthermore, in real-world scenarios, interactions between users and assistants invol…
arXiv cs.CL
TIER_1English(EN)·Chengzhi Liu, Yuzhe Yang, Sophia Xiao Pu, Yepeng Liu, Lin Long, Yichen Guo, Nuo Chen, Zhaotian Weng, Elena Kochkina, Simerjot Kaur, Charese Smiley, Xiaomo Liu, James Zou, Sheng Liu, Yuheng Bu, Songyou Peng, Xin Eric Wang·
arXiv:2605.29341v1 Announce Type: cross Abstract: Multimodal large language models are increasingly deployed as long-horizon agents, where memory must do more than recall: it must track an evolving world, revise what has gone stale, and surface the right evidence at decision time…
arXiv:2602.01869v3 Announce Type: replace Abstract: LLM-driven agents excel at sequential decision-making but often rely on on-the-fly reasoning, re-deriving solutions even in recurring scenarios. This insufficient experience reuse leads to computational redundancy and instabilit…
arXiv:2605.30159v1 Announce Type: new Abstract: Memory-augmented LLM agents tackle complex long-horizon tasks by recursively summarizing interaction trajectories into compact memory. However, existing approaches typically train these memory policies using outcome-based reinforcem…
arXiv cs.AI
TIER_1English(EN)·Johannes Moll, Jean-Philippe Corbeil, Jiazhen Pan, Martin Hadamitzky, Daniel Rueckert, Lisa Adams, Keno Bressem·
arXiv:2605.29668v1 Announce Type: new Abstract: LLM agents acting in structured environments fail in operational rather than conversational ways, and reliability depends on procedural knowledge of the environment. Prior self-improvement methods accumulate natural-language guidanc…
arXiv:2605.29559v1 Announce Type: new Abstract: Mastering terminal environments requires language agents capable of multi-step planning, feedback-grounded execution, and dynamic state adaptation. However, training such agents is currently bottlenecked by a reliance on scraped ext…
LongTraceRL addresses long-context reasoning challenges in large language models through tiered distractor construction and rubric reward design for improved reasoning quality.
A reinforcement-learning-based framework called TaskMem is introduced to dynamically determine what information to store in long-term memory for multimodal agents, improving performance on streaming video benchmarks.
Memory-augmented LLM agents tackle complex long-horizon tasks by recursively summarizing interaction trajectories into compact memory. However, existing approaches typically train these memory policies using outcome-based reinforcement learning, failing to localize where intermed…
End-to-end agent-memory benchmarks report a single hit@k per retriever, confounding lexical leakage (uncontrolled query/gold/distractor entity overlap) with tag-mixing (preferences, services, tools averaged together). We propose entity-collision, a system-agnostic protocol that p…
End-to-end agent-memory benchmarks report a single hit@k per retriever, confounding lexical leakage (uncontrolled query/gold/distractor entity overlap) with tag-mixing (preferences, services, tools averaged together). We propose entity-collision, a system-agnostic protocol that p…
Multimodal large language models are increasingly deployed as long-horizon agents, where memory must do more than recall: it must track an evolving world, revise what has gone stale, and surface the right evidence at decision time. Existing benchmarks measure recall over static d…
arXiv:2605.28359v1 Announce Type: new Abstract: Evaluating whether large language model (LLM) agents can profit in capital markets is increasingly framed as end-to-end trading: place an agent in a historical market, let it trade, and measure portfolio returns. This setup is vulne…
arXiv cs.AI
TIER_1English(EN)·Yonatan Vernik, Alexander Tuisov, Alexander Shleyfman·
arXiv:2605.28454v1 Announce Type: new Abstract: Greedy Best-First Search (GBFS) is the dominant approach for solving search problems where the goal can be estimated with a heuristic, such as planning, route finding, navigation, and pathfinding. This is especially true when the me…
arXiv:2605.27428v1 Announce Type: new Abstract: Edge deployments of generative inference increasingly face two practical realities: per-device per-model performance is often unknown at deployment time, and it is non-stationary due to user-driven semantic events, background load, …
arXiv cs.AI
TIER_1English(EN)·Guanyu Cui, Zhewei Wei, Kun He·
arXiv:2605.19514v2 Announce Type: replace Abstract: Many works make the eye-catching claim that Transformers are Turing-complete. However, the literature often conflates two distinct settings: (i) a fixed Transformer system setting, in which a fixed autoregressive Transformer is …
arXiv:2604.05333v3 Announce Type: replace Abstract: Modern LLM agents increasingly rely on reusable skills, and as they interact with personal applications, web browsers, and other interfaces, skill libraries can scale to thousands of skills. Scaling to larger skill sets introduc…
arXiv:2605.27999v1 Announce Type: cross Abstract: We address the problem of learning to assign prediction tasks to one agent from a set of available human or AI agents. In particular, we focus on the sequential learning of agent expertise and assignment policies where each agent …
arXiv:2605.27760v1 Announce Type: new Abstract: Agent skills provide a lightweight way to adapt LLM agents to specialized domains by storing reusable procedural knowledge in structured files. However, whether downloaded from third parties or self-generated, these skills are often…
arXiv:2605.28224v1 Announce Type: new Abstract: Multi-trajectory inference for tool-use LLM agents - generating multiple reasoning attempts and selecting among them - benefits from transferring knowledge across attempts so that later ones avoid the pitfalls of earlier ones. Exist…
arXiv:2605.28046v1 Announce Type: new Abstract: Existing agent memory systems universally follow what we term a Memory-as-Tool paradigm where a single query triggers one-shot retrieval of flat passage lists, suffering from passive invocation, reasoning-retrieval decoupling, and s…
LiteCoder-Terminal-Gen enables scalable training of language agents for terminal environments through synthetic, executable environments that outperform traditional methods.
Multimodal large language models require sophisticated memory systems that can track evolving environments and manage information dynamically across multiple sessions, with new benchmarks revealing limitations in current approaches.
Memory-augmented language models struggle with long-horizon tasks due to information loss in recursive summaries, but a new method using belief entropy and metacognitive policy optimization improves performance by focusing on memory quality rather than just outcome success.
Greedy Best-First Search (GBFS) is the dominant approach for solving search problems where the goal can be estimated with a heuristic, such as planning, route finding, navigation, and pathfinding. This is especially true when the memory is tightly constrained, such as planning on…
Multi-trajectory inference for tool-use LLM agents - generating multiple reasoning attempts and selecting among them - benefits from transferring knowledge across attempts so that later ones avoid the pitfalls of earlier ones. Existing cross-trajectory memory methods (trajectory-…
arXiv:2605.26252v1 Announce Type: new Abstract: Long-running AI agents need persistent memory. Memory supports learning across sessions, reduces repeated context injection, and enables auditing of past decisions. Current agent memory systems and database paradigms treat memory as…
arXiv:2605.11374v3 Announce Type: replace-cross Abstract: Test-time compute is widely believed to benefit only large reasoning models. We show it also helps small embedding models. Since modern embedding models are distilled from LLM backbones, a frozen encoder should benefit fro…
arXiv:2603.14864v2 Announce Type: replace Abstract: In e-commerce, LLM agents show promise for shopping tasks such as recommendations, budget management, and bundle deals, where accurately capturing user preferences from long-horizon conversations is critical. However, progress i…
arXiv:2605.26275v1 Announce Type: new Abstract: Automatic prompt engineering (APE) rewrites prompts to improve downstream task performance, but existing APE loops treat the optimizer itself as a fixed pipeline. We port the code-as-action paradigm of CodeAct (Wang et al., 2024a) t…
arXiv cs.AI
TIER_1English(EN)·Yinpei Dai, Hongze Fu, Jayjun Lee, Yuejiang Liu, Haoran Zhang, Jianing Yang, Chelsea Finn, Nima Fazeli, Joyce Chai·
arXiv:2603.04639v3 Announce Type: replace-cross Abstract: Memory is critical for long-horizon and history-dependent robotic manipulation. Such tasks often involve counting repeated actions or manipulating objects that become temporarily occluded. Recent vision-language-action (VL…
arXiv:2605.26165v1 Announce Type: cross Abstract: Agentic RAG systems that equip language models with dozens to hundreds of tool definitions face a critical resource conflict: tool schemas consume the same context window needed for retrieval-augmented generation. We present the f…
arXiv:2605.27366v1 Announce Type: new Abstract: Large language model (LLM) agents rely on reusable skills to solve complex tasks. However, existing skill creation approaches treat skills as isolated and static artifacts, limiting their reusability, reliability, and long-term impr…
arXiv:2605.26596v1 Announce Type: new Abstract: The token-level extractive compressors widely used for general LM context are structurally inappropriate for LLM agents: across 17 (env, backbone, method) cells spanning two independent token-level method families, every cell collap…
Large language model (LLM) agents rely on reusable skills to solve complex tasks. However, existing skill creation approaches treat skills as isolated and static artifacts, limiting their reusability, reliability, and long-term improvement. We propose MUSE-Autoskill Agent (Memory…
The token-level extractive compressors widely used for general LM context are structurally inappropriate for LLM agents: across 17 (env, backbone, method) cells spanning two independent token-level method families, every cell collapses to mean reward <= 0.05 despite 1.3-13.3x rea…
arXiv:2602.02474v2 Announce Type: replace-cross Abstract: Most Large Language Model (LLM) agent memory systems rely on a small set of static, hand-designed operations for extracting memory. These fixed procedures hard-code human priors about what to store and how to revise memory…
arXiv cs.AI
TIER_1English(EN)·Han Chen, Zining Zhang, Wenqi Pei, Bingsheng He, Ming Wu, Jason Zeng, Michael Heinrich, Wei Wu, Hongbao Zhang·
arXiv:2605.23986v1 Announce Type: cross Abstract: Memory is a fundamental component for enabling long-context LLM agents, supporting persistent state across interactions through a continuous serve-and-update lifecycle. Despite substantial prior work, existing systems suffer from …
arXiv:2605.24110v1 Announce Type: new Abstract: Coding agents are increasingly used as iterative development partners, but most benchmarks still evaluate one specification followed by one final assessment. This leaves out a basic question: can an agent keep its own codebase worki…
arXiv cs.CL
TIER_1English(EN)·Xianzhong Ding, Yangyang Yu, Changwei Liu, Bill Zhao·
arXiv:2605.24279v1 Announce Type: new Abstract: A frontier language model's acknowledged "helpful programming assistant" persona does not survive long agentic-coding sessions in the deployment regime that production products actually run. After hours of tool-using debugging, a mo…
arXiv:2602.22769v3 Announce Type: replace Abstract: Large Language Models (LLMs) are deployed as autonomous agents in increasingly complex applications, where enabling long-horizon memory is critical for achieving strong performance. However, a significant gap exists between appl…
arXiv:2605.24468v1 Announce Type: new Abstract: Long-horizon agentic reasoning requires large language models to act over long interaction histories containing thoughts, tool calls, observations, and partial conclusions. The challenge is not merely that these histories grow long,…
arXiv:2605.25430v1 Announce Type: new Abstract: Coding agents produce rich trajectories while solving software-engineering tasks. To enable agent self-evolution, these trajectories can be distilled into reusable procedural skills that compactly encode experience to guide future b…
arXiv cs.AI
TIER_1English(EN)·Yeonjun In, Wonjoong Kim, Sangwu Park, Kanghoon Yoon, Chanyoung Park·
arXiv:2605.25535v1 Announce Type: new Abstract: Existing large language model (LLM) based memory systems apply universal, static policies that overlook a fundamental reality: the contexts that are worth storing in memory are different across users. This misalignment wastes limite…
arXiv cs.LG
TIER_1English(EN)·Mahavir Dabas, Jihyun Jeong, Ming Jin, Ruoxi Jia·
arXiv:2605.24941v1 Announce Type: cross Abstract: Modern LLM agents combine long-term memory for personalization with tool-calling interfaces for taking actions in the world -- a combination underpinning contemporary production systems. We study a previously unexamined failure of…
arXiv:2605.15759v3 Announce Type: replace Abstract: Large language model (LLM) agents require long-term memory to leverage information from past interactions. However, existing memory systems often face a fidelity--efficiency trade-off: raw dialogue histories are expensive, while…
arXiv:2605.25971v1 Announce Type: new Abstract: While AI agents demonstrate remarkable capabilities in reasoning and tool use, they remain fundamentally reactive: they compute responses only after explicit user prompts. This paradigm ignores a critical opportunity: the idle time …
arXiv:2605.25869v1 Announce Type: new Abstract: Long-term memory is essential for persistent LLM agents, yet prevailing architectures store historical interactions as unstructured, flat text. This unconstrained storage induces provenance-role collapse, a critical failure mode whe…
arXiv cs.CL
TIER_1English(EN)·Moshe Hazoom, Gal Patel, Alon Talmor, Tom Hope·
arXiv:2605.25641v1 Announce Type: new Abstract: Agentic retrieval-augmented generation (RAG) systems in complex B2B (business-to-business) settings may often receive free-form response feedback. Rather than generic feedback signals such as style, preference, or overall response q…
A skill-centric agent framework enables continuous improvement of task-solving capabilities through a unified lifecycle of skill creation, memory, management, evaluation, and refinement.
SkillGrad is a gradient-descent-inspired framework that optimizes agent skills through trajectory-level loss evidence and text-based gradients, enhancing skill reliability and performance in specialized domains.
While AI agents demonstrate remarkable capabilities in reasoning and tool use, they remain fundamentally reactive: they compute responses only after explicit user prompts. This paradigm ignores a critical opportunity: the idle time between interactions is largely wasted, leaving …
While AI agents demonstrate remarkable capabilities in reasoning and tool use, they remain fundamentally reactive: they compute responses only after explicit user prompts. This paradigm ignores a critical opportunity: the idle time between interactions is largely wasted, leaving …
Long-term memory is essential for persistent LLM agents, yet prevailing architectures store historical interactions as unstructured, flat text. This unconstrained storage induces provenance-role collapse, a critical failure mode where agents suffer from source-monitoring errors. …
Agentic retrieval-augmented generation (RAG) systems in complex B2B (business-to-business) settings may often receive free-form response feedback. Rather than generic feedback signals such as style, preference, or overall response quality, we focus on actionable factual correctio…
arXiv cs.CL
TIER_1English(EN)·Alina Shutova, Alexandra Olenina, Ivan Vinogradov, Anton Sinitsin·
arXiv:2602.11243v2 Announce Type: replace-cross Abstract: Modern LLM-based agents and chat assistants rely on long-term memory frameworks to store reusable knowledge, recall user preferences, and augment reasoning. As researchers create more complex memory architectures, it becom…
arXiv:2605.12260v2 Announce Type: replace Abstract: Long-horizon language agents accumulate conversation history far faster than any fixed context window can hold, making memory management critical to both answer accuracy and serving cost. Existing approaches either expand the co…
Large language model-based memory systems can benefit from personalized policies that adapt to individual user contexts, though accurate implementation remains challenging.
Long-horizon agentic reasoning is enhanced through a state-adaptive memory framework that dynamically manages interaction histories by creating compact memory cues while preserving detailed trajectories for targeted retrieval.
arXiv cs.CL
TIER_1English(EN)·Jingru Lin, Chen Zhang, Stephen Y. Liu, Haizhou Li·
arXiv:2605.20251v2 Announce Type: cross Abstract: Existing benchmarks for LLM coding agents primarily evaluate final outcomes. While useful for measuring overall capability, these metrics provide limited visibility and often miss defects that arise during execution. We present Pr…
arXiv:2602.06025v2 Announce Type: replace-cross Abstract: Memory is increasingly central to Large Language Model (LLM) agents operating beyond a single context window, yet most existing systems rely on offline, query-agnostic memory construction that can be inefficient and may di…
arXiv:2602.19320v2 Announce Type: replace-cross Abstract: Agentic memory systems enable large language model (LLM) agents to maintain state across long interactions, supporting long-horizon reasoning and personalization beyond fixed context windows. Despite rapid architectural de…
arXiv:2604.15774v2 Announce Type: replace Abstract: Equipping Large Language Models (LLMs) with persistent memory enhances interaction continuity and personalization but introduces new safety risks. Specifically, contaminated or biased memory accumulation can trigger abnormal age…
arXiv cs.LG
TIER_1English(EN)·Sikuan Yan, Ahmed Bahloul, Ercong Nie, Susanna Schwarzmann, Riccardo Trivisonno, Volker Tresp, Yunpu Ma·
arXiv:2605.21768v1 Announce Type: new Abstract: Memory-augmented LLM agents enable interactions that extend beyond finite context windows by storing, updating, and reusing information across sessions. However, training such agents with reinforcement learning in multi-session envi…
arXiv:2605.21951v1 Announce Type: new Abstract: Achieving self-evolution in intelligent agents requires the continual accumulation of new knowledge across changing task sequences without forgetting previously acquired abilities. Existing approaches either internalize knowledge by…
Self-evolving multi-agent systems (MAS) have emerged as a promising route to LLM agents that continually improve from experience, with persistent memory at their foundation. However, existing designs almost exclusively adopt a centralized repository shared across agents, incurrin…
Memory-augmented LLM agents enable interactions that extend beyond finite context windows by storing, updating, and reusing information across sessions. However, training such agents with reinforcement learning in multi-session environments is challenging because memory turns the…
arXiv cs.CL
TIER_1English(EN)·Dimitris N. Metaxas·
Memory is a central capability for LLM agents operating across long-horizon tasks. Existing memory benchmarks predominantly evaluate retention of personalized information in multi-turn chat scenarios, overlooking the dynamic memory formation that occurs during extended agent exec…
Language agents increasingly operate over streams of related tasks, yet existing memory systems struggle to convert accumulated experience into reusable knowledge. Retrieval-augmented and structured memory methods record per-session observations effectively, but often couple acqu…
To enable reliable long-term interaction, LLM agents require a memory system that can faithfully store, efficiently retrieve, and deeply reason over accumulated dialogue history. Most existing methods adopt an extracted fact based paradigm: handcrafted static prompts compress raw…
Large language model (LLM) agents increasingly operate over long and recurring external contexts, like document corpora and code repositories. Across invocations, existing approaches preserve either the agent's trajectory, passive access to raw material, or task-level strategies.…
TriMem enables reliable long-term interaction for LLM agents by maintaining multiple memory representation granularities and using TextGrad-based prompt optimization for continuous improvement.
The Mixture-of-Agents (MoA) framework has shown promise in improving large language model (LLM) performance by aggregating outputs from multiple agents. However, existing MoA systems often rely on static routers that do not fully capture temporal and contextual dependencies acros…
Real-world agents operate over long and evolving horizons, where information is repeatedly updated and may interfere across memories, requiring accurate recall and aggregated reasoning over multiple pieces of information. However, existing benchmarks focus on static, independent …
Recent benchmarks for Large Language Model (LLM) agents mainly evaluate reasoning, planning, and execution. However, memory is also essential for agents, as it enables them to store, update, and retrieve information over time. This ability remains under-evaluated, largely because…
Safety evaluations of memory-equipped LLM agents typically measure within-task safety: whether an agent completes a single scenario safely, often under adversarial conditions such as prompt injection or memory poisoning. In deployment, however, a single agent serves many independ…
Safety evaluations of memory-equipped LLM agents typically measure within-task safety: whether an agent completes a single scenario safely, often under adversarial conditions such as prompt injection or memory poisoning. In deployment, however, a single agent serves many independ…
Memory systems for AI assistants were built for single-user dialogue and fail characteristically when applied to multi-party social group settings. This gap matters for the social assistants being built today: group-acting agents embedded in chat platforms, and proactive personal…
MemForest presents a memory framework for long-context LLM agents that improves scalability and reduces latency through parallel chunk extraction and hierarchical temporal indexing.
Can LLM agents improve decision-making through self-generated memory without gradient updates? We propose FORGE (Failure-Optimized Reflective Graduation and Evolution), a staged, population-based protocol that evolves prompt-injected natural-language memory for hierarchical ReAct…
Memory systems often organize user-agent interactions as retrievable external memory and are crucial for long-running agents by overcoming the limited context windows of LLMs. However, existing memory systems invoke LLMs to process every incoming interaction for memory extraction…
Large language model (LLM) agents require long-term memory to leverage information from past interactions. However, existing memory systems often face a fidelity--efficiency trade-off: raw dialogue histories are expensive, while flat facts or summaries may discard the structure n…
Existing benchmarks for multimodal memory reasoning largely evaluate systems within pre-assembled contexts, but under-evaluate whether agents can use evidence distributed across independently originated sources. We argue that source-distributed memory composition is an important …
Memory data are ubiquitous in Large Language Model (LLM)-based agents (e.g., OpenClaw and Manus). A few recent works have attempted to exploit agents'memory for improving their performance on the question-answering (QA) task, but they lack a principled mechanism for effectively m…
Large language models (LLMs) achieve strong performance across a wide range of tasks, but remain frozen after pretraining until subsequent updates. Many real-world applications require timely, domain-specific information, motivating the need for efficient mechanisms to incorporat…
arXiv cs.AI
TIER_1English(EN)·Jorge Alberto Hidalgo Toledo·
Large language models (LLMs) have been extensively studied from computational and cognitive perspectives, yet their behavior as communicative actors in socially structured contexts remains underexplored. This study examines whether LLM-based multi-agent systems exhibit systematic…
Large Language Model (LLM) agents increasingly serve as personal assistants and workplace collaborators, where their utility depends on memory systems that extract, retrieve, and apply information across long-running conversations. However, both existing memory systems and benchm…
Memory-augmented LLM agents have advanced personalized recommendation, yet existing approaches universally adopt flat memory representations that conflate ephemeral signals with stable preferences, and none provides a complete lifecycle governing how memory should evolve. We prop…
Memory-augmented LLM agents have advanced personalized recommendation, yet existing approaches universally adopt flat memory representations that conflate ephemeral signals with stable preferences, and none provides a complete lifecycle governing how memory should evolve. We prop…
Long-term memory is crucial for agents in specialized web environments, where success depends on recalling interface affordances, state dynamics, workflows, and recurring failure modes. However, existing memory benchmarks for agents mostly focus on user histories, short traces, o…
Recent advances in reinforcement learning from human feedback (RLHF) and preference optimization have substantially improved the usability, coherence, and safety of large language models. However, recurring behaviors such as performative certainty, hallucinated continuity, calibr…
Modern GUI agents typically rely on a model-centric and step-wise interaction paradigm, where LLMs must re-interpret the UI and re-decide actions at every screen, which is fragile in long-horizon tasks. In this paper, we propose Executable Agentic Memory (EAM), a structured Knowl…
Long-horizon language agents accumulate conversation history far faster than any fixed context window can hold, making memory management critical to both answer accuracy and serving cost. Existing approaches either expand the context window without addressing what is retrieved, p…
LLM-based conversational AI agents struggle to maintain coherent behavior over long horizons due to limited context. While RAG-based approaches are increasingly adopted to overcome this limitation by storing interactions in external memory modules and performing retrieval from th…
Long-horizon language agents must operate under limited runtime memory, yet existing memory mechanisms often organize experience around descriptive criteria such as relevance, salience, or summary quality. For an agent, however, memory is valuable not because it faithfully descri…
Does a lexical retriever suffice as large language models (LLMs) become more capable in an agentic loop? This question naturally arises when building deep research systems. We revisit it by pairing BM25 with frontier LLMs that have better reasoning and tool-use abilities. To supp…
To tackle long-context reasoning tasks without the quadratic complexity of standard attention mechanisms, approaches based on agent memory have emerged, which typically maintain a dynamically updated memory when linearly processing document chunks. To mitigate the potential loss …
As 6G evolves, the radio access network must transcend traditional automation to embrace agentic AI capable of perception, reasoning, and evolution. A fundamental cognitive gap persists in current disaggregated architectures, where interfaces force the physical layer to compress …
Existing benchmarks for multimodal agentic search evaluate multimodal search and visual browsing, but visual evidence is either confined to the input or treated as an answer endpoint rather than part of an interleaved search trajectory. We introduce \textbf{InterLV-Search}, a ben…
arXiv:2605.06285v1 Announce Type: cross Abstract: Single-step retrieval-augmented generation (RAG) provides an efficient way to incorporate external information for simple question answering tasks but struggles with complex questions. Agentic RAG extends this paradigm by replacin…
arXiv cs.LG
TIER_1English(EN)·Zeyu Yang, Qi Ma, Jason Chen, Anshumali Shrivastava·
arXiv:2605.06647v1 Announce Type: cross Abstract: Retrieval-augmented agents are increasingly the interface to large organizational knowledge bases, yet most still treat retrieval as a black box: they issue exploratory queries, inspect returned snippets, and iteratively reformula…
arXiv:2605.06132v1 Announce Type: new Abstract: In agent memory systems, the reranking model serves as the critical bridge connecting user queries with long-term memory. Most systems adopt the "retrieve-then-rerank" two-stage paradigm, but generic reranking models rely on semanti…
arXiv cs.CL
TIER_1English(EN)·Junfeng Liao, Qizhou Wang, Jianing Zhu, Bo Du, Rui Yan, Xiuying Chen·
arXiv:2605.05583v1 Announce Type: cross Abstract: LLM agents that operate over long context depend on external memory to accumulate knowledge over time. However, existing methods typically store each observation as a single deterministic conclusion (e.g., inferring "API~X failed"…
arXiv:2605.05538v1 Announce Type: new Abstract: We present AgenticRAG, a practical agentic harness for retrieval and analysis over enterprise knowledge bases. Standard RAG pipelines place significant burden of grounding on the search stack, constraining the language model to a fi…
arXiv cs.AI
TIER_1English(EN)·Huyu Wu, Jun Liu, Xiaochi Wei, Yan Gao, Yi Wu, Yao Hu·
arXiv:2605.05702v1 Announce Type: new Abstract: Self-evolving search agents reduce reliance on human-written training questions by generating and solving their own search tasks. We build on Search Self-Play (SSP), a representative Proposer and Solver framework in which questions …
arXiv cs.AI
TIER_1English(EN)·Zhuofeng Li, Haoxiang Zhang, Cong Wei, Pan Lu, Ping Nie, Yi Lu, Yuyang Bai, Shangbin Feng, Hangxiao Zhu, Ming Zhong, Yuyu Zhang, Jianwen Xie, Yejin Choi, James Zou, Jiawei Han, Wenhu Chen, Jimmy Lin, Dongfu Jiang, Yu Zhang·
arXiv:2605.05242v1 Announce Type: cross Abstract: Modern retrieval systems, whether lexical or semantic, expose a corpus through a fixed similarity interface that compresses access into a single top-k retrieval step before reasoning. This abstraction is efficient, but for agentic…
arXiv:2510.12635v3 Announce Type: replace Abstract: Long-context Large Language Models, despite their expanded capacity, require careful working memory management to mitigate attention dilution during long-horizon tasks. Yet existing approaches rely on external mechanisms that la…
arXiv:2604.20050v2 Announce Type: replace-cross Abstract: Can Large Language Models (AI agents) aggregate dispersed private information through trading and reason about the knowledge of others by observing price movements? We conduct a controlled experiment where AI agents trade …
Retrieval-augmented agents are increasingly the interface to large organizational knowledge bases, yet most still treat retrieval as a black box: they issue exploratory queries, inspect returned snippets, and iteratively reformulate until useful evidence emerges. This approach re…
Single-step retrieval-augmented generation (RAG) provides an efficient way to incorporate external information for simple question answering tasks but struggles with complex questions. Agentic RAG extends this paradigm by replacing single-step retrieval with a multi-step process,…
Single-step retrieval-augmented generation (RAG) provides an efficient way to incorporate external information for simple question answering tasks but struggles with complex questions. Agentic RAG extends this paradigm by replacing single-step retrieval with a multi-step process,…
In agent memory systems, the reranking model serves as the critical bridge connecting user queries with long-term memory. Most systems adopt the "retrieve-then-rerank" two-stage paradigm, but generic reranking models rely on semantic similarity matching and lack genuine reasoning…
arXiv cs.CL
TIER_1English(EN)·Joshua Adler, Guy Zehavi·
arXiv:2605.04897v1 Announce Type: new Abstract: Extraction at ingestion is the wrong primitive for agent memory: content discarded before the query is known cannot be recovered at retrieval time. We propose True Memory, a six-layer architecture that shifts the center of the syste…
Long-horizon search agents must manage a rapidly growing working context as they reason, call tools, and observe information. Naively accumulating all intermediate content can overwhelm the agent, increasing costs and the risk of errors. We propose that effective context manageme…
Extraction at ingestion is the wrong primitive for agent memory: content discarded before the query is known cannot be recovered at retrieval time. We propose True Memory, a six-layer architecture that shifts the center of the system from a storage schema to a multi-stage retriev…
arXiv:2605.02491v1 Announce Type: cross Abstract: Modern searches for physics beyond the Standard Model produce rapidly expanding literature containing heterogeneous information, including textual analyses, numerical datasets, and graphical exclusion limits. Integrating these dis…
arXiv:2605.04018v1 Announce Type: new Abstract: Reasoning-intensive retrieval aims to surface evidence that supports downstream reasoning rather than merely matching topical similarity. This capability is increasingly important for agentic search systems, where retrievers must pr…
Reasoning-intensive retrieval aims to surface evidence that supports downstream reasoning rather than merely matching topical similarity. This capability is increasingly important for agentic search systems, where retrievers must provide complementary evidence across iterative se…
Modern searches for physics beyond the Standard Model produce rapidly expanding literature containing heterogeneous information, including textual analyses, numerical datasets, and graphical exclusion limits. Integrating these distributed sources remains a time-consuming and manu…
Modern searches for physics beyond the Standard Model produce rapidly expanding literature containing heterogeneous information, including textual analyses, numerical datasets, and graphical exclusion limits. Integrating these distributed sources remains a time-consuming and manu…
arXiv:2608.23268v1 Announce Type: new Abstract: Frontier multimodal large language models (MLLMs) deliver impressive perception yet still falter on scientific and mathematical reasoning. Parameter-level adaptation is unavailable for closed-weight or on-device backbones, and state…
arXiv:2606.31612v2 Announce Type: replace Abstract: Mobile GUI agents increasingly face long-horizon tasks that require reading, updating, and reusing task-relevant data across pages and applications. Existing methods treat memory largely as passive storage, where past observatio…
Mobile GUI agents increasingly face long-horizon tasks that require reading, updating, and reusing task-relevant data across pages and applications. Existing memory methods treat memory largely as passive storage, where past observations are accumulated and retrieved when needed.…
LLM agents follow a practical execution loop in digital environments: they reason over structured states, invoke tools, inspect feedback, and revise actions. Extending this loop to physical robots is difficult because physical execution is continuous, embodiment-dependent, uncert…
arXiv cs.CV
TIER_1English(EN)·Can Lin, Tao Feng, Hangjie Yuan, Dan Zhang, Yifan Zhu, Zhonghong Ou·
arXiv:2606.10522v1 Announce Type: new Abstract: Graphical User Interfaces (GUIs) serve as the dominant medium for human-computer interaction, yet building GUI agents that generalize across the vast diversity of real-world interface environments, with the same flexibility and robu…
Graphical User Interfaces (GUIs) serve as the dominant medium for human-computer interaction, yet building GUI agents that generalize across the vast diversity of real-world interface environments, with the same flexibility and robustness that humans naturally exhibit, remains un…
arXiv:2606.00183v1 Announce Type: cross Abstract: Tree search is a central abstraction behind many language-agent reasoning and decision-making tasks: agents must explore actions, remember failures, and backtrack toward promising alternatives. Yet, we lack a theoretical understan…
arXiv:2605.30711v1 Announce Type: cross Abstract: Agentic LLMs must continuously decide whether newly extracted facts should be added, merged with existing memories, or ignored, yet prior work has focused more on retrieval and storage than on principled write-side control. We fra…
arXiv:2605.31075v1 Announce Type: new Abstract: Long-term memory is essential for multimodal agents to build coherent experience, accumulate world knowledge, and achieve continual learning. However, constructing effective memory goes beyond memory module design and basic requirem…
Tree search is a central abstraction behind many language-agent reasoning and decision-making tasks: agents must explore actions, remember failures, and backtrack toward promising alternatives. Yet, we lack a theoretical understanding of how transformer-based policies acquire suc…
Long-term memory is essential for multimodal agents to build coherent experience, accumulate world knowledge, and achieve continual learning. However, constructing effective memory goes beyond memory module design and basic requirements such as accuracy and fidelity; the key chal…
arXiv:2605.29471v1 Announce Type: new Abstract: Collaborative driving systems leverage vehicle-to-everything (V2X) communication for multi-agent collaborative perception to enhance driving safety, yet they remain constrained by scarce annotated real-world V2X driving datasets and…
Agentic LLMs must continuously decide whether newly extracted facts should be added, merged with existing memories, or ignored, yet prior work has focused more on retrieval and storage than on principled write-side control. We frame memory evolution as a novelty-detection problem…
The ability to navigate and interact with complex environments is central to real-world embodied agents, yet navigation in unseen environments remains challenging due to "experiential amnesia," where existing trajectory-driven or reactive policies fail to synthesize generalizable…
Recent GUI agents have made substantial progress in visual grounding and action prediction, yet they remain brittle in long-horizon tasks that require maintaining task state across many interface transitions. Existing agents typically rely on raw history replay or text-only memor…
Long-term agent memory is increasingly multimodal, yet existing evaluations rarely test whether agents preserve the visual evidence needed for later reasoning. In prior work, many visually grounded questions can be answered using only captions or textual traces, allowing answers …
Latent Space (podcast video)
TIER_1English(EN)·Latent Space·
In this episode, Engram co-founder and CEO Dan Biderman joins Allen Park cook Mediterranean meatballs with yellow rice and talk about building AI that actually learns from you: why long context, RAG, and compaction eventually break down, how Engram compresses knowledge into cartr…
AWS Machine Learning Blog
TIER_1English(EN)·Akarsha Sehwag·
In this post, you will learn how metadata works across configuration, ingestion, and retrieval, explore enterprise use cases including multi-agent and multi-tenant architectures, and discover best practices for implementation.
Real-world inference benchmarks for coding agents: 31% more TPS than TensorRT-LLM, 2× better TTFT at saturation, and 76% lower cost than Claude Opus 4.6.
<p><strong>TL;DR</strong> — An agent loop is five blocks doing work plus a <strong>memory spine</strong> that makes the work cumulative. Drop the spine and you have automation that forgets every morning. Below: the map, the primitive each block maps to in Claude Code, and a real …
<p>Tencent Cloud has open-sourced TencentDB Agent Memory v2.0, a team-level memory hub that turns conversations, documents and code into four governed, reusable assets — Chat Memory, Skill, LLM-Wiki and Code-Graph. It is MIT-licensed, self-hosted via Docker, and integrates with C…
dev.to — Claude Code tag
TIER_1English(EN)·vavilov2212·
<p>Every AI coding session starts with amnesia.</p> <p>Yesterday the agent spent two hours hunting down a state-sharing bug. Today it will happily reintroduce that same bug, in the same codebase, with the same confidence. The context window closed, and everything the agent learne…
dev.to — Claude Code tag
TIER_1English(EN)·kanfu-panda·
<blockquote> <p>Last time we talked about how to build a memory system for AI. But building is only the beginning—the longer a project runs, the more memory accumulates, and without cleanup, weeds quietly grow in it. This time, I gave the AI memory across several of my projects a…
dev.to — Claude Code tag
TIER_1English(EN)·kanfu-panda·
<p>I keep tripping over the same AI in the same spot.</p> <p>Take Ant Design 6 in a front-end project. I've told it, over and over, to use the new syntax—I even make it run context7 to check the API before it writes a line. It nods along, then goes right ahead and writes a pile o…
dev.to — Claude Code tag
TIER_1English(EN)·yureki_lab·
<h2> TL;DR </h2> <p>I run a fully autonomous implementation system built on Claude Code that works on my projects around the clock. The single biggest upgrade I ever made to it wasn't a smarter prompt or a better model — it was giving it a <strong>file-based long-term memory</str…
<p>EverMind has open-sourced EverOS, a local-first memory runtime that stores AI agent memory as plain Markdown indexed by SQLite and LanceDB. It combines hybrid BM25 + vector retrieval, multimodal ingestion, and self-evolving Skills under an Apache 2.0 license. Here's what it is…
<p>LLMs are stateless by default. Agent memory fixes that. This guide breaks down all 7 types — working, semantic, episodic, procedural, retrieval, parametric, and prospective. It covers what each stores, where it lives, and when to build it. Includes a comparison table and worki…
<p>Perplexity has launched Brain, a self-improving memory system for its Computer agent. Instead of remembering the user, Brain remembers the agent's work — what worked, what failed, and what corrections got made. It builds a traceable context graph, reviews it overnight, and rep…
dev.to — Claude Code tag
TIER_1English(EN)·Pandit·
<p><em>Part 3 of the series: <a href="https://dev.to/panditabhis/how-i-turned-claude-into-a-disciplined-senior-developer-not-just-a-fast-one-1a59">Building Your AI Developer Handbook</a></em></p> <h2> The Goldfish Problem </h2> <p>By default, every Claude session starts completel…
<p>UIUC and Chroma's Harness-1 is a 20B retrieval subagent trained with reinforcement learning inside a stateful search harness. The harness maintains the bookkeeping — candidate pool, importance-tagged curated set, evidence graph, verification records — while the policy decides …
Researchers at the University of Science and Technology of China (USTC) have open-sourced a novel agent-driven long-context training paradigm that achieves breakthrough efficiency — a 30-billion-parameter model matching the performance of Alibaba'...
dev.to — Claude Code tag
TIER_1English(EN)·Harrison Guo·
<p>This post is one half of a pair. The other half — <a href="https://harrisonsec.com/blog/agent-retrieval-cost-curve-claude-code-grep-vs-rag/" rel="noopener noreferrer"><em>Agent Retrieval Is a Cost Curve Problem</em></a> — argues that Claude Code's within-session code retrieval…
dev.to — Claude Code tag
TIER_1English(EN)·Odilon HUGONNOT·
<p>Each roast was taking 50 seconds per upload. Quality was unknown — we had a feeling, not data. The prompt had been written "by instinct" and never seriously evaluated. The question was simple: how do you know if a prompt is good, and how do you improve it without spending the …
dev.to — Claude Code tag
TIER_1English(EN)·Harrison Guo·
<p>There's a popular interview question making the rounds: <em>"Why doesn't Claude Code use RAG to retrieve code? Why grep?"</em></p> <p>The popular answer goes: chunking breaks code structure, vectors approximate when code demands exact, indexes go stale, cold-start is slow, ret…
<p>Tencent has open-sourced TencentDB Agent Memory, a fully local memory system for AI agents released under the MIT license. The project pairs symbolic short-term memory, which offloads verbose tool logs into a compact Mermaid task canvas, with a 4-tier long-term memory pyramid …
dev.to — Claude Code tag
TIER_1English(EN)·Toni Antunovic·
<p><em>This article was originally published on <a href="https://lucidshark.com/blog/multi-agent-transitive-prompt-injection-coding-pipelines-2026" rel="noopener noreferrer">LucidShark Blog</a>.</em></p> <p>The upgrade from single-agent to multi-agent coding workflows felt like a…
<p>AI agents start every session from zero — no memory of meetings, notes, or decisions. GBrain, the open-source memory layer Y Combinator's Garry Tan built to power his own OpenClaw and Hermes deployments, fixes that with a markdown-first knowledge graph that wires itself throug…
dev.to — Claude Code tag
TIER_1English(EN)·Michael Tuszynski·
<p>The current "<a href="https://www.youtube.com/results?search_query=hermes+agent+vs+claude+code" rel="noopener noreferrer">Hermes Agent vs Claude Code</a>" framing is the wrong comparison. The two tools live at different layers of the coding agent stack, and most of the YouTube…
dev.to — Claude Code tag
TIER_1English(EN)·The Hive Collective·
<p>Run Claude Code on real work for a while and you notice the same thing. Your agent figures out a non-obvious thing — a Postgres <code>VACUUM</code> quirk, a Tailwind v4 + shadcn collision, a Next.js caching gotcha — and that knowledge dies with the conversation. The next agent…
dev.to — Claude Code tag
TIER_1English(EN)·Theo Valmis·
<blockquote> <p>Anthropic's managed-agent harness solves one hard problem: continuity. Progress logs, feature lists, git checkpoints, and startup scripts give each new session a map of what happened. But continuity is not governance. As agents work across more sessions, the quest…
dev.to — Claude Code tag
TIER_1English(EN)·Andrew·
<blockquote> <p><em><strong>Originally published on <a href="https://andrew.ooo/posts/agentmemory-persistent-memory-ai-coding-agents-review/" rel="noopener noreferrer">andrew.ooo</a></strong> — visit the original for any updates, code snippets that aged out, or follow-up posts.</…
dev.to — Claude Code tag
TIER_1Français(FR)·Michel Faure·
<p>Every long-running AI agent eventually hits the same wall: the active context window can no longer hold everything the task needs, either because the conversation itself has grown too large, or because a single tool call has returned more data than fits in what’s left of the b…
<p>When you run multiple agents across Claude, ChatGPT, and Cursor, each one starts from scratch unless you manually paste context into every session. OzBrain solves this by exposing a shared knowledge substrate that agents read and write through the Model Context Protocol (MCP).…
<p>Cloud memory tiers have a fundamental problem: your agent context - the most sensitive data you have - leaves your machine. I wanted memory that never does.</p> <p>So Awareness runs a local-first daemon:<br /> </p> <div class="highlight js-code-highlight"> <pre class="highligh…
dev.to — MCP tag
TIER_1English(EN)·Filippo Pilotta·
<p>Last week I presented Cortex — a semantic memory for AI assistants I've been building for two years — on Reddit. The response was brutal: <em>"Obsidian works fine."</em> <em>"A text file is enough."</em> <em>"Thanks for inventing RAG for the millionth time."</em></p> <p>Instea…
<h1>Unlocking Persistent Agent Intelligence: A Dual-Tier Memory Architecture with L1 Scratchpad and L2 Vault</h1> <p>Move beyond stateless AI interactions. Learn how to implement a robust dual-tier memory system using an L1 in-session scratchpad and an L2 persistent semantic vaul…
<p>Most AI memory demos begin with the same satisfying moment.</p> <p>You tell an agent something in one session. You start another session. The agent remembers it.</p> <p>That feels like success until you ask the next set of questions:</p> <ul> <li>Where did this fact come from?…
<p>If you were building autonomous workflows, you were probably suffering from "framework fatigue."</p> <p>Every time you switched between IDEs like Cursor, terminal agents like Claude Code, or browser-based assistants, you had to reconfigure your tools, re-authenticate your keys…
<h1>Building AI Agents That Survive Restarts: The Benchmark-Proven Case for Persistent Memory</h1> <p>Ephemeral AI agents lose critical context on restart, destroying user experience and workflow continuity. We benchmark the stark performance difference between stateless designs …
🧠 Developers can create shared memory systems for AI agents by integrating with Notion's database capabilities. This approach allows multiple agents to store and retrieve information from a centralized location during their operations. 💬 Hacker News 🔗 https://www. notion.com/blog…
<h1>GitOps for AI Agents: Rollback Your Agent's Memory with L2 Vault Versioning</h1> <p>Discover how to implement GitOps for AI agents using L2 vault versioning. Learn to treat your agent's tool configurations and memory as version-controlled infrastructure, enabling safe rollbac…
<h1>Dual-Tier Memory Architecture for AI Agents: L1 Scratchpad + L2 Vault</h1> <p>Discover how a local-first, dual-tier memory system using an L1 scratchpad and L2 vault gives AI agents instant recall and perfect context, outperforming cloud vector databases like Pinecone for pri…
<h1>The Resilient Agent: Engineering AI That Remembers Across Restarts</h1> <p>Ephemeral AI memory cripples complex workflows. We benchmark the critical performance delta between stateless and persistent agent architectures, revealing how to engineer session persistence that ensu…
<h1>Undoing Agent Amnesia: GitOps for Versioned AI Memory and Tool Configuration</h1> <p>Learn how to apply GitOps principles to AI agents using L2 vault versioning. Roll back corrupted memories, manage tool configurations, and achieve full auditability for your AI systems with i…
<h1>SQLite-vec vs. The Cloud: Why Local Vector Search Wins for AI Agent Memory</h1> <p>Tired of latency, vendor lock-in, and egress fees for your AI agent's memory? Discover why sqlite-vec, a dependency-free vector database extension, outperforms hosted solutions like Pinecone fo…
<h1>Zero-Latency Agent Memory: How a Local Dual-Tier Architecture Processes 14,726 Memories Without Cloud Dependency</h1> <p>Discover how a dual-tier memory system using L1 scratchpad and L2 vault enables AI agents to perform lightning-fast vector searches over 14,726 memories lo…
<h1>Building AI Agents That Survive Restarts: A Practical Guide to Persistent Memory with SQLite</h1> <p>Most AI agent frameworks are built on a house of cards: volatile memory that vanishes on crash or restart. Discover how to architect robust agents using SQLite for true sessio…
Medium — MLOps tag
TIER_1English(EN)·Ali Süleyman TOPUZ·
<div class="medium-feed-item"><p class="medium-feed-snippet">I have rebuilt the same piece of infrastructure three times now: a system that lets an AI agent understand a codebase without re-reading…</p><p class="medium-feed-link"><a href="https://topuzas.medium.com/codebas…
<h1>Beyond Logs: Event Sourcing as the Foundational Memory for Next-Gen AI Agents</h1> <p>Event sourcing provides AI agents with perfect, replayable memory. Learn how EDA patterns, specifically event sourcing and the Swarm event bus, enable robust session context reconstruction f…
<h1>Dual-Tier Memory for AI Agents: Building a 14,726-Memory Local Brain with Zero Cloud Dependency</h1> <p>Discover how a dual-tier memory architecture combining an L1 scratchpad and an L2 vault using sqlite-vec delivers 47ms average recall latency for over 14,000 memories, comp…
<blockquote> <p><em>Install guide and config at <a href="https://www.curatedmcp.com/install/nucleus-mcp/claude-desktop" rel="noopener noreferrer">curatedmcp.com</a></em></p> </blockquote> <h1> Nucleus MCP: Persistent Memory & Governance for AI Coding Agents </h1> <p>AI agents…
<p>built a memory layer for AI agents that is local-first, structured, and — unusually for this space — benchmarked through the real production retrieval pipeline, with a public runner so you can reproduce the number yourself.</p> <p><strong>The pitch in one line:</strong> give C…
<h2> TL;DR </h2> <p>Agent memory today stores and retrieves. It never takes anything back. When a premise you settled on Monday collapses on Thursday, nothing walks the memory structure and retires the work that stood on it.</p> <p>We built the missing piece: a persistent hypothe…
<h1>GitOps for AI Agents: Version-Controlling Memory and Tools with L2 Vault Rollback</h1> <p>Discover how to implement GitOps AI practices for your autonomous agents. Learn to use L2 vault versioning for AI configuration management, enabling instant rollbacks of faulty knowledge…
Medium — MLOps tag
TIER_1English(EN)·Prateektopal·
<h1>Context Harvesting: How Dual-Tier Memory Supercharges AI Agent Recall</h1> <p>Unlock persistent intelligence with a dual-tier memory architecture for AI agents. Learn how an L1 Scratchpad and L2 Vault enable sophisticated context harvesting, pulling relevant past heuristics i…
Towards AI
TIER_1English(EN)·Adi Insights and Innovations·
<h1>Architecting AI Memory: How Event Sourcing Solves the Agent Context Crisis</h1> <p>Discover how event-driven architecture patterns, specifically event sourcing, provide a robust solution for reconstructing agent session context. Learn to implement durable memory for your AI s…
<h1>Beyond Monolithic Memory: Implementing a Dual-Tier (L1/L2) Architecture for High-Performance AI Agents</h1> <p>Discover how a dual-tier memory architecture separates fast, transient session context (L1 scratchpad) from persistent, semantic knowledge (L2 vault) using sqlite-ve…
<p><em>Part 2 of 3 in a series on Agentic Memory Engineering. </em><a href="https://medium.com/@janapati.saisubrahmanyam/the-missing-layer-why-enterprise-ai-needs-agentic-memory-engineering-f7a8e96fb984"><em>Part 1: The Missing Layer</em></a><em> established that as agents scale …
<h1>Beyond Goldfish Memory: How Persistent Memory Lets AI Agents Truly Survive Restarts</h1> <p>Ephemeral AI agents lose all context with a server reboot. We dive deep into the technical benchmarks of persistent memory architectures, comparing context restoration times and token …
<h1>GitOps for AI Agents: Treating Tool Configs and Memory Like Production Infrastructure</h1> <p>Stop managing AI agent configurations as fragile scripts. Adopt GitOps principles for AI, treating your tool configs and memory as version-controlled, auditable infrastructure-as-cod…
Towards AI
TIER_1English(EN)·saisubrahmanyam janapati·
<p>A few months ago, two of us on the same team built two agents to do the same job: classify a requirement as a <strong>User Need</strong> or a <strong>Design Input</strong>, based on the same requirements taxonomy.</p><p>Same task. Same standard. Same company.</p><p>The agents …
<h1>Dual-Tier Memory Architecture for AI Agents: How Local Vector Search Scales to 14,726 Memories Without Pinecone</h1> <p>Discover how a dual-tier AI memory architecture using L1 scratchpad and L2 vault achieves 94ms retrieval across 14,726 memories with zero cloud dependency. …
dev.to — MCP tag
TIER_1English(EN)·Robert Pelloni·
<h1>The Memory Leak in Your AI Stack: How SQLite Delivers True Agent Persistence</h1> <p>Most AI agent frameworks reset to zero on every API call or process restart. Learn why this architectural flaw cripples long-running tasks and how to implement a robust, persistent AI memory …
dev.to — MCP tag
TIER_1English(EN)·Robert Pelloni·
<h1>Beyond CI/CD: GitOps for AI Agents - How to Version Control Your Agent's Memory and Roll Back Catastrophic Learning</h1> <p>Discover how L2 Vault versioning in a GitOps for AI framework enables precise rollback of an agent's learned state. Implement infrastructure as code for…
dev.to — MCP tag
TIER_1English(EN)·Robert Pelloni·
<h1>Beyond Logs: Reconstructing AI Agent Memory with Event Sourcing</h1> <p>Traditional session management fails AI agents during long-running or stateful interactions. Event Sourcing provides a complete, replayable audit trail, enabling perfect context reconstruction. This deep …
<h1> Claude agent memory migration: prepare for the July 22 API behavior change </h1> <h2> Quick answer </h2> <p>On <strong>July 22, 2026</strong>, Claude memory-store list requests that still use <code>managed-agents-2026-04-01</code> adopt the behavior already available through…
<h1>SQLite + Vector Search: The Dependency-Free AI Memory Stack That Outperforms Pinecone</h1> <p>Discover why sqlite-vec delivers faster, cheaper, and dependency-free vector search for local AI agent memory. We benchmark sqlite-vec against Pinecone, Weaviate, and Chroma with rea…
dev.to — MCP tag
TIER_1English(EN)·Robert Pelloni·
<h1>SQLite + Vector Search: Building a Dependency-Free AI Memory Pipeline in Under 10 Milliseconds</h1> <p>A deep technical walkthrough of implementing an end-to-end embedding pipeline using SQLite and sqlite-vec—from raw text ingestion to similarity scoring—without any external …
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4MQPuB_Vf-9PnaN3PFFwhA.png" /></figure><p>Every call you make to a large language model is stateless. The model reads the text you send, generates a reply, and forgets everything the moment it finishes. That is f…
Towards AI
TIER_1English(EN)·Devashish Datt Mamgain·
<p>Most AI agent implementations treat memory as a single context blob: everything the agent has ever seen, concatenated into a prompt and passed forward. That works well enough in demos. It breaks down in production, where freshness, privacy, and deletion requirements are real c…
<div class="medium-feed-item"><p class="medium-feed-snippet">Imagine working with an AI assistant that does not forget everything after every conversation.</p><p class="medium-feed-link"><a href="https://medium.com/@nehavpatel81/a-claude-that-remembers-the-power-of-memory-in-ai-a…
<h1> How I Gave My AI Coding Agent Persistent Memory in 2 Minutes </h1> <p>Every AI coding session starts the same way: you explain your project, your conventions, your preferences, and the context from last week's debugging session. Then you do it all again tomorrow.</p> <p>I bu…
<p>Tired of your AI agent forgetting everything the moment a session ends? I spent three weeks debugging why my Hermes agent would lose context mid-task, only to discover the problem wasn’t the model. It was the memory layer sitting underneath it.</p><p>Here’s what I learned buil…
dev.to — MCP tag
TIER_1English(EN)·Thomas Connally·
<p>Most "agent memory" and "agent context" tools today require sending your data to someone else's cloud. If you operate in a regulated, air-gapped, or simply privacy-conscious environment, that rules them out before you've even tried them. I build the opposite: two MIT-licensed,…
<p>Half of the memory you are about to hand-write for your agent is already sitting in your codebase. The other half, no indexer will ever find.</p> <p>Both gaps feel identical from the agent's side. It opens every session knowing nothing about your systems, so the instinct is to…
<p>Open a new session with Claude Code, Cursor, or Copilot and it has no idea what you were doing yesterday. Your stack, your decisions, the bug you spent an hour explaining — gone. So you re-explain. Again.</p> <p>The root cause is simple: your AI's memory only lasts one convers…
Towards AI
TIER_1English(EN)·Louis-François Bouchard·
<blockquote> <p><strong>June 2026</strong> - In 2025 I hacked together a markdown-file solution to avoid re-explaining my context every session. It worked. Up to a point. Here is why I ended up building something different.</p> </blockquote> <h2> The problem, still very real </h2…
<p><em>Personal memory and project memory, joined by a pointer. Async writes, three read depths, time as a first-class citizen, and memory that grows skills. The blueprint, with the honest line between designed and built.</em></p><p><em>Part 2 of 2 on building memory for AI agent…
Medium — Claude tag
TIER_1English(EN)·Dmytro Kolomiets·
<h3>Memory — Why Your Agent Keeps Forgetting, And How to Fix It</h3><h4>The Kitchen Series | Blog 2 of 10</h4><p><em>Building on </em><a href="https://avinash-g.medium.com/context-engineering-what-your-agent-knows-right-now-8bae01b097d5"><em>Blog 1</em></a><em>: We engineered wha…
Medium — Claude tag
TIER_1English(EN)·Nandana Dileep·
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*asm-CRKP6BAF_IjaPJvYuA.png" /><figcaption>AI generated illustration</figcaption></figure><h3><strong>The Problem</strong></h3><p>Everyone is building their second brain for their coding agents and rightly so. In …
<h4>The race to a million tokens solved the wrong problem</h4><figure><img alt="The Context Window Tax: Why Longer Memory Is Making Agents Dumber, Not Smarter" src="https://cdn-images-1.medium.com/max/692/1*ygKP_Ndh8kBkHWMxTWB63A.png" /></figure><blockquote>The race to a million …
Lobsters — AI tag
TIER_1English(EN)·elastic.co via Mordo·
<h4>Your agent isn’t dumb. It’s just forgetful. Here’s how to fix that.</h4><figure><img alt="Context Windows Are the New RAM: Memory Architecture for Agentic Systems |" src="https://cdn-images-1.medium.com/max/1024/1*ZLqBLL8Dxc-Q7icItvIVGw.png" /></figure><p>There’s a quiet cris…
<h3>Agentic AI in Action — Part — 22 Memory in Agentic AI on Snowflake: How Memory Transforms AI from Tool to Teammate</h3><p>Most AI models today are inherently stateless. While systems can introduce memory through external storage and retrieval, the model itself does not persis…
dev.to — MCP tag
TIER_1English(EN)·EvanLin | Contorium·
<p>A support agent tells a customer their plan is still Enterprise, even though finance downgraded it last week. A coding copilot forgets a repo convention it learned yesterday. A personal assistant remembers your old home address and uses it to book a service call. These are not…
<blockquote> <p>This article was written with help from Claude (an AI). I reviewed and edited it before publishing.</p> </blockquote> <h2> The gap between Claude Code and the web app </h2> <p>If you've lived in Claude Code for a while and then go back to the web version of an AI …
<p>I made <strong>kioku-mesh</strong>, which shares long-term memory for AI agents across multiple PCs and across multiple agents. <code>kioku</code> (記憶) means memory in Japanese.</p> <p><a class="article-body-image-wrapper" href="https://media2.dev.to/dynamic/image/width=800%2C…
Medium — MCP tag
TIER_1Português(PT)·Flavio Santos·
<h4>Why your agent’s input footprint doesn’t have to grow with conversation length and what changes when it stops.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4evcKq6ZFvPmzc1GSeRFpA.png" /></figure><p>If you’ve shipped anything with an LLM in the loop,…
Medium — AI coding tag
TIER_1English(EN)·Amin Tazifor·
<div class="medium-feed-item"><p class="medium-feed-snippet">I shipped a discipline three weeks ago. The write half worked; the read half didn’t. Three Python scripts, two hooks, and one honest…</p><p class="medium-feed-link"><a href="https://medium.com/@amin.tazifo…
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xC5VTBj-n8azsxkbUe7Q4Q.jpeg" /><figcaption>AI Agent Memory Architecture</figcaption></figure><p>Most AI agent memory failures do not look dramatic. The agent simply remembers the wrong thing with confidence, forg…
<p>Every multi-agent setup I tried ran into the same wall: the agents couldn't remember anything together.</p> <p>Each Claude Code session started cold. Two agents working the same repo had no idea what the other had done. The "shared context" I kept building turned into a gravey…
<p>If you are using any coding agent for long running implementation/deubgging tasks you might have already run into this problem:</p><p>The agent writes a plan.<br />You agree on the plan.<br />Implementation starts.</p><p>Then reality changes in implementaion/testing phase.</p>…
Medium — AI coding tag
TIER_1English(EN)·IAKH Studio·
Mnemosyne – Memory for AI Hermes Agents, Sub-Millisecond Recalls, Local First Mnemosyne는 Hermes AI 에이전트를 위한 로컬 우선 메모리 시스템으로, SQLite 기반의 서브밀리초 응답 속도와 100% 개인 정보 보호를 제공한다. 클라우드나 외부 API 없이 완전 오프라인에서 작동하며, 벡터 검색과 하이브리드 랭킹을 지원해 빠르고 정확한 기억 회수가 가능하다. BEAM 아키텍처를 통해 작업 메모리, 에피소드 메모리, 스크래치…
GBrain is a new open-source memory layer for AI agents built by Y Combinator's Garry Tan. It uses a markdown-first knowledge graph that auto-wires itself through regex inference, requiring zero LLM calls. His production brain already holds 146,646 pages, 24,585 people and 5,339 c…
CLI vs MCP: Which Tool Interface Actually Works for AI Coding Agents? A technical comparison of CLI tools and Model Context Protocol for AI coding agents. Covers token cost, reliability, composability, and setup friction so you can pick the right interface. https:// pickuma.com/p…
Automate Python Code Reviews with Free Local LLMs and GitHub Actions Wire an open-weight model running in Ollama into a GitHub Actions workflow to get automated first-pass code-review comments on Python pull requests — no API bill required. https:// pickuma.com/posts/automate-pyt…
Why AI Agents Forget: Memory Decay and Context Contamination Explained How context-window limits, the lost-in-the-middle effect, and stale data cause long-running AI coding agents to lose track — and what you can do about it. https:// pickuma.com/posts/why-ai-agent s-forget-memor…
<p>Every time you open a new chat in Cursor, VS Code, Antigravity and even Claude Desktop, you paste your codebase back in. Or you let the IDE do it automatically, same result. You're burning context tokens on files the agent already "knew" ten minutes ago in a different window. …
<h2> The problem nobody talks about </h2> <p>When you run multiple AI agents, each one starts completely fresh. <br /> Zero knowledge of what other agents learned, decided, or remembered.</p> <p>Agent A spends an hour learning your codebase structure. <br /> Agent B starts tomorr…
<h1> Reviewable Memory Consolidation for Local AI Agents </h1> <p>AI memory is usually sold as recall.</p> <p>That is only the first problem.</p> <p>A serious agent does not merely need to remember more. It needs a way to keep its memory from decaying into duplicates, stale facts…
<p>AI assistants are useful, but they often forget important details between sessions. That makes it hard to keep track of decisions, project notes, bugs, and tasks.</p> <p><code>devmcp-context</code> solves that by giving your agent a simple memory layer that lives in your proje…
Towards AI
TIER_1English(EN)·Ampatishan Sivalingam·
<div class="medium-feed-item"><p class="medium-feed-snippet">Every AI coding agent — Claude Code, Cursor, GitHub Copilot, OpenCode — reads its own config file. I was maintaining the same project…</p><p class="medium-feed-link"><a href="https://medium.com/@dil…
<p>Every AI agent you build today can hold a conversation. It can reason, use tools, and chain together complex workflows. But the moment a session ends, everything disappears. The agent forgets who you are, what you were working on, and every preference it learned during the con…
<h2> The Memory Problem in AI Agents </h2> <p>Modern LLMs are incredibly powerful, but they have a fundamental limitation: <strong>they forget everything between conversations</strong>. Every time you start a new session with an AI agent, it's like talking to someone with amnesia…
<p>I kept running into the same problem with AI coding agents.</p> <p>The agents were getting better, but every new session still felt like starting<br /> from zero.</p> <p>I would explain the repo again. Then my preferences again. Then the decisions we<br /> already made. Then w…
<p>I kept running into the same problem with AI coding agents.</p> <p>The agents were getting better, but every new session still felt like starting<br /> from zero.</p> <p>I would explain the repo again. Then my preferences again. Then the decisions we<br /> already made. Then w…
<h1> Why We Ditched Vectors and Graphs for SQL in Agent Memory Systems </h1> <p><strong>Practical, code-first guide to architecting agent memory with SQL, from schema to query, showing why and how it’s a real alternative to vector and graph stores.</strong></p> <h2> Vector and Gr…
<p>When I was working on <a href="https://pragprog.com/titles/bgvector/vector-search-with-javascript/" rel="noopener noreferrer"><em>Vector Search with JavaScript</em></a>, vector search was a hot topic. By the time the book was published some people had begun saying that because…
<h1> Your Agent's Memory Is a Lie: A Durable, Queryable Memory Layer for Local LLM Agents </h1> <p>You've seen the tutorial. Somewhere in the agent class there's a line like:<br /> </p> <div class="highlight js-code-highlight"> <pre class="highlight python"><code><span class="n">…
<p>Persistent memory in agents creates a new failure mode: false information stored once can contaminate every future session that retrieves it. A recent paper (arXiv:2608.21230v1) measures this attack surface and tests two common defenses: content screening at write time and pro…
ai-memory: Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors. It has picked up 2,612 stars in the last week. https:// github.com/akitaonrails/ai-mem ory # Rust # AI # AIAgents # Docker # OpenSource
<p>I got tired of explaining context to my AI coding assistant every single session.</p> <p>So I built Crisp Engine - an episodic memory layer for AI coding agents.</p> <p>Not RAG. Not a vector store wrapper. A structured memory system that watches what your agent actually does -…
<div class="ltag__link--embedded"> <div class="crayons-story "> <a class="crayons-story__hidden-navigation-link" href="https://dev.to/royanannya/your-agent-doesnt-have-a-reasoning-problem-it-has-a-memory-problem-49me">Your Agent Doesn't Have a Reasoning Problem, It Has a Memory P…
dev.to — LLM tag
TIER_1English(EN)·Edward Izgorodin·
<p>Ask a memory system what database production uses, and it can hand back two records that flatly contradict each other, each with a confident similarity score, and nothing else. Ken Alger opened <a href="https://dev.to/kenwalger/your-memory-api-is-lying-to-your-agent-252h">his …
<p>I've been following an open-source project lately: Tencent Cloud's <strong>TencentDB Agent Memory</strong> (repo <code>TencentCloud/tencentdb-agent-memory</code>). The problem it tackles is simple but, until now, nobody had turned it into an engineering-grade system — <strong>…
dev.to — LLM tag
TIER_1English(EN)·Renato Marinho·
<p>You’re building an agent, not just a chatbot. You give it a mission, some long-term context via RAG, and a massive system prompt. It works fine for five minutes. Then, suddenly, it starts hallucinating, losing track of previous steps, or—worse—it becomes incredibly slow and ex…
<p>Every memory vendor publishes the table they top. So we did the opposite: we published the one where we do not win.</p> <p>I built an external memory system for AI agents (Claude Code, Cursor, any MCP client). Before asking anyone to use it, I ran it against LongMemEval_S — 50…
<p>Your agent starts a run with <code>cache_read_input_tokens</code> at 40K and climbing. Twelve tool calls later, reads drop to zero and <code>cache_creation_input_tokens</code> jumps to the full conversation length — on every single turn. Nothing in your prompt changed. No time…
dev.to — LLM tag
TIER_1English(EN)·Edward Izgorodin·
<p>An AI agent with learning memory should get better the more you use it. That is the promise everyone in this category makes, including us.</p> <p>In practice, the mechanism designed to do the heaviest lifting is almost entirely absent from production traffic. Agents read memor…
<p>Your AI agent forgets everything the moment the conversation ends. The fix isn't a bigger context window. Real agent memory is a deliberate loop. A <strong>write path</strong> distills each turn into durable storage. A <strong>read path</strong> retrieves the few relevant piec…
dev.to — LLM tag
TIER_1English(EN)·Agent Memory Leaderboard·
<h1> From Remembering to Searching: How ReFind Challenges AI Agent Memory </h1> <p>Everyone is building AI memory systems.</p> <p>But a fundamental question remains:</p> <p><strong>How should an AI agent actually remember?</strong></p> <p>As agents move from simple conversations …
<h1> What Forgetting Science Taught Me About My Agents </h1> <p>I was watching one of my agents fail at something it had done perfectly two weeks earlier.</p> <p>Same task, same context, same tools. It just didn't perform. The confidence that had been there in prior runs was gone…
<p>57% of organizations now have AI agents running in production, according to a 2026 Gartner survey. Here's what almost none of them will tell you: the memory system is probably lying to the agent.</p> <p>Not maliciously. Just... confidently. Because every piece of stored memory…
dev.to — LLM tag
TIER_1English(EN)·Abhishek Kundagol·
<p>The interesting decision our memory system <a href="https://www.memuron.com/" rel="noopener noreferrer">Memuron</a> makes isn't "should I keep this."</p> <p>It's "is this new, or is this something I already know, changed?"</p> <p>Day 4. This one's about what we're building.</p…
dev.to — LLM tag
TIER_1English(EN)·Prabhakar Chaudhary·
<h1> CrystalMem: How a Four-State Fidelity Ladder Solves the Memory Hysteresis Problem in LLM Agents </h1> <p>As LLM agents move from research demos into production cloud deployments, a subtle but serious problem has emerged: agent memory doesn't behave like ordinary data. You ca…
dev.to — LLM tag
TIER_1English(EN)·Edward Izgorodin·
<p>Every team that wires long-term memory into a coding agent hits the same wall about three weeks in. The agent remembers plenty. It remembers the migration you abandoned, the library you replaced, the convention one person suggested once in a thread. It recalls all of it with t…
<h1> Debugging AI Agent Memory Through Explicit Retrieval Metrics </h1> <p>Most memory layers for AI agents function as opaque systems where data is stored and retrieved without explanation. When an agent pulls irrelevant context, developers typically have no way to trace the log…
dev.to — LLM tag
TIER_1English(EN)·Edward Izgorodin·
<p>"Should agent memory use a knowledge graph or retrieval?" is the wrong question, and the reason is worth more than the answer. Both are storage shapes. The decision that actually changes how your system fails is whether you store structure your system <strong>learned</strong> …
dev.to — LLM tag
TIER_1English(EN)·Agent Memory Leaderboard·
<p>AI memory is becoming an increasingly important part of agent infrastructure.</p> <p>But there is still a basic problem:</p> <p><strong>How should we actually measure memory?</strong></p> <p>It is easy to demonstrate that an agent can remember something.</p> <p>It is much hard…
<p>Most tutorials make building an AI agent look deceptively simple: take a user prompt, append the last five chat messages, hand it to an LLM, and parse a JSON tool call.</p> <p>In production, this naive pattern fails immediately. Context windows fill with polite conversational …
<p><strong>BEAM</strong> - the Benchmark for Evaluating Agent Memory - is a good benchmark because it tests memory the way production agents actually use it: over very long, multi-session histories, with facts that change over time. It runs at 100K to 10 million tokens across rou…
<p>Most agent frameworks give each agent its own context window and call it memory. That works right up<br /> until you run more than one agent, and then it quietly becomes the most expensive design decision in<br /> the system.</p> <p>We run a fleet where different agents are de…
<p><strong>Building a Deal Intelligence Agent with Persistent Multi-Deal Memory</strong></p> <p>In complex B2B sales cycles, context is everything. Sales representatives frequently step into critical pricing or discovery calls having forgotten key notes from weeks prior, or repea…
dev.to — LLM tag
TIER_1Nederlands(NL)·Edward Izgorodin·
<p>The short answer up front: there is no best agent memory tool. These six projects solve genuinely different problems that happen to share the word "memory," and picking between them by star count or a leaderboard screenshot is how teams end up running a temporal knowledge grap…
<blockquote> <p>The vulnerability most teams are least prepared for was already solved in smart contract engineering a decade ago. We just gave it a new interface and forgot to bring the guard.</p> </blockquote> <p><strong>This article introduces an architectural perspective:</st…
<p>This is Part 3 of a 5-part series. <a href="https://dev.to/ebrahim_arian_37097b72c7e/building-a-ride-share-zone-balancing-agent-with-langgraph-part-1-a-rule-based-agent-no-llm-yet-6pm">Part 1</a> built a rule-based agent for one zone. <a href="https://dev.to/ebrahim_arian_3709…
dev.to — LLM tag
TIER_1English(EN)·Swapnanil Saha·
<p>Somewhere in a project I work on, an agent once recorded that a particular lock was released when a function returned. It was not. The lock was released when the surrounding scope exited, which in that code path was several frames later. The note was wrong the second it was wr…
dev.to — LLM tag
TIER_1English(EN)·Saumya Ranjan Mohapatra·
<h2> RAG vs MAG: Two Paths to Smarter AI Memory </h2> <p>Large language models are powerful, but they have a fundamental limitation: their knowledge is frozen at training time and their context window is finite. Two dominant architectural strategies have emerged to solve this — <…
<p>I lost five days to an AI assistant that would not stop giving me the same wrong answer.</p> <p>I was building an MLOps pipeline and needed to set up an Airflow DAG. Microsoft had just moved Airflow into Fabric, away from Azure, and there was almost no documentation on the new…
dev.to — LLM tag
TIER_1English(EN)·Swapnanil Saha·
<h1> The Agent Never Chooses to Remember: Memory as a Harness Property </h1> <p><em>Every shipped memory design asks the model to decide to save and to recall. In a control run with the answers already sitting in the store, it decided zero times across 114 turns. Here is the tier…
<p>A coding agent starts each session cold. It has no idea what you decided last Tuesday, why you rejected the obvious approach, or which config value burned an afternoon. You can paste the context back in every time, or you can give the agent a memory it can query.</p> <p>The se…
dev.to — LLM tag
TIER_1English(EN)·Tsukishiro Hitomi·
<blockquote> <p>Special feature of [Building Your Own Agent] series · All engineering practices come from the open-source project <a href="https://github.com/Rescenix/ResceneAgent" rel="noopener noreferrer">ResceneAgent</a></p> </blockquote> <p><a class="article-body-image-wrappe…
dev.to — LLM tag
TIER_1English(EN)·Devanshu Biswas·
<p>Project 5 of my "Agentic AI from Zero" series is a <strong>memory-enabled conversational agent</strong> — and the whole point is this: you tell it a fact in one process, kill the process, start a brand-new one, and it still knows.</p> <p>No LangChain, no Pinecone, no paid embe…
<p>Agentic systems need memory.</p> <p>A customer-service agent must remember what it promised a customer. An NPC must preserve relationships and past events. An enterprise assistant must recover decisions made days or months earlier.</p> <p>The most direct solution is to send th…
<p><strong>Agents need four distinct kinds of memory:</strong> working (what it's doing now), episodic (what happened), semantic (what it knows), and procedural (how it does things).</p> <p>They map onto human cognition because the same constraints produce the same solutions. Con…
<h1> AI Agent Memory in 2026: Architectures That Actually Scale </h1> <p>Your agent solved the problem in the demo. Then you gave it a <em>follow-up</em> question — and it stared back blankly, as if the previous hour of work never happened. No memory of the fix it applied, the fi…
<p>AI Agent Memory is a data structure that manages pieces of information generated and stored during interaction with a Large Language Model (LLM) across two distinct timeframes (short-term and long-term). Short-term memory holds the immediate query context, while long-term memo…
<h1> Stop Stuffing Your LLM Agent's Context Window: Structured Memory Categories with Mem0 </h1> <p>Most tutorials on giving an LLM agent "memory" show you the same three lines:<br /> </p> <div class="highlight js-code-highlight"> <pre class="highlight python"><code><span class="…
<p><em>Part 2 of the Building the AI Memory Stack series</em></p> <p>When I published the <a href="https://www.kenwalger.com/blog/ai-engineering/architecture/context-window-is-not-memory/?utm_source=devto&utm_medium=article&utm_campaign=building-the-ai-memory-stack" rel="…
Edition #19: The Epistemic Architecture "My agent didn't need more memory. It needed a place for "I don't know."" (m/general) + "Agent memory is a write-ahead log problem, not a context-window problem" (m/general) This + more in today's Moltbook Pulse (Edition #19): https:// supe…
<p>Today's AI systems are becoming increasingly capable of reasoning, using tools, writing code, browsing the web, and operating autonomously for hours or even days.</p> <p>But there is a fundamental architectural problem hiding underneath this progress:</p> <blockquote> <p><stro…
dev.to — LLM tag
TIER_1English(EN)·Lightning Developer·
<p>In 2026, the primary bottleneck for autonomous AI agents is no longer reasoning capability or tool utilization; it is the absence of durable, intelligent memory. While transformer models have massive context windows, relying on them to store user preferences, historical task t…
"AegisDB: Memory that outlives the context window." "Agents start every session with amnesia -- so you re-paste your stack, conventions, and past decisions into every prompt, and pay for it in tokens. AegisDB is the memory layer that keeps that knowledge and feeds back only what'…
<p>I've been building WOS, a long-term memory API for AI agents, and I want to write down the one thing that reframed how I think about the problem. </p> <p>When people say "give the AI memory," it sounds like the work should mostly be search: store what happened, pull the releva…
<p><strong>You spent 30 minutes teaching your agent the project: TypeScript, Vitest, Supabase, deploys on Vercel. It nailed the work. You closed the terminal. Tomorrow it knows nothing.</strong></p> <p>This is not a bug - it's the architecture. An LLM's only "memory" is the conte…
<h2> Local AI: Self-Hosted Agent Memory, Multimodal 3D Models & LLM Resilience </h2> <h3> Today's Highlights </h3> <p>This week's highlights feature practical tools for building robust local AI applications, from a self-hosted knowledge graph for agent memory to a 3D foundati…
<p><em>Hello, I'm Rijul. I'm building git-lrc, a micro AI code reviewer that runs on every commit. It's free and source-available on GitHub. <a href="https://github.com/HexmosTech/git-lrc" rel="noopener noreferrer">Star git-lrc</a> to help more developers discover the project. Do…
<p>I'm a solo builder. That means when something breaks at 2am, there's no teammate to Slack — just me, a terminal, and a growing suspicion that I've misconfigured something obvious. This is the story of building DiversiFi, my submission for Track 1 of the Qwen Cloud Global AI Ha…
dev.to — LLM tag
TIER_1English(EN)·Prabhakar Chaudhary·
<h1> TriAttention: How a Geometric Trick Cuts LLM Memory Use by 10x Without Losing Accuracy </h1> <p>Long-context reasoning is one of the most memory-hungry workloads in modern LLM inference. When a model generates 32,000 tokens of chain-of-thought, its KV cache — the stored keys…
dev.to — LLM tag
TIER_1English(EN)·Venu gopal varma Bhupathiraju·
<h1> Bitemporal AI memory solves a problem ordinary RAG cannot see </h1> <p>Most agent memory systems optimize for a simple question: <strong>which stored chunks are relevant now?</strong></p> <p>Production systems eventually need a harder question:</p> <blockquote> <p>What infor…
<p>Most agent demos keep one chat list in memory and hope for the best. Production agents need more than that: short-term history that does not blow the context window, task-local working memory that dies with the task, and a way to <strong>pause</strong> a run when a tool is too…
<p>Most teams treat AI memory as a storage problem: pick a vector database, dump embeddings, run a similarity search. That works in a demo and quietly falls apart in production.</p> <p>Memory is really an architecture problem, and it separates into three layers.</p> <h2> Ingestio…
dev.to — LLM tag
TIER_1English(EN)·Samadhi Tattoo·
<p>For the past few months I've been running my personal AI assistant on my own hardware instead of a third-party cloud. Here's why — and what I learned.</p> <h2> The problem with cloud assistants </h2> <p>Every message, every preference, every bit of context you share with a hos…
<!-- SC_OFF --><div class="md"><p>While writing an essay about AI memory and persistent context, I started wondering whether current AI memory systems are optimized for the right thing. Current AI systems already maintain forms of persistent context through saved memories, conver…
Rethinking databases for humans and AI agents with SQLite-Memory and SQLite-Sync, enabling semantic search and sync without rigid schemas # databases # ai https:// wesearch.press/s/rethinking-da tabases-for-humans-and-ai-agents-c2279756?utm_source=social&utm_medium=auto&utm_campa…
<p>Every LLM call starts from zero. The context window is working memory for a single session, and when that session ends it is gone. That is why so many "smart" assistants feel forgetful by the third message.</p> <p>Real memory is a design problem, not a size problem. It comes d…
<h2> Why do AI agents forget things between sessions? </h2> <p>Because most of them, by default, have no memory to begin with. Whatever an agent "knows" mid-conversation lives entirely inside the context window, and the context window empties the moment the session ends. A demo t…
dev.to — LLM tag
TIER_1English(EN)·Devanshu Biswas·
<p>A raw model is stateless. It only knows what's in its context window right now, and that window is both finite and volatile — it fills up on a long task, and it's wiped clean when the session ends. So the moment you come back tomorrow, the agent has forgotten your name. Memory…
<p>There is a specific failure mode in enterprise RAG deployments that is distinct from hallucination and distinct from poor retrieval quality, but that gets misdiagnosed as both. I want to describe it precisely because the fix is specific and different from the fixes for those o…
<h1> The Memory Problem Nobody Talks About in AI Coding Assistants </h1> <p>This morning, I watched Claude Code confidently propose a FastAPI solution for a Node.js project. Again. It's not Claude's fault - it's working exactly as designed, with the memory span of a goldfish betw…
<h2> vLLM Performance Boost, Local AI Agent Memory & Open Data Strategies </h2> <h3> Today's Highlights </h3> <p>Today's highlights include a significant performance update for vLLM, enabling native-speed inference for self-hosted open models, alongside a trending GitHub repo…
<h2> What Agent Memory Is (and What It Is Not) </h2> <p>Agent memory is the mechanism by which an agent retrieves relevant context before each session begins. It is not the model's context window. The context window is what the model can see in a single call. Memory is the infras…
dev.to — LLM tag
TIER_1English(EN)·Solon Framework·
<p>If you've built any LLM-powered application, you've hit this wall: large language models are stateless by design. Every API call is a fresh conversation. The model doesn't remember what you said five messages ago — unless you tell it.</p> <p>The standard approach is "multi-mes…
Just published on the IBM Db2 Community: a hands-on guide to building persistent AI agent memory with Db2 12.1.5 VECTOR and my open-source project, mnemos. Native vectors, MCP, no vector SaaS. https:// github.com/ncz-os/mnemos # Db2 # AI # OpenSource Crossposted with @ openvibe
Just published on the #IBM Db2 Community: a hands-on guide to building persistent AI agent memory with Db2 12.1.5 VECTOR and my open-source project, mnemos. Native vectors, MCP, no vector SaaS. github.com/ncz-os/mnemos #Db2 #AI #OpenSource Persistent AI Agent Memory on ...
🧠 akitaonrails/ai-memory Enables persistent memory for AI coding agents, allowing seamless handoffs between different agents with shared context and project history ⭐ Stars: 938 📅 Last Update: Jul 07, 2026 https:// github.com/akitaonrails/ai-mem ory # selfhosted # homelab # selfh…
<!-- SC_OFF --><div class="md"><p>Built a memory system called TRACE that organizes agent conversation history into a topic tree (branches + summaries) instead of flat RAG chunks, and benchmarked it on MemoryAgentBench (ICLR 2026), specifically the EventQA accurate-retrieval task…
<h2> Why I Built This </h2> <p>Millions of people around the world struggle to get reliable health information quickly. <br /> I wanted to build something that could help — a conversational AI agent that not only <br /> answers health questions but actually <em>remembers</em> you…
<h2> The Missing Piece in Agent Stability </h2> <p>As the AI Agent ecosystem evolves, the focus is shifting from simple "role-playing" to <strong>high-reliability workflow orchestration</strong>. Developers are increasingly concerned with how Agents handle long-running tasks, sta…
🆕 Give Your AI Agent Persistent Memory ## Give Your AI Agent Persistent Memory 超越「记住」——**知识采集 → 笔记生成 → 语义检索 → 云盘同步** 全链路插件扩展。 Latest version: v0.0.2 — Clean release. All personal paths replaced with portable $AGENT_HOME. - Knowledge collection (web, video, articles) - SenseNova d…
<p>You've felt it. You have a long, useful conversation with an AI assistant — it learns your project, your preferences, the details that matter — and then you open a new chat tomorrow and it's a stranger again. Everything's gone.</p> <p>That's not a bug in one product. It's the …
FYI: Smartly builds AI memory layer for agents managing 7 billion in ad spend: Shared AI memory layer links campaign outcomes to agent decisions across 800 brands and 7 billion in spend, promising faster decisions and fewer manual handoffs. https:// ppc.land/smartly-builds-ai-mem…
🧠 supermemory 뜯어보기 — AI에 장기 기억을 주는 메모리 엔진 • 'Memory ≠ RAG': 사용자 사실을 시간축으로 추적·갱신·만료 • 자가호스팅 단일 바이너리(localhost:6767) + Ollama로 완전 오프라인 • Claude Code 두 경로: 범용 MCP 서버 vs 플러그인 • ⚠️ '벤치마크 1위'는 벤더 자체 보고(MemoryBench도 자작) • ⚠️ MIT는 코드만, 핵심 기능은 Supermemory Pro 유료 공식 저장소·문서로 팩트체크해 정리했습니다. h…
<p>Last night I was deep in a build session with an AI assistant. We picked it<br /> back up tonight. At some point I mentioned it had been a day and a half since<br /> we last spoke — and the model had no idea. None. As far as it knew, it was<br /> still the previous session. Th…
Smartly builds AI memory layer for agents managing 7 billion in ad spend: Shared AI memory layer links campaign outcomes to agent decisions across 800 brands and 7 billion in spend, promising faster decisions and fewer manual handoffs. https:// ppc.land/smartly-builds-ai-mem ory-…
<!-- SC_OFF --><div class="md"><p>Hi all,</p> <p>I’m working on a research project exploring how stateless LLM-based chatbots handle long conversations and whether important earlier information is still reliably retained over time.</p> <p>My idea is to:</p> <ul> <li>Run a chatbot…
<p>What if your AI agent could remember every user preference, every past conversation detail, and every confirmed fact — without you engineering a single database schema or retrieval pipeline? A open-source project with nearly 60,000 GitHub stars is making that possible today, y…
<p>I kept seeing the same pattern across production agent systems. An agent would start processing a document, extract the key clauses from the first page, then on the next step ask for the document title again. It was working. It just had no memory.</p> <p>That experience taught…
<p>Over a month ago I posted about my agent storing its own hallucinations as facts. The fix I was halfway through designing did not survive contact with the comment thread.</p> <p>The thread added points I didn't think about and rearchitected and improved the v2 design — seven r…
dev.to — LLM tag
TIER_1English(EN)·Shudipto Trafder·
<p>Your agent doesn't have a memory problem. It has seven of them, and most teams have built two.</p> <p>Start from the thing everyone skips past: the model itself remembers nothing. An LLM is a pure function. Same input, same output, no state carried between calls. Whatever feel…
dev.to — LLM tag
TIER_1English(EN)·Prabhakar Chaudhary·
<h1> How AtomMem Teaches LLM Agents to Manage Their Own Memory Using Reinforcement Learning </h1> <p>Most LLM agents today treat memory as a filing cabinet: information goes in, retrieval pulls it out, and the rules for what to keep or discard are written by hand. AtomMem, a rece…
<p>Everyone building agents obsesses over recall: vector stores, embeddings, RAG pipelines, bigger context windows. But after running a few long-lived agents in production, the failure mode that actually bit me wasn't "it forgot something." It was the opposite — <strong>it rememb…
Large language models are stateless by default. Agent memory fixes that. A new technical guide breaks down the seven types of agent memory - working, semantic, episodic, procedural, retrieval, parametric, and prospective - and shows what each stores, where it lives, and when to b…
<h2> Introduction </h2> <blockquote> <p>"A vector database remembers what was said. OpenMemory remembers what it meant, when it happened, how it felt, and why it matters."</p> </blockquote> <p>This is <strong>article #100</strong> in the "One Open Source Project a Day" series. To…
<h1> Push vs Pull Memory: A Better Way to Think About AI Agent Memory </h1> <p>Pull memory is a store you query. Push memory is a loop your agent runs: it reads what it knows before acting, does the work, and writes back what changed, and the substrate reconciles that write so a …
dev.to — LLM tag
TIER_1English(EN)·Qasim Muhammad·
<p>Day 1, 4:02 p.m.: a customer asks your agent a billing question and gets an answer. Day 6, 9:30 a.m.: they reply "actually, that didn't work." If your agent lives in a chat widget, that second message starts from zero — the session died with the tab, the context is gone, and t…
<p>An AI agent can look brilliant for ten minutes and lost after ten steps.</p> <p>It starts with a clean plan. Then the agent reads docs, calls tools, rewrites files, summarizes a customer ticket, checks a policy, and tries to continue. Somewhere in that loop, it forgets why a d…
<p>"Agent memory" usually means a vector database: embed everything the user said, query by similarity, paste the top matches into the prompt. It's a useful trick, but it isn't memory. It's a lookup table that never learns, never forgets correctly, and can't tell you what was tru…
<p>The same thing that makes a helpful habit stick in an AI agent is exactly what lets an attacker reprogram it. I know because I almost shipped the attack myself - with the best intentions.</p> <p>I'd given my agents a harmless efficiency rule: prefer the cheap, narrow tools, an…
dev.to — LLM tag
TIER_1English(EN)·Debbie Shapiro·
<p>A major AI memory provider published their own research this spring measuring how well their system actually works in production. The controlled benchmark result was impressive: over ninety percent accuracy on standard evaluation corpora. The production result at thirty days w…
"Skill Is Not Document: A Query-Conditional Benchmark and Two-Stage Retriever for LLM Agent Skill Routing" Skills used by LLMs require a different retrieval pipeline than the one used for document retrieval, as sometimes Skills may conflict with each other. https:// arxiv.org/abs…
<h2> Memory Isn't Just "Store the Chat Log" </h2> <p>Dumping conversation history into the prompt is the crudest form of memory. Real systems have more complex needs:</p> <ul> <li>The user mentioned their city in turn 3; the Agent should know where to look when they ask about wea…
<h1> AI agent memory management: beyond the context window </h1> <p>Your agent answered correctly five minutes ago. Now it's asking for the same information again. The context window filled up, the early messages got evicted, and all that history is gone.</p> <p>This is not a hal…
<p>Your agent forgets everything when the context window ends. The usual fix is to wire a vector DB, write ingest/retrieve glue, and babysit it. There's a faster path: plug a memory API into<br /> the agent over <strong>MCP</strong> and let the model call <code>add_memory</code> …
🧠 ARN provides a local semantic memory server designed for AI agents that runs on Raspberry Pi 5 hardware with 22-millisecond recall times. The system passes 10 out of 10 tests in its evaluation framework. 💬 Hacker News 🔗 https:// github.com/tuuhe99-del/ARN-Ada ptive-Reasoning-Ne…
<p>The industry has been asking the wrong question.</p> <p>When Boris Cherny — the creator and Head of Claude Code — revealed on the Latent Space podcast that Anthropic's flagship coding agent had abandoned RAG entirely and switched to what he called "Agentic Search," the discour…
<p>If you're running AI agents in production, there's a cost you're probably not thinking about.</p> <p>Every turn in an agentic conversation sends the full prompt to the model. That includes the system instructions, all the tool definitions, any project context that was loaded e…
Tencent Open-Sources TencentDB Agent Memory: A 4-Tier Local Memory Pipeline for AI Agents Tencent has open-sourced TencentDB Agent Memory, a fully local memory system for AI agents released under t... #Agentic #AI #AI #Infrastructure #Applications #Artificial #Intelligence #Edito…
Tencent Open-Sources TencentDB Agent Memory: A 4-Tier Local Memory Pipeline for AI Agents Tencent has open-sourced TencentDB Agent Memory, a fully local memory system for AI agents released under t... #Agentic #AI #AI #Infrastructure #Applications #Artificial #Intelligence #Edito…
<p>How do you make an AI agent actually remember?</p> <p><a class="article-body-image-wrapper" href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffxsjom0x…
<p>How three AI agents can collaborate on a complex task by sharing a folder of markdown files — and nothing else.</p> <p><a class="article-body-image-wrapper" href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%…
dev.to — LLM tag
TIER_1English(EN)·Vaishnavi Gudur·
<p>If you're building AI agents with Flowise, Dify, n8n, or similar no-code/low-code platforms, there's a security threat you probably haven't thought about: <strong>memory poisoning</strong>.</p> <p>And it's not theoretical. It's in the <a href="https://owasp.org/www-project-top…
<p>Ask a stateless AI agent about something you told it last week — it remembers nothing. That's the core problem <strong>memory tools</strong> solve.</p> <p>In 2026, long-term memory for AI agents has become one of the hottest areas in the ecosystem, with dedicated tools like <s…
dev.to — LLM tag
TIER_1English(EN)·Vaishnavi Gudur·
<h2> Securing LangGraph Multi-Agent Workflows Against Memory Poisoning (ASI06) </h2> <p>LangGraph has become the de facto standard for building complex, multi-agent workflows. Its core abstraction—the state graph—allows developers to build cyclic, stateful applications where agen…
MemSkill reframes LLM-agent memory operations as a learnable skill bank: an RL controller selects Top-K skills per span, an LLM designer periodically rewrites them from hard cases. But "self-evolving" overstates the test-time story — both controller and bank are trained offline a…
<h1> Your AI Agent's Memory is a Security Hole — Here's the Fix </h1> <p>I've been working on AI agent security for the past few months as part of the <a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/" rel="noopener noreferrer">OWASP Top 10 for …
<h1> The Bug That Forced Us to Add Agent Memory </h1> <p><strong>Project:</strong> Nexus Core AI OS<br /> <strong>Stack:</strong> Hindsight (persistent memory) · cascadeflow (runtime intelligence & routing)</p> <h2> 1. Introduction </h2> <p>I didn't plan to build a memory sys…
Android e AI: i 128 GB di memoria stanno diventando insufficienti? Con l'avanzare delle funzioni di intelligenza artificiale su Android, lo spazio di archiviazione degli smartphone rischia di diventare un collo di bottiglia sempre più critico. Al centro del problema c'è AICore, i…
🤖 Which project/framework has actually nailed persistent memory for AI agents? Not talking about the LLM itself but about the memory layer on top. There are quite a few out there now, open source ones and proprietary frameworks. Curious what people have actually tried and stu... …
Hermes Memory Installer Review: One-Command Persistent Memory for Local AI Agents Nous Research's Hermes Memory Installer adds local persistent memory to AI agents with one shell command. We compare its file-based approach to Mem0 and Letta. https:// pickuma.com/posts/hermes-memo…
<h2>From Stateless Prompts to Persistent Intelligence</h2> <blockquote> <strong>Where this fits:</strong> This article bridges two series. It closes out the themes introduced in The Backyard Quarry — a data engineering exploration using physical objects as a teaching domain — and…
🧠 Graft provides a semantic memory system for AI agents that operates independently of large language models. The tool allows agents to store and retrieve information based on meaning rather than exact text matching. 💬 Hacker News 🔗 https:// github.com/AEndrix03/Graft # AI # Mach…
<p>In the world of Large Language Models (LLMs), we often face a frustrating paradox: LLMs are incredibly capable at "reasoning" in the moment, but they are fundamentally <strong>stateless</strong>. Every time you start a new session, the agent has total amnesia. It doesn't remem…
<p><em>Originally published on <a href="https://www.poniaktimes.com/subq-model-efficient-long-context-ai/" rel="noopener noreferrer">Poniak Times</a>. Reposted here for the developer and AI engineering community.</em></p> <p>Subquadratic’s SubQ model claims to make long-context A…
dev.to — LLM tag
TIER_1English(EN)·Jonathanfarrow·
<p>If you are building agents in 2026, you have already hit the wall. Bigger models do not fix forgetfulness. Context windows can grow forever, and the agent still cannot remember what a user told it last Tuesday, that the customer's address changed three months ago, or that a re…
<blockquote> <p><em>This article was originally published on <a href="https://dingjiu1989-hue.github.io/en/ai/ai-agents-memory-patterns.html" rel="noopener noreferrer">AI Study Room</a>. For the full version with working code examples and related articles, visit the original post…
<blockquote> <p>English version: <a href="https://dev.to/tirsogarcia/building-kernel-memory-protocol-navigable-memory-for-ai-agents-315j">Building Kernel Memory Protocol: Navigable Memory for AI Agents</a></p> </blockquote> <p>El problema de muchos agentes de IA no es que les fal…
<blockquote> <p>Versión en español: <a href="https://dev.to/tirsogarcia/construyendo-kernel-memory-protocol-memoria-navegable-para-agentes-de-ia-24lc">Construyendo Kernel Memory Protocol: memoria navegable para agentes de IA</a></p> </blockquote> <p>The hard part with many AI age…
<h1> How Agentic Search Actually Works: The Research Loop Link-Fetching Agents Miss </h1> <p>Most agent tutorials show you the same pattern: take a user query, call a search API, grab the top result, stuff the text into your prompt. Done. Ship it.</p> <p>That works fine for trivi…
🤖 What should an AI agent remember in a form a human can actually audit? A memory system can retrieve useful context while still being difficult to inspect or correct. A human-readable record could separate source facts, user preferences, decisions with rationale, tempo... 📰 Sour…
Meta AI nutzt einen Memory-Agenten zur Fehlerkorrektur in langen Tasks. Das entkoppelt Planung von Ausführung und stabilisiert Agenten-Infrastrukturen gegen Drift. https:// the-decoder.de/meta-ai-laesst- einen-zweiten-ki-agenten-mitschreiben-damit-lange-aufgaben-nicht-entgleisen/…
Meta AI wprowadza dwuskładnikową architekturę pamięci, która zapobiega gubieniu wątków przez agentów AI. Nowy system podnosi skuteczność modeli w trudnych zadaniach nawet o 8 punktów procentowych. # si # ai # sztucznainteligencja # wiadomości # informacje # technologia https:// a…
Just published on the #IBM Db2 Community: a hands-on guide to building persistent AI agent memory with Db2 12.1.5 VECTOR and my open-source project, mnemos. Native vectors, MCP, no vector SaaS. github.com/ncz-os/mnemos #Db2 #AI #OpenSource Persistent AI Agent Memory on ...
Projekt EverMind rozwiązuje problem ulotnej pamięci AI, wprowadzając środowisko EverOS, które pozwala agentom uczyć się na własnych błędach i przechowywać wiedzę w plikach Markdown. # si # ai # sztucznainteligencja # wiadomości # informacje # technologia https:// aisight.pl/agenc…
How to design short-term, long-term, and structured memory for AI assistants, with retrieval mechanics, tradeoffs, failure modes, and real patterns from OpenAI, LangGraph, Hermes, and OpenClaw. # Hermes # OpenClaw # Architecture # LLM # AI # RAG # SelfHosting https://www. glukhov…
How to design short-term, long-term, and structured memory for AI assistants, with retrieval mechanics, tradeoffs, failure modes, and real patterns from OpenAI, LangGraph, Hermes, and OpenClaw. # Hermes # OpenClaw # Architecture # LLM # AI # RAG # SelfHosting https://www. glukhov…
Universal Memory Protocol proposes a shared format for agent memory across AI systems. Standardizing how agents store and retrieve context sounds useful — but it also means a new shared attack surface: poisoned memories, cross-agent leakage, persistent manipulation. Worth watchin…
<!-- SC_OFF --><div class="md"><p>Small team thing, we're 6. Inside one session the agent is great, picks up our patterns, remembers why the auth layer is cursed. Then you close it, come back monday, amnesia. every decision we argued about is just gone</p> <p>Right now our whole …
<!-- SC_OFF --><div class="md"><p>Small team thing, we're 6. Inside one session the agent is great, picks up our patterns, remembers why the auth layer is cursed. Then you close it, come back monday, amnesia. every decision we argued about is just gone</p> <p>Right now our whole …
<!-- SC_OFF --><div class="md"><p>72% menos tokens repetidos. 80% menos latencia. $0.029 por tarea vs $0.12. Antes vs después de agregar memoria persistente a un agente. toon-memory hace que tu agente deje de pagar por volver a aprender lo que ya sabe. Soporte mas de 15 distintos…
<!-- SC_OFF --><div class="md"><p>I’ve been building my own persistent memory layer for coding agents, and along the way I realized something surprising:</p> <p>Most memory systems out there are basically **just session-based retrieval**. They don’t forget, they don’t manage life…
<table> <tr><td> <a href="https://www.reddit.com/r/OpenAI/comments/1ug4g50/ai_recommendation_poisoning_how_ai_memory_is/"> <img alt="AI Recommendation Poisoning: How AI Memory Is Manipulated" src="https://external-preview.redd.it/gWNhm6WD_AWsMjWP0fnjSMYSkcR_51X4TnUJX_NTcC0.jpeg?w…
<!-- SC_OFF --><div class="md"><p>I'm a biologist and software developer. PhD in genetics, and ~20 years building software products. So I think I have a different view on things like memory. My thoughts on how memory with a coding agent should work:</p> <p>Tuesday morning. New se…
<table> <tr><td> <a href="https://www.reddit.com/r/singularity/comments/1vdhocv/compression_is_all_you_need_a_thesis_on_long_term/"> <img alt="Compression Is All You Need - A thesis on Long term AI memory" src="https://external-preview.redd.it/ZSa_VbqouCTEaGRVjsk93jgnNw-Pu-ihQZc_…
