返回博客列表

Agent 越跑越笨?Deep Agents 上下文工程的检索与记忆

2026-11-14T12:00:00+08:00
Deep AgentsContext EngineeringRAGAI AgentLangChain

Agent 越跑越笨?Deep Agents 上下文工程的检索与记忆

上下文工程不是把窗口塞满,而是决定什么有资格进来。

考前突击过的人都有这个体验:背得越多,最早看的章节忘得越干净。长任务里的 Agent 犯的是同一种病——指令、工具返回、中间文件一路堆进 context window,历史和噪声越多,模型的准确率和推理质量越差。LangChain 把这个现象叫 context rot。

LangChain 的 Jess Weng 在 2026 年 10 月连发了两篇 Deep Agents 概念指南,一篇讲检索(retrieval),一篇讲记忆(remember),两篇互为上下篇。这篇文章把它们合成一条完整链路:信息先经过检索这道闸门,再由窗内的五种技术动态搬运,目标只有一个——让主 Agent 在任何时刻只带着它真正需要的上下文。

本文提纲

  1. 问题:上下文窗口的两种死法
  2. 入口侧:检索决定什么信息有资格进窗口
  3. 窗内侧:五种把上下文搬出去的技术
  4. 五个 middleware 各自挂在 Agent loop 的哪个点
  5. 落地策略与失效边界

问题:上下文窗口的两种死法

原文用一个开卷考试的比喻开场:理论上答案都在书里,但找到正确答案反而更难。Agent 面对的约束和考生一样,context window 有限,它不可能把所有信息背下来,只能边查边做。检索会以三种方式出问题:

  • 搜索低效:每次搜索都烧 token 和时间。一个习惯打开每个文件看内容、或者反复改写同一个 query 的 Agent,还没找到有用信息,上下文已经被失败的搜索结果填满。
  • 一次给太多:一次搜索吐出整份数据导出或十几份文档,context window 一步到位被占满,留给真正干活的空间为零。
  • 无关或过时:跑题的、过期的信息在模型眼里和正确答案一样可信。一旦进了窗口,Agent 会基于它继续推理,错误会传递到后面每一步。

这是"入口侧"的问题。就算检索很精准,长任务还有第二重麻烦:再精准的 Agent 也会累积多余的消息、工具结果和中间产物,这就是 context rot。对应的技术因此分成两类:

  1. 阻止不必要的信息进入 context window(检索);
  2. 管理和过滤已经进入窗口的东西(offloading、summarization、skills、subagents、memory)。

Deep Agents 是 LangChain 的开源 agent harness,这两类技术在它里面都做成了开箱即用的 middleware。先看整条链路长什么样:

flowchart LR
    SRC["Sources
files / vector DB / search API / MCP"]:::red RET["Retrieval
glob, grep, retrieval tool"]:::teal OFF["Offload
write results to files"]:::yellow SUB["Subagents
read and summarize"]:::blue WIN["Main agent context window
middleware-managed"]:::sage MEM["Long-term memory
plain markdown files"]:::mint SRC --> RET --> OFF --> SUB --> WIN WIN -->|persist learnings| MEM MEM -->|load on next run| WIN classDef red fill:#FF6B6B,stroke:#764ba2,color:#000 classDef teal fill:#4ECDC4,stroke:#764ba2,color:#000 classDef yellow fill:#FFEAA7,stroke:#764ba2,color:#000 classDef blue fill:#45B7D1,stroke:#764ba2,color:#000 classDef sage fill:#96CEB4,stroke:#764ba2,color:#000 classDef mint fill:#98D8C8,stroke:#764ba2,color:#000 linkStyle default stroke:#764ba2

贯穿两篇文章的例子是同一个:一个竞品分析 Agent,每周一研究一批竞品,按团队模板写报告。它要找 A 公司上周的笔记、从几万行市场数据里查一个营收数字、还要搜新闻档案里的新动态。三件事对应三种不同的检索,正好把所有坑踩一遍。顺带一提,两篇原文对这个例子的规模说法略有出入:记忆篇写的是 5 家公司,晚九天发布的检索篇写成了数百家,机制本身不受影响。

入口侧:检索决定什么信息有资格进窗口

先查名字和关键词:glob 与 grep

最常见的信息源是文件系统,但"打开每个文件看看里面是什么"是最差的搜法:每个读进来的文件都占上下文,光看就能把窗口看满。

Deep Agents 自带的文件系统工具遵循"先搜后读":glob 按文件名模式匹配(比如 **/company-a*.md 直接定位 A 公司的笔记),grep 在不加载文件的情况下搜内部文本,可以只返回匹配的文件、匹配行或计数。这和开卷考试先翻书后索引页是一个道理。配套的 ls、read_file、write_file、edit_file 也是内置的,而且无论文件在 Agent state、本地磁盘、持久化存储还是沙箱里,调用方式都一样,因为全部走 Agent 的 backend 抽象。

一个容易被忽略的细节:grep 只做精确文本匹配。搜 "Company A funding" 会漏掉标题为 "Company A closes $50M Series B" 的文章。上语义搜索之前有个便宜的过渡方案——让 Agent 主动换同义词,"funding" 也可能写成 "Series B" 或 "raised",每个词跑一次 grep 即可;团队内部黑话(比如内部产品代号)则写进 skill。措辞可预测时这套够用,不可预测时才需要向量检索。

关键词不够时:retrieval tool 与 agentic retrieval

retrieval tool 是 Agent 可以调用来取信息的任何工具:接收 query、查数据源、返回最接近的结果。背后的数据源决定匹配方式,不止 vector store 一种:

  • vector store:按语义匹配,解决 grep 的精确匹配问题;
  • SQL 数据库:结构化查询,比如销售额、客户记录;
  • search API:从网上拿新鲜信息;
  • MCP server:复用别人已经建好的工具,比如文档检索。

什么时候搜也有讲究。很多 RAG 方案在开头搜一次就直接答题,原文叫 2-step RAG,FAQ 机器人这么干没问题。但研究类 Agent 不行:研究 C 公司到一半发现一个此前不知道的产品发布,临时需要它的定价,这个需求在任务开头根本不可能预见,只搜一次的报告必然漏料。研究 Agent 需要的是 agentic retrieval:由 Agent 自己决定何时搜、搜什么、要不要再搜一次。Deep Agents 默认就是这个模式,Agent 跑在 loop 里,可以按需多次调用任意工具。

搜索经验本身也可以沉淀。把"用哪个索引、query 怎么措辞、引用怎么排版"打包成一个 skill,Agent 平时只看到 skill 的名字和一句描述,任务命中时才加载完整指令。这就是 progressive disclosure,后面讲 skills middleware 时还会出现。

一次给太多:分页、offload 与 retrieve-offload-delegate

搜对了也可能返回太多。市场数据导出有 4 万行,Agent 只需要其中一个营收数字。这里有三道防线,粒度依次变粗。

第一道是分页读。read_file 默认一次读 100 行,可以用 offset(从第几行开始)和 limit(读多少行)跳到目标位置。正确姿势是先 grep 定位,再只读匹配行附近的几行。

第二道是 harness 自动 offload。工具返回超过约 20,000 token 时,harness 会把完整结果写到 /large_tool_results/ 下的文件,Agent 只拿到文件路径加一段简短预览(开头和结尾几行),需要细节时再用分页读回来。

第三道是给自己的 retrieval tool 立规矩:不等超限,直接让工具把每条结果写成文件、只返回路径。这是 "retrieve, offload, delegate" 模式的前两步。原文给了一个简化实现:

backend = StateBackend()

@tool
def search_news(query: str) -> str:
    """Search the news archive and save each result to a file."""
    docs = vector_store.similarity_search(query, k=4)
    files = [(f"/retrieved/result_{i}.md", doc.page_content.encode()) for i, doc in enumerate(docs)]
    backend.upload_files(files)
    return "Saved results to: " + ", ".join(path for path, _ in files)

主 Agent 看到的不再是四篇完整文章,而是四个短路径。

错的和旧的:subagent 过滤、日期与注入

小结果如果是错的,同样没用。四篇文章里可能有名字相近的另一家公司,也可能是两年前的旧闻,而主 Agent 总得有人读这些文件才能判断哪篇有用;它每打开一篇跑题文章,噪声就进一次它的上下文。

"delegate" 一步解决这个问题:让 subagent 在自己的 context window 里读文件,只把关键事实返给主 Agent。定义一个 subagent,description 告诉主 Agent 何时调用(一次一个文件),system prompt 规定它读完要返回什么:

chunk_analyst = {
    "name": "chunk-analyst",
    "description": "Analyze one retrieved file. Pass the question and a single path under /retrieved/.",
    "system_prompt": "Use read_file to read the assigned file. Return the key facts and the source URL.",
}

agent = create_deep_agent(
    model=model,
    tools=[search_news],
    backend=backend,  # same instance, so read_file can see /retrieved/
    subagents=[chunk_analyst],
)

注意 backend 必须传同一个实例,subagent 才能读到 retrieval tool 写下的文件。之后的流程是:主 Agent 调 search_news 拿到四个路径,把每个路径派发给一个 chunk-analyst(可以并行),分析师返回带出处的短摘要,主 Agent 只做综合,发现缺料再搜一轮。跑题内容永远留在 subagent 的窗口里,主窗口保持干净。

过滤能挡住跑题,挡不住过时。周一跑的 Agent 不能用上个月的索引。两个办法:接 search API 或 MCP server 拿当前信息;数据自带日期就在检索工具里按日期过滤。还有个反直觉的坑:索引里新旧版本并存时,旧文档往往更长更详细,相关性排名反而更高;人看到 "last updated 12 B.C." 会跳过,但文档切块进向量库时日期通常丢失。所以检索工具应该把日期放进返回文本,让 subagent 连同关键事实一起回传、标记可疑的过时项。

最后是安全边界:检索回来的文本是数据不是指令,里面可能藏着 prompt injection,没有任何 prompt 或分隔符策略能完全防住。原文给的纪律是校验输出——检查答案是否引用了预期来源、声明是否与来源一致,并把所有检索文本当成不可信内容处理。

窗内侧:五种把上下文搬出去的技术

检索解决"什么能进来",但长任务里上下文还是会缓慢堆积。Deep Agents 用五种技术把信息移出活动窗口——注意是移走,不是删除,原始数据随时可以恢复。

middleware:这些技术挂在哪里

Agent 跑在一个 loop 里:模型决定动作、调工具、读结果、重复直到任务完成。middleware 就是插在这个 loop 特定位置的代码,比如 Agent 启动前、每次模型调用前后、每次工具调用前后。它在每个位置都能读上下文并在下一步执行前改写它。上文的每种技术,本质都是挂在某个点上的一段 middleware;大部分内置可用,不用自己写,只有要定制行为时才需要动手。

Offloading:大结果换路径

除了前面讲的 20,000 token 工具结果阈值(由 FilesystemMiddleware 在每次工具调用时检查,完整结果写入 /large_tool_results/{tool_call_id}),超大的用户消息也有同等待遇,阈值更高:约 50,000 token,比如粘贴进来的通话记录,会存到 /conversation_history/。模型看到的始终是预览加路径。

Summarization:给已经堆积的上下文做压缩

offloading 挡的是单次尖峰,summarization 管的是缓慢爬升。SummarizationMiddleware 在每次模型调用前检查 token 用量,一旦超过 context window 的 85%(默认阈值),就发起一次独立的 LLM 调用,把较旧的消息压缩成一份摘要,旧消息移出窗口,最近的消息原样保留。模型先看到摘要、再看到近期消息,新内容不会被转述污染。

两个细节决定它好不好用。一是可恢复:被压缩的消息写到 /conversation_history/{session_id}.md,写报告时突然需要 A 公司调研里的某个细节,可以读文件找回来。二是会循环:任务继续后用量再次爬升,下一次摘要会把上一次摘要也包进去。除了按 token 阈值触发,也可以配置成话题切换时触发,并自定义摘要 prompt。

Skills:按需加载的 know-how

销售团队对季度业务回顾(QBR)报告有固定格式,但这个格式一个季度只用一次,放进 system prompt 意味着每次模型调用都为它付 token 和延迟。skill 是一个装着指令(可选脚本和参考文档)的文件夹,Agent 平时只看到一句短描述,QBR 任务出现时才加载完整指令。

SkillsMiddleware 用两个 hook 实现:Agent 启动前扫描 skills 目录、只读每个 SKILL.md 的头部;每次模型调用把名字和描述注入 system prompt。完整指令只有在模型判定相关、主动用 read_file 读取时才进上下文。原文给了一个很直观的量化说法:因为分层加载,十个 skill 占用的上下文大约相当于十条单行描述。

Subagents:把已知嘈杂的活隔离出去

offloading 应对的是"意外超大"的结果,而有些活在动手前就知道必然嘈杂——比如几十次搜索加翻页调研一家公司。这种工作直接派给 subagent,它在自己的 context window 里完成,只回传最终结果,主 Agent 连原始报告的预览都看不到。

market_researcher = {
    "name": "market-researcher",
    "description": "Researches a company and returns the 3 most notable developments.",
    "system_prompt": "Use pull_market_report, then return 3 short bullet points. Do not return the raw report.",
    "tools": [pull_market_report],
}

agent = create_deep_agent(model=model, subagents=[market_researcher])

SubAgentMiddleware 负责给 subagent 配独立的 system prompt 和工具集。还有两个附带好处:subagent 任务通常小而边界清晰,可以用更便宜的模型;多家公司的调研可以并行跑。

Long-term memory:跨会话记住东西

任务结束时 Agent 学到了不少东西,有些值得留下。比如你告诉它"摘要用要点、不要段落",没有 memory 的话每周都得重复一遍。Deep Agents 的长期记忆就是一个 markdown 文件,一个参数指给 Agent,剩下的由 MemoryMiddleware 处理:run 开始时读入文件,每次模型调用把内容加进 system prompt,等 Agent 学到值得保留的东西(比如你的排版偏好)再更新文件。

因为记忆是你自己存储里的纯文本文件、不是托管在模型厂商那里,换模型或换 provider 时记忆原样保留:

agent = create_deep_agent(
    model="openai:gpt-6",  # different provider, same memory
    memory=["/memories/AGENTS.md"],
    backend=backend,
    store=store,
)

下周换一个模型来读同一个文件,照样会用要点写摘要。provider agnostic 这条原则在记忆设计上落得很彻底。

五个 middleware 对照

技术 挂载点 触发条件 信息搬去哪 主 Agent 看到什么
FilesystemMiddleware 每次工具调用 工具结果约 20,000 token;用户消息约 50,000 token /large_tool_results/、/conversation_history/ 路径 + 首尾几行预览
SummarizationMiddleware 每次模型调用前 用量达窗口 85%(默认) 旧消息写入 /conversation_history/{session_id}.md 摘要 + 近期原文消息
SkillsMiddleware 启动前 + 每次模型调用 模型判定某个 skill 相关 skill 文件夹 平时只有名字和描述,用时加载全文
SubAgentMiddleware 主 Agent 派发任务时 已知嘈杂的子任务 subagent 独立 context window 只有最终结果
MemoryMiddleware run 开始 + 每次模型调用 + 学到新东西时 全程 你自己存储里的 markdown 文件 每次调用注入记忆内容

落地策略与失效边界

两篇文章结尾各给了一份策略清单,合并起来就是一套可以直接照抄的设计准则,但每条都有它的适用前提。

检索侧的五条:能用高效工具就别上重的,知道确切用词时 grep 比 embedding 查找便宜得多,语义搜索留给真正需要的场景;大文件分页读而不是整体加载;返回指针而不是载荷;把阅读工作 delegate 给 subagent;校验答案与检索来源的对应关系,检索文本一律按不可信处理。

窗内侧的六条:大输入要 offload 而不是截断(截断有损,offload 可找回);压缩必须可恢复;know-how 按需加载;嘈杂工作隔离;记忆归你自己所有;默认阈值必须可定制——一套阈值不可能适合所有任务。

实际选型时有几个边界要心里有数。agentic retrieval 比 2-step RAG 灵活,但每多一轮搜索就多一轮 token 和延迟,FAQ 这类确定性场景反而该用便宜的固定流程。subagent 隔离噪声的代价是多一次模型调用和结果传递,任务本身很轻时直读更划算;并行能摊薄时间,但会同时放大调用量。summarization 保证可恢复的前提是 Agent 想得起去读历史文件,压缩本身仍有信息损失,对数字、ID 这类精确信息,最好在摘要 prompt 里明确要求保留。memory 不是只会做对的事:Agent 可能把一次性指令当成长期偏好写进文件,所以记忆文件得可人工审阅,关键约束放在 system prompt 比放在记忆里更可靠。最后,所有这些技术都建立在 backend 抽象之上,文件系统工具和 middleware 能否跨 state、本地磁盘、沙箱一致工作,取决于你选的 backend 实现,自建 harness 时这是第一个要验证的点。

想动手的话,安装就是一行 uv add deepagents;两篇原文各自附了一场 workshop 录播和 LangChain Academy 的免费 Deep Agents 课程,链接放在下面。

参考文档与链接

你的 Agent 现在怎么管理上下文——全靠窗口硬撑,还是已经上了 offload 和 subagent?评论区聊聊踩过的坑。觉得有用点个赞。


作者: itech001
来源: 公众号:AI人工智能时代(the-ai-era)
网站: https://www.theaiera.top/ 关注每日最新AI新闻和技术博客,主页有更多的文章的AI 技术参考:https://www.theaiera.top

本文首发于 AI人工智能时代,转载请注明出处。

分享给朋友