如何打造 AI-Native 软件产品研发组织

如果一个团队真的想做 AI-Native 研发组织,第一步是改组织契约:谁可以让 AI 产出代码,谁对代码负责,什么质量底线不能退,什么流程可以砍,什么流程必须更重。

AI 现在太会写代码了,但是这就会导致一个问题:它把「产出代码」这件事的成本做到很低,低到组织里原本那些靠角色边界、流程延迟、评审机制勉强维持的质量平衡,突然失效了。

过去一个 PM 提需求,前端写页面,后端写接口,测试回归,整个链条慢,但慢本身也是一种摩擦力。现在 PM 自己就能把页面跑起来,AI 一下午能写出几十个组件,速度是上去了,但系统开始更脆弱了。

先说 AI-Native 组织不是什么。 AI-Native 组织它不是「让所有人都开始写代码」,也不是「研发岗位会被提示词工程师替代」。

它是把软件组织里的逻辑重排。

以前文档是入口,代码是结果。现在代码变成入口,文档变成派生物。 以前角色按工种切,PM、设计、前端、后端、测试各守一段。现在角色要按责任切: 谁定义业务闭环,谁维护系统护栏,谁提供稳定契约,谁为线上事故买单。

今天我们先聊组织契约,再聊角色重构,然后再把一条研发流水线拆开聊聊。

组织契约

没有组织契约,AI 进团队只会把烂流程放大。

合理预期

在某些 Demo 场景,或者脚本类场景,10 倍是一个合理的预期。 但是对于一个组织来说,10 倍是一个不科学的场景,因为在组织里面,在产品研发过程中,写代码并不是整个生产过程中最耗时的部分。

所以,我们要先摈弃一个幻觉:不要拿 10 倍产出当目标。

AI 在研发组织里的收益区间,我一直认为是 1.5 到 2 倍,高质量前提下的 2 倍。为什么呢? 因为代码生成速度和有效交付速度不是一回事。AI 能把编码阶段压缩掉一大块时间,但需求澄清、边界判断、异常处理、联调、测试、观测、回滚,这些成本不会自动消失。很多时候还会更高。

如果团队盯着 10 倍,结果一般都一样:PR 数量暴涨,代码体积暴涨,Review 质量下降,线上回归问题增加,半年后开始集中还债。这就是技术债积累速度第一次超过了团队消化速度。

所以合理预期应该写进团队共识里:我们追求的是 2 倍高质量交付,不追求 10 倍低质量代码喷射。

所有权

每个 AI 输出都必须有所有者。

谁发起生成,谁提交 PR,谁 approve merge,这中间可以分层,但最终必须落到一个明确的人身上。这个人要能够面对一句话:如果这段代码挂上你的名字,你愿不愿意负责。要是答案是否定的,这段代码就不该进主干。

这条规则听起来像废话,实际上很多团队做不到。因为 AI 会制造一种错觉:代码好像不是谁写的,是系统吐出来的。人变成了搬运工。只要团队接受这种错觉,质量就开始漂移。一个有所有权的流程大概是这样:

  • PR 模板里要求声明 AI 参与范围
  • 提交人对业务正确性负责
  • Reviewer 对工程质量负责
  • 合并人对上线风险负责

责任可以分工,但责任不能悬空。

质量顺序

质量第一,数量第二。

团队如果不显式声明这一点,默认会被 AI 拖向另一个方向:先铺功能,再补治理。这个方向对 demo 团队成立,对正式业务组织通常是灾难。因为 AI 特别擅长快速补齐显性功能,却不擅长主动建立长期维护结构。它会顺着需求走,不会替你守架构。

AI 时代必须把一些以前属于「好习惯」的东西升级为「强制门槛」,也就是我们之前经常强调的规范,流程等等,如测试、监控、CI/CD、单测等等。

  • 没有测试,不进主干
  • 没有异常处理,不进主干
  • 没有监控埋点,不进主干
  • 没有 feature flag,不上线
  • 不能被 reviewer 解释清楚的代码,不 merge

当代码供给能力暴涨时,质量约束必须同步加码,否则系统会很快从可控变成不可控。

交付代码

传统产品研发里,PRD 是上游,代码是下游。这个模型的问题大家都熟:PRD 经常过期,设计稿和实现偏移,字段定义藏在飞书文档、接口平台、聊天记录和前端代码里,最后没有一个地方是真正可靠的。

AI-Native 组织里:代码作为唯一源,文档从代码反向提取。

从代码出发

现在 PM 借助 Codex、Claude Code(最近又有同事被封号了)、Cursor 这类工具,已经可以生成带交互的页面、Mock 数据、状态流转,很多场景下甚至能直接把核心业务路径跑通。既然这样,就不要再让 PM 先写一份长 PRD,再让研发去猜什么叫「列表为空时的引导态」。让页面先跑起来,再从页面反推需求定义,效率和准确率都更高。

这里有个好处:讨论变得具体了。

以前评审会上大家讨论一句文档描述,脑子里各自渲染不同 UI。现在把页面摆出来,点击路径、字段结构、交互反馈、错误提示都变成可观察对象。对齐成本直线下降。后端也不需要看十页文字说明,只要看这个页面最终需要什么数据结构,就知道接口该怎么供给。

文档反向生成

代码是唯一真相源,不等于不要文档。让文档变成派生物,而且是自动派生物。

流程大概如下:

  1. PM 先生成并跑通前端页面,带 Mock 数据
  2. AI 从页面代码、组件 props、Mock schema 中逆向提取字段说明、交互流程、状态机描述
  3. PM 对这份自动生成的文档做人审
  4. 后端按确认后的 JSON Schema 或 TypeScript Interface 实现接口
  5. 联调时再根据真实契约让 AI 回写文档

这样处理后,文档不再是一个独立维护成本很高的系统,而是代码的视图层。它可以读给人看,但它的源头来自真实实现,而不是空想。

建议把接口契约标准化为 JSON Schema 或 TypeScript Interface

角色重构

AI-Native 组织可能会有一些角色的变更,但是也可能会裁掉一些角色,因为我们是重写角色边界。如果当前人不合适,或者适应不了,就需要换,否则就会变成打造新组织过程中的阻碍。

很多人讨论这件事喜欢走两个极端。一个极端是「以后人人都是全栈」。另一个极端是「AI 只会替代初级岗位,核心角色不变」。这两个判断都不够准确。

真正发生的变化是:低门槛生产能力下放,专业门槛上移。简单说,更多人能做出东西,但真正有价值的岗位,会向规范制定、质量兜底、系统抽象和复杂问题处理集中。

PM 变成产品工程师

在这个新组织中,变化最大的角色是 PM。

过去 PM 的主要输出物是 PRD、流程图、原型图和口头解释。现在这些东西很多都可以收敛成一个交互可运行的页面。于是 PM 的角色自然往「产品工程师」移动:他不再只描述需求,他直接构造需求的运行形态。

但这里一定要说清楚,PM 写了前端代码,不等于 PM 变成前端工程师。PM 的责任边界还是业务逻辑,不是工程治理。

PM 需要对什么负责:

  • 用户路径是否闭环
  • 页面状态是否完整
  • 文案、条件、分支、空态是否符合业务预期
  • Mock 数据结构是否表达真实业务语义
  • 生成代码是否遵守团队规定的基础组件和样式约束

PM 不需要对什么负责:

  • 全局状态架构是否优雅
  • 包体积是否最优
  • 路由切换是否引入副作用
  • 渲染性能是否达标
  • 工程抽象是否可复用

这些后者还是需要专业前端要接住。

问题不是让 PM 承担更多,而是让 PM 把过去停留在文档层的业务表达,直接推进到代码层。这样整个团队拿到的是可执行的业务定义,不是抽象说明书。

设计师变成立法者

设计角色也会变。

当 PM 可以直接借助 AI 生成页面时,设计师如果还把大量时间耗在单页面高保真稿上,投入产出比会快速下降。更有价值的位置,是维护设计系统和机器可消费的样式规范。

设计师的工作重心会变成:

  • Design System
  • 样式 token
  • Visual QA

也就是把颜色、间距、字体、圆角、阴影、组件状态、可访问性规范,从设计稿资产转化成代码和配置资产。比如 Tailwind config、CSS variables、组件规范、图标集、交互动效约束。这些东西一旦进入 AI 生成上下文,PM 或其他角色在生成页面时就不容易跑偏。

说白了,设计师从「画每一张图」转向「制定法律」。立法做得越完整,AI 和 PM 生成的页面越像一个系统,而不是一堆拼起来的截图。

前端变成守门员和重构者

前端是最容易被误读的角色。很多人看到 PM 可以生成页面,就开始下结论:前端会被干掉。实际情况通常相反。前端从体力活里解放出来之后,工程价值反而被放大了。

因为 PM 生成的页面,最常见的问题不是「长得不对」,而是「能跑但脆」。

可能会有大量这类代码:

  • 一个组件里塞满请求、状态、渲染、事件处理
  • loading、error、empty 三种状态缺两种
  • useEffect 依赖写错
  • 切页面回来状态丢失
  • 没有 abort controller,快速切换导致竞态更新
  • 表单校验只校 happy path
  • 直接把 mock 字段名写死在视图层,后续接口一改全炸

这些问题不是 PM 能解决的,也不是 AI 自己会主动解决的。前端真正的工作变成三块:

第一块,Review。
不是审美式 review,也不是找缩进。重点看稳定性、边界条件、状态管理、组件职责、可维护性。

第二块,Refactor。
把单文件逻辑拆成组件、hooks、domain service,把团队组件库接上,把状态流收敛,把重复逻辑抽掉。这个过程需要持续迭代,做到团队规范中,给到 PM 生成的上下文中。

第三块,Integration。
把 Mock 替换成真实 API,处理鉴权、缓存、错误回退、重试、并发、路由守卫、埋点、监控。

这个阶段的前端,更像体验架构师和质量守门员。

后端变成能力供应商

后端角色也会收缩:提供稳定、安全、确定性的能力边界。

如果前端页面能更快被构造出来,后端的价值就不在于「接收一份文档然后写 CRUD」,而在于把系统能力以 API 或 Tools 的形式稳定暴露出来。尤其是 AI Agent 场景下,后端实际上在扮演工具供应商。

后端重点关注四类问题:

  • 契约稳定性
  • 权限与安全
  • 幂等性与确定性
  • 可观测性与审计

前端、PM、Agent 都可能直接消费这些能力。一旦接口设计漂、错误码混乱、鉴权模型含糊,整个上层生成式开发就会持续返工。AI 会把不稳定接口的问题放大得很明显,因为它极度依赖上下文中的确定性。

流程重构

只讲角色变化不够,需要把研发流程改成适合 AI 的形状。下面是一版比较能落地。

需求具象

第一阶段,需求不再先写成长文档,而是先具象成可运行页面。

PM 独立生成前端

PM 拿着明确业务目标,直接在受控环境里生成页面代码。这个页面至少要包含:

  • UI 布局
  • 基本交互
  • 主要状态流转
  • Mock 数据
  • 核心校验逻辑
  • 空态、错误态、加载态

特别强调最后三项。很多团队让 PM 生成页面,只盯着主流程,结果页面演示时很漂亮,一联调全是坑。空态、错误态、加载态必须在这个阶段一起生成,否则后面每一轮都要补票。

禁止黑盒交付

PM 生成页面这件事,最怕黑盒。也就是只看效果图对不对,不管代码是否落在团队跑道上。

所以团队必须先准备好脚手架和护栏。比如:

  • 必须使用指定组件库
  • 必须使用既定样式 token
  • 必须遵守目录结构
  • 必须使用指定的数据获取模式
  • 必须输出可运行测试脚本
  • 必须带 feature flag 接入点

否则 PM 生成的代码看似完成任务,实际是给前端制造二次工程。

不要让 PM 从空白页面开始提示 AI,而是给一个完整的基础模板,再让 AI 在模板内填充。这个模板的价值极高,它决定了团队是让 AI 在高速公路上开车,还是在野地里乱冲。

契约握手

第二阶段,前端页面和后端能力正式握手。

前端反定义接口

以前是后端先定义接口,前端去适配。现在很多场景可以反过来:前端页面里需要什么数据结构,先自然长出来,再把这份结构抽取成契约。

这里的关键点是「自然长出来」之后,必须立刻标准化。不能停留在 JS 对象字面量和口头描述。最好直接生成:

  • JSON Schema
  • TypeScript Interface
  • 字段说明
  • 校验规则
  • 错误码预期
  • 状态迁移说明

做到这一步,后端看到的就不是「我要一个用户列表接口」,而是一个明确的数据契约:字段、类型、可空性、分页、排序、过滤、异常响应、鉴权要求,全都摆明。

这一步会明显减少沟通损耗。后端可以少看很多无效文档,直接围绕契约开发。

后端提供确定性能力

后端接手后,不建议只机械实现接口。要借这个机会把系统能力做成稳定工具层。

如果团队本身就在做 Agent 或工作流系统,这里更应该统一成 Tools 注册机制,而不是散落一地的临时 API。因为未来调用这些能力的,未必只有前端页面,还有内部 Agent、自动化流程、运营工具、甚至外部合作系统。

后端在这一阶段最常踩的坑有几个:

第一,返回结构不稳定。
今天 success 返回 data,明天又套一层 payload。前端 AI 生成代码时非常怕这个,会反复产生错误适配。

第二,错误码语义不清。
鉴权失败、参数错误、资源不存在、限流、业务冲突全都混成一种 message,联调体验很差。

第三,幂等性缺失。
AI 驱动的调用链经常会重试,如果创建类接口没有幂等控制,很容易重复写入。

第四,缺少审计。
AI 或 PM 直接驱动系统能力时,操作路径更分散,审计日志不能省。

联调瓶颈

真正的瓶颈通常出现在第三阶段:联调、测试、排雷。

到这一步,很多团队会发现:AI 把前半段提速提得很猛,但最后这段并没有自动消失,甚至更重。因为前面生成得越快,后面积累的隐患越多。

Review 的重点

前端 reviewer 在这一阶段要非常克制。不要把 review 做成审美比赛,也不要上来就要求所有代码重写一遍。真正该看的,是那些会直接影响稳定性和维护成本的问题。

我会把检查项固定成一张表,至少覆盖这些内容:

  • 异步请求是否有取消机制
  • Loading、Empty、Error 状态是否完整
  • 表单提交是否防重入
  • 路由切换是否会遗留脏状态
  • 全局状态有没有被随意污染
  • 组件职责是否过载
  • 是否接入统一埋点与异常上报
  • 是否存在明显重复逻辑
  • 是否绕过设计系统直接手写样式
  • 是否引入不必要依赖

这样做的好处是,review 从个人经验驱动变成组织标准驱动。AI 时代 PR 量会明显增加,没有标准化检查单,review 质量一定掉。

测试和验收左移

如果团队已经允许 PM 直接交付前端页面,那测试必须同步左移。否则生成速度越快,测试越像消防队。

谁生成页面,谁至少生成对应的 E2E 测试脚本。这个要求不算过分。因为页面交互路径是 PM 最熟的,AI 根据这些路径生成 Playwright 或 Cypress 脚本,命中率通常不低。

在生成代码时,PM 已经完成了第一次的验收。

测试左移不是为了把测试岗位干掉,而是为了把最贴近业务逻辑的验证提前到需求具象阶段。后面的 QA 才能把精力放在组合场景和系统回归上。

发布保险

第四阶段是发布与可观测性。这在 AI-Native 组织里是核心流程。

因为一旦允许更广泛的人群借助 AI 产出代码,线上报错率几乎一定会上升。组织必须提前接受这个现实,然后把监控和发布控制建好。

前端监控

前端监控一定要上,而且要够细。

至少需要这些能力:

  • 错误堆栈捕获
  • Source map 还原
  • 用户会话回放
  • 性能指标采集
  • 接口失败聚合
  • 版本维度对比

像 Sentry、LogRocket 这类工具的价值,在 AI 场景下会更高。因为当报错出现时,你可以把错误堆栈、用户操作轨迹、接口上下文直接喂给 AI,让它先生成修复建议,再由责任人确认。这种协作模式对定位简单问题很有效,尤其是 UI 状态错乱、边界遗漏、类型不匹配这类故障。

但不要误解成「有了 AI 修 bug 就轻松」。线上修复的难点从来不只是生成 patch,而是确认根因、评估影响面、决定是否回滚、验证是否引入新问题。这些仍然要靠工程纪律。

灰度发布

Feature Flag 在这个模式里几乎是必需品。

原因不复杂:当业务页面大量由 PM + AI 参与生成时,组织需要一个足够便宜的试错阀门。否则每次上线都把全量用户暴露在新逻辑下,风险太高。

把 Feature Flag 从「重要功能才加」提升为默认机制。尤其是下面这些场景必须强制:

  • 新页面替换旧页面
  • 新流程替换旧流程
  • 高价值转化路径
  • 涉及支付、权限、数据修改的动作
  • 首次由非传统研发角色主导产出的功能

灰度期间要明确看哪些指标,不要只看有没有报错。还要看:

  • 转化率变化
  • 页面停留时长
  • 关键按钮点击率
  • 表单提交成功率
  • 接口失败率
  • 用户退出路径

这些数据能帮助团队判断问题究竟出在代码稳定性,还是业务交互本身。

基建先行

前面这些流程能否跑起来,核心在于基建。没有基建,AI-Native 组织会迅速退化成提示词手工作坊。

可以先建三类基础设施。

护栏脚手架

这是第一优先级。

它包括:

  • 项目模板
  • 目录规范
  • 统一组件库
  • 设计 token
  • 数据获取封装
  • 表单与校验约定
  • 埋点和监控 SDK
  • 测试模板
  • CI 预设规则

这套东西是整个组织 Harness 的部分。

Prompt 资产

很多团队低估了 Prompt Library 的价值。实际上,当非工程角色也开始产出代码时,提示词模板本身就是组织资产。

可以把高频场景沉淀成标准模板,比如:

  • 列表页生成模板
  • 表单页生成模板
  • 详情页生成模板
  • 多步骤流程模板
  • 异常状态模板
  • E2E 测试生成模板
  • 文档反向提取模板
  • 重构任务模板

这些模板不是为了追求文风统一,而是为了把团队积累的工程约束嵌进去。你希望 PM 每次生成页面都自动包含 loading、error、empty、feature flag、埋点、测试入口,那就别靠口头提醒,直接写进模板。

CI/CD 闸门

AI 时代,CI/CD 不能只是跑个 lint。它必须承担质量闸门职责。

最低限度我会要求:

  • Lint
  • Type check
  • Unit test
  • E2E smoke test
  • Bundle size 检查
  • 安全扫描
  • 依赖合规检查
  • 自动化预览环境
  • 灰度发布流水线
  • 一键回滚

如果团队现在连这些都没有,先别急着搞 PM 交付前端代码。真把口子放开了,组织会先被事故教育一遍。

常见误区

这是几个最常见的误区。

把 AI 当外包

这是第一类坑。很多团队使用 AI 的方式,本质上和用廉价外包没区别:把需求甩出去,拿回代码,自己不理解也不维护。

这个模式短期可能看起来很省,长期一定出问题。因为系统复杂度没有消失,只是被包进了你看不懂的代码里。等线上出事,你会发现团队没有形成任何新的内生能力。

只提速前半段

第二类坑是,只提速需求到页面这一段,不提速后面的治理、测试、发布、观测。结果就是项目看板前面一片绿,最后两列全堵死。

AI 会把组织瓶颈照得更亮。以前慢慢暴露的问题,现在两周就能堆出来。你不改后半段流程,前半段越快,堵得越严重。

容忍脏代码,也容忍脆弱代码

我能接受 PM 生成的代码不够优雅。变量命名一般、文件拆分普通、抽象层次一般,这些问题都能后续治理。真正不能接受的是脆弱代码:没异常处理、没监控、没测试、状态流断裂、提交会重复、接口失败直接白屏。

脏和脆是两回事。组织必须把这条线划清楚。

用 AI 替代判断

第四类坑最隐蔽。团队开始迷信 AI 给出的架构建议、重构建议、性能建议,仿佛它给出了答案,工程判断就可以省掉。

这是错的。AI 非常适合提供候选方案、加快实现、缩短试错周期,但它不拥有系统上下文,不承担线上责任,也不会为半年后的维护成本买单。架构判断、边界判断、风险判断,最终还是人做。

最后

如果一定要用一句话概括我对 AI-Native 软件研发组织的理解,那就是:把代码生产普遍化,把工程责任集中化

前者意味着更多角色可以直接参与构造软件。PM 可以交付可运行页面,设计可以把规范直接编码,后端可以把能力做成工具供全组织消费。后者意味着系统质量不能民主化。责任必须更清晰,护栏必须更强,发布必须更克制,观测必须更细。

「PM 交付前端代码」这件事很容易被包装成一个新故事。真落地时,它首先是工程纪律问题,然后才是工具问题。团队如果没有建立所有权,没有把代码当唯一真相源,没有把契约、测试、监控、灰度这些基础设施补齐,这条路大概率会走成一场持续返工。

反过来,如果这些条件具备了,AI 确实会把组织推到一个新阶段。PRD 不再是那份总会过期的文档,代码本身就是需求表达。角色不再围着工种转,而是围着责任和系统边界重组。研发流程不再把大量时间浪费在翻译需求上,而是更早进入真实问题:契约、质量、异常、性能、发布。

这才是我理解的 AI-Native。

以上。

从碎片检索到深度推理:如何重塑 AI Agent 的知识引擎

如果现在对于AI Agent 的知识引擎或者知识库的认知还停留在在「向量库 + embedding + topK 检索」的人,项目大概率正在踩坑。

传统 RAG 解决的是「能不能把资料塞给模型」的问题,而知识引擎要解决的是「模型能不能沿着知识结构走到正确答案」的问题。 这两个层级差得很远。前者偏检索,后者开始接近推理。Agent 一旦进入企业场景,尤其是要处理流程、制度、系统配置、投融资关系、风控链路、故障追因这类问题,知识如果还是碎片状态,后面的规划、调用、执行基本都会失真。因为对于模型来说重要的上下文已经是经是不完整的了,自然而然的就开始瞎猜了。

就 AI Agent 知识引擎来说,研发团队常遇到两个坑:

第一,很多团队高估了向量检索的上限。
第二,很多团队又低估了图结构落地的工程代价。

今天我们聊一下AI Agent 的知识引擎如何从碎片检索走到深度推理。

咱们今天主要聊四件事:

  • 为什么传统 RAG 在复杂问题上会持续失手
  • GraphRAG 到底重塑了什么
  • 真正可落地的架构怎么搭
  • 当前有哪些新一些的进展

传统短板

很多人第一次做 RAG,体验都挺好。

文档切块,做向量化,进库。用户一问,召回几段文本,拼 Prompt,模型生成答案。对于 FAQ、制度查询、产品说明、接口文档检索,这一套能迅速出结果,性价比很高。

问题在第二阶段才出现:用户不再问单点事实,而是开始问链式问题。

比如:

  • 「2019 年收购 A 公司的企业,其母公司在 2021 年的主要投资对象是谁?」
  • 「某服务在去年三季度的故障,和两个月前那次容量扩容有没有关联?」
  • 「这份上百篇研报里,哪些公司通过共同供应商暴露了同类风险?」

这类问题有一个共同点:答案不在某一个 chunk 里,而是在多个实体、多个时间点、多个文档之间。

传统 RAG 在这里会出现几种典型失效。

关系丢失

向量检索擅长找「语义相近」。它不擅长找「关系成立」。

文档切块以后,文本里的结构被打散了。原文中可能存在很清楚的逻辑链:

  • 公司 B 在 2019 年收购 A
  • 公司 B 是集团 C 的子公司
  • 集团 C 在 2021 年投资了 D

切完块之后,这三个事实可能散落在不同 chunk、不同文档、不同索引分区里。向量检索能不能一次把它们都召回?经常不能。即便召回了,顺序也未必对,相关性分也未必稳定。

这时候模型只能自己「脑补拼图」。一旦有一块没找到,推理链就断。而且,模型也不会老老实实说「证据不够」,它会倾向于补一个看起来像答案的东西出来。这就是很多人嘴里的幻觉。说白了,很多幻觉并不是生成模型凭空发疯,而是检索层先把它带沟里了。

上下文碎片化

RAG 的 chunk 机制本质上是一个工程妥协。

chunk 太小,语义不完整;chunk 太大,embedding 稀释,召回变钝,窗口成本暴涨。滑窗重叠能缓解一点,但解决不了跨章节、跨文档、跨时间的连续推理。

尤其是企业内部知识库,天然不是一本结构优雅的教材,而是一堆:

  • PRD
  • wiki
  • 飞书文档
  • 邮件摘要
  • 会议纪要
  • Jira 评论
  • 数据库导出
  • 运维记录
  • 外部 PDF

这些东西之间本来就没有自然连续性。你再把它们切成块,信息完整性只会进一步恶化。

实体歧义

只靠向量,相同名字的实体很容易串。

一个公司简称可能对应母公司、子公司、事业部;一个人名可能在不同组织里都出现过;产品代号可能跨年份复用。向量模型对这种歧义问题并不稳定,尤其在中文企业数据里,简称、别名、历史命名混在一起,非常常见。

实际项目里,实体歧义一旦没有解决,后面所有链路都白搭。你在检索层把「A 公司」对齐错了,后面再高级的 Agent 规划、工具调用、答案归因,都是建立在错图上。

时间失真

这个问题很多团队前期根本没建模。

企业知识不是静态的。组织关系会变,制度会改版,接口会下线,股权会变更,设备状态有有效期,药品说明有版本,风控规则按月份生效。

传统 RAG 里,一个 chunk 通常只是一段文本。它不天然携带明确的「生效时间」「失效时间」「版本边界」。所以用户一旦问时间敏感问题,系统就容易把不同年份的事实混成一团。

你会看到模型回答得头头是道,但时间轴已经错了。

多跳能力弱

这个问题其实不是模型不会推理,而是检索不给路。

Agent 场景里,很多问题天然是多跳的。要找到答案,系统需要先定位实体,再沿某种关系扩展,再结合时间、置信度、来源做过滤,最后拿到一条可靠路径。传统向量召回没有这个导航能力,它只会不断找「像不像」。

这就是为什么很多团队把模型从一个升级到另一个,效果只提升一点点。瓶颈不在模型本身,而在知识引擎没有结构。

图谱价值

把知识图谱拉进来,改变了检索目标

传统 RAG 检索的是文本片段。
GraphRAG 检索的是实体、关系、路径、子图,以及这些结构对应的证据。

这个差别很大。

显式关系

知识图谱最核心的价值,是把原来需要模型从文本里隐式猜出来的关系,变成显式结构。

比如:

  • 公司 A — 收购 — 公司 B
  • 公司 C — 母公司 — 公司 A
  • 公司 C — 投资 — 项目 D

一旦这些关系被建出来,系统面对复杂问题时就不需要靠 Prompt 去碰运气,而是可以沿着边去找路径。路径找到后,再把路径上的证据喂给模型组织语言。

这一步非常关键。因为它把「推理」从纯生成问题,变成了「结构检索 + 受约束生成」。

多跳导航

图结构天然支持多跳。

从一个节点出发,系统可以做一跳邻域扩展、两跳路径发现、带类型约束的遍历、带时间过滤的路径搜索。很多复杂问题,其实本质上就是图上的 constrained traversal。

做过故障分析、供应链穿透、组织权限审计的人都知道,真实问题往往不是「找到相似文本」,而是「沿着几类特定关系往外走,直到找到证据链」。

GraphRAG 在这里的优势很直接:它给系统一张路网,而不是一堆散落纸片。

可解释性

只要答案建立在路径之上,归因就容易很多。

传统 RAG 的可解释通常是「我引用了这几段文本」。这不够,因为用户看不出这些片段之间为什么能导出结论。

GraphRAG 则可以给出:

  • 命中的核心实体
  • 扩展的关系类型
  • 经过的中间节点
  • 命中路径对应的来源文档
  • 时间和版本约束

对于金融、医疗、法务、审计这类场景,是准入门槛。没有路径级证据,系统很难真正进入业务闭环。

异构融合

企业知识天生异构。数据库里有结构化字段,文档里有叙事描述,日志里有事件序列,报表里有指标快照,外部网页里有补充事实。

知识图谱很适合做这一层统一承载。节点和边上可以挂:

  • 来源
  • 时间戳
  • 置信度
  • 版本号
  • 原文锚点
  • 权限标签

这样,后面的 Agent 就不需要分别理解十几种数据形态,它只需要围绕图这个统一语义层工作。

幻觉压制

有人说 GraphRAG 「能消灭幻觉」。做工程的人都知道,不存在这种好事。

更准确地说,GraphRAG 能明显降低两类幻觉:

  • 检索证据不足导致的瞎补全
  • 实体关系错配导致的错误推断

图结构把推理空间收窄了。其本质上是一个针对知识的 harness 工程。模型不是面对无边界文本海洋自由发挥,而是在一个有限子图上做组织和归纳。再加上路径归因、时间约束、来源过滤,错误空间会被进一步压缩。

架构重构

GraphRAG 要真正落地,分为三段:建图、检索、生成

建图阶段

图谱质量决定了 GraphRAG 的上限,建图成本决定了它的下限。

如果图是脏的、歧义的、缺时间边界的,后面做再多检索优化都只是补洞。

实体抽取

最基础的是从文本中抽实体、属性、关系。

早期很多方案喜欢直接让 LLM 通读文档抽三元组。这么做效果可以有,但成本极高,而且稳定性不够。文档一长、格式一乱、术语一偏,大模型就开始漂。

建议:实体抽取和关系抽取要拆开看,不要一把梭。

实体层往往更适合用稳定的 IE 管线或者轻量模型先打底,再让 LLM 做补充和歧义修正。原因:

  • 实体是高频基础设施,规模大
  • 实体错一个,影响整片图
  • 实体任务相对更规则,适合工程化优化

尤其在垂直领域,术语标准化比抽取本身更难。医疗、金融、制造、运维,每个领域都有自己的缩写、版本命名、内部代号。这里如果没有术语表和字典体系,后面图融合基本没法看。

关系抽取

关系抽取是建图里最贵、最脆弱的一层。

关系比实体更依赖上下文。它牵涉事件角色、动作方向、时间条件、否定表达、范围限定。比如:

  • 「计划收购」
  • 「已完成收购」
  • 「传闻收购」
  • 「终止收购」

如果你都抽成同一种边,图就废了。

所以关系抽取不能只问「有没有关系」,还要问:

  • 关系类型是什么
  • 方向是什么
  • 是否已生效
  • 时间区间是什么
  • 证据来源在哪里
  • 置信度多少

不建议一上来就追求极全的关系本体。项目初期,关系类型设计得太花哨,抽取和维护成本会迅速失控。更稳一些的做法是围绕业务问题反推关系集合,先保核心链路通。

实体对齐

这是最容易被低估的坑。

同一个实体可能有:

  • 全称
  • 简称
  • 英文名
  • 别名
  • 历史名称
  • 内部代号
  • 不同系统中的主键

如果没有实体对齐,图上会出现大量看似不同、实际相同的节点。结果是路径断裂、统计失真、召回稀释。

实体对齐需要多种信号联合:

  • 名称相似度
  • 类型一致性
  • 属性重合度
  • 上下游关系重合度
  • 来源可信度
  • 时间重叠情况

仅靠名称相似度会出很多事故。尤其在中文企业环境里,简称重复极多。我见过一个项目把两个不同区域的同名子公司合并成一个节点,导致后面整条供应链分析全错。

时间与版本

这部分如果不做,GraphRAG 只是比 RAG 多了一层图壳。

建议节点和边都尽量具备时间语义,至少要能表达:

  • 创建时间
  • 生效时间
  • 失效时间
  • 采集时间
  • 数据版本

这样系统才能回答历史状态问题。比如:

  • 「2021 年时它是否还是子公司」
  • 「这个接口在 3 月版本里是否存在」
  • 「某规则在事故发生当日是否已生效」

如果没有时间建模,系统只会返回一个「混合当前状态和历史状态」的伪答案。

质量控制

建图不是 ETL 一次跑完就结束。它需要持续质控。

至少要有几层控制:

  • 抽取置信度阈值
  • 本体约束校验
  • 规则冲突检测
  • 抽样人工复核
  • 高风险实体白名单校正

比如,公司类型节点不该挂「毕业院校」属性;人员节点不该作为「机房设备」的父实体;时间区间不能出现失效时间早于生效时间。

这些校验就是 harness 工程。

检索阶段

GraphRAG 的检索不是去图库里「搜一下」这么简单。真正有效的检索,至少是一个分层过程。

第一步:实体定位

用户问题进来,先要知道问的是谁、什么对象、哪个版本、哪个时间点。

这一步常见做法是实体链接,必要时混合向量召回。目标是在图里找到核心节点。

这里有两个坑特别常见。

一个是用户表达不规范。简称、口语、错别字、历史名称都可能出现。
另一个是问题里实体不止一个,而且主次关系不清。

所以实体定位通常需要结合:

  • NER
  • 别名字典
  • 向量相似召回
  • 类型约束
  • 上下文消歧

如果这一步错了,后面全错。

第二步:子图扩展

定位到核心节点后,要决定往外扩多少。

这一步不能粗暴按 N 跳展开。图一旦大起来,邻域爆炸是很快的。尤其企业图谱里很多「高连接度节点」会把子图迅速拉成垃圾堆。

建议的做法是带约束扩展:

  • 限关系类型
  • 限最大跳数
  • 限时间区间
  • 限置信度
  • 限来源可信等级
  • 限节点类型

比如查询收购链路,就优先沿「收购」「母公司」「投资」这类关系走,而不是把「合作」「提及」「共现」都混进来。

第三步:路径发现

复杂问题很多时候不只是看邻居,而是找满足条件的路径。

比如:

  • 从 A 出发,找到其收购方,再找到收购方母公司,再找到该母公司在某年的主要投资对象
  • 找到某故障对应组件,再向上找到依赖链,再找变更记录,再对齐时间窗口内的容量调整

这类问题,本质上就是受约束路径搜索。图数据库和图算法在这里比纯向量库更像工具。

但有个问题:路径一多,候选会急剧增加。这个时候不能一股脑全喂给模型。要做路径评分和裁剪。

常见评分信号包括:

  • 路径长度
  • 关系类型优先级
  • 时间匹配度
  • 节点权威性
  • 来源可信度
  • 历史问答反馈

第四步:证据序列化

图拿到了,不能直接丢给模型。大多数模型并不擅长原生理解复杂图结构。

要把子图变成模型好消化的证据形式。常见有两种:

  • 路径序列化
  • 子图摘要

路径序列化适合事实问答。
子图摘要适合全局分析和开放问题。

实际工程里,更推荐结构化证据和原文片段联合输入。因为图给的是骨架,文本给的是细节。只有骨架,没有细节,答案会很硬;只有文本,没有骨架,答案会发散。

生成阶段

GraphRAG 不是检索完就结束。很多项目到这一步依然翻车,因为 Prompt 设计和输出约束没做好。

证据优先

Prompt 里必须明确要求模型优先依据图证据回答,不足时才引用文本补充,证据冲突时按来源等级和时间规则处理。

如果不写这些约束,模型还是会习惯性按语言流畅性组织答案,最后把未经验证的补全混进去。

路径归因

对于高事实性场景,建议回答里至少保留轻量级路径说明。未必要全部展示给用户,但系统内部必须保留。

比如答案背后至少知道:

  • 起点实体
  • 中间关系
  • 终点实体
  • 每一步证据来源
  • 时间过滤条件

有了这层,后面才能做审计、回放、纠错、反馈学习。

模板化输出

在财务、医疗、法务、运维这些高风险领域,自由生成要尽量少。

更稳的方式是字段化输出,例如:

  • 结论
  • 证据路径
  • 证据来源
  • 时间范围
  • 置信度
  • 不确定点

这样做的缺点是可读性略硬,优点是稳定。企业系统最终是要接流程、接审批、接工单、接风控策略的,格式稳定比文采重要得多。

三类路线

GraphRAG 现在大体有三条实现路线。可以工程投入和适用边界来看:

知识驱动

这一类把图谱作为主检索引擎。问题进来后,系统尽量转成图查询、路径搜索或者约束遍历,文本只做辅助。

这条路线适合:

  • 实体和关系相对清晰
  • 业务规则稳定
  • 可解释性要求高
  • 多跳推理占比高

典型场景像金融股权穿透、资产关系分析、故障因果链、药物禁忌关系、组织权限依赖。

优点:精度高、证据链清晰、推理路径稳定。

缺点:图谱不全时脆弱,对建图质量依赖极大。

如果你手里只有一堆杂乱文档,图谱覆盖率还没起来,就直接 all in 知识驱动,项目容易陷进「图不够用,文本又没保留好」的尴尬局面。

索引驱动

这一类不强调图上直接推理,而是把图结构转成索引增强信号。

比如:

  • 给 chunk 挂上关联实体、关系标签
  • 把子图摘要拼进 chunk 再做向量化
  • 用邻居关系信息做 rerank 特征

这条路线改造成本低,适合已有 RAG 系统做增强。很多团队第一阶段其实更适合走这条,而不是直接重做知识底座。

缺点也很实在:图只是辅助特征,没有成为真正的推理空间。所以多跳能力提升有限,可解释性也一般。

混合路线

现在真正跑得稳的,大多是混合型。

简单讲就是双路甚至多路召回:

  • 一路走图
  • 一路走向量
  • 必要时再接关键词或结构化库查询
  • 最后统一重排、裁剪、融合

这条路线最像真实世界。因为企业问题本来就不是纯图问题,也不是纯文本问题。很多时候用户一半在问事实链路,一半在问叙事背景。只用一种召回方式,效果往往不稳。

混合路线的问题在于系统复杂度高。链路变长之后,监控、调参、缓存、权限控制、延迟预算都更难。可它依然是现在最主流、也最靠谱的方案。

轻量建图

微软把 GraphRAG 带火,但慢慢大家发现了一个问题:原版重度 GraphRAG 太贵。

用 LLM 通读全量文档,逐段抽实体、关系、摘要,这种方案到真实数据规模经常直接失控。于是轻量化建图开始流行。

实体图思路

轻量路线的核心变化是:不再执着于完整关系抽取,而是先把实体和文档块稳定连起来。

也就是说,先建一个实体图,或者说 relation-light graph:

  • 节点是实体、文档、chunk
  • 边主要表达提及、共现、引用、归属、锚定等轻关系
  • 更复杂的关系留给后续局部推理或按需补抽

高质量关系抽取太贵、太慢、太脆。那就先把高确定性的部分做出来,把知识骨架做起来。

很多场景下,这么做反而更稳。因为实体图能显著改善召回导航,成本又远低于全量三元组图谱。

成本变化

轻量建图通常能把两个指标打下来:

  • Token 消耗
  • 图谱更新时间

这对中小项目非常关键。一个知识引擎如果更新周期是按天甚至按周算,它对 Agent 的支撑就已经很有限了。现实里的知识是流动的,尤其在运维、客服、风控、投研这些场景,更新速度直接决定答案可信度。

局限

轻量图省成本,但也有边界。

它更适合做「导航增强」和「局部上下文组织」,不适合承担强逻辑推理的全部职责。因为如果关系层太弱,系统最终还是要回文本里做大量补推断。

所以我们一般把轻量图看成一个很好的过渡层,或者作为混合架构中的图底座。

Agent 化检索

GraphRAG 这两年另一个明显趋势,是从固定流水线走向 Agent 化。

传统流程大多是:

用户提问 → 定位实体 → 扩子图 → 生成答案

问题是,复杂问题往往一轮检索拿不全证据。系统需要边查边判断:现在的证据够不够?应该沿哪类边继续走?有没有必要换一个切入实体?要不要回文档补背景?

这时候,GraphRAG 和 Agent 很自然就结合起来了。

查询拆解

复杂问题先拆成子问题,是 Agent 化 GraphRAG 的第一步。

比如:

「2019 年收购 A 公司的企业,其母公司在 2021 年的主要投资对象是谁?」

可以拆成:

  1. 谁在 2019 年收购了 A
  2. 该收购方的母公司是谁
  3. 该母公司在 2021 年的主要投资对象有哪些
  4. 哪个对象符合「主要投资对象」定义

拆解后的每一步都更适合图查询和约束检索。

迭代探索

Agent 可以根据中间结果决定下一步动作:

  • 命中实体不确定,先做消歧
  • 路径证据不足,扩大时间窗口
  • 图证据不全,补文本检索
  • 文本冲突,回图里查来源优先级

这比一条固定链路强很多。因为真实问题不会永远按设计者预想的路径走。

风险

Agent 化一听就很高级,但工程上有几个明显的问题:

  • 延迟增加
  • token 消耗增加
  • 调试复杂度上升
  • 失败路径变多

如果没有严密的步骤预算和停止条件,Agent 会在图里越走越远,最后拖垮时延和成本。

所以 Agent 化 GraphRAG 要有明确的控制策略:

  • 最大迭代轮数
  • 最大扩展跳数
  • 最大证据数
  • 最大 token 预算
  • 终止阈值

没有这些约束,系统会变成一个会自主发散的检索器。

强化学习

2025 到 2026 年,另一个值得关注的方向是把强化学习或者类似 reward-guided 策略引进图检索过程。

这个方向的核心问题是:子图应该扩到哪里停?哪条边值得继续走?

以前这类问题多靠规则和启发式。比如限制两跳、限制 topN 邻居、按关系优先级排序。够用,但不够细。

强化学习的吸引力在于,它试图让检索器学会一件事:在有限上下文预算下,优先收集对答案最有价值的证据。

为什么有价值

GraphRAG 很容易出现一个悖论:

  • 扩得太少,证据不够,答不出来
  • 扩得太多,噪声暴涨,模型反而更容易错

最优点其实是一个动态平衡,而且和问题类型、图谱密度、时间约束都相关。静态规则很难适配所有情况。

落地现实

这个方向我认为在部分场景是一个比较不错的解。

原因很简单。强化学习提升的是「策略细节」,前提是你的图已经比较干净,检索反馈链路也能闭合。如果底层图谱质量一般,奖励模型再聪明也学不到稳定策略。

所以在工程优先级上,我会把它排在:

  1. 实体对齐
  2. 时间建模
  3. 混合召回
  4. 路径裁剪
  5. 再考虑 RL 优化

很多团队喜欢直接追最新论文方向,结果底座没打稳,投入产出很差。

动态建图

静态全量图谱还有一个问题:更新慢。

数据一旦高频变化,整库重建非常重,增量融合也复杂。于是最近很实用的一条路是查询驱动的动态局部建图

思路

先用向量检索或关键词检索,快速圈出和问题强相关的一小批文档或 chunk。然后只针对这部分数据,在内存里临时构建一个局部图,用来做当前问题的推理。

这样做的好处很明显:

  • 不需要维护一个永远完整的全局大图
  • 对高频更新数据更友好
  • 构建成本和时延更可控
  • 对冷门知识不用提前付建图成本

适用场景

这条路线特别适合:

  • 数据更新快
  • 查询分布长尾
  • 很多知识只会被偶尔问到
  • 无法接受全量图谱重构成本

比如运维告警分析、实时舆情、工单流、交易异常调查。

局限

动态建图的问题也很明显:它的全局视角弱。

如果问题本身需要跨全库的大结构理解,比如全局主题分布、长期模式汇总、跨社区关联,局部动态图就不够用了。所以它更像实时推理层,不是全局知识层的完全替代品。

多模态图

GraphRAG 继续演进,节点已经不再局限于文本实体。

很多真实场景里,关键证据来自图像、图表、表格、时序信号。把这些都挂进图里,才可能支撑更完整的 Agent 推理。

例如医疗场景里:

  • 症状描述是文本节点
  • 检查指标是结构化节点
  • 影像特征是图像节点
  • 治疗方案是流程节点

如果这些数据还分散在不同系统里,Agent 再强也只能在局部瞎猜。多模态图的价值,在于把这些证据接成可遍历的语义网络。

不过这块别急着神化。多模态 GraphRAG 落地难度明显高于文本图谱,主要难点有三类:

  • 跨模态对齐难
  • 证据置信度难统一
  • 存储与检索链路更复杂

所以大多数团队短期内更现实的做法,是先把表格和结构化字段接进来,再逐步引入图像等模态。

超图方向

传统的知识图谱仅支持二元关系(即一条边连接两个节点,如 实体A → 关系 → 实体B)。然而在真实复杂场景中,事实往往是多维度的。

比如:

  • 三家公司共同参与某项目
  • 一笔交易涉及买方、卖方、标的、通道、时间、地区
  • 一个法律案件涉及原告、被告、法条、法院、时间节点
  • 超图与超边(Hypergraph & Hyperedges):超图允许单条“超边”连接任意数量的实体/节点。例如在医学场景中,描述“某症状”的发生可能涉及“患者、医生、检查手段、特定药物和治疗结果”。
  • 低阶与高阶关联:通过超图,系统能同时无损存储成对的“低阶关联”与包含多个实体的“高阶关联”,从根本上减少信息压缩带来的损失。

这个方向在金融穿透、案件分析、复杂项目协作里很有吸引力。因为它能更自然地表达群体事件和多方关系。

但说实话,超图现在离大规模工程标配还有距离。核心原因不是理念不对,而是生态、工具链、调试经验都还不够成熟。一般团队现在没必要急着上,除非业务场景确实被二元关系表达卡住了。

落地取舍

那么 团队到底该怎么选?

只做传统 RAG 就够的情况

如果你的问题大多是:

  • 单文档问答
  • FAQ 查询
  • 产品知识助手
  • 代码片段召回
  • 对多跳推理要求不高

那就别急着上图。把 chunk、embedding、rerank、query rewrite、metadata filter、citation 做好,收益通常更高。

应该上轻量 GraphRAG 的情况

如果已经出现这些信号:

  • 同一个问题答案分散在多个文档
  • 实体名称混乱、简称多
  • 用户经常追问上下游关系
  • 向量召回结果看起来相关,答案却老是不对
  • 需要更稳定的引用与归因

那我建议先上轻量图。先做实体层和文档锚定层,不要一口气建满关系宇宙。

应该上重度 GraphRAG 的情况

如果业务本身就是关系驱动的:

  • 金融穿透
  • 医疗知识网络
  • 风控依赖链
  • 故障根因传播
  • 供应链关联追踪
  • 组织权限审计

那重度图谱是值得的。因为这里的问题本质上就是图问题,用纯文本方案长期只能堆补丁。

Agent 化和 RL 什么时候考虑

当且仅当你已经满足这些条件时再往上走:

  • 图谱基础质量稳定
  • 问题复杂度确实需要多轮探索
  • 现有检索链路可观测、可回放
  • 成本和延迟预算允许

否则,先把基础检索做好,比上复杂策略更值。

小结

图结构是检索的 harness 工程。

向量检索还是底座,图结构正在变成高阶能力的分水岭。

没有向量,系统对模糊语义和开放文本会很迟钝。
没有图,系统对关系、路径、时间、一致性会很脆弱。

未来成熟的 Agent 知识引擎,大概率都不是单一路线,而是分层组合:

  • 向量层负责广覆盖召回
  • 图层负责关系组织与多跳导航
  • 结构化查询层负责精确过滤
  • Agent 层负责查询拆解与迭代探索
  • 生成层负责受约束表达与归因输出

说到底,知识引擎这件事,已经从「找资料」变成「构造可推理的证据空间」。

GraphRAG 不是给 RAG 多加一个数据库,也不是给模型多喂一点上下文。它把原来松散、偶然、靠模型自行拼接的知识,重组成了一张可以遍历、可以约束、可以回放的网络。

对 AI Agent 来说,对于 AI Agent 的上下文构建来说,这是关键的一步。

因为 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 到组织」。

以上。