从 Prompt 到 Harness:企业级 Agent 工程的完整演进之路

阿里妹导读


本文系统性地回顾了我们在构建企业级 AI Agent 平台过程中走过的完整技术演进路径——从大模型的先天约束出发,经历 Prompt 工程、Context 工程、Harness 工程三个阶段,最终演化出一套五层架构的 Agent 操作系统。每一层的出现都是因为前一层遇到了天花板。(文章内容基于作者个人技术实践与独立思考,旨在分享经验,仅代表个人观点。)

一、大模型的"先天约束"——

为什么需要工程化

在谈任何工程方法论之前,先要理解我们面对的"对手"是什么。大语言模型有四个结构性约束,它们不会因为模型变大、训练数据变多而消失。所有后续的工程努力,都是在这四面墙壁围成的房间里做文章。

1.1 上下文窗口是稀缺资源

我们的系统运行在 128K token 的上下文窗口内。看起来很大,但算一下就知道它有多脆弱:

一个 ReAct Agent 每执行一个步骤,至少产生 3 条消息:

一个 5 步技能、每步 3 轮迭代,就是 45+ 条消息。如果每个工具结果是一份 API 返回的 JSON(动辄数万字符),消息队列会在几轮之内膨胀到 200K+ 字符——远超 128K 的物理上限。

更棘手的是,这不是一个"截断旧消息"就能解决的问题。四个原因让简单截断变得不可能:第一,截断的 JSON 是残废数据,LLM 无法从中提取有效信息——一个被砍掉后半段的嵌套 JSON 连 parse 都无法 parse。第二,OpenAI 协议要求 tool 消息必须紧跟其对应的 assistant tool_calls,随意截断会破坏配对结构导致 API 报错。第三,即使上下文没溢出,LLM 在 20+ 轮对话后也会"遗忘"早期的关键发现——注意力被后来的信息稀释了。第四,被压缩的数据也不能真正丢掉,用户可能随时需要完整原文(审计、回放、追溯)。

这意味着我们需要的不是"截断",而是一套完整的"信息生命周期管理"——从产生、压缩、索引到按需恢复,每个环节都需要工程化的解决方案。

1.2 注意力稀释效应——"LLM 越跑越蠢"

这是我们在 S2 初期最困扰的现象:同一个 Skill,3 步的任务执行质量很好,加到 8 步质量就明显下降,到 15 步几乎不可用。最初怀疑是模型能力问题,换了更大的模型并没有预想中的改善。

后来通过逐步骤 dump 上下文发现了真相:到第 8 步时,上下文中 70% 的内容是前几步工具调用的原始返回值(大量 JSON),20% 是历史对话消息,只有 10% 是真正有用的当前步骤指令和上下文变量。LLM 的注意力被这些"噪音数据"严重稀释。这不是模型不够聪明,是我们喂给模型的信息质量在逐步劣化——信噪比在每一步都在恶化。

这个发现揭示了一个反直觉的事实:上下文窗口的"物理容量"和"有效容量"是两回事。 128K 的窗口塞满了 70% 的噪音数据,有效容量可能还不如一个精心管理的 32K 窗口。就像一间 100 平的办公室,如果 70 平堆满了杂物,实际可用空间还不如一间 30 平的整洁工作间。

更深层的问题是:这是一个自我恶化的循环。上下文膨胀 → 注意力稀释 → 工具调用参数错误率上升 → 产生更多无效的重试消息 → 上下文进一步膨胀。在 S1 的线性架构下,这个循环没有任何制动机制。

这个教训可以浓缩为一句话:不要用更大的模型掩盖工程层面的问题。 模型从 32K 升级到 128K 不会解决注意力稀释——它只是把天花板从第 5 步推迟到第 8 步,恶化的趋势不变。真正的解决方案必须从工程层面入手:管理信息质量,而非扩大物理容量。

1.3 数据搬运谬误

在多步骤的技能执行流程中,步骤 A 的输出需要作为步骤 B 的输入。这些数据由模型从步骤 A 的工具返回中提取,然后"搬运"到步骤 B 的工具参数中。在这个搬运过程中,模型可能截断长字符串、遗漏嵌套字段、混淆相似的 ID、或者在上下文压缩后彻底"忘记"某个关键值。

以 auto_coder 工具为例:自动模式下暴露了 input(required)参数给 LLM,迫使 LLM 充当"数据搬运工"——从上下文中找到前序步骤的输出数据,复制一遍塞进参数。这浪费大量 token,且容易出错(__refId 丢失、数据截断、字段遗漏)。我们观察到一个典型的失败模式:当步骤 A 返回一个包含 15 个元素的数组,LLM 在"搬运"到步骤 B 时只传递了 3-5 个"代表性"元素——它在无意识中做了一次"摘要",但对于精确执行来说这就是数据丢失。

更隐蔽的失败场景:步骤 A 返回的 JSON 中有一个 refId 字段(UUID 格式,如 a1b2c3d4-e5f6-7890-abcd-ef1234567890),步骤 B 需要用这个 ID 调用另一个 API。LLM 在搬运时可能把 UUID 的最后几位截断、把两个相似的 UUID 混淆、或者在上下文压缩后直接幻觉出一个不存在的 ID。每一种错误都会导致步骤 B 调用失败,而失败信息又会膨胀上下文,加速注意力稀释。

自动模式的本意是"用户只说要做什么,Agent 全权处理",让 LLM 填 input 等于把自动模式降级成了手动模式——用户不需要手动搬运数据,但 LLM 在替用户做同样的事。

核心原则是:让 LLM 做它擅长的事(理解意图、规划、推理),让系统做它擅长的事(数据搬运、格式转换、精确传递)。 这条原则后来成为第四章"从防御到赋能"设计哲学的基石——parameterBindings 声明式绑定的本质就是"把数据搬运从 LLM 的职责中彻底移除"。

1.4 无状态的先天缺陷

LLM 的每次对话都是无状态的——每一轮 API 调用对模型来说都是"第一次见面"。这个约束在两个层面造成问题:

单次执行内的无状态:一个 Agent 执行到第 12 步时,前 11 步的状态完全依赖上下文消息来承载。如果进程崩溃、网络断开或服务重启,所有中间状态瞬间蒸发——LLM 没有"硬盘",只有"内存",断电就清零。

跨执行的无状态:这是更深层的问题。Agent 无法从历史执行中学习。一个 Agent 昨天在执行"选品任务"时发现"搜索关键词不能用空格分隔"(调了三次才成功),今天执行相同任务时这个教训已经不存在了——它会重新犯同样的错误,重新消耗三次重试的 token。

我们在生产中观察到的一个典型案例:某个 Agent SDK 的 agentId 参数在菜单配置中应该是数字类型(12),但开发者写成了字符串类型("12"),导致助理不出现。一位工程师花了 1.5 天调试才定位到这个问题。问题是,这个知识只存在于那次调试的上下文中——如果另一个团队成员遇到同样的问题,他们会重复这 1.5 天的调试过程。知识在诞生的同时就开始遗忘。

重要的架构决策和技术事实如果不显式记录,就会在新会话中被重新讨论甚至做出矛盾的决定。这不仅是效率问题,更是一致性问题——一个"每次对话都是新生"的 Agent 永远无法成为可靠的长期伙伴。

这四个约束共同指向一个结论:原始的大模型只是一块"高性能 CPU",没有内存管理、没有文件系统、没有进程调度。要让它稳定地、大规模地执行企业级任务,需要在它外围构建一整套"操作系统"级别的基础设施。这就是从 Prompt 到 Harness 的演进动因——每一章的主题,都是在为这块"裸 CPU"补一个操作系统的子系统。

二、Prompt 工程阶段——

一切从一段文本开始

2.1 从角色扮演到结构化注入

最早期的做法,是把所有信息塞进一段 System Prompt:角色描述、业务规则、行为约束、格式要求。随着系统复杂度增加,这段文本从几百字膨胀到数千字,最终演化为一份完整的项目上下文注入文档(我们称之为 CLAUDE.md)——超过 500 行、10 个结构化章节,涵盖:

设计哲学(统一的工程审美标准)、安全硬规则(调用 API 前必须确认、修改代码前必须等待审批)、项目路径映射表(4 个项目的本地路径 → 远程仓库对应关系)、核心站点全景(4 个微前端站点的 URL/布局/路由映射,覆盖 30+ 路由)、微前端发布规范(版本号必须 bump、分支命名规则、tag 校验前置条件)、API 端点注册表(两个服务的 baseURL + 完整端点表)、知识体系目录(四层记忆架构的物理路径索引)、Skill 创建规范(planDefinition schema、outputMode 纪律、发布阻断规则)、系统状态与关键文件路径(30+ 核心文件的位置索引)。

这份文档本质上是一种"持久化的 System Prompt 工程"。它通过结构化信息(表格、映射关系、规则列表)最大化 LLM 的上下文利用效率,通过"上下文推断规则"实现了一种轻量级的 RAG——无需向量检索,靠关键词触发即可将用户意图映射到正确的代码路径。例如:"当用户提到 X 概念时,关联到 Y 目录下的文档"——这种声明式规则让 LLM 不需要搜索就能找到正确的知识入口。

但一份 500+ 行的静态文档注入也有其上限:它占据了宝贵的上下文空间(约 15K-20K token),每次对话都全量注入无论是否相关。这为后来的"渐进式披露"和"按需检索"思路埋下了伏笔。

2.2 Prompt Hack 的标语困境

随着系统复杂度上升,工程师开始在工具 description 中注入格式规则——用 ⚠️ 标记强调"搜索关键词不要用空格分隔"、"元组数组必须包含 N 个元素"。这些规则本身没有错,但依赖模型"注意到"并"遵守"。

这像极了工厂车间墙上的安全标语。"注意安全"永远是正确的,但如果安全依赖于工人每次都阅读并遵守标语,那这个安全体系是脆弱的。真正的安全来自机械互锁、自动断电、物理防护——来自消除危险条件,而非警告危险存在。

我们的实践验证了这一点:指令遵从率在多步长链路中急剧下降。在 3 步的简单任务中,格式规则的遵从率可能有 95%;到 10 步以上,这个数字会跌到 70% 以下,因为每一步的上下文中都在累积新的信息,早期的 ⚠️ 标记被淹没在海量 token 中。

2.3 Attention 引导的局限

为了应对指令遵从率下降的问题,我们尝试了各种 Attention 引导术:用 ⚠️ 标记提高视觉显著性、用粗体和全大写字母(IMPORTANT: DO NOT...)模拟"强调语气"、把关键规则放在工具 description 的最开头和最结尾(利用注意力机制的 primacy/recency effect)、甚至在每一步的 user message 中重复注入关键约束。

这些技巧在短对话中确实有效——3-5 步的任务中,规则遵从率从 85% 提升到 95%。但在 10+ 步的长链路中依然不可靠。原因很本质:Transformer 的注意力是一种有限资源,它在所有 token 之间做加权分配。当上下文从 10K 膨胀到 100K 时,一个 ⚠️ 标记获得的注意力权重被稀释了 10 倍——即使你把它加粗、大写、放到最前面。

这本质上是在和模型的注意力机制做"军备竞赛":你加一个 ⚠️,上下文膨胀稀释了它,你就加三个 ⚠️⚠️⚠️;模型开始忽略 emoji,你就换成 [CRITICAL];模型开始忽略 [CRITICAL],你就在每一步重复注入……这是一场永远赢不了的竞赛,因为你在用"更多 token"来对抗"token 太多"——火上浇油。

真正的出路不在 Prompt 层面,而在系统层面。与其让模型"记住"规则,不如让系统"强制执行"规则——这个认知后来演化为第四章"从防御到赋能"的核心哲学。

2.4 S1(MVP)的三个结构性缺陷

Prompt 工程阶段的顶峰,是我们的 S1(第一代 Agent 系统,FY26 上半年)MVP。它的架构可以用一句话概括:"工作流编排 + 单轮对话"——预定义的工作流节点按顺序串联,每个节点是一次 LLM 调用。没有 Agent 概念、没有 Skill 概念、没有 ReAct 循环。

S1 用三个月跑通了"AI 能做大促"的最小可行产品,8 月覆盖全量活动场景,活动举办效率提升 50%。这证明了方向正确。但上线后很快暴露出三个结构性缺陷——所谓"结构性",是指它们不是 bug(可以修复),而是架构选择的必然后果(只能重建)。

第一,没有容错,一断全崩。 工作流执行是纯内存的 while 循环——没有事件溯源,没有检查点持久化,没有执行状态的外部表示。状态全在进程内存里。一个 15 步的选品任务,第 12 步因外部服务超时失败,唯一的选择是从头重跑全部 15 步(约 6 分钟)。更糟的是用户场景:用户关闭浏览器标签页 → SSE 断开 → 后端的 Promise 链还在跑但结果无处推送 → 用户重新打开页面看到的是空白状态。

第二,上下文像气球一样膨胀,最终爆炸。 每一步工具调用的返回结果都完整塞入对话上下文。一次 API 调用返回 50KB 的 JSON,三步之后上下文就逼近 128K 的窗口极限。即使没有溢出,注意力稀释也让工具调用的参数错误率显著上升,形成"越跑越蠢"的恶性循环——这个循环在架构层面没有任何制动机制。

第三,执行完就结束,不会回头看。 单向管道从第一个节点跑到最后一个节点,不检查前几步的输出是否合理,不根据中间结果调整后续计划。对于 3-5 步的简单任务这不是问题,但对于 10+ 步的复杂任务,错误在链路中不断放大——第 3 步的一个小偏差,到第 10 步可能已经完全偏离用户意图,产出"形式上完成但逻辑不一致"的结果。

这三个缺陷修修补补解决不了,它们指向同一个根因:S1 的引擎把 AI 当作一次性脚本执行器,而不是有状态、能反思、能管理自身资源的智能运行时。你可以给脚本加上 try-catch 和日志,但你无法让一个脚本"反思自己写错了"、"记住上次跑崩在哪里"、"主动优化自己的资源消耗"。

Prompt 工程走到了天花板。下一阶段(S2,FY26 下半年)的任务就是重建这个运行时——不是修缮 S1,而是以完全不同的架构假设从零构建。

三、Context 工程阶段——

"管好上下文就管好了一半"

3.1 核心判断:

上下文管理是 Agent 工程化的第一命题

在动手重构之前,我花了大量时间研究业界最前沿的 Agent 运行时。几个关键输入:

ReAct Loop(Yao et al., 2022)确立了"Reasoning + Acting"交替推理的范式,但原始 ReAct 有一个隐含假设:上下文无限大。论文中的 demo 只有 3-5 步,不需要管理上下文。一旦步骤超过 10 步,原始 ReAct 就会因为上下文膨胀而退化。我们的系统需要在 128K 的上下文窗口内稳定执行 30+ 步、数十次工具调用——这是原始 ReAct 从未面对过的工程挑战。

Claude Code(Anthropic)给了我最大的两个启发。第一是上下文层面的 compaction 策略——当上下文接近窗口上限时,把整段对话压缩为一份结构化的"交接文档",用这份文档替换原始对话继续推理。第二是渐进式披露(Progressive Disclosure)的设计哲学——构建 Agent 最难的部分在 Action Space 的设计,而非推理能力本身。

Codex(OpenAI)在数据层面做了类似的事,把大结果存到外部,上下文里只保留引用指针(refId),按需取回。这个 pattern 后来成为我们 L1 层的核心灵感。

这些研究让我形成了核心判断:上下文管理是一个需要分层防御的系统工程,不能指望单点优化。 就像网络安全不能只靠防火墙一样,上下文管理也不能只靠一种压缩策略。不同粒度的数据膨胀需要不同层级的应对机制——单次工具调用可能产生 50KB 的 JSON,5 步累积可能膨胀到 200K+,而 30+ 轮对话的渐进式膨胀又是另一种完全不同的模式。每种膨胀需要不同的"拦截武器"。

3.2 四层上下文防线:

按时间顺序逐层拦截

四层防线不是想到哪加到哪,而是严格按照数据膨胀发生的时间顺序逐层拦截——从工具返回数据的那一刻起,到数据最终被消费或过期,每一层解决一个特定粒度的膨胀问题。

一条数据从产生到消亡的完整旅程如下:

L1——工具结果压缩(ToolResultRefStore):拦截单次大数据

工具结果是上下文膨胀的最大来源。一次 API 调用可能返回 50KB 的 JSON 数据,但 LLM 实际需要的可能只是"共 23 条记录,状态均为 active"这样的结论。

ToolResultRefStore 是一个"大结果外置 + 引用替换"机制。三个触发条件:字符数超限(>8000)、数组元素超限(>10)、强制存储模式(alwaysStore,用于参数绑定场景下的数据完整性保障)。大结果存 MySQL,消息中只留引用对象:

{"__stored":true,"__refId":"a1b2c3d4-...","__toolType":"unified_protocol_service","__originalLength":52340,"__summary":"23 records, all active...","__hint":"Call get_stored_data(refId=\"a1b2c3d4-...\") for full data"}

其中数组元素超限的设计有一个重要的背景:LLM 倾向于在搬运大数组时"优化"掉部分元素。它不是恶意的,而是在有限的注意力中自然地做了"摘要"——但对于需要精确传递的业务数据来说,这种"优化"就是数据丢失。我们观察到:Step 1 返回 15 条记录,Step 2 需要处理全部 15 条时,LLM 会只搬运 3-5 条"代表性样本"。超过 10 个元素的数组强制外置存储,从根本上消除了 LLM 的篡改机会——它只能通过 get_stored_data 获取完整数据。

还有一个容易被忽视的细节:存储记录中有一个 preview 字段(前 12000 字符),但这个 preview 永远不进入 LLM prompt,它仅用于审计/调试/回放。这个约束是"单一表示原则"(3.3 节)的一个具体体现。

L2——语义压缩(SemanticCompressor):压缩中等数据

单条工具结果超过 10000 字符时触发 LLM 语义压缩。用另一个 LLM(temperature=0.3,超时 60s)从海量数据中提取对后续推理最关键的信息,输出上限 2000 字符。本质上是用一个小模型做"注意力蒸馏"——把 50KB 的原始数据蒸馏为 2KB 的高密度结论。

为什么选 temperature=0.3 而不是 0?因为 temperature=0 在某些模型上会触发贪心解码的退化模式(重复 token),0.3 是我们在"确定性"和"输出质量"之间找到的平衡点,经过线上 2000+ 次压缩验证稳定。压缩后原始数据仍然保留(TTL 1 小时),确保后续步骤需要时可以通过 DataBus 取回。

降级策略也很重要:LLM 压缩失败时退化为结构化截断(前 3000 字符 + JSON 包装 + __fallbackTruncated: true 标记),而非直接截断原始文本。JSON 包装确保 LLM 能识别"这是一段不完整的数据"而非"这是全部数据"。

这里有一个被废弃的教训——我们曾有一个 generateToolResultSummary 函数,让 LLM 同时生成 summary(500 字符)和 preview(5000 字符)。结果发现 LLM 在重写 preview 时会改变字段名称和数据结构前缀。这导致了一个隐蔽的 bug:ToolExecutor.findMatchingStoredObject() 使用前缀匹配来识别哪些工具参数应该从 MySQL 恢复原始数据。LLM 的"智能重写"让前缀对不上了,腐败数据直接流入了下游工具调用。修复方案很简单:preview 改用原始文本的 substring——不经过任何 LLM 处理。**"过度智能反而有害"**,这个教训深刻地影响了后续的设计哲学:在数据流转管道中,确定性永远优先于智能性。

L3——对话压缩(Compaction):压缩累积膨胀

L1 和 L2 管的是单条消息的体积,L3 管的是消息累积后的总量膨胀。基于 usage-based 触发:当 prompt_tokens / contextWindow >= 85% 时启动,目标压缩到 30%。

为什么是 85% 而不是 95%?因为 95% 时模型可能没有足够的输出空间,返回空响应。为什么目标是 30% 而不是 50%?因为压缩有延迟(LLM 调用 + DB 写入),这段时间内新消息还在累积,如果目标太保守,压缩刚结束就再次触发。30% 提供了足够的缓冲区。

压缩产物不是简单的摘要,而是一份结构化交接文档。理念是"交接而非丢弃"——类似于团队交接时写的 handover doc。我们后来对这个交接文档做了一次重要的结构化改造:从 LLM 自由叙述改为固定 schema。

改造前的问题是:30+ 轮对话后,"已完成的工作"是一段自由叙述文本,模型无法快速定位"第几步做了什么";没有"已尝试但放弃的方案"字段,模型可能重复走失败路径;没有"当前阻塞/待解决"字段,接手后不知道卡在哪里。

改造后的结构化 schema 包含四个核心字段:

第一,用户原始请求——防止模型在长对话压缩后"忘记初心"。第二,按逻辑阶段分组的执行历史([阶段描述] → [做了什么] → [得到什么结果])——这里有一个关键的 prompt 约束:要求 LLM "保留具体的值、ID、名称,不要概括泛化"。因为 LLM 天然倾向于生成抽象摘要("数据已检索"),但后续步骤需要的是具体的 ID 和数值。第三,已放弃的路径(~~[方案描述]~~:[放弃原因])。第四,数据引用索引——从被压缩的对话中提取所有 __stored 的 refId,维护为一个迷你索引表,确保压缩不会导致数据引用丢失。

"已放弃的路径"这个字段的价值怎么强调都不过分——它直接防止了 LLM 在长对话中"重蹈覆辙"。放弃的路径独立成段,模型在 Plan 阶段能直接看到"这些方案试过了不行",不需要从冗长的叙述中推断。

消息分割也有一个边界安全约束:不能从 tool 消息开始截断,否则破坏 assistant-tool 配对结构。实现上需要向前回溯找到对应的 assistant 消息作为分割点。最少保留 6 条消息(硬下限),最少删除 2 条消息(避免低效压缩)。

L4——数据总线(DataBus):补偿压缩后的按需取回

L3 压缩后丢失了原始细节,但后续步骤可能需要引用前序数据。DataBus 在 system prompt 中维护全局数据索引表,根据当前步骤的 step.input 声明和 step.description 中的 {{variable_name}} 变量引用做依赖分析,按需预取。

预取逻辑分两级:小数据(<=4096 字符)直接从 MySQL 取回完整内容注入 system prompt;大数据(>4096 字符)取回后生成增强摘要(enhancedSummary,上限 1000 字符),格式不是简单截断而是保留结构信息:

Array, 23 items total  [0]: {id: 1, name: "Product A", price: 99.9, status: "active"}  [1]: {id: 2, name: "Product B", price: 149.0, status: "active"}  ... and 20 more items

严格预算控制(4096 字符),超预算时按固定顺序降级:丢 preview → full → summary → 去掉非直接依赖 → 收缩 transcript → 收缩 working memory。这个降级顺序遵循一个原则:越接近当前任务核心的信息越晚被牺牲。

DataBus 还提供了一套"检查模式"(Inspect Mode)工具,作为 get_stored_data 整块恢复的轻量替代:outline(refId) 快速查看数据结构概览,search(refId, query) 在大数据中定位证据点,context(refId, anchor, before, after) 获取指定锚点周围的局部窗口,head/tail(refId) 用于调试。推荐路径是:artifact_ref → DataBus 索引 → outline/search → context → 生成结论——每一步只取最小必要信息,避免重新膨胀上下文。

这个设计类似于 CPU 缓存的 prefetch 策略——预测性地将可能需要的数据加载到"快速访问区"(system prompt),减少运行时的信息检索延迟。不同之处在于,CPU prefetch 靠硬件预测,我们靠步骤定义中的声明式依赖分析——后者是确定性的,不存在 cache miss。

3.3 单一表示原则

四层防线之上,有一条贯穿全局的永久约束:同一份上游数据在任一后续 step 的 LLM 上下文中,只允许出现一种表示形态。

这条规则看似简单,实则是整个上下文管理系统的"宪法条款"。它的存在源于一个反复验证的观察:当 LLM 面对同一数据的多种描述时,它不会"取最精确的那个",而是花费大量 token 做交叉验证,甚至因为不同表示之间的细微措辞差异而产生幻觉("summary 说有 23 条,但 preview 的列表看起来只有 10 条——是不是有些被过滤了?"实际上 preview 只是截断了)。

禁止以下组合进入同一个 step prompt:full output + summary、summary + preview、full output + tool_result preview、full output + tool_results + assistant narration。

小数据(<8000 字符)的唯一表示是完整结构化对象(inline);大数据(>8000 字符)的唯一表示是 artifact_ref(refId + 有界摘要 + 元数据)。这两种形态是互斥的,绝不共存。

这条约束高于"为了方便先都塞进去再让模型自己判断"的诱惑。一旦系统允许多种表示共存,DataBus 和压缩链路就会失去意义——你精心设计了四层压缩把 50KB 压到 500B,然后一个不经意的 assistant 叙述又把原始数据的片段重新引入了上下文。这就像给水桶补了三个洞,却在桶底开了一个新口。

工程实现上,我们在 PromptBuilder 中加入了一个运行时检查:如果检测到同一 refId 对应的数据以多种形态出现在待组装的 prompt 中,直接拒绝组装并抛出告警。这是"编译时"检查,而非"运行时"祈祷。

3.4 三层记忆:

对抗长链路遗忘的横切关注点

四层防线管的是"怎么在窗口内塞更多有效信息",三层记忆管的是"哪些信息必须跨步骤存活"。它们是正交的两个维度——防线负责"减少",记忆负责"保留"。

State(变量表) 是跨步骤共享的 key-value 存储,存储步骤输出和用户参数。它是确定性的数据通道:Step A 的输出写入 State,Step B 从 State 读取——不经过 LLM 的"搬运",不存在数据损耗。这是第四章 parameterBindings 的底层基础设施。

Working Memory 分两种角色:

Pinned 是任务目标——用户的原始请求 + 当前执行计划。它始终在上下文最前面(紧跟 system prompt),确保模型永远不会忘记"这次执行要做什么"。这解决了一个真实的生产问题:在 20+ 步的任务中,模型到后面会开始"跑偏"——执行的动作和用户原始意图渐行渐远。Pinned 是对抗"目标漂移"的锚点。

Insights 是滚动的关键发现,从尾部逆序注入(最新的在前),旧的自动淘汰。每个步骤可以通过 working_memory 工具主动写入 insights(第四章 4.1 节讨论的"赋能"理念的工程实现)。

Transcript 是最近 N 条消息,N 随步骤数自适应调整:

keepTarget = round(36 - steps × 0.8)// 5 步 ≈ 保留 32 条; 15 步 ≈ 24 条; 30 步 ≈ 12 条

步数越多,保留的消息越少——因为早期消息中的关键信息已经被 Working Memory 提取为 Insights,原始消息的信息密度在递减。

这里有一个精妙的动态平衡:当 Transcript 被压缩时,Working Memory 反向扩张:

insightsTarget = round(steps × 1.2 + complexity × 4)charsTarget = round(2000 + steps × 200 + complexity × 1000)// complexity 由步骤描述长度和工具数量决定(0~2)

步数越多允许越多 insights(上限 40 条 / 8000 字符)。这体现了一种注意力资源的动态再分配策略——当对话历史被压缩时,用结构化知识补偿信息损失。效果是:即使 Transcript 只剩 12 条消息,模型仍然"记得"关键发现,因为它们已经被固化在 Working Memory 中了。

这个设计的认知科学类比是人类的"短期记忆"和"长期记忆"的关系:你不记得上周三午餐的每句对话(Transcript 被压缩了),但你记得那天决定了项目方案 B(Insight 被保留了)。

3.5 Prompt 预算预检:

成本控制从事后统计到事前治理

在调用 LLM 之前先估算上下文成本,超预算时按固定顺序降级,降级后仍超限则直接失败返回 PROMPT_BUDGET_EXCEEDED。

这是一个关键的工程创新:将成本控制从事后统计提升为事前治理。传统做法是"先调用,看看 token 花了多少",我们的做法是"先估算,超预算就不调用"。这不仅避免了无谓的 LLM 调用(省钱),更重要的是避免了因为上下文过长导致的推理质量下降(省质量)——一个塞满 128K 的上下文,即使没有溢出,推理质量也会因为注意力稀释而显著退化(回到第一章 1.2 节的问题)。

降级顺序的设计原则是"越接近当前任务目标的信息越晚被牺牲":最先丢弃的是 preview(纯辅助性信息),最后触碰的是 working memory 中的 pinned 任务目标。如果连 pinned 都不够空间放了,说明这个任务不应该在当前上下文环境中执行——直接失败比"硬跑但质量很差"更诚实。

预算预检在两个时机触发:每个步骤迭代开始前(确保不会启动一个注定失败的 LLM 调用),以及最终输出前(确保结果提取有足够的上下文空间)。每条消息的 token 估算使用固定系数(约 350 token/条),这个系数不追求精确——它只需要提供一个"够用"的预警,真正精确的 token 计数在 LLM API 返回后由 usage 字段提供。

3.6 实际效果与设计哲学

四层上下文防线 + 三层记忆的组合,产生了显著的工程效果:Token 消耗降低 60%+(等同于直接的成本下降),Agent 在 20 步以上的复杂任务中推理质量不再随步骤增加而显著退化——从 S1 时代"8 步开始衰减、15 步几乎不可用"到 S2 的"30+ 步稳定执行"。

回顾整个 Context 工程,有三个设计哲学值得提炼:

第一,分层拦截优于全能方案。没有一个"银弹"压缩算法能同时处理 50KB 的单次爆发和 200K+ 的累积膨胀。四层各管一段,每层做最简单的事,组合起来覆盖全场景。这和微服务拆分的哲学一致——单一职责。

第二,确定性优于智能性。在数据流转管道中,任何引入 LLM 的环节都是潜在的不确定性来源。能用 substring 的地方不用 LLM,能用声明式绑定的地方不用模型搬运。智能只用在真正需要"理解"的环节(L2 的语义压缩、L3 的结构化摘要)。

第三,事前治理优于事后修复。预算预检、单一表示检查、强制存储阈值——这些都是"编译时"约束,让问题不可能发生,而非"运行时"检测到问题再修复。这条原则后来贯穿到第四章的整个设计哲学中。

Context 工程解决了"信息质量"的问题,但 Agent 的可靠运行远不止于此。它还需要容错、需要断点恢复、需要被治理。这就把我们推向了下一个阶段。

四、Harness 工程阶段——

完整的 Agent 运行时工程

如果说 Context 工程是给 LLM 装了一套"内存管理系统",那 Harness 工程就是围绕 LLM 构建一整套"操作系统"——包括进程调度(PERO 编排 + 断点续传)、文件系统(四层记忆架构)、IPC(SharedBlackboard 跨 Agent 通信)、安全机制(RecursionGuard + Safety Gate)、自我进化能力(Se…

— 以上为试看内容(约 40%),开通会员后阅读全文 —