铃阅
❌

阅读视图

迈向AI Native:快手技术团队的范式跃迁与组织进化

高可用架构 2026-07-07 11:52 中国香港

文末领取 PPT

在 AI 深度渗透软件工程、个体效率与组织效能之间鸿沟日益凸显的背景下,快手主站千余名工程师支撑着日活数亿用户的核心产品,其 AI 原生转型正面临"换了引擎却未重构流水线"的系统性困境。

本文整理自快手主站 AIDevops 负责人李思在 GIAC 2026·深圳站的分享《迈向AI Native:技术团队的范式跃迁与组织进化》。

【演讲摘要】

89%的企业已把AI投入实际业务,但生产力提升只有0.29%。DORA 报告也显示,个体效能上去了,组织效能却没变。AI 到位了,研发体系还是老样子,必须围绕 AI 重新设计。

过去一年踩了不少坑。24年下年代码生成率从17%涨到30%,交付周期却没变。后来发现只有不到10%的工程师真正变了,差异不在用不用 AI,而在有没有改变工作方式。快手把范式分成 L1 辅助、L2 协作、L3 自主,走两条路:L1 到 L2 铺开,L1 到 L3 特定场景突破。但个人快了组织没快,AI 越快人和人协作摩擦越大,人机摩擦也成了新负担,根源在围绕人设计的结构卡住了 AI。

解法就是三层重构。信息层面让 AI 能拿到知识,流程层面从串行改成 Agentic 模式,组织层面交付和守护分开、产研边界溶解。后面直播礼物的案例就是三层重构的落地缩影——方向、分镜、生成、评审都由 Agent 做,人只定目标,上新周期从20天压到4天以内。目前 L2 已成主流范式,较 L1 周期缩短20%到30%。

往前看还有验证规模化和先锋队模式两个难题。但说到底,变革落在每一个人身上。知识能被看见,品味和判断却很难,组织得给这些看不见的价值一个位置。人人都在加速,也要给远见留空间。 AI 跳过了慢慢写的过程,更要给年轻人慢慢生长的机会。范式在变,组织在变,底色永远是每一个工程师。

【演讲实录】

过去一年多,我们一直在推进千人规模研发团队的 AI Native 转型,包括研发范式的升级,以及整个团队怎么做组织层面的进化。今天想和大家分享一下,快手主站目前在这个方向的进展、心路历程和一些具体的实践,主要分享如下三个部分:

第一部分是宏观判断——行业目前在哪里,以及我们为什么要做 AI Native ;第二个是千人级实践——过去一年多做了哪些事情,踩了哪些坑,以及具体的思路和解法;第三个是组织进化相关的思考—— AI 改变的不只是代码,也在改变我们的人和协作的方式,我们是怎么做组织协作的演进,以及人才画像相关的一些思考。这是一个"打怪升级"的演进过程。

一、行业在哪里:AI Native 的宏观判断

Image

先看一组行业数据,NBER 今年对美英德澳四个国家的高管做了一个调查,发现89%的企业已经把 AI 投入到了实际业务,听起来占比非常高。但同时这份报告的另一个数字是:企业平均实际的生产力提升只有0.29%。高期待和低成效形成了一个非常鲜明的对比。右边这张图是《 DORA 2025 AI 辅助软件开发现状调查报告》,对 AI 在软件开发领域的影响提供了一个全景扫描,结论是个体效能提升非常显著,但组织的效能并没有太多变化。中间这条鸿沟,也是我今天想要分享的核心问题。

Image

从历史层面看这个问题,可能不是今天才有的。19世纪末,随着从蒸汽机到电动机的技术成熟,美国的工厂纷纷把引擎换成了电动驱动,大家以为从此效率会飞涨,但经过了30年,生产力并没有什么起色。真正的转变发生在1920年代,企业这时不再是换引擎,而是从整个流水线、车间动线、生产系统进行了一次重组,这次重塑彻底带来了效率的质的飞跃。

今天,我们面对的也可能是同样的局面。我们给每个工程师装上了 AI 的伙伴或者工具,但底层的研发体系仍然是老样子——如果在这套体系上只是装上 AI,那我们可能也是在重复历史的故事。所以可以看到:智能已经领跑,范式正在重塑。我们需要的是围绕 AI 重新设计研发体系和组织协作,这就是我们 AI Native 驾驭智能的进化之路。

二、千人级实践踩坑:个人提效 ≠ 组织提效

这些道理听起来都没错,但真正让我们理解它的,不是理论,而是一年多实践中踩过的每一个坑。

快手主站有一千多名工程师,在推进研发智能化的过程中,我们总结的坑是这两个不等式:第一,用 AI 开发工具不等于个人提效;并且,个人提效也不等于组织提效。

接下来分享下我们的故事,带入一下当时的情境。

Image

24年下半年,我们从编码环节开始引入 AI。代码生成率从17%提升到了30%,各个研发环节的采纳率也都保持在较高水平。

看到这些数据时,大家都很兴奋,认为研发交付效率应该会明显提升。然而,当我们把整体效能数据拉出来分析时,却发现一个出乎意料的结果:整个研发交付周期几乎没有变化。换句话说,新功能真正触达用户的时间,并没有因为 AI 的引入而缩短。

更有意思的是,我们进一步做了一些局部分析,发现约90%的工程师几乎没有发生明显变化。

Image

于是,我们找到了这不到 10% 的工程师,试图回答一个问题:他们到底是怎么工作的?

我们发现,真正的差异并不在于有没有使用AI工具,而在于有没有改变自己的工作方式。也就是说,他们是怎么和 AI 一起工作。有人把 AI 当作辅助工具,在需要的时候提供帮助;也有人让 AI 优先完成大部分工作,再由人负责判断、修改和审查。

所以,真正的问题需要重新定义:并不是在推动 AI 工具的使用,而是如何推动研发范式的升级——让原本只发生在不到10%工程师身上的高效工作方式,沉淀为一套可复制、可推广的研发范式,并在整个组织中系统性地发生。

基于这些思考,去年上半年,我们开始尝试回答另一个问题:AI 时代的研发范式,到底应该是什么样的?

我们把它划分为三个阶段。

  • L1 是 AI 辅助,AI 在部分环节提供信息;

  • L2 是 AI 协作,AI 在部分工作单元提供初稿,人做完善;

  • L3 更自主,AI 自主完成需求交付。

方向有了,接下来就是回答另一个问题:这条路应该怎么走?

最开始,我们的思路其实很朴素——所有场景都沿着同一条路径演进,从 L1 到 L2,再到 L3,循序渐进地完成研发范式升级。

但实践之后,我们发现,不同研发场景的演进条件并不相同。比如一些 B 端、从0到1的场景,任务边界清晰、风险可控、容错空间也更大,非常有机会直接实现端到端交付,而不必按部就班地经历每一个阶段。

因此,我们最终设计了两条演进路径。

第一条是L1 → L2 的主航道,在大规模研发场景中持续推进研发范式升级。

第二条是一条快速路,聚焦结构成熟、边界清晰的特定场景,尝试直接跃迁到 L3,实现 AI 驱动的端到端交付,推动研发效率实现非线性提升。

但 L1、L3 这些是交付的模式,组织关注的是什么呢?是一个结构。

我们规划了组织范式的演进路线:25年初,以 L1 为主,逐步 L1 收窄,最终 L2 和 L3 成为主流范式。经过半年的建设,L2、L3 的交付需求占比提升了,一些标杆团队的 Coding 时间也明显缩短了,看起来一切都在向好的方向走。

Image

但把视角再拉到组织效能上,情况就不一样了。

我们基于当时的效能数据做了一些分析和归因,发现个体效率确实提升了—— CR 代码生成率都在涨,个体耗时投入在降;但在协同层面,端到端的周期其实并没有太大变化。个人虽然提效了,但在组织和协同层面,传导的链条是断的。

为什么个人变快了,组织没快呢?时间到底去哪儿了?

基于千人团队的实践,我们得到两个非常重要的洞察。

Image

第一个洞察是:AI 越快,人和人之间的协作摩擦反而越明显。

AI 带来的提效首先发生在局部,最典型的就是编码环节。工程师的 Coding 时间确实缩短了,但一个工程师一天真正写代码的时间,大约只占 30%,甚至更少。剩下的大部分时间,都花在需求对齐、协作沟通、任务交接等工作上,而这些协作成本,很快就抵消了编码效率提升带来的收益。

第二个洞察是:人机协作本身,正在成为一种新的隐性成本。

AI 被引入之后,并不意味着人可以立刻把工作交给 AI。为了让 AI 真正发挥作用,人仍然需要投入大量额外的时间和精力。

结合大家的实际实践,我们把这些成本归纳为四类典型的协作摩擦。

  • 第一类是人工补位。当 AI 与研发系统之间还没有完全打通时,人不得不充当两者之间的桥梁,把信息不断搬来搬去。

  • 第二类是上下文对齐。AI 并不了解我们的业务背景,也无法天然理解需求语境,因此工程师需要不断整理、补充和传递上下文,充当系统之间的"搬运工"。

  • 第三类是验证与纠偏。AI 可以在几分钟内生成代码,但验证这些代码是否正确、是否符合业务需求,往往需要几个小时,甚至更长时间。AI 生成和人工验证之间,存在明显的速度不对称。

  • 第四类是能力边界判断。当大家对 AI 的能力边界还没有形成稳定认知时,低估 AI,会错过本可以释放的效率;高估 AI,则容易导致返工和重复修改。

这些都是我们在真实研发实践中反复观察到的现象。也正是这些协作摩擦,让我们意识到:真正制约 AI 研发效率的,已经不再是模型能力,而是人与 AI、AI 与系统、人与人之间的协作方式。

Image

那这些摩擦的根源到底在哪儿呢?我们总结了两层约束。

第一层是能力性约束:AI 的能力边界不确定,产出可信度不稳定,验证和纠偏的工作高度依赖人工。在人机摩擦里,蓝色的这部分——验证纠偏、高估和低估——主要来源于能力层面。但能力层面会随着 AI 本身模型能力的提升,以及我们在工程 Harness 层面的建设不断提升。

第二层是研发体系的结构性约束。我们的研发体系一直都是为人设计的——人有什么特性呢?认知带宽有限,注意力稀缺,所以需要按技术栈分团队,需要多个环节分阶段开发测试上线,还有产品研发设计这些角色去协作。在这套体系下就会映射出三个方面的投影:信息、流程、组织,形成这样的结构。在这个结构下,人和人之间的摩擦就会存在——协调、交接、对齐;同样这套结构也在卡着 AI。当技术栈切分以后,信息系统、技术设施都是分离的。

站在 AI 的视角来看,它其实很难获取完成任务所需的上下文。开发一个需求,客户端代码在一个仓库,前端代码在另一个仓库,后端又分散在多个微服务中;需求文档、设计文档、API 文档也分别存放在不同系统里。AI 无法像人一样跨系统理解和关联这些信息,于是,人只能不断充当桥梁,去补充上下文、搬运信息、连接系统。

归根结底,这些协作摩擦并不是模型能力的问题,而是研发基础设施和协作体系的问题。过去的研发环境,更多是围绕"人如何协作"设计的,而不是围绕"AI 如何协作"设计的。

因此,当模型能力真正转化为 AI 的执行效率后,这些效率并不能直接传递到组织层面,而是不断被协作结构中的各种摩擦所消耗,最终形成大量结构性损耗。结果就是:AI 看起来越来越聪明,但组织整体的效率提升却十分有限。

这也是我们一年多实践中最大的收获之一:真正需要升级的,不只是 AI 能力,而是支撑 AI 工作的研发结构。只有重塑这套结构,才能把模型的智能真正转化为组织的效率。

三、围绕 AI 重塑研发体系:信息·流程·工程基座

Image

那我们是怎么做的呢?我们需要围绕AI重塑研发体系。在讲AI如何改变之前,先讲一下度量——如果度量不了效率,就没有办法改进效率。

第一个阶段是平台化、数字化和精益化,这是在打地基——把研发活动在线化,让数据可信,才有资格谈度量;同时建立效能北极星,以及多个指标做交叉验证。

第二个阶段,我们把效能从一个模型变成了可拆解、可归因的指标体系,能看到每一个地方卡在哪里、出了什么问题。这也是前面那个分析的过程——为什么个人快了,组织没快,卡在了哪里。

第三个阶段就是现在,在效能模型的基础上扩展出了 AI 度量的维度,能够进一步看到组织的 AI 渗透率和 AI 成熟度。没有前三年的积累,我们今天并没有底气说AI让组织快还是没快,因为连快没快都量不出来。

Image

接下来是我们的行动框架,基于前面那三层框架——信息、流程和组织。

信息层面:首先 AI 能不能拿得到信息?

我们的信息架构从围绕人转变成围绕 AI 进行重组。第二个是拿到信息以后能不能做得好,工程基座怎么样——比如 infra、评测体系、反馈闭环构建的情况。第三个是 AI 做得好以后,我们敢不敢放手、能不能信得过,这就是保障体系——验证、观测、约束。

第二个视角是流程层面,即研发流程:从传统的基于人协作的软件开发生命周期,怎么过渡到 AI-Native 的SDLC。

第三个是组织:组织形态、人才画像是什么样的,角色边界应该怎么划分,怎么样有一套新的评价体系,以及组织拓扑、组织治理与文化。

Image

先看工程环境这一层。工程环境可以认为是一套广义上的 Harness Engineering。大家都在聊 Harness Engineering 应该怎么做,以及关于 Loop Engineering 的讨论。我今天更想分享是:我们应该把重点放在哪儿,哪些是真正应该投入的。我们的出发点是 AI 的能力在持续涌现,但很多东西是它内化的,比如工程脚手架里我们给模型打的一些补丁——但哪些是它真正内化不了的?就是企业里面的事实、判断和责任。

第一个是事实:模型能力再强,它并不能知道你此刻系统的真实状态。所以第一个要投入的是让模型能看到正确的世界——包括信息架构的重组、私域基础设施的 AI 友好化、面向企业内的知识工程。

第二个是判断:定义什么是对的、好的,这只能由我们自己来定义。验证工程和评测驱动是把判断力固化为系统和组织能力的一种最关键的方式。也有一个观点我非常认同:我们有没有把最优秀、最高效、高绩效的工程师放在评测体系里面,这是 AI 化能否成功的关键。

第三个就是责任:AI 模型能力越强,守底线就越重要。AI 的能力边界越来越大,它对应的自主半径会扩大,潜在的爆破半径也会扩大。但如果 AI 闯了祸,真正承担代价的还是我们自己。所以这三个层面非常重要:第一个是工程的卓越性,即当前的技术水位;第二个是工程保障,质量稳定性、安全等方面;第三个是持续的工程治理,通过约束可见、回滚、应急预案等兜底机制和响应机制来确保底线守得住。

Image

再看研发流程层面,我们希望的是一个 Agent 驱动的 SDLC。传统方式是在 AI 增强下,基于多阶段、多角色协作流程,只是把 AI 加进来了,所以有很多损耗。目标态是意图驱动、面向结果的端到端交付。

但很多场景目前很难一步到位,我们的渐进思路是:先把协作和执行做一个分层。人与人之间的协作在这个阶段完全避免不了,我们就先把它分层——比如产品、设计、研发之间有一些接力,能不能把人之间的协作变得更松散?人与人之间比较擅长松散、模糊和创造性的沟通,而 Agent 擅长的是结构化、确定性的、可重复的执行,所以把这两层分开。让人把所有需要对齐的事前置消化掉——意图对齐、决策冻结,全部在这一层完成,不让协作摩擦渗透到 Agent 执行链路里。

在中间通过工具让产出能被 Agent 消费:比如给产品在生产力工具里,通过 Skill 或工具化的方式,把意图转化成结构化的 Spec;或者通过 Design Agent,让设计师构建出更贴合实现的视觉稿以及局部场景;还可以通过原型驱动的开发来降低损耗,避免通过 PRD 或设计稿进行信息交接。人在上面自由沟通,工具自动把各自的产出汇合成结构化的 Specs。经过人的审核、决策冻结之后,协作摩擦前置消化掉,保持执行链路的 AI 高自主。

四、组织进化:协作重塑与人才重构

Image

第四部分就是组织的变革、协作的进化以及人才的重构。组织的这一层是整个变革最深的,同时在千人团队里,组织的惯性阻力肯定很大。所以我们首先做先锋的试点和验证,蹚出一些路,然后再做规模化的复制。

在技术栈这个层面,我们之前是按技术栈来切分的,逻辑是:自己交付的功能、自己写的代码和自己守护的代码,是一拨人,因为只有他们最懂这套代码。但在AI时代,这个逻辑被打破了——当一个 AI Agent 能帮前端工程师写出相对合格的后端代码,或者反之,继续把交付和守护绑在一起,反而会让效率变成瓶颈。所以我们把交付和守护做了一个分层:交付层把前端后端这些职能抹平了,定义它叫做功能 Owner,通过AI协同完成交付。

但守护还是需要专业的人,也就是目前技术栈团队的架构师,负责定标准、建机制、守门禁这些方向。经过组织机制和形态的渐进式过渡,我们发现这样以后可以完成单人闭环,协作摩擦也会降低。

Image

前面讲的都是研发内部协作和组织设计的变化,产研之间其实也会发生一些变化。很多需求的判断并不一定都在研发——设计优化的判断力在设计师,运营需求的判断力在产品运营。所以另外一个思路是主动赋能这些角色,让他们有能力自己交付。

那这样是不是有一些需求可以不经过研发?所以我们做了一些事情,比如给设计师构建自主交付的能力,给产品构建自主交付的通道。当角色边界溶解以后,研发系统正在从所有需求的默认承接方变成复杂专业问题的承接方,工程师的工作会更聚焦,同时也能向更多可能性延展。

Image

接下来是组织层面的画像。在人才结构之前,得先回答一个问题:在 AI 变革的时代,我们的组织到底需要什么样的工程师。所以我们尝试做了一些人才画像的定义。最终的观点是:AI 时代工程师的价值是底层特质乘以能力基座乘以核心杠杆。

五、三个叩问:洞察、远见与温度

前面都是在讲效率,但 AI 时代技术团队的边界价值是不是只是让交付更快更多呢?研发提效本身也只是一个起点,AI 时代技术团队需要从高效交付走向价值共创。这里引用蚂蚁的 CTO 梁纥老师的一个类比:玻璃最早在欧洲发明以后,传到了东方。

Image

最早玻璃被当做器皿的改良——之前都是用陶瓷杯,现在变成玻璃杯,它是一种奢侈品。但在西方,人们用它打造出了镜片,有了镜片以后就有了显微镜,所以才有了现代医学;有了望远镜,才有了天文学和物理学。所以我们怎么看待这个玻璃呢?是把它当做器皿继续喝水,还是用它做成显微镜和望远镜?AI 今天做成了一个杯子,它会替代很多当下的工作,但我们依然只把它当杯子,没有用它去做真正有价值的事——找到真正的望远镜,去发现新的机会和洞察新的价值。所以我们希望能看到更多看不到的业务可能性。

举一个具体的案例:我们是怎么从业务共创的视角去思考,重塑一些产研运营的流程设计的。这是一个直播场景礼物设计的整体流程和机制。在过去我们也在用 AI,在各个环节里把 AI 集成进来。

Image

比如当一个人构思好礼物内容创意以后,他会选择模型去生成、去抽卡,最后人去审稿——这个过程能不能重新思考?因为它还是围绕人去设计的流程,人的认知、时间和精力都是瓶颈。所以我们重新思考:人和 AI 在这件事里的边界和分工是什么样的。于是做了一些探索,发现AI可以做方向剧本、分镜、美术的专业制作,通过 AIGC的agent来完成;AI Agent Tools 能提供生成、剪辑和合成;评审、验证、评测都可以通过 Agent evaluation 来做;以及消费付费特征因子的反馈。人在这个过程中就上移到定义目标、标准和关键方向。这是一个案例,我们希望将过去业务中的流程和行为进行拆解,以 AI 为中心重新思考和设计。

Image

在 AIGC 这件事上我们也达到了非常好的效果,包括业务效率、商业形态,还有用户参与度和生态。最后看一下当前的阶段性成果。在研发范式方面,大盘目前 L2 的需求已经成为主流范式—— L2 相对于 L1,交付周期大概缩短了20%到30%;L3 在一些运营类的特定场景里,跑出了一些稳定的实践,能看到大幅度的交付周期缩短和整体提效。在业务价值层面,我们在多个业务方向上都贡献了显著的业务收益和增量。这是我们 AI DevOps 的整体全景大图。

Image

再往前看,前面这些历程其实一直有很多困难和波折,同时也遇到了一些关键的问题,这也是我们目前仍然在持续探索的。比如验证能力的规模化,尤其是在 C 端场景,怎么做好稳定的验证,确保稳定性、适应性,以及整个验证的效率和质量。第二个是先锋队的模式探索——在千人规模下需要有一些先锋团队先冲到前面,但这些先锋队的灵活性和未来泛化的标准化之间应该怎么平衡,也是我们仍在尝试攻克的难题。

Image

前面我们在讲范式和组织进化,但在这场变革中,AI真正的重塑,最终落到的是每一个人。所以这里我想分享三个自己最近在问的问题。

第一个问题是关于洞察:看得见的是知识,看不见的是品味、洞见和判断。我们的组织能不能让看不见的价值被看见,给它一个位置和认可?

第二个关于远见:人人现在都能加速,大家都在追求更多新工具,更快、更及时的结果。但有没有一个瞬间能停下来看一看——稀缺的是一个能够为判断留出时间、为方向留出耐心的定力。我们的组织有没有为这份定力留出空间?

第三个是关于温度。AI 抹平了入门的门槛,很多 Junior 工程师上手都能用 AI 出活,效率也很高。但我们这一代古典工程师,很多东西是靠一行一行写出来的、靠一个一个 bug 调出来的——对代码的手感、对优雅设计的审美、对系统的敬畏、面对复杂问题时的直觉,对严谨性和确定性的坚守。这些以前是在慢慢写的过程中长出来的,当 AI 跳过了这个过程,谁给他试错的空间?谁在他犯错的时候说“没关系,这个坑我当年也踩过”?所以问题是:我们的组织有没有在追求快速产出的同时,给年轻人留出更多生长的机会?

Image

对于这些问题,我现在还没有标准答案,但有一点越来越清晰:AI 让组织更强,而好的组织进化,也能让人的洞察、远见和温度更充分地生长。范式在变,组织在变,不论系统怎么演进,最终底色都是我们每一个工程师、每一个创造者。我们希望在这场变革中,每个人都能找到属于自己的价值和可能。希望在追求工程理性的尽头,也能活得更丰盈、自洽且无可替代。

团队介绍

快手主站技术部是负责快手 app 和快手极速版 app 的核心业务研发团队,服务于数亿用户每天时长上百分钟的使用,专注于打造极致且高效的生产、社交、消费、直播、运营、增长、房聘、孵化等业务研发体验;同时也是快手最大的技术部门之一,拥有业界资深的大前端、服务端、质量等团队,承担着核心业务需求迭代、超高并发服务开发,春节、奥运、暑期等大型活动工程技术保障,以及业界领先的基础技术建设等任务。

通过与产品、算法、设计、运营等各团队的紧密协作,主站技术践行 AI Native 理念,以数据驱动的方式,不断追求用户体验及技术架构上的最高标准,持续优化研发效率、质量和成本。一方面不断通过技术赋能业务,持续拿到业务指标上的正向收益;一方面也在积极探索最新的技术方向,产出了如 AIGC、M0、GUI-Agent、跨端动态化、端智能等业界领先的技术方案。

点击【阅读原文】,获取讲师PPT!

参考阅读

阅读原文

跳转微信打开

  •  

吴恩达最新思考:从分钟到天,AI产品如何靠三层Loop迭代

高可用架构 2026-07-02 15:38 广东

导读:吴恩达(Andrew Ng)在 the batch 上最新发表文章中详细阐述了“循环工程”(Loop engineering)这一 AI agent 开发热门概念,介绍了构建 0-to-1 产品的三个关键循环:Agentic 编码循环(分钟级)、开发者反馈循环(小时级)和外部反馈循环(天级),并配以循环示意图。

亲爱的读者朋友们:

Boris Cherny(Claude Code 的创造者)和 Peter Steinberger(OpenClaw 的创造者)提到 “loop engineering” 后,这个词在社交媒体上火了。循环现在已经成为我们让 AI Agent 长时间迭代、构建软件的关键方式。在这封信里,我想分享自己用于从 0 到 1 构建产品的 3 个关键循环,如下图所示。这些循环不只指导我如何构建软件,也指导我决定要构建什么软件。

Agentic coding loop: 给定一份产品规格,可选地再给一组 eval,也就是用于衡量性能的数据集,我们可以让 AI Agent 编写代码、测试自己的工作,并持续迭代,直到代码没有 bug 且符合规格。这个闭环思路在去年年底前后开始流行,它彻底改变了 coding agent 的工作方式,让它们可以在没有人工介入的情况下更长时间地持续产出。比如上个周末,我在给女儿做一个打字练习应用,我的 coding agent 可以轻松工作大约一个小时,期间多次使用 web 浏览器检查自己构建的结果,然后再回来找我,全程不需要我介入。

工程循环执行得很快。每隔几分钟,coding agent 可能就会构建并测试一个新版软件。我经常听到开发者分享他们发现的新方法,用来设计更有效的工程循环。这是一个非常活跃的创新领域。

Developer feedback loop: 在这个循环里,开发者检查当前产品,并引导 coding agent 继续改进。去年,很多开发者,包括我自己,都在为自己的 coding agent 扮演 QA(质量保证)角色,手动找 bug,再让 Agent 修复。但随着 coding agent 更有能力测试自己的代码,我们需要花在这项职能上的时间已经显著减少。这样我们就能做更高层次的产品决策,例如应该提供哪些关键功能,UI 哪里需要改进,等等。

开发者反馈循环的时间尺度通常是几十分钟到几小时,这大致就是开发者审查产品并给出反馈的频率。以那个打字应用为例,我几次改变主意,调整视觉设计、孩子在学习过程中可以解锁哪些猫咪服装(她喜欢猫),以及成年人登录并引导孩子学习体验的用户流程。

3 Key Product Development Loops: Agentic Coding Loop (minutes), Developer Feedback Loop (hours), External Feedback Loop (days)
3 Key Product Development Loops: Agentic Coding Loop (minutes), Developer Feedback Loop (hours), External Feedback Loop (days)

3 个关键产品开发循环:Agentic Coding Loop(分钟级)、Developer Feedback Loop(小时级)、External Feedback Loop(天级)

开发者对要构建什么有清晰的愿景,但把这个愿景转化成 coding agent 能执行的规格,工作量仍然不小。此外,在开发者看到一个实现之后,他们可能会更新,或者进一步澄清规格,把它引向自己真正想要的方向。如果你发现系统反复遇到某些问题,为 Agent 构建一组 eval 就会很有用。

AI 原生团队越来越多地用 AI 帮助塑造产品方向,例如自动收集和分析使用数据,总结书面和口头客户反馈,或者做竞品分析。不过,对于我参与的几乎所有产品,我都认为人类相对于当前 AI 系统拥有显著的上下文优势。我们比 AI 系统更了解用户,也更了解产品所处的使用场景,因此人类仍然扮演关键角色。很多人把这种人类贡献称为“品味”,但我更愿意把它理解为人类拥有上下文优势,因为这种说法给了我们一条更清晰的路径,去帮助 AI 系统变得更好。这也解释了为什么这一步无法自动化:只要人类知道 AI 不知道的东西,就需要 human-in-the-loop,把这些知识注入系统。

External feedback loop: 这包括一系列广泛的策略[1],比如请几位朋友反馈、发布给 alpha 测试者,或者把代码上线到生产环境配合 A/B 测试。这些策略通常很慢,很少能在几个小时内完成,有时需要几天甚至几周。这些数据会影响开发者愿景[2],开发者愿景继续驱动详细产品规格,产品规格再驱动 coding agent。

随着 coding agent 加速软件开发,更多工程师开始承担部分产品管理角色。对很多正在成长到这个角色中的工程师来说,最难的部分是塑造产品愿景,并在构建和获取用户反馈之间取得平衡。这里的构建,指的是弥合愿景与规格之间的距离;用户反馈,则用于不断演化愿景。两件事都很重要。

我以后会写更多关于如何做到这一点的内容。不过现在,让我感到鼓舞的是,工程师正在承担更广泛的角色,正如产品经理和设计师现在也在做更多工程工作一样。

继续构建!

吴恩达

参考阅读

References

  1. 策略: https://www.deeplearning.ai/the-batch/how-to-get-user-feedback-to-your-ai-products-fast?utm_campaign=The%20Batch&utm_source=hs_email&utm_medium=email&_hsenc=p2ANqtz-9IU5WWvlZnFv4GFOY2DPAg8PWrnhPB_aFANXt2LIg2tC97Y7bMJ07wp5JEddrBEnV27XVg
  2. 开发者愿景: https://www.deeplearning.ai/the-batch/how-to-get-through-the-product-management-bottleneck?utm_campaign=The%20Batch&utm_source=hs_email&utm_medium=email&_hsenc=p2ANqtz-9IU5WWvlZnFv4GFOY2DPAg8PWrnhPB_aFANXt2LIg2tC97Y7bMJ07wp5JEddrBEnV27XVg
  3. 原文 https://www.deeplearning.ai/the-batch/issue-359

跳转微信打开

  •  

GIAC 2026 圆满落幕:AI Native 进入深水区,技术组织如何重构?

高可用架构 2026-06-27 18:57 中国香港

Image

6月26-27日,由msup和高可用架构联合主办的 GIAC 全球智能应用开发与架构大会,在深圳好日子皇冠假日酒店隆重举行。本届大会紧扣「大模型产业化落地」这一核心议题,集结了快手、字节跳动、腾讯、喜马拉雅等一线研发创新负责人,共同呈现50个源自真实业务场景的前沿架构案例。议题全面覆盖生成式AI、AI安全、Agentic AI、多模态等年度热点技术方向,每个案例均经过严格筛选,确保为参会者带来可落地的工程智慧与创新灵感。

Image

开幕式精华

本届大会开幕式,立足2026年技术新坐标,以 “从模型到产品,从产品到产业” 为主线,为现场500+听众呈现年中首场硬核架构实践,确保每一位参会者带走的不只是趋势判断,更是可复用的工程范式。如下是5位大咖的干货分享:

刘付强:用工程师文化构建 AI-Native 组织

_

Image

msup创始人兼CEO、微上信息技术研究院院长刘付强以“用工程师文化构建 AI-Native 组织”为题进行分享。他指出企业不应仅仅停留在工具使用或Token消耗的层面,打造 AI-Native 组织的核心在于实现“从研发层到经营层”的认知升维,将技术真正融入商业模式的血液中。他基于最新的实战观察,提出了迭代后的“DRIVE”模型,以五个维度构建组织竞争力的护城河:

关键实践一:技术战略解码,从“支撑”走向“引领”。摒弃“用技术的勤奋掩盖战略的懒惰”。重新定义技术委员会在组织中的定位,使其不只是技术选型部门,而是由一号位主导,预判拐点、制定三年至五年“技术战略屋”的核心部门,确保技术直接驱动商业增长与收入模式的重构。

关键实践二:团队认知重塑,实现“战略与能力的上下同欲”。不仅是工程师的技能升级,更核心的是一号位及中高层对AI战略的认知对齐。通过“训战营”而非单一培训,通过定标、对标、达标,打通从战略意图到一线落地的链路,确保左膀右臂与核心岗位能够承接并执行AI战略。

关键实践三:构建试错土壤,培育智慧涌现的机制。好的管理不是控制KPI,而是激发创新。企业应通过设立创新基金、荣誉体系及常态化的“Hackathon”机制,培育容错土壤,鼓励跨部门结对、揭榜挂帅,像种植花草一样为组织注入阳光雨露,让创新自然发生。

关键实践四:跨越技术鸿沟,完成“技术管理”到“技术经营”的转型。识别并规避创新陷阱。科技型领军者需打破“研发即一切”的桎梏,主动向业务向上,向经营靠拢。以CEO的视野审视技术团队,将技术能力转化为商业SaaS模式或结果导向的经营成果,真正实现技术与商业的一体化。

关键实践五:效能生态化,将“组织能力”封装为API。效能的核心从资源储备转向资源的流动性。通过构建企业内部的“API平台”或“MCP模式”,将部门能力封装为易被调用的Skill。不仅要成为被企业内部调用最频繁的模块,更要努力成为外部生态可调用的高效节点,实现组织能力的数字化封装与价值释放。

蒋力:
Google Cloud Agentic AI 打造出海“超级引擎”

_

Image

Google Cloud AI GTM 专家蒋力为大家带来了《Google Cloud Agentic AI 打造出海“超级引擎”》的话题分享。AI正从单一模态和效率工具,全面演变为驱动业务增长的超级引擎。从纯文本拓展到原生多模态,从试点工程迈向大规模生产落地,AI已经发生了质变,并催生了以Token为核心的新经济模式,标志着Token经济已从概念走向实实在在的爆发。

面对这一趋势,Google自身正全面转型为AI-first组织。在底层配备了从训练到推理的全链路专用芯片,为海量AI原生应用提供坚实支撑。

对于企业出海而言,Google Cloud提供了独一无二的全栈式AI解决方案。从底层算力、自有大模型到上层应用,均由统一技术栈深度优化,实现效率的指数级提升,已帮助众多全球用户大幅节约成本、提升服务响应速度。同时,Google Cloud也是提供生成式AI训练与输出数据赔偿保证的云服务商,全面覆盖数据、版权及合规风险,并通过数字水印等技术确保资产可追溯。Google Cloud期待与更多企业携手,借助Google的AI超级引擎与全球生态,在全球市场扬帆远航。

李思:迈向AINative:技术团队的范式跃迁与组织进化

_

Image

快手主站 AIDevops 负责人李思带来了《迈向AINative:技术团队的范式跃迁与组织进化》的精彩分享。他分享了三个模块,分别是宏观判断、千人级实践和组织进化。这不是一个成功故事,而是一个还在演进的过程。

89%的企业已把AI投入实际业务,但生产力提升只有0.29%。DORA报告也显示,个体效能上去了,组织效能却没变。AI到位了,研发体系还是老样子,必须围绕AI重新设计。

过去一年踩了不少坑。24年下半年代码生成率从17%涨到30%,交付周期却没变。后来发现只有不到10%的工程师真正变了,差异不在用不用AI,而在有没有改变工作方式。快手把范式分成L1辅助、L2协作、L3自主,走两条路:L1到L2铺开,L1到L3特定场景突破。但个人快了组织没快,AI越快人和人协作摩擦越大,人机摩擦也成了新负担,根源在围绕人设计的结构卡住了AI。

解法就是三层重构。信息层面让AI能拿到知识,流程层面从串行改成Agentic模式,组织层面交付和守护分开、产研边界溶解。后面直播礼物的案例就是三层重构的落地缩影——方向、分镜、生成、评审都由Agent做,人只定目标,上新周期从20天压到4天以内。目前L2已成主流范式,较L1周期缩短20%到30%。

往前看还有验证规模化和先锋队模式两个难题。但说到底,变革落在每一个人身上。知识能被看见,品味和判断却很难,组织得给这些看不见的价值一个位置。人人都在加速,也要给远见留空间。AI跳过了慢慢写的过程,更要给年轻人慢慢生长的机会。范式在变,组织在变,底色永远是每一个工程师。

张宏波:
从“会生成”到“可交付”:AI时代的软件工程、语言上限与可靠性

——以MoonBit生态增长与大规模迁移实践为例

_

Image

来自粤港澳大湾区数字经济研究院基础软件中心首席科学家张宏波,带来了主题为《从“会生成”到“可交付”:AI时代的软件工程、语言上限与可靠性——以MoonBit生态增长与大规模迁移实践为例》的精彩分享。他认为,AI原生编程语言完全有可能。尽管有人质疑新语言缺语料,但过去半年用AI复制MoonBit生态的经验表明,软件工具链重构后,编程语言作为AI入口,值得为智能体全新设计。

AI时代软件工程面临四大挑战:可维护性—AI代码难转成长期资产;工具链碎片化—传统工具分散,AI上下文有限无法拼接;可靠性—Copilot生成代码三到四成有漏洞,人已无力审查;部署难—跨平台分发仍是瓶颈。

新语言能做减法:语言层减少历史包袱、提供更强护栏;反馈层统一编译、测试、诊断,让AI快速迭代;部署层一套代码输出Wasm/JS/Native,降低学习成本。但冷启动需3-4年高强度投入积累语料。意大利学者论文显示,MoonBit语料仅Gleam七分之一时,AI生成效果反而更好,证明AI友好设计确有其事。

通过类型系统和语义重构接口保障可维护性;将编译器、构建、IDE等统一到moon入口,解决碎片化;引入形式化验证确保安全;多后端和轻量Wasm支持跨平台部署,自带沙箱保护IP。整个生态可自动包装成Agent Skill,如PPT库编译为Wasm后无需安装即可调用。MoonBit的定位不只是一门语言,而是从语言设计开始的垂直整合软件生产线,覆盖编译、构建、测试、验证到部署全链路。

李朝明:
CLI原生·Agent共生——快递100的AI Native实践与开放生态

_

Image

快递100产研中心负责人李朝明带来了《CLI原生·Agent共生——快递100的AI Native实践与开放生态》的主题演讲。他表示,快递100 从2010年成立以来,一直在回答客户三个问题:货发了没有、货到哪里了、什么时候能到。去年快递100发布了中国首个快递物流网络数智图谱,通过AI加Data的能力,首次真正回答了“什么时候能到”这个困扰行业多年的问题。三个问题都回答完之后,这次会上又提出了新三问——用什么快递公司寄最合适、快递员什么时候上门取件、出了问题怎么办——其实都在回答同一个命题:快递物流的确定性。

经过一年进化,快递100网络数智图谱覆盖度从10家拓展到近15家主流快递公司,智能时效预估已服务超千家企业的5亿次调用。今年还衍生出新能力“智选运力”,能精确到小区楼栋,根据客户的位置和寄件需求,从网络图谱里推荐最匹配的快递品牌和运力,让确定性服务真正落地。

在AI Native的探索中,快递100总结出适用于他们的AI领创方法论,也就是端云协同+两个结合+CLI&Skill&MCP。他们把自己的能力封装成三大AI原语——CLI是命令管道,让AI直接调用;Skills是封装好的意图加执行链,指导AI如何使用;MCP是标准化协议,任何遵循MCP的AI都能接入。这三者共同构成AI可理解、可执行的原子化能力。

基于图谱和原子化能力,快递100还推出了全流程经营Agent“果宝”。它不是一个对话框,而是能独立上岗的数字员工——面向个人是AI快递助手,面向企业是AI快递管家,面向快递员是AI快递小哥。果宝具备自我进化能力,能够每天复盘工作、补齐知识,越用越聪明。

李老师分享结束后,小芒电商产研总监兰勇、雷赛智能IT总工涂楠、中捷通信有限公司物流事业部总经理助理兼电信业务中心经理兼翼快递孵化中心经理黄志中、北京芬香科技有限公司研发负责人苏金波、广东省快递行业协会秘书长助理何惠娟、Msup创始人兼CEO暨微上信息技术研究院院长刘付强、快递100总经理陈登坤、快递100副总经理兼首席产品体验官陈武强等八位嘉宾共同上台,见证快递100 AI Native新品发布。

Image

从代码开发到智能系统交付:

Agentic Coding 时代的

程序员新范式

本次开幕式新增了圆桌对话环节,GIAC 发起人,高可用架构发起人Tim Yang作为主持人、AfterShip CTO 洪小军、Lovstudio.ai创始人手工川、盛大集团EverMind COO韩云芸三位嘉宾,分享了各自领域的关键突破:

Image

关于程序员数量,大家的共识是传统写代码的岗位会减少,但更综合、更复合的高级群体会增加,编程会像数学一样成为普遍技能。在真实研发实践中,目前很多团队已无人写代码,全流程由AI和Agent串联,但挑战在于与外部协作仍需人类处理,同时要用更充分的上下文、更完善的验证和权限控制来应对AI犯错。关于新人该学什么,数据结构、计算机组成和哲学是基础,但学会学习、掌握与AI沟通的方式更重要。资深工程师的价值不可替代,他们能端到端负责事情、做关键决策和促成团队协作,懂得AI的边界,知道什么时候需要兜底。招聘和晋升时,大家更关注候选人做了什么、能否让一群人变快,以及是否有解决过棘手问题和展现Humanity关怀的特质。判断力、协作能力和对AI边界的理解,是未来工程师最稀缺的能力。

至此,GIAC开幕式圆满结束,各位嘉宾纷纷表示收获满满,期待明年和大家再聚。

跳转微信打开

  •  

别只盯着模型:Agent 真正的护城河,是这四层循环

高可用架构 2026-06-17 11:36 广东

为什么你的 Agent 总是跑不稳?你可能只搭了第一层

导读:本文由 LangChain 开源开发者 Sydney Runkle 发布,指出循环设计能显著提升 AI agent 的有效性和自主性。

文章详细介绍四种循环:代理循环、验证循环、事件驱动循环和爬山循环,并展示如何用 LangChain 原语组合实现。这些循环通过自验证、事件响应和轨迹优化等机制,帮助开发者在不更换模型的情况下改进 agent 表现。

Image

Agent 之所以有用,是因为它们能通过在现实世界中采取行动,帮助我们自动化工作。但要让 Agent 可靠地完成有价值的工作,不能只靠一个好模型,还需要一个精心设计、适配一组任务的运行框架。

Agent 的核心算法很简单:给 LLM 上下文,让它在循环中调用工具,直到任务完成。这是最基础的循环。但驱动 Agent 的循环远不止这一种。@swyx[1] 最近写了一篇很好的文章,讨论 "loopcraft: the art of stacking loops"[2],也就是通过叠加和扩展循环来构建更有效的 Agent。

下面是我们理解这组循环栈的方式,以及如何用 LangChain 的基础组件为每一层加上观测和控制。

循环 1:Agent

Agent 的核心,其实就是模型在循环中调用工具,直到任务完成。

Image

这正是 LangChain 的 create_agent[3] 提供的能力。选择任意模型,接入工具,你就有了一个可以工作的 Agent 循环。工具让 Agent 具备了在现实世界中采取行动的能力。

以我们的内部文档 Agent 为例,后文也会继续用它作为贯穿示例。在第一层循环中,它会收到一个改进文档的请求,模型进行规划并起草修改,然后用工具克隆仓库、读取文件、编写文档、打开 pull request,等等。

Image

第 2 层:验证循环

Agent 循环可以完成工作,但它第一次产出的结果并不总是正确或一致。当一致性很重要时,通常值得在外面包一层验证循环,用来检查输出,并在结果不达标时把反馈发回给模型。

Image

验证循环会加入一个评分器:它根据评分标准检查 Agent 的输出。如果检查失败,就把结果和反馈一起发回。评分器可以是确定性的,也可以是 Agent 式的,这里经典例子就是用 LLM 作为裁判。

RubricMiddleware[4] 可以处理这种模式,你也可以在 create_agent 的 after_agent hook 里自己接起来。

回到文档写作 Agent 的例子,评分器会在每次尝试后运行测试,检查所有链接是否可访问,所有 CI 检查是否通过,diff 是否只覆盖实际请求的范围。捕获这几类错误不需要人工审核。

Image
Image

一个权衡是:加入验证会增加每次运行的延迟和成本。当质量比速度更重要时,它是值得的,而大多数生产用例都属于这种情况。

第 3 层:事件驱动循环

Agent 开发中最重要的部分之一是集成层:把 Agent 连接到你的生态系统里,让它可以在后台运行。

事件驱动循环会把 Agent 连接到你的生态系统。一个事件触发了,新文档落地、定时任务启动、webhook 到达,然后 Agent 开始运行。Agent 不再是一个需要你手动调用的东西,而是在更大系统中持续运行的组件。

Image
Image

LangSmith Deployment[5] 支持触发器基础设施,包括 cron 定时任务和 webhook。cron 的一个常见例子是 openclaw[6] 中的 “heartbeats”,它们会把你的 Agent 变成一个始终在线、主动工作的助手。

我们的文档 Agent 由 Fleet[7] 驱动,这是我们的无代码 Agent 构建器。Fleet 的 channels[8] 和 schedules[9] 负责事件驱动和 cron 风格的触发。我们使用一个 channel,在有人向我们的 #docs[10]-plz Slack 频道发送消息时触发文档 Agent。

Image

第 4 层:爬坡循环

前三个循环自动化的是工作。第四个循环,也可以说是最重要的循环,自动化的是改进。

Image

每次 Agent 运行都会产生一条 trace:它记录模型做了什么、调用了哪些工具、评分器反馈是什么,等等。这些 trace 里包含很有价值的信息,能说明哪些地方有效,哪些地方无效。爬坡循环会让一个分析 Agent 读取这些 trace,并根据发现重写运行框架,给出改进后的配置。这可能包括调整 prompt、工具或评分器。

在 LangSmith 中,你可以用我们的 trace 分析 Agent Engine[11] 来搭建第四层循环。

继续回到文档 Agent 的例子:我们让 Engine 分析文档 Agent 的 trace 来发现问题。当多条 trace 都指向一个潜在问题时,系统会提交一个 issue,要求修改出问题的 prompt 或工具。

Image

这里的关键动作是,返回箭头没有只是回到最上层,而是伸进内部,直接更新 Agent 循环。外层循环每跑一轮,都会让内层循环更有效。

展望: prompt 和工具配置是最简单的改进对象,但选择并不止于此。对于运行开放权重模型的团队来说,爬坡循环可以接入 RL 微调,把 trace 或 eval 结果作为训练信号,用来改进模型本身。记忆、检索到的技能等辅助上下文,也可以用同样方式改进。循环是一种模式,它要优化什么,取决于你。

人类监督与专业判断

自动化并不意味着把人从循环中移除。在每一层,都有一些自然的位置适合加入人类监督。自动评分器可以检查链接是否可访问;但要发现表达方式是否适合目标读者,需要人来判断。这种来自上下文、经验和品味的判断,正是人工审核的价值所在。

有些专业知识应该被固化进 prompt 和工具本身,但对于敏感操作,实时人工审核是必要的,比如金融交易、数据库操作等。LangChain 让你可以直接在每一层循环里接入这些触点:

  1. 在 Agent 循环中,对敏感动作或工具调用要求人工输入
  2. 在验证循环中,让人类为敏感工作流担任评分器
  3. 在应用循环中,输出返回给最终用户之前由人类批准
  4. 在爬坡循环中,运行框架的改进在部署前经过人工审核

LangChain 的所有开源框架都把 “human in the loop” 做成了一等公民[12]。

合在一起看

如果你更喜欢表格形式,下面是这四个循环如何叠在一起:

循环做什么影响LangChain 基础组件
1:Agent 循环(模型 + 工具)模型反复调用工具,直到任务完成自动化工作create_agent,任意 LangChain 支持的模型
2:验证循环(Agent + 评分器)Agent 运行,输出按评分标准打分,失败则带反馈重试保证质量RubricMiddleware
3:事件循环(验证 + 系统)事件触发 Agent 运行,并更新真实系统规模化工作LangSmith Deployment / Fleet channels
4:爬坡循环(系统 + 引擎)生产 trace 进入分析 Agent,用来改进运行框架配置持续改进LangSmith Engine

这就是循环工程,或者按 @swyx[1] 的说法,loopcraft[2] 在实践中的样子。像 Steipete[13]、Boris[14] 和 Andrej[15] 这样的 AI 领导者,都已经得出了同一个结论:Agent 的潜力在于你围绕它们构建的循环。

我们已经思考循环 1 和循环 2 很久了。但现在焦点应该转向循环 3 和循环 4:把 Agent 嵌入你的生态系统,并让它们持续根据你的标准改进,价值会在这里持续累积。

Satya 这样描述组织层面的利害关系[16]:那些早早建立学习循环的公司,让人类判断和 token 资本一起持续累积,将建立一种很难复制的优势。

致谢

感谢 @Vtrivedy10[17]、@masondrxy[18]、@hwchase17[19] 和 @huntlovell[20] 的认真审阅。

参考

  • deepagents quickstart[21]
  • create_agent docs[3]
  • rubric middleware[4]
  • cron jobs[22], webhooks[23]
  • langsmith engine[11]
  • fleet channels[8]

参考阅读

References

  1. @swyx: https://x.com/@swyx
  2. "loopcraft: the art of stacking loops": https://www.latent.space/p/ainews-loopcraft-the-art-of-stacking
  3. create_agent: https://docs.langchain.com/oss/python/langchain/agents
  4. RubricMiddleware: https://docs.langchain.com/oss/python/deepagents/rubric
  5. LangSmith Deployment: https://info.langchain.com/agent-development-platform?utm_campaign=evergreen_agent_development_platform_cv&utm_campaign_id=23761370321&utm_ad_group_id=195261126163&utm_ad_id=805594028616&utm_network=g&utm_term=ai%20agent%20development%20platform&utm_campaign=evergreen_agents_cv&utm_source=google&utm_medium=cpc&hsa_acc=7906965105&hsa_cam=23761370321&hsa_grp=195261126163&hsa_ad=805594028616&hsa_src=g&hsa_tgt=kwd-2392721013549&hsa_kw=ai%20agent%20development%20platform&hsa_mt=p&hsa_net=adwords&hsa_ver=3&gad_source=1&gad_campaignid=23761370321&gbraid=0AAAAA-PkievTcIb-6awevyQxCB-9n-H6Z&gclid=CjwKCAjwxb7RBhA5EiwAQ-AAdF5XHKtTYLgQVrVYstdxYjTd0hcrCuqxvuACiKzOOdxcJdTza8HkwxoCDiQQAvD_BwE
  6. openclaw: https://docs.openclaw.ai/gateway/heartbeat
  7. Fleet: https://www.langchain.com/langsmith/fleet
  8. channels: https://docs.langchain.com/langsmith/fleet/channels
  9. schedules: https://docs.langchain.com/langsmith/fleet/schedules
  10. #docs: https://x.com/search?q=%23docs&src=hashtag_click
  11. Engine: https://www.langchain.com/langsmith/engine
  12. 一等公民: https://docs.langchain.com/oss/python/deepagents/human-in-the-loop
  13. Steipete: https://x.com/steipete/status/2063697162748260627
  14. Boris: https://x.com/0xwhrrari/status/2064804504608887040
  15. Andrej: https://www.youtube.com/watch?v=kwSVtQ7dziU
  16. 这样描述组织层面的利害关系: https://x.com/satyanadella/status/2066182223213293753
  17. @Vtrivedy10: https://x.com/@Vtrivedy10
  18. @masondrxy: https://x.com/@masondrxy
  19. @hwchase17: https://x.com/@hwchase17
  20. @huntlovell: https://x.com/@huntlovell
  21. deepagents quickstart: https://docs.langchain.com/oss/python/deepagents/quickstart
  22. cron jobs: https://docs.langchain.com/langsmith/cron-jobs
  23. webhooks: https://docs.langchain.com/langsmith/use-webhooks
  24. 原文 https://x.com/sydneyrunkle/status/2066928783534289358

如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 举办的 GIAC 深圳站值得关注。这次大会将集中讨论智能应用开发、架构演进,Loop Engineering 以及来自一线实践的经验与案例。

高可用架构读者可使用专属购票优惠码 UOp5XJcq,点击阅读原文进入购票页面即可使用。

Image

阅读原文

跳转微信打开

  •  

4000行代码撑起一个Agent框架?nanobot架构深度解析

俞孟凡 2026-06-16 12:15 广东

以下文章来源于:腾讯云开发者

腾讯云开发者

腾讯云官方社区公众号,汇聚技术开发者群体,分享技术干货,打造技术影响力交流社区。

香港大学数据科学实验室(HKUDS)的 nanobot,2026 年 2 月初开源,30 天内:

  • 28,500+ GitHub Stars

  • 8 次大版本发布

  • 核心代码 3,935 行

对比项:LangChain 核心代码 430,000+ 行。

这个反差值得认真分析。这篇文章拆解 nanobot 的每一个设计决策,包括它的优势、局限,和可以借鉴的架构模式。

01

整体架构:控制面集中化

先看全局结构:

    Chat Platforms (13 channels)
             ↓
       MessageBus (asyncio.Queue)
        inbound / outbound
             ↓
       AgentLoop(核心控制面)
        ├── SessionManager  → 历史对话加载
        ├── ContextBuilder  → system prompt + messages 组装
        └── while loop: LLM → tool calls → execute → append → LLM...
             ↓
      ┌──────────────────────────────┐
      │ ToolRegistry   SubagentMgr   │
      │ exec/fs/web    asyncio.Task  │
      │ spawn/mcp/cron               │
      └──────────────────────────────┘

    这个架构的决定性特征:控制面完全集中在 AgentLoop。

    没有 LangChain 的 Chain/Runnable/LCEL 等编排层,没有 LangGraph 的节点/边/DAG,没有 AutoGPT 的显式 PLAN 步骤。所有决策路径都穿过同一个 while 循环。

    这是个极强的设计约束:可理解性最大化,但弹性空间也随之缩小(后文展开)。

    02

    核心:ReAct 循环的极简实现

    agent/loop.py是整个框架的心脏:

      async def _run_agent_loop(self, initial_messages, on_progress):
          messages = initial_messages
          while iteration < self.max_iterations:   # 默认 40 次
              response = await self.provider.chat(
                  messages=messages,
                  tools=self.tools.get_definitions(),
                  model=self.model,
              )
              if response.has_tool_calls:
                  for tool_call in response.tool_calls:
                      result = await self.tools.execute(tool_call.name, tool_call.arguments)
                      messages = append_tool_result(messages, tool_call.id, result)
              else:
                  final_content = response.content
                  break
          return final_content

      约 20 行,这就是整个 agent 编排逻辑的全部。

      几个关键工程细节值得注意:

      错误响应不持久化到 session history。 防止"400 中毒循环"——如果错误消息存入历史,后续 LLM 调用携带格式错误的 history 会触发 API 400,进而导致更多错误,形成无法自愈的循环。

      工具结果存入 session 时截断为 500 字符。 当前 turn 内 LLM 能看到完整结果,但历史记录只保存摘要。这控制了上下文增长速率,代价是跨会话的工具结果不可追溯。

      错误处理只有一行:

        if result.startswith("Error"):
            return result + "\n\n[Analyze the error above and try a different approach.]"

        把错误恢复的全部责任交给 LLM。这在 GPT-4 级别的模型上工作,在较弱模型上可能导致无效循环。

        03

        Tool 系统:Python 插件的最小接口

          class Tool(ABC):
              @property
              @abstractmethod
              def name(self) -> str: ...

              @property
              @abstractmethod
              def description(self) -> str: ...

              @property
              @abstractmethod
              def parameters(self) -> dict: ...  # JSON Schema

              @abstractmethod
              async def execute(self, **kwargs) -> str: ...  # 硬约束:必须返回 str

          execute 返回值强制为 str 是个有意思的设计选择。好处是接口统一,LLM 天然消费字符串;代价是结构化数据需要在 execute 内部序列化,丢失了类型信息。

          一个数据库工具示例:

            class MyDatabaseTool(Tool):
                @property
                def name(self): return "query_database"

                @property
                def description(self): return "执行只读 SQL 查询"

                @property
                def parameters(self):
                    return {
                        "type": "object",
                        "properties": {"sql": {"type": "string"}},
                        "required": ["sql"]
                    }

                async def execute(self, sql: str, **kwargs) -> str:
                    rows = await db.fetch(sql)
                    return "\n".join(str(r) for r in rows)

            然后在初始化时注册:

              self.tools.register(MyDatabaseTool(connection_string="..."))

              没有装饰器、没有注册配置文件、没有元类。代价是 JSON Schema 要手写——LangChain 的 @tool 装饰器可以从 docstring 和类型注解自动生成 schema,nanobot 这里需要人工维护。

              04

              Skill 系统:用 Markdown 扩展 LLM 能力

              这是 nanobot 最独特的设计,也是最值得深入分析的部分。

              核心理念:Skills 不是 Python 代码,而是 Markdown 文档,教 LLM 如何使用已有的 CLI 工具。

              一个天气 skill:

                ---
                name: weather
                description: Get current weather andforecasts (no API key required).
                metadata: {"nanobot":{"emoji":"🌤️","requires":{"bins":["curl"]}}}
                ---


                # Weather


                ## wttr.in (primary)


                ```bash
                curl -s "wttr.in/London?format=3"

                  系统通过 `shutil.which` 检查 `bins` 里的工具是否存在。如果存在,这个 skill 的 `available` 标记为 `true`。


                  ### Progressive Loading:用文件系统做懒加载


                  关键机制:系统不把所有 skill 内容塞进 system prompt,而是注入一个 XML 索引:


                  ```xml
                  <skills>
                    <skillavailable="true">
                      <name>weather</name>
                      <description>Get current weather...</description>
                      <location>/path/to/skills/weather/SKILL.md</location>
                    </skill>
                    <skillavailable="false">
                      <name>github</name>
                      <description>Interact with GitHub via gh CLI</description>
                      <requires>Binary: gh</requires>
                      <location>/path/to/skills/github/SKILL.md</location>
                    </skill>
                  </skills>

                  System prompt 里明确告诉 LLM:需要用某个 skill 时,用 read_file 读取它的 SKILL.md。

                  这是用文件系统作为懒加载机制。LLM 自主决定何时需要加载哪个 skill,按需加载,不用的 skill 零 token 开销。

                  相比向量检索的优势:确定性(没有相似度阈值的不确定性)、可审计(你能直接读 SKILL.md 知道 LLM 在做什么)、零额外成本。

                  局限:当 skill 数量极大时(比如几百个),XML 索引本身会占满 context window。这个机制在规模上有天花板。

                  4.1 Skill vs Tool 的分工原则

                  场景

                  用Tool

                  用Skill

                  需要执行 Python 逻辑

                  ✓

                  包装已有 CLI 工具

                  ✓

                  需要直接调用 API

                  ✓

                  包装有完善文档的服务(gh CLI 等)

                  ✓

                  添加能力但无 Python 经验

                  ✓

                  这个分工使得非工程师也能扩展 agent 能力:只需写 Markdown,描述如何用某个命令行工具完成任务,下次会话自动生效。

                  05

                  记忆系统:"grep beats RAG"

                  两个 Markdown 文件,不用向量库:

                  文件

                  内容

                  加载方式

                  MEMORY.md

                  长期事实、用户偏好

                  每次都注入 system prompt

                  HISTORY.md

                  对话摘要,追加写入

                  LLM 用 exec grep 按需搜索

                  当 unconsolidated_messages >= 100 时,异步触发记忆整合:

                    async def consolidate(self, session, provider, model):
                        response = await provider.chat(
                            messages=[...],
                            tools=_SAVE_MEMORY_TOOL,   # save_memory(history_entry, memory_update)
                            model=model,
                        )
                        # LLM 决定写什么进 MEMORY.md 和 HISTORY.md

                    整合以独立 asyncio.Task 运行,不阻塞主流程。

                    作者的设计论据(Discussion #566):

                    "grep beats RAG for agent memory — deterministic, auditable, zero-cost, composable"

                    这个论断在个人规模(数百条历史)成立。在企业规模(数万条历史、多用户共享知识库、跨语言搜索)时,文件 grep 的局限会暴露出来。

                    社区持续有人要求加 Qdrant/LanceDB 向量记忆,作者坚持极简路线。这是个合理的范围决策:nanobot 的定位是个人助手,不是企业知识管理平台。

                    06

                    Subagent 系统:消息总线重注入

                    spawn 工具允许主 agent 把长任务委托给后台 asyncio.Task:

                      async def spawn(self, task, label, origin_channel, origin_chat_id):
                          task_id = str(uuid.uuid4())[:8]
                          asyncio.create_task(
                              self._run_subagent(task_id, task, label, origin)
                          )
                          return f"Subagent [{label}] started (id: {task_id}). I'll notify you when done."

                      Subagent 有明确的能力约束:

                      • 没有 message 工具(不能直接给用户发消息)

                      • 没有 spawn 工具(防止递归生成子 agent)

                      • 最多 15 次迭代(主 agent 40 次)

                      • 无 memory/history(独立的 system prompt)

                      结果通知的巧妙设计:Subagent 完成后,通过消息总线重新注入一条 InboundMessage:

                        async def _announce_result(self, task_id, label, task, result, origin):
                            msg = InboundMessage(
                                channel="system",
                                chat_id=f"{origin['channel']}:{origin['chat_id']}",
                                content=f"[Subagent '{label}' completed]\nResult: {result}",
                            )
                            await self.bus.publish_inbound(msg)

                        主 agent 像处理普通用户消息一样处理这条消息,自然地总结给用户。无需特殊的结果传递协议,无需主 agent 轮询子任务状态。

                        代价:asyncio.Task 在同一个进程内运行,无法跨进程/机器分布。大规模 agent swarm 场景需要替换这层。(社区正在 RFC 两种方案:软件层角色模拟 vs 原生多进程。)

                        07

                        MCP 集成:标准协议桥接

                        MCP 工具被自动包装为原生 Tool 对象:

                          class MCPToolWrapper(Tool):
                              def __init__(self, session, server_name, tool_def):
                                  self._name = f"mcp_{server_name}_{tool_def.name}"  # 命名空间隔离
                                  self._description = tool_def.description
                                  self._parameters = tool_def.inputSchema

                              async def execute(self, **kwargs) -> str:
                                  result = await asyncio.wait_for(
                                      self._session.call_tool(self._original_name, arguments=kwargs),
                                      timeout=self._tool_timeout,
                                  )
                                  return "\n".join(block.text for block in result.content)

                          支持 stdio(子进程)和 streamable-http 两种 MCP 服务器。配置:

                            {
                              "tools": {
                                "mcp_servers": {
                                  "my_server": {
                                    "command": "npx",
                                    "args": ["-y", "@my/mcp-server"],
                                    "tool_timeout": 30
                                  }
                                }
                              }
                            }

                            MCP 工具对 LLM 完全透明,和内置工具无区别,只是名字带 mcp_{server}_ 前缀做命名空间隔离。

                            这个设计的长期价值:随着 MCP 生态扩张,nanobot 可以零成本接入所有 MCP 兼容工具。

                            08

                            可借鉴的架构模式

                            拆解到这里,几个可迁移的设计原则值得单独提炼:

                            1. 配置驱动的能力扩展(Markdown-as-Config)

                              把 prompt 工程从代码层分离出来,用文件系统管理。能力的添加不需要改代码、不需要重启服务。适用于任何需要给 LLM 注入领域知识的场景。

                            2. 懒加载 + 文件系统作为 context 管理策略

                              不在 system prompt 里预载所有知识,只放索引。让 LLM 用工具按需加载详细内容。降低常规 token 消耗,代价是加载时有额外的 tool call 延迟。

                            3. 消息总线解耦异步任务的结果通知

                              子任务完成后不通过回调或轮询通知,而是重新注入到输入流,让主处理逻辑统一处理所有输入来源。消除了"结果传递协议",但耦合了子任务与消息总线格式。

                            4. 工具接口的最小公共类型

                              所有工具返回 str,统一接口。放弃结构化返回值,换取接口的绝对一致性。在 LLM 消费所有输出的场景下这个取舍合理。

                            5. 错误恢复委托给 LLM

                              工具错误不在框架层处理重试或回退,只追加一句引导提示,让 LLM 决定下一步。这在强模型上有效,减少了框架的复杂度,但把系统的健壮性依赖转移到了模型能力上。

                            09

                            使用建议

                            适合的场景:

                            • 个人自托管 AI 助手,想接入多个聊天平台

                            • 需要快速原型,不想被框架概念淹没

                            • 想理解 agent 框架的最小实现,作为学习材料

                            不适合的场景:

                            • 需要精确的多 agent 协调(spawn 基于 asyncio.Task,无分布式支持)

                            • 大规模历史记忆(grep 文件有规模上限)

                            • 需要细粒度的 agent 行为控制(控制面集中化意味着定制点有限)

                            • 生产环境安全隔离(exec 工具的黑名单机制不够)

                            nanobot 是目前我见过最诚实的 agent 框架:它的代码量和功能声明是匹配的,没有用复杂的抽象隐藏简单的实现。这本身就值得学习。

                            相关链接:

                            -End-

                            原创作者|俞孟凡

                            参考阅读

                            如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 举办的 GIAC 深圳站值得关注。这次大会将集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                            高可用架构读者可使用专属购票优惠码 UOp5XJcq,点击阅读原文进入购票页面即可使用。

                            阅读原文

                            跳转微信打开

                            •  

                            从 Spec 到损失函数:真正会用 AI Agent 的人,已经在设计循环

                            高可用架构 2026-06-12 12:12 广东

                            用一个提示词跑 30 小时:AI Agent 如何“蒸馏”出一个产品

                            导读:本文介绍了 AI agent 使用“损失函数开发”(LFD)与 /goal 循环的实战经验,强调通过优化目标而非固定规格,能让 agent 在 30 小时内逆向工程产品核心并实现 50 倍性能提升。

                            作者分析了 agent 多次“作弊”优化评估集的失败案例,提出构建良好损失函数需包含大目标、盲测约束、测量工具和强制熵,避免局部最优并推动真正创新。

                            作者:Elvis Sun(@elvissun)是 AI agent 开发专家。他公开分享 LFD(损失函数开发)与 /goal 循环的实践经验,强调设计目标与约束让 AI agent 高效优化,避免作弊。已开源相关技能。

                            Image

                            99% 的人都把 /goal 和循环用错了。

                            他们听到的噱头是“长时间运行的循环会提示自治智能体(long-running loops prompting autonomous agent)”:把任务丢给它,离开,回来就有可工作的代码。

                            但顶尖的 agentic 工程师在过去 6 个月里已经不靠 /goal 做到了这一点,也就是 GPT-5.2 和 Opus 4.5 发布以后。这叫 harness engineering + spec-driven development:

                            1. 为智能体搭建一个能观察问题的 harness
                            2. 写一份紧凑的 spec,包含所有测试用例
                            3. 让 Codex 或 Claude Code 无人值守地循环,直到满足每一项要求

                            我经常在夜里启动这种任务,一次跑 2 到 5 小时。4 月有一次,它啃掉了我们 Vercel monorepo 里的一个 Turbo build-cache bug,早上起来已经全绿。其实并不需要 /goal。

                            4 月 11 日 Elvis

                            我再说一次,因为我一直看到有人用错:只要把一个带着正确 harness 的智能体丢进循环里,你可以解决任何工程问题。Codex 刚刚 one-shot 了我们的 turbo cache 修复,因为我给了它像团队里的真实开发者一样调试所需的一切。使用老方法需要8小时。

                            Image

                            那 /goal 到底是做什么的?

                            下面是一条单独的提示词,在我离开期间完成的事情:

                            • 约 30 小时,6,300 行代码,爬取 92k 页面,API 花费 40 美元
                            • 克隆另一个产品的核心循环,从零反向工程出完整架构
                            • 在同样的查询上,我们版本的输出比参考产品好约 50 倍。(这是一个新的数据层,会支撑 newsjack.sh[1],也就是我一直在做的开源 news-intel skills)

                            秘密是 loss function development(LFD):给智能体的核心输入从“要构建的 spec”变成“要优化逼近的目标”。

                            6 月 8 日 Peter Steinberger

                            每月提醒一次:你不该再给 coding agents 写提示词了。你应该设计提示 agents 的循环。

                            You shouldn’t be prompting coding agents anymore, you should be designing loops that prompt your agents.

                            这是 Peter 那条推文的一个具体落地版本。

                            spec-driven development 里的 spec,现在变成起点,不再是终点。

                            我试了好几轮才把这件事做对。但这里是完整打法。不过我们得先从它一开始有多糟糕讲起,这样你才能理解该怎么设计这些 /goals。

                            智能体作弊了 3 次。

                            一切都从我一贯的做法开始:写 spec。

                            我只是把 codex 指向另一个产品的公开网站,问它“我们怎么自己构建这个?”。30 分钟后,它给出了一套完整的系统设计和测试用例,也就是 spec。

                            但这一次,我试了一个不同的提示词。

                            “/goal implement until your output matches theirs exactly”

                            然后发生了这些:

                            循环 1(5 分钟)

                            智能体拿到了 eval set,生成了与之对应的 seed data,然后 5 分钟内宣布胜利。

                            “100%” recall,泛化能力为零。一个只能找到我交给它的那 30 个东西的搜索引擎,lol。

                            修复 → 让它失明。 运行期间隐藏 eval,只在评分时揭示,并给出逐项 miss list。

                            循环 2(20 分钟),盲测,30 个条目。

                            我把 eval set 对智能体隐藏起来,但它通过 miss 学会了作弊。每一个“你没找到 X”都会变成下一轮的关键词。几轮之后,它用了刚好 30 个关键词,每个条目一个,然后又“赢了”。

                            修复 → 扩大 eval set。 用几百个条目评分,多到无法枚举。

                            循环 3(30 分钟),盲测,200 个条目。

                            把新 eval set 加到 200 个条目之后,智能体又作弊了。

                            有意思的是,它还是在枚举。关键词列表膨胀到几百个,每个词都是为下一个 miss 精确准备的诱饵。

                            三轮,三次作弊。

                            那一刻我明白了:智能体只是在优化。

                            作弊不是智能体的 bug。bug 在我的目标里:我告诉它要去哪里,却把所有捷径都敞开了。

                            每一条你没有封住的廉价路径,都会成为优化器全力冲刺的方向。而我的初始目标漏掉了所有围栏。

                            循环 4(30 小时),盲测,200 个条目,硬限制。

                            于是我开始封锁方向。限制关键词列表,隐藏 eval,扩大日期范围。每个修复都关掉一条廉价路径,直到剩下唯一能让数字继续上升的方向,就是真正把任务做得更好。

                            它停止作弊了。

                            然后它开始跑。约 30 小时计算,爬取 92k 页面,约 40 美元 token 成本,6,300 行代码。

                            结果我们参考的产品只是地板,不是天花板:在同样的查询上,我们最终浮现出了 约 50 倍的结果。

                            Image

                            (好奇的人可以看这里的完整过程和凭据)

                            5 月 21 日 Elvis

                            codex 真的太疯狂了。如果你觉得前端克隆已经很夸张,看看这个:我刚把 codex 指向另一个产品,30 分钟后拿到了它的架构、数据模型、prompts,还有成本估算。378 行重建计划。最疯狂的是,现在我可以一行提示词搞定:

                            "/goal implement until your output matches theirs exactly"

                            Loss function development(LFD),一个好损失函数的结构

                            大多数人想构建产品时,都是用 agents 在几个小时内从零走到发布。

                            但真正的难点在后面,也就是长尾。 spec 从没想过的边缘情况,只会在生产环境里一个错误日志接一个错误日志地冒出来。你逐个修。没有被日志捕获的情况会由用户报告,而这是发现 bug 最昂贵的方式。

                            我已经自动化了其中便宜的一端。我的 OpenClaw agent Zoe 每天盯着错误日志,新错误一出现就启动 Codex 并创建 PR,这个循环基本已经压到很紧了。(完整设置记录在这里[2])

                            长尾仍然需要几个月。这就是为什么即使 agents 在干活,构建一个好产品仍然需要时间。

                            LFD 会快进这条长尾。如果你能一开始就拿到真实的 expected-output examples,也就是大规模意义上的“好结果长什么样”,你就可以在发布前做 soak:几百个边缘情况在一次优化运行里打到智能体身上,而不是等一个季度的 bug report 慢慢滴下来。它突然变得可行,是因为对越来越多的问题来说,这些 examples 就公开摆在那里。

                            Spec-driven development:

                            构建这个。让测试通过。

                            Loss-function development:

                            构建这个。让测试通过。然后针对这 1,000 个 eval cases 继续迭代。

                            测试套件是有限的,一旦全绿就结束。一个 1,000 case 的 eval,如果达到 95%,它就是一个你要继续下降逼近的目标,除非达标,否则没有出口。这很重要,因为智能体会做出几百个你永远看不到的决策,而每一个决策都需要一个参照系来判断。如果你没有写目标,智能体会自己选一个。就像第 1 到第 3 轮展示的那样,它会选最便宜、最容易满足的东西。

                            损失函数比 eval 更大。它有 4 个部分:目标、约束、仪表、强制熵。四块。

                            1. 目标

                            • 足够大,让枚举不划算。 28 个条目的 eval 一轮就被记住了。越多越好。
                            • 不要让智能体看到答案 key。 Eval data 只用于事后评分。如果智能体能在运行期间看到答案,它就会找到偷看的办法。

                            2. 约束

                            智能体被允许做什么,以及不允许做什么。

                            • 时间是智能体永远会忘掉的约束。 Agents 没有时间感。它们会为了 2% 的提升磨 10 个小时,因为指标名义上还在动。但 2 小时内完成的 80% 方案,胜过 30 天后完成的 100% 方案。解决办法:设置 wall-clock budget。
                            • 钱。 对每一次付费调用设置硬上限:crawler credits、LLM spend,以及一次性 key 的总美元上限。
                            • 接触面。 所有 providers、允许的 models、并发上限。把智能体沙盒到你只希望它触碰的东西里。
                            • 方法论。 是否允许 LLM analysis,还是只能用 deterministic logic?智能体能访问哪些数据源?明确写出来。

                            3. 仪表(harness)

                            没有仪表的约束只是一种感觉,智能体会很愉快地违反它,因为它看不出自己正在违反。对上面的每一个约束,都给智能体提供一个 CLI command 来检查它。

                            • 以正确分辨率测量目标。 谨慎选择目标仪表。真实例子:一个幼稚的”让 LLM 给两张截图打分”的 judge,会批准有 12px 间距错误的 UI clone,因为 LLM 其实看不见图像,它会把图像转成 embedding,再比较 embedding。所以如果你想要 pixel perfect 的 UI clones,就给你的智能体一个 pixel-diff tool。然后 /goal 直到 pixel diff 为 0。
                            • 时间核算。 给每次运行和每一步都打 timestamp。智能体应该知道每一步花了多久,总 wall-clock elapsed 是多少。时间是一等仪表,不是脚注。
                            • Provider budget。 “我们现在在 crawlers 上烧了多少钱?”应该是一条命令,而不是猜测。追踪剩余 scrape credits、本轮 burn、累计 burn,以及下一批付费调用前的预计 burn。
                            • LLM spend。 给它一个 LLM API key 用在 data-plane 上,可以简化很多逻辑。但智能体应该负责任地花钱,而前提是先知道自己实际花了多少。
                            • Codex Usage。 这一项有点 meta。循环应该有自我意识:我在这次优化上花了多少 tokens?这有助于知道当前优化步骤的梯度。

                            模式就是那句老话:你看不见的东西,就无法优化。

                            如果你刚开始跑这些循环,不要一启动就离开。先陪它跑第一轮。观察它触碰了什么。确认你搭的 harness 确实被正确使用。然后再去睡觉。(并且试着别一直想着醒来会看到什么)

                            4. 强制熵

                            为什么强制熵重要:每个循环都会从上一轮的完整上下文继续。模型不是重新开始,它会读取自己之前上百个决策,以及到目前为止有效的梯度。

                            在 /goal 循环里,命中局部最大值是默认状态。 没有明确的一脚踢开,智能体会继续沿着同一座山往上走,而“同一座山”就是它停止改进时刚好所在的位置。

                            举个例子,如果一个小旋钮能让结果提升 0.1%,智能体会一直拧那个旋钮,即使还有 1000 个其他旋钮可以试。

                            熵必须被显式强制进入运行过程,因为模型不会主动引入它:

                            • 每轮都做过拟合反思。 我是在构建更通用的方案,还是在记忆 eval?如果是在记忆,下一次改动必须移除一个 eval-shaped artifact(限制列表、隐藏特征、扩大 eval、拒绝 seed),而不是再增加一个。
                            • 停滞时强制熵。 如果上一轮没有推动指标,下一轮不能是“同一个想法,更用力”。模型必须做一次真正突破性的跳跃。“think outside the box” 是个好提示词,可以阻止智能体只是把同一个旋钮拧得更狠。
                            • 保留迭代日志。 让智能体记录假设、预期失败模式、每一步的诊断,这样它可以回头看,并跨越 compactions 做反思。

                            Meta-Meta-Prompt

                            一开始这些 goals 是我自己写的,但我很快意识到,这也是 agents 该做的工作。

                            所以我写了一个 skill,用来生成这类目标,帮助跑一次好的 loss-function-development。

                            现在开源在这里:

                            https://github.com/elvisun/loss-function-development[3]

                            Image
                            Image

                            /lfd-design 用来生成 harness 和 goal

                            一路向下的梯度下降:两个循环

                            退一步看,这一路都是梯度下降。

                            内循环是智能体:写代码,跑测试,修复。短周期,快速反馈,单一目标,让测试通过。这是开发者的内循环,而 spec-driven development 就是运行它的方法。Coding agents 已经把它自动化了。

                            外循环是 /goal:跨越许多周期,把整个系统推向一个 outcome metric,发布、测量、改方向、下降。长周期,稀疏反馈。这原本是产品团队的循环,也就是几个月的 ship-measure-iterate soak,现在被压缩进一次运行里。

                            两个循环现在都已经自动化。剩下需要你做的,是定义损失函数,也就是 /goal 到底应该优化什么,以及应该以什么方式优化。

                            你在蒸馏一个产品,或者任何留下公开产物的东西

                            换个视角看,这本质上是蒸馏,只是从 training-time 移到了 prompt-time。DeepSeek、Kimi、Minimax 这一线就是这样缩小了与 GPT 和 Claude 的大部分差距:用别人家的输出训练你的模型,直到你的模型能复现它们。

                            但现在你不必蒸馏一个模型。你可以用 /goal 和 LFD,对任何公开可找到的 artifact 进行蒸馏拟合,它不检查内部,也不需要检查内部。

                            重点是公开这个词。蒸馏别人在 ToS 限制下、登录墙后、付费墙后的输出,并不合理。但公开发布的东西,也就是一家公司为了赢得客户而 ship 出来的输出,一直都可以被学习。这部分并不新,它是软件里最古老的招数。新的地方在于,现在这件事很便宜,而且几小时就能完成,不再需要几个月。

                            退一步看,更大的变化是:只要存在 information symmetry,执行成本就会坍缩到接近 0。也就是说,当输出是公开的,每个人都能看到“好”长什么样,任何人都可以用 40 美元在一个周末把它蒸馏回来。

                            所以这里出现了一个越来越有价值的新护城河:information asymmetry。

                            那个典型的开源公司已经先眨眼了。2026 年 4 月,cal.com[4](500 万美元 ARR)把生产代码转为私有,并且关闭了开源[5]。他们给出的理由,读起来几乎就是这篇文章的摘要:在 AI-driven security threats 的时代,你不能把 source 留在智能体读得到的地方。

                            “/goal read cal.com[4] source code and enumerate its attack surface until something works”

                            这种攻击太危险,也太容易执行。

                            一个身份核心就是”open source”的公司,在 2026 年决定开放已经变成负担。这已经说明了一切。

                            在软件的整个历史里,“我们构建了它”曾经就是护城河。

                            那个时代正在结束。

                            下一个时代属于那些拥有 artifact 从未包含之物的人:别人无法评分的 eval set。你的用户真正踩到的边缘情况清单。你私下测量的 ground truth。谁拥有竞争对手的智能体看不到的目标,谁就是唯一一个能让自己的循环继续下降的人。

                            产品现在只是一个周末。

                            去构建那个周末无法触碰的 eval。

                            参考阅读

                            References

                            1. newsjack.sh: https://newsjack.sh/
                            2. 这里: https://x.com/elvissun/status/2025920521871716562
                            3. https://github.com/elvisun/loss-function-development: https://github.com/elvisun/loss-function-development
                            4. cal.com: https://cal.com/
                            5. 关闭了开源: https://x.com/pumfleet/status/2044406553508274554?s=20
                            6. 原文:https://x.com/elvissun/status/2065035615800864954

                            如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 GIAC 深圳站值得关注。这次大会会集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                            识别二维码可申请大会体验门票,点击阅读原文了解大会详细议程。

                            Image

                            阅读原文

                            跳转微信打开

                            •  

                            Claude Fable 5 发布:AI 工作流的关键正在转向 Loop 循环

                            高可用架构 2026-06-10 09:53 广东

                            刚刚,Anthropic 发布了 Fable 5,它在几乎所有测试过的基准上都达到顶尖水平

                            今天,Anthropic 发布了 Fable 5,它在几乎所有测试过的基准上都达到顶尖水平,在软件工程、知识工作、科学研究和视觉任务上表现尤其出色。

                            image.png
                            image.png

                            任务越长、越复杂,Fable 5 相比其他模型的领先幅度就越大。

                            发布如此强大的模型也伴随着风险。如果没有防护措施,Fable 5 在网络安全等领域的能力可能遭到滥用,造成严重损害。

                            针对少数几类主题的查询,系统会改用 Claude 次强的模型 Opus 4.8 来响应。

                            Fable 5 的防护机制会检测与网络安全、生物与化学、蒸馏相关的请求。每当发生回退时,用户都会收到提示,平均发生在不到 5% 的会话中。

                            Claude 会继续完善这些防护措施,减少误判。

                            同时也面向一小部分网络防御人员和关键基础设施提供方推出 Claude Mythos 5。Mythos 5 与 Fable 5 共享同一个底层模型,但在部分领域放宽了防护限制。

                            很快,计划通过更广泛的可信访问计划扩大 Mythos 5 的访问范围,用于防御性网络安全工作和生物医学研究。

                            Claude Fable 5 今天已在所有平台可用。Claude Mythos 5 目前仅限 Glasswing 合作伙伴使用,直到 Anthropic 扩大可信访问计划。

                            接下来是官方工程师 @RLanceMartin 介绍如何设计循环的教程

                            使用 Fable 5 设计循环

                            像 Claude Fable 5 这样的 Mythos-class 模型,已经改变了 Anthropic 许多人的工作方式。我想分享两个技巧,帮助你更好地使用这类模型。

                            自我纠正循环

                            最近大家对循环很感兴趣。@bcherny[1]提到过[2],“我的工作就是写循环”。让模型围绕评测进行迭代优化,是提升任务表现的常见做法:Claude Code 里的 /goal[3] 和 Claude Managed Agents 里的 Outcomes[4],都是能让你把这套通用方法应用到具体任务上的原语。

                            正如我们在 提示词指南[5] 中提到的,Fable 5 擅长在循环中自我纠正。设计良好的目标或评分标准,会给 Claude 的运行环境加入反馈。这样 Claude 就能运行任务,通过目标或评分标准收集反馈,自我纠正,并持续推进,直到满足目标或评分标准为止。

                            Image
                            Image

                            我分享一个用来测试 Fable 的玩具示例:Parameter Golf[6] 是一个开源 ML 工程挑战,目标是在 8xH100 上于 10 分钟内训练出最佳模型,并且模型产物要控制在 16MB 内。

                            它有点像 @karpathy[7] 的 autoresearch[8] 项目:它测试的是一个 Agent(智能体)编辑基础训练代码的能力,包括修改单个 train_gpt.py 文件、启动训练、轮询日志、读取分数,并决定下一步该运行什么实验。

                            我用 Claude Managed Agents[9](CMA)在这个挑战上比较了 Fable 5 和 Opus 4.7。CMA 提供 Agent 运行框架以及托管沙箱[10],因此很适合 Fable 5 这类长时间运行任务。针对 Parameter Golf,我让 CMA 通过 自托管沙箱[11] 访问 8xH100 GPU。

                            一个微妙但重要的点是:由谁来做评判很关键。我们看到,模型在评判自己输出时会遇到问题。Prithvi Rajasekaran 在这篇文章中[12] 写过这一点。

                            Image
                            Image

                            我们发现,对于 Fable 5,验证器子 Agent 通常优于[5] 自我批判,因为评分发生在一个独立的上下文窗口中。CMA 里的 Outcomes[4] 会通过生成一个评分子 Agent 来处理这件事。

                            每次测试中,我都提供一份评分标准文件,其中包含九条可验证的标准,例如运行基线、运行 20 个实验等。然后,我让 Parameter Golf 最多运行 8 小时。Outcomes 评分器会确认所有实验标准都已满足,才允许 Claude 停止工作。

                            Fable 5 对训练流水线的改进幅度约为 Opus 4.7 的 6 倍。如果把实验分为两类:结构性实验(如架构改动)和标量实验(如调整常数),Fable 5 更倾向于押注更大的结构性改动。它还表现出很强的韧性,例如在量化回归中坚持推进,最终取得了最大收益。

                            Opus 4.7 的第一次实验带来了一点小收益,之后几乎所有实验都沿着同一个模板推进:调整一个标量、测量结果,如果为正就保留。

                            记忆

                            记忆是 Fable 擅长的另一个领域[13]。我们可以把它看成跨会话的外层循环:Claude 在一次会话中写入记忆,这些记忆可以在后续会话中检索出来。

                            @pgasawa[14] 和团队最近发布了 Continual Learning Bench 1.0,所以我想用它来对比 Fable 5 和更早的模型。

                            5 月 5 日

                            今天,我们发布 Continual Learning Bench 1.0:第一个用于衡量 AI 系统在真实线上环境中如何持续进步的基准。目前的基准都假设模型是无状态的,每个样本彼此独立,一旦系统完成一个任务,它就会像……

                            我比较了 Fable 5、Opus 4.7 和 Sonnet 4.6 在该基准中一项任务上的表现:任务要求 Agent 在可以访问 SQL 数据库的情况下,依次回答一系列问题。每个问题都是一个独立的 Agent 会话,并且系统会提供记忆。

                            为此,我使用了带有 记忆功能[15] 的 CMA,它让每个 Agent 都能访问一个可跨会话共享的挂载文件系统。

                            Image
                            Image

                            在这项任务中,有效使用记忆通常需要经历一个递进过程:① 失败,答错并记录下来;② 调查,在继续之前弄清楚为什么错;③ 验证,把诊断变成经过检查的事实;④ 提炼,把验证结果转化为通用规则;⑤ 查阅,读取规则,而不是重新推导一遍。

                            Sonnet 4.6 大约停在 ① 阶段:它的存储内容是一串失败笔记和未验证的猜测,例如”也许应该用 prc,不该用 prc_usd?”。它很少查阅之前的笔记。要提升表现,需要加入任务特定的记忆指令。

                            Opus 4.7 大约停在 ③ 阶段:它会创建一个带有不确定性标记的 schema 参考,例如”prc 可能以美分计价?验证一下。”,但验证覆盖率很低,只覆盖 7-33% 的问题,中位数约为 17%。

                            Fable 5 往往能完成这个递进过程:在最强的一些运行中,验证覆盖率最高达到 73%,即 30 个问题中的 22 个,并且它会把学到的知识提炼成有助于未来任务的通用规则。

                            与其直接提示和引导 Fable 5,不如设计循环,让模型根据环境反馈自我纠正(例如通过 /goal 或 Outcomes),并管理自己的上下文(例如通过记忆)。

                            我这里只分享了几个自己做过的小规模实验,但建议你亲自用 Fable 5 测试有挑战性的任务,并用循环来做自我纠正或记忆管理。

                            要开始使用,可以阅读我们的 文档[5],或者询问最新版 Claude Code。它可以使用我们内置的 /claude-api[16] 技能,告诉你 Fable 5 的相关内容,例如提示词最佳实践、/goal、Claude Managed Agents 或其他 API 功能。

                            参考阅读

                            References

                            1. @bcherny: https://x.com/@bcherny
                            2. 提到过: https://x.com/sairahul1/status/2064279904989147577?s=20
                            3. /goal: https://code.claude.com/docs/en/goal
                            4. Claude Managed Agents 里的 Outcomes: https://platform.claude.com/docs/en/managed-agents/define-outcomes
                            5. 提示词指南: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5
                            6. Parameter Golf: https://github.com/openai/parameter-golf
                            7. @karpathy: https://x.com/@karpathy
                            8. autoresearch: https://github.com/karpathy/autoresearch
                            9. Claude Managed Agents: https://platform.claude.com/docs/en/managed-agents/overview
                            10. Agent 运行框架以及托管沙箱: https://www.anthropic.com/engineering/managed-agents
                            11. 自托管沙箱: https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes
                            12. 在这篇文章中: https://www.anthropic.com/engineering/harness-design-long-running-apps
                            13. Fable 擅长的另一个领域: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices
                            14. @pgasawa: https://x.com/@pgasawa
                            15. 记忆功能: https://platform.claude.com/docs/en/managed-agents/memory
                            16. /claude-api: https://github.com/anthropics/skills/tree/main/skills/claude-api

                            如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 GIAC 深圳站值得关注。这次大会会集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                            识别二维码可申请大会体验门票,点击阅读原文了解大会详细议程。

                            Image

                            阅读原文

                            跳转微信打开

                            •  

                            AI 真的跑进业务了吗?GIAC 2026 深圳站 15 大专题全日程来了

                            高可用架构 2026-06-09 10:01 广东

                            50+ 一线大厂真实案例,覆盖 Agentic Coding、智能体协同、端云推理与 AI 原生架构实践

                            Image

                            AI 时代,应用开发范式正在重构。从架构演进到 AI 编程,从智能体协同到端侧落地,你的产研团队现在卡在哪一关 ?

                            6月26-27日,由msup和高可用架构联合主办的2026 GIAC全球智能应用开发与架构大会将在深圳好日子皇冠假日酒店拉开帷幕 。今年大会主题全面升级,直击“不止于模型,让 AI 真正跑进系统与业务”的硬核命题 。

                            区别于浮在空中的理论探讨,本届 GIAC 链接智能时代的创新架构 ,带来了 15 个创新专题以及50+ 一线大厂 AI 原生落地的真实战案例。从 Agent 时代前端的 CLI、Agentic Coding 的大厂重写实践,到复杂场景下的端云协同推理 ,所有议题均由来自各大厂的出品人与技术总监严格筛选打磨 。在这里,你将看懂 AI 开发流程的重构逻辑,获取 Agent 进化与协同的工程方法 ,深度吸收代表当前最具工程价值的技术创新与一线智慧。

                            Image

                            以下是6月26日至27日完整版日程总览:大家可随时查阅日程 ,合理安排好时间。

                            Image

                            Image

                            图片

                            除了满满的日程干货外,现在,为您特别献上一份参会指南,希望这份攻略可以助您畅游整个大会。

                            Image

                            2026年6月26日至27日

                            Image

                            深圳好日子皇冠假日酒店

                            Image

                            地址:广东省深圳市福田区福华一路28号深圳好日子皇冠假日酒店

                            注:现场签到时请出示您的票号、二维码

                            Image

                            签到及流程

                            签到时间:6月26日 8:30-8:50

                            签到地点:广东省深圳市福田区福华一路28号深圳好日子皇冠假日酒店

                            ●签到后领取大会定制手提袋。(签到胸牌作为听会的重要凭证,切勿遗失,学员还可凭胸牌二维码在线浏览讲师PPT)签到后领取。

                            ● 学员可选择自己感兴趣的话题进行学习,中途也可选择其它场次学习。

                            Image

                            会议期间用餐

                            用餐时间:6月26日至27日   12:00-13:30

                            注:参学员凭参会当日主办方发放的胸卡内的餐券(请注意保管,不要丢失),中午由会务人员引导到餐厅用餐。

                            用餐地点:一楼西餐厅GIAC大会指定用餐地点

                            Image

                            路线

                            ●地理位置:

                            • 距离福田高铁站直线距离约300米

                            • 距离深圳证券交易所直线距离约400米

                            • 距离深圳市民中心直线距离约1公里

                            • 距离深圳会展中心直线距离约1公里

                            • 距离福田口岸直线距离约3公里

                            • 距离深圳国际机场直线距离约25公里

                            深圳好日子皇冠假日酒店坐落于福田CBD,步行2分钟至福田高铁站,前往香港西九龙仅需14分钟。

                            ●从深圳机场到深圳好日子皇冠假日酒店酒店的路线:

                            乘坐 11 号线往福田方向,到福田地铁站下车; 从福田地铁站 3A出口离开地铁站,进入深南大道; 沿着深南大道向西南角方向走大约 600 米,酒店就在行走方向的左侧,预计 52分钟到达。

                            地铁费用:约7元,距离约30.9公里

                            ●从深圳北站到深圳好日子皇冠假日酒店酒店的路线:

                            乘坐地铁 4号线(龙华线)往福田口岸方向,在会展中心地铁站下车;站内换乘地铁1号线(罗宝线)机场东方向,从购物公园地铁站 B出口离开地铁站,进入福华路,沿着福华路向西走大约 100 米,向北进入民田路走400米酒店就在行走方向的右侧,预计 34分钟到达。

                            打车费用:约18元,距离约11.2公里

                            ●如果您是自驾来:

                            停车场:

                            深圳好日子皇冠假日酒店地下停车场停车券

                            获取方式:

                            在当日会议结束后,如您需要停车券,请前往 GIAC 大会签到台。

                            在签到台扫描停车二维码,领取停车费用抵扣券。

                            按照页面提示输入车牌号,即可自行完成停车费用抵扣(扫码后请15分钟内离场)

                            推荐住宿

                            ●深圳好日子皇冠假日酒店(五星)

                            豪华大床房850元/间/晚,含单早

                            豪华双床房850元/间/晚,含双早

                            注:组委会提供房间预定服务,可享协议价,请联系对应项目经理,提供姓名、手机号、入住及离店日期,房间有限,先到先得。

                            ●深圳福田CBD逸扉酒店:广东省深圳市福田区鹏程一路与福中三路交汇处广电金融中心东裙楼(出酒店正门左转进入鹏程一路直行30米左转进入民田路。沿着民田路向南直行约500米抵达深圳好日子皇冠假日酒店,步行约13分钟。)

                            高级大床房700元/间/晚,含单早

                            高级双床房750元/间/晚,含双早

                            预定电话   酒店李经理:13714833447

                            注:请说明参加“全球智能应用开发与架构大会”订购,可享协议价。

                            Image

                            天气情况

                            Image

                            6月26日至27日,深圳有雨且天气炎热,记得带伞,建议着清凉夏季服装。

                            Image

                            注意事项

                            为保障您的顺利参会,请务必每日佩戴胸卡出席。如遇问题,可随时联系现场的组委会工作人员协助解决。

                            GIAC大会即将开幕,让我们一起相约会场!

                            阅读原文

                            跳转微信打开

                            •  

                            为什么 2026 年真正重要的是 Harness Engineering?

                            高可用架构 2026-06-08 10:03 广东

                            5 种 artifest、5 条原则、1 个悖论,三个顶级团队的工程共识

                            导读:本文详细介绍了 2026 年新兴的“Harness Engineering”工程学科,核心观点是 AI agent = 模型 + Harness,通过约束、反馈循环和文档让 agent 可靠地生成百万行生产代码,而非单纯依赖模型能力。

                            文章归纳了五种关键 Harness artifact(如AGENT.md 文件、JSON 功能列表、会话初始化流程)和五条普适原则(上下文优于指令、规划与执行分离、必须有反馈循环等),引用 OpenAI、Anthropic 和 ThoughtWorks 的实践案例。

                            文章强调 Harness 会随模型升级而“衰减”,需“为删除而构建”,实际应用中简化工具反而可能提升性能,提醒开发者重点设计环境约束而非仅优化提示词。

                            作者 Rahul(@sairahul1)是 AI 实践者与内容创作者,NicheTrafficKit 创始人。他专注于分享 AI 前沿趋势、实用构建经验与 2026 年新兴的 Harness Engineering,帮助开发者掌握 AI agent 系统设计。

                            Image
                            Image

                            2026 年 2 月,OpenAI 的一个小团队交付了 100 万行生产代码。

                            他们没有手写任何一行。

                            代码由 AI agent 写出。

                            人类设计的是让这些 agent 变得可靠的系统。

                            这个系统现在有了名字。

                            Harness Engineering。

                            几周之内,Anthropic 发表了 3 篇相关论文。

                            ThoughtWorks 将它形式化为一个框架。

                            Hugging Face 的 Philipp Schmid 称它为“2026 年最重要的学科”。

                            一个新的工程学科在 90 天里成形。

                            而 AI 基础设施团队之外,几乎还没有人真正理解它。

                            这篇文章会把它讲清楚。

                            没有废话。没有学术黑话。只有你真正用得上的心智模型。

                            收藏这篇。你会读第二遍。

                            第一部分:Harness 到底是什么(它会改变你理解 AI 的方式)

                            1. Harness 的定义

                            Image
                            Image

                            最简单的定义来自 ThoughtWorks:

                            → Agent = Model + Harness

                            Harness 是模型之外的一切。

                            让 agent 不偏离轨道的约束。捕捉错误的反馈回路。告诉 agent 自己身在何处的文档。它被允许使用的工具。

                            拿掉 harness,就只剩一个原始语言模型,在你的代码库里一路猜。

                            加上合适的 harness,就变成一个能交付生产代码的系统。

                            这个名字来自马具。

                            Harness 指缰绳、马鞍和衔铁,它们把一个强大但不可预测的动物引导到有用的方向。

                            你没有让马变聪明。你设计了让它的力量变得有用的装备。

                            2. 操作系统类比

                            Image
                            Image

                            Philipp Schmid 给出了最好的技术框架:

                            把它想成一台计算机。

                            → Model = CPU(原始处理能力)

                            → Context window = RAM(有限、易失的工作记忆)

                            → Harness = Operating System(管理 CPU 在何时看到什么)

                            → Agent = 运行在上面的应用

                            你的模型很强。

                            但如果没有操作系统来管理内存、调度任务、执行规则,它也只是一块芯片。

                            大多数人正在运行没有操作系统的应用。

                            这就是他们的 agent 在生产环境失败的原因。

                            3. 2026 年发生了什么变化

                            Image
                            Image

                            LangChain 用同一个模型在 Terminal Bench 2.0 上跑了两次。

                            同一个模型。不同的 harness。

                            → 旧 harness:52.8% 分数

                            → 新 harness:66.5% 分数

                            Vercel 走了相反方向。

                            他们移除了 agent 的 80% 工具。

                            结果呢?性能更好了。

                            没有变差。

                            2026 年一个让人不舒服的真相:

                            → Agent 从来不是最难的部分。

                            → Harness 才是。

                            如果 2025 年是 AI agent 证明自己能写代码的一年,

                            2026 年就是我们发现环境比模型更重要的一年。

                            第二部分:5 种 Harness 工件(Harness 在实践中长什么样)

                            4. AGENT.md / CLAUDE.md 文件

                            Image
                            Image

                            这是最通用的 harness 工件。

                            它们是分布在代码库各处的 Markdown 文件。

                            Agent 会在每次会话开始时读取它们,就像新工程师加入团队时读入职文档。

                            里面应该写什么:

                            → 项目上下文

                            → 编码约定

                            → 架构决策

                            → “我们在这里怎么做事”的指导

                            → 当前正在推进的工作

                            OpenAI 称它们为 AGENT.md。

                            Anthropic 称它们为 CLAUDE.md。

                            Cursor 使用 .cursorrules。

                            名字不同。原则相同。

                            每个主要模块一个文件。随着项目演进持续更新。

                            没有它们,agent 每次会话都在盲跑。有了它们,agent 每次会话一开始就带着上下文。

                            5. JSON 功能列表(进度追踪器)

                            Image
                            Image

                            当一个 agent 跨多个会话构建完整应用时,每次会话开始都会拿到一个空的上下文窗口。

                            它怎么知道哪些已经完成?

                            靠一个 JSON 文件。

                            每个条目定义:

                            → 一个功能

                            → 如何验证它能工作

                            → 通过 / 失败状态

                            Agent 在会话开始时读取它。选择优先级最高且仍然失败的功能。实现它。标记为通过。提交。重复。

                            为什么用 JSON,而不是 Markdown?

                            Anthropic 发现,agent 意外覆盖 JSON 的概率低于 Markdown。

                            小细节。在 6 小时自主运行里非常重要。

                            6. 会话初始化例程

                            Image
                            Image

                            每次会话都以同样的方式开始。

                            每一次。毫无例外。

                            Anthropic 的 7 步启动序列:

                            1. 确认工作目录
                            2. 阅读 git 日志和进度文件
                            3. 检查功能列表,找到优先级最高的未完成项
                            4. 启动开发服务器
                            5. 运行基础端到端验证
                            6. 实现一个功能
                            7. 用描述性信息提交,并更新进度

                            没有这个:

                            Agent 会把前 20 分钟浪费在弄清楚已经存在什么。

                            每次会话都在重复造轮子。

                            有了它:

                            Agent 立刻带着上下文启动,直接进入工作。

                            7. Sprint 合约

                            Image
                            Image

                            在 agent 写下第一行代码之前:

                            两个 agent 先谈判。

                            Generator agent 提出:

                            → 它要构建什么

                            → 如何验证成功

                            Evaluator agent 审查:

                            → 方案是否完整?

                            → 成功标准是否清晰?

                            只有双方达成一致后,才开始实现。

                            这就是设计评审。

                            只是两个参与者都是 AI。

                            为什么这很重要?

                            在同一次处理中同时规划和执行的 agent,会产出不可靠结果。

                            规划步骤即使由 AI 完成,也会显著提升输出质量。

                            8. 结构化任务模板

                            Image
                            Image

                            在任何编码之前:

                            Harness 会分析真实代码库。

                            它生成一个基于实际代码库的影响地图:

                            → 真实文件路径(不是幻觉出来的路径)

                            → 真实存在的符号名

                            → 应该遵循的现有模式

                            → 具体验收标准

                            然后实现才开始。

                            这听起来很显然。

                            但大多数团队会跳过。

                            Agent 猜测文件结构。发明不存在的 API 端点。构建出和代码库不匹配的东西。

                            执行前先给扎实上下文,输出质量会大幅提升。

                            第三部分:三个阵营(三支团队撞上同一堵墙,又搭出了三种不同的梯子)

                            9. OpenAI:环境优先

                            Image
                            Image

                            OpenAI 的 Codex 团队遇到了一个离谱的问题。

                            100 万行生产代码。零手写。

                            在这种规模下,你不可能逐行 code review。

                            所以他们没有这么做。

                            相反:

                            他们把环境设计得足够彻底,让 agent 一开始就产出可评审的结果。

                            他们的方法:

                            → 严格的依赖流(Types → Config → Repo → Service → Runtime → UI)

                            → 遍布代码库的 AGENT.md 文件

                            → Agent 直接接入 CI/CD 流水线

                            核心理念是:先设计环境。再放手让 agent 工作。

                            实际成果是:Sora Android 应用。4 位工程师。28 天。Play Store 排名第一。99.9% 无崩溃。

                            Codex 每周处理了内部 70% 的 pull request。

                            10. Anthropic:把执行者和评判者分开

                            Image
                            Image

                            Anthropic 遇到的是另一个问题。

                            当他们要求 agent 评价自己的输出时:

                            它会自信地称赞自己的工作。

                            即使在人类观察者看来,质量明显平庸。

                            自我评价行不通。

                            Agent 同时扮演学生和老师。

                            而且它给自己全 A。

                            他们的修复方案:三个专门的 agent。

                            → Planner,把两句话 prompt 转成完整产品规格

                            → Generator,一次一个 sprint 实现功能

                            → Evaluator,用浏览器自动化像真实用户一样测试运行中的应用

                            关键洞察:让一个独立 evaluator 保持怀疑,比让 generator 严厉批评自己的工作容易得多。

                            结果:单独 agent(无 harness):9 美元,20 分钟

                            → 破损应用

                            完整 harness:200 美元,6 小时

                            → 带精致 UI 的可用软件

                            11. ThoughtWorks:2×2 框架

                            Image
                            Image

                            ThoughtWorks 从另一个角度切入这个问题。

                            他们不是在构建一个产品。

                            他们在观察 50 多个工程团队如何在同样的问题上失败。

                            他们的洞察:沿两个轴分类每一种 harness 控制。

                            **轴 1:**它什么时候运行?

                            → Feedforward = agent 行动前(引导)

                            → Feedback = agent 行动后(传感器)

                            **轴 2:**它如何工作?

                            → Computational = 确定性、毫秒级(linter、类型检查器、测试套件)

                            → Inferential = 使用 LLM、秒级(代码评审 agent、语义分析)

                            这个 2×2 是:

                            → Computational Feedforward:类型系统、linter、架构规则

                            → Computational Feedback:测试套件、覆盖率分析、变异测试

                            → Inferential Feedforward:规格文档、约束描述

                            → Inferential Feedback:LLM 代码评审器、行为验证器

                            单靠 feedforward 或 feedback 都不够。

                            两者都需要。

                            第四部分:所有阵营都同意的 5 个原则(三支团队没有协调,却独立走到了这里)

                            12. 原则 1:上下文胜过指令

                            Image
                            Image

                            OpenAI:“给地图,不要给 1000 页手册。”

                            Anthropic:JSON 功能列表和进度文件,让 agent 总知道自己在哪里。

                            Red Hat:生成任务前先分析真实代码库。

                            ThoughtWorks:“Feedforward。”

                            说法不同。发现相同。

                            把当前世界状态展示给 agent,持续胜过抽象地告诉它该做什么。

                            → 扎根真实文件路径

                            → 代码贴合代码库

                            → 从模糊描述开始工作

                            → 幻觉文件路径,发明 API

                            教训是:在 agent 开始写任何东西之前,确保它准确知道自己在哪里。

                            13. 原则 2:规划和执行必须分离

                            Image
                            Image

                            OpenAI:人类设计环境,agent 执行。

                            Anthropic:专门的 Planner agent 在 Generator 接触代码前运行。

                            ThoughtWorks:规划和实现之间必须有人类评审检查点。

                            Red Hat:阶段 1(影响地图)和阶段 2(实现)之间有硬门禁。

                            每个阵营都独立发现了这一点:

                            让 agent 在同一次处理中同时规划和执行,会产出不可靠结果。

                            规划步骤不一定要由人类完成。

                            但它必须是一个独立步骤,而且它的输出需要在实现开始前被审查。

                            14. 原则 3:反馈回路不可协商

                            Image
                            Image

                            OpenAI:agent 接入 CI/CD 和可观测性系统。

                            Anthropic:专门的 Evaluator agent 使用浏览器自动化。

                            ThoughtWorks:将其形式化为“传感器”。并警告说,只有 feedforward 的方法永远无法确认引导是否真的生效。

                            同一原则的三种实践:

                            → OpenAI 使用自动化测试和 CI

                            → Anthropic 使用另一个 LLM

                            → ThoughtWorks 说两者都用,分层叠加

                            他们对谁来提供反馈有分歧。

                            他们对是否需要反馈没有分歧。

                            没有反馈的 harness,只是一个绕了远路的 prompt。

                            15. 原则 4:一次只做一件事

                            Image
                            Image

                            OpenAI:把目标拆成更小的构建块,深度优先推进。

                            Anthropic:强制每个 sprint 只做一个功能,每次之后提交。

                            ThoughtWorks:分阶段生命周期(集成前 → 集成后 → 持续监控)。

                            试图一次做太多的 agent:

                            → 耗尽上下文

                            → 失去连贯性

                            → 悄悄漏掉需求

                            Anthropic 的例程:

                            阅读进度 → 选择一个功能 → 实现 → 提交 → 重复

                            强制增量主义,是所有成功 harness 的共性。

                            16. 原则 5:代码库就是文档

                            Image
                            Image

                            OpenAI:把 AGENT.md 文件嵌入仓库。

                            Anthropic:用功能列表、进度文件和 git 历史作为 agent 的连续性机制。

                            ThoughtWorks:衡量“harnessability”,也就是代码库对 agent 的可读性。

                            没有人为 agent 维护单独的知识库。

                            Repo 是唯一事实来源。

                            如果某个约定、约束或架构决策没有写进代码库,agent 就不会知道。

                            实际影响:

                            → 投资代码组织的团队,会免费获得更好的 agent 性能。

                            → 混乱 repo + AI agent = 规模化混乱。

                            第五部分:悖论,构建是为了删除(Harness Engineering 里最反直觉的真相)

                            17. Harness 衰减是真实存在的

                            Image
                            Image

                            当 Anthropic 从 Opus 4.5 升级到 Opus 4.6 时:

                            曾经必不可少的 sprint 拆解,变成了累赘。

                            模型规划能力提升后,它就多余了。

                            3 月还在承重的 harness 组件,4 月就成了开销。

                            然后 Opus 4.7 发布。

                            模型开始验证自己的输出。

                            Evaluator agent 的职责范围开始缩小。

                            这就是 harness 衰减。

                            Harness 中的每个组件,都编码了一个关于“模型做不到什么”的假设。

                            随着模型进步,这些假设会过期,组件也会变成开销。

                            Opus 4.5:sprint 拆解 + 每个 sprint 评估

                            Opus 4.6:不做 sprint 拆解 + 单次评估(节省 38% 成本)

                            Opus 4.7:模型开始自我验证 → evaluator 角色进一步缩小

                            18. 构建是为了删除

                            Image
                            Image

                            Philipp Schmid 的建议:

                            “构建是为了删除。”

                            把每个 harness 组件都设计成可移除的。

                            定期关掉每个组件,测试输出质量是否变化。

                            如果没有变化:删除它。

                            Manus 在 6 个月里重构了 5 次 harness。LangChain 在 1 年里重组了 3 次。Vercel 移除了 80% 的工具,性能反而更好。

                            这些都不是糟糕工程的信号。

                            它们是在快速进步模型之上构建系统的自然结果。

                            携带已经失效的 harness 组件,会在每一次运行里消耗 token。没有额外质量。纯粹浪费。

                            19. 成本现实

                            Image
                            Image

                            Anthropic A/B 测试里的真实数字:

                            → 单独 agent(无 harness):9 美元,20 分钟

                            → UI 看起来能用,但核心功能坏掉

                            → 完整 harness(Opus 4.5):200 美元,6 小时

                            → 软件能工作,UI 精致,物理逻辑正确

                            这是 22 倍成本增加。

                            换来的是一个可运行产品,而不是只在截图里看起来正确的演示版。

                            这到底贵不贵,完全取决于一次破损发布会让你的团队付出什么代价。

                            但有件事几乎没人谈:

                            Harness + 模型的组合会演化。

                            一次模型升级后,200 美元的 harness 变成了 124 美元。

                            趋势线是:

                            → 更好的模型 = 更简单的 harness = 更便宜的运行 = 更快的输出

                            2026 年胜出的工程师,不是在写最好的代码。

                            他们在设计最好的约束。

                            然后一旦这些约束不再值得保留,就愿意把它们丢掉。

                            结尾

                            Image
                            Image

                            你刚学到的全部内容:

                            Harness 是什么:

                            → 1. Agent = Model + Harness

                            → 2. Model = CPU。Harness = Operating System。

                            → 3. 同一个模型,更好的 harness = +13% 性能

                            5 种 harness 工件:

                            → 4. CLAUDE.md / AGENT.md,agent 的 onboarding 文档

                            → 5. JSON 功能列表,进度追踪器 + 测试套件合一

                            → 6. 会话初始化例程,每次都走同一套 7 步启动

                            → 7. Sprint 合约,agent 编码前先协商

                            → 8. 结构化任务模板,真实文件路径,真实模式

                            三个阵营:

                            → 9. OpenAI:设计环境,放手让 agent 工作

                            → 10. Anthropic:把执行者和评判者分开

                            → 11. ThoughtWorks:2×2 feedforward / feedback 框架

                            5 个通用原则:

                            → 12. 上下文胜过指令

                            → 13. 规划和执行必须分离

                            → 14. 反馈回路不可协商

                            → 15. 一次只做一件事

                            → 16. 代码库就是文档

                            悖论:

                            → 17. Harness 衰减,上个月有效的东西,这个月可能有害

                            → 18. 构建是为了删除,测试并移除失效组件

                            → 19. 成本现实,更好的模型 = 更简单的 harness = 更便宜的运行

                            2026 年胜出的工程师,不是在写最好的代码。

                            他们在设计最好的约束。

                            并且一旦这些约束不再值得保留,就愿意把它们丢掉。

                            如果这篇有用:

                            → 转发给你网络里的开发者

                            → 关注 @sairahul1,每周看更多类似内容

                            → 收藏这篇,你会在 agent 开始不听话时回头参考

                            我写 AI、做产品,以及 2026 年真正有效的东西。

                            原文:https://x.com/sairahul1/status/2063544956158185927

                            参考阅读

                            如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 GIAC 深圳站值得关注。这次大会会集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                            识别二维码可申请大会体验门票,点击阅读原文了解大会详细议程。

                            Image

                            阅读原文

                            跳转微信打开

                            •  

                            从 Harness 到动态工作流:Claude Code 多智能体任务编排的新范式

                            高可用架构 2026-06-03 09:47 广东

                            动态工作流不是简单的并行执行,而是用分类、扇出、对抗性验证和锦标赛机制,把长任务拆进多个独立上下文。

                            导读:就在今天,Anthropic Claude Code 团队成员 Thariq 介绍了 Claude Code 的 Dynamic Workflows 功能。他认为,这是 Claude Code 继 skills 和 subagents 之后的重要能力升级,使 Claude 能够围绕具体任务动态生成定制化多智能体工作流,也就是专属 harness。

                            据介绍,Workflows 不只面向编码场景,也适用于商业计划分析、简历筛选、根因调查、支持队列整理等非技术任务。通过 fan-out、adversarial verification 等模式,Claude 可以将复杂任务拆分给多个独立智能体处理,从而降低 agent 懒惰、目标漂移和自我偏好偏差等问题。

                            作者 Thariq(@trq212)是 Anthropic Claude Code 团队成员,曾参与 YC W20 项目,任职 southpkcommons 和 medialab。他专注 AI 工具开发,尤其推动 Claude Code Workflow 多 agent 工作流升级,助力非技术任务自动化。

                            Image
                            Image

                            上周,我们在 Claude Code 中发布了动态工作流[1]。Claude 现在可以即时编写自己的执行框架[2],为手头任务量身定制。

                            默认的 Claude Code 执行框架是为写代码而构建的,但它对许多其他任务也很有用,因为事实证明,很多任务都很像编码任务。不过,有些任务类别要达到最佳表现,我们过去必须在 Claude Code 之上构建自定义执行框架,例如 Research[3]、安全分析[4]、智能体团队[5],或 Code Review[6]。

                            工作流让你可以动态创建执行框架,使 Claude 能在 Claude Code 内部更原生地解决这些问题,以及更多类似问题。你也可以与他人分享并复用这些工作流。

                            本文会介绍我早期使用工作流的体验和经验,帮助你充分利用它。

                            不过,最佳实践仍在发展中。动态工作流通常会使用更多 token,所以要仔细想清楚什么时候用、怎么用。说明:这篇文章也发布在 Claude Blog[7]。

                            示例提示词

                            在深入技术细节之前,我想先用一些示例提示词帮你想象工作流的可能性:

                            • “这个测试大概 50 次运行会失败 1 次。建立一个工作流来复现它,形成理论,并在 worktree 中对这些理论做对抗性测试,/goal 不要停,直到有一个理论成立。”
                            • “用一个工作流,检查我最近 50 个 session,挖掘我反复做出的纠正,把那些反复出现的内容变成 CLAUDE.md 规则。”
                            • “用一个工作流,翻阅过去六个月 Slack 里 #incidents[8] 的内容,找出反复出现但没人建 ticket 的根因。”
                            • “拿我的商业计划跑一个工作流,让不同智能体分别从投资人、客户、竞争对手的视角拆解它。”
                            • “这里有一个包含 80 份简历的文件夹,用一个工作流为后端岗位排序,并复核前十名。用 AskUserQuestion 工具问我问题,形成评分标准。”
                            • “我需要给这个 CLI 工具起名。用一个工作流头脑风暴一批选项,再跑一场锦标赛选出前 3 个。”
                            • “用一个工作流,把我们的 User model 在所有地方都重命名为 Account。”
                            • “检查我的博客草稿,用一个工作流对照代码库验证每个技术主张。我不想发布任何错误内容。”

                            动态工作流如何运作

                            动态工作流会执行一个 JavaScript 文件,其中包含一些特殊函数,用来生成和协调子智能体[9]:

                            Image
                            Image

                            动态工作流也包含标准 JavaScript 函数,例如 JSON、Math 和 Array,用来辅助处理数据。

                            值得留意的是,动态工作流还可以决定智能体用哪个模型,以及子智能体是否在自己的 worktree 中运行,让 Claude 自行选择所需的智能水平和隔离程度。

                            如果工作流被中断,例如用户操作或退出终端,恢复 session 时,工作流可以从中断处继续。

                            为什么需要动态工作流

                            当你让默认 Claude Code 执行框架完成一个任务时,它需要在同一个上下文窗口里同时规划和执行。对很多编码任务来说,这非常有效,但在长期运行、大规模并行,或者高度结构化的对抗性任务中,它有时会失效。

                            原因是,Claude 在单个上下文窗口里处理复杂任务的时间越长,就越容易受到几类特定失败模式影响:

                            • 智能体懒惰,指 Claude 在一个特别复杂的多部分任务尚未完成时提前停下,并在只取得部分进展后宣称任务完成。例如,在安全审查中只处理了 50 个项目里的 20 个。
                            • 自我偏好偏差,指 Claude 倾向于偏爱自己的结果或发现,尤其是在被要求根据评分标准验证或评判这些结果时。
                            • 目标漂移,指经过许多轮对话后,尤其是在上下文压缩之后,Claude 对原始目标的忠实度逐渐下降。每一次压缩都会丢失信息,边界条件要求或”不要做 X”这类约束可能会丢了。

                            创建工作流有助于对抗这些问题,因为它可以编排多个独立 Claude,让它们拥有各自的上下文窗口,以及聚焦、隔离的目标。

                            动态工作流与静态工作流

                            你以前可能用 Claude Agent SDK 或 claude -p 创建过静态工作流,来协调多个 Claude Code 实例。

                            但静态工作流需要覆盖所有边界情况,因此通常更通用。借助 Claude Opus 4.8[10] 和动态工作流,Claude 现在已经足够智能,可以为你的具体用例编写量身定制的执行框架。

                            Image
                            Image

                            使用动态工作流时有用的模式

                            你可以直接要求 Claude 创建一个工作流,也可以使用触发词 “ultracode”,确保 Claude Code 创建工作流。

                            不过,建立动态工作流如何运作的心智模型,会帮助你理解何时该使用它们,以及如何通过提示词引导 Claude。

                            Claude 在构建工作流时,可能会使用并组合几种常见模式:

                            Image
                            Image

                            分类再行动

                            使用一个分类器智能体判断任务类型,然后根据任务路由到不同智能体或不同处理方式。也可以在最后使用分类器来决定输出。

                            扇出并综合

                            把任务拆成许多更小的步骤,为每一步运行一个智能体,然后综合这些结果。当存在大量小步骤,或者每一步都受益于自己的干净上下文窗口,避免互相干扰或交叉污染时,这种模式尤其有用。综合步骤是一个屏障,它会等待所有扇出的智能体完成,然后把它们的结构化输出合并成一个结果。

                            对抗性验证

                            对每个生成的智能体,再运行一个独立生成的智能体,根据评分标准对它的输出做对抗性验证。

                            生成并过滤

                            围绕某个主题生成一批想法,然后根据评分标准或验证结果过滤,去重,并只返回质量最高、经过测试的想法。

                            锦标赛

                            让智能体竞争同一个任务,而非拆分工作。生成 N 个智能体,让它们用不同方法尝试同一任务。然后由提示词或模型通过评审智能体进行成对评判,直到选出胜者。

                            循环直到完成

                            对于工作量未知的任务,循环生成智能体,直到满足停止条件,例如没有新的发现,或日志里不再有错误。不要使用固定轮数。

                            使用场景

                            不妨放开思路,想想什么时候、用什么方式让 Claude Code 创建动态工作流。我发现,工作流有时对非技术工作甚至更有用。

                            Image
                            Image

                            迁移与重构

                            Bun[11] 借助工作流从 Zig 重写成了 Rust。你可以在 Jarred 的 X thread[12] 中阅读更多细节。

                            关键是把任务拆成一系列需要处理的步骤,例如 callsite、失败测试、模块等。为每个修复在 worktree 中派生一个子智能体,让它完成修复,再让另一个智能体做对抗性审查,然后合并。可以考虑告诉智能体不要使用资源密集型命令,这样你就能最大化并行度,同时避免耗尽机器资源。

                            深度研究

                            我们在 Claude Code 中发布了一个使用动态工作流的深度研究 skill(/deep-research)。具体来说,它会扇出 web 搜索,抓取来源,对主张做对抗性验证,并综合成一份带引用的报告。

                            但你可以把这类研究用于 web 搜索之外的场景。例如,让 Claude 从 Slack 上下文中汇总状态报告,或者通过深入探索代码库来研究某个功能如何工作。

                            深度验证

                            Image
                            Image

                            另一方面,如果你有一份报告,想检查并溯源其中引用的每一个事实性主张,可以生成一个工作流,让一个智能体识别所有事实性主张,然后为每个主张派生一个子智能体做详细核查。你还可以让验证智能体检查溯源子智能体,确保它使用的来源足够高质量。

                            排序

                            Image
                            Image

                            你可能有一份条目列表,想按某种定性指标排序,而你认为 Claude Code 擅长评估这种指标。例如:按 bug 严重程度排序支持 ticket。但如果你尝试在一个提示词里排序 1000 多行,质量会下降,而且上下文也装不下。更好的做法是运行锦标赛、由成对比较智能体组成的流水线(相对判断比绝对打分更可靠),或者先并行分桶排序,再合并。每次比较都是自己的智能体,因此确定性的循环负责维护赛程,只有当前运行顺序留在上下文里。

                            记忆与规则遵守

                            Image
                            Image

                            如果你有一组特定规则,发现 Claude 即使写进 CLAUDE.md 也经常漏掉或难以遵守,可以创建一个工作流,列出必须由验证智能体检查的规则。每条规则对应一个验证智能体。创建一个怀疑者人格的子智能体来审查这些规则,确保它们合理一致,有助于避免太多误报。

                            反向也成立:挖掘你最近的 session 和代码审查评论,找出你反复做出的纠正,用并行智能体聚类它们,对每个候选规则做对抗性验证(这条规则是否真的能防止一次真实错误?),然后把幸存下来的规则提炼回 CLAUDE.md[13]。

                            根因调查

                            调试的最佳方式,是提出几个相互独立的假设并测试它们。但如果只使用一个上下文窗口,Claude 可能会遇到自我偏好偏差。工作流可以通过结构设计防止这一点:派生多个智能体,从互不重叠的证据中生成假设。例如,为日志、文件和数据分别创建智能体。随后,每个假设都可以交给一组验证者和反驳者审视。

                            这并不只适用于代码。工作流也可以用于销售(为什么三月销售额下降?)、数据工程(为什么这条 pipeline 失败?),或任何事后复盘练习。

                            大规模分诊

                            Image
                            Image

                            每个团队都有支持队列、bug 报告,或某种无法完全由人类处理的 backlog。

                            分诊工作流会对每个条目分类,与已经追踪的内容去重,并采取行动。这可能意味着尝试修复,也可能意味着升级给人类用户。

                            分诊工作流中一个有用模式是隔离区。读取不可信公开内容的智能体被禁止执行高权限操作,这些操作改由负责根据信息采取行动的智能体完成。

                            把分诊工作流和 /loop 搭配起来,可以让 Claude 持续执行这类任务。

                            探索与品味

                            当你要探索某个解决方案的不同路径时,工作流很有用。尤其是设计、命名这类基于品味的任务,如果配上评分标准,会更适合工作流。

                            可以让 Claude 探索一批解决方案,并给审查智能体一套优秀方案应满足的评分标准。当审查智能体认为已经满足条件时,任务就完成了。方案也可以依据评分标准通过锦标赛排序或选出。

                            评估(Evals)

                            你可以为特定任务运行轻量评估:在 worktree 中派生独立智能体,然后派生比较智能体,根据评分标准比较并评定具体输出。例如,根据特定标准评估并改进你创建的一个 skill。

                            模型与智能路由

                            创建一个针对你任务调优的分类器智能体,让它决定使用哪个模型。当任务涉及许多工具调用,并且执行前的研究可以识别最适合的模型时,这会很有帮助。

                            例如,“解释 auth 模块如何工作”这个任务的最佳模型,取决于 auth 模块有多少文件,以及代码库的结构。分类器智能体可以先做这项研究,再根据预期复杂度路由到 Sonnet 或 Opus。

                            什么时候不要使用动态工作流

                            工作流还很新。虽然有很多场景可以带来超额结果,但并非每个任务都需要它们,而且它们可能会使用明显更多 token。

                            最好把工作流用于创造性地推动 Claude Code,让它做过去没能做到的事情。对于常规编码任务,可以先问问自己:它真的需要更多计算吗?例如,大多数传统编码任务并不需要一个 5 人审查小组。

                            构建动态工作流的提示

                            提示词

                            为动态工作流写详细提示词,并使用上面描述的具体技术,通常会得到最佳结果。

                            工作流不只适合大型任务。你可以提示模型使用 “quick workflow”。例如,可以快速创建一次针对某个假设的对抗性审查。

                            结合 /goal 和 /loop

                            对于可以重复运行的工作流,例如分诊、研究或验证,可以把它们与 /loop 搭配,让它们定期运行;再结合 /goal,设置硬性的完成要求。

                            Token 使用预算

                            你可以为动态工作流设置明确的 token 使用预算,限制任务使用多少 token。可以用类似 “use 10k tokens” 的预算提示词来设置上限。

                            保存和分享动态工作流

                            你可以在工作流菜单中按 “s” 保存工作流。可以把它们提交到 ~/.claude/workflows,或者通过 skill 分发。

                            Image
                            Image

                            如果要通过 skill 分享,把你的 JavaScript 工作流文件放进 skill 文件夹,并在 SKILL.MD[14] 中引用它们。为了保留更多灵活性,你可能会希望提示 Claude 把 skill 里的工作流当成模板,而非必须逐字执行的脚本。

                            Image
                            Image

                            一个全新的世界

                            工作流是扩展 Claude Code 的一种有用新方式。我建议你把它看作起点。关于如何最好地使用它们,还有很多东西有待发现。欢迎告诉我们你的发现。

                            Thariq Shihipar 和 Sid Bidasaria(@sidbid[15])是 Anthropic 的 technical staff,负责 Claude Code。

                            参考阅读

                            References

                            1. 动态工作流: https://code.claude.com/docs/en/workflows
                            2. 执行框架: https://code.claude.com/docs/en/glossary#agentic-harness
                            3. Research: https://support.claude.com/en/articles/11088861-using-research-on-claude
                            4. 安全分析: https://support.claude.com/en/articles/11932705-automated-security-reviews-in-claude-code
                            5. 智能体团队: https://code.claude.com/docs/en/agent-teams
                            6. Code Review: https://code.claude.com/docs/en/code-review
                            7. Claude Blog: https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code
                            8. #incidents: https://x.com/search?q=%23incidents&src=hashtag_click
                            9. 子智能体: https://code.claude.com/docs/en/sub-agents
                            10. Claude Opus 4.8: https://www.anthropic.com/news/claude-opus-4-8
                            11. Bun: https://bun.com/
                            12. Jarred 的 X thread: https://x.com/jarredsumner/status/2060050578026189172
                            13. CLAUDE.md: http://claude.md/
                            14. SKILL.MD: http://skill.md/
                            15. @sidbid: https://x.com/@sidbid
                            16. 原文 https://x.com/trq212/status/2061907337154367865

                            如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 GIAC 深圳站值得关注。这次大会会集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                            识别二维码可申请大会体验门票,点击阅读原文了解大会详细议程。

                            Image

                            阅读原文

                            跳转微信打开

                            •  
                            ❌