Agents Are Stuck in a Loop: Memory Growth and Propagation Siddharth 2026-04-20 25.0 KB 142.6K 163 ☆ 收藏 𝕏 文章列表 文章深入探讨了 AI Agent 面临的记忆系统瓶颈：无限记忆增长（UMG）导致检索效率低下和噪声干扰，以及虚假记忆传播（FMP）利用思维链错误放大幻觉。作者指出现有的 RAG 系统因读写混合而加剧了该问题，并提出可以借鉴强化学习（RL）机制，根据任务验证结果对记忆进行奖惩打分，从而过滤无效记忆。 AgentLLMMemoryRAGReinforcement LearningHallucinationMemGPTCoT 67 值得读 ▶ 文章精准切中了当前Agent发展中的核心痛点（记忆无限增长与错误记忆传播），分析透彻且提出了RL验证等较新颖的解决思路，但由于结尾截断，未能提供完整的落地操作指南。 # Agents Are Stuck in a Loop. Memory Growth and Propagation is why ! **作者**: Siddharth **日期**: 2026-04-19T16:33:38.000Z **来源**: [https://x.com/Pseudo_Sid26/status/2045903661042479135](https://x.com/Pseudo_Sid26/status/2045903661042479135) ---  Agents are in an unapologetic loop. They somehow never have the right memory and the bandwidth. You give them a long task, they hallucinate something mid way, store it, retrieve it later, and now that hallucination is load bearing. That's not a model problem. That's a memory problem. These 2 problems are the main bottlenecks when it comes to agent memory at scale: Uncontrolled Memory Growth: memory continues piling up without intelligent eviction, causing the entire system to choke because of too much history. False Memory Propagation: after storing one single false fact, this piece of information will repeatedly be retrieved and reinforced, and before you know it, the agent ends up being absolutely certain about anything and everything. Lets discuss both of these problems in detail with simple intuitions, as well as a list of other reasons why this keeps happening. ## Memory in Agents: A Quick Preview When people say agent memory they usually mean one of three things. > Firstly, there’s in context memory – the prompt window. > Secondly, there’s external memory, e.g., a vector database, an offloaded file generated by the agent itself. > Thirdly, there’s parametric memory – memories acquired via the learning process and thus cannot be updated while the agent runs. Production agents today rely primarily on the first two types, having a window of rolling context along with a retrieval store for the older information. This sounds reasonable until you realize neither system has good answers for what to forget, what to trust, or what to do when something wrong gets stored. The MemGPT paper is one of the few serious attempts at thinking about this as a real systems problem. They treat the LLM as a CPU and memory tiers as explicit architectural components. Worth reading if you haven't. The core insight is that you need deliberate memory management, not just a naive one.  ## Uncontrolled Memory Growth (UMG) This is how most agent pipelines work in reality. Every action, every tool output, every intermediate idea ends up stored in the memory bank. Nothing is ever forgotten. The logic is that the more context there is, the better. No way !!!! It leads to excessive noise, slows down retrieval, and ultimately leads to retrieving obsolete information in place of relevant new data. > Vectors do not have expiry. Embeddings keep on accumulating infinitely, while older embeddings get further away from being relevant. > Retrieval time will increase linearly with the size of the vector store, particularly when performing long-running multiple-step agent workloads. > Outdated information does not simply lie dormant. Instead, it comes to light through query embeddings that inadvertently retrieve stale information, corrupting present-day inference processes. > There is no intrinsic notion of this information is now outdated in many information retrieval systems. Intuition: It often happens with us that we start making notes from the very first lecture in clg, a lot of those notes are rough, irrelevant, sometimes from different course too in the same notebook. Later on during exams, when we search for the right note, we struggle finding it, this is a classical example of uncontrolled memory in agents, the context starts to rot and finding appropriate answers from the context pool becomes difficult. ## False Memory Propagation (FMP) The FMP approach is more sophisticated and actually more frightening. First, there is one piece of information that is simply false. Perhaps the machine imagined some result from a tool call operation. Perhaps a user entered erroneous input. Perhaps the API provided bad data. For whatever reason, this false fact is recorded in memory. On the next recall, it comes out. It is used to reason about other things. The entire process is saved in memory. The Chain of Thought paper shows that reasoning chains dramatically improve accuracy. But there's a flip side nobody talks about. If the initial stage of the process chain was incorrectly formed and this stage turns out to be a part of memory, all subsequent processes will inevitably include the mistake. CoT acts as a power magnifier both for right and for wrong logic.  > It is not failure in appearance for FMP. The agent is certain, consistent, and totally wrong. > The more time the agent spends executing, the more ingrained the false memory becomes in the ranking of recall. > Standard measurement tools cannot detect this as they test only final results and not internal states. Intuition: Now, for me there is a very interesting intuition for this and we all have experienced this. Sometimes we write an exam and we copy some formula from someone else, or we do a project and someone does a certain calculation somewhere. Without confirming we move on and and eventually now everyone is using the wrong formula or calculated value. This is what false memory propagation in agents is, one wrong context or memory and it all scrambles. ## Why RAG Makes This Worse, Not Better Everyone falls back on RAG for memory. Of course, it's simple and elegant in concept. Find relevant documents, ground the generation, avoid hallucinations. It's perfect for cases where your knowledge base is carefully curated and static, like an internal corporate wiki or a set of legal documents. The issue lies in the fact that agents write into their retrieval databases. This is the fundamental flaw with the approach. Instead of sourcing information from a separate and pure data set, your retriever is now reading from a database that your agent has been writing to, possibly containing mistakes from past queries. > Ground truth is an assumption in RAG that the retrieval corpus holds. The agent memory is not ground truth; rather, it is the ongoing transcript of the agent’s thoughts. > Factual accuracy is not embedded in similarity. Two memories, one erroneous and one accurate, can be extremely similar if they fall under the same topic. > Each retrieval of the agent loop where a mistaken memory pops up is a signal of validation for that memory as well. ## RL as a Fix for FMP This is a dimension that is often overlooked by most individuals. In the case where FMP is a reinforcement problem, perhaps the solution to the problem can also be approached from the perspective of a reinforcement problem. In this regard, it will be possible to approach the validation of memories as a reward signal. When the agent uses a memory and applies it in a step in the reasoning process, the result of the step becomes the feedback to indicate the validity of the memory used. When the step results in the production of verifiable results, the agent increases the confidence score of the memory. However, when the step fails, the memory receives penalties and may be deleted. The InstructGPT paper laid out the RLHF framework for aligning model outputs with human preferences through reward modeling. The same logic extends naturally here. You're not scoring model outputs, you're scoring memory entries based on how reliable they prove to be over time.  > Reward signal is obtained from successful completion of the task, corrections made by the user, or verification of results with a known source. > Memories with low confidence ratings are not used for recall or are even deleted, interrupting the feedback cycle. > This system demands that each memory be uniquely identifiable and assessable, something current pipelines cannot provide. ## File-Based Memory as a Starting Point Before getting into building the full graph memory system, it is useful to implement a file based memory system first. The logic here is rather straightforward. While vector appending will do fine in the case of raw memories, adding structured memories to files that contain meta-information can be more beneficial. In particular, the metadata includes a timestamp, the importance of the memories, its source, and the level of certainty. As an example of how well it works in practice, the Generative Agents paper can be referenced. Namely, the memory stream they used included an importance score for the memories based on their relative importance according to the agent's perspective. Recall was then performed using the parameters of recency, importance, and relevance. > Metadata aware retrieval lets you filter out old or low-confidence memories before they even enter the ranking stage. > JSONL format keeps it auditable. You can inspect, debug, and manually correct memory entries, something you can't easily do with a black box vector store. > The access count field lets you track which memories are being retrieved most, which is a proxy for influence on agent behavior. ## Graph Memory as the Real Upgrade File based memory systems are decent. Graph-based memory systems are better. List-based memory systems treat each memory as separate data, which means they lack relational memory. User prefers Python and user's project uses asyncio are two separate memories that are related to each other. Storing and retrieving these two memories separately will mean that their relationship cannot be determined at retrieval time. Graph-based memory systems are based on the concept of nodes. Nodes represent the memories, while edges represent relations between memories. Relations include contradiction, dependency, derivation and updates. Retrieving any node also means traversing the edges, meaning you always get relational context and contradictions at retrieval time. > Detection of contradiction happens structurally, whereby the introduction of memory whose edge is marked contradicting will alert the system to do an investigation rather than overwriting it silently. > Using graph traversal helps achieve richer results through retrieval without having to increase the number of similarity queries. > MemoryBank proves that graph structured memory enables agents to retain far more consistent personae and factual information than would be the case with flat retrieval systems. > The derived from edge becomes particularly helpful in detecting FMPs because one wrong root memory generates several other memories that may need pruning. ## The Context Window is Not Your Friend Here People think bigger context windows solve memory problems. They don't. A 1M token context window just means you can fit more potentially wrong information in one shot. The retrieval problem doesn't disappear. It shifts. Instead of deciding what to retrieve, you're now deciding what to include in a very long prompt, and the model has to figure out what's relevant inside that wall of text. The Lost in the Middle paper showed something uncomfortable. LLMs perform significantly worse at using information that appears in the middle of long contexts compared to information at the start or end. So even if you dump everything into context, the model is not treating all of it equally. Position matters. Recency matters. The retrieval problem just moved inside the context window.  > Long context is merely a cheat to delay the problem, without addressing it. > The middle part of the context is automatically undervalued, meaning that any important memory stored there will simply be overlooked. > Intelligent external memory with selective recall always beats context dumping for complex multi stage processes. CONCLUSION The bottleneck for agents is not computation; it’s epistemology. An agent that can’t tell the difference between what it knows and what it believes itself to know cannot be trusted. UMG inflates the search space. FMP contaminates the data source. RAG pulls from a poisoned source. And a wider context simply means more poison to work with. The solution is not going to come from one research paper or even one framework. It comes from taking agent memories seriously, just like we take database management seriously. Schemas, validation processes, eviction strategies, scoring algorithms, audits. Until we do that, agents will continue to loop around, confidently but mistakenly. ## 相关链接 - [Siddharth](https://x.com/Pseudo_Sid26) - [@Pseudo_Sid26](https://x.com/Pseudo_Sid26) - [35K](https://x.com/Pseudo_Sid26/status/2045903661042479135/analytics) - [Upgrade to Premium](https://x.com/i/premium_sign_up) - [12:33 AM · Apr 20, 2026](https://x.com/Pseudo_Sid26/status/2045903661042479135) - [35.4K Views](https://x.com/Pseudo_Sid26/status/2045903661042479135/analytics) - [View quotes](https://x.com/Pseudo_Sid26/status/2045903661042479135/quotes) --- *导出时间: 2026/4/20 14:49:30* --- ## 中文翻译 # 智能体陷入循环。原因就在于记忆的增长与传播！ **作者**： Siddharth **日期**： 2026-04-19T16:33:38.000Z **来源**： [https://x.com/Pseudo_Sid26/status/2045903661042479135](https://x.com/Pseudo_Sid26/status/2045903661042479135) ---  智能体陷入了一个毫无歉意的循环。它们不知为何总是缺少正确的记忆和足够的带宽。你交给它们一个长任务，它们会在中途产生幻觉，把幻觉存储下来，之后再检索出来，于是这个幻觉就成了承重墙。这不是模型的问题，而是记忆的问题。 在大规模智能体记忆方面，这两个问题是主要的瓶颈： 不受控制的记忆增长：记忆在没有智能淘汰机制的情况下不断堆积，导致整个系统因历史数据过多而窒息。 虚假记忆传播：在存储了一条错误信息之后，这条信息会被反复检索和强化，不知不觉间，智能体就会对一切事物都变得无比确信——尽管全是错的。 让我们用简单的直觉来详细讨论这两个问题，以及其他一些导致这种情况持续发生的原因。 ## 智能体中的记忆：快速预览 当人们谈论智能体记忆时，通常指的是以下三种之一。 > 首先，是上下文内记忆——即提示词窗口。 > 其次，是外部记忆，例如向量数据库、由智能体自身生成的卸载文件。 > 第三，是参数化记忆——通过学习过程获得的记忆，因此在智能体运行期间无法更新。 如今的生产级智能体主要依赖前两种类型，即拥有一个滚动上下文窗口，同时配有一个用于存储较旧信息的检索存储库。 这听起来很合理，直到你意识到：对于该遗忘什么、该信任什么、以及当错误信息被存储时该怎么办，这两个系统都没有好的答案。 MemGPT 论文是为数不多的将其作为一个真正的系统问题来认真思考的尝试。他们将 LLM 视为 CPU，将记忆层级视为明确的架构组件。如果你还没读过，值得一读。其核心洞察是：你需要的是有意识的记忆管理，而不是朴素的管理方式。  ## 不受控制的记忆增长（UMG） 现实中大多数智能体流水线是这样工作的。 每一个动作、每一次工具输出、每一个中间想法，最终都被存储到记忆库中。 什么都不被遗忘。逻辑是：上下文越多越好。 才不是呢！！！！ 这会导致过多的噪声，拖慢检索速度，并最终导致检索到过时信息，取代相关的新数据。 > 向量没有过期机制。嵌入向量无限累积，而越旧的嵌入离“相关性”越来越远。 > 检索时间会随向量库的规模线性增长，尤其是在执行长时间运行的多步骤智能体工作负载时。 > 过时的信息并不会简单地沉睡。相反，它会通过查询嵌入被无意中检索出来，污染当下的推理过程。 > 在许多信息检索系统中，并不存在“此信息已过时”这一内在概念。 直觉解释： 我们经常遇到这种情况：从大学第一节课开始做笔记，很多笔记很粗糙、无关紧要，有时同一个笔记本里甚至混着不同课程的内容。 到了考试时，当我们想找正确的笔记时，却很难找到——这就是智能体中不受控制记忆的经典例子：上下文开始腐化，从上下文池中找到合适的答案变得困难。 ## 虚假记忆传播（FMP） FMP 这种方式更为隐蔽，实际上也更可怕。首先，存在一条完全错误的信息。也许是机器在工具调用操作中想象出了某个结果。也许是用户输入了错误的内容。也许是 API 返回了坏数据。无论出于何种原因，这个错误事实被记录进了记忆。在下次召回时，它被提取出来，被用来推理其他事情，而整个推理过程又被保存进记忆。 思维链（Chain of Thought）论文表明，推理链能显著提高准确性。但有一个没人谈论的反面。 如果过程链的初始阶段就出错了，而这个阶段又成为记忆的一部分，那么所有后续过程都将不可避免地包含这个错误。CoT 对正确和错误的逻辑都是强大的放大器。  > FMP 并不会在外表上表现为失败。智能体表现得很确定、很连贯，却错得彻头彻尾。 > 智能体运行的时间越长，虚假记忆在召回排序中的地位就越牢固。 > 标准的评估工具无法检测到这一点，因为它们只测试最终结果，而不测试内部状态。 直觉解释： 对我而言，有一个非常有趣的直觉来理解这一点，而且我们所有人都经历过。有时我们考试时抄了别人的某个公式，或者做项目时某个人在某处做了某个计算。我们没有核实就继续往下走，最终所有人都用上了错误的公式或错误的计算值。这就是智能体中的虚假记忆传播：一条错误的上下文或记忆，就能让一切全盘崩坏。 ## 为什么 RAG 让情况更糟，而不是更好 所有人都退回到用 RAG 来做记忆。当然，这个概念简单而优雅。找到相关文档，为生成提供依据，避免幻觉。它非常适合知识库经过精心整理且静态的场景，比如企业内部 wiki 或一套法律文档。 问题在于智能体会写入它们自己的检索数据库。这是该方法的根本缺陷。你的检索器不再从一个独立的、纯净的数据集中获取信息，而是从一个你的智能体一直在写入的数据库中读取，其中可能包含过去查询中产生的错误。 > 真值（ground truth）是 RAG 中对检索语料库的一个假设。智能体记忆并不是真值；它只是智能体思维过程的持续记录。 > 事实准确性并不包含在相似性中。两条记忆，一条错误、一条准确，如果它们属于同一主题，可能极为相似。 > 在智能体循环中，每次检索到一条错误记忆，也是对该记忆的一种验证信号。 ## 作为 FMP 修复手段的强化学习（RL） 这是大多数人经常忽视的一个维度。如果 FMP 是一个强化学习问题，那么也许也可以从强化学习问题的角度来寻求解决方案。在这个思路下，可以将记忆的验证作为一个奖励信号来处理。 当智能体使用某条记忆并将其应用于推理过程中的某个步骤时，该步骤的结果就成为指示所用记忆有效性的反馈。当该步骤产生了可验证的结果时，智能体会提高该记忆的置信度分数。 然而，当该步骤失败时，该记忆会受到惩罚，甚至可能被删除。 InstructGPT 论文提出了 RLHF 框架，通过奖励建模将模型输出与人类偏好对齐。同样的逻辑可以自然地延伸到这里。你评分的不是模型输出，而是记忆条目，依据是它们随着时间推移所证明的可靠程度。  > 奖励信号来源于任务的成功完成、用户做出的纠正，或通过与已知来源的核对对结果进行验证。 > 置信度较低的记忆不会被用于召回，甚至会被删除，从而中断反馈循环。 > 该系统要求每条记忆都能被唯一识别和评估，而当前的流水线无法做到这一点。 ## 基于文件的记忆作为起点 在构建完整的图记忆系统之前，先实现一个基于文件的记忆系统是很有用的。这里的逻辑相当直接。虽然向量追加对于原始记忆来说效果不错，但将结构化的记忆添加到包含元信息的文件中可能会更有益处。具体来说，元数据包括时间戳、记忆的重要性、其来源以及确定性等级。 作为其在实践中效果的示例，可以参考 Generative Agents 论文。具体而言，他们使用的记忆流中包含了基于智能体视角的相对重要性而给出的重要性评分。随后通过近因性、重要性和相关性这三个参数来进行召回。 > 具备元数据感知的检索让你可以在陈旧或低置信度的记忆进入排序阶段之前就将其过滤掉。 > JSONL 格式使其可审计。你可以检查、调试并手动修正记忆条目，这是黑盒向量存储难以做到的。 > 访问计数字段让你可以追踪哪些记忆被检索得最频繁，这是对智能体行为影响力的一种代理指标。 ## 图记忆作为真正的升级 基于文件的记忆系统还不错。基于图的记忆系统更好。基于列表的记忆系统将每条记忆视为独立的数据，这意味着它们缺乏关系型记忆。“用户偏好 Python”和“用户的项目使用 asyncio”是两条相互关联的独立记忆。分开存储和检索这两条记忆意味着在检索时无法确定它们之间的关系。 基于图的记忆系统建立在节点的概念之上。节点表示记忆，而边表示记忆之间的关系。关系包括矛盾、依赖、推导和更新。检索任何节点也意味着遍历边，这意味着在检索时你总是能获得关系上下文和矛盾信息。 > 矛盾的检测在结构上进行，即当引入一条其边被标记为矛盾的记忆时，系统会收到警示去进行调查，而不是静默地覆盖它。 > 使用图遍历有助于在不增加相似性查询次数的情况下获得更丰富的检索结果。 > MemoryBank 证明了图结构化记忆使智能体能够保持比扁平检索系统远为一致的人设和事实信息。 > "derived from"（派生自）这条边在检测 FMP 时特别有用，因为一个错误的根记忆会生成若干条可能需要修剪的其他记忆。 ## 上下文窗口在这里帮不了你 人们认为更大的上下文窗口能解决记忆问题。其实不能。一个 100 万 token 的上下文窗口只意味着你可以一次性塞入更多潜在错误的信息。检索问题并没有消失，只是转移了。你不再需要决定检索什么，而是要决定在一个非常长的提示中包含什么，而模型必须在那堵文字墙中弄清楚什么是相关的。 Lost in the Middle 论文揭示了一些令人不安的事实。与出现在长上下文开头或结尾的信息相比，LLM 在使用出现在长上下文中间的信息时表现明显更差。所以即使你把所有内容都塞进上下文，模型也不会平等地对待所有信息。位置很重要，近因性很重要。检索问题只是转移到了上下文窗口内部。  > 长上下文只是推迟问题的一种权宜之计，并没有解决问题。 > 上下文的中间部分会被自动低估，这意味着存储在那里的任何重要记忆都会被直接忽略。 > 对于复杂的多阶段流程，具备选择性回忆的智能外部记忆总是胜过简单堆砌上下文。 结论 智能体的瓶颈不在于计算，而在于认识论。一个无法区分“自己知道什么”和“自己以为自己知道什么”的智能体是不可信的。UMG（无根据记忆泛化）会膨胀搜索空间。FMP（错误记忆传播）会污染数据源。RAG 会从被污染的来源中检索。而更大的上下文窗口只意味着更多的“毒物”可供处理。 解决方案不会来自某篇研究论文，甚至不会来自某一个框架。它来自于我们像认真对待数据库管理那样，认真对待智能体的记忆。模式设计、验证流程、淘汰策略、评分算法、审计。在我们做到这些之前，智能体将继续原地打转——自信满满，却错得离谱。 ## 相关链接 - [Siddharth](https://x.com/Pseudo_Sid26) - [@Pseudo_Sid26](https://x.com/Pseudo_Sid26) - [35K](https://x.com/Pseudo_Sid26/status/2045903661042479135/analytics) - [升级到 Premium](https://x.com/i/premium_sign_up) - [12:33 AM · 2026年4月20日](https://x.com/Pseudo_Sid26/status/2045903661042479135) - [35.4K 次浏览](https://x.com/Pseudo_Sid26/status/2045903661042479135/analytics) - [查看引用](https://x.com/Pseudo_Sid26/status/2045903661042479135/quotes) --- *导出时间: 2026/4/20 14:49:30*
M Memory Transfer Learning for Coding Agents 技术解析 本文深入探讨了一篇关于编码智能体的 Memory Transfer Learning (MTL) 论文。文章解释了如何将过往编码任务的“记忆”复用到新任务中，比较了 Trajectory、Workflow、Summary 和 Insight 四种记忆格式的效果。研究通过在多个基准测试中复用异构记忆池，证明了提取的元知识能有效提升智能体解决新问题的能力。 技术 › Agent AVB 2026-04-21 AgentLLMMemoryTransfer LearningCoding AgentRAGReinforcement Learning论文解读
A Agent Memory Is Not a Search Problem 文章指出 Agent 记忆系统的核心问题不是检索而是上下文组织。跨 15 个模型、20 万模拟对话的研究显示，任务拆分为多轮会使准确率平均下降 39%，而合并为单轮可恢复大部分损失。文章回顾了 Agent 记忆的四个发展阶段（全量历史、滚动摘要、向量检索、知识图谱），批评语义/情景/程序性记忆分类无法指导检索决策，并主张按六种问题类型构建六种上下文形态。作者基于开源 Graphiti 引擎，以客户历史为例实操演示如何让记忆系统在模型运行前正确组织上下文，避免基于过时信息的自信回答。 技术 › Agent Akshay 2026-09-29 AgentLLMMemory知识图谱Graphiti上下文工程向量检索RAG
A Agent 系统中的上下文与记忆工程 本文探讨了在 Agentic AI 系统中，上下文工程与记忆工程如何解决不同问题。上下文工程专注于单次推理调用的设计，涵盖选择性包含、结构放置、压缩和历史管理；记忆工程则关注跨会话的持久化，涉及写入策略、存储层选择和检索策略。两者在检索边界交汇，共同决定了 Agent 在实际工作负载中的可靠性。 技术 › Agent beamnxw 2026-08-05 AgentMemoryContextRAGSystem DesignLLMEngineeringAI
A Agent 的数据面概念扫盲-建立技术侧认知体系 本文深入解析了 Agent 数据面的核心概念，将其比作操作系统的内存管理单元。文章详细阐述了 Context Engineering 的演变、Session/Thread/Profile 的架构差异，以及 Session Memory 与 Long-term Memory 的区别。作者还重点介绍了 Hermes 中的 Memory 设计方案、SQLite FTS5 与 BM25 算法原理，以及向量检索与关键词检索在 RAG 中的混合应用，旨在为开发者建立一套完整的 Agent 数据面技术认知体系。 技术 › Agent MateMatt 2026-07-12 AgentContext EngineeringRAGMemoryBM25SQLite FTS5向量检索HermesLong-term MemoryLLM
A Agent Memory Framework: Remember, Cite, Forget 本文提出了一个智能体记忆系统的可靠框架，该框架需同时完成三个核心任务：记住该记的、引用可信的、遗忘过期的。文章详细介绍了记忆的六个层级（如会话状态、项目记忆、索引检索等），阐述了如何通过权威排序解决冲突，并强调了通过硬过期、双时序或软衰减等机制让旧记忆失效的重要性。 技术 › Agent Vox 2026-05-23 AgentMemoryRAGLangGraphMem0ZepGBrainLLM系统架构工程实践
A Agentic Memory: 详解 Agent 记忆系统的架构与实现 文章通过生动的类比，指出缺乏记忆是当前 LLM Agent 的主要短板。作者详细拆解了 Agent 记忆系统的三个核心功能：连续性、上下文和学习。文章重点介绍了四种记忆类型：上下文记忆、外部记忆、情景记忆和参数记忆，并深入探讨了如何通过检索增强（RAG）和反思循环来构建持久的智能。 技术 › Agent Ramakrishna (techwith_ram) 2026-05-17 AgentLLMMemoryArchitectureRAGVectorStoreContextEpisodic向量数据库系统设计
A Agent Memory Engineering 文章探讨了 AI Agent 的记忆机制，解释了为何不同 Agent（如 Claude Code 和 Codex）之间无法直接通过复制文件来迁移记忆。作者指出，这是因为模型在后期训练时与特定的记忆层“融合”了。文章对比了 Hermes、Codex CLI 和 Claude Code 三种实现，并得出结论：最聪明的架构（如向量数据库、知识图谱）输给了最简单的方案（LLM + Markdown + Bash 工具）。核心在于 Agent 遵循的读写规范，而非数据结构本身。 技术 › Agent Nicolas Bustamante 2026-05-02 AgentMemoryLLMEngineeringClaude CodeCodexRAGPost TrainingMarkdownHermes
W Why Karpathy’s Second Brain Breaks at Agent Scale. How Mercury Solves It. 本文探讨了 Andrej Karpathy 的 LLM Wiki 工作流在人类“第二大脑”场景下的优势，指出其在处理 AI Agent 时的局限性。文章强调，人类记忆优先考虑可读性和反思，而 Agent 记忆系统则需要快速检索、低 Token 成本和冲突解决。Mercury 提出的混合架构方案，主张使用 Markdown 作为人类界面，同时采用结构化内存作为 Agent 的底层设施，以实现上下文的持续累积和可靠运行。 技术 › Agent Zaid 2026-04-29 AgentMemoryLLMKarpathyRAGMercuryArchitectureSecond BrainDesign
A AI 记忆工具两大阵营：Memory Backends 与 Context Substrates 文章深入分析了 GitHub 上的 AI Agent 记忆工具，将其分为两大阵营：一是“记忆后端”，如 Mem0 和 Supermemory，主要提取事实并存储于向量数据库；二是“上下文基底”，如 OpenClaw，通过人类可读的结构化文件让会话在上下文中累积。作者指出，虽然 Camp 1 主导了市场，但 Camp 2 的架构才是支持连续、多会话工作的未来方向，例如 Zep 已开始从“记忆”转型为“上下文工程”。 技术 › Agent witcheer 2026-04-17 AgentOpenClawMem0ContextMemoryRAGLLM向量数据库知识图谱
A Agent 高频题 01. 讲讲你的 RAG 链路 本文是 Agent 高频面试题详解系列第一篇，聚焦 RAG（检索增强生成）链路。文章基于近两个月牛客网 82 场面试的统计，指出 RAG 是最常被追问的题目。内容先给出 RAG 整体架构图，解释为什么需要 RAG 及其与长上下文、grep、微调、工具调用、记忆等方案的边界；再沿离线、在线两条线逐环讲解：离线部分涵盖文档解析、切分策略、embedding 向量化、HNSW/IVF 索引原理；在线部分讲解问题改写、BM25 与向量多路召回、RRF 融合、交叉编码器重排等环节。每个环节均附上面试常见追问，并提供复习优先级参考。 技术 › Agent 码良 2026-10-20 RAG面试检索增强生成向量检索embeddingBM25HNSW重排LLMAgent
深 深度体验 EverOS Cloud：让 Agent 记忆与经验沉淀为技能的测评 文章针对 AI Agent 开发中记忆缺失、RAG 低信噪比切片、状态冲突与多主体污染三大痛点，测评了 EverOS Cloud（API v2）这一 Agent 记忆操作系统。核心机制包括语义事件切割、记忆整合消解冲突、多主体严格隔离，在 LoCoMo 基准上达 93.05% SOTA，减少 90% 以上 Token 消耗。其自进化技能引擎可将任务执行链路沉淀为 Case 并蒸馏为可复用 Skill，任务成功率最高提升 234.8%。接入仅需两行核心调用，支持记忆治理 API、多模态资料挂载、MCP 协议兼容 Claude Code 等工具，以及云/本地双模部署。作者认为其适合需要跨会话跟踪意图与沉淀业务 SOP 的场景。 技术 › Agent 浅水虾 2026-10-20 Agent记忆系统EverOSRAGLLM测评MCPSkillToken优化
T The 2026 LLM Engineering Roadmap 本文提出了2026年LLM工程路线图，指出与LLM工作不只是提示词，生产级系统需要对LLM的工程化、部署和优化有深入理解。文章总结八大支柱：提示工程（将prompt当作代码管理）、RAG系统（嵌入、检索、重排）、上下文工程（管理上下文窗口中各类信息的取舍）、微调（LoRA/QLoRA等技术）、Agent（工具调用循环与编排、状态管理、重试逻辑），并为每个领域提供了大量免费开源学习资源，如Anthropic、OpenAI官方指南及多个GitHub教程仓库。 技术 › LLM Avi Chawla 2026-10-09 LLM提示工程RAG上下文工程微调Agent开源资源学习路线图
