铃阅
❌

普通视图

AI Agent 技术全景解析 —— 从提示词工程到高级智能体构建

2026年11月11日 20:00

原创 互联研发效能团队 2026-11-11 20:00 广东

本文系统梳理了 AI Agent 技术演进全景,核心目标是构建能自主规划、调用工具、交付结果的"数字员工"。

作者:vivo 互联研发效能团队- Wu Qinghua

目录

01. 背景

02. 现实问题

03. 理论探索

04. 方法设计

05. 实践脉络:从知识沉淀到范式开发

06. 效果评估与经验教训

07. 结论展望

本文系统梳理了 AI Agent 技术演进全景,核心目标是构建能自主规划、调用工具、交付结果的"数字员工"。从提示词工程(如何精准传达意图),到 RAG(如何接入外部知识),再到 Harness 工程(如何让模型持续可靠运行),再到 ReAct 循环(如何赋予自主决策与执行能力),最后到多智能体协作。

1分钟看图掌握核心要点👇

00

引言:从"问答工具"到"数字员工"

我们熟悉的 AI 交互

大家都用过 ChatGPT 或类似的大语言模型。交互方式很简单:你问一个问题,它给一个回答。这种"对话式"交互已经很强大了,但仔细想想,它有三个明显的局限:

  • 一次性任务:每次对话都是独立的,它不会主动延续上次的话题

  • 缺乏长期记忆:换个窗口,它就把你忘了

  • 无法自主执行:它只能"说",不能"做"——不能帮你查数据库、发邮件、跑测试

打个比方:这就像一个博学但没有手脚、也没有记忆的顾问。你每次都得把背景重新交代一遍,他给你建议,但你得自己动手执行。

核心问题

我们真正想要的是什么?是一个能理解目标、自主规划、并执行复杂任务的"智能代理"——就像一个新员工,你给他一个任务,他会自己拆解步骤、调用工具、遇到问题会调整方案,最终交付结果。

这就是 AI Agent 要解决的核心问题。

一段简短的历史演进

在正式开始之前,让我们快速回顾一下这条技术路线是如何演进过来的——理解历史,能帮我们看清未来:

一条主线贯穿始终:从"人写好 prompt 让 LLM 执行",到"LLM 自己规划并执行"——自主性一步一步提升,每一步都伴随着新的工程挑战。

今天的路线图

本次分享,我将带大家走完这样一条路:

每一步都不是凭空出现的,而是前一步跑不动了,才催生了这一步。理解了这条因果链,你就理解了 Agent 的全貌。

01

基石:与 LLM 高效协作的艺术

在构建 Agent 之前,我们必须先掌握与 LLM 高效沟通的方法。这一部分讲三个层次的"协作艺术"。

1.1 提示词工程(Prompt Engineering)

解决的问题:如何精确地向 LLM 传达意图,获得高质量的回答?

这是人机协作的起点。LLM 的输出质量高度依赖输入——同样的问题,不同的"问法"可能得到天差地别的结果。这不是 bug,而是 LLM 概率推理本质的必然结果:prompt 决定了模型在概率空间中往哪个方向走。

底层原理:为什么 prompt 如此重要

要理解提示词工程为什么有效,需要回到 LLM 的工作原理。LLM 本质上是一个自回归语言模型——它做的事情是"给定前面的 token,预测下一个 token 的概率分布":

    P(token_n | token_1, token_2, ..., token_{n-1})

    这意味着:

    • 每一个 token 都会改变后续所有 token 的概率分布。prompt 中的每一个词,都在把模型"推向"某个方向。这就是为什么角色设定("你是 Java 工程师")有效——它把后续 token 引向技术领域的概率空间。

    • LLM 没有真正的"理解"。它不是先理解你的意图再生成回答,而是基于训练数据中的 pattern 统计,逐 token 生成最"像"训练数据中类似上下文的文本。Few-shot 示例有效,正是因为它在 prompt 中构造了"这种输入应该对应这种输出"的 pattern。

    • 上下文窗口是注意力机制的作用范围。Transformer 的自注意力机制让每个 token 都能"看到"窗口内的所有其他 token,但窗口之外的内容完全不可见。所以"放在上下文里"和"不在上下文里",对 LLM 来说是"存在"和"不存在"的区别。

    理解了这些,你就会明白为什么 prompt 不是"花言巧语",而是控制 LLM 输出分布的工程手段。

    基础技巧

    • 角色扮演:给 LLM 一个明确的身份。"你是一个资深 Java 后端工程师"比"请回答以下问题"有效得多——它约束了输出范围,影响模型的注意力分布。

    • 清晰指令:把任务要求说清楚、说具体。"写一个分页查询接口,用 MyBatis-Plus,返回 Result 包装"比"写个接口"好得多。

    • Few-shot 示例:给几个输入-输出的例子。LLM 是从例子中 pattern matching 的,给它看三个情感分析的例子,比单纯说"请分析情感"有效得多。

          // AgentScope 中的角色设定 + 结构化输出
          ReActAgent agent = ReActAgent.builder()
                  .name("weather_assistant")
                  .sysPrompt("你是一个天气助手,可以查询不同的城市的天气情况,可以简洁的按照格式给用户回答。")
                  .model("dashscope:qwen-plus")
                  .build();

          // 结构化输出——让 LLM 按 JSON Schema 返回,而非自由文本
          publicrecordWeatherResponse(String location, String temperature, String condition){}

          Msg result = agent.call(
                  List.of(new UserMessage("旧金山天气如何?")),
                  WeatherResponse.class
          ).block();

          WeatherResponse weather = result.getStructuredData(WeatherResponse.class);
          // weather.location() → "San Francisco"

      框架会根据模型能力自动选择路径:支持原生结构化输出的模型走 response_format 参数,不支持的走"合成工具 + 指令"的降级路径——但对调用方完全透明。

      高级技巧

      思维链(Chain-of-Thought, CoT):让 LLM "想一想再回答",把推理过程写出来。本质是把"一步到位的直觉判断"拆成"多步的显式推理",每一步都在缩小概率空间,降低单步出错率。这个思想后来直接演变成了 Agent 的 ReAct 循环。

      CoT 之所以有效,有一个信息论视角的解释:直接生成最终答案时,模型需要在一个 step 内完成"从输入到答案"的全部映射,这个映射的熵很高(不确定性大),出错概率高。而 CoT 把这个映射拆成多个 step,每个 step 的熵更低(从"当前推理状态"到"下一步推理状态"的映射更确定),每步出错率更低,整体准确率就上去了。

      自洽性(Self-Consistency):让 LLM 对同一问题多次推理(设 temperature > 0),取多数票结果。用"多个独立推理的共识"代替"单次推理的直觉",降低随机性。代价是成本翻 N 倍。

      横向对比:不同提示策略的取舍

      策略

      准确率提升

      Token成本

      延迟

      适用场景

      Zero-shot

      基线

      最低

      最低

      简单任务

      Few-shot

      中等

      低(加几个示例)

      低

      格式控制、分类任务

      CoT

      高(数学/推理题可提升 20%+)

      中(输出推理过程)

      中

      多步推理任务

      Self-Consistency

      最高

      高(N 倍调用)

      高

      对准确率要求极高的场景

      一个趋势:目前新一代的模型基本都开始把 CoT 内化到模型训练中——模型自己学会"内部思考",不再需要用户手动加 "think step by step"。但理解 CoT 的原理仍然重要,因为它是 ReAct 循环的思想源头。

      类比:提示词工程就像给一个聪明但不了解你业务的新员工写"沟通指南"。指南写得越清楚,他交付的成果越符合预期。

      1.2 上下文工程(Context Engineering)

      解决的问题:LLM 的上下文窗口有限,如何处理需要外部知识或超长内容的任务?

      提示词工程管的是"一次推理怎么说清楚",但很快我们会遇到一个问题:有些知识不在 prompt 里,LLM 根本不知道。比如公司内部的报销制度、最新的产品文档、某个客户的历史订单——这些不在 LLM 的训练数据中。

      为什么不能直接微调(Fine-tuning)?

      一个自然的问题是:既然 LLM 不知道私有知识,为什么不在私有数据上微调它?RAG 相比微调有什么优势?

      微调(Fine-tuning)

      RAG

      知识更新

      需要重新训练,成本高

      更新知识库即可,即时生效

      知识溯源

      知识"融化"在权重里,无法追溯

      可以引用具体文档来源

      幻觉风险

      模型可能"编造"学过的知识

      基于检索到的真实文档回答

      计算成本

      训练 + 推理都贵

      只需推理时多一次检索

      适合

      改变模型的"风格/能力"

      注入"事实性知识"

      核心区别:微调改变的是模型的"能力"(怎么回答),RAG 改变的是模型的"输入"(基于什么回答)。事实性知识适合 RAG(可更新、可溯源),行为模式/领域推理能力适合微调。两者不互斥,实际系统常常组合使用。

      RAG 的工作流程

      RAG(Retrieval-Augmented Generation,检索增强生成) 的核心流程:

      RAG 的精妙之处在于:不把所有知识塞进 LLM,而是在需要时按需检索。就像人不需要把百科全书背下来,遇到问题时去查就行。

      底层原理:向量检索是怎么工作的

      具体怎么"查"?通常用向量检索:

      • 文档预处理:把文档切成片段(通常 200-500 token 一段),每个片段用 embedding 模型转成向量(一个几百到几千维的浮点数数组)

      • 查询时:用户问题也用同一个 embedding 模型转成向量

      • 相似度计算:计算问题向量与每个文档向量的余弦相似度,取最相关的 Top-K

      为什么 embedding 能捕捉语义相似度? embedding 模型在训练时,学会了把"语义相近"的文本映射到"空间相近"的向量。比如"如何报销差旅费"和"差旅费报销流程"这两个短语,虽然用词不同,但 embedding 向量的余弦相似度会很高。这比关键词匹配强得多——关键词匹配找的是"字面相同",向量检索找的是"意思相近"。

            // AgentScope 中接入知识库的代码示例
            KnowledgeBase kb = new BailianKnowledge(baseConfig);

            ReActAgent agent = ReActAgent.builder()
                    .name("assistant")
                    .model("dashscope:qwen-max")
                    .knowledgeBase(kb)        // 注册知识库
                    .build();

            // Agent 在需要领域知识时会自动检索知识库
            Msg result = agent.call(
                    List.of(new UserMessage("我们公司的差旅费报销标准是什么?")),
                    RuntimeContext.empty()
            ).block();
            // Agent 内部:检索"差旅费报销"相关文档片段 → 拼入 prompt → LLM 基于文档回答

        RAG 的进阶:不只是"检索+拼接"

        朴素 RAG(检索 Top-K 拼入 prompt)有很多变体来提升效果:

        • 混合检索:向量检索(语义)+ 关键词检索(BM25,精确匹配)+ 重排序,取长补短

        • 查询改写:LLM 先把用户问题改写得更适合检索(如"那个报销的事" → "差旅费报销标准 流程")

        • 分块策略:按语义切分而非固定长度,或用父子文档(检索子块、返回父块获取更多上下文)

        • 多跳检索:第一轮检索结果中发现新线索,再检索一轮(适合"A 公司的 CEO 之前在哪家公司"这种需要推理的问题)

        RAG 解决了两个关键问题:知识过时(知识库可以随时更新)和幻觉(LLM 基于检索到的真实文档回答,而非凭空编造)。它也是后面 Agent 连接外部知识库的基础。

        类比:如果提示词工程是给新员工写"沟通指南",那 RAG 就是给他配一个"公司内部文档检索系统"——他不需要背下所有文档,需要时搜一下就行。

        1.3 Harness 工程(Agent的运行时基础设施)

        解决的问题:单一的 Prompt 无法完成复杂任务,如何将多个 LLM 调用串联起来,形成工作流?

        从"链"到"Harness"的演进

        到目前为止,我们讲的都是"一次 LLM 调用"。但真实任务往往需要多步:

        • 先理解用户意图 → 再检索相关知识 → 再生成回答 → 最后格式化输出

        • 先写代码 → 再跑测试 → 测试失败则修改 → 再跑测试

        2022 年,LangChain 提出了"链(Chains)"的概念——把多个 LLM 调用(以及非 LLM 的处理步骤)用代码串成一条流水线。这是最早的流程编排尝试:

              # LangChain 的早期"链"范式(伪代码)
              chain = LLMChain(
                  llm=OpenAI(),
                  prompt=PromptTemplate("翻译以下文本为英文:{text}")
              )
              result = chain.run(text="你好世界")

          但"链"有一个根本局限:它是开发者硬编码的固定流程。链走哪条路、在哪分叉、在哪循环,都是写死的。一旦任务需要"根据情况动态决定下一步做什么",链就力不从心了。

          这就催生了从"链"到"Agent"的转变——而 Agent 需要长期运行、状态管理、安全管控等工程基础设施,这就是 Harness 工程。

          Harness 工程 关心的是运行时基础设施:让一个自主 Agent 能长期、可靠地跑起来,需要哪些支撑层。它解决的不是"走哪条路",而是"在路上怎么不翻车"。

          在 AgentScope 2.0 中,这套编排能力被系统化为 Harness 工程。它不只是把调用串起来,还解决了:

          • 状态管理:每一步的中间结果如何保存和传递

          • 上下文压缩:多步对话后上下文膨胀怎么办(自动摘要 + 大结果落盘)

          • 错误处理:某一步失败了如何重试或降级

          • 可观测性:整个流程的执行过程如何追踪和调试

          底层原理:Middleware 洋葱模型

          Harness 的核心扩展机制是 Middleware(中间件)——它借鉴了 Web 框架(如 Express、Koa)的"洋葱模型",在 ReAct 循环的关键时机插入自定义逻辑:

          每个 middleware 可以在"前"和"后"两个时机介入。比如你可以写一个审计 middleware,在 onActing 的"前"记录"即将调用什么工具",在"后"记录"工具返回了什么"——而不影响其他逻辑。

                // 自定义 Middleware 示例:记录所有工具调用到审计日志
                publicclassAuditMiddlewareextendsMiddlewareBase {

                    @Override
                    public Mono<Void> onActing(ActingContext ctx, MiddlewareNext next){
                        String toolName = ctx.getToolCall().getName();
                        String userInput = ctx.getToolCall().getInput().toString();
                        auditLog.info("工具调用开始: tool={}, input={}", toolName, userInput);

                        return next.proceed(ctx)
                                .doOnSuccess(v -> {
                                    String result = ctx.getToolResult().getTextContent();
                                    auditLog.info("工具调用完成: tool={}, resultLen={}",
                                            toolName, result.length());
                                });
                    }
                }

                ReActAgent agent = ReActAgent.builder()
                        .name("audited_agent")
                        .model("dashscope:qwen-max")
                        .middlewares(List.of(new AuditMiddleware()))
                        .build();

            关键设计:Harness 的内置能力(压缩、记忆、子 Agent、Plan Mode)全部以 middleware 形式实现,钩在 ReAct 循环的关键时机上。核心推理算法本身不变,Harness 只往里加东西。这意味着你可以按需开启——不需要的全关掉,Agent 依然能跑。

            横向对比:主流编排框架

            LangChain

            LlamaIndex

            AgentScope 2.0

            起源定位

            LLM 应用开发框架

            RAG 框架

            Agent 平台

            核心抽象

            Chain / Agent

            Query Engine

            ReActAgent + Harness

            状态管理

            需自己接 Memory

            需自己接 Storage

            AgentState 内置,自动持久化

            多用户隔离

            需自己实现

            需自己实现

            (userId, sessionId) 内置

            长期运行

            不擅长

            不擅长

            Harness 专门解决

            生产部署

            需自己搭

            需自己搭

            分布式、多租户、沙箱内置

            选型建议:简单的 LLM 应用用 LangChain 快速搭原型;以 RAG 为核心的应用用 LlamaIndex;需要构建生产级自主 Agent 用 AgentScope。三者不是互斥的——AgentScope 也可以接入 LlamaIndex 的检索能力。

            Harness 工程将 LLM 从一个"单点工具"变成"流水线"中的一个环节,是通向 Agent 自动化的关键一步。

            类比:如果提示词工程是"沟通指南",RAG 是"文档检索系统",那 Harness 工程就是"标准作业流程(SOP)"——把多个步骤编排成一条可重复、可监控的流水线。

            02

            核心:构建自主工作的 AI Agent

            前面三块基石,本质上都还是"人驱动、LLM 执行"的模式。现在,我们进入真正的 Agent 领域——赋予 AI 自主性。

            2.1 Agent 的"大脑"——规划与决策(Planning & Decision-Making)

            解决的问题:面对复杂目标,Agent 如何自主决定"先做什么,后做什么"?

            规划范式的演进

            Agent 的规划能力经历了几代演进,每一代都在解决上一代的局限:

            第一代:Plan-then-Execute(先规划后执行)

            思路:先用 LLM 生成一个完整的计划,然后逐步执行。

            局限:计划是静态的。执行中发现某步走不通,整个计划就废了——而真实世界中"执行中发现意外"是常态。

            第二代:ReAct(推理+行动交错)——当前主流

            ReAct(Reason + Act) 的核心思想是推理和行动交错执行:

            ReAct 的精妙之处:不是"先想好所有步骤再执行"(纯规划),也不是"盲目执行不思考"(纯行动),而是"想一步、做一步、看结果、再想下一步"。这更接近人类解决陌生问题的方式。

            ReAct 循环内部实际给 LLM 的 prompt 大致是这样的(简化版):

                  你是一个能使用工具的助手。请按以下格式回答:

                  Thought: 我需要先理解用户想要什么...
                  Action: search_web
                  Action Input: {"query": "Spring Boot 3.2 新特性"}

                  (框架执行工具,返回结果)

                  Observation: Spring Boot 3.2 主要更新包括...

                  Thought: 现在我知道了主要特性,可以总结了
                  Action: [无需工具,直接回答]
                  Final Answer: Spring Boot 3.2 的主要新特性包括...

              每一轮迭代中,LLM 都能看到:之前所有的 Thought、Action、Observation。这意味着它可以根据执行结果动态调整后续计划——这是 Plan-then-Execute 做不到的。

              第三代:Tree of Thoughts / MCTS(树状搜索)——前沿探索

              ReAct 是"单链推理"——一条路走到底。但有些复杂问题需要"探索多条路径,回溯不靠谱的分支"。Tree of Thoughts 把推理组织成一棵树,支持分支探索和回溯,类似下棋 AI 的蒙特卡洛树搜索(MCTS)。

              代价是成本高很多(每个节点都是一次 LLM 调用),目前主要在研究阶段,生产中很少用。

              横向对比:三种规划范式

              Plan-then-Execute

              ReAct

              Tree of Thoughts

              灵活性

              低(计划静态)

              高(每步可调整)

              最高(可回溯)

              成本

              低

              中

              高(指数级 LLM 调用)

              适合

              步骤明确的任务

              大多数任务

              需要探索的复杂推理

              生产可用

              是

              是(主流)

              尚不成熟

              对于特别复杂的任务,ReAct 之上还可以叠加 Plan Mode:Agent 先在只读模式下分析任务、生成一个计划文件,用户审核计划后,Agent 再按计划执行。这实现了意图与动作的解耦——先想清楚要做什么,再动手做。

              2.2 Agent 的核心循环与架构

              Agent 与普通 LLM 应用的本质区别是什么?是"自主性"。

              普通 LLM 应用是"你给一个输入,它给一个输出"。而 Agent 是"你给一个目标,它自己决定怎么做,做完告诉你结果"。

              传统程序 vs Agent:控制权的转移

              理解 Agent,最好从它与传统程序的根本区别入手:

              传统程序:控制流是开发者写死的。if-else 怎么分叉、for 循环几次、调用哪个函数——都是预先确定的。程序是"开发者控制的执行体"。

              Agent:控制流由 LLM 在运行时动态决定。下一步做什么、调用什么工具、什么时候停止——都由 LLM 根据当前上下文判断。程序变成了"LLM 驱动的执行体"。

              这是一次根本性的转变:控制权从开发者转移到了 LLM。开发者不再编写"执行逻辑",而是编写"执行框架"——框架定义了 LLM 可以在哪些点做什么决策,但具体决策内容由 LLM 自己根据上下文判断。

              实现这种自主性的,是 Agent 的核心控制循环:

              这个循环的每个环节:

              • 目标理解:把用户的自然语言请求,转化为可执行的任务目标

              • 规划:把大目标拆成可执行的子步骤

              • 执行:调用工具完成每个子步骤

              • 观察:获取工具执行的结果

              • 反思/修正:根据结果判断是否完成,没完成则调整计划

              AgentScope 中的实际控制流

              在 AgentScope 中,这个循环的具体实现是 ReActAgent 的主循环:

              几个值得注意的运行机制:

              • 迭代上限:循环不是无限的。maxIters(默认 10)限制了最大迭代次数,防止 Agent 陷入死循环

              • 并发工具调用:如果 LLM 一次返回多个工具调用,Agent 可以并发执行(标记了 concurrency

                -Safe 的工具)

              • 权限闸门:每次工具执行前都走权限检查(允许/询问/拒绝),敏感操作会暂停等待人工确认

              • 中断恢复:支持 interrupt(userId, sessionId) 精确中断某个 session,中断后状态自动保存,下次调用从中断点恢复

              这个循环是理解后续所有组件的框架——工具是"执行"环节的手脚,记忆是贯穿全循环的状态,知识库是"规划"和"执行"的参考。后面讲的每个组件,都可以对应到循环中的某个位置。

              2.3 Agent 的"手"和"脚"——工具(Tools)与技能(Skills)

              解决的问题:LLM 本身无法与外部世界交互(调用 API、读写文件、执行代码),如何赋予它行动能力?

              工具(Tools)

              工具就是 Agent 可以调用的外部函数。对 LLM 来说,一个工具需要暴露三件事:名称、描述、参数格式。LLM 根据这些信息决定"什么时候用哪个工具"。

              底层原理:Function Calling 是怎么工作的

              工具调用的完整流程涉及 LLM 和框架的协作:

                    1. 框架把工具的 JSON Schema 注入 LLM 请求
                       POST /v1/chat/completions
                       {
                         "messages": [...],
                         "tools": [{
                           "type": "function",
                           "function": {
                             "name": "get_current_time",
                             "description": "返回指定时区的当前时间",
                             "parameters": {"type": "object", "properties": {"timezone": {"type": "string"}}}
                           }
                         }]
                       }

                    2. LLM 决定是否调用工具。如果调用,返回的不是普通文本,而是一个结构化的 tool_call:
                       {
                         "tool_calls": [{
                           "id": "call_abc123",
                           "function": {"name": "get_current_time", "arguments": "{\"timezone\": \"Asia/Shanghai\"}"}
                         }]
                       }

                    3. 框架解析 tool_call,执行对应的 Java 方法,拿到结果

                    4. 框架把工具结果作为新消息加入上下文,再次调用 LLM
                       → LLM 基于工具结果继续推理

                关键点:LLM 本身不"执行"工具,它只是输出一个"我想调用这个工具"的结构化指令。真正执行工具的是框架代码。LLM 做的是"决策",框架做的是"执行"。

                      // AgentScope 用注解定义工具,框架自动推导 JSON Schema
                      @Tool(name = "get_current_time",
                            description = "返回指定时区的当前时间",  // 这个描述决定了 LLM 用不用它
                            readOnly = true)
                      public String getCurrentTime(
                              @ToolParam(name = "timezone", description = "IANA 时区,如 Asia/Shanghai")
                              String timezone) {
                          return LocalDateTime.now(ZoneId.of(timezone))
                                  .format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
                      }

                  这里有一个关键点:工具的描述必须详细具体。"数据查询工具"远不如"查询指定日期范围内的订单数据,支持按客户ID筛选"有效——因为 LLM 是靠描述来决策的。

                  当工具数量多了,会带来两个问题:上下文膨胀(每个工具的 schema 都占 token)和决策干扰(工具太多,选错率上升)。解决方案是工具组(Tool Group):把工具分组,运行时只激活当前任务相关的组——这就是"按需披露"。

                        // 工具组:按需激活
                        ToolGroup database = new ToolGroup(
                                "database", "数据库操作工具",
                                ToolGroupScope.SESSION, /* active = */false);
                        database.addTool("db_query");
                        database.addTool("db_migrate");

                        ReActAgent agent = ReActAgent.builder()
                                .name("router")
                                .toolkit(toolkit)
                                .enableMetaTool(true)   // 启用 reset_tools 元工具,让 Agent 自己切换工具组
                                .build();
                        // Agent 遇到数据库任务时,自己调用 reset_tools 激活 database 组

                    MCP(Model Context Protocol)

                    解决的问题:工具提供方和 Agent 框架的解耦。

                    如果没有 MCP,你用 AgentScope 写的工具,换成 LangChain 就得重写。每换一个框架,工具生态就重建一遍。

                    MCP 是一个标准化协议:工具提供方按 MCP 协议实现一个 server,任何支持 MCP 的 Agent 框架都能接入。它让工具变成可复用、可独立部署的"微服务"。

                    MCP 的协议设计

                    MCP 定义了三种连接方式,对应不同的部署场景:

                    链接方式

                    通信方式

                    适合场景

                    STDIO

                    本地进程 stdin/stdout

                    本地工具(如文件系统操作)

                    SSE

                    HTTP 长连接

                    远程工具,需要实时推送

                    Streamable HTTP

                    HTTP 流式

                    远程工具,现代推荐方式

                    MCP server 启动后会暴露一个工具列表,客户端(Agent 框架)连接后自动发现可用工具。这跟微服务的"服务注册与发现"是同一个思想。

                          // 接入一个远程 MCP server 只需几行代码
                          McpClientWrapper weather = McpClientBuilder.streamableHttp()
                                  .name("weather").url("https://api.weather.com/mcp")
                                  .header("Authorization", "Bearer xxx")
                                  .build();

                          Toolkit toolkit = new Toolkit();
                          toolkit.registerMcpClient(weather).block();
                          // 框架自动处理协议协商、工具发现、结果转换
                          // MCP 工具在 toolkit 中以 mcp__weather__get_forecast 命名,避免冲突

                      类比:MCP 之于 Agent 工具,就像 HTTP 之于 Web 服务——一个标准协议,让生产者和消费者解耦。就像你不需要关心一个 REST API 是用 Java 还是 Python 写的,MCP 让你不需要关心一个工具是跑在哪个 Agent 框架里。

                      技能(Skills)

                      工具是"能做什么"(能力),但 Agent 每次处理同类任务都从零摸索——它不记得"上次怎么做最有效"。

                      技能(Skill) 解决的就是这个问题:它是 Agent 的 SOP,一份可复用的工作流程文档。本质是 Markdown 指令,告诉 Agent "遇到这类任务该怎么做"。

                        code-reviewer/           ← 一个技能就是一个目录
                        ├── SKILL.md             ← 指令文档:"先搜代码、再读文件、按检查清单评审"
                        ├── references/          ← 参考资料(如代码风格规范)
                        └── scripts/             ← 可执行脚本(如自动化检查脚本)

                        技能 vs 工具的本质区别:工具是"一个可调用的函数",技能是"一套工作流程的指令"。技能不能直接调用——Agent 先读取技能指令,再用已有工具按指令执行。技能是"知识",不是"动作"。

                        更进阶的是,Agent 可以自己起草技能——成功经验自动沉淀为技能草稿,经审核后变成正式技能。这就是 Agent 的"自进化"能力:know-how 在每次运行之间累积。

                        2.4 Agent 的"记忆"——短期与长期(Memory)

                        解决的问题:如何让 Agent 记住对话历史、任务进度和过去经验,避免重复犯错?

                        LLM 本身是无状态的——两次调用之间,模型不记住任何东西。要让 Agent "有记忆",需要工程手段。

                        记忆问题的本质

                        "记忆"听起来是一个概念,但实际包含三个不同层次的问题:

                        • 单次调用内的记忆:一次 call() 内多轮 ReAct 循环中,前一步的结果如何传到下一步?→ 靠上下文(AgentState.context)

                        • 跨调用的记忆:用户上一次对话说的内容,这次对话还记得吗?→ 靠 AgentState 持久化

                        • 跨会话的记忆:上个星期对话中提取的经验,这次新对话能用上吗?→ 靠长期记忆系统

                        这三层问题的解决方案完全不同,不能混为一谈。

                        记忆分两层:

                        短期记忆——会话记忆(Session Memory)

                        管理单次任务/对话中的上下文。核心载体是 AgentState,它不只存对话历史,还存权限规则、任务清单、工具激活状态等所有影响推理的运行时状态:

                          AgentState
                          ├── context              ← 对话历史(用户输入、assistant 回复、工具调用、工具结果)
                          ├── summary              ← 压缩后的摘要(上下文超阈值时生成)
                          ├── permissionContext    ← 工具权限规则(哪些工具允许/询问/拒绝)
                          ├── planModeContext      ← Plan Mode 状态(当前是否在规划阶段)
                          ├── tasksContext         ← 任务清单(todo_write 维护的子任务列表)
                          └── toolContext          ← 工具组激活状态(当前激活了哪些工具组)

                          为什么权限规则和任务清单也放在 AgentState 里? 因为它们都影响 LLM 的推理决策。权限规则决定 LLM 知道"哪些操作可以做",任务清单决定 LLM 知道"当前进度到哪了"——这些和对话历史一样,都是推理时需要看到的上下文。

                          在 AgentScope 中,Agent 实例本身是无状态的——所有状态按 (userId, sessionId) 外部化存储:

                                // 配置 Redis 状态存储——生产环境推荐
                                ReActAgent agent = ReActAgent.builder()
                                        .name("assistant")
                                        .model("dashscope:qwen-plus")
                                        .stateStore(new RedisAgentStateStore(jedis))  // 分布式状态存储
                                        .build();

                                // 第一次调用——创建会话,Agent 查了航班信息
                                agent.call(List.of(new UserMessage("帮我查北京到上海的航班")),
                                        RuntimeContext.builder().userId("alice").sessionId("s1").build()).block();

                                // 第二次调用——自动恢复上次的 AgentState,Agent 知道"最便宜的"指什么
                                agent.call(List.of(new UserMessage("最便宜的是哪个")),
                                        RuntimeContext.builder().userId("alice").sessionId("s1").build()).block();

                            一个 Agent 实例可以同时服务成千上万个用户,互不干扰。状态存储用 Redis 等分布式后端时,还能实现跨机器的故障转移和滚动发布零中断——不同物理机上的 Agent 实例都能拿到完全一致的状态。

                            长期记忆(Long-term Memory)

                            会话记忆是"短期记忆"——会话结束就归档了。但有些信息是跨会话的:用户偏好、项目约定、历史经验。这些不应该靠用户每次重说一遍。

                            AgentScope 的长期记忆分两层,解决"既要记住长期事实,又不能让上下文无限增长"的矛盾:

                            这里有三处独立的 LLM 调用,每一处都有自己的 prompt 和触发时机:

                            #

                            操作

                            写入目标

                            触发时机

                            1

                            Flush——从对话抽取长期事实

                            memory/YYYY-MM-DD.md

                            每次 call() 结束(可节流)

                            2

                            Consolidation——合并日流水账到 MEMORY.md

                            MEMORY.md

                            后台节流(默认 30min 一次)

                            3

                            Compaction——对话前缀蒸馏成摘要

                            注入当前上下文

                            上下文超阈值时

                                  // 记忆系统配置——可以用小模型跑记忆操作,省成本
                                  HarnessAgent agent = HarnessAgent.builder()
                                      .model("openai:o3")                      // 主推理模型(强)
                                      .memory(MemoryConfig.builder()
                                          .model("openai:gpt-4.1-mini")        // 记忆操作用小模型(便宜)
                                          .flushTrigger(MemoryConfig.FlushTrigger.throttled(
                                                  Duration.ofMinutes(10)))      // 最多每 10 分钟 flush 一次
                                          .build())
                                      .compaction(CompactionConfig.builder()
                                          .triggerMessages(30)                  // 30 条消息触发压缩
                                          .keepMessages(10)                     // 保留最近 10 条
                                          .model("openai:gpt-4.1-mini")        // 压缩也用小模型
                                          .build())
                                      .build();

                              Agent 还获得 memory_search 工具,可以主动检索历史记忆。这就像人有"日记本"和"经验总结"——日记记原始事实,经验总结是提炼后的智慧。

                              横向对比:记忆方案的选择

                              方案

                              实现复杂度

                              检索精度

                              适合

                              全量上下文(不压缩)

                              最低

                              最高(全看得到)

                              短对话

                              摘要压缩

                              中

                              中(摘要丢细节)

                              中长对话

                              向量记忆库(存所有历史,按需检索)

                              高

                              中(依赖检索质量)

                              需要长期记忆

                              分层记忆(AgentScope 的方案)

                              高

                              高(摘要 + 按需检索)

                              生产级长期运行

                              类比:Session 是"工作记忆"(你正在想的事),Memory 是"长期记忆"(你积累的经验)。

                              2.5 Agent 的"知识库"(Knowledge Base)

                              解决的问题:Agent 如何获取执行任务所需的专业领域知识?

                              这里我们回到第一部分讲的 RAG。知识库是 Agent 获取静态领域知识的主要来源——公司制度文档、产品技术文档、行业规范等。

                              知识库 vs 记忆的区别(这是容易混淆的点):

                              记忆(Memory)

                              知识库(Knowledge Base)

                              内容

                              Agent 经历的事实

                              外部静态领域知识

                              来源

                              对话中自动提炼

                              预先准备好的文档

                              类比

                              个人日记

                              百科全书

                              知识库 vs 技能的区别:

                              技能(Skill)

                              知识库

                              性质

                              指令("怎么做")

                              参考资料("是什么")

                              例子

                              "代码评审的步骤"

                              "公司报销制度全文"

                              2.6 Agent 的"组织"——多智能体协作(Multi-Agent Systems)

                              解决的问题:单个 Agent 的能力有限——上下文污染、工具过多、无法并行。如何通过组织多个 Agent 协同工作来解决更宏大的

                              单 Agent 的瓶颈

                              随着任务复杂度增加,单 Agent 会遇到瓶颈。就像一个人要同时做设计、开发、测试、运维——不是做不到,而是效率低、容易出错。具体来说有三个瓶颈:

                              • 上下文污染:所有子任务的中间结果都堆在一个上下文里,互相干扰,LLM 注意力被稀释

                              • 工具过载:一个 Agent 要处理所有类型任务,工具列表越来越长,选错率上升

                              • 串行瓶颈:单 Agent 是串行执行的,无法同时处理多个独立子任务

                              子 Agent 的核心思想

                              子 Agent(Sub-Agent) 的核心思想是分工:每个子 Agent 有独立的上下文、工具集、人格和推理循环,可以并行执行,互不污染。

                              两种委派模式:

                              • 同步委派:主 Agent 调用子 Agent,等结果返回再继续——"我需要你的结果才能往下走"

                              • 后台委派:交给子 Agent 后不等待,完成后通过 system-reminder 自动推送结果——"你先做着,我干别的"

                                    // 声明式子 Agent:在 workspace/subagents/ 目录下放一个 Markdown 文件
                                    // subagents/code-reviewer.md 内容:
                                    // ---
                                    // name: code-reviewer
                                    // sysPrompt: 你是一个代码评审专家,专注于发现潜在bug和代码规范问题。
                                    // tools: [read_file, search_code, run_tests]
                                    // ---
                                    // 评审步骤:
                                    // 1. 读取目标代码
                                    // 2. 检查常见问题模式
                                    // 3. 给出结构化评审报告

                                    // 主 Agent 通过 agent_spawn 创建子 Agent,agent_send 发送任务
                                    // 子 Agent 独立运行,有自己的上下文和工具集

                                多智能体协作模式

                                以"软件开发团队"为例:

                                不同的协作模式适合不同场景:

                                协作模式

                                结构

                                适合场景

                                例子

                                层级式(Supervisor)

                                主管分配任务给专业子 Agent

                                任务可清晰拆分的场景

                                技术负责人分配开发/测试任务

                                辩论式(Debate)

                                多个 Agent 对同一问题给不同观点

                                需要降低单一 Agent 偏差的场景

                                多个 Agent 评审同一架构方案

                                流水线式(Pipeline)

                                前一个的输出是后一个的输入

                                顺序处理的场景

                                需求→设计→开发→测试

                                Handoffs(交接)

                                Agent 做完自己的部分后交给下一个

                                按角色交接的场景

                                前端做完交给后端

                                Tool vs Skill vs Subagent 的层次关系:

                                Tool

                                Skill

                                Subagent

                                本质

                                一个函数调用

                                一套指令文档

                                一个完整的推理循环

                                有独立上下文?

                                否

                                否

                                是

                                有独立人格?

                                否

                                否

                                是

                                能并行?

                                能(并发工具)

                                不能

                                能

                                适合

                                原子操作

                                复用工作流

                                复杂子任务

                                三者不是互斥的:子 Agent 内部会用到工具,也可能加载 Skill。它们是不同层次的抽象——Tool 是"手脚",Skill 是"方法手册",Subagent 是"另一个大脑"。

                                这就是从"一个全能 Agent"到"一个 Agent 团队"的演进——就像从"个人英雄"到"高效团队"。

                                03

                                实战指南:从概念到落地

                                前面两部分讲的是"Agent 是什么、怎么工作"。但真正落地时,你会发现"知道概念"和"做出好用的系统"之间还有很大的距离。这一部分,我们来看三个实战维度:在什么场景用、常见坑在哪里、最佳实践是什么。

                                3.1 典型应用场景:Agent 适合解决什么问题

                                不是所有问题都适合用 Agent。判断的核心标准是:任务是否需要"多步推理 + 动态决策 + 外部工具"。如果只需要一次 LLM 调用就能完成,用 Agent 是杀鸡用牛刀。

                                场景一:知识问答助手(RAG + 轻量 Agent)

                                业务背景:公司内部有大量文档(制度、产品文档、技术 wiki),员工查找效率低。

                                为什么用 Agent:单纯的 RAG 只能"检索+回答",但员工的真实需求往往需要多步——先查制度,再查配套流程,再结合个人情况给建议。

                                架构:知识库(RAG) + 轻量 Agent(ReAct 循环 + 2-3 个工具:检索、读文件、回答)

                                      // 知识问答助手——最轻量的 Agent 应用
                                      ReActAgent agent = ReActAgent.builder()
                                              .name("kb_assistant")
                                              .sysPrompt("你是公司内部知识助手。回答时请引用文档来源。"
                                                      + "如果检索结果不足以回答,请明确告知而非编造。")
                                              .model("dashscope:qwen-plus")
                                              .knowledgeBase(kb)            // 知识库
                                              .maxIters(5)                  // 知识问答不需要太多轮迭代
                                              .build();

                                  落地建议:这是 Agent 的"入门级"应用,ROI 容易量化(节省的查找时间)。先从这个场景切入,验证效果后再扩展。

                                  场景二:代码工程助手(工具密集型 Agent)

                                  业务背景:开发团队需要一个能读代码、跑测试、提交 PR 的 AI 助手。

                                  为什么用 Agent:代码任务天然需要多步——理解需求→搜索相关代码→读取文件→修改代码→运行测试→根据测试结果修复→提交。每一步的结果都影响下一步怎么做,这是 ReAct 循环的典型场景。

                                  架构:HarnessAgent + 工作区(代码仓库) + 工具集(read_file, write_file, execute_shell, search_code) + Plan Mode

                                        HarnessAgent agent = HarnessAgent.builder()
                                                .name("code_engineer")
                                                .sysPrompt("你是一个代码工程师。修改代码前先理解上下文,"
                                                        + "修改后必须运行测试验证。")
                                                .model("dashscope:qwen-max")
                                                .workspace(workspace)               // 代码仓库作为工作区
                                                .enablePlanMode()                   // 复杂修改先出计划
                                                .compaction(CompactionConfig.builder()
                                                        .triggerMessages(20)         // 代码任务上下文增长快,提早压缩
                                                        .keepMessages(8)
                                                        .build())
                                                .build();

                                    落地建议:代码场景的 Agent 效果显著,但安全风险也高——必须配权限系统和沙箱。建议先在只读模式(只分析不修改)下验证,再逐步放开写权限。

                                    场景三:数据处理与分析 Agent(多工具协作)

                                    业务背景:业务团队需要从多个数据源取数、清洗、分析、生成报表。

                                    为什么用 Agent:数据分析的过程高度动态——先看数据结构,决定分析方向,写 SQL 取数,发现异常再深挖,最后出图。这种"边探索边决策"的过程,硬编码的 ETL 管道做不到。

                                    架构:Agent + 多工具组(数据库查询、Python 执行、图表生成) + 知识库(业务指标定义)

                                          // 数据分析场景——工具组按需激活
                                          ToolGroup queryGroup = new ToolGroup("db", "数据库查询工具", ...);
                                          queryGroup.addTool("sql_query");
                                          queryGroup.addTool("schema_inspect");

                                          ToolGroup analysisGroup = new ToolGroup("analysis", "分析工具", ...);
                                          analysisGroup.addTool("python_execute");
                                          analysisGroup.addTool("plot_chart");

                                          ReActAgent agent = ReActAgent.builder()
                                                  .name("data_analyst")
                                                  .toolkit(toolkit)
                                                  .enableMetaTool(true)       // 让 Agent 自己切换工具组
                                                  .knowledgeBase(metricsKb)   // 业务指标定义
                                                  .maxIters(15)               // 数据探索需要更多轮次
                                                  .build();

                                      落地建议:SQL 执行工具必须配只读数据库账号,Python 执行必须在沙箱中。数据分析 Agent 的价值在于"替代数据分析师的重复劳动",不是替代数据分析师本人。

                                      场景四:多 Agent 协作——自动化研发流水线

                                      业务背景:将需求分析、代码开发、代码评审、测试验证串联成自动化流水线。

                                      为什么用多 Agent:每个环节需要不同的专业能力和工具集,放在一个 Agent 里会上下文污染、工具过载。

                                      架构:Supervisor Agent + 4 个专业子 Agent(PM / Developer / Reviewer / Tester)

                                      落地建议:多 Agent 系统复杂度高,建议在单 Agent 验证效果后再引入。初期可以用"人在回路"(HITL)替代部分子 Agent,逐步自动化。

                                      不适合 Agent 的场景

                                      场景

                                      为什么不适合

                                      替代方案

                                      简单问答(一问一答)

                                      不需要多步推理

                                      直接调 LLM API

                                      固定流程的 ETL

                                      策略执行状态的判定不清

                                      规格化时前置澄清

                                      高精度数值计算

                                      LLM 算术不可靠

                                      传统程序

                                      实时低延迟场景

                                      Agent 多轮推理延迟高

                                      直接 API 调用

                                      3.2 常见痛点与避坑指南

                                      Agent 落地过程中,以下痛点几乎每个人都会遇到。这里把"踩过的坑"提前列出来。

                                      痛点一:Agent "不按预期行动"——工具调用决策不准

                                      现象:Agent 该用工具时不用,不该用时乱用;或者选错了工具。

                                      根因:LLM 是根据工具的 description 来决策的。描述模糊、描述之间有重叠,都会导致选错。

                                      避坑指南:

                                        ❌ 坏的描述:description = "查询数据"
                                        ✅ 好的描述:description = "查询 MySQL 订单表中指定日期范围内的订单记录,
                                                      支持按客户ID和订单状态筛选。返回字段:订单号、金额、状态、创建时间。"

                                        • 工具描述要写到同事能看懂的程度——不只是"做什么",还要包括"输入是什么格式、输出是什么格式、什么时候该用"

                                        • 工具之间不要有职责重叠——如果有两个工具都能"查数据",LLM 会困惑。合并它们,或者用更清晰的命名区分

                                        • 给工具加 readOnly 标记——只读工具可以放心并发,框架会自动优化

                                        痛点二:上下文爆炸——Token 成本失控

                                        现象:长对话中 token 消耗线性增长,成本越来越高,效果反而越来越差("迷失在中间")。

                                        根因:每轮 ReAct 循环都会往上下文加消息(推理过程 + 工具调用 + 工具结果),如果不管理,几十轮后上下文就爆了。

                                        避坑指南:

                                              // 生产环境的标准配置
                                              HarnessAgent agent = HarnessAgent.builder()
                                                      .compaction(CompactionConfig.builder()
                                                              .triggerMessages(20)          // 20 条就触发,不要等太多
                                                              .keepMessages(8)              // 只保留最近 8 条 + 摘要
                                                              .truncateArgs(CompactionConfig.TruncateArgsConfig.builder()
                                                                      .maxArgLength(2000)   // 工具参数超 2000 字符就截断
                                                                      .build())
                                                              .build())
                                                      .toolResultEviction(ToolResultEvictionConfig.defaults())  // 大结果落盘
                                                      .memory(MemoryConfig.builder()
                                                              .flushTrigger(MemoryConfig.FlushTrigger.throttled(
                                                                      Duration.ofMinutes(10)))  // flush 节流,不是每次都跑
                                                              .model("dashscope:qwen-turbo")     // 记忆操作用便宜模型
                                                              .build())
                                                      .build();

                                          • 压缩阈值宁低勿高:20 条消息触发压缩,比 50 条再压缩效果好——上下文越长,LLM 注意力越分散

                                          • 大工具结果必须落盘:read_file 读了个 100KB 的文件,全文进上下文就是灾难。配 toolResultEviction 让超 80K 的结果自动落盘

                                          • 记忆操作用小模型:flush 和 consolidation 不需要主模型那么强,用 qwen-turbo 等轻量模型能省 80% 成本

                                          痛点三:Agent 陷入死循环——反复调用同一个工具

                                          现象:Agent 反复调用同一个工具,或者在不同步骤间来回跳,无法收敛到最终答案。

                                          根因:通常是 prompt 不够清晰,或者工具返回的结果让 LLM 误判了任务状态。

                                          避坑指南:

                                          • 设 maxIters 兜底:生产环境必须设,默认 10,复杂任务最多 20。宁可让 Agent "没做完就返回",也不能让它无限跑

                                          • 工具结果要包含状态信息:不要只返回数据,还要告诉 LLM "这个操作成功了吗""还有多少没做"

                                            // ❌ 坏的工具返回:只有数据,没有状态
                                            return"Order #12345, amount: 100, status: pending";


                                            // ✅ 好的工具返回:包含状态,帮助 LLM 判断下一步
                                            return"查询成功。找到 1 条订单:Order #12345, amount: 100, status: pending。\n"
                                            + "该订单处于待审批状态,你可以使用 approve_order 工具进行审批。";
                                            • 用 TodoTools 让 Agent 跟踪进度:复杂任务开启 enableTaskList(),Agent 维护一个任务清单,每完成一项划掉,避免"忘了做到哪了"

                                            痛点四:安全问题——Agent 执行了危险操作

                                            现象:Agent 误删文件、执行了危险命令、把敏感数据发到了外部 API。

                                            根因:Agent 有了行动力,也意味着有了破坏力。没有权限管控的 Agent 就像没有刹车的汽车。

                                            避坑指南:

                                                  // 生产环境的安全配置——三道防线
                                                  ReActAgent agent = ReActAgent.builder()
                                                          .permissionContext(PermissionContextState.STRICT)  // 严格权限模式
                                                          .toolkit(toolkit)                                   // 工具白名单
                                                          .build();

                                                  // 第一道防线:工具粒度权限
                                                  // 写操作工具必须标记 readOnly = false,框架会走权限检查
                                                  @Tool(name = "delete_file", description = "删除指定文件",
                                                        readOnly = false, dangerousDirectories = {"/etc", "/system"})
                                                  public String deleteFile(@ToolParam(name = "path") String path){ ... }

                                                  // 第二道防线:HITL 人工确认
                                                  // 敏感操作触发 RequireUserConfirmEvent,暂停等待人工确认
                                                  // 确认后规则可持久化——同类操作以后自动放行

                                                  // 第三道防线:沙箱隔离
                                                  // 不可信代码在 Docker 沙箱中执行,宿主不受影响
                                                  HarnessAgent agent = HarnessAgent.builder()
                                                          .filesystem(new DockerFilesystemSpec()...)  // 沙箱文件系统
                                                          .build();

                                              • 最小权限原则:Agent 初始权限只给只读工具,写操作需要审批。宁可多确认几次,也不要一上来就给全权

                                              • 危险路径黑名单:delete_file、execute_shell 等工具要配 dangerousDirectories / dangerousCommands

                                              • 沙箱是最后一道墙:即使权限系统失效,沙箱也能保证影响范围可控

                                              痛点五:评估困难——不知道 Agent 效果好不好

                                              现象:传统软件测试是"输入→断言输出",但 Agent 的多步推理 + 工具调用让输出变得非确定性——同样的输入可能走不同的路径。

                                              避坑指南:

                                              分层评估:

                                              • 工具层:每个工具单独测(传统单元测试)

                                              • 推理层:给定上下文,断言 LLM 是否选对了工具(批量用例)

                                              • 端到端:给定目标,断言最终结果是否正确(允许路径不同,只看结果)

                                              黄金集回归:维护一批"标准问题+标准答案",每次模型升级或 prompt 修改后跑一遍

                                              可观测是前提:必须能追踪 Agent 的每一步推理和工具调用。AgentScope 的 Studio 可视化工具就是干这个的

                                                    // 开启可观测——生产环境必备
                                                    ReActAgent agent = ReActAgent.builder()
                                                            .name("observable_agent")
                                                            .model("dashscope:qwen-max")
                                                            .toolkit(toolkit)
                                                            // 每一步推理、工具调用、工具结果都以事件流出
                                                            .build();

                                                    // 用 streamEvents 而非 call,实时追踪执行过程
                                                    agent.streamEvents(userMsg)
                                                            .doOnNext(event -> {
                                                                switch (event.getType()) {
                                                                    case TEXT_BLOCK_DELTA -> System.out.print(((TextBlockDeltaEvent) event).getDelta());
                                                                    case TOOL_CALL_START -> log.info("工具调用: {}", ((ToolCallStartEvent) event).getToolCallName());
                                                                    case TOOL_CALL_END -> log.info("工具完成: {}", ((ToolCallEndEvent) event).getToolCallName());
                                                                }
                                                            })
                                                            .blockLast();

                                                3.3 行业最佳实践

                                                实践一:渐进式引入——从"HITL"到"全自动"

                                                不要一上来就做全自动 Agent。推荐的分阶段路径:

                                                实践二:Model Routing——不同任务用不同模型

                                                不是所有步骤都需要最强的模型。一个常见成本优化策略:

                                                任务类型

                                                推荐模型

                                                理由

                                                主推理(规划、决策)

                                                强模型(qwen-max / GPT-4o)

                                                推理质量决定整体效果

                                                工具结果摘要

                                                中等模型(qwen-plus)

                                                摘要不需要顶级推理

                                                记忆 flush/consolidation

                                                轻量模型(qwen-turbo)

                                                提取事实用小模型够了

                                                简单分类/路由

                                                轻量模型(qwen-turbo)

                                                分类任务小模型够用

                                                      // 主模型用强模型,辅助操作用小模型
                                                      HarnessAgent agent = HarnessAgent.builder()
                                                              .model("dashscope:qwen-max")              // 主推理
                                                              .memory(MemoryConfig.builder()
                                                                      .model("dashscope:qwen-turbo")    // 记忆操作
                                                                      .build())
                                                              .compaction(CompactionConfig.builder()
                                                                      .model("dashscope:qwen-turbo")    // 压缩摘要
                                                                      .build())
                                                              .build();
                                                      // 这样整体成本能降 40-60%,效果几乎无损

                                                  实践三:Skill 沉淀——让 Agent 越用越强

                                                  团队在使用 Agent 的过程中,会积累大量有效的工作模式。把这些模式沉淀成 Skill,让 Agent 越用越强:

                                                  关键原则:

                                                  • 通用能力放 Git 技能仓库,团队共享

                                                  • 项目特有规范放 workspace/skills/,跟代码版本走

                                                  • 个人偏好放 <userId>/skills/,用户隔离

                                                  实践四:生产部署 Checklist

                                                  上线前逐项检查:

                                                  • 状态存储:用 Redis/MySQL,不要用内存或本地 JSON(多副本会丢状态)

                                                  • maxIters 上限:必须设,防止死循环烧 token

                                                  • 权限模式:生产环境用 STRICT 模式,不要用 DEFAULT

                                                  • 沙箱隔离:涉及代码执行的工具必须在沙箱中

                                                  • 上下文压缩:必须配 compaction,否则长对话必爆

                                                  • 大结果卸载:必须配 toolResultEviction,否则大文件读取必爆

                                                  • 可观测性:开启事件流日志,接监控告警

                                                  • 降级方案:模型超时/限流时的 fallback 模型

                                                  • 成本监控:设置 token 用量告警阈值

                                                  • 隐私脱敏:工具返回中的敏感信息(手机号、身份证号)要脱敏后再进上下文

                                                        // 生产级 Agent 配置模板
                                                        HarnessAgent agent = HarnessAgent.builder()
                                                                .name("production_agent")
                                                                .model("dashscope:qwen-max")
                                                                .maxRetries(3)                                    // 模型重试
                                                                .fallbackModel("dashscope:qwen-plus")             // 降级模型
                                                                .workspace(workspace)
                                                                .stateStore(new RedisAgentStateStore(jedis))      // 分布式状态
                                                                .compaction(CompactionConfig.builder()
                                                                        .triggerMessages(20).keepMessages(8).build())
                                                                .toolResultEviction(ToolResultEvictionConfig.defaults())
                                                                .memory(MemoryConfig.builder()
                                                                        .flushTrigger(MemoryConfig.FlushTrigger.throttled(Duration.ofMinutes(10)))
                                                                        .model("dashscope:qwen-turbo")
                                                                        .build())
                                                                .permissionContext(PermissionContextState.STRICT)
                                                                .enablePlanMode()
                                                                .build();

                                                    04

                                                    总结与展望

                                                    全景架构图

                                                    让我们把今天讲的所有概念整合到一张图里:

                                                    一句话总结:

                                                    • 推理层让 Agent 会思考(提示词 + 上下文 + ReAct)

                                                    • 行动层让 Agent 能做事(工具 + MCP + 技能 + 权限管控)

                                                    • 知识层让 Agent 有知识(知识库 + 记忆 + Session)

                                                    • 协作层让 Agent 能分工(子 Agent + 多 Agent 协作)

                                                    • Harness 底座让 Agent 稳定长跑(编排 + 状态 + 压缩 + 容错)

                                                    四层叠加在底座上 = 完整的自主智能体。

                                                    当前挑战

                                                    Agent 技术发展很快,但也面临实实在在的挑战:

                                                    • 稳定性:LLM 的概率推理本质意味着 Agent 不可能 100% 可靠,同样的输入可能得到不同结果

                                                    • 成本:多轮推理 + 工具调用 + 记忆提炼,一个复杂任务的 token 消耗是单次对话的几十倍

                                                    • 安全性:Agent 有了行动力,也意味着有了破坏力——误删文件、执行危险命令的风险真实存在

                                                    • 评估困难:传统软件测试是"输入→断言输出",Agent 的多步推理 + 工具调用让测试变成一个非确定性问题

                                                    这些挑战也催生了很多工程实践:权限系统做三态决策(允许/询问/拒绝)、HITL 让敏感操作可暂停等待人工确认、沙箱隔离让不可信代码安全执行。

                                                    未来方向

                                                    展望未来,几个值得关注的方向:

                                                    • 更强的自主规划能力:从 ReAct 的"走一步看一步"到更全局的规划——树状搜索、蒙特卡洛树搜索(MCTS)等

                                                    • Agent 自进化:Agent 自动沉淀成功经验为技能、自动清理过时技能——know-how 越用越多

                                                    • 多 Agent 生态:不同团队、不同公司的 Agent 通过标准协议(如 A2A 协议)互相协作,形成"Agent 的互联网"

                                                    • 与物理世界结合:Agent + 机器人,从数字世界走向物理世界——具身智能(Embodied AI)

                                                    一个启发

                                                    最后,我想留给大家一个思考:

                                                    Agent 技术的本质,不是让 AI 变得更"聪明",而是给 AI 搭一套"工程基础设施"——让它从"灵光一闪的问答"变成"可靠运转的系统"。这跟软件工程的发展史如出一辙:从单个脚本,到工程化,到平台化。

                                                    Agent 就是软件工程3.0--软件工程3.0的开发新范式。

                                                    我们正在经历的,是 AI 从"模型"到"系统"的工程化转折点。而这个转折点中的每一个工程问题——可靠性、可观测性、安全性、可维护性——都是我们工程师最擅长的领域。

                                                    Agent 的未来,不只是 AI 研究员的未来,更是我们每个工程师的未来。

                                                    END

                                                    跳转微信打开

                                                    vivo 邀您参加 COSCon'26 第十一届中国开源年会 @杭州

                                                    2026年11月11日 20:00

                                                    vivo 开源 2026-11-11 20:00 广东

                                                    2026年11月14-15日,杭州,不见不散

                                                    COSCon'26  第十一届中国开源年会将于 11 月 14 日至 15 日在杭州举办。

                                                    本次会议以“ 开源下一代,Open Source: The Next Generation ” 为主题,聚焦 AI 时代下的开源机遇、下一代开发者的成长路径,以及开源协作模式的持续演进。

                                                    会议日程

                                                    主论坛:

                                                    • 11 月 14 日:「下一代开源商业」与「下一代开源技术」

                                                    • 11 月 15 日:「下一代开源社区」与「下一代开源人才」

                                                    分论坛:26场平行分论坛

                                                    🤖 【下一代技术:AI infra 底层基建】

                                                    • 云原生开源分论坛(11/14)

                                                    • AI 原生开源操作系统分论坛(11/14)

                                                    • 开源 AI 基础设施分论坛(11/14-15)

                                                    • 具身智能开源论坛(11/14)Data × AI:

                                                    • 下一代数据基础设施(11/14-15)

                                                    • RISC-V软件生态分论坛(11/15)

                                                    • 开源工业 AI 分论坛(11/15)

                                                    • AI for Healthcare(11/14-15)

                                                    🧠 【下一代应用:Agent 时代与前沿实战】

                                                    • Agentic 时代的开源知识阅读:焦虑与注意力转移[BoF](11/14)

                                                    • Agent Builder Meetup × AAIF Meetup(11/14)

                                                    • LocalAI 开源小模型同好者研讨会[BoF](11/14)

                                                    • 开放 Agent 生态圆桌[BoF](11/15)

                                                    • Agent 自主进化:从记忆到持续学习(11/15)

                                                    🌱 【下一代人才:教育与学术】

                                                    • 青少年开源论坛(全天,11/14)

                                                    • AI 时代开源新人才(11/14)

                                                    • 下一代开源教育(11/15)

                                                    • 女性开源分论坛(11/15)

                                                    • The State of Academic Open Source Research Software[BoF](11/14)

                                                    🌍 【下一代社区生态:商业、治理与公益】

                                                    • 开源法律论坛(11/14)

                                                    • 开源供应链治理与可信协同实践(11/15)

                                                    • 开源生态的资助者与支持者们(11/15)

                                                    • 开源 For 罕见病[社区团聚](11/15)

                                                    • OpenGood 开源公益分论坛(11/15)

                                                    🛠️ 【Workshop:硬核动手与极客狂欢】

                                                    • Data × AI:检索、智能体记忆与上下文管理实战(11/14)

                                                    • 首期媒体FDE实战共创营(11/14-15)

                                                    • 开源硬件工作坊:雪花灯焊接活动(11/15)

                                                    • 真-开源人黑客马拉松[晨跑活动](11/15早)

                                                    点击了解活动日程:

                                                    https://www.bagevent.com/event/coscon26

                                                    vivo 赞助并积极参与本次会议

                                                    "拥抱开源,拥抱未来!" 

                                                    vivo 基于开源软件生态,为全球 5 亿+ 用户提供极致体验的智能产品和智慧服务。

                                                    vivo 已加入 Linux 基金会、TODO Group,持续加强与行业的开源交流及合作,与全球开源同行共同交流和探讨开源之道。在持续提升内部开源合规的同时,也向部分开源项目上游贡献代码。

                                                    此次 vivo 以星牌合作伙伴的形式参与 COSCon'26 第十一届中国开源年会 ,以实际行动传递 vivo 对开源的开放态度和积极贡献。

                                                    欢迎来 vivo 展台参与互动游戏,将有机会获得 vivolife 定制礼品。

                                                    COSCon'26 第十一届中国开源年会现场,vivo 展台不见不散。

                                                    购票请前往:

                                                    https://www.bagevent.com/event/coscon26#website_moduleId_1174908

                                                    ⬇️点击阅读原文,了解更多活动信息

                                                    阅读原文

                                                    跳转微信打开

                                                    面向技术产品经理的 Agent Harness 设计:从任务编排到可验证交付

                                                    2026年11月4日 20:00

                                                    原创 互联网产品团队 2026-11-04 20:00 广东

                                                    把用户目标转化为可执行任务、工具契约、权限策略、结构化结果和可验收的工程系统。

                                                    作者:vivo 互联网产品团队- Meng Disheng

                                                    目录

                                                    01. Agent 产品为什么需要技术建模

                                                    02. 从用户目标到 Agent Workflow

                                                    03. 任务模型:不要只设计一轮对话

                                                    04. 工具设计:产品经理要定义工具契约

                                                    05. 权限与副作用:用风险等级设计审批

                                                    06. 结果协议:从文本回答到结构化交付

                                                    07. 失败处理:重试、恢复与幂等性设计

                                                    08. 可观测性与验收:监控不能替代验证

                                                    09. 案例:反馈分析 Agent 的技术设计

                                                    10. 产品经理的交付物:需要围绕关键业务动作

                                                    11. 总结:从功能需求到 Agent 系统契约

                                                    面向产品经理的 Agent Harness 设计指南:把用户目标转化为可执行任务、工具契约、权限策略、结构化结果和可验收的工程系统。 产品经理在设计 Agent 产品时,不仅仅只写 Prompt、页面和最终输出,还要参与定义 Agent 如何执行任务、调用工具、控制权限、处理失败并交付结果。

                                                    1分钟看图掌握核心要点👇

                                                    01

                                                    Agent 产品为什么需要技术建模

                                                    传统产品需求往往可以用“输入—处理—输出”描述:用户提交信息,系统完成处理,再返回结果。但 Agent 产品通常不是一次同步调用,而是一段可能持续较长时间的工作过程。它可能需要读取多个数据源、调用多个工具、等待用户确认、处理外部系统失败,并在中间生成可复用的结果。

                                                    因此,Agent 产品需求不能只描述“用户输入什么、模型回答什么”。它至少要解释任务如何拆分、步骤之间是否存在硬依赖、可调用的工具是否会改动外部系统、何处需要用户确认,以及发生超时、拒绝或服务异常时任务应当停止、降级还是恢复。最终交付也不能只是一段回复,而要明确是结构化数据、可下载产物,还是一个已写入业务系统的资源。

                                                    如果一份 Agent 需求只能描述输入和输出,它通常还没有进入工程设计阶段。产品经理设计的不只是交互页面,还包括一套能够被执行、被观察和被验收的任务模型。

                                                    本文所说的 Agent Harness,不是某个特定框架的名称,而是承接任务定义、步骤调度、工具调用、权限执行、结果校验和运行观测的控制层。业务工作流决定“要完成什么”,工具实现决定“如何访问外部能力”,Harness 则把两者组织成一段可约束、可追溯的运行。本文关注的正是产品经理需要参与定义的这部分系统契约,而不讨论某一种模型或编排框架的具体实现。

                                                    02

                                                    从用户目标到 Agent Workflow

                                                    产品经理首先需要把用户目标转换成可执行的工作流,而不是直接把目标写成一个 Prompt。

                                                    例如,“根据用户反馈生成改进建议,并在确认后提交到目标工作系统”可以拆解为:

                                                    读取反馈数据

                                                      -> 清洗和去重
                                                      -> 按问题类型聚类
                                                      -> 统计影响范围
                                                      -> 查询历史记录
                                                      -> 生成候选建议
                                                      -> 检查建议冲突
                                                      -> 输出评估报告
                                                      -> 用户确认并提

                                                      每一个步骤都需要具备明确的工程属性:

                                                      字段

                                                      示例

                                                      步骤名称

                                                      用户反馈聚类

                                                      输入

                                                      反馈记录

                                                      输出

                                                      问题分类结果

                                                      使用工具

                                                      数据查询、文本分析

                                                      是否可并行

                                                      是

                                                      是否需要审批

                                                      否

                                                      失败处理

                                                      重试或跳过

                                                      产出类型

                                                      结构化数据

                                                      验收标准

                                                      每条反馈必须有分类

                                                      产品经理不一定需要实现聚类算法,但需要判断工作流是否完整:哪些步骤必须串行,哪些步骤可以并行,哪些结果可以被后续步骤消费,哪些环节需要产品经理介入。

                                                      为步骤定义执行语义

                                                      工作流不能只有顺序,还要定义调度语义。通常可把步骤分成四类:

                                                      步骤类型

                                                      典型场景

                                                      技术要求

                                                      serial

                                                      先完成数据清洗,再做聚类

                                                      前序输出校验通过后才可启动

                                                      parallel

                                                      同时查询历史记录与统计影响范围

                                                      独立输入、并发上限、聚合策略

                                                      fan-out/fan-in

                                                      按问题类别分别分析,再汇总建议

                                                      分片键、子任务失败容忍度、聚合条件

                                                      human-gate

                                                      向目标系统提交记录前等待确认

                                                      暂停条件、审批 payload、过期处理

                                                      例如,问题聚类和历史记录匹配可以并行,但建议生成是否必须等待两者完成,取决于历史记录在这项业务中是硬依赖还是增强信息。前者应阻塞后续生成;后者可以记录“历史匹配缺失”并降级继续。两种行为都要由任务定义决定,不能让执行器在运行时猜测。

                                                      建议把这种语义写进 Workflow DSL 或 JSON 配置,而不要散落在 Prompt 中。下面的配置将历史匹配视为硬依赖,因此任一步失败都会阻塞建议生成:

                                                          "id": "generate\_recommendation",  
                                                          "dependsOn": \["cluster\_feedback", "analyze\_impact", "match\_history"\],  
                                                          "mode": "serial",  
                                                          "input": {  
                                                            "clusters": "$steps.cluster\_feedback.output",  
                                                            "impact": "$steps.analyze\_impact.output",  
                                                            "history": "$steps.match\_history.output"  
                                                          },  
                                                          "onFailure": "block",  
                                                          "timeoutSeconds": 90  
                                                        }

                                                        这里的 dependsOn 定义依赖图,input 明确数据绑定,onFailure 定义失败传播。示例把影响范围统计也列为前置依赖,避免建议生成在缺少影响信息时继续执行。产品需求写清这些字段后,研发才能稳定实现调度、重试和可视化进度。

                                                        03

                                                        任务模型:不要只设计一轮对话

                                                        Agent 产品需要明确任务对象,而不是只围绕会话设计。建议将用户目标、输入、执行过程和结果组织在一个任务模型中:

                                                          Task
                                                          ├── taskId
                                                          ├── userGoal
                                                          ├── inputRefs
                                                          ├── workflowVersion
                                                          ├── owner
                                                          └── runRefs

                                                            Run
                                                            ├── runId
                                                            ├── taskId
                                                            ├── currentStep
                                                            ├── status
                                                            ├── outputs
                                                            ├── approvals
                                                            └── errors

                                                            产品经理需要区分以下对象:

                                                            对象

                                                            完整定义

                                                            典型作用

                                                            Conversation

                                                            用户与 Agent 之间按时间组织的消息和上下文记录。

                                                            提供交互入口与沟通历史。

                                                            Task

                                                            围绕一个明确业务目标组织的任务定义,包含输入、工作流和完成标准。

                                                            承载需要被完成和验收的业务工作。

                                                            Run

                                                            某个任务在特定配置、输入版本和时间点下的一次执行实例。

                                                            支持失败重试、运行对比和过程追踪。

                                                            Artifact

                                                            任务执行后生成的、可被访问、下载或继续消费的结果对象。

                                                            承载报告、结构化结果或外部系统记录。

                                                            一个任务可以包含多轮对话、多次运行和多个产物。对话是交互载体,任务是业务目标,运行是一次执行实例,产物是可继续使用的交付结果。如果把这些对象混成一个聊天线程,后续很难支持重试、对比、恢复和结果归属。这里的 Task.owner 表示业务归属或责任主体,不等同于发起会话的用户;Run.approvals 保存本次执行实际使用的审批记录引用,而不是把审批内容复制进每条消息。

                                                            任务对象需要版本和引用语义

                                                            任务对象在工程上至少要支持两个能力:输入可复现与结构可演进。前者要求任务保存输入的稳定引用,不是只保存提示词中的长文本;后者要求对象允许字段逐步增加,同时保持历史任务可读。

                                                              {  
                                                                "taskId": "task\_01J...",  
                                                                "schemaVersion": 2,  
                                                                "goal": "基于用户反馈生成需求建议",  
                                                                "inputRefs": \[  
                                                                  {"type": "feedback\_sheet", "id": "file\_123", "version": "v7"}  
                                                                \],  
                                                                "workflowVersion": "feedback-analysis@1.3.0",  
                                                                "runs": \["run\_a1", "run\_a2"\],  
                                                                "artifactRefs": \["artifact\_report\_01"\]  
                                                              }

                                                              schemaVersion 解决对象结构演进,workflowVersion 解决同一任务在不同编排版本下的行为差异,inputRefs.version 则避免数据源更新后无法解释历史结论。产品经理至少需要提出“历史任务是否必须复现”“规则更新后旧任务如何展示”这两个问题;它们会直接影响存储模型与审计成本。

                                                              04

                                                              工具设计:产品经理要定义工具契约

                                                              Agent 是否可靠,很大程度取决于工具是否设计清晰。产品经理不一定编写工具实现,但需要参与定义工具契约:

                                                                Tool:  
                                                                  name  
                                                                  description  
                                                                  inputSchema  
                                                                  outputSchema  
                                                                  permission  
                                                                  sideEffect  
                                                                  timeout  
                                                                  retryPolicy

                                                                以“提交建议到目标工作系统”工具为例:

                                                                  submitRecommendation:  
                                                                    input:  
                                                                      title  
                                                                      description  
                                                                      priority  
                                                                      targetScope  
                                                                      idempotencyKey  

                                                                    output:  
                                                                      recordId  
                                                                      url  
                                                                      status  

                                                                    permission:  
                                                                      write\_target\_system  

                                                                    sideEffect:  
                                                                      create\_external\_record

                                                                  产品经理需要确认:

                                                                  • 工具什么时候可以被调用;

                                                                  • 参数是否足够完整;

                                                                  • 返回结果是否足够支持下一步;

                                                                  • 工具是否修改外部系统;

                                                                  • 是否需要审批;

                                                                  • 调用失败后是否可以重试;

                                                                  • 是否允许重复调用;

                                                                  • 是否需要幂等键。

                                                                  此处注意工具不是“给模型调用的接口列表”,工具是 Agent 工作流中的业务动作协议。一个工具的输入、输出、权限和副作用如果没有明确约定,模型的自由度越高,系统的不确定性也越高。

                                                                  4.1 输入校验、输出校验和错误码必须分层

                                                                  工具调用至少需要三层校验:

                                                                  • 调用前校验:使用 JSON Schema、字段枚举和权限策略拒绝非法参数,例如优先级不在允许范围、项目不属于当前授权范围。

                                                                  • 执行后校验:对工具返回值做 Schema 校验,避免模型把错误响应误当成成功结果继续推理。

                                                                  • 业务结果校验:验证业务不变量,例如提交成功后必须获得可查询的 recordId

                                                                  建议让工具返回稳定的结果,不要把异常拼成自然语言:

                                                                    {  
                                                                      "ok": false,  
                                                                      "requestId": "req\_8f2c",  
                                                                      "error": {  
                                                                        "code": "DUPLICATE\_RECORD",  
                                                                        "retryable": false,  
                                                                        "message": "同一业务动作已提交记录",  
                                                                        "details": {"recordId": "record\_1024"}  
                                                                      }  
                                                                    }

                                                                    其中 retryable 决定执行器是否自动重试,requestId 用于日志关联,details 让后续步骤可以选择跳转已有记录而不是重复提交。这里的 DUPLICATE_RECORD 适用于“业务上不允许重复”的场景;若调用方携带的是同一幂等键,服务端更稳妥的做法是返回首次成功的资源,并在响应中标明 idempotentReplay: true。产品经理在定义工具输出时,应要求区分“未执行”“执行失败”“已执行但结果不满足业务条件”和“幂等重放返回已有结果”。

                                                                    4.2 工具描述是约束接口

                                                                    模型看到的工具描述会影响调用决策,但它不能替代机器可校验的 Schema。推荐把人类可读说明、机器可读 Schema 和策略约束分离:

                                                                      Tool description -> 告诉模型何时使用、何时禁止使用
                                                                      JSON Schema       -> 约束参数类型、枚举、必填项
                                                                      Policy           -> 约束主体、资源范围、风险等级
                                                                      Executor         -> 负责超时、重试、幂等与审计

                                                                      这能避免把“禁止修改其他项目”“标题最长 80 字”之类的硬约束仅写在 Prompt 中。Prompt 可以被误解,Schema 和 Policy 必须能够在执行前强制生效。

                                                                      05

                                                                      权限与副作用:用风险等级设计审批

                                                                      不同工具对系统的影响不同,权限策略不能只采用“允许”或“禁止”两种状态。可以按照副作用和风险将工具分级:

                                                                      等级

                                                                      类型

                                                                      示例

                                                                      默认策略

                                                                      L0

                                                                      只读计算

                                                                      文本分类、格式转换

                                                                      自动执行

                                                                      L1

                                                                      读取业务数据

                                                                      查询历史记录、查询知识库

                                                                      权限校验

                                                                      L2

                                                                      生成内部产物

                                                                      生成方案草稿、报告、测试用例

                                                                      自动执行并记录来源

                                                                      L3

                                                                      修改业务数据

                                                                      向目标系统提交记录、更新任务字段

                                                                      明确授权,必要时审批

                                                                      L4

                                                                      高风险外部动作

                                                                      删除数据、发送消息、对外发布

                                                                      强制审批和审计

                                                                      策略可以进一步表达为结构化配置:

                                                                        Policy:  
                                                                          tool: submitRecommendation  
                                                                          riskLevel: L3  
                                                                          requireApproval: true  
                                                                          allowedScopes: \[...\]  
                                                                          allowedFields: \[...\]  
                                                                          idempotencyRequired: true

                                                                        产品经理需要把“需要确认”转化为可执行规则:哪些工具必须确认,哪些参数变化会触发重新确认,确认的有效范围是什么,拒绝之后如何处理,是否允许预授权,以及审批过程如何记录。

                                                                        授权应绑定主体、资源和动作

                                                                        审批不仅仅是一个布尔值。有效授权至少应绑定三类上下文:

                                                                        • Subject:谁在授权,例如当前用户或代理服务身份

                                                                        • Resource:可访问或修改什么,例如 scopeId、documentId、tenantId

                                                                        • Action:允许做什么,例如 read、create、update、publish

                                                                        例如“允许提交建议”并不等于“允许向所有目标空间写入记录”。更可执行的授权记录是:

                                                                          {  
                                                                            "subject": "user\_12345",  
                                                                            "action": "recommendation.submit",  
                                                                            "resource": {"scopeId": "workspace\_1001"},  
                                                                            "constraints": {"priorityIn": \["P1", "P2"\], "expiresAt": "2026-08-22T12:00:00Z"},  
                                                                            "approvalId": "approval\_01"  
                                                                          }

                                                                          当工具参数越过资源范围、修改了受约束字段或审批过期时,执行器必须重新请求授权。这样可以避免一次确认被错误扩展为无限范围的通行证。

                                                                          06

                                                                          结果协议:从文本回答到结构化交付

                                                                          Agent 的结果不应只有一段 Markdown 文本。不同任务需要定义不同的结果协议,例如:

                                                                            Result:  
                                                                              summary  
                                                                              evidence  
                                                                              decisions  
                                                                              risks  
                                                                              pendingQuestions  
                                                                              artifactRefs  
                                                                              nextActions

                                                                            用户反馈分析可以输出:

                                                                              {  
                                                                                "summary": "...",  
                                                                                "clusters": \[\],  
                                                                                "priorityRecommendations": \[\],  
                                                                                "matchedRequirements": \[\],  
                                                                                "evidenceRefs": \[\],  
                                                                                "uncertainties": \[\],  
                                                                                "nextActions": \[\]  
                                                                              }

                                                                              产品经理需要区分四类结果,因为它们对应不同的存储、展示和后续消费方式:

                                                                              结果类型

                                                                              完整说明

                                                                              适用场景

                                                                              自然语言说明

                                                                              面向用户阅读的结论、解释和执行过程摘要。

                                                                              在会话中说明判断依据与下一步建议。

                                                                              结构化业务结果

                                                                              满足固定字段约束、可被程序继续读取和校验的数据对象。

                                                                              将分析结果传给后续 Agent、页面组件或规则引擎。

                                                                              可下载产物

                                                                              具备文件格式、版本和访问地址的独立交付物。

                                                                              输出报告、表格、文档或图片等可留存材料。

                                                                              外部系统记录

                                                                              在目标工作系统中创建或更新的稳定资源。

                                                                              形成可继续跟进的事项、任务或数据记录。

                                                                              结构化结果可以被前端展示,也可以被后续 Agent 消费;产物可以导出为报告;外部系统记录则需要返回稳定的 ID 和访问地址。重要结论还应带有证据引用和不确定性说明,避免把推测包装成事实。

                                                                              6.1 将证据与结论建成可追溯关系

                                                                              结果协议中的 evidenceRefs 不应只是 URL 列表,需要能表达“哪条结论依据了哪些来源”。推荐使用可定位引用:

                                                                                {  
                                                                                  "recommendationId": "rec\_01",  
                                                                                  "statement": "登录失败提示需要覆盖网络异常场景",  
                                                                                  "confidence": 0.82,  
                                                                                  "evidence": \[  
                                                                                    {"sourceId": "feedback\_328", "locator": "row:328", "role": "user\_feedback"},  
                                                                                    {"sourceId": "metric\_login", "locator": "2026-08-01..2026-08-15", "role": "metric"}  
                                                                                  \],  
                                                                                  "assumptions": \["反馈样本已完成去重"\]  
                                                                                }

                                                                                confidence 不能替代证据,但可以帮助界面进行排序和提示;assumptions 则把模型推理依赖的前提显式化。对于需要进入外部系统的结果,建议增加 resultVersion、generatedAt、generatorVersion,以便后续比较不同版本的分析差异。

                                                                                6.2 结果发布前增加确定性校验

                                                                                LLM 输出具有非确定性,结构化输出也可能字段齐全但业务不正确。因此,发布前应增加确定性校验器,例如:

                                                                                  - 每条建议至少绑定一条 evidence
                                                                                  - priority 必须属于 P0/P1/P2/P3
                                                                                  - sourceRef 必须属于本次 Task 的可访问输入
                                                                                  - externalRecordId 只能在写工具成功后出现
                                                                                  - 风险等级为高时必须有 nextAction

                                                                                  这些规则更适合由普通代码或规则引擎执行,而不是再次交给模型判断。模型负责生成候选结论,校验器负责守住协议边界。

                                                                                  07

                                                                                  失败处理:重试、恢复与幂等性设计

                                                                                  Agent 任务的失败不能只显示“执行失败,请重试”。至少需要区分:

                                                                                    InputError
                                                                                    PermissionError
                                                                                    ToolError
                                                                                    TimeoutError
                                                                                    ModelError
                                                                                    ValidationError
                                                                                    ExternalSystemError

                                                                                    不同错误类型应采用不同策略:

                                                                                    错误类型

                                                                                    处理方式

                                                                                    输入错误

                                                                                    引导用户补充信息

                                                                                    权限错误

                                                                                    请求授权或更换数据源

                                                                                    工具错误

                                                                                    重试或切换工具

                                                                                    超时

                                                                                    继续后台执行或拆分任务

                                                                                    模型错误

                                                                                    降级模型或重新规划

                                                                                    校验失败

                                                                                    返回 Agent 修正

                                                                                    外部系统错误

                                                                                    保留任务并支持恢复

                                                                                    需要特别关注具有副作用的步骤。如果向目标系统提交记录的接口已经成功,但响应在网络传输过程中丢失,简单重试可能造成重复写入。因此,写操作应使用任务 ID、步骤 ID或业务幂等键标识同一业务动作:

                                                                                    同一个 taskId + stepId 不应重复创建相同业务数据

                                                                                    产品经理需要在需求阶段明确:哪些失败可以自动重试,哪些失败必须通知用户,哪些步骤支持从中间位置继续,以及失败时已经产生的产物如何处理。

                                                                                    7.1 重试策略必须区分读、写与模型生成

                                                                                    “最多重试三次”不是通用策略。不同类别的操作需要不同的执行规则:

                                                                                    操作类型

                                                                                    典型失败

                                                                                    推荐策略

                                                                                    只读查询

                                                                                    网络抖动、限流

                                                                                    指数退避重试,可加入抖动

                                                                                    写外部系统

                                                                                    响应丢失、网关超时

                                                                                    先按幂等键查询,再决定是否重试

                                                                                    模型生成

                                                                                    格式不合法、内容不完整

                                                                                    修复提示词或基于校验错误再生成

                                                                                    长任务

                                                                                    执行超时

                                                                                    拆分、异步化或延长租约,不应盲目重复执行

                                                                                    指数退避可以表达为 delay = base * 2^attempt + jitter。jitter 的作用是避免大量任务在同一时刻重试造成二次拥塞。对于 L3/L4 写操作,重试前必须优先检查是否已经落库;这是比“请求是否超时”更可靠的判断。

                                                                                    7.2 幂等键应表达业务动作

                                                                                    一个可用的幂等键通常由业务主键组成:

                                                                                      idempotencyKey = hash(taskId + stepId + targetProjectId + normalizedPayload)

                                                                                      其中 normalizedPayload 应排除时间戳、展示文案等不影响业务语义的字段。服务端收到相同键时,应返回首次创建的资源,而不是再次执行。这样即使执行器重启、网络响应丢失或用户重复点击,也能把同一业务动作折叠为一次结果。

                                                                                      08

                                                                                      可观测性与验收:监控不能替代验证

                                                                                      Agent 上线后,最容易出现两种误判:一是任务“跑完了”就被视为成功;二是平均耗时下降就被视为体验变好。前者掩盖了结论无依据、写操作重复执行等问题,后者又可能以牺牲结果质量为代价。对 Agent 而言,观测数据的价值不在于堆出一张大盘,而在于帮助团队定位一次失败究竟发生在任务设计、模型决策、工具接口,还是用户确认环节。

                                                                                      以“根据反馈提交改进建议”为例,如果完成率突然下降,先看任务是否停在输入校验或授权环节;如果完成率没有变化、人工返工却明显增加,再回看引用是否缺失、聚类规则是否漂移、工作流版本是否变化。工具超时率只有和具体的步骤、数据源及重试次数放在一起,才有诊断意义。单独统计“工具成功率”通常解决不了问题。

                                                                                      实践中可以把观测字段压缩为一条可关联的执行记录:

                                                                                        traceId, taskId, runId, stepId, toolName,
                                                                                        workflowVersion, promptVersion, inputRef, outputRef,
                                                                                        latencyMs, retryCount, errorCode, approvalId

                                                                                        taskId 服务于业务检索,traceId 用于跨服务追踪,workflowVersion 和 promptVersion 用来解释“为什么同一类输入这周开始产生不同结果”。如果一条需求建议被用户退回,团队应该可以沿着这条记录还原它使用了哪个输入版本、走过哪些步骤、调用了什么工具、何处发生重试,以及最终依据来自哪里。

                                                                                        验收也不应停留在“看几条回答是否顺眼”。更实用的做法是保留少量高价值样本:空反馈、历史记录服务不可用、重复提交、目标空间越权、用户拒绝审批等。每个样本都写清不可触碰的边界,而不是罗列一长串泛泛指标。下面的用例同时约束工具选择、结果结构和副作用上限:

                                                                                          case: feedback-duplicate-submit  
                                                                                          inputRef: fixture://feedback/duplicate.csv  
                                                                                          expect:  
                                                                                            requiredTools: \[readFeedback, clusterFeedback, submitRecommendation\]  
                                                                                            forbiddenTools: \[publishAnnouncement\]  
                                                                                            resultSchema: AnalysisResult@v1  
                                                                                            assertions:  
                                                                                              - path: $.recommendations\[\*\].evidenceRefs.length  
                                                                                                operator: greaterThan  
                                                                                                value: 0  
                                                                                              - path: $.artifactRefs\[?(@.type == 'target\_system\_record')\].externalId  
                                                                                                operator: exists  
                                                                                            sideEffects:  
                                                                                              maxSubmittedRecords: 1

                                                                                          这类用例更接近契约测试:它不承诺模型必须写出哪一句话,却明确要求不能绕过证据、不能调用无关工具、不能因为重试创建两条需求。把它放进 CI 或灰度回归,比让测试同学反复手工体验更能发现工程回归。

                                                                                          09

                                                                                          案例:反馈分析 Agent 的技术设计

                                                                                          9.1 业务目标

                                                                                          根据用户反馈,自动生成改进建议,并在用户确认后提交到目标工作系统。

                                                                                          9.2 任务流程

                                                                                          先导入用户反馈并完成格式检查,然后执行数据清洗、问题聚类和影响范围分析,再匹配历史记录并生成候选方案,经过结果校验和用户确认后,才调用提交建议的写入工具。

                                                                                          该流程中的前半段只读取和分析数据,后半段则从“生成建议”转入“改变业务系统”。这条边界决定了提交动作必须放在用户确认之后,并使用可追踪的幂等键执行。

                                                                                          9.3 工具列表

                                                                                          工具

                                                                                          完整职责

                                                                                          输入和输出边界

                                                                                          readFeedback

                                                                                          读取并标准化用户反馈文件,识别空行、非法字段和版本信息。

                                                                                          输入为文件引用,输出为可分析的反馈记录集。

                                                                                          queryHistorical-Records

                                                                                          查询与问题类别、关键词或业务域相关的历史记录。

                                                                                          输入为查询条件,输出为带来源标识的候选记录集合。

                                                                                          clusterFeedback

                                                                                          对反馈记录进行分类、聚类和去重,形成问题主题。

                                                                                          输入为标准化记录,输出为带成员列表的聚类结果。

                                                                                          generateRecom-mendation

                                                                                          根据聚类、影响范围和历史匹配生成候选改进建议。

                                                                                          输入为分析结果,输出为附带证据的建议对象。

                                                                                          validateRecom-mendation

                                                                                          用确定性业务规则验证建议的字段、来源和冲突情况。

                                                                                          输入为候选建议,输出为通过项、阻塞项和修复建议。

                                                                                          submitRecom-mendation

                                                                                          在用户授权的目标空间中提交正式记录。

                                                                                          输入为已确认的建议与幂等键,输出为记录 ID、链接和提交状态。

                                                                                          9.4 权限、结果与校验如何落到一条链路上

                                                                                          这六个工具并不处在同一个风险等级。readFeedback 和 queryHistoricalRecords 会读取业务资料,应在数据源授权范围内以 L1 执行;clusterFeedback 和 validateRecommendation 只处理已获授权的输入,属于 L0;generate-

                                                                                          Recommendation 产生内部分析材料,可按 L2 管理并保留生成版本;submitRecommendation 会向目标工作系统写入记录,必须按 L3 执行,绑定目标空间、用户确认和幂等键。

                                                                                          最终输出的 AnalysisResult 不应只是一段摘要。它至少要包含 clusters、affectedUsers、priority-

                                                                                          Suggestions、matchedRecords、recommen-

                                                                                          dations、risks 和 evidenceRefs。其中每条 recommendations 都应携带证据引用,便于追问“这条 P1 建议对应哪几类反馈”。提交成功后得到的资源不宜混入分析结果,而应作为独立的 SubmitRecommendationResult,或以 artifact-

                                                                                          Refs 中的外部记录引用返回;这样分析输出和写操作结果的生命周期不会混在一起。

                                                                                          提交记录前,校验器要连续确认几件具体的事:标题不能为空;每条建议必须能回指到反馈或历史记录;目标空间必须在当前用户的授权范围内;优先级只能取系统允许的值;相同 taskId + stepId + targetScope 不能已经提交过资源;并且用户必须已经对这一次写操作确认。任何一项不满足,都应该停在提交前,而不是让模型自己补一个默认值继续执行。

                                                                                          验收时建议直接围绕故障场景做判断。空反馈应回到补充输入,而不是生成泛泛的结论;历史记录服务不可用时,可以提示“缺少历史匹配”但不能伪造引用;没有证据的方案不能进入提交步骤;用户拒绝后不得发起写请求;网络超时后必须先按幂等键查询已有结果;成功返回则必须包含记录 ID 和可访问链接。这样的验收描述同时覆盖用户体验和服务端行为,比“任务成功率达到多少”更接近真实风险。

                                                                                          这个案例中,产品经理通过定义任务、工具、权限、结果和验收标准,参与了 Agent 的技术方案设计,而不是只描述一个聊天页面。

                                                                                          10

                                                                                          产品经理的交付物:需要围绕关键业务动作

                                                                                          Agent 需求经常失败在一个很朴素的地方:文档里写了用户要什么,却没有写清系统在不确定条件下该怎么做。研发只能把判断塞进 Prompt,测试也只能凭感觉点几轮。更有效的交付不是六张独立的清单,而是一张围绕关键业务动作展开的任务卡。

                                                                                          以“提交建议到目标工作系统”这个动作为例,任务应把以下内容写在同一个上下文中:任务要解决哪类用户问题,哪些输入是可信来源,必须经过哪些前置步骤,读取和写入分别可以访问哪些系统,什么情况下暂停等待人确认,外部接口超时后如何避免重复提交,最终要返回什么资源标识,以及哪些反例必须在测试中覆盖。这样研发看到的是一个可实现的闭环,不是一组被拆散的名词。

                                                                                          可以用下面的模板审查一张任务卡是否足够完整:

                                                                                          审查项

                                                                                          需要回答的问题

                                                                                          业务完成条件

                                                                                          任务产生什么可验证结果,什么状态下算真正完成?

                                                                                          输入和来源

                                                                                          输入来自哪里,是否有版本号、权限限制和失效处理?

                                                                                          工作流边界

                                                                                          哪些步骤是硬依赖,哪些可降级,哪里必须等待人工决策?

                                                                                          工具和副作用

                                                                                          工具能读写哪些资源,超时与重复调用时会发生什么?

                                                                                          结果与证据

                                                                                          哪些字段必须结构化返回,结论如何回指到来源?

                                                                                          异常和恢复

                                                                                          缺输入、无权限、服务超时和写入不确定时分别怎么处理?

                                                                                          验收反例

                                                                                          哪些越权、重复写入、无证据结论或错误降级必须被拦住?

                                                                                          产品经理越早补齐这些问题,研发越容易选择合适的执行模型、工具协议和存储方式,测试也越容易建立稳定的回归样本。这里的目标不是让产品经理承担实现细节,而是避免关键业务判断在实现后期才以补丁形式出现。

                                                                                          11

                                                                                          总结:从功能需求到 Agent 系统契约

                                                                                          Agent 产品的技术设计,不能停留在 Prompt、模型和聊天界面。真正需要被设计的是一条业务动作链:任务的输入和完成条件先被固定下来,再拆成带依赖关系的步骤;每个步骤只能通过有 Schema、权限和副作用约束的工具执行;结果以可追溯的结构化协议交付;异常、重试和验证则保证这条链在不确定环境下仍然可控。

                                                                                          这不意味着产品经理要替研发决定存储引擎或调度框架。产品经理要负责的是把那些不能靠模型自由发挥的判断提前说清楚:一条需求建议何时算完成,哪些来源可以作为证据,什么范围内允许写入业务系统,用户拒绝或接口超时后应当发生什么,以及哪些反例必须被测试拦住。研发据此选择实现方式,测试据此建立回归样本,双方都不必在上线前再通过补规则修正业务边界。

                                                                                          最终,Agent 产品的竞争力不只是模型回答得是否自然,还要能把复杂工作稳定地转化为可执行、可追溯、可验证的业务结果。好的 Agent 需求,是先把不能出错的业务边界写进任务、工具和验证规则。

                                                                                          注:本文插图和部分代码由ai辅助生成

                                                                                          END

                                                                                          跳转微信打开

                                                                                          把 Agent 的判断与行动变成可恢复的软件事实|KDC 系列 工程篇

                                                                                          2026年11月4日 20:00

                                                                                          互联网存储团队 2026-11-04 20:00 广东

                                                                                          一次 Agent 运行如何被恢复、交接、验证和持续演进。

                                                                                          作者:vivo 互联网存储团队 - Xiao Bo

                                                                                          AI 合作者:ChatGPT(GPT-5.5)

                                                                                          创作模式:Human-led, AI-collaborated

                                                                                          责任声明:文章观点、理论体系及最终内容由作者负责;AI 参与讨论、推演、表达优化及部分内容生成。

                                                                                          目录

                                                                                          01. 会执行一次循环,不等于可以运行一个产品

                                                                                          02. 三种事实不能混在一起

                                                                                          03. 生产级 Agent 需要两条可以连接的链

                                                                                          04. ReAct、Harness 和 KDC 分别解决什么

                                                                                          05. 公开实践不是一套统一理论,但在回答同一组问题

                                                                                          06. Harness 不是一个单体

                                                                                          07. 最小运行对象:让现场拥有稳定归属

                                                                                          08. Session、Context、State、Memory 

                                                                                                和 Knowledge 不是同一个对象

                                                                                          09. State、View 和 Control 必须分开

                                                                                          10. 语义责任必须分开,物理存储可以统一

                                                                                          11. 一份最小 State Schema

                                                                                          12. 从判断到执行,需要经历一次可恢复的状态变化

                                                                                          13. Checkpoint 不等于 Durable Execution

                                                                                          14. Run 结束以后,哪些事实可以离开 Session

                                                                                          15. 日志和 Trace 仍然不等于运行状态

                                                                                          16. 长时间任务还需要 Progress Contract

                                                                                          17. Agent Harness 本身也需要 Evaluation Contract

                                                                                          18. Harness 的假设也有生命周期

                                                                                          19. 不要先建设一个庞大的 Harness 平台

                                                                                          20. 实践:对一条 Agent 流程做恢复演练

                                                                                          21. 从“模型做过什么”走向“系统可以相信什么”

                                                                                          22. 理论边界与开放问题

                                                                                          会推理、会调用 Tool,只能说明 Agent 能够完成一次执行循环。要进入真实业务,系统还必须让目标、判断、审批、执行、产物和反馈拥有稳定状态,并在刷新、重连、进程重启和人工介入后继续保持一致。本文区分领域现实、业务判断事实和软件运行事实,提出业务因果链与运行事实链的双链结构;进一步将 Session、Harness 与执行环境解耦,区分 Session、Context、State、Memory 和 Knowledge,并以 Resume Contract、Progress Contract 与 Evaluation Contract 说明一次 Agent 运行如何被恢复、交接、验证和持续演进。

                                                                                          研究说明:知识驱动计算(Knowledge-driven Computing,KDC)是我们提出和正在打磨的一套 AI 应用软件工程理论,目前仍处于开放研究阶段。前四篇分别从 Reality、Knowledge、Reasoning、Skill、Capability、Memory 和 Feedback 展开。这一篇不再逐个解释概念,而是回答最后一个问题:它们如何组成一套完整、可审计、可治理、可渐进采用的软件工程模型?

                                                                                          1分钟看图掌握核心要点👇

                                                                                          还是从退款这个具体场景开始。

                                                                                          用户问售后 Agent:

                                                                                          帮我看看这笔订单能不能退。如果可以,就直接帮我处理。

                                                                                          Agent 查询订单,引用当前退款政策,判断订单符合条件,然后准备调用退款能力。由于退款会改变订单和资金状态,系统要求用户确认。页面显示了一条审批提示:

                                                                                          订单符合退款条件。是否确认发起退款?

                                                                                          用户还没有点击确认,页面突然刷新。

                                                                                          刷新之后,审批提示消失了。聊天记录里还能看到 Agent 说过“准备退款”,但前端不知道审批是否仍然有效,后端不知道用户是否已经做过决定,能力运行时也不知道应该继续、暂停还是取消。

                                                                                          更危险的情况是,退款请求已经提交给支付渠道,但后端在写入本地完成状态之前重启。恢复后,系统只看到“任务尚未完成”,于是再次调用退款接口。

                                                                                          这一次,问题不在知识是否可靠,也不在 Agent 是否理解了用户目标。判断和授权规则可能都是正确的,系统仍然可能因为缺少稳定运行事实而丢失现场、重复执行或无法追责。

                                                                                          这说明,从“Agent 做出了正确判断”到“系统可靠地完成了行动”之间,还有一层不能省略的工程结构。

                                                                                          01

                                                                                          会执行一次循环,不等于可以运行一个产品

                                                                                          ReAct 可以把模型行为概括成一个循环:

                                                                                            Thought -> Action -> Observation

                                                                                            模型根据当前上下文形成下一步,调用 Tool,读取结果,再继续判断。这个抽象很好地解释了模型如何在一次任务中交替推理和行动。

                                                                                            但产品系统面对的不是一段始终连续的模型调用。页面会刷新,连接会断开,进程会重启,Tool 会长时间运行,审批可能等待几个小时,外部系统可能已经完成操作但响应丢失,子 Agent 也可能在另一个执行环境中继续工作。

                                                                                            生产系统还需要回答:

                                                                                            • 当前是哪一次 Run、哪一个 Turn 在运行?

                                                                                            • 模型已经提出了什么行动,行动是否得到授权?

                                                                                            • Tool 是尚未调用、正在执行、已经完成,还是结果未知?

                                                                                            • 用户刷新页面后,原审批是否仍然有效?

                                                                                            • 进程重启后,应该从哪里恢复?

                                                                                            • Artifact 和子 Agent 属于哪个目标、判断和行动?

                                                                                            • 用户点击 Stop 时,究竟停止哪一次运行?

                                                                                            • 外部行动是否已经发生,重试会不会造成重复影响?

                                                                                            这些问题不能依靠模型“记住”,也不能让 UI 从聊天文本中猜测。它们必须成为系统可以持久化、引用和恢复的运行事实。

                                                                                            我们把承载这类责任的工程系统称为 Agent Harness,并提出通过共享 State Schema、Runtime Event、View 和 Control,把模型行为转化为可恢复、可控制、可追溯的产品事实。vivo 团队关于从 ReAct 到 Agent Harness 的工程讨论,是本文继续追问状态归属、恢复边界和产品一致性的一个直接起点。

                                                                                            这个视角与 KDC 的对象化、运行时化和治理化高度契合。但在接入 KDC 之前,需要先澄清“事实”并不只有一个层次。

                                                                                            02

                                                                                            三种事实不能混在一起

                                                                                            在 Agent 系统中,至少存在三种需要分别管理的事实。

                                                                                            层次

                                                                                            回答的问题

                                                                                            退款场景示例

                                                                                            主要依据

                                                                                            领域现实

                                                                                            现实中究竟发生了什么

                                                                                            用户是否真正收到退款

                                                                                            到账回执、对账结果、用户确认

                                                                                            业务判断事实

                                                                                            系统为什么形成当前结论

                                                                                            订单符合退款条件,但必须获得用户确认

                                                                                            目标、订单事实、知识版本、风险和策略

                                                                                            软件运行事实

                                                                                            系统已经执行到哪里

                                                                                            正在等待审批;Tool 已发起;结果待确认

                                                                                            Runtime Event、State、Checkpoint、外部调用记录

                                                                                            领域现实是应用软件的最终参照物。软件只能通过接口、事件、人工确认和其他表示间接观察它。

                                                                                            业务判断事实说明系统基于什么目标、知识和证据形成结论,又为什么建议某项行动。这里的“事实”不是说判断必然正确,而是说系统确实在特定上下文和依据下形成过这项判断。KDC 用推理对象或等价的 AI Action Record 表达这类责任。

                                                                                            软件运行事实则说明某次运行中已经发生了什么:Run 是否开始,审批是否挂起,Tool 是否执行,Artifact 是否创建,Checkpoint 位于哪里。

                                                                                            三者有关联,但不能互相替代:

                                                                                              tool.call.completed
                                                                                                不等于
                                                                                              退款已经到账


                                                                                              pendingApproval = null
                                                                                                不等于
                                                                                              用户已经同意退款


                                                                                              页面显示“已完成”
                                                                                                不等于
                                                                                              业务目标已经实现

                                                                                              Runtime 可以权威地声明“这次 Tool Call 已经完成”,却不能仅凭这个运行事实证明用户已经收到资金。UI 可以显示审批条,却不能因为审批条消失就推断用户已经授权。

                                                                                              KDC 与 Agent Harness 在这里形成互补:Harness 让运行事实可信,KDC 继续追问这些运行事实对应什么业务判断和领域现实。

                                                                                              03

                                                                                              生产级 Agent 需要两条可以连接的链

                                                                                              KDC 的业务因果链关注系统为什么行动,以及行动是否实现现实目标:

                                                                                                Reality
                                                                                                  -> Knowledge / Memory
                                                                                                  -> Reasoning
                                                                                                  -> Skill
                                                                                                  -> Capability
                                                                                                  -> Policy Decision
                                                                                                  -> Action
                                                                                                  -> Feedback
                                                                                                  -> Reality

                                                                                                Agent 产品的运行事实链关注一次执行如何持续存在:

                                                                                                  Runtime Event
                                                                                                    -> State
                                                                                                         -> View
                                                                                                         -> Checkpoint -> Resume


                                                                                                  User Control
                                                                                                    -> Runtime Event

                                                                                                  两条链不能各自独立。只保留业务因果链,系统可能解释得清楚却无法恢复。只保留运行事实链,系统可以恢复调用,却不知道行动是否具备业务资格,也不知道最终结果是否实现现实目标。

                                                                                                  图:业务因果链与运行事实链通过稳定身份连接

                                                                                                  连接两条链的关键不是复制更多文本,而是稳定身份:

                                                                                                    runId
                                                                                                    turnId
                                                                                                    reasoningObjectId
                                                                                                    skillId
                                                                                                    capabilityId
                                                                                                    policyDecisionId
                                                                                                    approvalId
                                                                                                    toolCallId
                                                                                                    artifactId
                                                                                                    feedbackId

                                                                                                    这些身份让系统知道,一条审批属于哪次判断,一次 Tool Call 来自哪个能力,一份 Artifact 支持哪个目标,一条反馈又应该修正哪次行动。

                                                                                                    04

                                                                                                    ReAct、Harness 和 KDC 分别解决什么

                                                                                                    三者并不是互相替代的架构方案。

                                                                                                    层次

                                                                                                    核心问题

                                                                                                    不单独解决什么

                                                                                                    ReAct / 模型循环

                                                                                                    模型看到当前 Observation 后,下一步做什么

                                                                                                    状态恢复、跨端一致、业务授权和现实验证

                                                                                                    Agent Harness

                                                                                                    模型行为如何成为可恢复、可控制的软件运行事实

                                                                                                    知识为什么可信、行动为什么具备业务资格、现实目标是否实现

                                                                                                    KDC

                                                                                                    现实、知识、判断、治理、行动和反馈如何形成业务因果闭环

                                                                                                    不规定某个固定 Agent Framework 或 State Schema

                                                                                                    从 KDC 视角看,Agent Harness 可以承担推理运行时、能力运行时和运行时可观测的一部分工程责任。它不是 KDC 的新核心对象,也不等于完整的能力控制平面。

                                                                                                    更准确的关系是:

                                                                                                    ReAct 让模型能够连续决定下一步,Harness 让这些步骤成为可靠的软件运行事实,KDC 让运行事实可以追溯到业务目标、知识依据、行动资格和现实结果。

                                                                                                    05

                                                                                                    公开实践不是一套统一理论,

                                                                                                    但正在回答同一组问题

                                                                                                    “Agent Harness”目前更像一组正在收敛的工程实践,而不是一套已有统一对象、边界和标准实现的理论。不同项目从不同故障出发,各自强调了生产级 Agent 的一部分责任。

                                                                                                    公开实践

                                                                                                    主要关注点

                                                                                                    与 KDC 的契合点

                                                                                                    仍然没有回答的问题

                                                                                                    长时间运行 Agent Harness

                                                                                                    跨上下文推进、进度记录、增量验证和任务交接

                                                                                                    让推理与行动具备可持续生命周期

                                                                                                    进展是否对应真实业务目标,经验何时成为 Memory 或 Knowledge

                                                                                                    Managed Agents

                                                                                                    Session、Harness、Sandbox 解耦,稳定接口和凭证隔离

                                                                                                    支持运行时对象化、能力治理和独立演进

                                                                                                    Tool 为什么具备业务资格,行动结果如何回到 Reality

                                                                                                    LangGraph Persistence / Interrupts

                                                                                                    线程状态、暂停恢复、跨线程 Store 和人工介入

                                                                                                    支持 Checkpoint、Pending Approval 和 Resume

                                                                                                    恢复后的业务授权是否仍然成立,长期 Store 内容是否可信

                                                                                                    Temporal Durable Execution

                                                                                                    Event History、确定性重放和外部 Activity

                                                                                                    强化命令、执行与运行事实的边界

                                                                                                    领域知识、推理依据和现实成功标准从哪里来

                                                                                                    12-Factor Agents

                                                                                                    显式拥有控制流,简化或统一执行状态

                                                                                                    降低多状态同步复杂度,使行为可测试

                                                                                                    高风险事实能否仅从消息或上下文可靠推导

                                                                                                    Agent Evals

                                                                                                    Task、Trial、Trajectory、Outcome 和多类 Grader

                                                                                                    把行动轨迹与现实结果分开验证

                                                                                                    评价结果如何反向治理 Knowledge、Skill 和 Capability

                                                                                                    这些实践共同暴露了状态连续性、外部副作用、长任务交接和系统评测问题,但对状态是否应该独立持久化、能否从线程上下文推导,并没有形成统一结论。Managed Agents 和 Durable Execution 更强调进程外的持久记录,12-Factor Agents 则更强调在可能时从统一线程上下文推导执行与业务状态。

                                                                                                    KDC 与它们的关系不是用新名称重新包装这些机制。KDC 提供的是更上层的业务因果约束:运行现场要连接哪一次判断,判断依据什么知识,Capability 为什么有资格被使用,授权如何形成,以及最终由什么现实反馈证明目标实现。本文后面的 Session、Resume、Progress 和 Evaluation 等契约,是把公开工程经验接入这条业务因果链的尝试。

                                                                                                    本文用 Contract 表示一组可以被实现、检查和测试的工程约束或交接模板,不把 Resume Contract、Progress Contract、Evaluation Contract 增加为 KDC 核心对象。

                                                                                                    06

                                                                                                    Harness 不是一个单体:

                                                                                                    Session、Harness 和执行环境应该解耦

                                                                                                    工程讨论中常把 Agent Harness 画成包围模型、工具和状态的一个大盒子。这个画法便于概括,却容易让团队把不同生命周期、不同信任等级的责任部署在同一个进程里。

                                                                                                    Anthropic 在 Managed Agents 的实践中提出了一个有价值的拆分:Session 保存可以持续追加的运行记录,Harness 负责循环、上下文组织和控制逻辑,Sandbox 承担代码、命令或工具的实际执行。三者通过稳定接口协作,而不必共享生命周期。Anthropic 的 Managed Agents 实践还进一步说明,Harness 本身可以尽量无状态;即使 Harness 进程崩溃,新的实例也可以从外部持久化的 Session 重建现场。

                                                                                                    把这个结构放入 KDC,可以得到一张更完整的运行拓扑:

                                                                                                    图:可替换 Harness、持久化 Session 与隔离执行环境

                                                                                                    其中每一部分承担不同责任:

                                                                                                    部分

                                                                                                    核心责任

                                                                                                    不应该隐含承担的责任

                                                                                                    Durable Session

                                                                                                    持久化 Event、Checkpoint、当前 State 和对象引用

                                                                                                    不替代领域现实,也不自动形成长期记忆

                                                                                                    Agent Harness

                                                                                                    选择上下文、驱动模型循环、处理暂停和恢复、提交控制命令

                                                                                                    不把自己的进程内变量当作权威状态

                                                                                                    能力控制平面

                                                                                                    校验主体、策略、参数、幂等键和授权范围

                                                                                                    不让“模型选择了 Tool”直接等于获准执行

                                                                                                    Sandbox / Tool Runtime

                                                                                                    在受限环境中执行代码、命令或外部调用

                                                                                                    不直接持有不受约束的长期凭证

                                                                                                    KDC 业务运行时

                                                                                                    连接目标、知识、判断、能力、策略、行动与反馈

                                                                                                    不规定某个固定模型循环或执行框架

                                                                                                    这项拆分带来三个直接收益。

                                                                                                    第一,恢复不再依赖原来的 Harness 实例。只要 Session 中的事件和状态足以重建现场,新的 Harness 或模型实例就可以接手;不同版本的运行器还必须满足 Session 接口、事件 Schema 和恢复语义兼容,或者先完成显式迁移。

                                                                                                    第二,“大脑”和“手”可以分别扩展。一个 Harness 可以驱动多个隔离执行环境;一个长时间运行的 Sandbox 也可以在模型调用结束后继续完成任务。模型上下文结束,不等于外部工作必须终止。

                                                                                                    第三,安全边界从 Prompt 约束变成结构约束。高权限凭证不进入模型上下文,也不直接暴露给不可信 Sandbox。能力代理根据主体、Capability、Policy Decision 和有效期发放最小权限或代为签名,并记录:

                                                                                                      executionEnvironmentId
                                                                                                      sandboxTrustLevel
                                                                                                      credentialScope
                                                                                                      credentialLeaseId
                                                                                                      networkPolicy
                                                                                                      dataAccessPolicy

                                                                                                      这并不要求所有系统立刻部署独立 Session 服务和 Sandbox 平台。它首先要求团队在接口和数据归属上把责任拆开:什么必须在进程外持久化,什么可以随 Harness 丢弃,什么只能由可信控制面执行,什么凭证绝不能进入模型可见范围。

                                                                                                      07

                                                                                                      最小运行对象:让现场拥有稳定归属

                                                                                                      KDC 的核心对象关注知识、记忆、推理、Skill 和 Capability。生产级 Agent 还需要一组支撑运行连续性的工程对象。

                                                                                                      运行对象

                                                                                                      主要职责

                                                                                                      最小身份或关系

                                                                                                      Run

                                                                                                      表示一次可独立开始、暂停、恢复和结束的运行

                                                                                                      runId、目标、状态、开始与结束时间

                                                                                                      Turn

                                                                                                      表示一次输入与响应边界

                                                                                                      turnId、runId、输入、输出引用

                                                                                                      Runtime Event

                                                                                                      记录运行状态变化

                                                                                                      eventId、类型、时间、Owner、关联对象

                                                                                                      Checkpoint

                                                                                                      保存可以恢复的执行位置与必要状态

                                                                                                      checkpointId、runId、版本、恢复令牌

                                                                                                      Pending Approval

                                                                                                      表示尚未完成的授权决策

                                                                                                      approvalId、风险、行动引用、状态

                                                                                                      Artifact Reference

                                                                                                      定位运行产生的文档、文件或结构化结果

                                                                                                      artifactId、Owner、内容引用、状态

                                                                                                      Sub-agent Reference

                                                                                                      表示父子运行关系

                                                                                                      subagentRunId、parentRunId、结果引用

                                                                                                      Control Command

                                                                                                      表示用户或系统发出的控制意图

                                                                                                      commandId、目标 Run、命令类型、发起者

                                                                                                      这些对象不必都成为独立数据库表,也不必升级成新的理论名词。它们首先是一组必须有明确 Owner、生命周期和持久化边界的工程责任。

                                                                                                      对象化的判断标准仍然是:如果某个状态影响恢复、审批、继续执行、跨端一致、审计或结果检查,它就不应该只存在于聊天文本、Prompt、组件变量或临时缓存中。

                                                                                                      08

                                                                                                      Session、Context、State、Memory 

                                                                                                      和 Knowledge 不是同一个对象

                                                                                                      “让 Agent 记住”在工程讨论里经常同时指五件不同的事:保存对话、恢复运行、给模型组装上下文、跨任务保留经验,以及提供经过治理的知识。它们都与历史有关,却不能共享同一个生命周期和可信等级。

                                                                                                      Google ADK 的 Session 文档将 Session、State 和 Memory 分开:Session 表示当前交互线程及其事件,State 是这个 Session 中的临时数据,Memory 则支持跨 Session 检索。LangGraph 的持久化设计也区分线程内 Checkpointer 与跨线程 Store。这些划分说明“恢复当前任务”和“让历史影响未来任务”需要不同的持久化语义。

                                                                                                      KDC 在此基础上还需要把 Context 和 Knowledge 单独列出:

                                                                                                      对象

                                                                                                      回答的问题

                                                                                                      典型内容

                                                                                                      生命周期与可信性

                                                                                                      Session Event Log

                                                                                                      这次交互和运行发生过什么

                                                                                                      输入、Runtime Event、命令、结果引用

                                                                                                      当前任务的持久化原始记录,可审计

                                                                                                      Runtime State

                                                                                                      当前执行到哪里

                                                                                                      活跃 Run、审批、Tool Call、Checkpoint

                                                                                                      从事件归约或快照恢复,是运行权威事实

                                                                                                      Context Projection

                                                                                                      这一次模型调用能看到什么

                                                                                                      最近消息、摘要、知识片段、工具结果

                                                                                                      临时、可重建、可以因窗口和策略变化

                                                                                                      View Projection

                                                                                                      当前界面应该展示什么

                                                                                                      进度、审批条、Artifact、错误状态

                                                                                                      从 State 派生,不是运行权威来源

                                                                                                      Memory Object

                                                                                                      哪段历史仍有资格影响未来

                                                                                                      用户偏好、经验证经验、长期任务关系

                                                                                                      跨 Session,但必须有来源、边界和生命周期

                                                                                                      Knowledge Object

                                                                                                      系统可以依据什么形成判断

                                                                                                      规则、概念、约束、经过验证的结论

                                                                                                      面向推理和行动,需要证据、版本和适用范围

                                                                                                      最关键的区别是:

                                                                                                      Session 是可恢复的历史来源,Context 是一次模型调用对历史的选择性投影。

                                                                                                      Context 可以被裁剪、压缩、重排或重新生成。它不应该是唯一保存审批、Tool 状态或外部请求身份的地方。一次上下文压缩如果遗漏“用户已经批准”,不应该让审批重新变成待处理;一次新的模型调用如果没有看到全部 Trace,也不应该改变已经发生的外部事实。

                                                                                                      为了使上下文选择可解释,生产系统可以为每次 Context Projection 记录:

                                                                                                        contextBuildId
                                                                                                        sourceEventRange
                                                                                                        includedObjectRefs
                                                                                                        omittedObjectRefs
                                                                                                        compactionPolicyVersion
                                                                                                        promptTemplateVersion
                                                                                                        tokenBudget

                                                                                                        这些字段不是要永久保存模型看到的每一个 Token,而是让团队能够回答:这次判断基于 Session 中的哪些事实,哪些内容被摘要或省略,使用的是哪一版上下文策略。

                                                                                                        同样,跨 Session 可检索也不等于已经形成 KDC Memory,更不等于形成 Knowledge。一个旧 Tool Result 可以进入搜索索引,但只有经过来源确认、适用范围判断、时效治理和必要验证后,它才有资格稳定影响未来判断或行动。

                                                                                                        09

                                                                                                        State、View 和 Control 必须分开

                                                                                                        一个常见失败方式,是让前端从消息文本中推断运行状态。

                                                                                                        例如,模型输出:

                                                                                                          需要用户确认后才能发起退款。

                                                                                                          UI 识别到“需要确认”,于是本地生成一个审批按钮。这个实现短期内可以工作,却没有回答:

                                                                                                          这条审批对应哪个 Run、Turn 和 Tool Call?

                                                                                                          刷新之后如何恢复?

                                                                                                          后端是否真的暂停在可恢复位置?

                                                                                                          用户点击同意时,决定应该发送给谁?

                                                                                                          策略已经变化或审批已经过期时怎么办?

                                                                                                          因此需要区分三类责任。

                                                                                                          State 是可恢复的运行事实

                                                                                                          State 由 Runtime 或明确的业务边界产生并持久化。它可以包含:

                                                                                                            activeRun
                                                                                                            currentTurn
                                                                                                            checkpoint
                                                                                                            pendingApprovals
                                                                                                            toolCalls
                                                                                                            artifactRefs
                                                                                                            subagentRefs
                                                                                                            runtimeStatus

                                                                                                            View 是从事实派生的展示

                                                                                                            View 可以包含:

                                                                                                              isBusy
                                                                                                              canStop
                                                                                                              approvalBanner
                                                                                                              toolBadges
                                                                                                              subagentProgress
                                                                                                              artifactPanel

                                                                                                              pendingApproval 存在,所以展示审批条。activeRun 处于运行状态,所以允许 Stop。View 可以随着交互设计变化,但不应该反向成为运行事实的权威来源。

                                                                                                              Control 是命令,不是直接改状态

                                                                                                              用户点击批准、拒绝、停止或恢复时,UI 发送 Control:

                                                                                                                resume(approvalId, decision)
                                                                                                                stop(runId)
                                                                                                                retry(toolCallId)
                                                                                                                reload(threadId)

                                                                                                                Control 表示“请求系统做什么”,不表示事情已经发生。用户点击 Stop 后,UI 不能直接把 Run 标记为已停止。Runtime 接收命令、处理取消边界,再产生新的 Event 和 State。

                                                                                                                可以把边界压缩成一句话:

                                                                                                                Runtime 写运行事实,View 读取运行事实,Control 提交命令,UI 不替 Runtime 补写运行事实。

                                                                                                                10

                                                                                                                语义责任必须分开,物理存储可以统一

                                                                                                                强调 State、View、Control、Session 和 Memory 的区别,不意味着第一版工程必须建立五套数据库。

                                                                                                                12-Factor Agents 的第五项原则主张在可能的情况下统一执行状态和业务状态,从线程上下文中推导当前进度。这个方向有明确价值:单一事件序列更容易序列化、分叉、回放和调试,也减少了多个状态库之间的同步问题。

                                                                                                                但“统一存储”不应退化为“从自然语言消息猜测权威状态”。尤其在退款、支付、权限变更等场景,下面这些状态必须有明确类型:

                                                                                                                  approval.required
                                                                                                                  approval.granted
                                                                                                                  capability.authorized
                                                                                                                  tool.call.dispatched
                                                                                                                  tool.call.accepted
                                                                                                                  tool.call.result_unknown
                                                                                                                  feedback.success_criteria_met

                                                                                                                  一种平衡方式是采用统一的追加事件日志,同时为不同语义建立强类型事件和投影:

                                                                                                                    {
                                                                                                                      “eventId“: “event-109“,
                                                                                                                      “eventType“: “approval.required“,
                                                                                                                      “runId“: “run-20260727001“,
                                                                                                                      “turnId“: “turn-003“,
                                                                                                                      “producer“: “policy-runtime“,
                                                                                                                      “reasoningObjectId“: “reasoning-021“,
                                                                                                                      “capabilityId“: “refund-order-v2“,
                                                                                                                      “correlationId“: “refund-intent-031“,
                                                                                                                      “causationId“: “event-108“,
                                                                                                                      “schemaVersion“: 2,
                                                                                                                      “occurredAt“: “2026-07-27T16:42:10+08:00“,
                                                                                                                      “payload“: {
                                                                                                                        “approvalId“: “approval-017“,
                                                                                                                        “risk“: “high“,
                                                                                                                        “expiresAt“: “2026-07-27T18:00:00+08:00“
                                                                                                                      }
                                                                                                                    }

                                                                                                                    同一份日志可以派生 Runtime State、用户 View、审计记录和评测轨迹,避免多处写入互相冲突。但每种投影仍然有自己的 Schema、Owner 和使用资格。审批状态必须由审批事件归约,不能因为 Agent 在文本中说“用户应该会同意”而改变;业务结果状态必须根据 Feedback Contract 检查反馈来源、证据和成功标准,不能因为 Tool 返回 200 就直接改写。

                                                                                                                    因此,更准确的工程原则是:

                                                                                                                    语义责任必须分开,物理存储可以统一;能从事件确定性归约的状态不必重复写,不能可靠推导的高风险事实必须显式记录。

                                                                                                                    11

                                                                                                                    一份最小 State Schema

                                                                                                                    下面的结构只是用于说明责任边界,不是 KDC 标准 Schema:

                                                                                                                      {
                                                                                                                        “session“: {
                                                                                                                          “sessionId“: “session-refund-001“,
                                                                                                                          “lastEventId“: “event-109“,
                                                                                                                          “stateSchemaVersion“: 2
                                                                                                                        },
                                                                                                                        “run“: {
                                                                                                                          “runId“: “run-20260727001“,
                                                                                                                          “status“: “waiting_for_approval“,
                                                                                                                          “goalRef“: “goal-refund-001“,
                                                                                                                          “currentTurnId“: “turn-003“,
                                                                                                                          “checkpointId“: “checkpoint-008“,
                                                                                                                          “contextBuildId“: “context-build-052“
                                                                                                                        },
                                                                                                                        “runtime“: {
                                                                                                                          “harnessVersion“: “harness-1.8.0“,
                                                                                                                          “modelVersion“: “model-release-202607“,
                                                                                                                          “executionEnvironmentId“: “sandbox-014“
                                                                                                                        },
                                                                                                                        “reasoning“: {
                                                                                                                          “reasoningObjectId“: “reasoning-021“,
                                                                                                                          “conclusion“: “eligible_but_requires_confirmation“,
                                                                                                                          “knowledgeRefs“: [“refund-policy-v4“],
                                                                                                                          “risk“: “high“
                                                                                                                        },
                                                                                                                        “pendingApprovals“: [
                                                                                                                          {
                                                                                                                            “approvalId“: “approval-017“,
                                                                                                                            “capabilityId“: “refund-order-v2“,
                                                                                                                            “toolCallId“: “tool-call-031“,
                                                                                                                            “policyDecisionId“: “policy-decision-044“,
                                                                                                                            “status“: “pending“,
                                                                                                                            “expiresAt“: “2026-07-27T18:00:00+08:00“
                                                                                                                          }
                                                                                                                        ],
                                                                                                                        “toolCalls“: [
                                                                                                                          {
                                                                                                                            “toolCallId“: “tool-call-031“,
                                                                                                                            “capabilityId“: “refund-order-v2“,
                                                                                                                            “status“: “proposed“,
                                                                                                                            “idempotencyKey“: “refund:order-001:intent-031“,
                                                                                                                            “externalRequestId“: null,
                                                                                                                            “dispatchedAt“: null,
                                                                                                                            “acceptedAt“: null,
                                                                                                                            “resultRef“: null,
                                                                                                                            “reconciliationStatus“: “not_required“,
                                                                                                                            “lastError“: null
                                                                                                                          }
                                                                                                                        ],
                                                                                                                        “artifactRefs“: [],
                                                                                                                        “subagentRefs“: []
                                                                                                                      }

                                                                                                                      这个结构同时保留了三类信息:

                                                                                                                      • 运行连续性所需的 runId、状态、Checkpoint 和审批;

                                                                                                                      • 业务因果追溯所需的推理对象、知识、能力和策略判定引用;

                                                                                                                      • 副作用控制所需的 Tool Call 状态、幂等键、外部请求和对账信息。

                                                                                                                      如果 State 只保存 pendingApproval = true,它仍然不够。系统还需要知道等待的是哪项行动、来自哪次判断、由哪个策略要求、什么时候失效,以及恢复后应该回到哪个执行位置。

                                                                                                                      同一个 Tool Call 发出后,如果支付渠道可能已经受理但响应丢失,State 不应回退成“尚未调用”,而应保留同一个 toolCallId 和 idempotencyKey:

                                                                                                                        {
                                                                                                                          “run“: {
                                                                                                                            “runId“: “run-20260727001“,
                                                                                                                            “status“: “awaiting_reconciliation“,
                                                                                                                            “checkpointId“: “checkpoint-009“
                                                                                                                          },
                                                                                                                          “toolCalls“: [
                                                                                                                            {
                                                                                                                              “toolCallId“: “tool-call-031“,
                                                                                                                              “capabilityId“: “refund-order-v2“,
                                                                                                                              “status“: “result_unknown“,
                                                                                                                              “idempotencyKey“: “refund:order-001:intent-031“,
                                                                                                                              “externalRequestId“: “payment-request-8841“,
                                                                                                                              “dispatchedAt“: “2026-07-27T16:48:12+08:00“,
                                                                                                                              “acceptedAt“: null,
                                                                                                                              “resultRef“: null,
                                                                                                                              “reconciliationStatus“: “pending“,
                                                                                                                              “lastError“: “response_timeout“
                                                                                                                            }
                                                                                                                          ],
                                                                                                                          “outcomeVerification“: {
                                                                                                                            “status“: “pending“,
                                                                                                                            “feedbackRefs“: []
                                                                                                                          }
                                                                                                                        }

                                                                                                                        这里的 result_unknown 不是失败的另一种写法,而是一个禁止盲目重试的恢复边界。Runtime 必须先使用外部请求身份查询或对账,再决定完成、补偿还是转人工。

                                                                                                                        12

                                                                                                                        从判断到执行,需要经历一次可恢复的状态变化

                                                                                                                        回到退款案例,一条更完整的运行路径可以这样设计。

                                                                                                                        1. 形成业务判断

                                                                                                                        推理运行时识别用户目标,引用退款政策和订单事实,形成推理对象:订单符合退款条件,但需要用户最终确认。

                                                                                                                        2. 提出能力调用建议

                                                                                                                        Agent 选择退款 Skill,并提出调用 refund-order-v2 的建议。此时只是行动建议,不是执行授权。

                                                                                                                        3. 控制平面要求确认

                                                                                                                        策略根据能力风险、用户目标和当前证据返回 requires_confirmation。Runtime 产生 approval.required 事件,写入 Pending Approval,并创建 Checkpoint。

                                                                                                                        4. View 展示审批

                                                                                                                        UI 从 Pending Approval 派生审批条。页面刷新后,审批条仍然可以从持久化 State 恢复,不需要重新解析聊天文本。

                                                                                                                        5. 用户提交 Control

                                                                                                                        用户确认后,前端发送 resume(approvalId, allow)。Runtime 校验审批是否仍然有效、主体是否一致、能力版本和前置条件是否发生变化。

                                                                                                                        6. 能力运行时执行

                                                                                                                        授权通过后,能力运行时调用底层 Tool。执行请求携带稳定的幂等键,并记录外部请求身份。

                                                                                                                        7. Runtime 记录执行结果

                                                                                                                        Tool 返回后,Runtime 产生 tool.call.completed 或 tool.call.result_unknown,更新 State 和 Checkpoint。结果未知时,系统不能简单回到“未执行”。

                                                                                                                        8. 现实反馈关闭业务闭环

                                                                                                                        支付渠道状态、对账结果或用户确认随后进入 Feedback Contract。只有系统取得符合成功标准的有效证据,才可以表达“退款已经到账”,并保留证据来源和验证时间。

                                                                                                                        这条路径将“业务上为什么可以做”和“软件上已经做到哪里”连接了起来。

                                                                                                                        13

                                                                                                                        Checkpoint 不等于 Durable Execution

                                                                                                                        持久化 Checkpoint 只能说明系统知道从哪里恢复,不能自动保证外部行动只发生一次,也不能保证恢复后的代码路径与中断前完全相同。

                                                                                                                        LangGraph 的 Interrupt 机制会在暂停时持久化状态,并通过同一个 Thread 恢复;但恢复时所在 Node 会从头重新执行,因此 Interrupt 之前的副作用必须能够安全重放。Temporal 的 Event History则用持久化事件历史记录 Workflow 生命周期,通过重放历史重建逻辑状态,并把外部副作用交给 Activity 等受控边界。

                                                                                                                        两类实践共同说明,Checkpoint 要与至少三个概念配合:

                                                                                                                        概念

                                                                                                                        含义

                                                                                                                        退款案例

                                                                                                                        Command

                                                                                                                        系统希望发生什么,尚不证明已经发生

                                                                                                                        请求支付渠道退款

                                                                                                                        Activity / Tool Call

                                                                                                                        执行外部副作用的受控边界

                                                                                                                        调用退款接口并等待结果

                                                                                                                        Event

                                                                                                                        系统已经观察并记录了什么

                                                                                                                        渠道已受理、结果未知、已取得到账确认依据

                                                                                                                        模型生成“执行退款”只产生行动建议。策略通过后,Runtime 才创建 Capability Command;能力运行时接收命令并调度 Tool Call;外部结果被观察和验证后,系统再追加 Event。把命令、执行和事实分开,才能在恢复时知道应该重放逻辑、查询外部状态,还是禁止再次执行。

                                                                                                                        考虑下面的时间窗口:

                                                                                                                          退款请求已经被支付渠道受理
                                                                                                                            -> 后端尚未写入 tool.call.completed
                                                                                                                            -> 进程重启
                                                                                                                            -> 本地状态仍显示 running

                                                                                                                          恢复后直接重试,可能再次发起退款。生产系统至少要考虑:

                                                                                                                          • 为高影响调用生成稳定幂等键;

                                                                                                                          • 区分“命令已发送”“外部系统已受理”“业务结果已确认”;

                                                                                                                          • 在结果未知时先查询或对账,而不是盲目重试;

                                                                                                                          • 使用事务消息、Outbox 或等价机制减少本地状态与事件发布之间的空窗;

                                                                                                                          • 记录能力的重试、补偿和人工接管策略;

                                                                                                                          • 让同一个 Approval 不能被重复消费;

                                                                                                                          • 恢复时重新验证已经变化的权限、政策和业务前置条件。

                                                                                                                          这些规则不应该散落在某个 Agent Prompt 中,而应该形成一份可以由 Runtime 执行和测试的 Resume Contract:

                                                                                                                          契约项

                                                                                                                          需要明确的问题

                                                                                                                          Replay Boundary

                                                                                                                          从哪个 Event、Node 或 Activity 边界恢复,哪些逻辑会重新运行

                                                                                                                          Side-effect Boundary

                                                                                                                          暂停点之前是否已经产生外部副作用,哪些步骤只允许执行一次

                                                                                                                          Idempotency

                                                                                                                          幂等键由什么稳定身份生成,外部系统是否真正支持去重

                                                                                                                          Reconciliation

                                                                                                                          本地与外部状态不一致或结果未知时,查询哪个权威来源

                                                                                                                          Authorization Revalidation

                                                                                                                          恢复时是否重查主体、权限、政策、风险和审批有效期

                                                                                                                          Version Compatibility

                                                                                                                          Checkpoint 对应的 Harness、状态 Schema、Capability 和模型版本是否仍可恢复

                                                                                                                          Compensation

                                                                                                                          不可继续时采用撤销、补偿、转人工还是保持待处理

                                                                                                                          Completion Evidence

                                                                                                                          哪种 Event 只说明技术执行完成,哪种 Feedback 才说明现实目标完成

                                                                                                                          对于高影响行动,执行状态与结果验证状态应该分别管理:

                                                                                                                            Action Execution Status


                                                                                                                            proposed
                                                                                                                              -> authorized
                                                                                                                              -> dispatching
                                                                                                                              -> accepted
                                                                                                                              -> completed / failed


                                                                                                                            dispatching / accepted
                                                                                                                              -> result_unknown
                                                                                                                              -> reconciling
                                                                                                                              -> completed / failed / manual_handoff


                                                                                                                            Outcome Verification Status


                                                                                                                            not_observed
                                                                                                                              -> pending
                                                                                                                              -> confirmed_success / confirmed_failure / inconclusive

                                                                                                                            执行状态回答 Capability Command 和 Tool Call 已经走到哪里;结果验证状态回答系统掌握的反馈证据是否满足业务成功标准。二者通过 toolCallId、feedbackId 和目标引用连接,但不共享一个终态。Run 可以在外部工作已经可靠移交、结果仍为 pending 时结束,后续 Feedback 再更新业务结果状态。

                                                                                                                            result_unknown 不是普通失败。它表示系统缺少足够证据判断外部行动是否已经发生,默认重试可能扩大风险。此时应该进入查询、对账或人工接管,而不是回退到 authorized 再次发起。

                                                                                                                            同样,Stop 也不是一个瞬间完成的布尔值。系统可能已经停止模型生成,却无法取消外部 Tool。它需要区分:

                                                                                                                              stop.requested
                                                                                                                              model.cancelled
                                                                                                                              tool.cancellation_requested
                                                                                                                              tool.cancelled
                                                                                                                              external_action_irreversible
                                                                                                                              run.stopped

                                                                                                                              可恢复不是“重新加载最后一条消息”,而是知道哪些事实已经发生、哪些行动仍在进行、哪些结果尚不确定,以及下一步怎样继续才不会扩大现实风险。

                                                                                                                              14

                                                                                                                              Run 结束以后,哪些事实可以离开 Session

                                                                                                                              前文已经区分了 Session、State、Memory 和 Knowledge。更具体的工程问题是:Run 结束以后,哪些信息应该清理,哪些只为审计保留,哪些可以影响未来?

                                                                                                                              Checkpoint、Pending Approval 和 Active Run 用于恢复同一次任务。它们回答:

                                                                                                                              这次运行执行到哪里?

                                                                                                                              记忆对象用于让历史在受治理条件下影响未来任务。它回答:

                                                                                                                              这段历史是否仍然可以影响未来判断和行动?

                                                                                                                              一次退款 Run 结束后,Checkpoint 可以归档或清理,Pending Approval 必须关闭,短期凭证应该撤销。Runtime Event 可以根据审计、隐私和合规要求保留,但“被保留”不表示“可以被未来 Agent 检索并使用”。

                                                                                                                              此次运行中的内容进入未来,可以经过一条显式晋升路径:

                                                                                                                                Runtime Event / Feedback
                                                                                                                                  -> Candidate Experience
                                                                                                                                  -> 来源与现实结果验证
                                                                                                                                  -> 适用范围、主体和时效判断
                                                                                                                                  -> Memory Object
                                                                                                                                  -> 多次验证与抽象
                                                                                                                                  -> Knowledge Candidate

                                                                                                                                例如,“这一次退款接口耗时 18 秒”通常只是运行记录;“该用户明确要求退款进度只通过短信通知”可能成为有期限的用户记忆;“某渠道在返回受理后仍需通过对账事件确认到账”在多次验证、明确边界和治理后,才可能形成可供未来推理使用的知识或规则。

                                                                                                                                用七个问题检查 Memory 与 Knowledge 是否真正连通

                                                                                                                                团队可以用下面七个问题评估当前的记忆与知识工程能力:

                                                                                                                                • 这条记忆来自什么经历?

                                                                                                                                • 它为什么仍能影响当前任务?

                                                                                                                                • 哪些记忆支持了这项候选知识?

                                                                                                                                • 这项知识经过了什么验证?

                                                                                                                                • 哪些反馈强化或推翻了它?

                                                                                                                                • 它目前能支持哪些判断和行动?

                                                                                                                                • 现实变化后,系统会降级、替换还是停止使用它?

                                                                                                                                这七个问题依次检查来源追溯、记忆使用资格、经验到知识的证据链、知识验证、反馈修正、行动边界和生命周期治理。如果系统只能回答“内容存在哪里、如何被召回”,却不能回答这些问题,那么它仍然主要是一个存储与检索系统,还没有形成 Memory 与 Knowledge 相互连接的运行能力。

                                                                                                                                因此:

                                                                                                                                  持久化 State ≠ 形成 Memory
                                                                                                                                  能够恢复 Run ≠ 历史可以影响未来
                                                                                                                                  保存所有 Event ≠ 获得组织经验

                                                                                                                                  把两者混在一起,会让临时运行状态长期污染用户画像,也会让真正需要复用的经验淹没在事件日志中。反过来,如果所有 Session 都在任务结束后整体删除,团队也无法从真实结果中形成受验证的经验。关键不是“全部保存”或“全部遗忘”,而是为不同对象设置明确的使用资格、保留期限、删除机制和晋升路径。

                                                                                                                                  15

                                                                                                                                  日志和 Trace 仍然不等于运行状态

                                                                                                                                  日志、Trace 和 Event 都很重要,但它们的职责不同。

                                                                                                                                  Trace 适合还原一次请求经过哪些组件以及耗时和错误。Event 表达某项状态变化已经发生。State 表达系统当前可恢复的事实。Checkpoint 保存继续执行所需的位置和上下文。

                                                                                                                                  系统可以从完整 Event Log 重建 State,也可以持久化 State Snapshot 并保留增量事件。具体方案取决于规模、恢复时延、审计要求和基础设施能力。

                                                                                                                                  无论采用哪种方式,运行信号都应该携带稳定的业务因果引用:

                                                                                                                                    runId
                                                                                                                                    reasoningObjectId
                                                                                                                                    capabilityId
                                                                                                                                    policyDecisionId
                                                                                                                                    toolCallId
                                                                                                                                    feedbackId

                                                                                                                                    否则,团队只能知道某个 Tool 在某个时间失败,却不知道它服务什么目标、基于什么知识、为什么被允许,也不知道错误应该回到推理、治理、能力实现还是外部系统。

                                                                                                                                    16

                                                                                                                                    长时间任务还需要 Progress Contract

                                                                                                                                    有些 Agent 任务会跨越多个上下文窗口、多个模型调用,甚至多个工作日。此时,持久化完整 Session 仍然不够。下一次接手的 Agent 虽然可以读取全部历史,却不一定能迅速判断当前基线是否可用、哪些工作已经验证、哪些只是尝试,以及接下来最安全的一步是什么。

                                                                                                                                    Anthropic 关于长时间运行 Agent Harness 的研究发现,仅依赖上下文压缩很容易让后续 Agent 高估进展、重复修改或破坏已经工作的部分。其工程方案包括初始化 Agent、结构化功能清单、进度文件、版本历史、环境启动脚本,以及每个会话只推进一个可验证增量。

                                                                                                                                    把这类经验推广到业务 Agent,可以定义一份 Progress Contract。它不是自由文本工作日志,而是当前工作现场的结构化交接面:

                                                                                                                                    字段

                                                                                                                                    说明

                                                                                                                                    Goal

                                                                                                                                    本次长任务要改变什么现实状态

                                                                                                                                    Completion Criteria

                                                                                                                                    什么可验证反馈代表完成,而不是仅仅“Agent 已回复”

                                                                                                                                    Work Items

                                                                                                                                    已计划事项及 not_started / in_progress / verified / blocked 状态

                                                                                                                                    Verified Baseline

                                                                                                                                    最近一次被测试或人工确认的稳定状态

                                                                                                                                    Current Change

                                                                                                                                    本次 Session 正在改变什么,尚未验证什么

                                                                                                                                    Evidence

                                                                                                                                    测试、查询结果、Artifact、审批和现实反馈引用

                                                                                                                                    Environment Bootstrap

                                                                                                                                    如何恢复必要环境、连接和最小上下文

                                                                                                                                    Risks and Blockers

                                                                                                                                    尚未关闭的风险、外部依赖和禁止执行项

                                                                                                                                    Next Safe Action

                                                                                                                                    下一次接手后可以执行的最小步骤

                                                                                                                                    Ownership

                                                                                                                                    当前 Owner、接管规则和超时策略

                                                                                                                                    例如,一个“协助完成供应商准入”的 Agent 可能跨越材料收集、合规检查、人工补件、审批和系统开户。Progress Contract 不应该只写“资料基本完成”,而应明确:营业执照已经验证,税务信息仍待人工确认,合规审批尚未发生,开户 Capability 因此仍不可用;下一步只能请求补件,不能重复创建供应商。

                                                                                                                                    Progress Contract 与前面的几个对象仍然不同:

                                                                                                                                      Checkpoint 说明从哪里恢复执行
                                                                                                                                      Runtime State 说明当前机器状态
                                                                                                                                      Progress Contract 说明跨 Session 如何可靠接手工作
                                                                                                                                      Memory 说明哪些历史有资格影响未来
                                                                                                                                      Knowledge 说明未来判断可以依据什么

                                                                                                                                      一次长任务会话开始时,Harness 应先恢复环境、读取 Progress Contract 并验证基线;结束前则应关闭不完整副作用、更新工作项、附上证据,并留下一个可执行的下一步。这样,交接不再依赖下一次模型从几十万 Token 的历史中自行揣测现场。

                                                                                                                                      17

                                                                                                                                      Agent Harness 本身

                                                                                                                                      也需要 Evaluation Contract

                                                                                                                                      Agent 能完成演示,不代表 Harness 能承担生产责任。模型、Prompt、上下文选择、恢复逻辑、Capability 描述和策略代理共同决定系统行为,因此不能只单独评价模型。

                                                                                                                                      Anthropic 的 Agent 评测方法区分了 Agent Harness 与 Evaluation Harness,并进一步区分 Transcript 或 Trajectory 和 Outcome:前者是 Agent 采取过的路径,后者是任务结束后环境真正处于什么状态。这个区分与 KDC 的核心问题高度一致:一条漂亮的推理轨迹不能代替现实反馈,一句“退款成功”也不能代替到账事实。

                                                                                                                                      对 KDC 工程实现而言,至少需要四类 Grader:

                                                                                                                                      Grader

                                                                                                                                      评价对象

                                                                                                                                      典型问题

                                                                                                                                      Trajectory Grader

                                                                                                                                      推理与行动路径

                                                                                                                                      是否引用了适用知识,是否使用合格 Capability,是否绕过审批

                                                                                                                                      Runtime / Recovery Grader

                                                                                                                                      软件运行事实

                                                                                                                                      刷新、重启、超时、重复回调后 State 是否一致,是否重复产生副作用

                                                                                                                                      Outcome Grader

                                                                                                                                      业务结果及其证据

                                                                                                                                      到账、权限生效等证据是否满足成功标准,目标是否只完成了一部分

                                                                                                                                      Governance Grader

                                                                                                                                      风险与责任边界

                                                                                                                                      主体、政策、权限、证据、人工确认和审计记录是否满足要求

                                                                                                                                      这些 Grader 可以组合确定性代码检查、模型判定和人工复核。高风险不变量应尽量使用代码或权威数据源验证,例如“同一审批只能消费一次”“未经授权不得调用退款能力”;表达质量、解释完整性等开放问题可以使用模型或人工评价。

                                                                                                                                      一份 Evaluation Contract 可以包含:

                                                                                                                                        taskDefinition
                                                                                                                                        initialEvidenceSnapshot
                                                                                                                                        successFeedbackCriteria
                                                                                                                                        forbiddenOutcomes
                                                                                                                                        requiredCapabilities
                                                                                                                                        forbiddenCapabilities
                                                                                                                                        interruptionInjections
                                                                                                                                        trajectoryGraders
                                                                                                                                        recoveryGraders
                                                                                                                                        outcomeGraders
                                                                                                                                        governanceGraders
                                                                                                                                        trialCount
                                                                                                                                        versionMatrix
                                                                                                                                        releaseThresholds

                                                                                                                                        initialEvidenceSnapshot 保存的是系统在 Trial 开始时获得的现实表示、来源和版本,而不是对 Reality 的直接复制。这样,Evaluation Contract 既能固定评测初始条件,也不会把数据快照误写成现实本身。

                                                                                                                                        其中 interruptionInjections 应主动覆盖最难在正常演示中出现的问题:在审批前刷新、在外部系统受理后断网、在 Tool 返回前杀死 Harness、在 Resume 前升级策略、重复投递回调、让子 Agent 延迟返回。

                                                                                                                                        Agent 运行存在非确定性,同一个任务需要多次 Trial 才能看出成功率和风险分布。能力探索阶段可以使用较难任务寻找系统上限;持续发布阶段则需要固定回归集,阻止模型、Harness 或 Capability 升级重新引入已经修复的问题。

                                                                                                                                        评测结果也不宜过早压缩成一个综合分数。退款重复执行一次的风险,不能被十次措辞更自然的回答抵消。KDC 更关心每项关键责任是否达到门槛,以及失败究竟发生在知识、推理、治理、运行恢复、能力执行还是现实反馈。

                                                                                                                                        18

                                                                                                                                        Harness 的假设也有生命周期

                                                                                                                                        Harness 并不是一层写完就不再变化的基础设施。模型能力提升后,过去为了弥补模型缺陷而加入的固定流程可能限制新模型;模型、上下文算法或 Tool 行为改变后,旧 Checkpoint 也未必能由新版本无损恢复。

                                                                                                                                        因此,运行事件和评测结果至少应该能够关联:

                                                                                                                                          modelVersion
                                                                                                                                          harnessVersion
                                                                                                                                          promptTemplateVersion
                                                                                                                                          contextPolicyVersion
                                                                                                                                          stateSchemaVersion
                                                                                                                                          skillVersion
                                                                                                                                          capabilityVersion
                                                                                                                                          policyVersion
                                                                                                                                          knowledgeVersion
                                                                                                                                          evaluationSuiteVersion

                                                                                                                                          版本记录不是为了让每次调用携带一长串不可读元数据,而是为四类工程决策提供依据:

                                                                                                                                          • 旧 Checkpoint 是否需要迁移、沿用旧 Runtime 恢复或直接转人工;

                                                                                                                                          • 新模型能否移除已经过时的编排补丁,而不破坏业务约束;

                                                                                                                                          • Capability 或 Policy 升级后,哪些挂起审批必须重新判定;

                                                                                                                                          • 线上回归究竟由模型、Harness、上下文、知识还是外部依赖变化引起。

                                                                                                                                          比较稳妥的升级方式是保持 Session、Harness 和 Sandbox 之间的接口稳定,对版本组合运行 Evaluation Contract,先小流量验证,再逐步放量;同时为高风险 Capability 保留回滚、暂停和人工接管能力。系统要治理的不只是 Agent 的行动,也包括 Harness 自己关于模型和运行环境的假设。

                                                                                                                                          19

                                                                                                                                          不要先建设一个庞大的 Harness 平台

                                                                                                                                          和 KDC 的其他运行时一样,Agent Harness 首先是一组工程责任,不必从独立平台开始。

                                                                                                                                          第一版可以只选择一条高影响流程,补齐:

                                                                                                                                          • 稳定的 Run、Turn 和 Tool Call 身份;

                                                                                                                                          • 进程外持久化的 Session Event 与可恢复 State;

                                                                                                                                          • 持久化 Pending Approval;

                                                                                                                                          • 一个可以恢复的 Checkpoint;

                                                                                                                                          • State、View 和 Control 的边界;

                                                                                                                                          • 一份明确重放、幂等、对账和版本兼容规则的 Resume Contract;

                                                                                                                                          • 高风险调用的幂等与结果核验;

                                                                                                                                          • 模型可见上下文与执行凭证、Sandbox 的隔离;

                                                                                                                                          • 推理、能力、策略和反馈的关联键;

                                                                                                                                          • 刷新、重启、重复提交和结果未知场景的 Evaluation Contract。

                                                                                                                                          当多个 Agent 产品开始重复处理审批、恢复、Artifact、子 Agent 和运行控制时,再把这些机制抽象为共享 Harness 或 Agent Runtime。

                                                                                                                                          抽象顺序仍然应该是:

                                                                                                                                            真实故障与业务风险
                                                                                                                                              -> 明确运行事实
                                                                                                                                              -> 建立最小状态协议
                                                                                                                                              -> 验证恢复和治理边界
                                                                                                                                              -> 再形成共享平台能力

                                                                                                                                            20

                                                                                                                                            实践:对一条 Agent 流程做恢复演练

                                                                                                                                            选择一个会产生现实影响的任务,例如退款、发消息、创建订单、修改权限或提交审批。不要只测试正常路径,至少演练下面这些故障。

                                                                                                                                            故障场景

                                                                                                                                            系统应该证明什么

                                                                                                                                            等待审批时刷新页面

                                                                                                                                            同一个 Approval 可以恢复,并仍指向原判断和能力

                                                                                                                                            等待审批时后端重启

                                                                                                                                            Runtime 能从 Checkpoint 恢复,且不会绕过审批

                                                                                                                                            用户重复点击确认

                                                                                                                                            Approval 只被消费一次,高风险调用不会重复执行

                                                                                                                                            Tool 已执行但响应丢失

                                                                                                                                            状态进入结果未知并主动核验,不直接盲目重试

                                                                                                                                            Tool 执行中用户点击 Stop

                                                                                                                                            系统能区分模型停止、Tool 取消和不可逆外部行动

                                                                                                                                            Artifact 生成后页面刷新

                                                                                                                                            Artifact 仍可通过稳定引用定位到原 Run 和 Tool Call

                                                                                                                                            子 Agent 在主进程重启后返回

                                                                                                                                            结果仍能关联到父 Run、Turn 和目标

                                                                                                                                            政策或权限在等待期间发生变化

                                                                                                                                            Resume 时重新校验,不沿用已经失效的授权前提

                                                                                                                                            接口返回成功但现实结果未发生

                                                                                                                                            Run 可以结束,业务目标仍保持待反馈或异常状态

                                                                                                                                            Context 压缩遗漏一段历史

                                                                                                                                            权威 State 不改变,新 Context 仍能引用必要的对象与事件

                                                                                                                                            Harness 进程永久丢失

                                                                                                                                            新实例能从 Durable Session 恢复,不依赖旧进程内变量

                                                                                                                                            Sandbox 被不可信代码控制

                                                                                                                                            高权限长期凭证仍不可见,调用范围受能力代理限制

                                                                                                                                            使用新版本恢复旧 Checkpoint

                                                                                                                                            系统执行兼容性检查、迁移或转人工,不静默按新逻辑重放

                                                                                                                                            长任务跨 Session 交接

                                                                                                                                            接手方能验证基线、理解未完成项并执行明确的下一步

                                                                                                                                            更换模型或 Harness 版本

                                                                                                                                            固定回归集能发现轨迹、恢复、治理或现实结果退化

                                                                                                                                            演练完成后,应留下五份最小产物:

                                                                                                                                            • 一份 State 与 Event Schema,说明哪些状态必须持久化、由谁产生以及如何归约;

                                                                                                                                            • 一份 Resume Contract,说明每种中断后的重放边界、幂等、对账、补偿和版本规则;

                                                                                                                                            • 一份安全边界说明,标出模型、Harness、能力代理、Sandbox、数据与凭证之间的信任关系;

                                                                                                                                            • 一份 Progress Contract,说明长任务怎样验证基线、交接现场和确定下一步;

                                                                                                                                            • 一份 Evaluation Contract,用故障注入和多类 Grader 验证轨迹、恢复、治理和现实结果。

                                                                                                                                            如果团队仍需要读取聊天文本、查看多个日志并询问当时值班人员,才能判断一次行动是否已获授权、是否已经执行以及能否重试,那么运行事实还没有成为稳定的生产能力。

                                                                                                                                            21

                                                                                                                                            从“模型做过什么”走向“系统可以相信什么”

                                                                                                                                            生产级 Agent 的难点不只是让模型形成更好的计划,也不只是接入更多 Tool。

                                                                                                                                            系统需要同时回答三组问题。

                                                                                                                                            第一组是业务因果问题:

                                                                                                                                              为什么这样判断?
                                                                                                                                              依据什么知识?
                                                                                                                                              谁允许采取行动?
                                                                                                                                              行动是否实现现实目标?

                                                                                                                                              第二组是运行连续性问题:

                                                                                                                                                当前执行到哪里?
                                                                                                                                                什么状态可以恢复?
                                                                                                                                                什么命令仍然有效?
                                                                                                                                                哪些外部影响已经发生?

                                                                                                                                                第三组是验证与演进问题:

                                                                                                                                                  中断之后能否安全继续?
                                                                                                                                                  下一次 Session 能否可靠接手?
                                                                                                                                                  最终环境是否真的达到目标状态?
                                                                                                                                                  模型、Harness 或能力升级是否造成回归?

                                                                                                                                                  Agent Harness 主要补齐运行连续性,Evaluation Harness 检查运行路径和现实结果,KDC 尝试把三组问题连接到同一条责任链上。

                                                                                                                                                  当业务因果链和运行事实链拥有稳定身份、明确 Owner、恢复契约和可验证边界时,Agent 才不只是“完成了一次模型循环”。它开始成为一个能够在中断、恢复、交接、审批、失败、升级和现实反馈中继续承担工程责任的软件系统。

                                                                                                                                                  22

                                                                                                                                                  理论边界与开放问题

                                                                                                                                                  本文把 Agent Harness 视为一种外部工程参考,而不是 KDC 的新核心术语。Run、Turn、Checkpoint、Pending Approval、Artifact Reference 和 Control Command 是候选运行时对象,其最小结构、状态机、持久化方式和跨框架协议仍需要通过具体实现验证。Session、Harness、Sandbox 的三层拓扑,以及 Resume Contract、Progress Contract、Evaluation Contract,是结合现有公开实践提出的 Derived 工程模型,不表示行业已经形成统一标准。

                                                                                                                                                  业务因果链与运行事实链的双链结构同样属于当前阶段的 Derived 工程模型。它与事件溯源、Durable Execution、工作流引擎、Saga、状态机、Agent Framework 和可观测系统之间的精确边界仍需要继续比较。尤其是统一事件存储能否在具体业务中同时满足性能、隐私、删除、审计和跨地域要求,旧 Checkpoint 如何跨模型与 Harness 版本恢复,以及哪些上下文投影元数据值得长期保留,都仍是开放问题。

                                                                                                                                                  本文也不主张所有低风险问答都采用完整的持久化、Sandbox 和审计结构。行动影响越大、执行时间越长、人工等待越多、外部副作用越难撤销,运行事实显式化和契约化的必要性才越强。具体实现应根据风险分层,而不是把完整拓扑机械复制到每一次模型调用。

                                                                                                                                                  参考

                                                                                                                                                  版权声明: 本文采用 CC BY-NC-ND 4.0(署名-非商业性使用-禁止演绎) 许可协议。转载请注明出处。

                                                                                                                                                  END

                                                                                                                                                  跳转微信打开

                                                                                                                                                  从知识沉淀到编程范式:AI Coding 项目冷启动落地实践

                                                                                                                                                  2026年10月28日 20:00

                                                                                                                                                  原创 互联技术保障团队 2026-10-28 20:00 广东

                                                                                                                                                  以 SmartFlow 互动策略引擎为实践,交付时间相比原计划减少 2/3。

                                                                                                                                                  作者:vivo 互联技术保障团队- Chen Ningning

                                                                                                                                                  目录

                                                                                                                                                  01. 背景

                                                                                                                                                  02. 现实问题

                                                                                                                                                  03. 理论探索

                                                                                                                                                  04. 方法设计

                                                                                                                                                  05. 实践脉络:从知识沉淀到范式开发

                                                                                                                                                  06. 效果评估与经验教训

                                                                                                                                                  07. 结论展望

                                                                                                                                                  AI Coding(AI 编码)的落地瓶颈已从模型逻辑能力转向上下文管理与开发意图的表达。

                                                                                                                                                  本文基于SmartFlow互动策略引擎从需求到前后端协同交付的实践,提出一套适用于存量业务系统的 AI Coding 项目冷启动方法,其核心是两条循环往复的实践主线,一是历史工程知识沉淀,从存量代码与历史需求中提炼项目级 Skill,将隐性架构知识显式化、可复用化;二是新需求按 AI 编程范式开发,在知识就绪的基础上,以需求规格化 → 规格评审 → 受控实现 → 验证联调 → 知识回写的闭环推进每一次需求交付。实践表明,该方法能显著降低跨服务、跨机房、跨前后端协同开发的认知成本,让 AI 从一次性对话工具升级为持续积累的团队资产。本文给出了方法设计、完整实践脉络与可复用的经验教训。

                                                                                                                                                  1分钟看图掌握核心要点👇

                                                                                                                                                  01

                                                                                                                                                  背景

                                                                                                                                                  本文将结合基于 WhatsApp 构建 SmartFlow 的实践,介绍项目冷启动的方法和经验。SmartFlow 主要是为 WhatsApp 编排一套互动策略流程,用户订阅某个 WhatsApp 账号后,如果向该账号发送一条消息或点击某个消息按钮,SmartFlow 就会根据上行消息匹配策略后做消息智能投放。项目启动时,项目上下文经验注入少,同时又要快速交付能力,过程中一边实战一边进行方法论梳理,依靠这套方法论,从项目启动到最终交付,相比原计划交付时间减少 2/3。前面简单介绍一下背景,本文更多想通过这次项目冷启动实战做更深入的思考总结,使这套方法论在 AI Coding 实践中给大家提供借鉴。

                                                                                                                                                  02

                                                                                                                                                  现实问题

                                                                                                                                                  在最开始进行AI Coding实践时想法很简单,只要模型足够强,写代码就不愁。但是真正到业务需求上试完之后,发现完全不是这么回事。这两年生成式 AI(GenAI)确实把编程往前推了一大截,各种新工具层出不穷,可拿到真实业务需求上一试就发现,模型参数堆得再大,业务逻辑里的幻觉和失控并没有减少[1]。经过不断摸索才慢慢意识到,限制 AI Coding 的不是推理能力,而是两件更基础的事,一是它能看到的信息不够干净,二是我们想让它做什么说得不够清楚[1][3]。这种感受在开发存量系统时尤其明显。大型代码库经过多年演化,真正重要的决策很少写在代码里,大多散在需求文档、群聊、会议记录和个人记忆中。AI 拿到任务后,既看不见这些隐性背景,又得从一长串对话历史里自己判断任务边界,结果常常是,代码写出来能编译、能跑,架构却是错的,业务逻辑也偏离了本来意图。落到具体引入AI Coding的环节,我们面对的问题有[1]:

                                                                                                                                                  • 背景缺失:关键决策不在代码里,而在文档、群消息、会议纪要甚至开发者的记忆里。AI 缺了这些背景,只能照语法写个样子对的方案,架构初衷对不上;

                                                                                                                                                  • 需求模糊:需求散落在 PRD 和聊天记录里,编码时找不到一份完整说明,AI 只能靠上下文自行补充,补着补着就可能就偏离需求原本的面貌;

                                                                                                                                                  • 经验留不住:会话窗口一关,AI 的能力就归零,每次都是从零开始,个人摸索出来的经验转化不成项目资产。

                                                                                                                                                  这三个问题,在一个需求横跨多个存量工程、多个机房、前后端同时改动的场景下会被急剧放大,而 SmartFlow 恰好就是这样一个典型场景。要怎么解决?相信这些问题对绝大多数AI Coding的开发者都是共性问题,接下来先从业界已有的研究和实践里找思路,看看别人怎么应对这三类问题。

                                                                                                                                                  03

                                                                                                                                                  理论探索

                                                                                                                                                  下面我们从理论出发,探索怎么让 AI 看懂项目、怎么让 AI 做对需求、开发过程中的能力经验又怎么才能更好的沉淀下来。通过对行业经验的探索,更好地指导开发人员在实际开发过程中,能更加快速高效的完成需求开发。

                                                                                                                                                  3.1 上下文工程:让 AI 看懂项目

                                                                                                                                                  在 SmartFlow 的实践过程中,经过几轮AI Coding后我们发现,同样一个需求,喂给模型的材料不同,产出质量天差地别。与其反复打磨提示词的措辞,不如想清楚,这一次会话里,该把哪些代码、文档、约束放进去[1][3]。这个思路对应业界上下文工程(Context Engineering),它和传统的提示词工程(Prompt Engineering)着眼点不同,后者关心话怎么说模型才听得懂,前者关心哪些信息进来、哪些信息不进窗口。Anthropic 的工程实践给了我们不少启发,其中有三条可操作原则:

                                                                                                                                                  • 状态与输入分开管理:会话长期积累的状态是一回事,单次任务要用的上下文是另一回事,两者不能混在一个筐里;

                                                                                                                                                  • 上下文要按章法拼装:用命名清楚、顺序固定的模块来组织输入,而不是想到什么塞什么;

                                                                                                                                                  • 尽量少给、按需再取:每个执行环节只加载它真正用得到的最小信息,发现不够了再通过工具现场补充[1][3]。

                                                                                                                                                  落到日常开发上,我们把它简化成一套固定的推进节奏,AI 先摸清项目现状,再开发改动,最后验证结果,大致模拟一个开发人员拿到任务时的思考顺序[4]。为了保证每次新会话都能站在同一认知起点上,在工程根目录放了一份项目说明,把架构、编码约定、历史踩过的坑都写进去,作为跨会话的长效记忆[1]。按照这套做法执行,AI 开发前已经把项目看懂了,而不是一边写一边猜。

                                                                                                                                                  3.2 规格驱动开发(SDD):让 AI 做对需求

                                                                                                                                                  规格驱动开发(Spec-Driven Development, SDD)解决的是AI 按什么标准干活的问题,开始编码前,开发人员和 AI 先共同敲定一份行为契约,明确系统应该表现成什么样,后续的代码生成、测试和验收都以这份契约为准绳[1][5]。关于这类实践怎么做,Thoughtworks 的 Birgitta Böckeler 在 martinfowler.com 上发表的分析

                                                                                                                                                  (Understanding Spec-Driven-Development:

                                                                                                                                                   Kiro, spec-kit, and Tessl)给了我们很清晰的坐标系[5],他把规格驱动实践分成三个递进层级:

                                                                                                                                                  • 规格优先(Spec-first):先写规格再让 AI 写代码,规格是执行前的输入;

                                                                                                                                                  • 规格锚定(Spec-anchored):规格在功能上线后保留下来,随功能演进持续更新,变成一份活文档;

                                                                                                                                                  • 规格为源(Spec-as-source):人只编辑规格,代码由AI生成,规格取代源码成为最主要的产出物,实现声明式开发。

                                                                                                                                                  在工程实践上,业界普遍把规格驱动拆成规格、计划、任务、实现、验证五个阶段,前一个阶段的产出约束后一个阶段的输入[6][7]。不过我们没有追求规格自动生成全部代码的理想形态,那对规格的形式化程度要求太高,现实业务很难满足。我们采用的是更务实的组合,规格先行,AI 负责实现、自动化测试,然后由人工评审把关。这样安排的核心逻辑是,判断做什么、不做什么、怎么验收,这些关键决策仍然由人来做,AI 的价值体现在约定边界内把活干得更快更稳,而不是替人做决定。

                                                                                                                                                  3.3 团队知识沉淀:让 AI 能力工程化

                                                                                                                                                  单次会话里把 AI 调教得再好,窗口一关一切归零。要让AI Coding能力从个人本事变成团队资产,关键不是让每个人各练各的,而是把经验打包成工程化的形式沉淀下来[1]。结合这次实践,我们主要用了三种打包方式:

                                                                                                                                                  • Skill 封装:团队长期积累的编码规范、安全审查要点、中间件用法,我们把这些整理成可加载的技能文件,AI 工具在开工时会自动带上,效果相当于把资深工程师的经验预制进了工具里,每个会话默认就有这套把关逻辑,而不是等出了问题再补。

                                                                                                                                                  • 负向约束沉淀:AI 在开发中反复踩同一个坑时,与其每次口头纠正,不如直接把这条教训写成不允许这么做的约束,写进项目规范。这样后续所有会话天然绕开,不用靠人盯。

                                                                                                                                                  • 效能飞轮:规定每完成一次需求交付,就把这次新学到的约束、新确认的约定更新回知识库;AI 反复犯的错也同步固化成规则。一轮轮积累下来,形成经验越攒越多、AI 越用越稳的循环[1],个人的一次性经验沉淀成可复用资产。

                                                                                                                                                  这三项理论基础,上下文工程、规格驱动开发、团队知识沉淀,共同构成了本文冷启动方法的设计支撑。

                                                                                                                                                  04

                                                                                                                                                  方法设计

                                                                                                                                                  基于前面的探索,我们先回答一个问题,如何让 AI 在存量业务系统中看懂项目、做对需求、沉淀经验?我们提出一套可复制的 AI Coding 团队冷启动方法,其内核是历史知识沉淀(Skill)与新需求按 AI 编程范式开发两条主线构成循环。

                                                                                                                                                  4.1 总体框架

                                                                                                                                                  本文提出如图所示的 AI Coding 项目冷启动方法。其核心是两条实践主线构成的闭环循环,两条主线的关系是,知识沉淀 回答AI 凭什么看得懂这个项目,AI 编程范式开发 回答需求来了怎么让 AI 做得对。形成沉淀 → 使用 → 再沉淀的自我增强循环。

                                                                                                                                                  4.2 从历史工程提炼项目级 Skill

                                                                                                                                                  这是冷启动的第一步,也是最容易被忽视的一步。存量业务系统在长期演化中积累了海量的隐性知识,架构决策、转发链路、状态机、配置约定、历史坑点。这些知识散落在各处,如果不先显性化,AI 每次开发都只能盲人摸象。我们把提炼过程分为四个步骤:

                                                                                                                                                  • 知识盘点:以哪些知识是 AI 开发新需求时必须知道、但无法从代码本身直接推断的为标准,盘点历史工程与历史需求。以SmartFlow为例,盘点出三类关键知识:多机房(部署在多个机房,按机房路由)请求转发链路、业务投放全流程、WhatsApp对接规范。

                                                                                                                                                  • 结构化组织:将盘点的知识组织为主文档 + 分层引用的结构。主文档回答这个系统是什么、关键链路怎么走、排查问题从哪里入手,包含系统架构全景图、产品全景图、关键链路、状态机、文件索引与使用指南等;需要长篇幅展开的细节则放入独立引用文档,按需加载。

                                                                                                                                                  • 按需加载设计:主文档只放高频、短小的核心信息,需要展开的细节放到独立文档里,AI 用到哪份再加载哪份。这个安排和上下文工程尽量少给、需要时再取的思路是一致的[3],一次会话里塞进去的内容越少,模型注意力越集中,不容易因为无关信息太多而中毒[1]。

                                                                                                                                                  • 持续回写:Skill 不是一次性产物。每次开发实践中发现的既有隐患、新增的架构约定,都要回写进 Skill,使后续会话天然携带最新约束,形成发现、固化、复用的正向循环[1]。

                                                                                                                                                  4.3 新需求按 AI 编程范式开发

                                                                                                                                                  在知识就绪后,每一次新需求开发都遵循统一的五阶段闭环,与 SDD 的规格 → 计划 → 任务 → 实现 → 验证五环节一致[2],其关键设计在于,规格不追求形式化的通用语言,而是针对存量业务系统的领域化描述,包含流程节点、状态机、接口契约等,保证开发人员可以评审,AI可以无脑执行;人的判断前置到需求、边界和验收标准上,AI 负责按规格高效执行[2]。

                                                                                                                                                  05

                                                                                                                                                  实践脉络:从知识沉淀到范式开发

                                                                                                                                                  接下来我们从SmartFlow 的完整开发过程出发,完整展示两条主线如何在实际业务中落地,聚焦实践过程与决策逻辑。

                                                                                                                                                  5.1 项目概况

                                                                                                                                                  SmartFlow 是一个基于可视化编辑的自动化营销工具,业务目标是,支持业务方配置基于 WhatsApp 的自动交互流程,实现用户发消息 → 匹配互动策略 → 自动下发营销模板 → 用户回复消息 → 再次下发消息或结束语的营销闭环。需求横跨三个工程,新建后端服务、存量中台改造、前端开发改造。需求本身隐含两类难点,一是多机房部署要求,互动策略需要按机房路由到对应环境;二是与既有存量系统深度耦合,不能与已有功能重复建设。

                                                                                                                                                  5.2 第一步:先沉淀,再开发

                                                                                                                                                  在写新代码之前,首先对涉及的存量系统做了一次系统的知识盘点与提炼,产出了项目级 Skill(sms-develop-skill)。整个过程分为四个环节:

                                                                                                                                                  • 梳理系统全景:明确系统由哪些工程、哪些层次组成,各层的职责分工与依赖关系,形成一张可被 AI 读取的系统地图。

                                                                                                                                                  • 提炼关键链路:将最核心、最容易出错的链路以流程化、结构化的方式写入知识库,并标注关键节点与决策点。

                                                                                                                                                  • 固化环境与配置约定:将各环境、各机房的配置规范与部署步骤整理成清单,避免 AI 在开发时对配置体系做出错误假设,并且对开发规范等做了约定。

                                                                                                                                                  • 标注已知问题与坑点:把历史开发中发现的隐患,显式记录,使后续所有会话天然规避同类问题,实现错误一次、永久免疫。

                                                                                                                                                  这一步是让 AI 在后续所有开发会话中,默认具备与资深工程师对等的系统认知,它知道请求从哪进、往哪转发、业务状态如何流转、配置从哪取,而不是靠每次临场猜测。

                                                                                                                                                  5.3 第二步:按 AI 编程范式开发新需求

                                                                                                                                                  当我们将项目历史知识形成Skill后,新需求的开发基于这个Skill,严格按这五个阶段推进,从而更加准确高效的进行功能开发迭代。

                                                                                                                                                  需求规格化

                                                                                                                                                  需求入口是一份 PRD,包含功能概述、节点类型、分支路由规则、定时任务要求等。在 AI 开发之前,团队先将 PRD 转换为可评审、可执行的规格,例如前后端交互契约规格、数据与模块边界规格等。规格化过程的核心产出是消除了需求中的关键歧义。例如一个商业账号只可绑定一个策略,执行实例如何判定活跃会话;用户超时无回复时,流程由谁推进、何时终结。这两点若不前置澄清,AI 实现的流程调度必然跑偏,这正是 SDD把人的判断前置的价值所在[2]。

                                                                                                                                                  规格评审

                                                                                                                                                  规格文档交由人工评审,确认做什么、不做什么、如何验收。评审不通过则回到需求规格化改规格,通过后才进入实现。这一环节保证了需求的边界由人来定,而不是由 AI 临场推断。

                                                                                                                                                  受控实现 

                                                                                                                                                  AI 按任务清单逐项实现。由于已经注入了完整架构知识与团队编码规范,AI 的实现表现出两个显著特征,一是主动复用既有模式,多机房转发、模板映射、消息发送等能力在存量系统中已有成熟实现,AI 知道这些功能就直接复用;二是遵循既有工程约定,包结构、命名、异常处理、配置获取方式均与存量代码保持一致,避免了语法正确、风格背离的返工。

                                                                                                                                                  验证联调

                                                                                                                                                  前后端按规格契约联调。关键改造点在于前端请求统一收敛到中台新增的转发通道,不再依赖按机房硬编码的路径转发,这既简化了运维,也让前端业务代码彻底摆脱机房感知。

                                                                                                                                                  知识回写

                                                                                                                                                  开发完成后,将本次实践中新增的知识与发现的问题回写进项目级 Skill,新增了哪些通道与配置、解决了哪些歧义、发现了哪些既有隐患。至此,一次需求开发闭环完成,知识库得到扩充,使下次的需求能更快的开发迭代。

                                                                                                                                                  5.4 实践中的关键问题与处理

                                                                                                                                                  问题

                                                                                                                                                  表现

                                                                                                                                                  处理方式

                                                                                                                                                  知识散落

                                                                                                                                                  AI 不了解多机房转发等隐性架构

                                                                                                                                                  先提炼项目级 Skill,注入架构认知

                                                                                                                                                  需求歧义

                                                                                                                                                  策略执行状态的判定不清

                                                                                                                                                  规格化时前置澄清

                                                                                                                                                  重复建设

                                                                                                                                                  AI 倾向新写既有能力

                                                                                                                                                  Skill 标注既有实现,强制复用

                                                                                                                                                  规范偏离

                                                                                                                                                  生成代码不合既有工程约定

                                                                                                                                                  团队编码规范显式化,注入 AI 上下文

                                                                                                                                                  联调断裂

                                                                                                                                                  前端直连各机房服务

                                                                                                                                                  中台新增统一转发通道,前端屏蔽机房感知

                                                                                                                                                  06

                                                                                                                                                  效果评估与经验教训

                                                                                                                                                  最后我们从结果的角度给这次实践做个复盘,先看交付层面拿到了哪些实打实的效果,再坦率地说说这套方法目前还有哪些局限,最后把整个过程中总结出来的经验教训提炼成六条,方便大家直接复用。

                                                                                                                                                  6.1 实践成效

                                                                                                                                                  从结果看,这次实践主要收获了几点:

                                                                                                                                                  • 端到端交付:在沉淀 → 开发闭环下顺利完成,没有出现与既有工程结构冲突的大改;

                                                                                                                                                  • 复用显著:中台转发通道完全复用既有转发模式,新增工作量集中在按既有约定扩展而不是重新设计,这直接得益于 Skill 注入的架构认知;

                                                                                                                                                  • 知识资产:沉淀出一份项目级 Skill,覆盖系统全景、关键链路、配置规范、已知问题四个维度,后续新成员或新会话能即时获得同一份架构认知;

                                                                                                                                                  • 质量稳定:全部新增代码通过团队编码规范扫描,没有发生因不理解既有架构而推倒重来的情况。

                                                                                                                                                  6.2 局限性

                                                                                                                                                  • 单案例局限:结论来自单一业务场景、没有对照组、量化指标也偏少,目前能拿得出手的只有交付时间这一项,工时节省比例、缺陷率变化这些并没有,普适性需要放到更多项目上验证;

                                                                                                                                                  • 人工依赖:规格评审、规范扫描目前还是人工在做,没有接入 CI/CD 实现自动化;

                                                                                                                                                  • 知识时效性:知识库和代码之间会漂移,时间一长容易对不上,需要一套跟代码变更联动的更新机制来兜底。

                                                                                                                                                  6.3 经验总结

                                                                                                                                                  基于这次冷启动实践,我们提炼出六条可复用的经验:

                                                                                                                                                  (1)先沉淀,再开发

                                                                                                                                                  在存量工程里,AI 生成语法正确、风格背离代码的根因是缺乏系统认知。先把历史工程与历史需求提炼成可复用的知识资产,是投入产出比最高的第一步,也是让 AI越用越懂项目的前提。

                                                                                                                                                  (2)项目级 Skill 是知识沉淀的最小完备单元

                                                                                                                                                  相比完整的规格工件体系,主文档 + 分层引用的结构轻量、渐进、按需加载,适合作为团队 AI 能力资产化的起点;随着实践成熟,可向 Spec-anchored / Spec-as-source 演进[2]。

                                                                                                                                                  (3)让 AI 复用既有功能,而不是重复开发

                                                                                                                                                  多机房转发、模板映射、消息发送这些能力,存量系统里早就有了成熟实现。知识库要做的就是让 AI知道这些模式存在、直接沿用,省得重复造轮子。

                                                                                                                                                  (4)把已知问题写进知识库

                                                                                                                                                  开发过程中发现的隐患与坑点,显式记录到知识库,让后续所有会话天然规避同类问题,实现错误一次、永久免疫。

                                                                                                                                                  (5)人机分工要明确

                                                                                                                                                  人是规格与验收的判定者,AI 是规格的执行者[2]。做什么、不做什么、如何验收,这些边界确认,必须在编码前完成,不能等生成代码后再靠修补挽回。

                                                                                                                                                  (6)一定要进行知识回写 

                                                                                                                                                  一次需求交付的结束,正是知识资产增值的开始。坚持每次开发都回写,团队 AI 能力才能持续积累而不是原地踏步。

                                                                                                                                                  07

                                                                                                                                                  结论展望

                                                                                                                                                  本文针对 AI Coding 在项目中的冷启动难题,提出历史知识沉淀项目级 Skill与新需求按 AI 编程范式开发两条线构成的闭环方法,并以 SmartFlow 的多工程协同开发实践验证了其可行性。这次实践最大启示是,SmartFlow 能提前交付,靠的不是用了更强的模型,而是提前把项目知识翻译成了 AI 能稳定消费的形式。知识沉淀解决AI 凭什么看得懂这个项目,规格化解决需求来了怎么让 AI 做得对,两条线合在一起,AI 产出的代码才能长期与存量工程的结构和规范保持一致,团队经验也随之沉淀为可复用的资产[1]。

                                                                                                                                                  后续工作包括三个方向,一是将规范扫描与验收接入 CI/CD,实现规格 → 实现 → 验证的自动化;二是将项目级 Skill 升级为团队级知识库,支持多项目复用与版本管理;三是引入量化评估(工时、缺陷率、返工率),为冷启动方法建立可度量的效果基线。

                                                                                                                                                  参考文献

                                                                                                                                                    [1] The New Stack. Context Is AI Coding's Real Bottleneck in 2026[EB/OL]. [2026-09-07]. 
                                                                                                                                                    https://thenewstack.io/context-is-ai-codings-real-bottleneck-in-2026/.


                                                                                                                                                    [2] GitHub Blog. Spec-Driven Development with AI: Get started with a new open source toolkit[EB/OL]. [2026-09-07]. 
                                                                                                                                                    https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/.


                                                                                                                                                    [3] Anthropic. Effective Context Engineering for AI Agents[EB/OL]. [2026-09-07]. 
                                                                                                                                                    https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents.


                                                                                                                                                    [4] Anthropic. How Claude Code Works[EB/OL]. [2026-09-07]. 
                                                                                                                                                    https://code.claude.com/docs/en/how-claude-code-works.


                                                                                                                                                    [5] Böckeler B. Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl[EB/OL]. (2025-10-15)[2026-09-07]. 
                                                                                                                                                    https://www.martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html.


                                                                                                                                                    [6] DORA (Google Cloud). Accelerate State of DevOps Report 2024[R/OL]. (2024-10-23)[2026-09-07]. 
                                                                                                                                                    https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report.


                                                                                                                                                    [7] Fission AI. OpenSpec: Spec-Driven Development for AI Coding Assistants[EB/OL]. [2026-09-07]. 
                                                                                                                                                    https://openspec.dev.

                                                                                                                                                    END

                                                                                                                                                    猜你喜欢

                                                                                                                                                    vivo HTTPDNS 端到端体验优化实践

                                                                                                                                                    NLLB 与 ChatGPT 双向优化:探索翻译模型与语言模型在小语种应用的融合策略

                                                                                                                                                    跳转微信打开

                                                                                                                                                    KDC 全景:从现实到反馈的完整工程模型 |KDC 系列 05

                                                                                                                                                    2026年10月28日 20:00

                                                                                                                                                    互联网存储团队 2026-10-28 20:00 广东

                                                                                                                                                    KDC 的价值不在于提出几个孤立名词,而在于尝试把这条链路变成可以被设计、运行、审计和演化的软件工程闭环。

                                                                                                                                                    作者:vivo 互联网存储团队 - Xiao Bo

                                                                                                                                                    AI 合作者:ChatGPT(GPT-5.5)

                                                                                                                                                    创作模式:Human-led, AI-collaborated

                                                                                                                                                    责任声明:文章观点、理论体系及最终内容由作者负责;AI 参与讨论、推演、表达优化及部分内容生成。

                                                                                                                                                    目录

                                                                                                                                                    01. KDC 要解决的不是所有软件问题

                                                                                                                                                    02. 一条从 Reality 到 Feedback 的完整闭环

                                                                                                                                                    03. KDC 有两张图:业务闭环与工程模型

                                                                                                                                                    04. 第一层:对象化,让隐含责任可以被引用

                                                                                                                                                    05. 第二层:运行时化,让对象真正运转

                                                                                                                                                    06. 第三层:治理化,让行动边界成为系统机制

                                                                                                                                                    07. 用一次退款任务组装完整模型

                                                                                                                                                    08. KDC 如何与现有体系协同

                                                                                                                                                    09. 渐进采用:从一个业务闭环开始

                                                                                                                                                    10. 成熟度:哪些已经验证,哪些仍是理论提案

                                                                                                                                                    11. 实践:用 KDC Architecture Canvas 做一次架构评审

                                                                                                                                                    12. KDC 试图建立的是一条可以被质疑的工程闭环

                                                                                                                                                    13. 理论边界与开放问题

                                                                                                                                                    KDC 试图把领域现实、数字表示、知识、记忆、推理、技能、能力、行动和反馈组织成一条连续的业务因果链。本文给出 Reality-to-Feedback 闭环以及对象化、运行时化、治理化三层工程模型,同时区分已验证实践、理论推导和开放问题,说明企业如何从一个高影响业务闭环开始渐进采用。

                                                                                                                                                    研究说明:知识驱动计算(Knowledge-driven Computing,KDC)是我们提出和正在打磨的一套 AI 应用软件工程理论,目前仍处于开放研究阶段。前四篇分别从 Reality、Knowledge、Reasoning、Skill、Capability、Memory 和 Feedback 展开。这一篇不再逐个解释概念,而是回答最后一个问题:它们如何组成一套完整、可审计、可治理、可渐进采用的软件工程模型?

                                                                                                                                                    1分钟看图掌握核心要点👇

                                                                                                                                                    在前四篇贯穿的退款案例中,我们已经得到四份产物:

                                                                                                                                                    • 一张 Reality Map,说明系统面对哪些现实对象、状态、关系和反馈

                                                                                                                                                    • 一张 Knowledge Card,说明当前退款规则来自哪里、为什么可信、适用于什么边界

                                                                                                                                                    • 一份 AI Action Record,说明 Agent 为什么建议退款、策略如何判定、用户是否确认

                                                                                                                                                    • 一份 Feedback Contract,说明接口成功之后,什么现实结果才算退款真正完成

                                                                                                                                                    每份产物都解决了一个问题,却没有任何一份能够单独解释完整业务。

                                                                                                                                                    Reality Map 不会自动告诉 Agent 应引用哪条政策。Knowledge Card 不会自动形成退款判断。AI Action Record 不能替代实际执行。Feedback Contract 也只有在能够追溯到原目标和行动时才有意义。

                                                                                                                                                    当它们被放到同一条因果链上时,KDC 的完整轮廓才出现:

                                                                                                                                                      系统面对什么现实
                                                                                                                                                        -> 如何表示和理解现实
                                                                                                                                                        -> 依据什么形成判断
                                                                                                                                                        -> 如何围绕目标组织行动
                                                                                                                                                        -> 怎样在治理约束下影响现实
                                                                                                                                                        -> 如何用现实反馈修正系统

                                                                                                                                                      KDC 的价值不在于提出几个孤立名词,而在于尝试把这条链路变成可以被设计、运行、审计和演化的软件工程闭环。

                                                                                                                                                      01

                                                                                                                                                      KDC 要解决的不是所有软件问题

                                                                                                                                                      在组装完整模型之前,需要先说明它的适用范围。

                                                                                                                                                      KDC 不是操作系统、数据库、编译器、网络协议或模型训练理论。它依赖这些数字基础设施,却不试图重新定义它们。

                                                                                                                                                      KDC 也不是所有应用软件的强制架构。如果一个程序只执行确定转换、固定规则和低风险 API 调用,不需要模型理解动态上下文,不涉及知识演化,也不会影响重要现实状态,那么传统代码、数据模型、接口契约、测试和监控已经可以很好地解决问题。

                                                                                                                                                      KDC 更关注这样一类系统:

                                                                                                                                                      • 业务语义密集,简单字段不足以表达全部条件

                                                                                                                                                      • 上下文会随用户、时间、项目和现实状态变化

                                                                                                                                                      • 模型会在运行时解释材料并形成判断

                                                                                                                                                      • 系统需要根据目标选择 Skill 或 Capability

                                                                                                                                                      • 行动可能影响订单、资金、权限、审批、通知或其他重要现实状态

                                                                                                                                                      • 团队需要知道判断依据、行动原因和责任边界

                                                                                                                                                      • 行动结果必须反馈并影响未来知识、记忆或治理

                                                                                                                                                      企业知识助手如果只做低风险文档问答,可能只需要来源和引用增强。当它开始生成审批建议、创建任务、发送通知或修改业务状态时,KDC 关注的完整链路才逐步变得必要。

                                                                                                                                                      因此,采用 KDC 不是二元选择。团队可以只补齐当前风险最高的一段,而不是一次性建设全部对象和运行时。

                                                                                                                                                      02

                                                                                                                                                      一条从 Reality 到 Feedback 的完整闭环

                                                                                                                                                      KDC 当前用下面这条链路组织核心概念:

                                                                                                                                                      图 5:KDC Reality-to-Feedback 业务闭环

                                                                                                                                                      这不是一条只能从左到右执行一次的流水线,而是一张因果地图。

                                                                                                                                                      2.1 Reality 是最终参照物

                                                                                                                                                      领域现实定义系统在职责范围内试图观察、建模、预测或影响的对象、状态、关系和动态规律。

                                                                                                                                                      退款系统面对的现实包括用户诉求、订单承诺、原支付、资金退回和到账结果。数据库状态很重要,但它不是最终参照物。接口成功也不能单独证明用户已经收到资金。

                                                                                                                                                      2.2 Reality Model 决定系统看见什么

                                                                                                                                                      现实模型选择哪些现实进入系统,如何划分对象和状态,怎样表达关系,又用什么反馈判断变化已经发生。

                                                                                                                                                      同一个退款过程可以被建模成"处理中、成功、失败",也可以区分"渠道受理、清算中、银行处理中、用户到账"。模型粒度应与系统职责和现实承诺匹配。

                                                                                                                                                      2.3 Representation 是现实的数字编码

                                                                                                                                                      数据、文档、API、事件、日志、图谱、Embedding、Prompt 和模型上下文都是表示。它们让现实能够进入数字系统,却不自动等于现实或知识。

                                                                                                                                                      2.4 Knowledge 提供可复用依据

                                                                                                                                                      表示经过解释、验证并形成可复用认知成果后,才能在 KDC 意义上成为知识。

                                                                                                                                                      知识需要来源、证据、适用边界、版本和成熟度。当前退款政策与订单事实可以支撑判断。一份相似度更高但已经过期的旧政策不能以相同资格进入推理。

                                                                                                                                                      2.5 Memory 让历史在受治理条件下影响未来

                                                                                                                                                      记忆保存知识、经验、决策、反馈和演化轨迹。它不是把所有历史对话放入向量库,而是决定哪段历史在什么条件下仍可影响当前判断。

                                                                                                                                                      上次用户选择退款可以解释过去,却不能自动成为"用户永远偏好直接退款"的稳定画像。

                                                                                                                                                      2.6 Reasoning 连接依据与结论

                                                                                                                                                      推理对象记录目标、上下文、知识和记忆引用、证据、关键判断、风险、结论和行动建议。

                                                                                                                                                      它不要求暴露完整 Chain-of-Thought,而是提供足以审计高影响判断的外部结构。比如,"满足退款条件"和"用户已经授权退款"必须成为两个可区分判断。

                                                                                                                                                      2.7 Skill 组织目标级复用

                                                                                                                                                      Skill 把业务目标、前置条件、参与能力、编排逻辑、风险边界和失败策略组织起来。

                                                                                                                                                      "处理退款"不是一个 Tool,而是一项可能包含目标澄清、规则判断、用户确认、执行、跟踪和异常处理的目标级能力组合。

                                                                                                                                                      2.8 Capability 是受治理的行动入口

                                                                                                                                                      Capability 把底层 Tool 或服务包装成具备身份、语义、权限、风险、Owner、版本、审计、可观测和生命周期的执行对象。

                                                                                                                                                      在 KDC 系统边界内,凡是需要被 AI 理解、选择、调用和治理的重要行动,都应通过能力对象表达。这里不声称世界上的所有变化都由 Capability 造成。用户、外部系统和自然事件同样会改变现实。

                                                                                                                                                      2.9 Action 作用于现实,Feedback 关闭闭环

                                                                                                                                                      能力运行时执行行动,现实结果再通过业务事件、外部状态、人工确认、用户反馈和对账结果进入系统。

                                                                                                                                                      反馈不是自动真值,也不应直接升级知识或强化记忆。它需要来源、关联、可信度和错误归因,然后由对应运行时决定更新什么。

                                                                                                                                                      2.10 Continuous Consistency 是长期方向

                                                                                                                                                      闭环的长期目标,是让系统能够观察领域现实与数字表示之间的偏差,并在知识过期、记忆失效、推理错误或行动失败时找到修正路径。

                                                                                                                                                      这里所说的"持续一致性",首先是一种持续发现偏差并寻找修正路径的能力,而不是要求系统与现实始终保持绝对同步,也不是用一个已经固定的总分概括系统状态。偏差可能来自现实覆盖不足、现实映射错误、知识过期、知识漂移或验证缺失。围绕这些问题,Reality Coverage、Reality Mapping、Knowledge Freshness、Knowledge Drift 和 Consistency Verification 目前只是候选的度量方向,具体定义和组合方式仍需要在实践中验证。

                                                                                                                                                      03

                                                                                                                                                      KDC 有两张图:业务闭环与工程模型

                                                                                                                                                      上面的 Reality-to-Feedback 链路回答"业务因果如何流动"。真正构建系统时,还需要另一张图回答"由什么工程机制承担责任"。

                                                                                                                                                      KDC 当前把工程模型概括为三个层次:对象化、运行时化和治理化。

                                                                                                                                                      图 6:KDC 对象、运行时与治理的工程责任结构

                                                                                                                                                      这三层不是三个必须独立部署的平台,而是三类工程责任。

                                                                                                                                                      04

                                                                                                                                                      第一层:对象化,让隐含责任可以被引用

                                                                                                                                                      传统 AI 应用常把关键内容放在 Prompt、会话上下文、文档片段、工具描述和日志中。这些内容可以工作,却缺少稳定身份和生命周期,难以跨任务引用和治理。

                                                                                                                                                      KDC 当前定义五类核心对象:

                                                                                                                                                      对象

                                                                                                                                                      主要回答的问题

                                                                                                                                                      退款场景示例

                                                                                                                                                      Knowledge Object

                                                                                                                                                      系统依据什么,为什么相信

                                                                                                                                                      当前退款政策和适用边界

                                                                                                                                                      Memory Object

                                                                                                                                                      哪些历史仍可影响未来

                                                                                                                                                      过去退款结果、用户纠正、渠道异常经验

                                                                                                                                                      Reasoning Object

                                                                                                                                                      系统如何形成判断

                                                                                                                                                      资格判断、授权判断、风险和行动建议

                                                                                                                                                      Skill Object

                                                                                                                                                      如何围绕目标组织能力

                                                                                                                                                      退款处理流程及失败策略

                                                                                                                                                      Capability Object

                                                                                                                                                      通过什么受治理入口行动

                                                                                                                                                      查询订单、发起退款、查询到账状态

                                                                                                                                                      对象化的重点不是把所有内容转换成统一 JSON,而是给高价值责任稳定身份。

                                                                                                                                                      当退款政策更新时,系统应该知道哪些推理引用了旧版本。当能力发生事故时,系统应该知道哪些 Skill 和行动受影响。当用户纠正偏好时,系统应该找到相关记忆,而不是只能全文搜索聊天记录。

                                                                                                                                                      对象化让"依据了什么、记住了什么、如何判断、怎样组织目标、通过什么行动"从临时内容变成可追溯关系。

                                                                                                                                                      05

                                                                                                                                                      第二层:运行时化,让对象真正运转

                                                                                                                                                      只有对象定义,没有运行时职责,对象会退化成静态 Schema。

                                                                                                                                                      KDC 当前提出四类运行时:

                                                                                                                                                      5.1 知识运行时

                                                                                                                                                      负责从表示中解析、抽取、关联、验证和检索知识对象,处理来源、证据、冲突、版本和生命周期。

                                                                                                                                                      它可以使用 RAG、搜索、知识图谱和规则系统,但不等于其中任何一个。

                                                                                                                                                      5.2 记忆运行时

                                                                                                                                                      负责记忆形成、检索、强化、冲突、衰减、遗忘、迁移和归档。

                                                                                                                                                      它治理的是历史如何影响未来,而不是保存尽可能多的历史。

                                                                                                                                                      5.3 推理运行时

                                                                                                                                                      负责目标识别、上下文装配、证据绑定、推理对象创建、风险评估、能力选择建议和反馈更新。

                                                                                                                                                      它不是 Prompt 模板管理器,也不要求暴露模型内部全部思维。

                                                                                                                                                      5.4 能力运行时

                                                                                                                                                      负责能力发现、选择、调用、组合、结果反馈和失败处理,并在控制平面的策略约束下执行。

                                                                                                                                                      它不是一个裸 Tool Executor。授权、风险、版本、失败策略和现实反馈都属于执行边界的一部分。

                                                                                                                                                      运行时是逻辑责任,不必一开始对应四个独立服务。一个现有应用可以通过模块、事件、策略和数据结构承担其中部分职责,再根据规模和边界逐步拆分。

                                                                                                                                                      06

                                                                                                                                                      第三层:治理化,让行动边界成为系统机制

                                                                                                                                                      当 AI 只能生成文本时,错误主要影响回答质量。当 AI 可以退款、下单、变更权限和发送通知时,错误会进入现实。

                                                                                                                                                      治理层需要把以下责任从 Prompt 约定提升为系统机制:

                                                                                                                                                      • 能力注册、发现和版本

                                                                                                                                                      • 主体身份、权限和策略

                                                                                                                                                      • 风险分级和 HITL

                                                                                                                                                      • 前置条件、后置不变量和事务边界

                                                                                                                                                      • 限流、熔断、灰度、回滚和补偿

                                                                                                                                                      • Owner、生命周期和退役

                                                                                                                                                      • 运行时可观测和对象化审计链

                                                                                                                                                      • 现实反馈和错误归因

                                                                                                                                                      能力控制平面承载能力注册、授权、策略、审计、观测和生命周期控制。能力注册表保存能力身份、语义、Owner、风险、依赖和状态。能力治理决定什么条件下允许、拒绝、降级或转人工。

                                                                                                                                                      治理也不只发生在能力入口。知识权限、记忆访问、推理证据和反馈可信度同样需要边界。一个控制平面无法替代所有运行时治理,它只是行动治理中最集中的基础设施节点。

                                                                                                                                                      07

                                                                                                                                                      用一次退款任务组装完整模型

                                                                                                                                                      现在我们把前四篇的退款任务完整走一遍。

                                                                                                                                                      7.1 识别现实目标

                                                                                                                                                      用户说:"帮我看看这笔订单现在能不能退?"

                                                                                                                                                      系统首先区分资格咨询和行动授权。当前目标是判断是否符合条件,不是立即退款。

                                                                                                                                                      Reality Map 告诉系统,退款涉及订单、原支付、活动权益、资金退回和到账反馈。"接口成功"不是最终现实结果。

                                                                                                                                                      7.2 装配知识与记忆

                                                                                                                                                      知识运行时提供当前有效的退款政策、订单事实和活动权益规则,并保留版本、证据和适用边界。

                                                                                                                                                      记忆运行时可能返回上次退款经历,但同时标明:这是特定订单下的情景和行动结果,不足以证明用户当前仍偏好直接退款。

                                                                                                                                                      7.3 形成推理对象

                                                                                                                                                      推理运行时记录:

                                                                                                                                                      • 目标是资格判断

                                                                                                                                                      • 当前政策版本为 v4.0

                                                                                                                                                      • 订单未发货且权益未核销

                                                                                                                                                      • 结论是符合退款条件

                                                                                                                                                      • 风险在于把咨询误解为授权

                                                                                                                                                      • 行动建议是向用户说明条件并请求明确确认

                                                                                                                                                      7.4 选择 Skill

                                                                                                                                                      Agent 选择"订单退款处理"Skill。该 Skill 规定:先判断资格,再解释影响,用户确认后才进入事务型退款能力。高金额或异常订单转人工。

                                                                                                                                                      7.5 提出能力调用建议

                                                                                                                                                      用户确认后,系统建议调用"发起订单退款能力"。能力对象声明其风险、权限、Owner、事务边界、审计策略和反馈要求。

                                                                                                                                                      7.6 控制平面判定

                                                                                                                                                      控制平面检查调用主体、用户确认、推理对象、订单状态、知识版本、风险策略和能力生命周期。

                                                                                                                                                      条件满足时授权执行。缺少确认时拒绝并返回可解释原因。命中高风险规则时进入 HITL。

                                                                                                                                                      7.7 能力运行时执行

                                                                                                                                                      能力运行时调用底层 Tool,处理事务、异常、重试或补偿,记录执行结果。Tool 返回成功只表示请求被受理,不直接把退款标记为现实完成。

                                                                                                                                                      7.8 现实反馈进入系统

                                                                                                                                                      支付渠道状态、对账结果和用户确认进入 Feedback Contract。系统将反馈关联到原目标、推理对象、能力对象和策略判定。

                                                                                                                                                      如果退款到账,行动结果可以形成候选记忆。如果延迟来自渠道故障,更新能力质量和行动-结果记忆。如果旧政策导致错误判断,让知识降级或过期。如果 Agent 误解目标,修正推理策略。

                                                                                                                                                      这一过程说明,Agent 的价值不是自己承担所有责任,而是协调对象、运行时和治理机制完成一个可追溯任务。

                                                                                                                                                      08

                                                                                                                                                      KDC 如何与现有体系协同

                                                                                                                                                      KDC 不以替代现有理论和基础设施来证明自己。它更像一张组合地图:

                                                                                                                                                      现有理论或实践

                                                                                                                                                      已经解决的核心问题

                                                                                                                                                      在 KDC 中的主要位置

                                                                                                                                                      DDD / 领域建模

                                                                                                                                                      业务语言、边界和领域模型

                                                                                                                                                      Reality Model 和知识语义的重要来源

                                                                                                                                                      事件驱动架构

                                                                                                                                                      状态变化传播与系统解耦

                                                                                                                                                      Reality 变化和 Feedback 的重要表示机制

                                                                                                                                                      Data Mesh / 数据平台

                                                                                                                                                      数据责任、产品化和治理

                                                                                                                                                      Representation 与知识形成的数据基础

                                                                                                                                                      RAG / 搜索

                                                                                                                                                      材料召回和上下文装配

                                                                                                                                                      知识运行时的局部机制

                                                                                                                                                      Knowledge Graph

                                                                                                                                                      实体、关系和图查询

                                                                                                                                                      知识关系或证据结构的实现机制

                                                                                                                                                      MCP / Tool-use

                                                                                                                                                      模型连接资源和执行入口

                                                                                                                                                      Capability 的协议和执行入口之一

                                                                                                                                                      Agent Framework

                                                                                                                                                      目标、计划、执行循环与协作

                                                                                                                                                      对象和运行时之上的协调实现

                                                                                                                                                      Workflow / BPMN

                                                                                                                                                      稳定流程和人工节点

                                                                                                                                                      Skill 路径与审批机制的实现基础

                                                                                                                                                      API Gateway / Service Mesh

                                                                                                                                                      网络入口和服务通信治理

                                                                                                                                                      能力控制平面的底层流量基础

                                                                                                                                                      IAM / Policy Engine

                                                                                                                                                      身份、权限和策略判定

                                                                                                                                                      能力治理的重要基础设施

                                                                                                                                                      OpenTelemetry / APM / Logging

                                                                                                                                                      技术观测和调用链

                                                                                                                                                      运行时可观测的信号来源

                                                                                                                                                      KDC 的补充,是把这些局部机制连接到一条从现实、知识和判断到行动、治理和反馈的因果链。

                                                                                                                                                      这也是 KDC 当前最主要的原创主张:新颖性不在于发明 Knowledge、Agent、API 或治理,而在于把它们组织成一个面向 AI 应用软件的连续工程闭环。

                                                                                                                                                      这个原创性主张仍需要更多实践、外部审阅和反例检验。它不能因为概念链条连贯,就自动被视为已经成立的行业理论。

                                                                                                                                                      09

                                                                                                                                                      渐进采用:从一个业务闭环开始

                                                                                                                                                      KDC 最容易失败的采用方式,是先建设一个名义完整的"知识平台、记忆平台、推理平台和能力平台",再去寻找业务场景。

                                                                                                                                                      更现实的路径是从一个高价值或高风险闭环开始。

                                                                                                                                                      ① 建立 Reality Map

                                                                                                                                                      明确系统边界、现实对象、状态、关系、动态规律和成功反馈。优先识别内部状态与现实承诺之间的缺口。

                                                                                                                                                      ② 识别关键 Representation 和 Knowledge

                                                                                                                                                      找出当前判断依赖的文档、数据、规则和事件。只对象化高价值、可复用或高风险知识,保留来源、证据、版本和成熟度。

                                                                                                                                                      ③ 外部化高影响判断

                                                                                                                                                      为高影响决策建立推理对象或等价审计依据。至少记录目标、知识引用、证据、结论、风险和行动建议。

                                                                                                                                                      ④ 治理重要能力

                                                                                                                                                      把影响现实状态的 Tool 纳入 Capability,补齐语义、Owner、权限、风险、版本、审计和失败策略。优先治理资金、权限、审批、外部通知和不可逆行动。

                                                                                                                                                      ⑤ 建立现实反馈和错误归因

                                                                                                                                                      定义执行结果与现实成功的区别,把反馈关联到目标、推理、能力和策略,并能够区分知识、记忆、推理、治理、执行和外部系统错误。

                                                                                                                                                      ⑥ 按真实瓶颈引入运行时能力

                                                                                                                                                      如果主要问题是旧政策和冲突,优先补知识运行时。如果历史误用频繁,补记忆生命周期。如果高影响判断不可审计,补推理对象和运行时。如果 Tool 失控,补能力治理和控制平面。

                                                                                                                                                      这条路径的原则是:

                                                                                                                                                        先闭合责任
                                                                                                                                                        再抽象机制
                                                                                                                                                        最后平台化

                                                                                                                                                        平台应该从反复出现且边界稳定的运行时责任中长出来,而不是从术语清单中长出来。

                                                                                                                                                        10

                                                                                                                                                        成熟度:哪些已经验证,哪些仍是理论提案

                                                                                                                                                        完整模型必须把证据强度写清楚,否则读者会误以为每一层都已经经过同等验证。

                                                                                                                                                        论断或模块

                                                                                                                                                        当前成熟度

                                                                                                                                                        说明

                                                                                                                                                        MCP + Tool + Skill + LLM 可完成电商业务流程

                                                                                                                                                        Verified

                                                                                                                                                        来自现有能力治理平台支持的电商实践

                                                                                                                                                        能力治理平台承担部分能力控制平面职责

                                                                                                                                                        Verified + Derived

                                                                                                                                                        注册、授权、测试、灰度、限流、熔断、审计和观测已有实践

                                                                                                                                                        Reality First 与现实驱动计算

                                                                                                                                                        Derived

                                                                                                                                                        来自第一性原理和工程问题推导

                                                                                                                                                        KDC 知识定义与成熟度

                                                                                                                                                        Derived

                                                                                                                                                        已形成操作性定义,仍需外部检验

                                                                                                                                                        五类对象模型

                                                                                                                                                        Derived

                                                                                                                                                        结构和边界已提出,需要更多场景验证

                                                                                                                                                        四类运行时模型

                                                                                                                                                        Derived + Hypothesis

                                                                                                                                                        职责已定义,完整产品形态和接口仍未冻结

                                                                                                                                                        企业知识库参考实践

                                                                                                                                                        Derived + Hypothesis

                                                                                                                                                        尚未完成完整工程验证

                                                                                                                                                        自主 Agent 参考实践

                                                                                                                                                        Derived + Hypothesis

                                                                                                                                                        多 Agent、身份和责任边界仍开放

                                                                                                                                                        记忆运行时与 Memory Taxonomy

                                                                                                                                                        Hypothesis + Derived

                                                                                                                                                        遗忘、迁移和统一分类仍有 Open Question

                                                                                                                                                        持续一致性度量

                                                                                                                                                        Derived + Open Research

                                                                                                                                                        已有候选定义和信号,缺实践数据验证

                                                                                                                                                        开放问题不是附录里的免责条款,而是理论演进的一部分。Reality Model 如何形式化,知识可信度如何计算、运行时最小接口如何冻结、记忆如何遗忘、多 Agent 如何分责、反馈如何成为验证证据,都需要继续通过 RFC 和参考实践收敛。

                                                                                                                                                        11

                                                                                                                                                        实践:用 KDC Architecture Canvas 

                                                                                                                                                        做一次架构评审

                                                                                                                                                        选择一个现有或拟建设的 AI 业务流程,邀请业务 Owner、架构、AI、数据、安全和运维相关人员共同完成一次评审。

                                                                                                                                                        Canvas 不需要先画成复杂图,可以从下面八个区域开始:

                                                                                                                                                        区域

                                                                                                                                                        核心问题

                                                                                                                                                        最小产物

                                                                                                                                                        Reality

                                                                                                                                                        系统面对什么现实,成功如何验证?

                                                                                                                                                        Reality Map

                                                                                                                                                        Representation

                                                                                                                                                        当前通过什么数据、文档、事件观察现实?

                                                                                                                                                        表示与观察来源清单

                                                                                                                                                        Knowledge

                                                                                                                                                        哪些认知会被重复用于重要判断?

                                                                                                                                                        Knowledge Cards

                                                                                                                                                        Memory

                                                                                                                                                        哪些历史可以影响未来,何时失效?

                                                                                                                                                        记忆类型和生命周期规则

                                                                                                                                                        Reasoning

                                                                                                                                                        哪些高影响判断必须可审计?

                                                                                                                                                        Reasoning / Action Records

                                                                                                                                                        Skill

                                                                                                                                                        哪些目标级流程值得复用?

                                                                                                                                                        Skill 边界、前置条件和失败策略

                                                                                                                                                        Capability & Governance

                                                                                                                                                        哪些行动影响现实,如何授权和控制?

                                                                                                                                                        能力清单与治理缺口

                                                                                                                                                        Feedback & Consistency

                                                                                                                                                        什么结果关闭闭环,错误如何归因?

                                                                                                                                                        Feedback Contracts 与最小信号

                                                                                                                                                        评审时依次检查:

                                                                                                                                                        1. 是否把数据库状态误当作现实结果?

                                                                                                                                                        2. 是否把文件、向量或 RAG 片段直接当作已验证知识?

                                                                                                                                                        3. 是否存在无法说明依据的高影响判断?

                                                                                                                                                        4. Skill 是否明确目标、边界和失败路径?

                                                                                                                                                        5. 重要 Tool 是否缺少 Capability 语义、Owner 和风险等级?

                                                                                                                                                        6. 关键治理是否只存在于 Prompt 或人工默契中?

                                                                                                                                                        7. 接口成功后是否缺少现实反馈?

                                                                                                                                                        8. 日志能否支持知识、记忆、推理、能力和治理之间的错误归因?

                                                                                                                                                        9. 当前流程真的需要完整 KDC,还是只补一两个高风险缺口即可?

                                                                                                                                                        最终不要产出一份宏大平台路线图,而是选择一个最重要、最可验证的缺口。

                                                                                                                                                        比如:先让退款能力必须绑定用户确认和推理对象。先让当前政策拥有稳定版本与有效期。先让到账反馈能够关联到原能力调用。完成一个闭环后,再决定是否需要抽象为共享运行时能力。

                                                                                                                                                        KDC Architecture Canvas 的目标不是证明系统"符合 KDC",而是帮助团队发现:哪些过去隐含的责任,已经因为 AI 参与判断和行动而必须显式化。

                                                                                                                                                        12

                                                                                                                                                        KDC 试图建立的是

                                                                                                                                                        一条可以被质疑的工程闭环

                                                                                                                                                        AI 时代的软件工程不会抛弃代码、数据库、API、工作流和既有治理体系。KDC 的判断是:当模型能够理解上下文、形成判断并参与现实行动后,软件工程还需要显式管理知识、记忆、推理、技能、能力、治理和反馈。

                                                                                                                                                        完整链路可以再次压缩为:

                                                                                                                                                          面对现实
                                                                                                                                                            -> 形成可靠认知
                                                                                                                                                            -> 产生可审计判断
                                                                                                                                                            -> 组织目标级技能
                                                                                                                                                            -> 通过受治理能力行动
                                                                                                                                                            -> 用现实反馈持续校正

                                                                                                                                                          对象化让关键责任可以被引用,运行时化让对象能够持续工作,治理化让行动边界不依赖模型自律。三者共同服务同一个目标:让 AI 应用软件从一次性演示走向长期生产系统。

                                                                                                                                                          KDC 当前仍是一套开放理论提案。它需要更多真实系统验证,需要与既有理论进行严格比较,也需要允许反例推翻或修正当前抽象。完整并不意味着成熟,连贯也不意味着正确。

                                                                                                                                                          我们真正希望保留的,不是每一个当前术语,而是这组工程问题:

                                                                                                                                                          系统面对什么现实,依据什么知识,记住了什么,如何形成判断,怎样围绕目标组织技能,通过什么能力行动,谁来治理,以及如何从反馈中修正自己?

                                                                                                                                                          当一个 AI 系统能够稳定回答这些问题,它才开始具备理解现实、参与行动并承担长期工程责任的基础。

                                                                                                                                                          13

                                                                                                                                                          理论边界与开放问题

                                                                                                                                                          本文是 KDC 完整模型的公开叙事版本,不是已冻结的架构规范。Reality、知识定义、对象模型主要属于 Derived。完整运行时、企业知识库、自主 Agent、记忆体系和持续一致性度量仍包含 Hypothesis 或 Open Research。KDC 不替代 DDD、RAG、MCP、Agent Framework、API 

                                                                                                                                                          Gateway、IAM、Policy Engine 或 Open-

                                                                                                                                                          Telemetry。

                                                                                                                                                          版权声明: 本文采用 CC BY-NC-ND 4.0(署名-非商业性使用-禁止演绎) 许可协议。转载请注明出处。

                                                                                                                                                          END

                                                                                                                                                          跳转微信打开

                                                                                                                                                          拥抱 Rust 开源生态 | vivo 积极支持并参与 RustChinaConf 2026

                                                                                                                                                          2026年10月28日 20:00

                                                                                                                                                          vivo 开源 2026-10-28 20:00 广东

                                                                                                                                                          用实际行动传递 vivo 对开源社区及 Rust 生态的参与和积极贡献。

                                                                                                                                                          2026年10月15日至17日,RustChinaConf 2026 在深圳南山伊顿酒店与 GOSIM 会议同场举行,vivo 作为钻石赞助商积极支持并深度参与了本次会议。

                                                                                                                                                          RustChinaConf 是面向 Rust 开发者与生态的技术大会,Rust 正在成为系统开发与 AI 工程的务实基础:从高效推理、可靠工具链,到将模型安全带入生产级服务。

                                                                                                                                                          本次会议以“ Rust 与 AI ” 为主题,设有 Rust for AI、AI for Rust、Rust in Production 三大并行分论坛。

                                                                                                                                                          vivo 积极拥抱 Rust 与开源生态

                                                                                                                                                          首日的 Rust 主会场上,vivo OSPO 代表及研发总监杨振涛做了题为《拥抱 Rust 与开源生态,加速开放式创新》的赞助商致辞,面向参会者与开发者传递了 vivo 对 Rust 生态、开源协作和开放创新的持续投入,以蓝河操作系统BlueOS为例展示了 vivo 参与开源生态建设的理念与具体实践。

                                                                                                                                                          随后, vivo 系统研发总监贺程带来了主题演讲《Rust × AI:vivo 蓝河操作系统技术架构创新与实践》。vivo 自2019年起基于 Rust 研发蓝河操作系统。本次演讲系统地介绍了蓝河全栈 Rust 落地的架构思路与工程经验,涵盖内核兼容层、Harness 与所有权驱动的生命周期管理、多媒体与相机框架、Rust UI 框架及超大规模编译构建,并分享仍待解决的挑战,探讨 AI 时代操作系统研发的新模式。

                                                                                                                                                          vivo展台体验:

                                                                                                                                                          体验最新软硬件产品 & 挑战 Rust 游戏

                                                                                                                                                          大会期间,vivo 展台设置了两大体验区:

                                                                                                                                                          产品体验

                                                                                                                                                          体验最新 vivo 软硬件产品,包括 vivo x500系列手机、搭载蓝河操作系统BlueOS的智能手表等,并与参会者面对面交流 Rust 与 AI 如何助力产品功能与体验交付。

                                                                                                                                                          游戏挑战

                                                                                                                                                          Rust 与蓝河操作系统答题挑战, Rust 关键词冲刺游戏,会议期间累计吸引了数百人次的参与。

                                                                                                                                                          现场参与者热情高涨,对于首次挑战分数不满意的开发者甚至找机会多次参与,只为进入榜单TOP10。下图是两类挑战的最终榜单,欢迎围观榜首的Rust大咖,也看看自己是否入围。

                                                                                                                                                          本次 RustChinaConf 大会 ,vivo 作为钻石赞助商支持并深度参与,用实际行动传递 vivo 对开源社区及 Rust 生态的参与和积极贡献。

                                                                                                                                                          未来,vivo 将持续参与开源生态建设,深耕 Rust 生态,通过社区共建、技术共享、赛事赋能等多元方式,推动基础软件领域的技术革新与生态繁荣,为产业的智能化转型注入持久动力。我们期待与更多伙伴和开发者一起共同拥抱 Rust 开源生态。

                                                                                                                                                          #  关于蓝河内核 BlueKernel

                                                                                                                                                          蓝河内核 BlueKernel  是由 vivo 基于 Rust 语言自研并面向行业开源的操作系统内核,是 vivo 蓝河操作系统的核心组成部分,具备安全、轻量、通用的核心特性。

                                                                                                                                                          安全

                                                                                                                                                          基于 Rust 语言自研的内核,Rust实现内核核心基础模块、标准库、系统调用等,从源头保障内存安全。

                                                                                                                                                          轻量

                                                                                                                                                          极低硬件资源需求,内核核心最小内存占用仅 13 KB,支持不同的内存管理算法,以更低的硬件成本满足各类终端产品的需求。

                                                                                                                                                          通用

                                                                                                                                                          低硬件资源支持多芯片架构 (ARM32、ARM64、RISCV32、RISCV64) 满足不同芯片平台需要,支持POSIX接口,兼容已有的软硬件生态。

                                                                                                                                                          #  关于 vivo开源

                                                                                                                                                          “拥抱开源,拥抱未来!”

                                                                                                                                                          vivo 基于开源软件生态,为全球 5 亿+ vivo 智能手机用户提供极致体验产品和智慧服务。

                                                                                                                                                          vivo 已加入 Linux 基金会、TODO Group、C2PA 等组织,持续加强与行业的开源交流和开放合作,并以切实行动参与贡献,推动开源软件生态的可持续发展。

                                                                                                                                                          【移动 OSS】

                                                                                                                                                          https://opensource.vivo.com

                                                                                                                                                          【互联网 OSS】

                                                                                                                                                          https://github.com/vivo 

                                                                                                                                                          【AI OSS】

                                                                                                                                                          https://github.com/vivo-ai-lab

                                                                                                                                                          【开源频道】@vivo互联网技术  #开源 

                                                                                                                                                          跳转微信打开

                                                                                                                                                          AAIF 深圳 1024 Meetup :如何把 Agent 带到真正的生产 | 活动回顾

                                                                                                                                                          2026年10月28日 20:00

                                                                                                                                                          vivo互联网技术 2026-10-28 20:00 广东

                                                                                                                                                          50多位开发者及3位讲师共同探讨了将 Agent 带到生产环境的工程挑战和实践经验。

                                                                                                                                                          2026年10月24日,AAIF 深圳 1024 Meetup 技术沙龙活动在莞深(河套)创新中心成功举行,来自大湾区的50多位开发者及3位讲师共同探讨了将 Agent 带到生产环境的工程挑战和实践经验。

                                                                                                                                                          一、活动介绍

                                                                                                                                                          活动最开始,由本次活动组织者 Chris YANG 向大家介绍了 AAIF 基金会及其托管的项目进展,并分享回顾了AAIF深圳社区上个月的首秀之夜活动,随后介绍了本次活动的整体议程。

                                                                                                                                                          AAIF(Agentic AI Foundation)是 Linux 基金会旗下的中立开源基金会,托管着 MCP、AGENTS.md 等一批 Agent 时代的开放协议与开源项目;AAIF 深圳是它在大湾区的本地社区,今年 9 月刚刚成立,致力于把构建 Agent 的开发者聚在一起。AAIF 官网 https://aaif.io 。

                                                                                                                                                          图:AAIF 开源项目清单(截止2026年10月)

                                                                                                                                                          了解更多 AAIF 项目详情 https://aaif.io/projects

                                                                                                                                                          二、技术分享

                                                                                                                                                          当 Agent 开始进入真实的生产环境调用工具、参与业务流程并执行长任务时,会面临怎么样的挑战?团队需要补齐哪些能力?本次活动围绕这一问题,带来3场主题分享。

                                                                                                                                                          知识驱动计算(KDC):不是术语,是生产级闭环

                                                                                                                                                          Agent 进入真实业务后,每一次工具调用都涉及行动依据、授权与责任。团队需要回答:

                                                                                                                                                          • 它依据什么知识采取行动?

                                                                                                                                                          • 谁允许它调用某项能力?

                                                                                                                                                          • 失败后如何回滚?

                                                                                                                                                          • 审计时如何还原过程?

                                                                                                                                                          围绕这些问题,来自 vivo 的肖博介绍了 KDC(Knowledge-Driven Computing,知识驱动计算)的工程思路,从“现实优先、表示、知识演化、能力作用、持续一致性”五条原理出发,讨论知识、记忆、推理、技能和能力五类工程对象,以及相应的运行时与能力控制平面。

                                                                                                                                                          在这套思路中:

                                                                                                                                                          • 知识需要明确身份、来源、证据和成熟度,避免未经验证的内容直接影响推理;

                                                                                                                                                          • 能力需要标明风险等级,并配置相应的控制机制;

                                                                                                                                                          • 验证需要结合预算、半衰期与失效模式持续进行,避免把一次验证当作永久信任。

                                                                                                                                                          这些设计将关注点延伸到了模型回答之外。对于高价值业务流程,团队既要关注任务能否完成,也需要解释行动依据、追溯执行过程,并将失败经验沉淀为可复用的组织知识。

                                                                                                                                                          现场的退款审批 Demo 进一步呈现了这些机制如何协同:以“退款要审批”为约束,串联能力注册、人工审批、记忆衰减与审计回放,让治理要求进入具体的执行流程。

                                                                                                                                                          业务流程改造,让 Agent 承担可验证的职责

                                                                                                                                                          当 Agent 参与企业工作,单个环节的自动化只是起点。更进一步的问题是:如何为它定义业务目标、连接上下游流程,并建立明确的验收与责任机制?

                                                                                                                                                          腾讯云 TVP、消费企业 CAIO 姚杨结合百果园、金粒门、擂饭等实业案例,讨论 Agent 如何逐步承担有目标、有上下文、可验证的业务职责,以及企业需要为此调整哪些流程与团队分工。

                                                                                                                                                          分享正提到,新媒体内容生产可以串联选题、封面、文案与发布,并支持多渠道分发;软件测试可以结合需求与代码生成测试用例,再依据代码覆盖率持续完善。这些实践关注多个环节如何协同,以及团队如何检查最终结果。

                                                                                                                                                          相应的角色分工也在变化:

                                                                                                                                                          • 产品经理需要定义 Agent 的目标与边界;

                                                                                                                                                          • 熟悉业务表格的同事可以参与语义层与知识整理;

                                                                                                                                                          • 研发和测试人员则需要承担工具管理、任务编排与结果验收等工作。

                                                                                                                                                          架构层面,分享介绍了记录层、决策层、交互层与大模型网关的组合,并以食品安全为例,讨论如何将问题发现前移到质量管理流程。

                                                                                                                                                          这些案例也带来了具体的落地提醒:

                                                                                                                                                          • 责任节点仍需落实到人;

                                                                                                                                                          • 先串通流程,再讨论平台;

                                                                                                                                                          • 优先选择结果可以验证的场景;

                                                                                                                                                          • 评估效率时,同时考虑适用条件、交付质量与人工复核成本。

                                                                                                                                                          现场展示的企业驾驶舱、员工智能体入口,以及人力行政、外贸询盘和地产案场分析等实践,也为这一议题提供了更多业务场景。

                                                                                                                                                          上下文管理,让经验在长任务中持续发挥作用

                                                                                                                                                          随着任务推进,Agent 需要处理的信息也在持续累积。

                                                                                                                                                          • 上下文过长会增加延迟与成本,并淹没关键信息;

                                                                                                                                                          • 上下文过短则容易丢失任务背景与历史经验。

                                                                                                                                                          因此,团队需要解决的不只是信息存储,还包括如何筛选、整理和更新信息,并在适当的时候交给 Agent 使用。

                                                                                                                                                          OceanBase 开源布道师郑晓峰分享了 Power Context 的设计思路。该方案从原始材料(source)出发,将信息整理为可复用的产物(artifact),包括原子记忆、经验、技能、用户画像和任务交接信息,再按任务需要组装上下文包。

                                                                                                                                                          这一过程通过后台触发机制蒸馏信息,减少原始内容的反复堆叠;借鉴 Git 的多版本管理方式保留变化记录;结合全文检索与向量检索寻找相关内容,并支持不同信息产物持续演进。

                                                                                                                                                          对于需要多轮执行、跨任务协作或中途交接的 Agent,上下文管理直接影响已有经验能否继续发挥作用。信息需要被整理、检索和更新,才能跟上任务与业务环境的变化。

                                                                                                                                                          vivo肖博分享

                                                                                                                                                          消费企业 CAIO 

                                                                                                                                                          姚杨分享

                                                                                                                                                          OceanBase 开源布道师郑晓峰分享

                                                                                                                                                          三、现场 Demo 展示

                                                                                                                                                          除了三场主题分享,五个现场 Demo 将讨论带到了可以运行、可以观察的系统中,覆盖检索与协作、浏览器操作、能力治理、本地分析和企业应用等方向:

                                                                                                                                                          Demo 1|周鹏:Agent Hub,现场开源

                                                                                                                                                          周鹏演示了自己开发的数据分析助手:用日常语言提问,它就能查数据、画图表、给结论,还能记住之前聊过的内容。演示的最后他当场宣布:这个项目从此刻起开源,任何人都可以免费使用和修改——这份现场原地开源的“仪式感”赢得了全场掌声。

                                                                                                                                                          Demo 2|李宇飞:1024 Agentic 夺旗赛游戏

                                                                                                                                                          李宇飞作为本次活动的联合组织者,特别为本次活动设计了一个闯关游戏(类CTF):一共七层关卡,但页面上找不到任何可见按钮——入口全藏在网页背后的代码和数据里。人类玩家束手无策,AI Agent 却能读懂这些“幕后信息”一路通关,现场只用几分钟就走完全程。设计者还留了个小心思:最后一关必须真人验证,奖品得亲手领。

                                                                                                                                                          Demo 3|肖博:KDC

                                                                                                                                                          本次活动的分享嘉宾肖博,为他分享的 KDC 知识计算概念提供了现场实战演示,一笔退款申请自动触发人工审批,每一步操作都留下可追溯的记录。概念停留在 PPT 上是遥远的,这个演示让参会者直观地感受到了 KDC 的真实落地。

                                                                                                                                                          Demo 4|谭智源:Mica Excel

                                                                                                                                                          谭智源带来的 Mica 专为“懂 Excel 但不懂代码”的人设计。他把一份财报文件拖进软件,剩下的全部交给 AI:识别数据、搭建估值模型、核对账目平衡,几分钟就交出了完整结果。更贴心的是,所有数据都只存在自己的电脑上,不上传云端。

                                                                                                                                                          Demo 5|Steven:FDE 事务所

                                                                                                                                                          Steven 一口气展示了五个真实交付的企业案例:老板手机上每十分钟更新一次的经营看板、员工按岗位使用的统一 AI 入口、没有采购现成软件而用 AI 直接搭建的人力系统、自动给外贸询盘分级的客服助手、给售楼处沟通录音打分的质检工具。这些案例背后是同一个思路——企业不必自己组建 AI 团队,把需求交给“事务所”,由它对最终结果负责。

                                                                                                                                                          四、1024 特别策划

                                                                                                                                                          现场技术分享与Demo 展示外,中场茶歇时还安排了抽奖、大合影、合作伙伴展台互动。特别是由 vivo 互联网技术 支持的 1024 定制蛋糕,为这个特别的节日填足了仪式感。这一特别策划,也在 AAIF 全球社区赢得了点赞,展现了大湾区 Agentic AI 生态开发者的创意和社区活力。

                                                                                                                                                          图:AAIF深圳 1024 定制蛋糕

                                                                                                                                                          #  关于 AAIF & AAIF 深圳社区

                                                                                                                                                          Agentic AI 基金会(AAIF)是隶属于 Linux 基金会的一个中立、开放的基金会,致力于托管面向代理式人工智能的开放协议和开源项目,包括模型上下文协议(MCP)、goose、AGENTS.md、Agent2Agent(A2A)、 agentgateway 和 Agent Router,以及最近刚刚新增的 Agent Skills、OpenResponse、OpenEnv 和 OpenSandbox。

                                                                                                                                                          AAIF 致力于在创新与责任之间寻求平衡。我们汇聚行业和研究领域的领军人物,共同制定框架、标准和合作模式,引领智能人工智能的发展。

                                                                                                                                                          AAIF 深圳是AAIF全球社区的一部分,于2026年9月申请成立并通过组织本地活动等发展本地社区,致力于凝聚大湾区的 Agentic AI 开发者、构建者、研究者等,促进 Agentic AI 知识技能和开放生态实践经验的分享交流。

                                                                                                                                                          (扫码加入)

                                                                                                                                                          跳转微信打开

                                                                                                                                                          域名埋点零侵入实时校验实践:基于代理转发与规则驱动的工具设计

                                                                                                                                                          2026年10月21日 20:00

                                                                                                                                                          原创 互联网前端团队 2026-10-21 20:00 广东

                                                                                                                                                          Flyheart Monitor,一套零侵入的域名埋点实时校验工具。

                                                                                                                                                          作者:vivo 互联网前端团队- Zhu Qinchuan

                                                                                                                                                          目录

                                                                                                                                                          01. 埋点测试的痛点

                                                                                                                                                          02. Flyheart Monitor 简介

                                                                                                                                                          03. Flyheart Monitor 的三个巧思

                                                                                                                                                          04. AI 辅助:把录入规则这件苦差事交给机器

                                                                                                                                                          05. 结语 & 未来展望

                                                                                                                                                          埋点是数据驱动的地基,成熟平台大多自带可视化测试后台,但仍有大量项目用的是没有配套后台的域名埋点,测试只能靠"抓包+肉眼比对"。自建后台要侵入业务代码,代价太高。本文介绍 Flyheart Monitor,一套零侵入的域名埋点实时校验工具:它不在 H5 页面端主动上报,而是在请求的必经之路上拦截一份数据去校验,且不绑定任何特定抓包代理(只要支持接口转发即可接入)。文章聚焦几个解决实际问题的巧思:把抓包请求变成实时数据流、用规则代替人脑校验、把验证结果沉淀为可归档的图片。

                                                                                                                                                          1分钟看图掌握核心要点👇

                                                                                                                                                          01

                                                                                                                                                          埋点测试的痛点

                                                                                                                                                          埋点是数据驱动的地基。数据分析、AB 实验、广告归因、用户增长,几乎所有下游决策都建立在埋点数据之上。一旦埋点漏报或错报,下游数据会全线失真,而这种失真往往在几周后才被发现,代价高昂。

                                                                                                                                                          正因如此,埋点上线前的测试至关重要。不过,受历史遗留问题、项目优先级等因素影响,部分项目在这一环节积累了技术债务,测试工作仍主要依靠人工完成:手机连上抓包代理(比如 Charles),操作页面触发埋点,然后在代理工具的请求列表里逐条查找,找到目标埋点后,仔细核对参数是否齐全、类型是否正确。

                                                                                                                                                          这套流程有几个绕不开的问题:

                                                                                                                                                          1. 定位困难:埋点请求淹没在海量网络请求中,靠肉眼逐条查找既慢又累

                                                                                                                                                          2. 容易漏报:一次操作可能触发多个埋点,事件密集时人工很难覆盖全部

                                                                                                                                                          3. 校验繁琐:某个参数该是字符串还是数字、必填项是否缺失,全凭测试人员逐字判断,稍一分心就会看漏

                                                                                                                                                          4. 交付低效:验证结果需要人工对每个埋点、每种场景逐一截图,整理后再传递给下游,心智负担重

                                                                                                                                                          这些问题的根源,是埋点测试缺少一个"把请求、规则、校验结果三者串起来"的工具。测试人员既充当抓包器,又充当规则库,又充当校验引擎,全靠人脑串联。

                                                                                                                                                          常见解法:带测试后台的埋点平台

                                                                                                                                                          面对这类痛点,业界成熟的思路是让埋点平台自带一个可视化的埋点测试后台 ——集中维护埋点规范、实时接收上报数据、自动比对校验,规则、上报、校验一站式打通。对于已经接入这类平台的项目来说,埋点测试早已不再是难题。

                                                                                                                                                          现实困境:大量项目仍在用域名埋点

                                                                                                                                                          理想虽好,现实却存在一个绕不开的前提。公司内有许多项目使用的是域名埋点,这类埋点方式没有上述配套的测试后台:埋点规范通常只记录在文档中,上报的数据也缺少一个能实时接收并自动校验的系统。因此,测试人员在面对这些项目时,往往只能回到最基础的方式——抓包,再逐条用肉眼比对。

                                                                                                                                                          于是一个自然的想法浮现出来:既然域名埋点没有测试后台,能不能自己为它补一个?

                                                                                                                                                          自建后台的代价:侵入业务代码

                                                                                                                                                          从技术上讲,自建一个埋点测试后台完全可行。但真正动手时会发现,最大的障碍不在后台本身,而在"数据怎么进后台"这一步。

                                                                                                                                                          要让后台能校验,就得让 H5 页面在上报埋点的同时,额外向这个后台再报一份数据。这意味着必须修改业务代码:接入一套新的上报 SDK、修改现有的埋点上报逻辑,甚至对全量埋点点位做一遍改造。对于这些已经稳定运行、点位众多的老项目来说,这样的侵入式改造成本高、回归风险大,还需要协调各个业务方配合排期——投入与产出很难成正比。

                                                                                                                                                          有没有更优雅的办法?

                                                                                                                                                          于是问题就变成了:有没有一种方案,既能实时校验埋点,又完全不碰业务代码?

                                                                                                                                                          自建后台之所以要侵入业务代码,症结在于"让 H5 页面主动把数据多报一份给后台"。如果把这个方向反过来,问题就迎刃而解了:数据无需主动上报,而是在它上报的必经之路上被拦截下来。H5 页面的埋点请求本来就要发往网络,只需在链路中间拦截一次、复制一份拿去校验,业务代码一行都不用改。Flyheart Monitor 正是沿着这个思路诞生的——让机器负责抓取和校验,让人只负责看结论。

                                                                                                                                                          02

                                                                                                                                                          Flyheart Monitor 简介

                                                                                                                                                          用一句话概括:Flyheart Monitor 是一套面向 H5 页面的域名埋点抓包与参数校验工具。它把 H5 页面上报的埋点请求实时"喂"到浏览器页面上,并根据预先配置的测试计划自动校验参数是否合规。

                                                                                                                                                          这里要特别强调一个定位:这套工具并不与 Charles 绑定。它对抓包代理的唯一要求,是代理能提供"接口转发/重定向"这个通用能力——这几乎是所有主流抓包代理的标配功能,手边惯用的任意一款支持接口转发的代理都可以搭配使用。下文选择以 Charles 举例,只是因为它在移动端测试中较为常见。

                                                                                                                                                          整体数据流非常直白——请求从手机出发,经过一次代理拦截、一次转发、一次广播,最终落到浏览器上被校验和展示:

                                                                                                                                                            手机 App
                                                                                                                                                              → 抓包代理(Charles / Fiddler / Whistle 等,拦截 HTTPS 流量)
                                                                                                                                                              → 接口转发/重定向到 http://localhost:9999/webhook
                                                                                                                                                              → node-forwarder(HTTP 接收 + WebSocket 广播)
                                                                                                                                                              → ws://localhost:8765
                                                                                                                                                              → 浏览器页面实时展示 + 参数校验

                                                                                                                                                            整个系统只有两个轻量模块,技术选型也刻意保持简单:

                                                                                                                                                            模块

                                                                                                                                                            定位

                                                                                                                                                            技术选型

                                                                                                                                                            node-forwarder

                                                                                                                                                            HTTP Webhook 接收 + WebSocket 广播

                                                                                                                                                            Node.js 18+ / ws

                                                                                                                                                            web

                                                                                                                                                            实时监控与校验前端

                                                                                                                                                            Vue 3 + Vite 6

                                                                                                                                                            抓包链路

                                                                                                                                                            HTTPS 流量拦截与接口转发

                                                                                                                                                            任意支持转发的代理

                                                                                                                                                            (Charles/Fiddler/Whistle…)

                                                                                                                                                            值得一提的是,这套工具没有引入任何重量级的后端框架、数据库或消息队列。node-forwarder 是一个不到三百行的原生 Node.js 脚本,前端是一个纯静态的 Vue 应用。这种"轻"是刻意的——它要能让测试人员在自己的电脑上一分钟内启动(后面还会看到,我们甚至把它打包成了双击即用的可执行文件),而不是依赖一套需要运维的服务。真正的价值不在架构的复杂度,而在于对几个具体问题的处理方式。下面几章就来拆解这些巧思。

                                                                                                                                                            03

                                                                                                                                                            Flyheart Monitor 的三个巧思

                                                                                                                                                            3.1 把抓包请求变成一条实时数据流

                                                                                                                                                            这套工具对抓包代理的要求,简单到只有一条:把目标埋点接口的请求整体转发/重定向到本地的一个 webhook 地址。这样一来,页面每次上报埋点,请求就会自动流向本地服务,形成一个天然的拦截入口,测试人员不需要在代理里做任何逐条的手动操作。

                                                                                                                                                            正因为只依赖"接口转发"这个所有主流代理都具备的基础能力,工具才没有与某一款代理绑定——Charles 里叫 Map Remote,Fiddler 里是重定向规则,Whistle 里是转发规则,配置方式不同,能力本质一样。测试人员用哪款顺手就用哪款,一行转发规则即可接入。

                                                                                                                                                            接口转发解决了"请求从哪里来"的问题,node-forwarder 则负责"请求怎么到浏览器"。它的设计很紧凑——同一个进程里同时运行着两套服务:HTTP 服务监听 9999 端口的 /webhook 接收代理转发的请求,WebSocket 服务监听 8765 端口向所有已连接的浏览器页面实时广播。这条"HTTP 进、WebSocket 出"的链路,就是把静态的抓包动作变成一条实时数据流的核心。

                                                                                                                                                            这里有个容易被忽略的细节:埋点上报的请求体格式多种多样,有的是 JSON,有的是 URL 编码表单,还有的是纯文本。为此,工具采用了一套逐层兜底的解析策略——先尝试 JSON 解析,失败则尝试表单解析,再失败就原样包装成文本。这样一来,无论 H5 页面用什么格式上报,请求都不会因解析失败而丢失。

                                                                                                                                                              function parsePayload(bodyText, contentType){
                                                                                                                                                                if (!bodyText) return {}
                                                                                                                                                                // 尝试 JSON 解析
                                                                                                                                                                try {
                                                                                                                                                                  return JSON.parse(bodyText)
                                                                                                                                                                } catch (_) {}
                                                                                                                                                                // 尝试 URL 编码表单解析(只要内容包含 = 就尝试)
                                                                                                                                                                if (bodyText.includes('=')) {
                                                                                                                                                                  try {
                                                                                                                                                                    const formPayload = {}
                                                                                                                                                                    const params = new URLSearchParams(bodyText)
                                                                                                                                                                    for (const [key, value] of params.entries()) {
                                                                                                                                                                      formPayload[key] = value
                                                                                                                                                                    }
                                                                                                                                                                    if (Object.keys(formPayload).length > 0) return formPayload
                                                                                                                                                                  } catch (_) {}
                                                                                                                                                                }
                                                                                                                                                                // 兜底:原始文本
                                                                                                                                                                return { raw_data: bodyText }
                                                                                                                                                              }
                                                                                                                                                              • 多台设备并行测试时,请求列表里全是相同的埋点,难以区分来源。工具通过 User-Agent 调用内部服务,把难以辨认的 UA 字符串翻译成"iQOO 13"这样的机型名称展示在请求上,并用 Map 缓存避免重复查询。前端因此能按机型维度筛选请求,在多设备回归测试时尤为实用。

                                                                                                                                                              此外,前端支持通过 URL 参数指定服务地址(?ws=电脑IP:8765),让工具由单人使用扩展为团队共享;WebSocket 断线后每 3 秒自动重连,连接状态实时显示在页面顶部。

                                                                                                                                                              最后还有一个面向非开发用户的务实设计:借助 pkg 把 node-forwarder 连同 Node 运行时、依赖一起打包成单个可执行文件,分别产出 macOS arm64、macOS x64 和 Windows 三个平台的版本。测试人员双击即可启动,无需预装任何环境。

                                                                                                                                                              3.2 用规则把"人脑校验"变成"自动校验"

                                                                                                                                                              抓包请求实时流进来只是第一步。真正把测试人员从"肉眼比对"中解放出来的,是一套规则驱动的校验机制。

                                                                                                                                                              工具的测试计划模型非常克制,只有两个核心概念:

                                                                                                                                                              • cfrom:埋点事件的 ID,作为请求和规则之间的匹配键。每条上报请求都带 cfrom,每条规则也绑定一个 cfrom,两者一对上就能关联起来。

                                                                                                                                                              • coreParams:一组参数声明,每项包含 name(参数名)、type(类型)、desc(描述)。它本质上是在声明"这个埋点应该有哪些参数、每个参数是什么类型"。

                                                                                                                                                              请求进来后,会按 cfrom 自动分组存储——同一个埋点的所有历史请求聚在一起,天然形成"一个埋点一档案"的结构。测试人员点开某条规则,就能看到这个埋点收到过的全部请求。

                                                                                                                                                              一份测试计划就是一个规则数组,结构如下:

                                                                                                                                                                [
                                                                                                                                                                  {
                                                                                                                                                                    "ruleName": "首页 Banner 点击",
                                                                                                                                                                    "cfrom": "01|03|029|008",
                                                                                                                                                                    "coreParams": [
                                                                                                                                                                      { "name": "series", "type": "string", "desc": "系列编码" },
                                                                                                                                                                      { "name": "position", "type": "number", "desc": "位置序号" }
                                                                                                                                                                    ]
                                                                                                                                                                  }
                                                                                                                                                                ]

                                                                                                                                                                有了声明式的规则,校验逻辑就变得很直接。对每条收到的请求,逐个检查其 coreParams:参数是否缺失?值的类型是否正确(字符串、数字、布尔、数组、对象)?

                                                                                                                                                                  export function validatePayload(payload, coreParams){
                                                                                                                                                                    const errors = []
                                                                                                                                                                    for (const param of coreParams) {
                                                                                                                                                                      const val = payload[param.name]
                                                                                                                                                                      if (val === undefined || val === null || val === '') {
                                                                                                                                                                        errors.push(`缺少参数 ${param.name}`)
                                                                                                                                                                        continue
                                                                                                                                                                      }
                                                                                                                                                                      const actualType = Array.isArray(val) ? 'array' : typeof val
                                                                                                                                                                      if (actualType !== param.type) {
                                                                                                                                                                        errors.push(`${param.name} 应为 ${param.type},实际为 ${actualType}`)
                                                                                                                                                                      }
                                                                                                                                                                    }
                                                                                                                                                                    return { status: errors.length ? 'fail' : 'pass', errors }
                                                                                                                                                                  }

                                                                                                                                                                  校验结果被直观地转化为视觉信号。点开请求详情,JSON 会高亮展示:类型不匹配的字段直接标红并加波浪下划线,鼠标悬停还能看到"预期类型"的提示。对存在类型异常的请求,列表上会显示一个跳动的"⚠️ 参数类型异常"脉冲标记,让问题请求在一堆正常请求里一眼可辨。

                                                                                                                                                                  从"逐字比对每个字段"到"扫一眼有没有红点",这就是规则化校验带来的效率跃迁。

                                                                                                                                                                  工具还有一个反向发现的设计值得一提:收到请求但 cfrom 不在测试计划中的埋点,会被单独归入"未匹配规则"分组,用醒目的黄色标记出来。这让测试人员能反向发现"多报""错报"这类问题——它们在传统的逐条核对模式下极易被忽略,因为人往往只会关注计划之内的埋点。

                                                                                                                                                                  当请求量增大,快速定位就成了刚需。工具提供了多个维度的筛选:按规则名称筛选、点击 cfrom 标签快速过滤、关键词搜索、按机型/UA 筛选设备、请求按时间正序或倒序排列。这些筛选组合起来,测试人员能在几秒内定位到目标请求。

                                                                                                                                                                  3.3 把"验证通过"沉淀成一张图

                                                                                                                                                                  测试做完,还有最后一步——如何把结果交付给开发和产品?传统做法是截取大量图片、配上文字说明,既零散又难以归档。

                                                                                                                                                                  工具内置了一个 Canvas 宫格图导出功能。测试人员在请求详情里勾选若干条请求,点击"宫格图预览",程序就用 Canvas 把这些请求拼接成一张排版整齐的宫格截图,确认无误后一键下载成 PNG。

                                                                                                                                                                  为什么不直接用浏览器截图或 DOM 转图片的现成方案?因为那些方案要么受限于可视区域(长列表截不全),要么依赖页面当前样式(导出的图会带上一堆无关的 UI 元素)。这里选择用 Canvas 逐像素重新绘制,好处是完全掌控排版——绘制哪些内容、如何布局、清晰度多高,都可以自主决定。

                                                                                                                                                                  这张图不是简单的页面截屏,而是专门为"汇报"重新排版的成果。它的绘制过程藏着几个值得一提的细节。

                                                                                                                                                                  先测量尺寸,再正式绘制。 Canvas 在绘制文本前并不知道一段文字最终会占据多少高度,而每条请求的参数数量不一,格子高度必须动态计算。这里的做法是先用一个离屏 Canvas 对每条请求的内容逐行测量文本宽度、算出换行后的总行数,得到每个格子的真实高度,再据此规划整张图的布局。宫格的行列数按请求数量开平方自动决定,尽量接近正方形;每一行的高度取该行最高格子的高度,保证对齐整齐。

                                                                                                                                                                    // 离屏量算换行后高度
                                                                                                                                                                    const mCanvas = document.createElement('canvas')
                                                                                                                                                                    const mCtx = mCanvas.getContext('2d')


                                                                                                                                                                    const cellData = reqs.map((req, idx) => {
                                                                                                                                                                      const { deviceLabel, timeLabel, rows } = buildRows(req, idx)
                                                                                                                                                                      const expanded = []
                                                                                                                                                                      for (const row of rows) {
                                                                                                                                                                        setFont(mCtx, row.type)
                                                                                                                                                                        // 逐行量算,超宽则自动换行
                                                                                                                                                                        wrapLine(mCtx, row.text, MAX_TEXT_W).forEach((t, wi) =>
                                                                                                                                                                          expanded.push({ text: t, type: wi === 0 ? row.type : 'kv', isError: row.isError })
                                                                                                                                                                        )
                                                                                                                                                                      }
                                                                                                                                                                      const contentH = expanded.reduce((s, r) => s + LINE_HEIGHT, 0)
                                                                                                                                                                      return { deviceLabel, timeLabel, expanded, cellH: TITLE_H + PADDING + contentH + PADDING }
                                                                                                                                                                    })


                                                                                                                                                                    // 行列数按数量开平方,尽量接近正方形
                                                                                                                                                                    const COLS = Math.ceil(Math.sqrt(cellData.length))
                                                                                                                                                                    const ROWS = Math.ceil(cellData.length / COLS)

                                                                                                                                                                    为高清屏而绘。 直接按逻辑尺寸绘制,导出的图在高分屏上会显得模糊。工具取设备像素比(且不低于 2)放大 Canvas 的物理尺寸,再对绘图上下文做等比缩放。这样绘制逻辑仍按逻辑坐标编写,产出的却是一张分辨率翻倍的高清图,放大查看参数值也依然清晰。

                                                                                                                                                                      const DPR = Math.max(window.devicePixelRatio || 1, 2)
                                                                                                                                                                      canvas.width = logicW * DPR
                                                                                                                                                                      canvas.height = logicH * DPR
                                                                                                                                                                      const ctx = canvas.getContext('2d')
                                                                                                                                                                      ctx.scale(DPR, DPR)

                                                                                                                                                                      综合下来,这张宫格图具备以下几个特点:

                                                                                                                                                                      • 高清渲染:按设备像素比做 HiDPI 渲染,图片放大也不模糊

                                                                                                                                                                      • 自动换行:长参数值会先测量宽度再逐字换行,不会溢出格子

                                                                                                                                                                      • 分组展示:每个格子里,"关注参数"和"其他参数"分区展示,并按 key 排序,一目了然

                                                                                                                                                                      • 异常标红:类型不匹配的字段在图里绘上红色底色和红字,与页面上的校验结果保持一致

                                                                                                                                                                      • 信息完整:每格顶部带机型名称、序号(第几条)和精确到秒的时间戳,可追溯

                                                                                                                                                                      值得一提的是,导出流程被拆成了"预览"和"下载"两步——点击后先弹出预览,让用户确认排版和内容,满意后再下载。这就避免了"直接存成文件、发现排版不对又要重来"的返工。

                                                                                                                                                                      这样一来,"验证通过"就从一句口头描述,变成了一张信息完整、清晰可读、可直接归档进测试报告的图片凭证。一个看似不起眼的导出功能,实际上补齐了埋点测试"验证—汇报"闭环的最后一环。

                                                                                                                                                                      04

                                                                                                                                                                      AI 辅助:把录入规则这件苦差事交给机器

                                                                                                                                                                      前面三个巧思构成了工具的主干。在此之上,还有一处锦上添花的效率优化值得一提。

                                                                                                                                                                      配置测试计划有一项隐藏的体力活:埋点详情通常整理在 Excel 中,要把它们逐条录入成规则,既枯燥又容易出错。为此,工具提供了一个 AI 辅助入口来简化这件事。

                                                                                                                                                                      用法很简单:把 Excel 里的埋点详情整段复制、粘贴到输入框,点击生成,AI 就会把它解析成规则 JSON。工程上有几个处理细节让体验更顺滑:

                                                                                                                                                                      • 流式响应:采用 SSE 边生成边预览,用户能实时看到规则逐条生成,而不必等待完整结果

                                                                                                                                                                      • 容错解析:AI 输出有时会夹带 Markdown 代码块标记,前端用正则把其中的 JSON 部分提取出来,避免解析失败

                                                                                                                                                                      • 状态提示:解析成功或失败有明确的标签提示,确认无误后一键应用到测试计划

                                                                                                                                                                      需要强调的是,AI 在这里只是一个"录入加速器",是锦上添花的辅助功能,而非平台的核心。它的价值在于省去重复的手工录入,真正解决测试痛点的仍然是前面那套抓包链路和规则校验机制。

                                                                                                                                                                      此外,规则还支持页面手动新增、导入/导出 config.json。导入时会做规则规范化处理——不管来源配置格式多么不规范(coreParams 缺字段、格式不标准),都会被统一整理成标准结构再入库。这让不同人、不同来源的测试计划都能顺畅导入,不会因格式差异报错。测试计划因此变成一份可复用、可版本化、可在团队间传递的资产,而不是每次测试都要从头配置的一次性文件。

                                                                                                                                                                      05

                                                                                                                                                                      结语 & 未来展望

                                                                                                                                                                      Flyheart Monitor 的架构并不复杂——两个轻量模块,几百行代码。它的核心思路也很简单:不改业务代码,只借助代理的接口转发能力在链路中间拦截一份数据,再通过规则自动比对。围绕这个思路,文章介绍了几个解决具体问题的设计,它们共同完成了一件事:把域名埋点的测试从"人工逐条肉眼核对"升级为"规则驱动的实时可视化校验"。测试人员不再需要同时充当抓包器、规则库和校验引擎,而是回归到只需要看结论、做判断的角色。

                                                                                                                                                                      目前这套工具还有一些可以继续打磨的方向:

                                                                                                                                                                      • 规则云端化:测试计划目前存储在浏览器本地,未来可以升级为服务端存储,支持团队共享与版本管理

                                                                                                                                                                      • 历史留存与回放:请求记录持久化,支持跨会话查询和回归对比

                                                                                                                                                                      • 自动化校验报告:一轮测试结束后自动生成通过率、异常清单等报告

                                                                                                                                                                      工具的意义,是把人从重复劳动中解放出来,把精力放到真正需要判断的地方。

                                                                                                                                                                      END

                                                                                                                                                                      跳转微信打开

                                                                                                                                                                      记忆不是存历史,而是治理未来行动|KDC 系列 04

                                                                                                                                                                      2026年10月21日 20:00

                                                                                                                                                                      互联网存储团队 2026-10-21 20:00 广东

                                                                                                                                                                      一次正确行动结束后,什么历史应该影响未来,又如何避免系统把偶然经验和错误反馈不断放大?

                                                                                                                                                                      作者:vivo 互联网存储团队 - Xiao Bo

                                                                                                                                                                      AI 合作者:ChatGPT(GPT-5.5)

                                                                                                                                                                      创作模式:Human-led, AI-collaborated

                                                                                                                                                                      责任声明:文章观点、理论体系及最终内容由作者负责;AI 参与讨论、推演、表达优化及部分内容生成。

                                                                                                                                                                      目录

                                                                                                                                                                      01. 单次正确,不等于长期可靠

                                                                                                                                                                      02. 常规 AI 记忆问检索什么,KDC 追问历史如何生效

                                                                                                                                                                      03. 不是所有历史都应该成为记忆对象

                                                                                                                                                                      04. 四类更接近行动治理的记忆

                                                                                                                                                                      05. 记忆必须有生命周期,也必须允许遗忘

                                                                                                                                                                      06. 反馈不只是奖励信号,也不是自动真值

                                                                                                                                                                      07. 持续一致性:让系统具备发现和修正偏差的条件

                                                                                                                                                                      08. 这不只是合规留痕,而是生产能力

                                                                                                                                                                      09. 与日志、Trace 和传统可观测的关系

                                                                                                                                                                      10. 实践:为一次重要行动建立 Feedback Contract

                                                                                                                                                                      11. 可靠系统不是记住一切,而是知道什么仍应影响现在

                                                                                                                                                                      12. 理论边界与开放问题

                                                                                                                                                                      记忆的价值不在于保存更多历史,而在于决定哪些历史仍然可以影响未来的判断与行动。本文把记忆放入形成、强化、衰减、冲突、遗忘、迁移和归档的生命周期,并进一步说明反馈验证与错误归因如何帮助系统修正知识、记忆、推理和治理策略。

                                                                                                                                                                      研究说明:知识驱动计算(Knowledge-driven Computing,KDC)是我们提出和正在打磨的一套 AI 应用软件工程理论,目前仍处于开放研究阶段。前三篇分别讨论了领域现实、知识边界以及从推理到受治理行动的链路。这一篇讨论长期运行问题:一次正确行动结束后,什么历史应该影响未来,又如何避免系统把偶然经验和错误反馈不断放大?

                                                                                                                                                                      1分钟看图掌握核心要点👇

                                                                                                                                                                      继续从一个案例开始。

                                                                                                                                                                      第一次处理退款时,Agent 做对了所有关键步骤。

                                                                                                                                                                      它确认用户只是咨询,说明了退款条件,等待用户明确同意后才发起退款。能力控制策略检查了订单状态、用户身份和风险等级,退款最终到账,用户也表示满意。

                                                                                                                                                                      系统把这次对话和执行结果写入长期记忆,并生成一条摘要:

                                                                                                                                                                      用户在符合条件时偏好直接退款,不需要过多解释。

                                                                                                                                                                      几周后,用户对另一笔订单说:

                                                                                                                                                                      这笔现在还能退吗?我只是先了解一下。

                                                                                                                                                                      记忆检索找到了上次的退款记录。Agent 将"上次选择退款"当作稳定偏好,减少解释步骤,并把这次咨询继续推进到退款确认流程。

                                                                                                                                                                      历史没有被记错。上一次,用户确实选择了退款。

                                                                                                                                                                      错误发生在另一处:系统把一次特定情景下的行动,泛化成了跨时间、跨订单的稳定偏好,并让它影响了新的行动。

                                                                                                                                                                      系统记住得更多,却不一定变得更可靠。

                                                                                                                                                                      01

                                                                                                                                                                      单次正确,不等于长期可靠

                                                                                                                                                                      我们很容易用单次任务评价 AI 系统:答案是否正确,Tool 是否调用成功,用户是否满意,流程是否完成。

                                                                                                                                                                      这些指标都重要,但生产系统面对的不是静止世界。订单状态会变化,制度会更新,用户偏好会改变,项目风险会演化,能力版本会替换,过去有效的经验也可能在新场景中失效。

                                                                                                                                                                      如果系统只处理当前输入,它会不断重复探索。如果系统无条件复用全部历史,它又会把旧经验强加给新现实。

                                                                                                                                                                      长期可靠性需要在两种失败之间找到边界:

                                                                                                                                                                        完全不记得过去
                                                                                                                                                                          <->
                                                                                                                                                                        让所有过去永久影响未来

                                                                                                                                                                        常见的"给 Agent 加记忆"通常从存储和检索出发:把历史对话写进向量库,在新任务开始时召回相似片段,再放进模型上下文。

                                                                                                                                                                        这解决了"怎样重新看到历史",却没有完整解决"历史是否应该影响当前行动"。

                                                                                                                                                                        KDC 研究记忆时,更关注后一个问题。

                                                                                                                                                                        02

                                                                                                                                                                        常规 AI 记忆问检索什么,KDC 追问历史如何生效

                                                                                                                                                                        可以用两个问题区分不同关注点。

                                                                                                                                                                        常规上下文记忆经常问:

                                                                                                                                                                          检索什么历史放进当前上下文?

                                                                                                                                                                          KDC 记忆运行时追问:

                                                                                                                                                                            哪段历史可以在什么条件下影响未来判断和行动?

                                                                                                                                                                            这个区别意味着,记忆不是"长期保存的文本"这么简单。

                                                                                                                                                                            一段历史要进入未来行动链路,至少需要回答:

                                                                                                                                                                            • 它是什么时候、在什么情景下形成的?

                                                                                                                                                                            • 它来自事实、用户表达、模型总结还是行动结果?

                                                                                                                                                                            • 它只适用于某次任务,还是可能跨场景复用?

                                                                                                                                                                            • 它被后续反馈支持过,还是只有一次偶然观察?

                                                                                                                                                                            • 它是否与新现实、新知识或新用户表达冲突?

                                                                                                                                                                            • 当前主体是否有权访问和使用它?

                                                                                                                                                                            • 它应该继续生效、降低影响,还是只用于历史解释?

                                                                                                                                                                            • 向量相似度可以帮助找到相关历史,却不能替系统回答这些治理问题。

                                                                                                                                                                            因此,KDC 把记忆对象(Memory Object)理解为带有时间、经验、上下文、反馈和演化状态的长期上下文对象。把记忆运行时(Memory Runtime)理解为负责记忆形成、检索、强化、冲突、衰减、遗忘、迁移和归档的一组运行时职责。

                                                                                                                                                                            这仍是当前阶段的理论提案。记忆分类、遗忘策略和组织级迁移尚未形成统一规范,但一个方向已经比较明确:记忆的核心不是保存更多历史,而是治理历史对未来的影响。

                                                                                                                                                                            03

                                                                                                                                                                            不是所有历史都应该成为记忆对象

                                                                                                                                                                            日志、聊天记录、执行结果和用户反馈都可以成为记忆来源,但不能因为被长期保存,就自动获得影响未来的资格。

                                                                                                                                                                            日志回答"发生了什么"。记忆对象还要回答"这段历史对未来理解和行动有什么意义"。

                                                                                                                                                                            举个例子:

                                                                                                                                                                            • refund_order 返回成功,是执行记录

                                                                                                                                                                            • 退款三天后到账,是行动结果

                                                                                                                                                                            • "该支付渠道在节假日退款通常需要更长时间",是在多次结果支持后可能形成的经验

                                                                                                                                                                            • "这个用户永远偏好退款",则可能是从单次行为中过度泛化出来的错误记忆

                                                                                                                                                                            记忆形成应该有门槛。一次偶然事件可以先形成候选记忆,保留来源和适用上下文,等待后续反馈。它不应因为被模型总结得很流畅,就直接成为稳定画像或组织经验。

                                                                                                                                                                            同样,模型输出也不能直接写成长期记忆。模型可以建议"这次交互可能反映用户更重视处理速度",但系统还需要区分这是一次情景判断、候选偏好,还是已经被多次行为验证的稳定倾向。

                                                                                                                                                                            04

                                                                                                                                                                            四类更接近行动治理的记忆

                                                                                                                                                                            为了让记忆讨论落到工程使用上,KDC 当前提出四类面向能力治理的候选记忆类型。

                                                                                                                                                                            4.1 行动-结果记忆

                                                                                                                                                                            记录某次能力调用、现实结果和错误归因。

                                                                                                                                                                            比如:退款能力被策略拒绝,因为订单已进入履约。退款接口返回成功,但对账显示到账延迟。某次外部通知因为权限配置错误发送失败。

                                                                                                                                                                            这类记忆直接影响未来能力选择和风险判断,通常时效较强。外部系统、政策和能力版本变化后,它可能快速失效。

                                                                                                                                                                            4.2 偏好或画像记忆

                                                                                                                                                                            记录用户、组织或 Agent 在一定范围内表现出的偏好和倾向。

                                                                                                                                                                            比如:用户在购买手机时更重视影像能力,某团队更偏好先小范围灰度,某审批人通常要求补充成本说明。

                                                                                                                                                                            偏好不是永久标签。它需要时间、场景和证据边界,也必须允许用户纠正、撤回和查看。一次行为通常只能形成候选偏好,不应直接覆盖明确表达。

                                                                                                                                                                            4.3 决策先例记忆

                                                                                                                                                                            记录相似目标下的历史决策、当时依据和后续结果。

                                                                                                                                                                            比如:某类高风险退款过去都进入人工复核。某种项目风险采用分阶段交付后得到缓解。某类故障通过降级而不是重试恢复。

                                                                                                                                                                            先例可以支持未来判断,但不能替代当前证据。多次跨场景验证的先例可能迁移为候选知识,迁移时仍要重新验证适用范围。

                                                                                                                                                                            4.4 情景记忆

                                                                                                                                                                            记录一次具体交互或任务的上下文,比如用户在上次对话中关注某款商品的续航,或某个项目会议中暂时搁置了一个方案。

                                                                                                                                                                            情景记忆最接近常见的对话记忆和向量检索。它有助于恢复上下文,却不应该被误认为已经形成稳定偏好或通用经验。

                                                                                                                                                                            这四类不是当前已经成熟的统一记忆分类,它们更像当前研究中用于区分治理方式的可建切片。前三类直接影响能力调用、风险和人工确认,情景记忆则更多服务上下文连续性。

                                                                                                                                                                            05

                                                                                                                                                                            记忆必须有生命周期,也必须允许遗忘

                                                                                                                                                                            如果记忆系统只支持写入和检索,它最终会被旧现实填满。

                                                                                                                                                                            KDC 记忆运行时至少需要考虑下面这些状态变化。

                                                                                                                                                                            5.1 形成

                                                                                                                                                                            从知识对象、推理对象、能力反馈、人工决策和业务事件中识别值得长期保留的上下文。形成不等于稳定生效,可以先作为候选记忆。

                                                                                                                                                                            5.2 强化

                                                                                                                                                                            多个独立反馈持续支持同一经验时,提高其可信度或扩大适用范围。强化不是简单增加命中次数,因为重复使用同一个错误来源,也可能只是重复放大错误。

                                                                                                                                                                            5.3 衰减

                                                                                                                                                                            随着时间过去、现实变化或长期缺少支持,降低记忆对未来推理的影响。支付渠道处理时间、促销偏好和项目状态往往需要较快衰减。稳定决策原则可能衰减较慢。

                                                                                                                                                                            5.4 冲突

                                                                                                                                                                            新行为、新知识或用户明确表达与旧记忆不一致时,显式标记冲突,而不是静默选择其中一条。开头的案例中,"我只是先了解一下"就是对"用户偏好直接退款"的当前约束,应该阻止旧记忆自动主导行动。

                                                                                                                                                                            5.5 遗忘

                                                                                                                                                                            让某段记忆停止参与当前判断和行动治理。遗忘不等于物理删除,它可以表现为降权、过期、限制上下文、要求重新验证或迁移到历史区。

                                                                                                                                                                            5.6 迁移

                                                                                                                                                                            把局部经验迁移到团队或组织范围,或者把多次稳定行动结果转化为候选知识。迁移不是复制,必须重新检查证据和适用边界。

                                                                                                                                                                            5.7 归档

                                                                                                                                                                            保留审计与历史解释价值,但不再让记忆影响当前行动。旧退款政策相关的历史经验可以帮助解释过去,却不应指导新订单。

                                                                                                                                                                            在长期 AI 系统中,遗忘不是缺陷,而是治理能力。真正危险的不是系统忘记一段无关历史,而是它无法停止让过期、越权或错误经验影响未来。

                                                                                                                                                                            图 4:历史如何成为记忆,以及何时停止影响未来

                                                                                                                                                                            06

                                                                                                                                                                            反馈不只是奖励信号,也不是自动真值

                                                                                                                                                                            行动完成后,系统可能收到多种反馈:

                                                                                                                                                                            • Tool 或 API 的执行结果

                                                                                                                                                                            • 外部系统状态变化

                                                                                                                                                                            • 用户确认、纠正、拒绝或投诉

                                                                                                                                                                            • 人工审批结果

                                                                                                                                                                            • 回滚、补偿和异常处理

                                                                                                                                                                            • 后续业务结果

                                                                                                                                                                            • 审计或复盘结论

                                                                                                                                                                            这些反馈的重要性不同,也可能相互矛盾。

                                                                                                                                                                            接口返回 success 说明执行请求被成功处理,但不一定证明用户收到退款。用户说"已经到账"是更接近现实结果的反馈,却仍可能存在误解或关联错误。对账系统确认资金完成,则提供另一类证据。

                                                                                                                                                                            因此,反馈进入系统时需要来源、时间、对象关联、可信度和适用范围。反馈不能绕过验证,直接把知识升级或把记忆强化。

                                                                                                                                                                            一个最小反馈处理链可以写成:

                                                                                                                                                                              执行结果或现实观察
                                                                                                                                                                                -> 关联到原目标、推理和能力
                                                                                                                                                                                -> 判断反馈来源与可信度
                                                                                                                                                                                -> 错误归因或结果验证
                                                                                                                                                                                -> 更新推理对象
                                                                                                                                                                                -> 形成候选记忆或候选知识
                                                                                                                                                                                -> 由对应运行时决定强化、降级或归档

                                                                                                                                                                              反馈可能改变系统的不同部分。

                                                                                                                                                                              如果退款没有到账是支付渠道故障,应该更新行动-结果记忆和能力质量摘要。如果系统引用了旧政策,应该让相关知识降级或过期。如果 Agent 把咨询误解为授权,应该修正目标解释和推理策略。如果治理策略本应拦截却没有拦截,则需要调整能力策略。

                                                                                                                                                                              没有错误归因,所有反馈都会被粗暴地归给"模型好不好"。系统也就无法知道究竟该改知识、记忆、推理、能力实现还是治理策略。

                                                                                                                                                                              07

                                                                                                                                                                              持续一致性:

                                                                                                                                                                              让系统具备发现和修正偏差的条件

                                                                                                                                                                              KDC 的长期目标不是让 AI 自动越用越聪明,而是让应用软件能够持续观察领域现实与数字系统之间的偏差,并保留修正偏差的工程路径。

                                                                                                                                                                              我们把这个方向称为持续一致性(Continuous Consistency)。它不是指任何时刻都达到绝对同步,而是指系统能够:

                                                                                                                                                                              • 知道自己覆盖了哪些现实、遗漏了哪些现实

                                                                                                                                                                              • 发现数字表示与现实观察不一致

                                                                                                                                                                              • 识别知识已经过期或发生漂移

                                                                                                                                                                              • 把行动结果与原判断重新关联

                                                                                                                                                                              • 在偏差出现后更新知识、记忆、推理或治理

                                                                                                                                                                              当前 KDC 研究提出五个候选度量方向:

                                                                                                                                                                              方向

                                                                                                                                                                              尝试回答的问题

                                                                                                                                                                              Reality Coverage

                                                                                                                                                                              系统职责范围内的重要现实元素覆盖了多少?

                                                                                                                                                                              Reality Mapping

                                                                                                                                                                              数字断言与现实观察是否仍然一致?

                                                                                                                                                                              Knowledge Freshness

                                                                                                                                                                              当前使用的知识距离上次验证有多久?

                                                                                                                                                                              Knowledge Drift

                                                                                                                                                                              知识内容或有效性正在以什么方式变化?

                                                                                                                                                                              Consistency Verification

                                                                                                                                                                              重要行动能否从目标和依据追溯到现实反馈?

                                                                                                                                                                              这些方向目前属于 Derived + Open Research。候选操作性定义和最小信号已经提出,但现实域如何枚举,真值如何判定、时效阈值如何设置、漂移如何计算、审计链完整性如何强制,仍需实践验证。

                                                                                                                                                                              尤其不能把它们过早组合成一个看似精确的"系统一致性分数"。一个总分可能掩盖局部高风险缺口。早期实践更适合从可采集信号开始,例如:活跃知识多久未验证、多少高风险行动缺少现实反馈、多少失败可归因于过期知识、多少记忆在冲突后仍被使用。

                                                                                                                                                                              08

                                                                                                                                                                              这不只是合规留痕,而是生产能力

                                                                                                                                                                              审计和合规是反馈闭环的底线,但不是全部价值。

                                                                                                                                                                              当系统能够把目标、知识、记忆、推理、能力、策略和现实反馈关联起来,团队可以更具体地回答:

                                                                                                                                                                              • 哪类知识最容易导致错误行动

                                                                                                                                                                              • 哪些用户偏好已经过期

                                                                                                                                                                              • 哪项能力经常在错误上下文中被选择

                                                                                                                                                                              • 哪条治理策略过严、过松或频繁触发人工介入

                                                                                                                                                                              • 哪种历史经验值得迁移,哪种只应归档

                                                                                                                                                                              • 系统是否在重复同一种失败

                                                                                                                                                                              这些能力会直接影响生产价值。团队可以更有把握地自动化高价值流程,也可以在风险上升时及时降级或转人工。组织经验不再只存在于事故复盘和专家记忆中,而可以在保留边界的前提下被复用。

                                                                                                                                                                              但这里仍要保持克制。反馈闭环提供的是可校正条件,不保证系统一定改对。错误反馈、错误归因和错误强化同样可能让系统越用越偏。系统必须允许质疑自己的记忆,也必须保留人工纠正和停止自动演化的边界。

                                                                                                                                                                              09

                                                                                                                                                                              与日志、Trace 和传统可观测的关系

                                                                                                                                                                              Logging、APM、Distributed Tracing、Audit Log 和 LLMOps 指标为长期运行提供了必要信号。它们能够记录事件、性能、调用路径、错误和模型使用情况。

                                                                                                                                                                              KDC 并不替代这些体系。运行时可观测需要复用它们提供的数据。

                                                                                                                                                                              区别在于,传统可观测通常更擅长回答:

                                                                                                                                                                              • 哪个服务失败了?

                                                                                                                                                                              • 请求耗时多少?

                                                                                                                                                                              • 哪个 Tool 被调用?

                                                                                                                                                                              • 模型消耗了多少 Token?

                                                                                                                                                                              KDC 还需要回答:

                                                                                                                                                                              • 这次行动引用了哪个版本的知识?

                                                                                                                                                                              • 哪段记忆影响了判断?

                                                                                                                                                                              • 推理对象形成了什么结论和风险?

                                                                                                                                                                              • 策略为什么允许或拒绝?

                                                                                                                                                                              • 现实反馈是否验证了原判断?

                                                                                                                                                                              • 错误应回到哪个对象、运行时或 Owner?

                                                                                                                                                                              因此,KDC 运行时可观测不是新的日志产品,而是要求现有信号通过稳定对象身份和因果关系形成审计链。可观测系统提供证据,不应越权直接修改知识或记忆。对象状态变化仍由相应运行时和治理流程负责。

                                                                                                                                                                              10

                                                                                                                                                                              实践:为一次重要行动建立 Feedback Contract

                                                                                                                                                                              选择一个已经进入或准备进入生产的重要 AI 行动。不要先设计统一指标平台,先定义这次行动如何被现实验证。

                                                                                                                                                                              可以从下面六个问题开始:

                                                                                                                                                                              1. 哪个现实结果可以验证行动是否成功?

                                                                                                                                                                              2. 反馈由谁产生,在多长时间内返回?

                                                                                                                                                                              3. 反馈如何关联到原目标、推理对象和能力调用?

                                                                                                                                                                              4. 多个反馈冲突时,谁有权确认或修正?

                                                                                                                                                                              5. 哪些结果应该形成记忆,何时衰减、遗忘或归档?

                                                                                                                                                                              6. 哪些稳定经验可以升级为候选知识,哪些只能保留为个案?

                                                                                                                                                                              然后形成一份最小 Feedback Contract:

                                                                                                                                                                              字段

                                                                                                                                                                              退款场景示例

                                                                                                                                                                              业务目标

                                                                                                                                                                              用户明确确认后完成订单退款

                                                                                                                                                                              执行结果

                                                                                                                                                                              退款请求已被支付渠道受理

                                                                                                                                                                              现实成功条件

                                                                                                                                                                              资金到账,或对账系统确认退款完成

                                                                                                                                                                              反馈来源

                                                                                                                                                                              支付渠道状态、对账结果、用户确认

                                                                                                                                                                              关联键

                                                                                                                                                                              订单、原支付、退款请求、推理对象、能力调用

                                                                                                                                                                              反馈时限

                                                                                                                                                                              受理后 72 小时内;超时进入异常处理

                                                                                                                                                                              可信度与冲突

                                                                                                                                                                              对账结果优先;用户反馈触发核验;接口成功不等于到账

                                                                                                                                                                              错误归因

                                                                                                                                                                              知识、目标解释、推理、治理、能力执行、外部渠道

                                                                                                                                                                              记忆形成

                                                                                                                                                                              保存渠道处理时长、失败原因和人工介入结果

                                                                                                                                                                              衰减与遗忘

                                                                                                                                                                              按渠道版本和政策周期衰减;规则变化后停止影响新行动

                                                                                                                                                                              知识升级

                                                                                                                                                                              多次验证的稳定处理规律进入 Candidate Knowledge

                                                                                                                                                                              最小观测

                                                                                                                                                                              反馈闭环率、到账超时、过期知识引用、错误归因完整率

                                                                                                                                                                              Feedback Contract 的核心,是明确"执行完成"和"现实目标实现"的区别,并规定反馈如何改变未来。

                                                                                                                                                                              第一版不需要综合评分。只要系统能稳定关联一次行动的目标、依据、执行和结果,并且知道反馈该进入知识、记忆、推理还是治理,就已经建立了最小闭环。

                                                                                                                                                                              11

                                                                                                                                                                              可靠系统不是记住一切,

                                                                                                                                                                              而是知道什么仍应影响现在

                                                                                                                                                                              AI 系统的长期价值,不取决于它积累了多少历史文本,而取决于它能否正确治理历史的影响。

                                                                                                                                                                              记忆需要形成门槛,需要上下文和权限,需要强化与衰减,也需要冲突、遗忘和归档。反馈需要来源和可信度,需要与原行动关联,也需要错误归因。持续一致性需要可观察和可验证,但不能被包装成尚未得到实践支持的统一公式。

                                                                                                                                                                              因此:

                                                                                                                                                                                保存历史 ≠ 形成记忆
                                                                                                                                                                                检索到过去 ≠ 过去仍然适用
                                                                                                                                                                                收到反馈 ≠ 获得真值
                                                                                                                                                                                积累更多 ≠ 持续变好

                                                                                                                                                                                KDC 不研究 AI 系统如何自动越用越好。它试图提供的是另一种能力:当现实变化、知识过期、记忆失效或行动失败时,系统能够发现偏差、解释偏差,并知道应该修正哪里。

                                                                                                                                                                                到这里,Reality、Representation、Knowledge、Reasoning、Skill、Capability、Memory 和 Feedback 已经分别出现。最后还需要回答一个整体问题:这些对象如何通过运行时和治理机制组成一套完整、可渐进采用的 KDC 软件工程模型?

                                                                                                                                                                                这将是第五篇的主题。

                                                                                                                                                                                12

                                                                                                                                                                                理论边界与开放问题

                                                                                                                                                                                本文的记忆对象与记忆运行时来自 KDC 当前阶段的理论推导,整体成熟度为 Hypothesis + Derived。记忆形成、上下文绑定、强化和归档具有较明确的推导基础。统一遗忘策略、Memory Taxonomy、组织级迁移和记忆可信度计算仍是开放问题。持续一致性五个度量方向目前为 Derived + Open Research,还不是成熟标准。

                                                                                                                                                                                版权声明: 本文采用 CC BY-NC-ND 4.0(署名-非商业性使用-禁止演绎) 许可协议。转载请注明出处。

                                                                                                                                                                                END

                                                                                                                                                                                跳转微信打开

                                                                                                                                                                                ❌