标签归档:Agent

做 Agent 架构时,OpenViking 的几个可以学习的点

设计 Agent 架构时,有一个模块的边界经常画不清晰:上下文。规划、工具调用、执行循环这些组件的职责都好切分,唯独「Agent 该知道什么」这件事,散落在 prompt 模板、RAG 管道、记忆插件和会话历史四个地方,各管一段,互不通气。

比较常见的状态是知识走一条 RAG 管道,用户记忆走一个独立的 memory 服务,工具使用经验干脆没有沉淀机制,靠 system prompt 里手写的几条注意事项撑着。跑长周期任务时问题集中爆发:第三十轮时 Agent 忘了第五轮的约束;召回了一段错误文档,事后想归因,向量库只给一个相似度 0.83,别的什么都没有。

这两个 case 背后是同一个架构缺陷:上下文没有被当作一个独立子系统来设计,它只是若干条数据管道的松散集合。

最近把火山引擎开源的 OpenViking 看了一遍,它把自己定位成「面向 AI 智能体的上下文数据库」,GitHub 上 27.2k star。这个定位本身就是一个架构主张:上下文应该是 Agent 架构里一个有统一接口、有存储模型、有检索语义、可观测的独立组件,地位类比业务系统里的数据库。

沿着这个主张往下拆,它有几个设计决策对做 Agent 架构的人有一些参考价值。

统一存储模型

Agent 架构里第一个要回答的问题:记忆、知识、技能这三类上下文,存储模型是分开还是统一。

分开是多数团队的现状,也是我们踩过的坑——三套 schema、三套检索接口、三套更新逻辑,Agent 侧要维护三种访问心智。OpenViking 的选择是统一:全部抽象成文件,挂在 viking:// 协议下的虚拟文件系统里,每个条目一个唯一 URI。它给出的目录结构:

viking://
├── resources/              # 资源:项目文档、代码库、网页等
│   └── my_project/
│       ├── docs/
│       │   ├── api/
│       │   └── tutorials/
│       └── src/
└── user/
    └── {user_id}/
        ├── memories/
        │   └── preferences/
        │       ├── writing_style
        │       └── coding_habits
        ├── resources/
        │   └── private_project/
        ├── skills/
        │   ├── search_code
        │   └── analyze_data
        └── peers/
            └── web-visitor-alice/

Agent 用 lstreefind 浏览自己的上下文。

从架构角度来看,这个统一带来两个收益。第一,定位从概率性变成确定性。扁平向量库里想精确更新某个用户的编码习惯记忆,只能靠 metadata filter 打补丁;文件系统里就是一个路径寻址,viking://user/{user_id}/memories/preferences/coding_habits,增删改查全部确定。多租户隔离也顺带解决了——user/{user_id} 这层目录天然就是隔离边界,商业版文档里明确把多租户共享和隔离列为核心场景。

第二,Agent 与上下文之间的接口收敛成了一套文件操作原语。这一点对架构的影响比看起来大。我们之前自研记忆系统时设计过一套 memory.query(scope, filter, ...) 风格的 API,模型调用的出错率明显高于让它直接操作路径。文件系统是 LLM 预训练语料里高频出现的心智模型,lstree 的语义模型天然理解,不需要在 prompt 里教。接口设计顺着模型先验走,省下的是持续的 prompt 工程成本。

代价在写入侧的分类决策。内容归置到哪个路径,做错了后续检索会系统性偏航,扁平向量库至少没有「放错文件夹」这种失败模式。OpenViking 靠写入时的自动语义处理来做归置,这个环节的质量上限决定了整棵文件树的可用性,我认为是它工程上最脆弱的一环。

预算分层供给

第二个架构问题:上下文以什么粒度供给给模型。

传统 RAG 的答案是 chunk 全量——检索 top-k 塞进 prompt,k 靠拍脑袋。这在架构上等于把上下文预算的管理责任丢给了一个魔法数字。OpenViking 的方案是写入时预计算三层表示:

  • L0(摘要):约 100 tokens,一句话总结,快速判断相关性
  • L1(概览):约 2k tokens,核心信息和使用场景,供规划阶段决策
  • L2(详情):完整原始数据,确有必要时才读

每个目录也带自己的 .abstract.overview,Agent 读任何完整文件之前,先花 100 个 token 判断这个方向值不值得深入。

放到 Agent 的执行循环里看,这三层恰好对应了三个阶段的信息需求:候选筛选阶段用 L0 扫一遍,规划阶段对少数目标加载 L1,执行阶段只对必要条目读 L2。上下文供给从一次性的赌博变成了跟随 Agent 决策流程的渐进加载,粒度和阶段对齐了。

数据上,OpenViking 0.3.22 在 LoCoMo 长对话记忆评测里,三种 Agent 集成的准确率到 80–83%,原生记忆只有 24–57%;输入 token 减少 34.3%–91.0%,查询时延降低 58.45%–66.10%。token 降幅区间这么宽,说明收益高度依赖任务形态:判断型任务能省九成,需要全量细节的任务省不了多少。评测脚本在仓库 ./benchmark 目录,可自行复现。

架构上的 trade-off 转移到了写入路径。L0/L1 由模型生成,每次数据摄入都有一笔推理开销,且是异步的——README 明确提示 add-resource 不加 --wait 时语义处理需要等待。写入吞吐敏感或数据高频变更的场景,这条路径会成为瓶颈。更隐蔽的风险是摘要写歪:L0 错了,后续所有基于它的相关性判断连带出错,等于在检索链路最上游埋单点。官方提供 ov reindex <uri> --mode semantic_and_vectors 重新生成语义产物再刷新向量,说明他们自己也预期摘要需要返工。

即便不引入 OpenViking,「写入时预计算多粒度表示、按 Agent 决策阶段供给」这个模式可以直接抄进自建架构。

检索即导航

检索组件在 Agent 架构里通常被实现成一个无状态函数:query 进,top-k 出。OpenViking 把它改成了一个有过程的导航。

先通过意图分析生成多个检索条件;向量检索定位初始切片所在的高分目录;在该目录下二次检索,高分结果更新进候选集;有子目录就逐层递归;最终返回最相关的上下文,连同周边语境一起。

一句话概括:先锁定高分目录,再向下精细探索。

这解决的是扁平 top-k 在 Agent 场景下的一个结构性缺陷——碎片没有语境。命中一个 chunk,Agent 不知道它前后是什么、属于哪份文档的哪个章节,拿到的是信息孤岛。导航式检索的返回结果自带位置和邻居:这段内容出自 API 文档的鉴权章节,同目录下还有 endpoints 说明。对代码库问答这类强依赖结构的任务,这个差异是决定性的。

代价:多轮向量查询加上可能的多次判断,单次检索的绝对延迟一定高于一把梭的 ANN。前面提到的时延降低 58%–66%,我的理解是端到端口径——省下的 token 让生成阶段变快,摊平了检索阶段的开销。架构选型时要按流量形态判断:Agent 任务型场景,单次任务价值高、容忍秒级检索,划算;高 QPS 低延迟的在线检索,这套递归策略不合适。

全链路留痕

Agent 架构的可观测性讨论,通常止步于工具调用日志。OpenViking 把留痕做进了检索内部:每次查询都保留完整的目录浏览轨迹,结果不对时能看到它出自哪条路径。

做过 RAG 生产运维的人知道 bad case 归因有多难。用户投诉答案错了,排查下来只能看到「这几个 chunk 相似度最高所以被召回」,正确内容为什么没进 top-k,向量空间不会解释。最后退化成调 embedding、调 chunk 大小、调 k 值的炼丹循环。

轨迹留存把归因变成可逐步 debug 的过程:检索在哪个目录拐错了弯、哪一层的 L0 摘要误导了判断,路径上每一步可查。修复动作随之有了着力点——重写某个目录的 abstract,或者调整文件归置,都对应到具体操作。配套的 OpenViking Helper 桌面端(Beta,支持 macOS 和 Windows x64)能解析 Claude Code、Codex、Trae 的会话,展示召回、Prompt 注入、MCP 调用、捕获和提交事件,Agent 与上下文系统之间的全部交互摆在明面上。

这一条我建议所有做 Agent 基础设施的团队照抄,无论用不用 OpenViking:把「检索决策可回放」写进架构的非功能需求。存储和埋点的成本,第一次生产事故排查时就能收回来。

经验回写闭环

多数 Agent 架构是开环的:任务执行完,除了对话历史什么都不留,下次遇到同类任务从零开始。OpenViking 在架构里补了一条回写路径:会话通过 session.commit() 显式提交后,系统异步提取两类内容写入长期记忆——用户偏好,和 Agent 经验,落到对应的 /memory 目录下。

用户偏好各家都在做。Agent 经验这条更值得看:从任务执行结果里提取操作技巧、工具使用经验,供后续同类任务复用。tau2-bench 的数据:经验记忆让任务成功率在 Retail 提升 6.87 个百分点,Airline 提升 11.87 个百分点,对比同一 LLM 无记忆基线。模型没动,纯靠架构里加一条经验沉淀回路,拿到两位数以内的成功率增量。

对比另一条提升路线——攒数据做 SFT 或 RL 微调,周期以周计,成本以万计。经验记忆改的是上下文而非权重,迭代周期是每次会话。两条路线不互斥,但在架构演进的排序上,外置经验回路的边际成本低得多,应该排在微调前面。

两处要留神。一是提取质量:异步抽取本身是 LLM 调用,抽错等于往长期记忆注入脏数据,且脏记忆会在后续任务里持续生效,危害大于一次性的错误回答。二是显式 commit 这个设计——记忆更新由开发者主动触发而非全自动,「哪些会话值得沉淀」的裁量权留在应用层。我们内部一度想做全自动沉淀,现在倾向于保留这个开关,至少在提取质量有验证机制之前。

接入成本

把这套东西放进现有 Agent 架构的成本,不高。

Python 3.10 以上,pip install openviking --upgradeopenviking-server init 走交互式向导——支持火山引擎、OpenAI、Codex OAuth、Kimi、GLM 和本地 Ollama,选 Ollama 还能按硬件拉合适的模型。openviking-server doctor 启动前体检配置、Python 版本、提供商连通性和磁盘空间。有官方 Docker 镜像和 Helm 部署。

集成面很宽:Claude Code、Codex、OpenClaw、Hermes、Cursor、Trae、OpenCode、pi、MCP 客户端、LangChain / LangGraph 都有官方接入,集成做的事是把召回注入 Agent 上下文并自动提交会话记忆。如果你的架构本来就走 MCP 或 LangGraph,接入成本主要在配置层。

许可证要过法务。主项目 AGPLv3,crates/ov_cli 和 examples 是 Apache 2.0。AGPLv3 自用没问题,基于它对外提供网络服务会触发传染性条款的开源义务。商业版 OpenViking Service 承诺与开源版共享同一套代码内核,差异在托管运维、基于 VikingDB 的规模(宣称万亿级向量、百亿数据毫秒级检索)、SLA 和企业级安全合规,有至多 50 个文件的免费试用和迁移工具。开源版默认本地存储加单机向量引擎,数据规模上去后的可靠性要自己扛,架构容量规划时要计入。

背后有论文支撑:VikingMem(arXiv:2605.29640),已被 VLDB 2026 接收,开源版实现了论文描述的部分核心能力。团队在按数据库系统的标准做存储和检索设计,这在 Agent 记忆类项目里少见。

需要注意的点

三点。

其一,整个体系的地基是写入时的自动语义处理——摘要、概览、目录归置全靠模型生成,这些产物没有质量下界。LoCoMo 和 tau2-bench 覆盖的场景有限,换到术语密集的企业知识库,L0 摘要的准确率会不会崩,要拿自己的真实数据验证,别信 benchmark 直接上生产。

其二,导航式检索的延迟特性划定了适用边界,架构选型时按流量形态判断,前面说过了。

其三,项目还早,README 自己承认「要做的事还很多」。1813 次 commit、92 个 open issue、320 个 PR,迭代活跃,反面是 API 稳定性存疑,核心链路重度依赖它要做好跟版本的准备。

回到 Agent 架构本身。「上下文作为独立子系统」「统一文件存储模型」「按决策阶段分层供给」「检索决策可回放」「经验回写闭环」,这五个设计每一个都能脱离 OpenViking 独立存在。

以上

Session First 和 Agent First,本身并没有高低之分

最近在思考一个问题:系统究竟把谁当成第一类公民。

现在我们看到很多的 AI 产品,,本质上还是「把聊天框做得更厚一点」。用户打开一个窗口,对着通识大模型说需求,模型在一个长 session 里记上下文、调几个工具、写几段内容、偶尔执行点操作。这个模式我称它为「Session First」。

「Session First」的模式跑得起来,落地也快。过去一段时间,桌面端的很多产品,包括一些 codex cc 一类的形态,都是这么长出来的。先有聊天,再把能力缝进去。先有 session,再把工具挂上去。整个产品又快又省,因为它继承的是大模型最自然的交互方式:对话。

但如果把时间线拉长,我觉得 Session First 像是一个过渡层。它把大模型带进软件,却没有真正重写软件。

另一个逻辑是 「Agent First」。

这里说的 Agent First,不是把 prompt 包一层 workflow 就算 agent。这里说的是一种更彻底的软件设计取向:系统从一开始就假设调用者不只是人,也包括 agent;系统的能力边界、接口形态、文档组织、安全机制、运行时观测,都优先围绕 agent 来设计。聊天只是入口之一,不再是核心结构。

过去我们是在和「通识大模型」对话,未来更多时候,我们是在和「带有领域知识、工具能力、任务规划能力的专用 agent」协作。再往前走,单一 agent 很可能都不够,基于 MaaS 的 agent teams 会逐步成为复杂任务的常态。Sakana AI 这类工作给了行业一个很有代表性的信号:多智能体协作,不只是研究兴趣,它在复杂探索任务上确实可能优于单体。

这种两种不同的范式,其实也没有高级和低级之分。二者背后的系统假设不同,工程代价不同,性能瓶颈不同,能解决的问题类型也不同。

Session First 和 Agent First 的不同

Session First 和 Agent First,表面上都可能长得像「用户输入一句话,系统输出一个结果」。很多人可能会觉得两者只是包装差异。其实差异蛮大的。

Session First 的中心对象是「会话」。系统假设一切能力都围绕一个持续增长的上下文展开。用户说一句,模型接一句;模型靠历史消息理解意图,靠当前 prompt 决定行为。工具调用存在,但工具通常是会话的附属物。它们由模型在 session 内临时选择、临时编排、临时解释。

所以在 Session First 里,能力组织方式通常是这样的:

  1. 先有一个大而全的聊天入口;
  2. 再有一组工具函数;
  3. 再在 system prompt 或 tool spec 里告诉模型什么时候调用它们;
  4. 复杂任务靠更长的上下文、更复杂的提示词、更精细的 few-shot 去兜。

这个模式最大的好处,是产品和研发都能快速起跑。我们不需要先把系统抽象成可组合能力,也不需要先考虑 agent 的长期运行、恢复、权限边界、状态持久化。只要模型够强、上下文够长、工具挂得上去,很多事情都能先做出来。

Agent First 的中心对象则是「行动体」。系统假设执行任务的主体是 agent,它会自己读取规范、规划步骤、调用工具、检查结果、重试修正。人在这个系统里依然重要,但人不再是唯一的控制中心。更准确地说,系统从「为人类交互而生」转向「为可委托执行而生」。

这个变化会连锁改写很多设计决策。

传统软件里,人是第一类公民。系统主要通过 UI 提供能力,文档写给人看,按钮给人点,异常信息也默认人会读。Agent First 里,agent 变成第一类公民。系统的关键界面不再是页面和按钮,而是 API、工具协议、语义化描述、状态机、权限模型、回调事件、执行日志。

传统模式是:

  • 人读文档;
  • 人理解业务逻辑;
  • 人决定点哪个按钮;
  • 人承担串联流程的责任。

Agent 模式是:

  • Agent 读取规范;
  • Agent 形成计划;
  • Agent 调用工具;
  • Agent 分析返回值;
  • Agent 根据反馈继续执行或者回滚。

这不是交互方式的小修小补,这是控制权和复杂性承载位置的转移。

Session First 把复杂性藏在会话里。
Agent First 把复杂性显式地放进系统结构里。

我更倾向后者。因为在规模化阶段会 Session First 开始需要大量的修补并且还不合脚。

Session First 的红利

Session First 也不是说不行了,落后了,它只是有自己的舒适区或边界。

它为什么会成为大多数团队的第一个选择?因为它天然适合模型的原生能力。

大模型最成熟的接口就是聊天接口。你给它上下文,它续写;你给它 instruction,它服从;你给它工具定义,它在概率空间里学着调用。这是当前已经成熟了的,并且对于大家的谁知来说没有门槛的。。产品经理能理解,前端能接,后端能包,用户也能马上用。

从落地顺序看,Session First 有三个明显优势。

交付速度快

最早一批 AI 应用能起量,基本都吃到了这个红利。做一个对话框,叠一层历史上下文,挂几类工具,外加 prompt 工程和少量业务逻辑,一个可卖的产品就出来了。

如果团队处在探索期,需求还没稳定,任务边界也不清晰,Session First 的性价比很高。因为我们可以把大量未定型的业务规则临时编码进 prompt,而不是过早地固化到接口和状态机里。说白了,它适合试错。

交互弹性高

很多需求在早期根本说不清。用户自己也不知道该点哪个按钮,只知道「我想把这堆信息处理一下」。这时聊天入口比传统 UI 更自然。Session First 天然适合承接模糊需求,尤其适合开放式任务、咨询类任务、内容类任务。

对通识模型友好

Session First 依赖的是模型在语言理解和上下文整合上的强项。很多场景下,不需要精细建模世界状态,只需要让模型在一个较长的 session 里维持语义连贯,效果就已经够用了。

所以如果一个产品主要解决的是下面这些问题,Session First 我认为完全合理:

  • 单轮或短链路任务;
  • 任务结果主要是文本、建议、草稿、分析;
  • 工具调用数量少,失败代价低;
  • 用户愿意在回路中持续确认;
  • 业务状态变化弱,对幂等性和恢复能力要求不高。

比如代码解释、文档问答、简历润色、轻量报表分析、知识库检索助手,这些都很适合。

问题出在很多团队做着做着,把它用到了不该用的地方。

Session 的代价

Session First 最大的问题,不是效果问题,而是系统复杂性的位置不对。

我们可以把 session 理解成一个不断膨胀的黑盒。任务描述、历史记录、工具调用痕迹、失败重试信息、用户偏好、临时约束,全都塞进去。模型在黑盒里靠注意力机制和 token 预算自行判断什么重要、什么该忽略、什么该继续执行。

短任务还行。链路一长,问题就开始多了。

状态污染

会话越长,状态越容易脏。一个典型问题是历史上下文对当前决策的隐性干扰。模型没有传统意义上的干净状态管理,它只有一段被不断续写的上下文。早期的一句错误假设、一次失败调用、一个过时约束,都可能在后续步骤中持续影响行为。

工程上我们会看到一些很烦的现象:

  • 明明用户已经修改目标,模型还沿着旧计划跑;
  • 明明工具返回了失败,模型把失败结果当成成功上下文继续推理;
  • 明明当前任务和上个任务无关,模型还把旧 session 里的偏好带进来。

这些都不是 prompt 多写两句能解决的。因为根因在于 session 本身不是一个严谨的状态容器。

上下文成本失控

Session First 很吃上下文。任务越复杂,历史越长,系统 prompt 越复杂,tool spec 越多,token 消耗越惊人。很多团队前期盯着模型单价,后期才发现账单真正膨胀的是「无效上下文」。

更糟的是,这部分成本并不总能换来线性收益。超过某个长度以后,模型对上下文的利用率明显下降。你花了更多 token,只换来更模糊的关注分布、更高的遗漏概率。

有一些系统,一次复杂任务真正有价值的工作 token 可能只占总 token 的 20% 到 30%,剩下的都在重复喂历史、喂规则、喂工具描述、喂先前失败记录。这样的系统,成本结构很难看。

工具选择不稳定

在 Session First 里,工具往往是通过提示词暴露给模型。模型根据自然语言描述决定什么时候调哪个工具。这种方式灵活,但稳定性一般。尤其当工具数量上来以后,工具间语义重叠、参数边界相近、返回格式不一致,模型的选择质量会迅速下降。

一个常见误区,是以为给工具写更长更详细的 description 就能解决。实际经验正相反:description 越长,竞争工具越多,模型越容易在语义相邻区域摇摆。最终你会发现,问题不是模型笨,而是整个工具层根本没有被设计成适合被模型消费。

可恢复性差

Session 是连续流,不擅长离散恢复。任务执行到一半,模型挂了、超时了、工具限流了、用户关闭页面了,系统怎么从中间恢复?很多 Session First 产品的恢复策略要么是重放整个对话,要么让模型读历史「自己想起来」。

这个策略在低风险任务里还能接受,在执行型任务里就很危险。因为它没有明确的检查点,没有确定的已完成步骤,没有结构化的执行日志,恢复质量完全依赖模型在长上下文里的自我理解。

可观测性弱

你问一个 Session First 系统:「为什么它刚才这么做?」答案通常很难给。因为真正的决策过程埋在 session 和模型隐状态里。你最多能看到 prompt、工具调用记录和输出,但很难形成稳定的、可归因的行为分析。

这会直接影响调试、评估、审计和优化。团队很容易陷入一种很熟悉的工作流:改 prompt、跑样例、感觉好一点、上线、再出新问题、继续改 prompt。系统像在「训一头很聪明但脾气不稳定的动物」,而不是在维护一个可控软件。

转向 Agent

Agent First 出现,本质上是在回答一个问题:当任务不再是聊天,而是委托执行时,系统该怎么设计?

用一名话来概括:Session First 优先组织对话,Agent First 优先组织能力、状态和约束。

这两者的差别,在简单场景里不明显;一旦任务变成多步骤、长周期、高风险、强工具依赖,这个差别会迅速放大。

Agent First 的核心变化有三层。

第一层,agent 拥有独立的任务身份。
它不再只是当前聊天窗口里的一个响应函数,而是一个可启动、可暂停、可恢复、可审计的执行单元。它有自己的目标、记忆、工具权限、运行环境和生命周期。

第二层,系统能力被显式结构化。
什么能力能调用,输入输出是什么,失败怎么表示,重试边界在哪,副作用怎么隔离,全部要写清楚。因为 agent 不是靠「猜」来用系统,它得靠规范来用系统。

第三层,任务执行被流程化和可观测化。
agent 的计划、步骤、结果检查、异常处理、人工介入点,都需要成为系统的一部分,而不是 prompt 里的一段希望。

这就是为什么我说 Agent First 更像软件设计理念,而不只是交互升级。它要求开发者从一开始就考虑 agent 的接入体验。注意,这里的「接入体验」不是 SDK 文档写得漂不漂亮,而是系统有没有把 agent 当成真正的使用者来对待。

对人友好的系统,重点是 UI。
对 agent 友好的系统,重点是 API、协议、文档、沙箱、日志。

这个顺序一换,整套架构都会变。

第一类公民

传统软件的第一类公民是人。因为系统操作链条默认由人承担:读页面、理解状态、做选择、点按钮、确认风险、处理异常。

Agent First 的变化在于,这条链路开始迁移给 agent。系统如果还保留「很多关键信息只藏在页面里、很多操作只能靠人脑理解、很多异常只有人看得懂」的设计,那 agent 就只能在外面绕路,最后产品体验会非常拧巴。

所以所谓「agent 是第一类公民」,落到工程上至少意味着四件事。

能力必须接口化

页面点击不是能力,API 才是。
表格展示不是能力,结构化查询和变更才是。
人工读懂的描述不算完成,机器可消费的 schema 才算完成。

很多团队表面上说在做 agent,实际上只是让模型去模拟用户点页面,或者让 Playwright 去跑浏览器自动化。这能用,但我通常把它看成过渡手段,不会把它当成长期基建。因为 UI 自动化的脆弱性太高,成本也太高。一旦页面变了、字段换了、弹窗多了、权限策略改了,整个链路就坏了。

如果一项业务能力值得被 agent 使用,那它应该先被抽成稳定接口。

语义必须外显

我们靠经验猜按钮含义,agent 不行。我们得把操作语义、字段含义、约束条件、异常语义都写出来。很多传统系统文档的问题,不是文档少,而是文档默认阅读者是熟悉业务的人。里面有大量省略、上下文跳跃、术语别名、口头约定。

人能脑补。agent 不会脑补,它会误解。

机器友好的文档,不是把原文档丢给 RAG 就结束了。它要求内容可索引、可切片、可定位、可引用、可验证。最好还能区分「定义」「约束」「样例」「反例」「危险操作」「返回码语义」。

权限必须细粒度

给人开的权限,往往是按角色开的。给 agent 开权限,粒度要更细。因为 agent 的调用频率高、组合能力强、自动化程度高,任何一个权限放大,都可能把小问题变成系统性事故。

我见过一些团队初期为了快,直接给 agent 一个「管理员 token」,想着先把链路跑通。跑通确实跑通了,后面风控和审计基本没法收场。Agent First 里,权限模型必须从 day 1 就设计进去。至少要做到工具级、资源级、动作级的边界清晰。

结果必须可审计

如果 agent 能执行动作,那所有关键动作都要留痕,谁发起、为什么发起、使用了哪些上下文、调用了哪些工具、拿到了哪些结果、做了什么决策、是否有人确认,都得能追出来。

这不是为了满足审计部门,而是为了我们自己能把系统维护下去。没有可审计性,复杂 agent 系统很快会变成「偶尔非常惊艳,偶尔完全失控」的黑箱。

四层结构

如果我们把 Agent First 的工程原则压缩成一个递进结构,它可以拆成四层:能力层、理解层、连接层、信任层。

API 优先

最底下是能力层,也就是 API 优先。它解决的是「Agent 能做什么」。

很多 AI 团队容易犯一个错误:先做 prompt,再做工具,再补 API。顺序反了。只要你准备认真做 agent,API 就应该先于 prompt 存在。

因为 prompt 负责引导决策,API 才负责承载能力。没有稳定能力面,agent 的执行质量永远靠运气。

我看一个系统适不适合 Agent First,第一眼就看它的 API 长什么样。重点不在 REST 还是 GraphQL,也不在用不用 MCP,而在这几个问题:

  • 接口语义是否单一清晰;
  • 参数是否结构化且有约束;
  • 返回值是否可判定成功失败;
  • 幂等性是否明确;
  • 长任务是否支持异步和回调;
  • 副作用操作是否支持 dry-run 或预检查;
  • 错误码是否可用于 agent 自恢复。

举个很实际的坑。很多内部系统的 API 是给前端页面写的,不是给 agent 写的。于是你会看到:

  • 一个接口返回几十个业务无关字段;
  • 失败时只返回「操作失败,请联系管理员」;
  • 同一个字段在不同接口里名字还不一样;
  • 创建和更新共用一个入口,副作用混杂;
  • 数据查询支持模糊匹配,但没有稳定过滤条件。

这种 API 给前端开发凑合能用,给 agent 基本就是灾难。因为 agent 消费接口时最怕三件事:语义不稳定、返回不可判定、失败不可恢复。

API 优先不是一句口号,它意味着你要为了 agent 重写一部分服务边界。代价不小,但省下的是后面无数轮 prompt 补丁。

机器文档

有了能力层,还不够。Agent 知道系统「能做什么」,不代表它知道「怎么正确地做」。

这就是理解层,也就是机器友好文档。

很多团队对文档的理解还停留在「给模型塞进知识库」。坦白说,这一步最多算资料接入,不算文档工程。机器友好文档要求内容本身就是为 agent 理解和执行设计的。

我们写文档喜欢写背景、写故事、写注意事项穿插在长段落里。机器文档要反过来,尽量消除叙事性,强化检索和判定性。什么场景能用哪个接口,前置条件是什么,参数组合有什么限制,成功条件是什么,失败后应该重试还是终止,全部要能被定位出来。

我比较推崇一种写法:把文档拆成五类最小单元。

  1. 定义单元:术语、对象、字段、状态含义。
  2. 操作单元:动作描述、输入输出、前置条件、后置条件。
  3. 约束单元:权限要求、配额、时序、互斥关系。
  4. 异常单元:错误码、成因、恢复建议、是否可重试。
  5. 样例单元:正确示例、错误示例、边界示例。

这样写出来的文档,对人读可能不友好,但对 agent 非常友好。因为 agent 需要的不是阅读体验,而是最短路径上的高密度语义。

还有一个容易被忽略的点:文档版本化。
如果系统能力在变,而 agent 依赖旧文档决策,事故几乎是必然的。机器文档必须带版本、带生效范围、带弃用说明。更进一步,文档变更最好能够被 agent 订阅或者被平台主动推送。否则你会得到一堆「以前能跑今天突然不行」的鬼问题。

协议层

再往上一层是连接层,也就是标准化协议。我们都知道 MCP,它当前重要性确实在上升。

Agent First 一旦进入平台化阶段,连接成本会成为瓶颈。每接一个系统都重新对工具做 schema 包装、鉴权对接、错误语义映射、流式交互适配,团队很快就会被集成工作拖死。标准协议的价值就在这里:让 agent 对外部能力做到尽可能低摩擦的即插即用。

协议不是为了优雅,是为了降低耦合和重复劳动。它至少解决三个问题:

  • 能力发现:agent 如何知道外部提供了哪些工具和资源;
  • 调用协商:参数 schema、返回 schema、流式能力、状态反馈如何统一;
  • 安全边界:认证、授权、调用隔离、资源限制如何标准化表达。

MCP 这类协议的意义,不只是统一 tool calling 的表面格式,更重要的是把「能力元数据」变成平台可理解的对象。一旦元数据标准化,很多平台能力才能长出来:自动装配、权限编排、调用治理、能力市场、兼容性检查、离线评测。

协议统一不会自动带来效果统一。现实里最常见的问题是:大家都说自己支持标准,结果 schema 质量参差不齐,语义粒度不一致,错误处理风格也不同。最后 agent 虽然能连上,依旧很难稳定用好。

所以协议层只是接入下限,不是体验上限。系统方如果指望「支持 MCP 了,agent 就能用了」,十有八九会失望。

信任成本

最上面一层是信任层:安全、沙箱、可观测性。它解决的是「Agent 如何被安全地使用」。

这层往往是被低估的。因为很多团队在前期更关心效果演示,安全和观测总想放后面补。等 agent 真开始执行动作,补起来就很痛苦。

Agent 系统的风险和传统自动化脚本不完全一样。脚本通常路径固定、输入有限、行为可枚举。Agent 的输入是开放的,计划是动态的,工具组合是可变的,自修正带来恢复能力,也带来行为不可预测性。这种系统如果没有信任层,部署规模一上来迟早出事。

信任层可以分为三块。

安全边界

包括权限控制、数据隔离、密钥管理、配额限制、危险操作确认机制。所有高风险动作都要能分级:只读、可写、可执行、不可逆。不同级别的动作,对应不同的确认和审计策略。

还有一件事必须单独说:prompt injection。
只要 agent 会读取外部内容、再基于内容调用工具,prompt injection 就不是附加风险,而是基本风险。你不能假设模型会自己免疫。系统层必须有输入隔离、指令优先级控制、工具调用白名单、敏感动作二次确认、结果验证。

沙箱执行

如果 agent 能运行代码、操作文件、访问网络,就必须有沙箱。别指望靠「模型会守规矩」来兜底。资源限制、网络出口策略、文件系统隔离、进程生命周期管理,这些都是必须项。

很多桌面端产品今天还在用一个比较重的本地 session 容器去承接 agent 行为,这在早期合理,因为本地环境天然带着用户上下文和工具可得性。但一旦平台化,执行环境一定要可控、可回收、可复制。否则你会发现 bug 根本没法稳定复现。

可观测性

这一块经常被做得太浅。普通日志不够。你需要的是面向 agent 的运行时观测:任务级 trace、步骤级事件、工具调用链、上下文快照、计划变更、重试原因、人工接管点、最终结果评估。

有了这些数据,很多事情才有可能做:行为分析、失败归因、离线回放、A/B 对比、策略优化、合规审计。

我甚至会说,没有可观测性,Agent First 根本不成立。因为你没法持续优化一个你看不见的系统。

单体与团队

再往前一步,Agent First 还会带来一个自然演进:从单一 agent 走向 agent teams。

这个趋势不难理解。单体 agent 的优势是简单、上下文统一、决策路径短。缺点也明显:任务一复杂,规划、执行、验证、知识检索、异常恢复全压在一个主体上,容易出现上下文拥堵和角色冲突。模型一边要想战略,一边要写细节,一边还要检查自己,稳定性会下降。

多 agent 协作的思路,是把不同职责拆开。比如规划 agent 负责分解任务,执行 agent 负责调用工具,验证 agent 负责检查输出,审计 agent 负责看风险和合规。你提到 Sakana AI,我觉得它给行业的启发就在这里:复杂问题的效果上限,未必来自更大的单体,而可能来自更合理的协作结构。

但别高估 agent teams 的短期收益。它的工程成本很高。

第一,通信成本会增加。
agent 之间传递的信息如果不够压缩,token 成本会迅速膨胀。很多团队做多 agent,最后账单翻倍,效果提升却不明显,问题就出在这里。

第二,错误归因更难。
单体 agent 出错,你还知道看一条链。多 agent 出错,很可能是上游规划有偏差、中游执行误解了任务、下游验证规则又太松。没有细致的 trace,很难定位。

第三,协作协议本身就是复杂度。
谁能给谁发任务,谁对谁有覆盖权,冲突怎么解决,结果以谁为准,失败是否回滚,人工在什么点介入,这些全得定规则。规则一多,系统会变得很重。

它是复杂任务的方向,但不是所有产品都该急着上。很多团队连单体 agent 的能力边界、观测体系、权限模型都没建好,就直接跳多 agent,最后只会把问题放大。

个人的判断

如果今天让我给团队定路线,我不会在所有场景里一刀切推 Agent First,也不会继续把 Session First 当主架构。

我的判断是这样的:

凡是以「理解、生成、陪伴、咨询」为主,任务链条短,用户始终在线,副作用低的场景,Session First 依然是最有效率的方案。别把简单问题搞复杂。一个高质量 session 产品,照样能有非常强的竞争力。

凡是以「委托执行、跨系统操作、长周期任务、可恢复流程、强审计要求」为主的场景,应该尽早转向 Agent First。拖得越久,后面迁移成本越高。因为你的 prompt、工具、日志、权限、数据结构都会按 Session First 的惯性越长越歪,最后很难矫正。

从行业演进看,我认为我们会经历三个阶段:

第一阶段,通识模型 + 聊天入口主导。
第二阶段,聊天入口还在,但底层逐步 agent 化,能力和状态开始结构化。
第三阶段,很多系统默认面向 agent 开放,我们反而通过 agent 间接使用软件。

今天大多数团队还处在第一阶段和第二阶段之间。很多产品表面上已经在说 agent,骨子里还是 session 产品。这个阶段没什么丢人的,行业本来就处在过渡期。问题在于,团队自己得知道自己在哪,不要把一个 prompt-heavy 的聊天系统误以为已经完成了架构升级。

小结

Session First 帮行业把 AI 快速带进了产品。它的重要性不用否认。没有这一阶段,大量需求不会被激活,很多团队也不会积累起对模型能力边界的真实理解。

但它的问题也越来越明显:状态管理松散、成本结构失真、工具使用脆弱、恢复和审计能力薄弱。任务越复杂,缺点越放大。

Agent First 把软件重新组织了一遍:把会话里的隐含复杂性,搬回系统里显式管理;把面向人的操作界面,扩展成面向 agent 的能力界面;把「模型偶尔能做成」变成「系统可稳定交付」。

如果要走这条路,我们就需要重写 API,补文档债,需要重做权限和日志,就会发现以前很多偷过的懒都要补回来。可如果我们的目标不是做一个会聊天的功能,而是做一个能被委托工作的系统,这些账早晚都要还。

所以我现在看一个 AI 产品会更关心它底下埋的是 session,还是 agent。前者决定它今天看起来多聪明,后者决定它一年后还能不能继续长。

以上。

聊聊 Harness:从 Agent 到组织

我们在落地 Agent 时面临的核心矛盾,是大模型的概率生成机制与工程系统所需的绝对确定性存在天然冲突。要获取大规模、可维护且值得信赖的代码,必须在系统外围构建 Harness。Harness 的本质是将不确定性转化为确定性。

提高信任度和可靠性需要极度压缩 Agent 的解决方案空间。我们必须放弃让模型「生成任何内容」的灵活性,转而采用包含大量技术细节的提示、规则和框架。特定的架构模式、强制执行的边界以及标准化的结构,构成了这套护栏的物理基础。

当前越来越多的团队在持续快速的产生代码,而这些演示很好看,当真的进入整个软件生命周期中,就会产生混乱,当越来越多的人随着时间的推移在仓库中堆砌代码,组织就开始堆人进行 review、反复返工,最后 AI 的吞吐量被人类注意力卡死,表面上用了 Agent,实际产能没上去,维护成本还更高。

当然,这是一种结果,也有人在过程中不停的构建基建,做 Harness 工程,整个代码不再是无序的扩张。从这个逻辑来讲,harness 的作用是把大模型输出从概率事件压回工程确定性的系统设计

Agent 的 Harness

harness 是什么

很多人把 harness 比作一个操作系统,模型是 CPU,但我觉得并不是。

如果模型真的是 CPU,那它接收指令后的执行结果应该是绝对严格且可预测的;但大模型本质上是一个概率引擎,它在潜空间里做的是模式匹配与概率生成。因此,harness 并不是像操作系统那样去调度底层硬件资源或分配内存,它更像是一套概率过滤器和对齐机制。它依靠纯粹的工程手段,把模型那种发散的、充满不确定性的「创造力」或「幻觉」,强行压缩进一条狭窄、严谨且符合人类预期的流水线里。

这种工程逻辑在实践中,体现为无处不在的防御性设计和反馈闭环。当模型吐出一串代码或一个决策时,harness 并不负责直接「运行」它,而是负责「质检」和「纠偏」。它通过静态检查、架构规则扫描、自动化测试和沙箱验证,把模型给出的「大概率正确」转化为工程上非黑即白的「通过或驳回」。正是这种让概率不断撞击确定性规则的过程,才使得最终沉淀到代码库里的产物是安全、可控且符合系统长期利益的。

harness 解决确定性问题的终极目的,是为了在系统中建立无需人工干预的信任,从而真正释放 AI 的吞吐量。如果没有这套逻辑,模型生成的代码越多,人类审查的负担就越重,整个组织的运转速度依然会被人类的注意力瓶颈卡死。

Martin Fowler 的博客中发表了 Thoughtworks 的技术专家的一篇文章,将 OpenAI 文章中所描述的 harness 分为三个方面:

上下文工程

上下文工程需要做到动态与静态的交织

单纯依赖超长 Prompt 无法解决复杂工程问题。上下文工程的核心在于构建代码库中持续增强的知识库,并打通 Agent 对动态上下文的访问路径。

静态知识库定义了系统的基础法则。我们将领域模型、API 契约和历史架构决策文档化,作为 Agent 初始化的基线上下文。动态上下文决定了 Agent 在运行时的决策质量。系统需要将实时的可观测性数据、测试覆盖率报告甚至浏览器导航状态,实时注入到 Agent 的工作流中。缺乏动态上下文的 Agent 就像蒙眼狂奔的打字机,产出的代码在语法上完美,在逻辑上完全脱离系统现状。

架构约束

架构约束是确定性的防线。

完全依赖 LLM 进行自我反思和代码审查,在生产环境中极度危险。架构约束必须由确定性的自定义代码检查器和结构测试来强制执行。

我们通过静态分析工具拦截不合规的依赖调用,利用 AST(抽象语法树)解析确保代码分层符合规范。当 Agent 试图在 UI 层直接发起数据库连接时,确定性的检查器会立即阻断该行为,并将具体的错误堆栈和修复路径作为反馈输入给 Agent。这种混合架构确保了系统的底线由死板的规则守卫,Agent 的创造力被严格限制在安全的沙盒内。

垃圾回收

垃圾回收主要是用于对抗代码熵增。

完全自主的智能体引入了代码库衰败的新问题。Agent 会精准且不知疲倦地复现代码仓库中已存在的模式,包含那些不均衡或不够理想的遗留设计。随着时间的推移,这种行为不可避免地导致系统架构漂移。

最初,人类开发者试图手动处理这个问题。团队过去每周五要花费 20% 的时间清理「AI 残渣」。这种依赖人力的做法毫无可扩展性。

我们将资深工程师的主观品味转化为机械规则,提炼为「黄金原则」并直接编码到代码仓库中,建立了一个循环清理流程。我们强制要求使用共享的实用程序包,禁止手工编写零散的辅助工具,确保不变式集中管理。我们严禁使用猜测性的数据探测,强制验证边界或依赖类型化的 SDK,防止 Agent 基于虚幻的结构进行构建。

系统定期运行一组后台 Agent 任务,扫描代码库中的偏差、更新质量等级,并发起有针对性的重构 Pull Request。这些 PR 大多可以在一分钟内完成审查并自动合并。这套机制的功能等同于内存管理中的垃圾回收。技术债务如同高息贷款,通过高频的微小重构不断偿还,远胜过让债务累积到系统崩溃。人类的架构品味一旦被捕获并规则化,就会无情地应用于每一行代码,每天自动发现并消灭不良模式。

AI Agent Harness 的工程化落地

从几个流行的框架来看,主要是从流程强化、规格沉淀、任务编排等逻辑上来做事情。

将这些逻辑拆开可以分为四个维度:

上下文工程

上下文工程主要是在规范层解决问题,其主要解决的「规则文件失控」的问题,实现规格沉淀与对齐,以及上下文工程的可控。

之前,我们习惯把所有规范塞进类似于单个 .cursorrules 文件,导致 AI 上下文过载且容易忽略细节。这一层落地的第一步是建立结构化、按需加载的规范体系。主要做到如下的点:

  • 规范模块化:将系统架构、数据库规范、错误处理等拆分为独立的结构化文档。
  • 按需检索:AI 不需要每次都通读所有规范,而是根据当前所处的任务阶段,动态检索并加载所需的上下文。
  • 任务记忆隔离:为每个独立任务建立物理隔离的工作区和日志。AI 每次开启新会话时,只读取当前任务的精确记忆,既解决了“跨会话失忆”,又屏蔽了无关信息的干扰。

以 Trellis 框架为例,Trellis 摒弃了单一庞大的全局提示词文件,而是采用 spec/ 目录将规范模块化(如拆分为 database-guidelines.md)。在执行任务时,它利用 tasks/ 目录下的 JSONL 配置文件,让 Agent 动态检索并按需加载上下文。

架构约束

架构约束的核心逻辑:用代码约束代码,实现闭环自愈。 口头约定或纯文本规范在 AI 面前是脆弱的,它极易为了「跑通逻辑」而破坏架构分层。

  • 规则代码化:将核心的架构依赖规则(例如“前端组件严禁直接调用数据库”)编写为静态分析脚本或自定义 Linter。
  • 带解释的强阻断:在代码提交或验证阶段强制执行这些拦截器。关键在于,报错信息不能仅仅是「检查失败」,必须输出高度结构化的指导:明确告诉 AI“为什么违反了规则”以及“正确的做法是什么”。
  • 自动修复:AI 读取到结构化的报错指导后,能够自动理解并修正代码,形成无需人类介入的自愈闭环。

反馈循环

核心逻辑:降噪处理,防范死循环。 LLM 的注意力会被长篇大论的日志(如几千行的覆盖率输出)稀释注意力,从而忽略真正致命的错误。 因此我们需要做到:

  • 零输出原则:改造验证脚本。如果测试通过,脚本应保持完全沉默;如果失败,只输出精简的错误堆栈和失败原因。
  • 强制验收清单:在 AI 试图标记任务「已完成」之前,系统应强制拦截,要求其对照需求文档逐项确认边界条件。
  • 防死循环干预:设定重试阈值。如果 AI 对同一文件连续修改多次且测试依然失败,系统应主动中断并强制其回滚代码、重新审视需求,防止 AI 陷入无效的「幻觉修 Bug」循环。

熵管理

熵管理主要是阻断「坏模式」的指数级扩散

核心逻辑:快速偿还技术债。 AI 复制坏代码的速度是指数级的。一旦允许一个临时的妥协方案合入主分支,AI 会在极短时间内将其复制到整个代码库。

  • 高频垃圾收集:彻底放弃“集中清技术债”的传统做法。每天必须安排固定时间,专门 Review AI 生成的代码(人工或 AI 自动),及时识别新引入的坏模式。
  • 规范资产的动态演进:一旦发现坏模式,立即让 AI 深度分析根因,并自动将正确的防范规则更新到规范库中
  • 团队级免疫:由于规范库与代码同源管理(存在于 Git 仓库中),当这段新规则被提交后,团队其他成员拉取代码时,他们的 AI 助手就能立刻“学会”这个新技能。这把偿还技术债的动作,变成了每天自动化、可积累的系统进化。

以 Cursor 为例,可以更新 Team Rules

组织级 Harness

聊完 Agent 的 Harness,再聊一下组织的。

人的角色已经变了

大家都知道康威定律,简单来说就是:设计系统的组织,其产生的设计受限于这些组织的沟通结构。

而系统设计到最后,也一定会遇到一个问题:谁来定义规则,谁来解释例外,谁来承担后果。

以前的软件开发分工相对稳定。PM 写需求,设计出稿,前后端分别实现,测试验证,运维发布。大家各自占一段链路,边界虽然有摩擦,但总体清楚。

AI 进来以后,边界开始模糊。

PM 已经可以直接产出前端原型,很多时候产出的还不是静态图,而是真能跑的页面代码。设计师也不再只是给稿子,很多交互和组件约束可以直接沉淀成生成资产。前端工程师花在纯页面搭建上的时间下降,开始更多介入状态管理、交互抽象、可维护性收拢。后端和算法也更早被拉进来,因为很多 AI 生成的原型一开始就会碰到真实数据和能力边界。

这是现在很多团队正在进行的转型。

如果组织还按旧的分工运转,Agent 会把协作缝隙快速放大。

组织级 Harness 要管什么

我理解的组织级 harness,重点在三件事:

  1. 定义新的协作接口
  2. 重新分配注意力
  3. 把责任从「谁写了代码」改成「谁定义了系统」

协作接口要前移

以前很多问题可以留到开发阶段再对齐。现在不行。

因为 PM 通过 AI 已经能直接产出前端代码,需求不再是文字说明,而可能是一个可交互原型;设计规范也不再只是 Figma 标注,而是可以半自动映射到组件约束;后端接口能力如果不提前讲清楚,前面的生成很容易一路偏到错误方向。

所以组织里的评审必须前移,重点也得改。

过去的需求评审,很多时候在讨论功能要不要做。现在要多讨论三件事:

  • 验收标准到底是什么
  • 哪些边界不能突破
  • 哪些部分允许先用原型推进,哪些必须工程化收拢后才能上线

这几个东西不提前定,后面会出现一个很常见的问题:原型阶段看起来进展飞快,进入工程化后才发现返工巨大。

注意力要重新分配

我现在越来越少鼓励资深工程师花时间逐行抠低风险代码。

这不是说 review 不重要,而是注意力要贵着用。

在 Agent 环境里,重要的工作变成了:

  • 定义验收标准
  • 设计架构边界
  • 提炼黄金原则
  • 识别系统性失败信号
  • 决定哪些异常值得阻塞主流程
  • 审核高风险改动和高影响面重构

反过来,低风险、重复性、局部性的东西,应该尽量交给自动化校验和后台清理任务。

如果一个组织还在让最贵的人力去看大批格式化差异、小工具改名、重复样板代码,那 harness 基本等于没有。

责任归属要重写

在 AI-Native 组织里,谁对结果负责?

PM 产出了页面代码,前端做了工程化收拢,Agent 自动补了测试,清理 Agent 又改了一轮共享工具。最后线上出问题,算谁的?

如果这个问题没有明确答案,团队会很快进入防御状态。每个人都怕接 AI 产出的锅,于是流程开始重新变重,所有人都试图把责任往后传。

所以组织级 harness 一定要明确责任模型。

可以按三层分:

  • 需求责任:谁定义了目标与验收标准,谁负责需求正确性
  • 架构责任:谁定义了边界、模式和约束,谁负责系统一致性
  • 发布责任:谁决定进入生产环境,谁负责风险接受

不要再执着于「谁手写了这行代码」。就像团队管理一样,最后拍板的人担责。

可落地的 AI-Native 研发流程

以下为我们当前在跑的流程:

需求生成

第一步由 PM 主导,但交付物不再只是 PRD,而是带验收标准的可运行原型

但是,原型代码不等于可直接上线代码。它的价值是澄清需求、暴露分歧、提前感知交互复杂度。

所以 PM 可以生成,但不能默认拥有工程决策权。最终所有的代码都需要前端工程师构建的工具链条,以及 AI 和人工的审核及合入。

联合评审

第二步是全员参与的需求评审与架构设计。设计、前端、后端、算法都要尽早介入。

这个阶段重点不是抠实现细节,而是确定:

  • 用户路径是否成立
  • 数据流怎么走
  • 状态边界怎么划
  • 哪些能力用现有服务承接
  • 哪些模块需要新增抽象
  • 风险点在哪
  • 验收怎么自动化

这这一步的产出结构化进仓库,因为后面它会直接成为 Agent 的约束输入。

工程收拢

第三步是工程化整合。这个阶段前端、后端、算法开始把前面的原型和需求收敛进正式系统。

这里 Agent 会大量参与,但人类不能退出。重点工作包括:

  • 把原型重构进现有组件和模块体系
  • 校正状态管理、错误处理、埋点、权限、监控
  • 对接真实接口和算法能力
  • 补齐类型、边界验证和回归测试
  • 处理跨模块影响面

这一段最考验 harness,因为原型代码最容易带着局部最优、全局失真、风格漂移的问题冲进主仓。

自动验证与灰度

最后一步是自动化测试、灰度发布和反馈回收。

这一步先由专门的工程团队来负责,加入部分的 AI 成分,固化系统。

从 Agent 到组织,真正难的是控制系统

很多人以为 AI 落地的核心挑战在模型能力、成本或者工具接入。我现在看,最大挑战更集中在三个词:环境、反馈回路、控制系统。

环境决定 Agent 看到了什么、能做什么、不能做什么。

反馈回路决定错误会被放大,还是会被系统吸收成改进信号。

控制系统决定生成能力增长之后,组织是变得更稳,还是更乱。

这三个东西做不好,模型再强也只是更快地产生问题。

做得好,哪怕模型能力没到最顶尖,系统一样能稳定进化。因为工程上真正稀缺的,从来不是一次惊艳输出,而是长期重复地产出靠谱结果。

组织的 AI-Native 化

组织的 AI-Native 化也是慢慢进货,逐步推进的,先从小范围试起,再根据结果不断调整规则和流程。并且各家有各家的风格和气质。

第一,选一条链路打透。不要一开始就全组织铺开。先找一个协作关系清楚、反馈周期短、风险相对可控的场景,比如中后台、运营工具、内部系统,或者低风险服务改造。重点不是让 AI 多写代码,而是先验证:信息怎么给、边界怎么定、错误怎么发现、问题怎么清理。

第二,先改规则,再谈效率。很多团队一上来就问产能能提升多少,但更重要的是:规则有没有沉淀下来,错误能不能回流,坏模式能不能及时发现并清掉。如果这些没做好,所谓提效往往只是把问题推后,甚至把混乱放大。

第三,把人的位置往上移。资深工程师要逐渐从大量写代码,转向定规则、画边界、看反馈;技术管理者要从盯人和排期,转向设计流程、分层风险、明确责任;产品可以更早参与原型,但不能越过工程判断。

组织真正变成 AI-Native,不是因为每个人都在用 Agent,而是协作方式已经围绕 Agent 被重新设计过。

模型当然重要,但不是决定性因素。真正拉开差距的,是谁先意识到:Agent 不是一个更快的开发者,而是一个高吞吐的生产单元。它会放大环境本身。规则清楚,它就放大规则;流程混乱,它就放大混乱。

所以到最后,harness 这件事谈的根本不只是 AI。

谈的是工程纪律怎么重新编码。

谈的是组织协作怎么重新布线。

谈的是我们怎么把概率生成系统,放进一个仍然要求长期维护、长期演进、长期负责的软件世界。

这是我理解的「从 Agent 到组织」。

以上。