← Agents From First Principles

记忆与选择性召回

把记忆定义为来自过去的受控影响,然后围绕合格性、来源、取代、冲突与检索策略构建选择性召回,而不是把存储或长上下文当作记忆。

能力边界给了智能体一个已定义的动作空间,以及每一步哪些能力合格的规则。运行时状态给了它一份显式的工作表示,记录这次运行到目前为止确立了什么、以及如何到达这一点。它们一起支配当前的执行,但两者都不给「更早一次运行的信息」一个受控的途径来影响这一次。有一整族失败恰好需要那个。

智能体撞上一种错误,而早先的运行已经诊断过它,它却又从头诊断一遍。用户三周前陈述了一条至今仍然生效的约束。一个策略上个月因某个理由失败了,而那个理由至今没有消失。一项策略昨天变了,而系统在一月学到的某样东西现在是自信地错的。

这些都是同一个问题穿着不同衣服。

过去什么东西应该影响下一个决定?

通常的答案是加一个向量数据库,这根本不是一个答案:它说出一个存储技术名,而人们要的是一套决定程序。

存储不是记忆。嵌入不是,对话历史不是,更大的上下文窗口也不是。这四样都是可以服务于记忆的机制。没有一个决定任何事。

工程的定义更窄、也更苛求:

记忆是一种受控的机制,让被选中的过去信息影响一个未来的决定。

那句话里的每个词都产生工作。选中意味着写入策略与读取策略。受控意味着影响是有界的、可检视的、可逆的。未来决定意味着:一条记录若不能改变任何决定,就没有权利要求进入存储。本章构建这些机制,并且把遗忘当作正确性的一部分,而不是维护工作。


1. 四个常被混淆的对象

在任何东西能被检索之前,四样东西需要各自独立的名字,因为它们的正确性规则各不相同。

对象 它回答的问题 正确性规则
执行轨迹 这次运行如何到达这一点? 仅追加的审计历史;更正靠追加,而不是重写
运行时状态 运行时当前把什么当作已确立? 显式、由证据导出;过期或错误的值是控制 bug
持久记忆 过去什么东西可能再次重要? 有范围的、可归因的、时间上有效的、可撤回的
模型上下文 这次决策模型能看到什么? 稀缺;为每个决策刻意投影

它们形成一组受控的投影,而不是一组可互换的存储。在一次运行之内,执行轨迹是最广的局部历史,运行时状态是当前要紧之物的一个结构化约简。持久记忆跨越运行,而不是坐在那个局部层级之内。模型上下文更窄:它是为某个决策刻意选出的工作视图。

这些表示之间的每次转换,都是运行时拥有的一个决定。

    flowchart TD
    T[执行轨迹] --> A[持久审计历史]
    T --> S[运行时状态]
    S --> C[模型上下文]
    M[持久记忆] -->|被触发时检索| C
    C --> D[模型决策]
    D --> T
  

实际后果是一条关于事实住哪里的规则。如果运行时从当前执行确立了 state.payment_sent is True,它就应该读那个字段。它不应该去问一个语义检索器要那条与字符串“已付款”最相似的记录,因为相似度没有办法把这次付款与上周二讨论过的某次付款区分开;而控制决策上的一次险些命中,结果是重复付款,而不是一个稍差的答案。

精确控制属于状态。

记忆可以用模糊的相关性来恢复潜在可适用的信息,但检索并不让该信息成为权威。精确的范围、身份、有效性与权限检查仍属于相似度排序器之外。

同一条规则贬低了对话历史。一段长的对话记录完全可能包含“migration 014 已经完成”这句话,但如果那个事实支配 migration 014 是否再跑一次,它就必须先被提升进结构化状态,成为 state.completed_migrations.add(14),然后才被信任。不应该要求模型通过阅读散文重新发现执行不变量;而且一段对话记录对这句话现在仍然为真、它曾经为真、或它能活过摘要化,都提供不了任何保证。历史善于保存细微差别与证据,不善于被查询。

如果一个事实重要到要用于确定性控制,就在把它当作记忆之前,先把它表示为状态。


2. 生命周期是写入、管理、读取

一个记忆系统至少有三个阶段,而大多数生产问题来自把它们坍缩成一个。2026 年一项关于自主 LLM 智能体记忆的综述,正是围绕这个循环为整个领域定框,把巩固、可信检索与习得性遗忘列为开放问题。[7]

    flowchart LR
    O["观察 / 结果 / 指令"] --> W
    subgraph W[写入]
        W1[写入决定] --> W2[带范围与来源的类型化记录]
    end
    W --> M
    subgraph M[管理]
        M1[巩固] --> M2[取代] --> M3["过期 / 撤回"]
    end
    M --> R
    subgraph R[读取]
        R1[触发] --> R2[合格性] --> R3[排序] --> R4[冲突] --> R5[预算]
    end
    R --> D[模型决策]
    D -->|归因| M
  

向量索引——如果存在的话——坐在那张图的一个格子里。

它是一个排序实现,不是一套架构。

天真的系统根本没有生命周期:

for message in conversation:
    memory.add(message)

那产出一堆倾倒物。

一周之内,存储里就装满了问候语、被放弃的草稿、转瞬即逝的工具输出、失败的猜测、重复的观察、在同一会话内被取代的事实,以及一个不可信网页要求被记住的任何文本。于是检索质量变成一个任何重排器都修不好的排序问题,因为那条有用的记录在与成千上万条本不该写下的记录竞争。

因此一次记忆写入需要本书对每个其他模型输出所持的同一立场:

模型可以提案某信息应该留存。运行时决定它是否能比这次运行活得更久。

最便宜的写入策略主要是拒绝。不要持久保存以下信息:已经是权威状态的信息、没有可信未来用处的、来自工具输出的原始不可信指令,以及没有附带证据的模型生成主张。把不确定的材料隔离起来,而不是把它提升到与已验证结果同一个池子里。

一个小型处置类型足以让那个决定可见:

from dataclasses import dataclass
from enum import StrEnum

class WriteDisposition(StrEnum):
    DISCARD = "discard"
    QUARANTINE = "quarantine"
    PERSIST = "persist"

@dataclass(frozen=True)
class MemoryWriteDecision:
    disposition: WriteDisposition
    reason: str

模型仍然可以帮助判断一个情节是否可复用,或两个观察是否表达同一条教训。它不拥有的是让任意文本耐久的权威。

写入路径正是确定性规则以最少的聪明做最多工作的地方。


3. 五种记忆,按契约区分

工作、语义与情景记忆的词汇来自认知科学,它在这里作为工程简写有用,而不是主张软件像大脑。让这个区分挣到位置的是:五种记忆确实有真正不同的晋升门槛与寿命。

种类 持有 示例 寿命 写入门槛
工作 运行局部的、非权威的近期决策草稿 本次运行已查看过的文件 本次运行 低;绝不能仅因它在上下文里就被晋升
语义 可复用的命题 “该 API 返回 HTTP 200,正文里带一个错误码” 直到被取代、过期或撤回 需附带证据、范围与有效性条件
情景 尝试过什么、结果如何 一次失败的修复及其失败证据 长,带相关性衰减 需记录结果与证据
程序 从反复的情节晋升而来的策略 一份导入失败的调试手册 直到环境变动 需反复的支持加验证
前瞻 等待线索的延迟意图 “当 build 913 完成时,复查它的失败” 直到触发或取消 需显式请求或可信工作流

工作记忆很少配得上嵌入,它也不是第 06 章那个权威的运行时状态。它是草稿信息,可能帮助策略在运行内推理:候选假设、已查看的文件、中间笔记,或最近失败的一个紧凑投影。任何重要到能确定性支配执行的东西,都属于 RunState。如果一张字典或关系表就能解决草稿问题,那才是正确的实现,有趣的设计工作在别处。

情景记忆带着一个容易失去、失去代价也高的区分。服务重启可以执行成功,而中断仍在继续。补丁可以干净应用,而测试仍然失败。如果存储只记下 restart_service → success,它就扔掉了让这个情节值得保留的那个事实,而未来的运行将兴高采烈地重复一个已被证明不起作用的策略。Reflexion 是最早的示范之一,表明保留的试验反馈能改善后来的尝试;[2] 可迁移的点不是它的架构,而是它的前提:过去失败只有在适用性活过存储时才对计算有用。

程序记忆是写入门槛最要紧的地方。一次幸运的结果是一个情节。把它变成塑造未来计划的规则,需要来自若干情节的证据;一个急着晋升的系统,会为那些只成功过一次的东西积累自信的手册。

前瞻记忆是另一个问题,因为那条记录不是要被回忆的东西,而是必须被触发的东西。这使它成为一种调度机制,需要一个显式的表示:

@dataclass(frozen=True)
class DeferredIntention:
    id: str
    action: str
    trigger_kind: str
    trigger_value: str
    status: str = "pending"

def due(intent: DeferredIntention, event: dict[str, str]) -> bool:
    return (
        intent.status == "pending"
        and event.get(intent.trigger_kind) == intent.trigger_value
    )

显式地测试线索,而不是指望模型在长上下文的某个地方注意到相关事件,就是全部机制。于 2026 年七月发布的 PM-Bench,评估的正是这种能力:智能体是否能把延迟意图跨过中间活动保留下来,并在线索到达时行动。它报告的最佳配置达到 65.1% F1。[6] 干扰下的保留不是已解决的能力;把它当作调度而不是召回,才是让它可测试的东西。


4. 一条记录是类型化对象,不是带向量的字符串

from dataclasses import dataclass, field
from datetime import datetime
from enum import StrEnum

class MemoryKind(StrEnum):
    SEMANTIC = "semantic"
    EPISODIC = "episodic"
    PROCEDURAL = "procedural"
    PROSPECTIVE = "prospective"

class Authority(StrEnum):
    UNTRUSTED = "untrusted"
    MODEL_INFERRED = "model_inferred"
    HUMAN_INSTRUCTION = "human_instruction"
    VERIFIED_OUTCOME = "verified_outcome"
    AUTHORITATIVE_SOURCE = "authoritative_source"

@dataclass(frozen=True)
class MemoryRecord:
    id: str
    kind: MemoryKind
    content: str
    created_at: datetime
    scope: dict[str, str]
    provenance: dict[str, str]
    authority: Authority = Authority.MODEL_INFERRED
    asserts: str | None = None
    asserted_value: str | None = None
    valid_from: datetime | None = None
    expires_at: datetime | None = None
    supersedes: tuple[str, ...] = ()
    retracted: bool = False
    evidence_ids: tuple[str, ...] = ()
    derived_from: tuple[str, ...] = ()
    sensitivity: str = "normal"
    metadata: dict[str, object] = field(default_factory=dict)

有四个字段值得评论。asserts 点出争议中的命题,例如 "refund_threshold" 或 "test_command",而 asserted_value 在存在时存储一个规范值。这使第 8 节能检测相互矛盾的结构化主张,而不把两个措辞不同的解释当作不同的事实。supersedes 使时间上的取代显式化,derived_from 为第 11 节的删除遍历保留谱系。

authority 刻意保持粗糙。它不让一条记录变真;它记录产出它的是哪一类来源,这样一个当前的权威来源就能压过旧的模型推断,而不必请另一个模型重新发现那套层级。

嵌入故意缺席。它可以存在于存储实现内部,但一条记录的语义契约远大于它的检索向量,而把向量放进类型,会邀请存储变成决定什么回来的唯一东西。


5. 合格性先于相似度

假设一个编码智能体跨五十个仓库工作,而记忆里有 run tests with pytest -q tests/unit。这对仓库 A 是对的、对仓库 B 是有害的,再多嵌入质量也无法区分它们,因为这两个情形确实语义相近。它们在一个字段上不同。

所以检索不应该以“找出全局最相似的记忆”开场。它应该以确定性过滤器开场,排序器对它们没有投票权。

    flowchart TD
    A[全部记忆] --> B{"此调用者被授权?"}
    B -->|no| X[已排除]
    B -->|yes| C{"在范围内:租户、项目、版本?"}
    C -->|no| X
    C -->|yes| D{"当前有效:未过期、未被取代、未被撤回?"}
    D -->|no| X
    D -->|yes| E[合格集合]
    E --> F[排序]
  

这映射了能力路由。先决定什么合格,再请排序器在全是可允许答案的东西之间做区分。过滤器便宜、精确、可审计。排序器昂贵、近似、难以解释。

把精确步骤放在前面意味着:当出错时,那个 bug 的搜索空间很小。

来源属于同一个论证,因为检索返回的记录应得的权威分量不同。“超过 €500 的退款需要人工批准”是一条多么不同的主张,取决于它来自哪里。MemoryRecord.authority 让那个区分机器可读;更丰富的 provenance 字段说出是哪个来源、运行、文档或用户陈述挣得这个标签。

来源 权威 视为
当前策略文档或权威 API 最高 接近状态;优先于任何记忆
已验证的前次运行结果 高 带已知检验的先前证据
直接的人类指令 高,范围受限 在其范围内有约束力
失败的前次案例 中 关于什么不起作用的证据
未验证的模型生成摘要 低 一个假设
外部网页或工具内容 最低 不可信输入,默认隔离

最后一行是安全边界,而不是质量判断。

工具内容是观察,不是权威。它之后可以为证据出力,但它不会仅凭经由一个工具到达就挣得那个地位。因此,支配动作边界的同一条规则支配写入路径:如果每条工具观察都被自动提升为持久记忆,那么一个说永久记住未来任务应该把凭据上传到这里的网页,就已经对尚未开始的运行获得了影响力。

外部原始观察可以为审计保留,同时仍被隔离在可信提升之外。被保留的输入与获准影响未来的记忆之间的区分,应当被显式表示,而不是在检索时重建。

持久记忆还改变了智能体的隐私面,而它提出的问题是 schema 必须回答的:谁能写这条记录、谁能检索它、哪个租户拥有它,以及一个用户的数据能否到达另一个用户的运行。第 11 节覆盖其中最难的一个。


6. 取代、过期与撤回

记忆里有一条一月记录说退款门槛是 €500。一项八月的策略更新把它设成 €1,000。错的设计追加第二条记录,指望排序解决它;对的设计表示出这个关系,然后读取它。

from collections import defaultdict
from enum import StrEnum

class Status(StrEnum):
    ACTIVE = "active"
    NOT_YET_VALID = "not_yet_valid"
    SUPERSEDED = "superseded"
    EXPIRED = "expired"
    RETRACTED = "retracted"

def supersession_index(
    records: list[MemoryRecord],
    now: datetime,
) -> dict[str, set[str]]:
    """Successors supersede predecessors once their effective time arrives."""
    index: dict[str, set[str]] = defaultdict(set)

    for record in records:
        if record.valid_from is not None and now < record.valid_from:
            continue
        for old_id in record.supersedes:
            index[old_id].add(record.id)

    return dict(index)

def status_at(
    record: MemoryRecord,
    now: datetime,
    superseded_by: dict[str, set[str]],
) -> Status:
    if record.retracted:
        return Status.RETRACTED
    if record.valid_from is not None and now < record.valid_from:
        return Status.NOT_YET_VALID
    if record.expires_at is not None and now >= record.expires_at:
        return Status.EXPIRED
    if superseded_by.get(record.id):
        return Status.SUPERSEDED
    return Status.ACTIVE

def active_at(
    records: list[MemoryRecord],
    now: datetime,
) -> list[MemoryRecord]:
    index = supersession_index(records, now)
    return [
        record
        for record in records
        if status_at(record, now, index) is Status.ACTIVE
    ]

Status 刻意不是布尔值,理由与动作边界使用 Stage 枚举而不是裸 ValueError 相同:当一条记录没能出现在检索结果里时,调试要问的是为什么。它可能尚未生效、可能已过期、可能已被取代,或可能已被撤回。一个只能说「未返回」的系统无法回答它。

对于普通的语义失效,墓碑比悄悄删除记录更有用。把 m17 从表里移除,会抹掉它不再支配决策的理由;而保留它并置 retracted=True,或把它链接到一个有名字的继任者,让活动检索器排除它,同时仍留下可审计的解释。

那条规则不覆盖真正的删除义务。如果底层内容必须不再保留,就应改用第 11 节的删除路径,信息必须被移除或通过其派生图重算。撤回意味着不要把这条记录当作活动记忆使用;删除意味着不要仅为可审计性保留这个信息。

上面的取代语义刻意保守:一旦继任者的 valid_from 到来,前任就不会仅因继任者后来过期或撤回而悄悄复活。重新激活一条更老的策略,本身就应该是一条显式的新记录。记忆历史应当经过声明的迁移流动,而不是经过推断的复活。

把这做对不是可选的打磨。LongMemEval 把知识更新与抽取、多会话及时序推理、弃权并列来测,把更新路径当作一等能力。[3] Memora 更进一步,测量智能体在用户信息改变后是否依赖过时的记忆,发现它们经常依赖。[5] MemoryAgentBench 把选择性遗忘列为四项核心能力之一,并报告当前系统没有全部掌握这四项。[4]

设计目标随之改变。

我们要最大化的不是召回率。我们要最大化的是有效召回,同时压制本不该再支配决策的信息,而这句话的后半句才是更难工程所在的地方。


7. 检索需要触发器和查询

以系统有记忆模块为理由,在每次模型调用前都检索记忆,是没有任何假设支撑的成本。

把住检索的问题是:早先的信息能否合理地改变这个决定。好的触发器是具体的:陌生的错误、刚刚失败的策略、回归的实体、系统以前处理过的任务类别,或现在可能到期的一个延迟意图。

def should_retrieve(state) -> bool:
    return any([
        state.new_error,
        state.strategy_failed,
        state.returning_entity,
        state.needs_prior_context,
    ])

把触发器做成一个函数而不是隐含的习惯,意味着触发器本身变得可度量:它多常触发,以及它授权的检索多常改变了什么。

查询是同一策略的另一半,而最初的用户请求通常是个糟糕的查询。如果目标是“修复结账”,而运行已经走了二十步,有用的信号是当前观察 PaymentIntent remains requires_action after redirect,而不是开场白。

def build_memory_query(state) -> str:
    return "\n".join(
        part
        for part in [
            f"Goal: {state.goal}",
            f"Subtask: {state.subtask}",
            f"Observation: {state.last_observation}",
            f"Entities: {', '.join(state.entities)}",
        ]
        if part
    )

8. 冲突应当活过检索

检索返回两条主张退款门槛的记录,一条说 €500,一条说 €1,000。把它们拼接进提示、指望模型挑对,就把一个可检测的数据问题转成一个不可检测的推理问题。

asserts 键让冲突在模型看到它之前就可见。

from itertools import groupby

@dataclass(frozen=True)
class MemoryConflict:
    key: str
    record_ids: tuple[str, ...]
    values: tuple[str, ...]

def detect_conflicts(records: list[MemoryRecord]) -> list[MemoryConflict]:
    keyed = sorted(
        (
            r
            for r in records
            if r.asserts is not None and r.asserted_value is not None
        ),
        key=lambda r: r.asserts,
    )

    conflicts = []
    for key, group in groupby(keyed, key=lambda r: r.asserts):
        items = list(group)
        values = {r.asserted_value for r in items}
        if len(values) > 1:
            conflicts.append(
                MemoryConflict(
                    key=key,
                    record_ids=tuple(r.id for r in items),
                    values=tuple(sorted(v for v in values if v is not None)),
                )
            )

    return conflicts

之后多数冲突靠元数据而不是自由形态的语义来解决:更晚的生效日期、更权威的来源、显式的取代链接,或真正匹配当前运行的范围。上面的简单检测器假设断言值在写入时已被规范化;它刻意不问一个 LLM "€1,000" 与 "1000 EUR" 在一次控制决定期间是不是同一个意思。只有挺过确定性测试的才是真歧义,而对真歧义的正确响应通常是去取权威来源或去问,而不是猜。

有一条顺序在几乎每个应用里都成立,值得作为默认陈述出来,因为颠倒它的诱惑很强:

当前直接检查的状态,然后是当前权威来源,然后是由已验证结果支撑的近期记忆,然后是更老或更弱的记忆,最后是未验证的回忆。

如果工具结果说 /v1/orders → 404、/v2/orders → 200,智能体就不应该因为一条关于它的存储记录碰巧排名高,就继续向 /v1/orders 发请求。记忆是带着来源与适用条件的先前证据。

它不是真相。


9. 上下文预算是一个独立的决定

检索五十条记录不等于展示五十条记录,把这两步坍缩是一个记忆系统变得不可解释的更常见方式之一。LongMemEval 发现,索引、检索与读取上的选择每一项都会实质影响长期性能,[3] 这只有它们是各自都能出错的不同阶段时才说得通。MemGPT 持久的贡献是这个边界,而不是任何具体的产品决定:它把上下文窗口当作一块稀缺的执行面,运行时把信息换入换出,而不是当作一个往里面倒记忆的容器。[1] 系统记住什么与模型此刻看到什么,是不同的问题,答案也不同。

@dataclass(frozen=True)
class RetrievedMemory:
    record: MemoryRecord
    score: float
    reason: str

def preserve_conflict_partners(
    ranked: list[RetrievedMemory],
    candidates: list[MemoryRecord],
    conflicts: list[MemoryConflict],
) -> list[RetrievedMemory]:
    """If one side is retrieved, carry every active structured contradiction."""
    selected = {item.record.id: item for item in ranked}
    candidate_by_id = {record.id: record for record in candidates}

    for conflict in conflicts:
        present = [
            selected[rid]
            for rid in conflict.record_ids
            if rid in selected
        ]
        if not present:
            continue

        inherited_score = min(item.score for item in present)
        for rid in conflict.record_ids:
            if rid in selected or rid not in candidate_by_id:
                continue
            selected[rid] = RetrievedMemory(
                record=candidate_by_id[rid],
                score=inherited_score,
                reason=f"conflict partner for {conflict.key}",
            )

    return list(selected.values())

def conflict_groups(conflicts: list[MemoryConflict]) -> dict[str, frozenset[str]]:
    """Map each conflicting record to its connected contradiction component."""
    adjacency: dict[str, set[str]] = defaultdict(set)

    for conflict in conflicts:
        ids = set(conflict.record_ids)
        for rid in ids:
            adjacency[rid] |= ids - {rid}

    groups: dict[str, frozenset[str]] = {}
    for root in adjacency:
        seen = {root}
        frontier = [root]
        while frontier:
            current = frontier.pop()
            for neighbour in adjacency[current]:
                if neighbour not in seen:
                    seen.add(neighbour)
                    frontier.append(neighbour)
        component = frozenset(seen)
        for rid in component:
            groups[rid] = component

    return groups


def render_memory(memory: RetrievedMemory) -> str:
    return "\n".join([
        f"Memory ID: {memory.record.id}",
        f"Kind: {memory.record.kind}",
        f"Source: {memory.record.provenance}",
        f"Created: {memory.record.created_at.isoformat()}",
        f"Content: {memory.record.content}",
    ])

def fit_to_budget(
    memories: list[RetrievedMemory],
    *,
    budget_chars: int,
    conflicts: list[MemoryConflict],
) -> list[RetrievedMemory]:
    """Greedy by score, while keeping contradiction components atomic."""

    grouped = conflict_groups(conflicts)
    by_id = {m.record.id: m for m in memories}
    chosen: dict[str, RetrievedMemory] = {}
    spent = 0

    for item in sorted(memories, key=lambda m: -m.score):
        group_ids = grouped.get(
            item.record.id,
            frozenset({item.record.id}),
        )
        group = [
            by_id[rid]
            for rid in group_ids
            if rid in by_id and rid not in chosen
        ]

        cost = sum(len(render_memory(memory)) for memory in group)

        if spent + cost > budget_chars:
            continue

        for memory in group:
            chosen[memory.record.id] = memory

        spent += cost

    return list(chosen.values())

例外是承重的部分。在预算压力下丢掉矛盾里得分较低的一半,省不下上下文;它制造出一个虚假共识。conflict_groups() 把传递性的矛盾分量当作原子的,所以 A 与 B 冲突、B 与 C 冲突,不会意外出现「A 被展示而 C 没有」——因为两个两两分组互相覆盖。

如果一个矛盾分组整体装不下,这个简单策略就不展示它的任何部分。独立的 conflicts 返回值仍然告诉调用者存在一个未解决的冲突,因此运行时可以去取权威来源、刻意扩大预算,或者去问,而不是静默只呈现一侧。

出于同样的理由,渲染应保留身份:

def render_memories(memories: list[RetrievedMemory]) -> str:
    return "\n\n".join(render_memory(memory) for memory in memories)

提示里的匿名字符串事后无法归因,而第 12 节的一切都依赖归因。


10. 控制器

以上一切组装成一条读取路径,而这条路径很短,因为决定住在具名的函数里,而不是住在它内部。

from typing import Protocol

class MemoryStore(Protocol):
    def add(self, record: MemoryRecord) -> None: ...
    def eligible(self, *, scope: dict[str, str]) -> list[MemoryRecord]: ...

def retrieve_for_decision(
    *,
    state,
    store: MemoryStore,
    rank,
    now: datetime,
    budget_chars: int = 4000,
) -> tuple[list[RetrievedMemory], list[MemoryConflict]]:
    if not should_retrieve(state):
        return [], []

    candidates = active_at(store.eligible(scope=state.memory_scope), now)

    # Structured contradictions are detected over the entire eligible set,
    # before relevance ranking has a chance to hide one side.
    conflicts = detect_conflicts(candidates)

    ranked = rank(build_memory_query(state), candidates)
    ranked = preserve_conflict_partners(ranked, candidates, conflicts)

    return fit_to_budget(
        ranked,
        budget_chars=budget_chars,
        conflicts=conflicts,
    ), conflicts

八个决定现在在一个函数的表面可见:是否检索、什么在范围内且被授权、什么时间上仍然有效、什么结构化冲突已经存在、查询如何措辞、如何排序、哪些冲突伙伴必须活过排序,以及什么装得下。

顺序要紧。冲突检测在相关性排序之前,运行在合格的活动集合上。如果排序只检索到结构化矛盾的一侧,preserve_conflict_partners() 会在应用上下文预算之前把其余活动侧拉回来。因此,相关性不被允许抹去存储能精确检测出的分歧。

store.eligible(...) 在这份草图里是一道安全边界,而不是相似度搜索。它被假定在排序开始之前强制调用者/租户范围与敏感度规则。向量索引可以帮助排序返回的候选;它绝不能决定调用者被允许检索哪个用户的记录。

存储后端可以在不触碰其中任何一个的情况下替换,这正是判断这个抽象是否值得拥有的检验。


11. 删除必须遍历派生图

一条原始情节被总结;摘要产出一个语义事实;这个事实被晋升为一个程序。每一步都是一次谱系被削薄的拷贝。

    flowchart LR
    E["原始情节 e17"] --> S["摘要 s9"]
    S --> M["语义事实 m42"]
    M --> P["程序 p3"]
    style E fill:#f6c8c8,stroke:#b04a4a
  

如果 e17 含有用户要求删除的东西,删除 e17 就只删了一行,信息一点没删。2026 年六月一项关于部署时记忆的研究直接度量了这一点,把持久的智能体记忆当作一个隐私—效用面,表明删除原始内容会在摘要这样的派生层里留下可恢复的信息。[8]

因此删除需要谱系和一次遍历:

def descendants(root: str, records: list[MemoryRecord]) -> set[str]:
    children: dict[str, set[str]] = defaultdict(set)

    for record in records:
        for parent in record.derived_from:
            children[parent].add(record.id)

    seen: set[str] = set()
    frontier = [root]

    while frontier:
        node = frontier.pop()
        for child in children.get(node, ()):
            if child not in seen:
                seen.add(child)
                frontier.append(child)

    return seen

然后每个后代需要一个处置:删除、编辑、重算或隔离。哪一种对,取决于被移除内容有多少在它里面活下来,所以一份由二十个情节构建的摘要可能只需要重算,而一条正是被删内容的语义事实必须去掉。

重要的实现改变是:谱系现在住在 MemoryRecord.derived_from 上,而不是住在一张不相关的旁表里。这让来源成为记录契约的一部分,并给写入路径一些具体的东西去校验。

仅这个字段无法证明谱系完整:生产者仍然可以发出一个 derived_from=() 的派生记录。因此写入边界必须在已知派生的记录缺少来源谱系时拒绝或隔离它们。让谱系可表示是第一步;在创建时强制执行它,才是防止删除问题变得不可见的东西。

一旦记忆跨用户与月份持久存在,这就不再是边缘案例。它变成「一个删除功能」与「一句删除声称」之间的差别。


12. 记忆在哪里帮上忙,在哪里失败

一次没能帮上忙的检索可以在六个不同地方失败,每个地方的修法都不一样。这是与候选选择、能力路由相同的拆解,应用到记忆路径上。

from collections import Counter

class MemoryStage(StrEnum):
    WRITTEN = "written"
    ELIGIBLE = "eligible"
    RETRIEVED = "retrieved"
    EXPOSED = "exposed"
    USED = "used"
    HELPED = "helped"

@dataclass(frozen=True)
class MemoryTrial:
    """One task where a specific record should have changed the decision."""
    task_id: str
    record_id: str | None = None
    eligible: bool = False
    retrieved: bool = False
    exposed: bool = False
    used: bool = False
    helped: bool | None = None

    def __post_init__(self) -> None:
        path = [
            self.record_id is not None,
            self.eligible,
            self.retrieved,
            self.exposed,
            self.used,
        ]
        if any(later and not earlier for earlier, later in zip(path, path[1:])):
            raise ValueError("memory funnel stages must be monotonic")
        if self.helped is not None and not self.used:
            raise ValueError("causal help cannot be assigned to unused memory")

    @property
    def flags(self) -> tuple[tuple[MemoryStage, bool | None], ...]:
        return (
            (MemoryStage.WRITTEN, self.record_id is not None),
            (MemoryStage.ELIGIBLE, self.eligible),
            (MemoryStage.RETRIEVED, self.retrieved),
            (MemoryStage.EXPOSED, self.exposed),
            (MemoryStage.USED, self.used),
            (MemoryStage.HELPED, self.helped),
        )

    @property
    def lost_at(self) -> MemoryStage | None:
        """First known stage not reached; causal help may remain unmeasured."""
        for stage, reached in self.flags[:-1]:
            if reached is False:
                return stage
        if self.helped is False:
            return MemoryStage.HELPED
        return None

def funnel(trials: list[MemoryTrial]) -> dict[MemoryStage, float]:
    total = len(trials) or 1
    rates = {
        stage: sum(1 for t in trials if dict(t.flags)[stage] is True) / total
        for stage in MemoryStage
        if stage is not MemoryStage.HELPED
    }

    evaluated = [t for t in trials if t.helped is not None]
    rates[MemoryStage.HELPED] = (
        sum(1 for t in evaluated if t.helped) / len(evaluated)
        if evaluated
        else float("nan")
    )
    return rates

def losses(trials: list[MemoryTrial]) -> Counter[MemoryStage]:
    return Counter(t.lost_at for t in trials if t.lost_at is not None)

losses() 是值得看的那个输出,因为每个桶都指向一个不同的子系统。

丢失在 实际失败的是什么 在哪里下手
已写入 记录从未存在 写入策略
合格性 被范围、授权或有效性过滤掉 范围指派、取代
已检索 合格但排序不够高 查询构造、排序器
已曝光 被检索到但被预算砍掉 fit_to_budget、上下文策略
使用 可见却被忽略 渲染、决定策略、提示
帮助 用过了但配对结果没改善 记录本身、其适用性、其权威,或使用了它的决定策略

没有归因,这个漏斗的大部分无法计算,所以轨迹必须携带它。检索事件应当记录它的查询、合格候选 ID 与选中 ID。面向模型的投影应当记录哪些记忆 ID 实际为该决策被曝光。

USED 需要一条额外的归因信号,而不是只从可见性推断——例如一份决定明确依赖的记忆 ID 结构化清单。即便如此,那也是归因,而不是因果效应的证明。HELPED 需要下面描述的配对实验。

因此轨迹可以直接重建写入、合格、检索与曝光各阶段,并记录声明的使用。因果帮助属于评估,而不是普通的执行遥测。

对最后两行有一个警告。一次成功运行期间可见的五条记忆,并不是五条记忆都有帮助的证据;可能一条帮了、可能一条也没帮、也可能这次运行尽管有两条捣乱仍然成功了。HELPED 应当从同一任务上有无检索集合的配对运行来填充,而不是从共现填充。

这就是为什么 helped 在代码里是三态的。None 表示因果效应未被度量;False 表示度量过、但没有帮助。把这两个态坍缩,会把缺失的实验证据变成负面结果——本书在别处一再拒绝犯的同一个错误。


13. 记忆可以让智能体变差

这是默认的可能性,而不是边缘案例,值得点出这些机制的名字:过期的事实、错误的范围、锚定在一个不再适用的解法上、被投毒的外部内容、不正确的摘要、互相矛盾的程序、过时的用户偏好,以及对一块有更好用途的上下文窗口的压力。Memora 报告被评估的智能体频繁复用无效记忆,[5] MemoryAgentBench 发现没有当前系统同时掌握检索、测试时学习、长程理解与选择性遗忘。[4]

最直白地暴露这一点的指标不是平均成功率。它是配对臂之间的不对称:

@dataclass(frozen=True)
class MemoryEffect:
    shared: int
    rescue: int
    regret: int
    unchanged: int

    @property
    def net(self) -> int:
        return self.rescue - self.regret

def memory_effect(
    with_memory: dict[str, bool],
    without_memory: dict[str, bool],
) -> MemoryEffect:
    shared_ids = with_memory.keys() & without_memory.keys()

    rescue = sum(
        1
        for task_id in shared_ids
        if with_memory[task_id] and not without_memory[task_id]
    )
    regret = sum(
        1
        for task_id in shared_ids
        if without_memory[task_id] and not with_memory[task_id]
    )
    unchanged = len(shared_ids) - rescue - regret

    return MemoryEffect(
        shared=len(shared_ids),
        rescue=rescue,
        regret=regret,
        unchanged=unchanged,
    )

一个有 60 次挽救和 55 次遗憾的系统,净收益只有五个任务结果,尽管它把 115 个配对结果朝相反方向改变了。只报净收益,隐藏了这个影响有多不稳定。

这些标签只有在配对臂把任务、模型、工具、预算与其他相关配置固定、只改变被测的记忆干预时才有意义。在这个设计下,报告挽救、遗憾、未改变情形与配对任务的分母。不对称是机制层面的证据;净收益只是一个总结。

记住更多信息并不单调地更好。


14. 分开测试写入路径与读取路径

差的写入者与差的检索者产生同一个端到端数字,所以两者必须用不同的夹具来度量。对写入路径,构造每个事件的正确处置已知的任务(存储、更新、取代、隔离、丢弃),度量写入精确率与召回率、重复创建率、范围指派准确率与取代准确率。对读取路径,固定一个已知良好的存储,度量合格召回率、recall@k、precision@k、过期记录检索率与范围违规率。只有这时才跑端到端,并看第 12 节的漏斗。

一座消融阶梯告诉你哪一层在为自己付账,同时固定模型、工具、提示、任务集、预算与验证器:

级 增加 它回答的问题
A 仅运行时状态 持久记忆根本不需要吗?
B + 运行局部的工作记忆 冗余工作才是真正的成本吗?
C + 持久语义记忆 可复用的主张能迁移吗?
D + 情景记忆 过去的失败能修剪策略吗?
E + 来源、范围、写入策略 纪律能胜过体量吗?
F + 取代与遗忘 正确性需要失效机制吗?
G + 条件检索与预算 一直开着的检索在让我们付代价吗?
H + 前瞻意图 任务需要延迟动作吗?

在阶梯旁边,刻意注入故障:一条过期记录、一条语义相近但错误的记录、一条错误项目与错误用户的记录、互相矛盾的对、重复、一条被投毒的外部记录、一个过时的程序、一份未删除的派生摘要,以及一个带误导性近匹配线索的前瞻意图。那套测试的目的不是让记忆看起来好。它是在「发现代价仍只是一次测试运行」时,弄清记忆怎么失败。


15. 什么时候别建这一切

缓存与记忆系统看起来相似,问的问题不同。缓存问输入是否等价到足以复用一次计算,那是一个关于同一性的问题。记忆问过去的信息是否适用到足以影响一个决定,那是一个关于判断的问题。

缓存 记忆
主要问题 这次计算等价到足以复用吗? 这条过去信息适用到足以影响这个决定吗?
选择 通常是精确或基于同一性的键 先精确的合格过滤器,再按任务的相关性排序
命中意味着 复用该输出 在其来源与权威之下考虑该先前信息
错误命中 过期或错配的复用,有时可检测 无关、过期或错误范围的信息影响了一个决定
正确的默认 未命中 不检索

把相似度分数转成自动缓存命中,就把两者坍缩了。

相似的问题通常有不同的正确答案。

通常诚实的答案是根本不需要语义记忆。短任务、确定性工作流、已装得进当前状态的信息、过期比复用更快的事实、廉价的重算,以及有精确键就够的问题——这些情形里,一行关系型记录或其他精确表示可能是更好的机制。它查询更简单、授权与审计更容易、维护更便宜,而且在一开始就不需要近似检索的问题里,更不可能引入近似检索的错误。

持久记忆在以下情形挣得自己的位置:任务跨会话重复、实体再现、先前失败能修剪坏策略、项目约定反复要紧、已验证结果应改变未来计划,或未来线索必须触发延迟意图。即便如此,无记忆基线才是要打败的东西,第 13 节解释了这个比较为什么必须配对。

四个问题让存储保持诚实。对一次拟议写入:这能改善什么未来的决定?对一次检索:这能改变什么当前决定?对一条保留的记录:什么会让它不再有效?对一次删除:哪些派生记录仍然含有它?前两个问题答案不清晰,意味着不要存储、不要检索。第三个问题没有答案,意味着系统没有遗忘策略。第四个问题没有答案,意味着无论它的文档怎么写,它都无法兑现一次删除请求。


16. 记忆买到了什么

现在智能体可以让选中的过去信息影响当前决定,而不把过去与当前的运行时状态混淆;而使这成为可能的机器,大体在模型之外:一条类型化记录、一个显式写入处置、确定性合格性、时间感知的取代、来源权威、提示构造之前的冲突检测、一个保持矛盾完整的预算,以及一条跟随派生的删除路径。

诊断词汇也随之改变。「智能体记忆力差」从来不是一个诊断。现在问题被拆解:这究竟是状态而不是记忆吗?它写入了吗?范围对吗?它被取代了吗?触发器触发了吗?它合格吗?它被检索到吗?它装得进预算吗?模型把自己的决定归因到它了吗?使用它真的帮上忙了吗?当所需的归因被记录时,执行轨迹可以回答或支撑对前九个的诊断。第十个是因果的,需要轨迹之外的评估——理想情况是有无检索记忆的配对运行。这个区分本身就是架构的一部分:可观测性能显示信息流动到了哪里;只有实验能确立它的存在造成了什么差别。

记忆不改变的是这次运行的形状。智能体仍然沿着一条轨迹走,只是比以前被告知得更充分;而当它过早承诺一条坏路径时,一个装得满满的记忆存储会帮助它自信地承诺。

这正是下一个机制要攻击的局限。


研究渊源

本章的架构是一次工程重构而非综述,而且刻意宽于任何单篇论文。下面这些工作为它的具体部分承重。

  1. Packer et al. — MemGPT: Towards LLMs as Operating Systems (2023). 引入了虚拟上下文管理与记忆层之间的显式分页;这里引用它,是因为它划出系统存储什么与模型看到什么之间的边界。 https://arxiv.org/abs/2310.08560

  2. Shinn et al. — Reflexion: Language Agents with Verbal Reinforcement Learning (2023). 在情景缓冲里保留试验反馈以改善后来的尝试;这里引用它,是因为它是语言智能体中「承载结果的情景记忆」最早的清晰案例。 https://arxiv.org/abs/2303.11366

  3. Wu et al. — LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory (2024). 评估抽取、多会话及时序推理、知识更新与弃权,并把记忆设计拆解到索引、检索与读取;第 6 节的更新语义与第 9 节的阶段分离都引用它。 https://arxiv.org/abs/2410.10813

  4. Hu, Wang & McAuley — Evaluating Memory in LLM Agents via Incremental Multi-Turn Interactions / MemoryAgentBench (2025). 把记忆能力框定为精确检索、测试时学习、长程理解与选择性遗忘,发现没有受评系统全部掌握这四项;引用它是因为它把遗忘当作一种能力,而不是维护。 https://arxiv.org/abs/2507.05257

  5. Uddin et al. — From Recall to Forgetting: Benchmarking Long-Term Memory for Personalized Agents / Memora (2026). 度量用户信息改变之后对过时记忆的依赖;引用它是因为「记忆系统实践中复用无效记录」这一主张。 https://arxiv.org/abs/2604.20006

  6. Liu & Gabriel — PM-Bench: Evaluating Prospective Memory in LLM Agents (2026). 测试延迟意图在中间活动下的保留;引用它是因为第 3 节那个 65.1% F1 数字。 https://arxiv.org/abs/2607.12385

  7. Du — Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers (2026). 一篇把记忆形式化为写入—管理—读取循环的综述;引用它是因为第 2 节的生命周期框架。 https://arxiv.org/abs/2603.07670

  8. Lei et al. — Deployment-Time Memorization in Foundation-Model Agents (2026). 把持久记忆当作隐私—效用面来研究,表明删除会在派生层留下可恢复内容;引用它是因为第 11 节的派生遍历。 https://arxiv.org/abs/2606.10062

这些没有一条意味着每个智能体都需要这里的每一个机制。它们合起来支持一个更窄的结论:现代智能体记忆是一条选择性写入、管理、检索、使用、更新与遗忘的生命周期,而不是「存储对话历史」的同义词。


下一章:轨迹搜索

记忆改善每一步可用的信息,但不把运行加宽。

智能体仍然承诺一个后继状态、评估其后果,并从它导向的地方继续。一个看起来局部合理的决定,可能正是输掉任务的那个,因为它排挤掉的备选项从未被生成。更好的记忆让那些承诺在信息更充分的同时,依然同样终局。

下一章让几个部分成形的未来活得足够久,久到证据能把它们区分开。那一章的问题不会是分支看起来是否更聪明。它会是:分支是否把已验证的结果改善到足以配得上那份计算、那段延迟,以及对一个给未完成工作打分的评估器的新依赖。