Agent 记忆不可信:证据链校验与降级回查(附代码)-环曜Agent

摘要:面向给 Agent 接了长期记忆、却发现"越用越错"的开发者与架构师。把经验写进记忆库不等于它可信——一条脱离了原始证据的结论,错了也查不出来。本文给出一套「记忆证据链三层 + descent 四触发」方法:结论层(insight)、归因摘要层(compilation)、原始轨迹层(raw trajectory)用 block id 互链,装载时断链拒载,运行时遇到缺细节、来源失败、相互冲突、工具报错四类情况就沿链下探核对。附一份可运行的 Python 3.12 脚本 evidence_memory.py(三层互链、断链拒载、四触发判定、降级回查、先验证后执行的门禁与 canary 自测桩)、两张对照表和适用边界。先说明边界:本篇讲记忆可靠性工程,不是记忆投毒防护、不是注入检测。

一、问题背景:Agent 记下的经验,正在悄悄过期

在"不给记忆三次都能解、给了记忆反而失败"的退化案例里,52% 被追溯到 Agent 跟随了某条被记住的经验,其中 20% 是这条经验本身就写错了。这是 arXiv 2611.14320 论文(Yukyeong Lee 等,KAIST 与 DeepAuto.ai,2026-11-10 预印本,ACL Rolling Review 在审)用 LLM 裁判(gpt-5.6-sol)对失败案例做的归因——论文自己强调,这描述的是"决策依据是什么",不是严格因果验证,读的时候要按归因看,别当成因果结论。

这个数字戳中一个普遍现象:Agent 刚上线时答得准,跑三个月后开始"记住了错规矩"。同一类任务以前会做,现在照着一条旧经验做错;开发者翻遍记忆库,只找到一句"这类请求用 X 字段"的结论,没说是哪次任务留下的、当时成没成功、原始调用轨迹是什么——根本无从核对。

这不是模型退化,是记忆退化:被记住的经验脱离了它的证据。论文在八套 suite、五个 benchmark 上给出的口径是,带证据链的记忆平均指标 90.2、无记忆基线 79.5、只给结论不给溯源的消融 87.0——注意这些是各 benchmark 原始 metric 的平均(主实验用 deepseek-v4-flash、三条 trial 取平均、各 baseline 改成 offline 单次构建),不是单一任务成功率,也不是"记忆让准确率涨 10 个百分点"这种读法。

先划清两条线,避免混淆:本篇讨论的是记忆自身的可靠性——一条正常写入、没有恶意的经验,为什么会误导后续决策,以及怎么让它可回查。 它不同于"记忆投毒"那类跨会话注入攻击的防护(那是安全域,研究的是怎么防住恶意写入),也不同于提示词注入检测。两类问题的方法栈不一样,本文不碰后者。

问题的根子在记忆的存法。多数实现把长期记忆存成一条条扁平的"结论 + 向量":

  • 写入时,把一次成功任务的经验抽象成一句 insight(结论),连同 embedding 落库;
  • 读取时,按相似度召回 insight,直接拼进 prompt 当"历史经验"用。

这条链路缺了一环:结论和其证据之间的关系没有被保存。三个月后那条 insight 到底对不对,既没有归因摘要解释它当时为什么成立,也没有原始轨迹能回查。于是错误经验一旦入库,就会在每次相似任务里被稳定地、反复地执行。

要治的正是这一环:让每条结论都能回答"它凭什么"。

二、核心框架:记忆证据链三层 + descent 四触发

本文把"可回查的记忆"拆成三层存储结构,配四类降级触发,合称「记忆证据链三层 + descent 四触发」。descent(降级回查)指从结论层沿链下探到原始证据的动作。

2.1 三层存储

层存什么能不能直接执行一句话区分
结论层(insight)一句可执行的结论,如"对账优先用 customer_id 关联"可,但需先过四触发存的是"答案"
归因摘要层(compilation)为何成功/失败的摘要,明确标注 interpretation(解读)而非 ground truth(事实)否,是中间证据存的是"当时为什么这么判"
原始轨迹层(raw trajectory)原始调用记录:跑了几轮、调了哪些工具、碰到哪些字段、任务成败否,是原始证据存的是"实际发生了什么"

三层用 block id 互链:insight 指向 compilation,compilation 反向指回 insight 并指向 raw trajectory,insight 自己也留一份 trajectory 指针做交叉校验。少任何一节反向指针就拒绝装载——一条没有证据链的 insight,不该有机会进入上下文。

一句话区分三层:结论层存"答案",归因层存"当时为什么这么答",轨迹层存"实际发生了什么";普通记忆只存结论这一层,证据链记忆把归因和轨迹两层也留在链上,让答案可回溯。

这个结构借鉴了同期的两项工作,但用途不同:SoMem(arXiv 2611.11929,香港城市大学与腾讯 Jarvis Lab,2026-11-09 预印本)把长期记忆组织成带 block id 的可编辑文档树,用不可变 Source store 加脚注回指原始轮次——本文只取"不可变源 + 溯源链接 + 校验安装"的结构思想,不照搬其 benchmark 数字作结论;RSI 综述(中科院自动化所与美团等,2026-11-15,OpenReview id X8epsNeCZk)提出经验变结构的七步生命周期(Collect→Evaluate→Diagnose→Abstract→Update→Verify→Consolidate),本文借它给记忆写入流程命名,不把它当已验证的工程定论。三者都不是成熟度定论,属预印本或学术框架,落地时要自己验证。

2.2 descent 四触发

运行时不是每条记忆都回查(那样成本和延迟都受不了),而是命中四类情况才沿链下探:

触发判据为什么要回查
缺细节(missing detail)采用结论所需的前提,不在当前上下文里结论有适用条件,条件缺失时照搬就是误用
来源失败(source failed)结论来自一个 outcome=failed 的任务,或轨迹缺失失败任务里提的经验,本身可能是失败原因
相互冲突(conflict)两条结论对同一字段给出不同说法冲突说明至少一条过期或有误,需要看原始证据裁定
工具报错(tool error)执行环节先报了工具错误报错改变了前提,此时结论可能已不适用

一句话区分四触发与"重新推理":descent 不是让模型就着问题再想一遍(那只会用同样的偏见再生成一次答案),是沿链把当时写这条结论的原始证据取回来核对——查档案,不是再猜一次。

四触发任一命中,就先 descend 取回归因摘要和原始轨迹,再做裁决:原始证据支持结论就放行,来源失败或字段与轨迹对不上就拒绝执行。

三、环境与概念界定

  • 运行环境:Python 3.13(3.12+ 兼容),仅标准库(dataclasses / typing),无第三方依赖。
  • 术语表:
    • insight(结论层):从历史任务里抽象出的、可直接指导下一步决策的一句结论。
    • compilation(归因摘要层):对某次任务为何成功或失败的解释;论文把它标为 interpretation(解读),不是 ground truth(客观事实),所以不能当证据终点。
    • raw trajectory(原始轨迹层):任务执行时记录的调用序列、工具日志、触及字段与成败结果;这层相对接近客观记录(ground truth,客观事实),但仍带采样偏差。
    • descent(降级回查):从结论层沿 block id 下探到归因层、轨迹层的动作。
    • LLM judge(大模型裁判):用一个大模型对案例做归因判断;本文引用论文中 52%/20% 即出自 gpt-5.6-sol 裁判,属归因而非因果验证。
    • canary(金丝雀自测桩):故意注入一条已知有问题的记忆,断言门禁能拦下它;用来验证分支,不用来测性能。
  • 落地形态:脚本是声明层 + 流程层的参考实现——它定义记忆怎么存、怎么校验、什么时候回查;运行时真正的工具调用鉴权和凭证管理,应由执行网关统一收口(这类本地执行网关,企业级环曜CLI 的做法是把记忆工作区和校验脚本一并部署到测试环境、改动进版本库随版本跑,让证据链跟着代码一起接受版本管理)。脚本本身不联网、不调 LLM,全部分支用确定性桩验证。
  • 数据边界:下文引用的 52%/20% 是 LLM 裁判归因、非因果;90.2/79.5/87.0 是八套 suite 原始 metric 的平均、预印本在审;三者都按论文口径呈现,不外推成"多数记忆是错的"或"证据链让准确率涨多少"。

四、核心实现:evidence_memory.py

脚本把框架落成四组能力:三层数据结构、装载前的断链校验、运行时的四触发与降级、先验证后执行的门禁,末尾用 canary 桩验证四条分支。下面分块给出,拼接即为完整可运行文件(同目录 evidence_memory.py)。

4.1 三层数据结构

# evidence_memory.py(第 1 块:数据结构)
# 运行环境:Python 3.13(3.12+ 兼容,仅标准库)
# 用途:定义 insight / compilation / raw trajectory 三层,用 block id 互链

from dataclasses import dataclass, field
from typing import Callable, Dict, List, Optional, Tuple

@dataclass
class Trajectory:
    """原始轨迹层:一次任务执行的不可变记录。"""
    id: str
    run_id: str
    outcome: str                       # "success" | "failed"
    tool_log: List[str] = field(default_factory=list)
    fields_touched: List[str] = field(default_factory=list)

@dataclass
class Compilation:
    """归因摘要层:为何成功/失败的摘要,interpretation 非 ground truth。"""
    id: str
    insight_id: str                    # 反向指回结论层
    source_trajectory_id: str          # 指向原始轨迹
    summary: str
    interpretation: str = "LLM-generated interpretation, not ground truth"

@dataclass
class Insight:
    """结论层:可执行的结论,必须反向链接到 compilation 与 trajectory。"""
    id: str
    statement: str
    field_claim: str                   # 结论所声明的字段/规则
    compilation_id: Optional[str]
    trajectory_id: Optional[str]
    preconditions: List[str] = field(default_factory=list)  # 采用该结论所需上下文键

4.2 装载校验:断链拒载

# evidence_memory.py(第 2 块:存储与装载校验)
# 用途:装载前检查每条 insight 是否有完整反向指针,断链即拒绝进入上下文

class EvidenceMemoryStore:
    def __init__(self) -> None:
        self.trajectories: Dict[str, Trajectory] = {}
        self.compilations: Dict[str, Compilation] = {}
        self.insights: Dict[str, Insight] = {}

    def add_trajectory(self, t: Trajectory) -> None:
        self.trajectories[t.id] = t

    def add_compilation(self, c: Compilation) -> None:
        self.compilations[c.id] = c

    def add_insight(self, i: Insight) -> None:
        self.insights[i.id] = i

    def link_integrity(self, insight_id: str) -> Tuple[bool, List[str]]:
        problems: List[str] = []
        ins = self.insights.get(insight_id)
        if ins is None:
            return False, ["insight 不存在"]
        comp = self.compilations.get(ins.compilation_id) if ins.compilation_id else None
        if comp is None:
            problems.append("缺 compilation 反向指针")
        else:
            if comp.insight_id != ins.id:
                problems.append("compilation.insight_id 与结论不一致")
            traj = self.trajectories.get(comp.source_trajectory_id)
            if traj is None:
                problems.append("compilation 指向的 trajectory 不存在")
            elif ins.trajectory_id != comp.source_trajectory_id:
                problems.append("insight 与 compilation 指向的 trajectory 不一致")
        return (not problems), problems

    def load_insight(self, insight_id: str) -> Optional[Insight]:
        ok, problems = self.link_integrity(insight_id)
        if not ok:
            print(f"    [装载拒绝] {insight_id}: {'; '.join(problems)}")
            return None
        return self.insights[insight_id]

要点:link_integrity() 校验的是双向一致性——不只是"insight 有没有指 compilation",还要"compilation 指回的 insight 是不是它"、"insight 和 compilation 指向的 trajectory 是不是同一条"。一条被截断或写坏的记忆,断在任何一节都进不了上下文。

4.3 四触发判定与降级回查

# evidence_memory.py(第 3 块:四触发 + descend)
# 用途:运行时判定是否需要沿链回查,并取回归因摘要与原始轨迹

    def should_descend(self, ins: Insight, context: dict) -> List[str]:
        reasons: List[str] = []

        # 触发1 来源失败:结论来自 failed run 或轨迹缺失
        traj = self.trajectories.get(ins.trajectory_id) if ins.trajectory_id else None
        if traj is None or traj.outcome == "failed":
            reasons.append("source_failed(来自失败任务或轨迹缺失)")

        # 触发2 缺细节:采用结论所需前提不在当前上下文
        missing = [p for p in ins.preconditions if p not in context]
        if missing:
            reasons.append(f"missing_detail(缺前提 {missing})")

        # 触发3 相互冲突:两条结论对同一字段给出不同说法
        for other in self.insights.values():
            if (other.id != ins.id and other.field_claim == ins.field_claim
                    and other.statement != ins.statement):
                reasons.append(f"conflict(与 {other.id} 对 {ins.field_claim} 矛盾)")
                break

        # 触发4 工具报错:执行环节先报错
        if context.get("tool_error"):
            reasons.append(f"tool_error({context['tool_error']})")

        return reasons

    def descend(self, ins: Insight) -> dict:
        comp = self.compilations.get(ins.compilation_id) if ins.compilation_id else None
        traj = self.trajectories.get(ins.trajectory_id) if ins.trajectory_id else None
        return {
            "insight": ins.statement,
            "compilation": comp.summary if comp else None,
            "interpretation": comp.interpretation if comp else None,
            "trajectory": ({
                "run_id": traj.run_id,
                "outcome": traj.outcome,
                "tool_log": list(traj.tool_log),
                "fields_touched": list(traj.fields_touched),
            } if traj else None),
        }

四触发的实现刻意保持简单、可解释:每一类都是能被日志和字段直接判定的条件,不依赖另一次大模型推理。冲突检测用的是"同字段、不同结论"的字面判据——这是保守的下限(同义改写可能漏检),但配合来源和字段回查已经能拦住大多数"旧经验误导"的场景。

4.4 先验证后执行的门禁

# evidence_memory.py(第 4 块:门禁裁决)
# 用途:装载 → 触发判定 → 必要时 descend → 基于原始证据裁决 → 才执行动作

    def verify_and_act(self, insight_id: str, context: dict,
                       action: Callable[[], str]) -> str:
        ins = self.load_insight(insight_id)
        if ins is None:
            return "REJECT:装载阶段断链,拒绝执行"

        reasons = self.should_descend(ins, context)
        if not reasons:
            return f"ALLOW:无触发,直接执行 → {action()}"

        evidence = self.descend(ins)
        traj = evidence["trajectory"]
        if traj is None or traj["outcome"] == "failed":
            return f"REJECT:触发 {reasons} → 原始轨迹显示任务失败,不执行结论"
        if ins.field_claim not in traj["fields_touched"]:
            return (f"REJECT:触发 {reasons} → 原始轨迹未出现字段 "
                    f"{ins.field_claim},结论与证据不符")
        return f"DESCEND_OK:触发 {reasons} → 回查后证据支持结论 → {action()}"

门禁给出三档裁决:ALLOW(无触发直接执行)、DESCEND_OK(触发后回查、证据支持,放行)、REJECT(断链、来源失败或字段与证据对不上,拒绝)。注意 REJECT 的两种判据都落在原始轨迹层——这就是为什么链上必须保留 raw trajectory:没有它,回查就变成了"用摘要验证摘要",等于没查。

4.5 canary 夹具与自测

# evidence_memory.py(第 5 块:canary 夹具 + main)
# 用途:注入干净/坏/冲突/断链四类记忆,断言门禁给出预期裁决

def build_fixture() -> EvidenceMemoryStore:
    s = EvidenceMemoryStore()

    # 好记忆:成功任务、前提齐备,但与 ins-conf 构成冲突
    s.add_trajectory(Trajectory(
        "traj-ok", "run-1001", "success",
        tool_log=["read:spec.md", "search:orders", "write:report"],
        fields_touched=["customer_id"]))
    s.add_compilation(Compilation(
        "comp-ok", "ins-ok", "traj-ok",
        "run-1001 用 customer_id 关联订单完成对账"))
    s.add_insight(Insight(
        "ins-ok", "对账优先用 customer_id 关联", "customer_id",
        "comp-ok", "traj-ok", preconditions=["有订单表"]))

    # 坏记忆:来自失败任务、字段写错
    s.add_trajectory(Trajectory(
        "traj-bad", "run-2002", "failed",
        tool_log=["read:spec.md", "write:report"],
        fields_touched=["customer_id"]))
    s.add_compilation(Compilation(
        "comp-bad", "ins-bad", "traj-bad", "run-2002 用 order_id 关联失败"))
    s.add_insight(Insight(
        "ins-bad", "对账优先用 order_id 关联", "order_id", "comp-bad", "traj-bad"))

    # 冲突记忆:对同一字段给出相反结论
    s.add_trajectory(Trajectory(
        "traj-conf", "run-3003", "success",
        tool_log=["read:legacy_note.md"], fields_touched=["customer_id"]))
    s.add_compilation(Compilation(
        "comp-conf", "ins-conf", "traj-conf", "旧笔记称 customer_id 关联慢"))
    s.add_insight(Insight(
        "ins-conf", "不要用 customer_id 关联", "customer_id", "comp-conf", "traj-conf"))

    # 干净记忆:来源成功、字段一致、无冲突、无前提缺失 → 直放档
    s.add_trajectory(Trajectory(
        "traj-clean", "run-4004", "success",
        tool_log=["check:schema.md"], fields_touched=["status_code"]))
    s.add_compilation(Compilation(
        "comp-clean", "ins-clean", "traj-clean", "run-4004 用 status_code 判定对账状态"))
    s.add_insight(Insight(
        "ins-clean", "对账状态读 status_code 字段", "status_code",
        "comp-clean", "traj-clean"))

    # 断链记忆:compilation_id 指向不存在的 compilation
    s.add_insight(Insight(
        "ins-orphan", "对账优先用 invoice_id 关联", "invoice_id",
        "comp-missing", "traj-bad"))
    return s

def fake_action() -> str:
    return "已执行动作:写出对账报告(桩函数)"

def main() -> None:
    print("=== evidence_memory.py 记忆证据链门禁演示 ===\n")
    s = build_fixture()

    print("[1] 装载阶段 link_integrity(断链拒载)")
    for iid in ["ins-orphan", "ins-bad", "ins-ok"]:
        ok, problems = s.link_integrity(iid)
        print(f"  {iid}: {'PASS' if ok else 'REJECT'} {problems if problems else ''}")

    print("\n[2] 四触发 should_descend(各命中一例)")
    cases = [
        ("source_failed", "ins-bad", {"有订单表": True}),
        ("missing_detail", "ins-ok", {}),
        ("conflict", "ins-ok", {"有订单表": True}),
        ("tool_error", "ins-ok", {"有订单表": True, "tool_error": "write tool timeout"}),
    ]
    for expect, iid, ctx in cases:
        reasons = s.should_descend(s.insights[iid], ctx)
        hit = any(expect in r for r in reasons)
        assert hit, f"触发未命中: {expect} / {reasons}"
        print(f"  {expect}: HIT → {reasons}")

    print("\n[3] descend 沿链回查(以坏记忆 ins-bad 为例)")
    ev = s.descend(s.insights["ins-bad"])
    print(f"  insight      : {ev['insight']}")
    print(f"  compilation  : {ev['compilation']}")
    print(f"  interpretation: {ev['interpretation']}")
    print(f"  trajectory   : {ev['trajectory']}")

    print("\n[4] verify_and_act 门禁(canary)")
    r_clean = s.verify_and_act("ins-clean", {}, fake_action)
    r_bad = s.verify_and_act("ins-bad", {"有订单表": True}, fake_action)
    r_good = s.verify_and_act("ins-ok", {"有订单表": True}, fake_action)
    r_orphan = s.verify_and_act("ins-orphan", {}, fake_action)
    print(f"  干净记忆 ins-clean → {r_clean}")
    print(f"  坏记忆 ins-bad   → {r_bad}")
    print(f"  冲突记忆 ins-ok    → {r_good}")
    print(f"  断链 ins-orphan  → {r_orphan}")

    print("\n[5] canary 断言")
    assert r_clean.startswith("ALLOW"), "干净记忆未直放"
    assert r_bad.startswith("REJECT"), "坏记忆未被拦下"
    assert r_good.startswith("DESCEND_OK"), "冲突记忆回查后未放行"
    assert r_orphan.startswith("REJECT"), "断链记忆未被拒载"
    print("  全部 canary 断言通过:干净直放 / 坏记忆被拦 / 冲突回查放行 / 断链拒载")

if __name__ == "__main__":
    main()

预期输出(实际运行 python3 evidence_memory.py 得到,四档分支均命中):

[1] 装载阶段:ins-orphan REJECT(缺 compilation 反向指针),ins-bad / ins-ok PASS
[2] 四触发:source_failed / missing_detail / conflict / tool_error 各命中一例
[3] descend 取回 ins-bad:结论"用 order_id"、轨迹 outcome=failed、fields_touched=[customer_id]
[4] 门禁裁决:
    干净记忆 ins-clean → ALLOW:无触发,直接执行
    坏记忆 ins-bad   → REJECT:触发 source_failed → 原始轨迹显示任务失败
    冲突记忆 ins-ok    → DESCEND_OK:触发 conflict → 回查后证据支持结论
    断链 ins-orphan  → REJECT:装载阶段断链
[5] canary 断言:干净直放 / 坏记忆被拦 / 冲突回查放行 / 断链拒载,全部通过

这里没有虚构任何压测数字——脚本只跑 canary 分支验证,输出的是每条记忆走哪条裁决路径,不涉及吞吐、延迟或准确率实测。

五、横评与覆盖度

5.1 三种记忆形态横评

相对级别评估:下表是对"记忆存储形态能力类型"的定性对照(✅ 原生具备 / △ 部分具备 / ❌ 不具备),不是性能实测排名;指标数值来自论文口径,非单一任务成功率。

维度扁平结论记忆(只存 insight)结论 + 摘要(insight + compilation)证据链记忆(三层互链)
结论可回查到来源❌ 只有一句结论△ 有归因,但无原始轨迹✅ 沿链到原始轨迹
断链可检出❌ 无从检测❌ 摘要断了也不影响读取✅ 装载即校验反向指针
冲突可裁定❌ 无法裁定△ 靠摘要判断,易循环论证✅ 回查原始字段裁定
失败经验可被识破❌ 看不出来源成败△ 摘要可能美化失败✅ 轨迹 outcome 直接可读
论文对应口径消融 87.0介于消融与完整之间完整 90.2

结论:三种形态不是替代关系,而是证据粒度逐级加厚——扁平结论省事但错了查不出;加摘要能解释但仍在"用解读验证解读";只有保留原始轨迹,回查才有落点。论文从 87.0(仅 insight)到 90.2(完整证据链)的口径差,正是这层粒度带来的,按八 suite 原始 metric 平均看,不当作单点成功率解读。

5.2 四触发覆盖度

相对级别评估:✅ 能覆盖 / △ 部分覆盖 / ❌ 不覆盖,按各形态能否处理该触发判定,非实测。

触发场景扁平结论记忆结论 + 摘要证据链记忆
缺细节(前提不在上下文)❌ 无法判断前提△ 摘要里可能写了条件✅ insight 显式声明 preconditions
来源失败(来自 bad run)❌ 看不出成败△ 取决于摘要是否诚实✅ trajectory.outcome 直接判定
相互冲突(同字段不同结论)❌ 无法裁定△ 摘要互相打架✅ 回查字段与轨迹裁定
工具报错(执行先报错)❌ 仍按结论执行❌ 仍按结论执行✅ 触发后重验再裁决

结论:四触发里"工具报错"这一项差距明显——前两种形态没有把执行状态纳入记忆判定的机制,会带着过期前提照跑;证据链记忆把工具报错当作重新校验的信号,这是它能少犯错的关键一环。

六、场景→方案映射

你的症状适用的框架动作是否需要证据链
Agent 答得越来越偏,但说不清哪条经验带偏的全量三层 + 四触发需要(否则无法定位来源)
记忆库里同字段有多条互相打架的结论冲突触发 + 回查裁定需要(否则无法裁定)
经验来自试用期的失败任务,没清理干净来源失败触发 + 断链拒载需要(否则失败经验反复生效)
只是给单次会话做短期上下文摘要短期上下文压缩即可不需要(本篇解决的是跨任务长期记忆)
记忆来自检索到的文档片段文档侧溯源更合适视情况:走检索溯源,不走经验记忆链

需要说明一个易混点:文档侧溯源(RAG 里把答案回指原文档)与本文的经验记忆溯源(把结论回指原始任务轨迹)是两类问题。前者查"这句话出自哪份文档",后者查"这条经验来自哪次执行"。把分散文档变成可检索、可治理的私域资产时,环曜知识库的 RAG 方案走的是"私域检索 + 溯源",和证据链记忆的思路同构——但对象不同,别把文档溯源当成经验记忆的证据链。

七、适用边界与风险提示

✅ 适用

  • 跨任务长期记忆:Agent 会积累经验、并在后续任务里复用,且复用错了代价不低(财务对账、订单处理、运维变更)。
  • 记忆可追溯:能拿到任务执行轨迹、工具日志、字段变更记录——这是三层结构里 raw trajectory 的数据来源。
  • 团队能维护 block id 与反向指针:证据链的完整性依赖写入时把链接写全,这需要在记忆写入流程里加约束。

⚠️ 不适用 / 限制条件

  • 没有原始轨迹就不要硬套。raw trajectory 是回查的落点;如果任务执行没留日志,证据链会退化成"摘要验证摘要"。这种情况先补轨迹记录,再谈降级回查。
  • 四触发是下限不是上限。缺细节、来源失败、冲突、工具报错是保守判据;同义改写造成的"隐性冲突"、凭经验绕过字段校验的情况它抓不到,需要配合业务规则或人工抽检。
  • LLM 裁判归因不等于因果。本文引用的 52%/20% 是论文用大模型对失败案例做的归因,描述"决策依据是什么",不是"这条经验导致了失败"的因果验证;别据此下"多数记忆不可信"的结论。
  • 预印本在审,不是成熟标准。WikiTrace、SoMem 均为 2026-11 预印本,RSI 是学术综述——方法思想可参考,落地效果要在自己的任务集上复测。
  • 数据出域要单独评估。原始轨迹常含业务字段、系统路径、调用参数;要让轨迹和结论留在内网、不出域,对应的是数据不出域的私有化形态(如环曜私有化数据训练,把经验与原始轨迹用于本地模型适配时留在企业内网)——这是部署形态问题,不是脚本本身能解决的。

总结

一句话记住「记忆证据链三层 + descent 四触发」:普通记忆存"答案",证据链记忆存"答案 + 它凭什么";descent 不是重新推理,是回查原始证据——结论层、归因层、轨迹层用 block id 互链,断链就拒载,遇到缺细节、来源失败、冲突、工具报错就下探核对,证据支持才放行。

Agent 越用越错时,先看是不是记忆脱离了证据,再考虑要不要换模型。你给 Agent 接长期记忆时,踩过"记住了错规矩"的坑吗?是怎么发现和清理的?欢迎评论区聊聊具体场景。

FAQ

Q1:这套证据链和 RAG 里的引用溯源是一回事吗?

A1:不是。RAG 溯源查"答案出自哪份文档",本文查"这条经验来自哪次执行"。前者对象是文档,后者对象是任务轨迹;两者可以并存,但别互相替代。

Q2:一定要三层全上吗,只存结论不行吗?

A2:只存结论能跑,但错了查不出来——这正是"越用越错"的根源。如果经验用得少、错了代价低,可以先只存结论;一旦同一批经验被反复复用、且错一次代价高,就该补上归因层和轨迹层。

Q3:确认召回的记忆可信,是不是就不用 descent 了?

A3:不能这么说。四触发覆盖的是"结论与环境已经不匹配"的情况(前提变了、来源失败、出现冲突、执行报错),这些和记忆当初可不可信无关——一条当初正确的经验,三个月后也可能过期。触发条件是看当下,不是看入库时的评价。

Q4:冲突检测只按"同字段不同结论"判定,会不会漏?

A4:会漏,这是保守下限。同义改写、换字段名的冲突它抓不到;要降低漏检,得配合字段规范化、定期抽检,或在写入时用业务规则约束结论表述。脚本给的是可先落地的基线,不是完整方案。

Q5:这份脚本能直接上线当门禁吗?

A5:不能。它是声明层 + 流程层的参考实现,验证的是记忆结构怎么存、什么时候回查、怎么裁决;运行时真正的工具鉴权、凭证吊销、沙箱隔离要由执行网关统一做。把它当成记忆侧的校验骨架,接进你现有的执行链路里。

Q6:论文里的 90.2、79.5 这些数字,能写进我们的立项材料吗?

A6:谨慎。这些是 arXiv 预印本在八套 suite 上原始 metric 的平均、deepseek-v4-flash、三条 trial 取平均、baseline 改成 offline 单次构建,不是通用准确率,也不是最终结论。立项可以引用"有证据链的记忆在该研究中优于仅存结论的消融"这个方向性发现,别把具体数字当成对你们业务的预测值。

先给记忆接上证据链,再谈长期记忆

企业级环曜CLI 这类本地执行网关,可把记忆工作区与校验脚本一并部署到测试环境、改动进版本库随版本跑,让证据链跟着代码一起接受版本管理;数据不出域的私有化形态则让原始轨迹与结论留在企业内网。先用三层互链与四触发搭起记忆侧的校验骨架,再决定要不要上长期记忆。

联系环曜Agent团队