铃阅时讯
❌

普通视图

让 AI 替你自主干活的 12 个技巧

2026年6月2日 19:41

原创 阳志平 2026-06-02 19:41 北京

AI自主系统

从去年年底开始,我做了一个新的尝试:每天下午出门跑步之前,把一批活派给 AI,然后出门。等我跑步回家,它还在持续工作。偶尔,心情来了,给同学们开直播,让大家围观 AI 是如何自主干活的。

刚开始,AI 自主干活的时长稳定在 30 分钟到 3 个小时,而最近几个月,这个时长不断被突破,慢慢地,3 个小时已经极为稳定了,9 小时也不在话下,甚至时不时持续工作到 36 个小时以上。

这种你不在电脑前、甚至在睡觉时,AI 依然在勤勤恳恳替你干活的感觉,只要体验过一次,你就再也回不到从前了。业界喜欢用「harness」这个词,我自己更愿意叫它 AI 自主系统(Autonomous AI System)。在一次访谈中,我甚至谈到,「衡量当前 AI 发展到了什么水准,就看一件事:在没有任何人类介入的前提下,它能独立工作多久、能不能交付高质量的成果。」

那么,如何实现一个好的 AI 自主干活系统呢?分享一些经验。

第一组:任务编排

这个环节,是为数不多需要人类介入的一环,因此极为重要:给 AI 恰到好处的任务、恰到好处的上下文,以及恰到好处的任务执行流程编排。

 技巧 1:合并同类项

指令示例:请你读取任务清单上所有尚未关闭的问题,然后请合并同类项,确保每轮执行的都是同一组问题。继而按照任务复杂度从低到高排序,控制在 12 小时能干完的工作量。

对新手来说,我建议任务清单不要写在本地,更建议写成一条又一条 issue,效果更好。AI 非常擅长处理 issue,而没那么擅长处理本地的自定义格式的任务清单。这里的 12 小时也可以下调为 3 小时或更短时间。

这条技巧背后的原理是尽量减少上下文切换。AI 自主干活,最怕任务杂。 让它一会儿修 bug、一会儿写文案、一会儿做表格,上下文反复横跳,交付质量必然差。同类任务则不然。它能把上一个任务里建立的模式、踩过的坑,顺势复用到下一个,越干越顺。

那么,为何还要按照复杂度排序呢?答案其实很简单,让 AI 先用简单任务「热身」,把这一类问题的套路摸熟,再去啃复杂的,成功率更高。AI 与人类有非常类似的一面:成功带来成功。反之,一个新手,则会不断打断 AI 干活,最后 AI 交付的质量也会越来越差。

技巧 2:确定性分流

指令示例:请你在实际动手干活之前先判断:你是否已拥有足够的上下文?你是否明白你要实现的目标或解决的问题了?你是否已经对你的目标或问题进行过元反思了,是否需要重新定义问题?如果你的确清楚,就直接干;如果不清楚,请先调研,把关键决策点列给我,等我拍板再干。

每次,我跑步之前,都会这么问它一轮,是否明白今天要自主干的这批活的目标,以及是否拥有足够上下文了?然后再让它提供关键决策点,我决策后就安心出门。

这就是 AI 自主干活系统的核心设计:把人介入的点,前置到「开工前」,而不是「返工时」。

很多人用 AI 的痛苦在于,AI 闷头干了半天,方向是错的。事后盯得更紧没用,关键是让 AI 在开工前先自我分流:高确定性的活,一句话确认就放手;高不确定性的活,先停下来,把拿不准的几个关键决策摆到你面前,你拍完板它再走。该自主的地方彻底自主,该请示的地方绝不自作主张。

技巧 3:开工前,先确认世界没变过

指令示例:开工前先确认一下当前的真实状态(最新的进度、版本、数据),别拿上一次缓存的旧状态当真相。

AI 干活的一个隐藏陷阱是:它手里的「事实」,往往是上一次对话开始时的快照。可这期间,别人可能已经改过了,后台可能已经自动合并过了。基于过期状态干活,轻则白忙,重则覆盖掉别人在途的工作。

因此,我的 AI 自主干活系统设定了一个 boot 原则,第一步永远是「先核对现在的真相」。放到任何协作里都一样:动手前,先确认世界没在你不知道的时候变过。

第二组:实际开工

这一组技巧极为反直觉,也体现了 AI 自主系统和传统工作流的根本不同。

技巧 4:干了再说,边干边对齐

指令示例:别在计划上无限纠缠。先把最小可用的版本跑起来,让产出本身说话;过程中每隔一段,就拿我们最初的意图回来对一次,看跑偏没有。

传统工程教育告诉你:先写详尽的计划,再动手。但在 AI 自主系统里,我越来越确信一件事——计划永远不是唯一的真相,实际产出(比如代码)才是。

复杂的活当然也写计划,但计划只是一次性的脚手架,别当成金科玉律。需求往往是「干」出来的,靠「想」想不全。用 AI 快速迭代原型,跑通四五个大版本之后,你才真正知道自己想要什么。这个阶段,人多反而是负担:你没法跟人解释「为什么又要推翻重来」,但 AI 不需要你解释,它马上帮你验证。

所以实现阶段的纪律就四个字:先跑起来。计划写得再周全,也不如让产出先长出来,再拿意图反复校准它。所谓对齐,是让意图和不断生长的产出互相补全,而不是让产出去迁就一份僵死的计划。

技巧 5:worktree 并行分身

指令示例:把这个大活拆成几块,每个分身负责一块,注意给每个分身都利用 git worktree 创建一个隔离的工作副本,让它们同时干、互不干扰,干完再合到一起。

普通人开两个 AI 改同一个项目,立刻就冲突打架。更大的提速,来自让一群分身同时干同一个大活。 单个 AI 的吞吐有上限,杠杆就在「并行」二字。

技术上的实现,就是 worktree。worktree 这个由 pclouds 主导开发的新功能,早在 2015 年就诞生了。但在 git 中却并非一个常用命令。如今,得益于 AI 的进步,它成了 AI 自主系统的标配了。

使用 worktree,几乎所有的人都不适应,因为人类大脑不是这么工作的,我们格外不擅长多线程切换,以及管理多线程。所以,这里的关键是,如何将 worktree 的工作流程约束在人类的工作记忆与认知负荷以内。

技巧 6:补齐测试

指令示例:干完别急着交。把各类测试、尤其是端到端测试补齐,功能必须真的跑通,而不是看起来跑通。

AI 擅长自我欺骗,很多时候,没有实际测试,就宣称工作完成。或者只测容易的场景,没有测复杂的场景;或者只考虑常见的数据,没有考虑到边缘数据。因此,我们得提前约束 AI 必须进行更复杂的各类测试。比如,端到端、多样本、真环境。 测一个不算数,要拿不同类型的样本各测一遍,确保产出跨场景都稳。

迁移到非编程类任务也一样:一篇稿子、一份方案,别只在你设想的理想读者身上「跑通」,要拿几类真实场景来进行压力测试。

第三组:自检与评审

认知科学中有一个著名的元认知错觉,就是我们以为自己知道,然而实际并不知道。同样,AI 作为一种新型智能体,也存在类似的元认知错觉。因此,我们需要让它进行自检与第三方评审。

技巧 7:对抗性自检

指令示例:请派几个分身,分别扮演最挑剔的评审者(或:你见过最严格的评审者),从互不相同的角度找漏洞:一个查重复和冗余,一个查并发和边界,一个查有没有破坏旧功能。各自把问题写下来。

这个技巧需要注意:

1)务必多视角。不要只一个视角。自检不是「再读一遍」。再读一遍,AI 只会再一次确认自己是对的。有效的自检,是把自己分裂成几个互不相同、互相对抗的视角同时审。 一个专挑冗余,一个专挑边界,一个专挑「为了实现新目标而破坏了旧功能」。视角越分化,越能逼出单一视角看不见的问题。

2)沉淀项目专用的自检 Skill。这里的「重复和冗余」「并发和边界」「是否破坏旧功能」,仅仅是举例。你可以根据自己项目的实际情况,替换为自己的自检维度。我建议每个项目,都沉淀一个专门的自检 Skill,将这个项目容易出现的一些错误都沉淀在里面。你可以调用 42plugin cli 的 skill 生成器自动生成。

技巧 8:换一个不同谱系的模型来评审

指令示例:请调用 Codex 进行评审,注意命令为:codex exec -m gpt-5.5 -c model_reasoning_effort=medium,评审提示词为  <review prompt>。

这是我认为最被低估的一步,也是大多数人很少尝试的一步。为什么仅仅依赖干活的 AI 大模型自检还不够?因为它的上下文已经被任务细节污染了,同时任意一个大模型的能力都会受限于训练数据与 Agent 提示词的设定,存在天然局限。

更好的做法是换一个干净的、不同谱系的 AI 大模型:一个全新的上下文,最好来自另一家公司、用不同训练数据和不同推理风格训出来的旗舰模型。

我一般是在 Claude Code 中用 Opus 4.8 模型干活,我设定的 AI 自主干活系统,必然有一个步骤,调用 Codex 的 GPT-5.5 模型来进行独立的第三方评审。很多人不知道,Claude Code 可以直接调用 Codex 做代码评审,但你需要指定模式为:codex exec -m gpt-5.5 -c model_reasoning_effort=medium。

技巧 9:分级修复,每轮给出通过信号

指令示例:请把所有问题按 P0/P1/P2 分级,一轮一轮修。每修完一轮,都要给我一个明确的「通过 / 不通过」信号,不许含糊地说「差不多了」;不通过就继续,直到通过为止。

评审的结论,必须落到一个可判定的信号上,而不是一句模糊的「应该可以了吧」。

这背后有个微妙的风险:让两个 AI 一起评审,最大的危险是它们会互相说服——干活的那个解读评审结论时,会下意识往「通过」的方向偏。所以我从不让干活的模型自己解读评审结果,而是设一个明确的判据:通过就是通过,不通过就接着改。同时,每一轮都必须是真修,不许原地打转重复提交。问题分级(P0 必修、P1 必修、P2 酌情),一轮轮收敛,直到通过。

需要注意的是,每轮修复,都要把教训沉淀成一条可复用的规矩,下次开工前先读一遍。把评审中学到的东西制度化,是让 AI 自主干活系统越用越聪明的飞轮。

第四组:自动续航

前三组技巧让 AI 能把「一件事」干漂亮。这一组,让它在你离场后,自己一件接一件地干下去。

技巧 10:看门狗

指令示例:请用 CronCreate 帮我创建一个看门狗,定时读取记录工作进展的文件,找到下一个未完成的步骤立即执行,不要问我任何问题。

看门狗是这套系统里最简单、却最关键的一招,正是它让我们摆脱「人在回路」。这样,哪怕你去睡觉,它也会一步步把活往下推。类似的还有「心跳监控」:让它定时读 memory 文件,有待办就立即执行,没有就回一句 HEARTBEAT_OK。

技巧 11:意外处理矩阵

指令示例:遇到任何卡死、修不动、不可恢复的情况,不要停在那里等我。把情况记进状态文件,跳过它,继续下一个。永不停摆。

仅仅依赖看门狗又不够,它依然会报错、卡住。因此,我们要提前预设意外处理矩阵。这是我的某个项目的真实「意外处理矩阵」示范:

如果:codex 评审超时(> 5 min 不返回),那么:kill 进程 + 记录 + PR 留着不合 + 跳下一个
如果:codex 持续 REQUEST_CHANGES(≥ 2 次),那么:PR 留着不合 + 评论附 codex 输出 + 跳下一个
如果:测试 fail 修不动,那么:PR 不开,分支保留 + 在 issue 评论标 BLOCKED + 跳下一个
如果:调用 /simplify Skill 改完测试 fail,那么:撤改动重新做 + 仍 fail 标 BLOCKED
如果:任何 unrecoverable,那么:记 .claude/notes/autonomous-state.md + 跳下一个

    就像人类设定执行意图能大幅提高行动力一样,提前预设「意外处理矩阵」,其实就是给 AI 预设执行意图,从而大大提高了行动力。

    撰写「意外处理矩阵」的核心原则是:永不停摆。 一批任务里,总有一两个会卡住。如果一卡就停,这个 AI 自主干活系统也太弱了吧?所以规则必须是:单条卡住,就跳下一条,绝不阻塞整体推进。 卡住的那条标记好、留着,等你回来手工处理;其余的继续往前。

    这个原则在设计 AI 自主系统的时候,几乎处处可见:为失败预设绕行路径,别让局部的卡顿拖垮整体。

    技巧 12:状态持久化

    指令示例:请维护一个状态文件,把「已完成 / 进行中(当前在哪一步)/ 卡住 / 待开始」实时写进去,每进入一个新阶段就更新一次。这是看门狗醒来后唯一的真相源。

    AI 没有跨对话的长期记忆,上下文一重置就「失忆」。解法是把记忆外置成一个文件。 这个状态文件是整个 AI 自主系统的唯一真相源:看门狗醒来,先读它,就知道上次跑到哪、下一步该干什么;中途任何一次中断,都能从断点无缝恢复。

    它还有一个常被忽略的作用:收尾时给你一份人话。 AI 自主干完一整夜,你最怕回来面对一个黑箱。所以这套流程要求它最后产出一份汇报:哪些完成了、哪些卡住了、做过哪些关键判断。让你一眼就能接管,而不是从头重新理解一遍。

    小结

    这轮 AI 发展足够快,整个社会还来不及适应,带来了很多新问题。最突出的新问题是——人有人的节奏:要吃饭、要睡觉,注意力是有限的;AI 有 AI 的节奏:可以持续运行,但上下文也会被塞满。

    当这两套节奏开始一起工作,问题就变成了:哪些事你要亲自做?哪些事可以交给 AI 持续推进?怎么让人的「碳基作息表」和 AI 的「硅基作息表」更好地协同?而更本源的问题是:如何让越来越强的 AI 增强人类,而不是削弱人类的自主感与意义感?因此,需要我们从单点思维跃迁到系统思维,我提出的 AI 自主系统就是尝试正面回应这类问题。

    真正的答案是什么?也许它不在那些确定的、高效的、可被自动化的回答里,而在人类面对 AI 这类快速生长的技术巨物时的恐惧之中,在它所带来的颠覆面前的踌躇之间,在一时不知如何自处的茫然之际。当 AI 把确定的事越做越快、把不确定留给人类,恰恰是这份恐惧、踌躇与茫然,见证着人类之所以为人类。

    阳志平
    2026-06-02

    相关阅读:

    跳转微信打开

    侠客汇 AI-Native 之路:如何打造「可自进化」的端到端 AI 工作流

    2026年6月2日 15:11

    原创 杨乐、金丽华 2026-06-02 15:11 北京

    想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

    2026 年 2 月,侠客汇一个会员改版需求,整整做了 3 个月才上线,业务一堆项目卡在后面干等。

    1 个月后的今天,同样规模的需求,我们 3 周就能交付。而且变化远不止「快」这一点:

    维度

    改造前

    改造后

    协作角色

    6 种(运营/产品/UI/前端/后端/测试)

    3 种(运营 / 产品设计 / 技术)

    文档产出

    纯人工撰写

    AI 出初稿、人审(纪要/PRD/技术文档/用例)

    信息衰减

    跨 6 角色层层衰减、反复对齐

    产品-技术两端直连,纪要即「需求契约」

    典型需求周期

    会员改版 3 个月

    同类需求 3 周交付

    研发效率

    —

    整体提升 50%

    经验复用

    靠人记、人传,人走即清零

    沉淀进知识库,越用越聪明、抗人员流动

    但最核心的改变不在这张表里——是我们打造出了一条「可自进化」的端到端 AI 工作流:从需求沟通到上线交付全程由 AI Agent驱动,而它每跑一个需求,就把新经验沉淀进「组织记忆」、自动变得更懂业务。正因如此,效率提升不再是一次性的,而是可累积、可复利:需求做得越多,工作流越聪明,下一个需求就越快。

    我们只做了两件事:

    • 让 AI Agent 驱动每个环节,人只做决策和审核

    • 把团队每一次的经验沉淀成那份会自进化的「组织记忆」

    下面,就从那个「耗时 3 个月」的需求讲起,说说这一切是怎么发生的。


    一次「3 个月才上线」的改版

    先把这 3 个月,慢在哪拆开看。

    一个会员改版需求,要走完这样一条链路:运营提需求、产品调研现有系统能力并梳理改动点、反复开会确认决策点;产品手写 PRD、画原型、改方案;再拉上前端、后端、测试、UI,开需求评审会、技术评审会、测试用例评审会……6 种角色、15 个节点、5 场评审会,需求在一个个角色之间层层传递。

    问题就出在「传递」上。每经过一个角色,信息都在衰减:运营的真实意图,产品转述时会走样;技术理解需求时又有 gap;UI 拿到再问一轮……于是反复沟通、反复返工。更棘手的是,会员系统历经 2 年、多次小改版,没人能完整复述线上逻辑,光是翻历史代码、捋清现状就耗掉大量时间。

    而最深的一道坑是:这条链路上的经验,没有沉淀下来。上次改版踩过的坑、定过的规则,都散在个别人的脑子里、某次会议的纪 要里。下一个需求来了,一切又从零开始。

    所以我们想做的,不只是「把这次改版做快」,而是让整个组织既快、又会越来越快——这就引出了贯穿全文的两条线:产品线与技术线。


    一、慢的真相:拆开旧流程

    那 3 个月,不是哪个人不努力,而是整条流水线的结构就注定了慢。把旧流程摊开,慢有三个根源:

    慢的根源

    具体表现

    重复劳动多

    需求现状调研、写 PRD、画原型、画 UI、写用例——大量人工撰写,纯耗时

    信息层层衰减

    需求跨 6 个角色传递,每过一道手就走样一次,理解偏差只能靠反复开会对齐

    经验不沉淀

    踩过的坑、定过的规则只在个人脑子里,下个需求从零开始,同样的弯路再走一遍

    解法的方向因此也很清楚:用 AI 替代重复劳动、精简角色与环节、消除信息衰减、把经验沉淀下来让组织复用。

    旧流程 vs AI-Native 新流程
    旧流程 vs AI-Native 新流程

    二、我们的两条信念

    信念一:每一个环节,都由 AI Agent 来操作和驱动,人只做决策和审核。

    AI Agent 是流水线的操作者——它读需求、查代码、写文档、自检、评审、归档,一整套连贯地跑下来。人退到该在的位置:在关键岔路口做判断、为模糊处拍板、对最终结果负责。重复劳动交给 Agent,高价值的决策留给人。

    信念二,也是本质:我们要的不是一个工具,而是一份「可自进化的组织记忆」。

    经验不再靠人「抽空整理」,而是在 Agent 执行任务的过程中被自然沉淀,再供给下一次的 Agent 或下一个人。需求做得越多,这份记忆越丰富、越准确、越成熟。它如同一位永不离职、且持续精进的资深同事。

    下面分产品、技术两条线看它们怎么落地——你会发现,它们其实是同一个故事的两种讲法。


    三、产品线:找关键提效点,约定输入输出标准

    这一段在解决什么:产品设计链路上「找真需求、写 BRD、写 PRD、画原型图、画 UI」的耗时与信息衰减。

    怎么解:先想清楚 AI 该先打哪、产品和技术怎么分工,再用 AI 替代重复撰写,把 6 种角色协作在生产端收敛成「产品设计、技术开发」两端的「1+1」极简协作——运营提出的需求,将产品设计、UI 设计都归到「产品」这一端。

    3.1 启动之前:先想清楚 AI 解决什么问题

    很多事情都可以通过AI赋能,但需要想清楚我们先解决什么问题,于是我们把需求分了类:

    需求分类

    特点

    怎么对待

    现有系统日常迭代

    占整体 90% 以上,依托业务系统、直面终端用户,业务逻辑复杂、中台逻辑耦合深

    痛点是上线流程繁琐、排期周期长、机会成本极高——本次优先攻坚

    纯增量创新需求

    创新型项目需求,多为内部运营配套系统,不直接面向终端用户。目前该类需求落地较少,投入产出比(ROI)偏低、业务优先级靠后,但实际也存在明确优化痛点。

    AI Agent 可全流程闭环,留作后续创新空间

    综合业务痛点优先级、落地难度及价值回报,本次产品的AI原生工作流建设,优先聚焦现有系统日常需求迭代的效率痛点,开展优化落地。

    我们参考了一下目前互联网企业AI工作流落地模式,不同公司不同部门工作范式差异巨大,没有统一标准,也无法直接照搬,要根据实际业务的情况和组织现状,去思考合适的范式。

    最终我们借鉴阿里「1+1协作」范式并进行本地化适配——舍弃产品闭环前端开发那一环,把范式定为产品-技术的「1+1」分工——【产品端:运营需求 + 完整方案 + 高保真 UI】+【技术端:全流程生产交付】。

    3.2 痛点:每个角色到底卡在哪

    前面「慢的真相」看的是全链路的三个结构性根源;现在把镜头推近,只看产品设计这一段,每个角色具体卡在哪:

    角色

    工作环节

    核心痛点

    运营

    需求采集、优先级判定

    如何找到真需求,并准确总结,定义优先级

    需求整理、BRD 输出

    纯人工撰写,耗时耗力,效率偏低,描述准确性低

    产品

    PRD 设计、原型输出

    人工调研周期长,跨角色传递信息衰减、理解偏差,反复沟通,修改成本高。

    UI

    UI 方案设计

    人工设计耗时久;跨角色理解偏差,需频繁与产品对齐,沟通成本高

    目标因此明确:用 AI 替代各环节重复性工作,精简协作角色与流转环节,从根上解决跨角色的信息衰减与理解偏差,把链路收敛成产品设计-技术两端的「1+1」协作。

    从「6 角色层层传递」到「产品-技术 1+1」
    从「6 角色层层传递」到「产品-技术 1+1」

    具体怎么落?我们从需求输入、PRD设计、UI设计 三个环节分步解决。

    3.3 第一步:把「写 BRD」换成「开一场好会」

    第一个关键判断是:不要拿 BRD 喂 AI。因为 BRD 有 AI 克服不了的天然缺陷——我们实测过不同投喂物料的效果:

    投喂物料

    效果

    BRD噪音多

    (背景与目标混杂、方案脑补、逻辑跳跃)、
    方案越界(写"我要这个功能",而非"要解决什么问题")、
    共识模糊(运营单向输出、未经产品校验)
    ——AI 会把错误假设当事实,生成看着完整、实则全是坑的 PRD

    会议纪要信息纯净

    (只记双向确认后的结论)、
    需求聚焦(会上已把"解法"拉回"需求")、
    共识强绑定(相当于双方签字的"需求契约")
    ——是当前条件下的最优解

    于是探索出一条高效的「产运工作流」:

    需求输入标准化:会议 → AI飞书纪要 → PRD
    需求输入标准化:会议 → AI飞书纪要 → PRD

    这条工作流背后是一个固化的 AI 技能:上传会议逐字稿、一句固定指令「按 BRD 结构输出文档」,自动产出覆盖核心痛点、数据支撑、P0/P1/P2 分级功能、业务流程、规则、风险、待办的标准化纪要,并且会自动创建飞书文档连接。它对业务无感、无负担——运营不必再提前花大量时间写 BRD,仅一场标准需求沟通会就完成共识;我们还可以统一需求会议标准,反向推动业务一起从源头提升需求沟通质量。

    3.4 第二步:PRD 从「人工撰写」到「AI 分步生成 + 人工逐段确认」

    对标传统 PRD 全流程,我们搭了一条分步人机校验的自动化工作流——不追求"一键生成完整 PRD"(那只会批量出错),而是 AI 分步起草、人工逐段把关:

    PRD 自动化五步
    PRD 自动化五步

    这条流水线不是一蹴而就的,它踩着坑迭代了六个阶段才成型——这段历程,恰好就是「知识沉淀」这件事的最初摸索:

    阶段

    做了什么

    踩到什么坑 / 得到什么认知

    尝鲜期

    直接用 AI 一键生成完整 PRD

    幻觉严重、编造业务逻辑——大模型只是概率预测工具,不是万能魔法

    规范期

    固定团队 PRD 模板投喂

    格式规范了,内容仍不达标——格式规范 ≠ 内容可用

    拆解期

    拆成多模块分步生成、逐模块人工核对

    出错率大降——最优模式是「AI 快速起草 + 人把控方向与逻辑」

    寻源期

    接入历史 PRD 与真实代码校准

    全量投喂导致上下文溢出——堆数据 ≠ 有效输入,必须精炼

    降噪期

    只投喂精炼核心:《产品逻辑时间轴》+《底层代码索引》

    输出质量质的跃迁,贴合真实业务、不再编造

    进化期

    搭「错题本」+ 动态纠错

    人工纠错自动沉淀为规则门禁,工作流自我纠错、持续进化

    走到「进化期」你会发现:产品线踩出来的这套「精炼知识 + 自动纠错」,恰恰就是技术线那座「项目知识库」的雏形。两条线在这里第一次握手。

    3.5 第三步:UI 从「反复对齐」到「AI 直出可交付物料」

    摒弃原有「产品手绘原型 + 提 UI 需求 + 反复沟通对齐」的低效模式:产品依托 AI 工具Claude code直接生成标准化 UI 交付文件(Figma),全程无需与 UI 设计师反复对齐,产出物可直接交付技术开发。这一步依托 UI 与前端的组件标准化基建。

    3.6 怎么把它稳稳铺开:先内部打磨,再业务无感渗透

    好工具还得能落地。我们没有一上来就全员铺开,而是走「先内部打磨、再对业务无感渗透」的两段节奏:

    双轨落地节奏
    双轨落地节奏
    • 团队内部:初期不追求全员铺开,聚焦小范围核心力量攻坚,在不影响正常业务迭代的前提下,快速跑通、打磨AI工作流。产品负责人亲自跟进所有AI产出结果,针对输出质量给出精准反馈,真实摸清当前AI能力的边界、优势与短板,明确后续技能优化、流程迭代的方向。接下来将已验证可行的AI工具、自定义Skill,优先培训给团队业务骨干,由骨干率先落地使用,持续收集一线使用问题,迭代优化工具与流程,打磨出稳定可用的标准化方案,再推广给全员。

    • 业务侧:不打乱业务原有节奏——先保留运营宣讲 BRD 的习惯,由产品侧独立把「会议转 BRD」跑通;再用统一的会议标准反向推动业务提升需求会议质量。核心原则是利他赋能、绝不把成本转嫁上游,靠真实的效率提升赢得业务配合。

    产品线这三步,节省的都是「重复撰写」和「跨角色对齐」——而 PRD 流水线里那个「错题本」,正是「可自进化的组织记忆」在产品线上的雏形:每一次人工纠错,都自动沉淀成规则门禁,下次主动规避。下一步,产品工作还会从「承接需求提效」往前延伸到「主动挖掘真实需求」,把闭环补全。


    四、技术线:从「老项目考古」到「会自进化的知识库」

    产品借助 AI 实现了效率的质变,那么研发侧该如何用 AI 提效?最直接的答案是 AI Coding,而过去普遍的做法是 Vibe Coding——凭感觉让 AI 直接写。

    但这条路有一个致命缺陷:AI只能看到代码"是什么样",看不到代码"为什么是这样"。而在一个老项目里,最要命的恰恰就是那些「为什么」:这条链路当年为什么不敢加缓存、这个字段为什么删不得、那段绕远的逻辑当初到底是为了填哪个坑——这些约束全都不写在代码里,只装在老员工的脑子里。人一走,就成了没人能解的谜。所以问题的本质,是要把藏在人脑里的隐性约束,显式地搬进 AI 的上下文,让它在和资深工程师同等的信息条件下工作。

    想清楚这一点,结论就很自然了:AI 缺的从来不是能力,而是「这个项目的上下文」。与其每个需求都临时喂一遍背景,不如一次性把整个项目的知识沉淀下来,建成一座 AI随时能查、而且越用越厚的「项目知识库」——这才是靠知识沉淀提效,而不是靠 Vibe Coding 碰运气。

    这座知识库的形成分两段——先一次性「打好地基」,再让它在每个需求里自我进化。下面这张图,先把整个闭环看一遍:

    闭环全景图:从老项目到「越用越懂行」的完整飞轮
    闭环全景图:从老项目到「越用越懂行」的完整飞轮

    关键点:知识库如何设计

    知识库目录结构
    知识库目录结构

    4.1 冷启动:给老项目「打一次地基」

    在进行老项目考古的时候,一个难点是你需要让AI知道什么东西,AI才能很好的理解这个项目,并在一定的规范的前提下,去进行需求的开发,这里面我们把AI想象成一个新人,当团队来新人之后,我们是怎么去培养新人的,让新人去理解整个项目。

    第一步 · 先带它了解项目全貌

    1. 告诉新人整个转转的技术体系,项目的代码结构,各模块之间的依赖关系,项目中用了什么外部能力

    2. 告诉新人项目对外提供了什么能力,这些能力在项目中是怎么分类的

    3. 告诉新人数据库在哪里,都有什么表,表结构怎么样,表之间的关联关系

    通过以上的三步,新人大体就能了解整个项目是如何运转的,以及接到需求之后,该如何下手,所以我们也将这些信息告诉AI,就有了以下三张蓝图:

    蓝图文件

    记录什么

    让 AI 能做什么

    ① 架构总览

    系统分层 + 全景图 + 下游依赖清单

    接到需求就判断「改动会影响哪几层、会调到哪些下游服务」

    ② 接口 清单

    (含全量入口速查表 + 循环依赖检测)

    每个对外接口的落点、参数、归属模块

    关键词一搜就命中「这个需求动哪些表、改哪个 Facade、会牵动谁」

    ③ 数据库 ER 图

    (含真实索引明细)

    全表清单 + 字段 + 线上真实索引

    写 SQL 知道走哪个索引、改字段前知道会影响哪些表

    过程中需注意的点:

    • 接口注释与实现脱节:人改代码常不维护注释(比如:名叫「查询」的方法实际还改状态),照搬就会得到错误的接口说明。机制是让 AI 逐行比对实现与注释,不一致就让人确认,绝不轻信接口注释。

    • 索引必须拿真实 DB 结果:线上索引几乎一定和代码里的不一致(手工加过、DBA 调过)——强制阻塞,等人回贴真实的 SHOW INDEX,不许从代码反推。

    • AI 会漏扫:强制它自检——拿接口清单里的实体去和数据库实体逐一比对,降低漏扫的发生。

    第二步 · 把「隐性知识」问出来

    认全项目后,AI 知道了「代码该怎么写」。但真到写需求时,还有大量隐性知识它不知道:历史上为什么这么设计、有哪些坑、哪些地方碰不得。这些代码里根本没有,新人也只能去问老员工——那怎么让 AI 也知道?我们的做法是「人设计问题、AI 扫代码、人来解答」:

    • 先按当前业务的特点,自己列出核心要关注的问题(长事务、锁设计、Facade 设计理念、联表查询等),让 AI 去扫代码、由人给解答;

    • 让 AI 扫描核心接口,我们设计好问题,由人补充业务逻辑和隐藏的坑——因为这些业务规则,AI 根本不可能从代码里推测出来。

    最终我们把这个过程中我们的回答,全部沉淀到知识库,这样AI在下次进行需求开发的时候,就有知识可以参考:

    这一步同样有两个关键要点:

    • 别直接问「有什么坑」:而是通过 AI 扫出的规则 + 代码证据去唤起老员工的记忆——「原来这块当年踩过坑」,顺手就补出了代码里扫不到的隐性坑(线上事故、上下游兼容历史),比干问准得多。

    • 核心接口不是扫得越全越好:扫太多会让 AI 上下文爆炸。我们做两个取舍——近三个月没有流量调用的接口不扫;再根据上下文容量,判断到底扫多少个接口合适。

    4.2 日常飞轮:每个需求都让知识库更聪明

    老项目进行了一次性的知识沉淀,是给了AI在做需求过程中一个参考,但知识会升级会新增也会过期,如何在日常需求承接过程中,让知识库可以自进化。

    从产品侧每来一个飞书格式的新需求,Agent 都会跑一遍 装载 → 归档 → 入库,外加一道贯穿其中的淘汰。我们先用一张表看清四个动作的边界:

    动作

    通俗定位

    能不能改知识库

    这一步的重点

    装载

    开工前一次装 + 开工中按阶段动态投喂

    ❌ 只读

    用「三级漏斗 + 反向检索」精准取出该用的几条,全程留痕

    归档

    收工后理经验

    ❌ 只产建议

    既登记「旧知识又被用了一次」,又萃取「本次新增的经验」

    入库

    把建议安全写回

    ✅ 唯一可改

    并发检测 + 自动恢复;升级成熟度、淘汰过时知识

    淘汰

    让错的旧知识退场

    定期触发

    每三个月清理一次,把零引用的知识移出活跃库

    ① 装载 —— 知识的「抽取」与「使用」

    装载要回答两个问题:一个项目沉淀了几百条知识,该抽哪几条喂给 AI?喂进去之后,怎么保证 AI 真的用了、用对了?

    知识装载总流程:基础认知一次装,专业知识按阶段装
    知识装载总流程:基础认知一次装,专业知识按阶段装

    先说「抽取」。知识装备分两种节奏——基础认知一次性全装,专业知识按阶段精准投喂:

    装载节奏

    装什么

    为什么这样做

    基础认知

    (一次性全装)

    项目定位 + 团队红线 + 业务术语 + 架构/数据库快照 + 知识总目录

    无论做什么需求都得懂的「常识」,开工时一次读完

    专业知识 · 写需求分析前

    业务规则 + 历史踩坑 速查表

    最怕漏掉业务规矩、最该参考前人的坑

    专业知识 · 写技术方案前

    架构决策 + 编码指南 + 数据模型 速查表

    必须对齐已有架构选型

    专业知识 · 写代码前

    数据模型 + 踩坑 + 指南 速查表

    聚焦表结构、避坑、代码规范

    成百上千条知识不可能全塞给 AI(会超出上下文上限),所以靠一套「三级知识漏斗」层层收敛——用一页目录 + 几行卡片,就锁定真正该读的三五条:

    三级知识漏斗:从一页目录逐级缩小到整条经验
    三级知识漏斗:从一页目录逐级缩小到整条经验

    而到底抽哪几条,不是预设的,是被对话驱动的。用户每回答一个关键问题,Agent 就自动跑一遍「反向检索」四步闭环:

    反向检索循环:用户每答一句,触发一次「按需取知识」
    反向检索循环:用户每答一句,触发一次「按需取知识」

    背后是一张「锚点 → 取知识」的映射,让自然语言里的线索精准命中知识:

    用户在对话里提到

    AI 自动触发读取

    涉及某条业务线

    业务线隔离规范 / 术语表对应段落

    金额相关字段

    金额处理规范(如必须用 BigDecimal)

    用到消息队列 / RPC

    对应的集成架构决策(ADR)

    改了表结构 / 增减接口

    数据库 ER 图、模块地图,核对影响面

    提到某个历史遗留逻辑

    当年那条决策记录 + 相关踩坑

    再说「使用」。抽出来还不够,得保证它真被用上——这里有两道硬约束:

    • 高风险强制必读:一旦用户的回答改变了影响范围、改变了数据流向、或触碰了红线(业务线隔离 / 金额 / 状态机),AI 不读对应知识就不许往下走;若项目里压根没有这条知识,它会反过来提醒「这里以后要补一条」。

    • 全程留痕账本:每读一条都登记「读了哪条 / 为什么读 / 谁触发 / 哪个环节」。这本账有两个硬价值——它是当下的质量闸门(账本为空 = AI 没参考任何经验,直接拦下),又是下一步升级知识的唯一证据。

    中间过程产物,如设计方案文档、与前端(APP 端、h5)的交互文档、修改范围文档等会同步上传到飞书,沉淀成一份结构化的在线文档——人不必额外整理。

    ② 归档 —— 历史知识的「复用登记」与新增知识的「萃取」

    一个需求做完,归档要同时处理两类知识:这次复用过的历史知识,和这次新产生的经验。它们走两条完全不同的路径,但都只产「建议」、绝不直接碰正式库。

    归档全流程
    归档全流程

    第一条路径 · 历史知识的「复用登记」。本次需求在「装载」阶段引用过哪些已有知识,会从那本留痕账本里被逐条提取出来。它们不新建条目,而是给对应的旧知识各记一笔「又被引用了一次」。这一步回答的是——「哪些旧经验,这次又被验证了一遍」。它正是后面成熟度升级的唯一证据来源:一条知识被多少个不同需求真实用过,全靠这里一笔笔攒出来。

    第二条路径 · 新增知识的「萃取」。本次需求新产生的经验,由多个 AI 分身并行从需求侧和代码侧开采:

    来源

    从这里萃取

    得到什么知识

    需求侧

    设计方案 spec、技术方案 plan

    业务规则、架构决策

    代码侧

    代码评审记录、Git 提交历史

    踩坑、编码约定、数据模型

    代码侧 · 对比

    实际代码 vs 旧快照

    架构图 / 模块地图 / ER 图的「蓝图变更」

    两条路径汇到一起,产出一份结构化知识草稿(决策 / 规则 / 踩坑 / 指南 / 模型 + 蓝图变更),每条新知识都带一个成熟度标签。而升级靠的不是「我觉得有用」,是第一条路径攒下的真实引用次数:

    成熟度

    含义

    升级门槛(量化)

    draft(初稿)

    第一次沉淀,还没被验证

    —

    verified(已验证)

    在多个需求里被反复用到

    被 ≥3 个不同需求真实引用

    proven(已夯实)

    足够可靠,可对外输出

    被 ≥5 个不同需求真实引用

    归档故意只产「建议」、不直接入库,原因有三:① 安全——萃取可能出错,先让人审;② 可反悔——建议是结构化文件,可改可重跑,正式库始终干净;③ 冲突要人拍板——当新代码证明旧决策错了,必须人在环。最终产出两份知识合并建议(业务知识 + 蓝图)

    ③ 入库 —— 知识的「更新」与「升级」

    到这里,才真正动手改写「项目知识库」。整个体系里,只有「入库」这一道门能写正式库——为什么单拎出来?因为「写入正式库」是高风险操作:多人协作时,可能你在整理的同时,同事已往同一份文件写了别的内容。

    入库全流程
    入库全流程

    入库前的安全闸门:先检查远程是否有人并发改了同一份知识(同分支被同事推过?目标分支有别的需求刚归档?)。一旦发现重合,AI 会自动备份 → 拉取最新 → 基于最新状态重算建议 → 再检测一次,才敢落盘——彻底杜绝「一保存把同事的改动覆盖掉」。

    更新按固定六步执行(先建档、再更新、最后维护索引,因为索引依赖前面的内容先就位):

    步骤

    做什么

    ① 建新知识档案

    全新知识正式建档

    ② 给旧知识打补丁

    已有条目增量增强

    ③ 追加术语 / 背景

    补全业务认知层

    ④ 知识演化(升级关键)把归档登记的「又被引用一次」落账 + 据此自动升级成熟度

    ⑤ 回填交叉链接

    知识之间建立关联

    ⑥ 更新导航速查表 + 总目录

    刷新分类索引 / 总目录

    「升级」就发生在第四步。它把「归档」阶段第一条路径登记的引用记录正式落账,并据此把成熟度进行升级:draft → verified → proven。这正是前面那本「留痕账本」的价值兑现处——账本里「真被用过」的记录,是唯一被认可的升级证据,整个飞轮就此闭合。每一步都记进入库台账,带来两个核心价值:可续跑(中途失败修复后重跑,自动跳过已成功的)和可追溯(随时能回答「这条知识是哪次需求、哪次入库建立的」)。

    和装载阶段一致,知识的更新和升级信息同步上传一份到飞书文档。

    ④ 淘汰 —— 让错的、过时的旧知识「退场」

    一个只增不减的知识库,迟早会变臃肿——三个月前的最佳实践可能已经过时,当年沉淀的某些知识可能再没人用过。知识不仅要能进,还要能退。

    每三个月定期清理一次,把这段时间里一次都没被用到的知识清出去。

    淘汰全流程
    淘汰全流程

    判断依据,正是前面那本留痕账本——每条知识被哪些需求引用过,都有记录。定期清理时扫一遍全库:一条知识若连续三个月零引用,就说明它要么过时、要么本就没价值,移出活跃知识库(淘汰记录留档可溯,不是物理抹掉)。这样库里留下的,永远是真正在被用的「活知识」。

    一句话:新知识靠「被用过 N 次」升级,旧知识靠「长期没人用」退场。有进有出,知识库才不会越来越臃肿。

    于是闭环成立了:需求做得越多 → 知识库积累的经验越多、越成熟、越干净 → AI 设计方案越快、越少踩坑、越符合团队规矩。这正是那句「用得越多,效果越好;效果越好,用得越多」的复利效应。


    五、其实,从头到尾都是同一个故事

    把两条线并排放在一起,你会看到它们高度同构:

    产品线

    技术线

    谁在驱动

    AI Agent 全程操作

    AI Agent 全程操作

    砍掉什么

    人工撰写 + 跨角色对齐

    重复考古 + 反复踩同一个坑

    经验装在哪

    会议纪要标准 + PRD 错题本

    项目知识库

    怎么沉淀

    纠错自动进规则门禁

    经验按引用次数升级、按零引用淘汰

    共同内核AI 驱动、人决策、经验自进化

    两条线,同一个内核。所以我们想说的从来不是「AI 替代人」,而是——AI 接管重复劳动,人去做需要判断力的决策;团队的经验第一次从「个人的脑子」搬进「系统的记忆」,并且会持续自我进化。


    六、回到开头那个会员改版

    文章开头那个做了 3 个月的会员改版,如果放到今天的工作流里会是什么样?

    运营几场需求沟通会即出结构化纪要,产品 AI 分步生成 PRD、直出 UI,技术带着知识库快速落地——不再是 3 个月,而是 3 周。

    开篇那张对比表里的每一个数字,背后都是前面五节讲的这套机制在支撑:6 个角色收敛成 3 个、纯人工撰写变成 AI 出初稿、跨角色衰减变成两端直连、3 个月减少到3周、整体效率目标提升 50%。

    而比数字更重要的,是这条端到端 AI 工作流本身是「可自进化」的——每跑完一个需求,它就把新经验沉淀进组织记忆,下一次就更快、更少踩坑。所以这次提速不是终点,而是起点:效率提升不再是一次性的,而是可累积、可复利的——需求做得越多,工作流越聪明,下一个需求就越快。这,才是我们想打造一条「可自进化」工作流的真正意义,也是「既快、又会越来越快」的来处。


    七、写在最后

    想在自己的团队跑通这件事,我们沉淀出三条经验:

    1. 立「事实来源」让 AI 不臆造(产品靠会议纪要、技术靠真实代码)

    2. 设「质量闸门」让 AI 不敷衍(PRD 检查清单、知识库只读隔离)

    3. 建「沉淀飞轮」让经验自己生长、也自己除旧

    技术会迭代,模型会更新,但沉淀下来的领域知识,是更长久的竞争力。当所有工作流都由 AI Agent 驱动起来之后,团队真正拥有的,是一份持续在线、不随人员流动而流失、且每天都比昨天更懂业务的「组织记忆」。

    从「一个需求迭代 3 个月」到「会自进化的组织」,我们要打造的从来不是一个工具,而是一条可自进化的端到端 AI 工作流——它由 AI Agent 全程驱动,把经验沉淀成组织记忆,并且每跑一个需求就更懂业务一分。这条路我们会持续走下去,如果你也着迷于「如何打造可自进化的 AI 工作流」这件事,欢迎与我们深入交流。

    关于作者

    杨乐,侠客汇业务线技术负责人。主导侠客汇技术架构建设与技术先进性演进,负责 AI-Native 研发工作流在业务线的落地。

    金丽华,采货侠产品负责人。主导采货侠App、侠客汇App的产品架构建设。负责AI-Native 产品设计工作流体系的搭建和落地。

    跳转微信打开

    聊一聊 Agent 的存算分离架构设计

    2026年6月2日 14:07

    原创 idoubi 2026-06-02 14:07 重庆

    存算分离是云端 Agent 运行目前的最优解。

    一个有灵魂,有记忆的 Agent,一次任务的生命周期包括以下步骤

    1. 用户输入 query(text + files)

    2. Agent 读取提示词文件(soul.md,identify.md,user.md 等)

    3. Agent 读取可用的工具和技能(tools,skills 等)

    4. Agent 读取记忆(memory.md,memory_search 查询)

    5. Agent 构建上下文(prompt + tools + memory + query)

    6. Agent 进入 Loop(LLM 调用 → 工具调用 → 观测 → 再推理)

    7. Agent 交付结果(Artifacts)

    什么需要存:提示词文件,工具和技能,对话记录,交付产物

    什么需要算:上下文拼接,LLM 调用,工具调用

    简单表示这个过程

    ❝

    fn(query, agent runtime) = artifacts

    我们可以把  agent 运行方式简单分为三类

    1. 本地裸机运行

    2. 本地带沙盒(sandbox)运行

    3. 云端多副本运行

    Agent 运行方式

    1. 本地裸机运行。

    这是 OpenClaw 之类 Agent 的常见模式。Agent 提示词文件、skills,对话记录(sessions)全部存在本地磁盘,Agent 执行任务时,会在固定 workspace 目录下运行,用户上传的文件、Agent 产出的文件全部落在同一个 workspace,Agent Loop 完全依赖本地文件构建上下文和执行工具调用,存跟算是一体的。

    这种模式好处是足够简单,避免了额外的文件挂载开销,弊端在于安全性,比如 Agent Loop 执行了一个 exec(rm  -rf /) 工具调用,很容易对宿主机产生破坏

    1. 本地带沙盒运行。

    这是 Codex 之类的 Agent 的常见模式。主要解决两个问题。一是防止 Agent 越权操作,提高安全性;二是解决宿主机的依赖缺失导致工具调用异常的问题。

    Agent Loop 执行工具调用时,涉及到敏感操作或者有外部依赖时,把宿主机的 workspace 目录挂载到 sandbox,在 sandbox 执行工具调用,输出产物自动同步到宿主机的 workspace 目录

    这种模式下的存算分离,只在工具调用环节引入 sandbox 来动态计算,存储主要靠宿主机的文件系统

    1. 云端多副本运行。

    这是 Manus 之类的工具型 Agent 的常见模式。主要特点是多租户,多任务,长时间运行

    像 genspark claw,kimi claw,max claw 之类的托管版小龙虾,本质上是在云端多副本运行的助理型 Agent,每个用户有独立的提示词文件,动态安装的 skills,需要长期记忆

    这类 claw 托管服务,最简单的实现方式是搭建一套 k8s 集群,在每个 pod 部署一套 Agent 框架(OpenClaw,harmes 等),通过 pvc 挂载云硬盘,实现对用户资料的持久化存储。通过负载均衡策略把每个用户的请求路由到固定的 pod,在同一个 pod 做 Agent Loop,存算是一体的,每个 Agent 有独立的运行空间。这种方案隔离性很好,不好的地方在于 pod 需要常驻,运行成本很高,难以规模化

    Agent 存算分离

    云端 Agent 需要规模化(scalable),必然要结合 serverless 架构做存算分离。计算层依赖 k8s 集群的调度机制动态扩缩容,水平扩展 Agent 网关的并发处理能力

    存储层结合 Agent 的运行生命周期,不同阶段的产物用不同的存储方案,主要分为四种

    1. 热状态。Agent Loop 的 step,plan,游标等状态,用 kv(redis)来存,高性能,低延迟,用于异常重启后的断点恢复

    2. 对话和任务记录。在任务完成后用关系型数据库(postgres)来存

    3. 长期记忆。基于对话/任务记录做摘要,提取成记忆,用向量数据库(pgvector,milvus)来存

    4. 工作产物。包括用户上传的文件,Agent 输出的文件,系统内置的 tools,动态创建的 skills 等,用对象存储(s3,oss)来存

    FastClaw 运行示例

    以 FastClaw 为例,演示基于存算分离架构的云端 Agent 的运行过程👇

    1. 一套 k8s 集群,日常 2 个 pod,部署 fastclaw gateway,接收用户请求

    2. 负载均衡把用户请求路由到其中一个 pod,Agent 开始计算逻辑:

    • 2.1  从 db 读取提示词文件(soul,identity,user)

    • 2.2  初始化 pod 内一个临时目录作为 workspace

    • 2.3 初始化 sandbox,挂载 workspace

    • 2.4 从对象存储下载用户资料和系统 skills 到 workspace

    • 2.5 调用 memory_search 工具,从向量数据库查询记忆

    • 2.6 拼接上下文,调用 llm,解析工具

    • 2.7 在 sandbox 执行工具调用,读写 workspace 内的文件

    • 2.8 把 Agent Loop 过程中的状态设置为 checkpoint,保存到 kv

    • 2.9 Agent 输出结果给用户

    1. 通过惰性检查,把不活跃的 sandbox 关闭,关闭前把 sandbox 内 workspace 的文件上传到对象存储

    以上的存算分离架构,计算层依赖 pod + sandbox,pod 水平扩容支持并发调用,sandbox 承接少量的工具调用,使用 e2b 作为 sandbox 可以做到秒级启动,构建 sandbox 池可以提高并发容错;存储层依赖 kv + db + vector db + oss 的组合使用,瓶颈在于 io 延迟

    这套架构最大的挑战在于分布式多副本场景下的数据一致性,需要合理使用锁机制和负载均衡策略。

    理解了这套架构,再去看 Manus,Claude managed agents 的实现,就很好理解了。

    Agent 托管服务迁移

    我年初开始做 OpenClaw 托管服务,在一套 k8s 集群部署了 500 个 Pod,每个 Pod 限制 4g 的运行内存。日常开着 18 台 4c16g 的服务器作为节点池,一个月成本将近 5k 刀。

    几个月下来,托管服务的 MRR 突破了 8k 刀,除去运营成本,利润非常低。

    今天终于把服务迁移到了 FastClaw,通过存算分离的架构,让 Agent 无需常驻,而是在收到请求时动态挂载 sandbox 来提供服务。服务器从 18 台降到了 3 台,运营成本降到了 1/6,下个月有机会赚到钱了。😄

    跟 OpenClaw 比,FastClaw 真的是太轻量了。

    1. 代码体积约为 OpenClaw 的 1/40

    2. 运行资源占用约为 OpenClaw 的 1/7

    3. 单二进制分发,无环境依赖

    4. OpenClaw 的 gateway 启动大概需要 15s,FastClaw 秒级启动

    FastClaw 本身是为云原生多租户场景而设计的 Agent 运行框架,同样也适用本地运行场景。

    继续完善,欢迎体验。❤️

    https://fastclaw.ai

    跳转微信打开

    ❌