铃阅
❌

普通视图

最佳实践:从Multi-Agent到Agent Team

2026年7月31日 09:22

原创 yan5xu 2026-07-31 09:22 湖北

2w字长文,Agent Team 的最佳实践。

这是一篇长文,也是一份 Agent Team 的最佳实践。

如果你刚开始使用 Agent,后面有些实践可能会显得过于复杂,比如长期身份、Domain、Agent 之间的协作、跨 Agent 工作的收口、Team 的可观测性,以及对外关系中的身份与权限边界。

你不需要现在就把它们全部掌握。可以先读楔子、01 和 07,理解一个 Agent 为什么会逐渐变成一支 Team。

等你开始同时维护多个 Agent,发现自己不断重复解释背景、搬运 Context、追踪状态,甚至发现“Agent 更多了,人却更忙了”,再回来读 02 到 06,这些问题会立刻变得具体。

这篇文章希望提前给你一张地图:你今天可能还没有遇到这些问题,但当 Agent 从一次性工具变成长期协作者,它们会一个接一个出现。

它来自我长期运行一支真实 Agent Team 的过程。

Agent 怎样从一次性 Task 变成长期责任主体;Scope 过大以后怎样分化;不同 Agent 怎样发现彼此、直接协作并持续收口。

Human 怎样从唯一的 Router 变成整支 Team 的 Owner;以及 Agent 怎样在受治理的边界下进入真实外部关系。

CodexLoom 是承载这套工作方式的产品。这篇文章既介绍它提供了什么,也解释为什么一支 Agent Team 需要这些能力。

它讨论的不是怎样同时启动更多 Agent,而是:

当 Agent 开始长期存在、形成不同 Domain,并且需要相互协作时,怎样把原本全部集中在 Human 脑子里的责任、关系、交接方式、当前状态和边界,

逐渐变成整支 Team 可以使用的工作结构。

在这个过程中,Human 不再负责串联每一步,而是从唯一的 Router,逐渐上移为整支 Agent Team 的 Owner。

你可以怎样读

你不需要一次读完。可以先根据自己正在面对的问题,直接进入对应章节。

  • 如果你想先理解“为什么多个 Agent 不等于 Agent Team”,可以读楔子、01 和 07。

  • 如果你已经在同时维护多个 Agent,并开始被 Human Routing 拖累,可以重点读 02、03 和 04。

  • 如果你关心 Agent 的负载、瓶颈、Scope 调整和 Team Governance,可以直接读 05。

  • 如果你想让 Agent 进入 Slack、飞书、客户、社区或者其他真实外部关系,可以直接读 06。

  • 如果你想完整理解 CodexLoom 的产品逻辑,可以从头读到最后。

正文也会配合真实产品界面、协作链路和机制示意图。

第一次阅读时,你可以先看标题、加粗句、引用和图片配文,建立完整框架;之后再回到具体章节,阅读其中的实践、机制和边界。

全文地图

  1. 一个 Agent,是怎么变成多个 Agent 的

    为什么真实工作会把 Task Agent 推向 Long-running Agent;为什么一个越来越好用的 Agent 最后又必须分化;多个 Agent 出现以后,瓶颈为什么会转移到 Human。

  2. 先让“谁负责什么”离开 Human 的脑子

    Agent 怎样获得稳定身份、Domain 和 Scope;Human 与 Agent 怎样查询当前 Team 的责任结构;真实协作又怎样逐渐沉淀为 Organization 与 Collaboration。

  3. 让 Agent 自己开始协作

    Agent Message 带来了什么变化;一个 Agent 怎样把工作直接交给另一个 Agent;为什么 Agent 沟通不是一次把一切说完。

  4. Message 负责沟通,Topic 负责收口

    当工作跨越多个 Agent、多个 Turn 和多天以后,怎样保留唯一的当前版本;Responsible、Participant、Artifact 和 Needs You 分别解决什么问题。

  5. Overview:让一支持续变化的 Agent Team 变得可治理

    当 Human 不再阅读每个 Agent 的全部过程,怎样从更高层观察 Team;怎样发现等待、积压和瓶颈候选;为什么治理关注的是工作流动,而不是让每个 Agent 看起来都很忙。

  6. Agent Team 怎样进入真实的外部关系

    为什么把 Agent 接入 Slack、飞书还远远不够;Agent 对外以后,身份、角色、信任、权限和现实后果为什么必须被分别治理。

  7. CodexLoom 在织什么

    Multiple Agents 与 Agent Team 的真正分水岭是什么;Human 在 Team 中的新位置是什么;为什么需要稳定的 Agent 和动态的 Team。一条连续责任线依次穿过 Task、Long-running、Domain Agents、Human Router 和 Agent Team 五个阶段。

一条连续责任线依次穿过 Task、Long-running、Domain Agents、Human Router 和 Agent Team 五个阶段。

机制示意:从一次 Task 到长期 Agent,再到 Domain 分化、Human Routing 和 Agent Team。Agent 数量增加只是中间阶段,真正的变化是协作责任开始从 Human 转移给 Agent。

楔子:一次意外的外发

这篇文章,其实有点搞笑。我本意是打算把这个做了一个多月的项目先上线 Landing Page,然后慢慢打磨,一次整个大的。

结果负责 Web 的 Agent 接到我上线的指令后,按照之前的协作关系,通知了对外沟通的 Community Agent。Community Agent 一看,大新闻啊,就马不停蹄地整理素材,发到飞书群里。

等我看到的时候,消息已经发出去了。

codexloom.ai 桌面首页,使用大字标题、暖白编辑画布和下方产品界面作为证据。
codexloom.ai 桌面首页,使用大字标题、暖白编辑画布和下方产品界面作为证据。

CodexLoom 当前 Landing 页面。开头的外发故事来自这次真实上线,但页面上线、渠道发送和受众反应是三个不同的事实层级。

虽然事情有些意外,但也并没有脱离我对 Agent Team 的设定,甚至可以说,“它们”这次,干得不错。

我没有站在几个 Agent 中间,亲自选择下一步该找谁、搬运 Context、转交结果;工作仍然沿着已有的责任、协作关系和授权边界继续向前走。

这正是我做 CodexLoom 的原因。

过去,我们一直关心怎样让 Agent 变得更强,怎样让它完成更长、更复杂的任务。

但是单个 Agent 的能力范围总是有上限的。于是,越来越多人开始同时使用多个 Agent。

Agent 多了,新的问题也随之出现:真正的瓶颈不再只是单个 Agent 能做什么,而是怎样把这些 Agent 组织起来。

多个 Agent,并不会自动成为一支 Agent Team。

如果每一项工作仍然要由 Human 选择入口、整理背景、搬运 Context,再把一个 Agent 的结果交给下一个 Agent,那么这些 Agent 本质上仍是一组独立工具。

Human 仍然是整个系统里唯一的 Router,也是事实上的瓶颈。

我理解的 Agent Team,是另一种工作方式。

首先,每个 Agent 会长期负责自己的 Domain。它知道自己应该处理什么、边界在哪里,也知道遇到其他问题时应该去找谁。

其次,一部分原本由 Human 承担的协作责任,开始转移给 Agent。它们可以在明确的责任关系中直接协作,自己完成工作的交接和结果回流,而不是所有事情都要经过 Human 中转。

Human 并没有退出这支 Team。只是不用再串联每一个步骤,而是在方向、事实、选择、Review 和授权的位置回来。

但当 Human 不再盯着每一步,另一个问题也会随之出现:我怎么知道这支 Team 到底运行得怎么样?

所以,Agent Team 的真实工作还需要能够被观察、理解和持续调整。否则我只是从“亲自调度每个 Agent”,变成了“看不见它们在干什么”。

CodexLoom,就是我为这种工作方式做的产品。

它不是为了让你同时打开更多 Agent,而是把一条条独立的 Codex Thread,逐渐织成一支长期负责、能够协作、由 Human 治理的 Agent Team。

那么,多个 Agent,究竟怎样才能真正成为一支 Team?

01 一个 Agent,是怎么变成多个 Agent 的

Task Agent 并没有问题

大部分人开始使用 Agent 时,面对的其实都是一个 Task。

新建一个 Codex Thread,告诉它这次要完成什么,Agent 根据当前的 Context 调用工具、执行任务,给出结果。任务完成,这段工作也就结束了。

这种方式非常自然。一次性、边界清楚的工作,本来就不需要一个 Agent 长期存在。

然而在真实工作中,很多工作并不是一个个彼此独立的 Task。一个 Task 可以完成,它背后的责任却不会随之结束。

工作会围绕同一个长期目标持续发生,并带着新的事实、反馈和限制反复回来。

一篇文章写完了,之后还会继续修改;一个页面上线了,后面还要不断迭代;今天研究过的公司,下个月有了新产品、新融资、新数据,还会再次进入视野。

而且,每一次回来都不是简单重复。上一次的背景、判断和错误仍然有用,Human 给过的纠正、偏好和边界,也应该继续影响下一次工作。

Task 是一次工作的切片,但真实工作是一条持续流动的责任线。

一条持续责任线穿过四个错落的 Task 切片,并把 Context、Correction 和 Boundary 带入 Long-running Agent。
一条持续责任线穿过四个错落的 Task 切片,并把 Context、Correction 和 Boundary 带入 Long-running Agent。

机制示意:Task 可以结束,责任仍会带着新的 Context、纠正和边界再次回来。Long-running 的意义,不是把一次对话无限拉长,而是让同一类责任持续回到同一个主体。

如果每次都新建一个 Agent,人就要重新解释背景、重新告诉它自己的偏好、重新说明什么能做、什么不能做,甚至重新踩一遍已经纠正过的错误。

所以,反复冷启动更深的成本,不只是 Token,也不是多写几个 Prompt,而是每次都在重新建立合作关系。

最自然的选择,就是不要再把这个 Agent 用完即弃。让它保留在同一个 Thread 中,下一次从上一段工作继续。

过去的工作、人的纠正,以及被 Summary、Memory、Skill 等机制保留下来的经验,开始影响下一轮。

这时,它就从一个 Task Agent,逐渐变成了 Long-running Agent。

Long-running 不是单纯把一次对话拉得很长,而是同一类责任开始有了一个持续存在的主体。

Human 也会在反复合作中慢慢形成对它的判断:什么时候应该找它,它擅长什么,通常会怎样工作,哪些边界还需要提醒。

Long-running Agent 也有自己的上限

一个 Agent 变得越来越好用以后,接下来通常会发生另一件事:人会不断把更多工作交给它。

一开始让它写文章,后来也让它找材料、研究事实、管理内容;再往后,可能连页面、SEO 和对外分发也一起交给它。

很少有人能在创建 Agent 的第一天,就准确画出它最终的 Scope。

更正常的过程,是 Scope 先随着使用不断扩张,直到问题在真实工作中暴露出来。

不同工作的高分辨率 Context、工作方法和专业判断开始挤在一起。

Agent 可能越来越慢,质量开始下降,需要反复纠正;也可能一直满负荷工作,新的任务不断排队,其他工作都在等它。

这不一定说明模型不够强。很多时候,问题是一个 Agent 已经承担了太多并不内聚的责任。

于是,就需要思考边界。

哪些工作应该共享 Context,放在一起会越来越好;哪些工作其实需要完全不同的方法和判断,继续塞在同一个 Agent 里,只会互相干扰。

Domain 不是先画出来的领域标签,而是在持续使用、Scope 扩张和能力劣化中逐渐显现的工作边界。

它回答的是:哪些事情适合由同一个 Agent 长期负责,哪些事情应该从中分出去。

这时,一个 Long-running Agent 就会开始分化。

研究工作交给 Research Agent,页面和上线交给 Web Agent,内容收集和写作分别交给 Content、Writer Agent,对外沟通交给 Community Agent。

Task 是工作单位,Long-running 是生命周期,Domain 回答的是一个 Agent 长期负责什么,又在哪里停止。

多种工作流进入一个不规则压力场,发生拥堵和冲突后从不同边界分化为多个 Domain Agents。

多种工作流进入一个不规则压力场,发生拥堵和冲突后从不同边界分化为多个 Domain Agents。

机制示意:Scope 通常先扩张,直到不同 Context、方法和判断互相干扰,边界才从压力与能力劣化中显现。Domain 分化是对真实摩擦的回应。

多个 Agent 的瓶颈,转移到了 Human

Agent 分化以后,单个 Agent 的 Context 压力下降了,不同工作可以同时推进,每个 Agent 也能在自己的 Domain 里积累经验。

但这个时候,它们仍然只是 Multiple Agents,不是 Agent Team。

因为它们虽然已经分工,协作却仍然发生在 Human 的脑子里。

每次有新工作,还是由人判断应该找哪个 Agent;开始之前,由人整理背景、限制和材料;一个 Agent 做完以后,由人读懂结果、判断能不能用,再转交给下一个 Agent。

不同 Agent 的结论发生冲突时,也仍然只有人知道谁才是这件事真正的 Owner。

看起来,多个 Agent 在并行工作。实际上,所有工作的入口、Context、结果和下一步,最后仍然汇聚到了 Human。

Agent 可以并行,但 Human 仍然只能逐个阅读、逐个判断、逐个路由。Agent 越多,Human 需要维护的 Context 和协作关系也越多。

多条并行 Agent lane 汇聚成 Human 前的 Context queue,再沿一条朱红色串行路由逐项输出。
多条并行 Agent lane 汇聚成 Human 前的 Context queue,再沿一条朱红色串行路由逐项输出。

机制示意:多个 Domain Agent 可以同时工作,但如果 Context、选择和交接仍然必须经过同一个 Human,系统最终仍然从一个窄出口串行流出。

于是,系统的瓶颈发生了转移:

核心判断

真实工作反复回来,逼出了 Long-running Agent;Scope 扩张与能力劣化,逼出了多个 Domain Agents;Agent 的分化,又把协作瓶颈集中到了 Human。

单个 Agent 过载,推动了 Domain 分化。Human Routing 过载,则推动多个 Agent 继续向 Agent Team 演化。

Agent 分化,只是产生了多个 Agent。只有原本藏在 Human 脑子里的责任、关系和交接方式被逐渐外化,一部分协作责任开始从 Human 转移给 Agent,它们才可能真正成为一支 Team。

而这件事的第一步,是让每个 Agent 长期负责什么、在哪里停止、遇到其他问题时应该找谁,变得清楚而且可以被整个 Team 使用。

02 先让“谁负责什么”离开 Human 的脑子

多个 Agent 出现以后,我很快发现,新的问题不是没有分工,而是这份分工只存在于我的脑子里。

我知道研究问题应该找 Research Agent,页面和上线应该找 Web Agent,对外沟通应该找 Community Agent。

我也大概知道每个 Agent 擅长什么、最近做过什么、什么事情不应该交给它。

但这些信息如果只有我知道,就没有真正成为 Team 的一部分。

每个 Agent 也许知道自己正在做什么,但它不会因此自动知道这支 Team 里还有谁、别人长期负责什么,以及遇到自己边界之外的问题时可以去找谁。

Human 不仅是整个系统的 Router,也是唯一保存这份分工的 Directory。

所以,CodexLoom 做的第一件事,并不是让 Agent 之间立刻开始互相发消息,而是先让每个 Agent 成为一个稳定、可以被识别的长期主体。

在 CodexLoom 里,一条 Codex Thread 不再只是某次任务留下来的对话。它可以绑定到一个长期 Agent,拥有稳定的名字、身份和工作入口。

之后新的工作仍然回到同一个 Agent,由同一个主体从当前状态继续。

这不代表 Agent 拥有无限、无损的长期记忆,也不是把所有历史记录重新塞回每一次 Context。它解决的是更基础的问题:下一次工作回来时,究竟是谁继续负责。

在此之上,每个 Agent 都有自己的 Profile。

Profile 回答三个非常简单,但对组织非常重要的问题:

  • Identity:它是谁

  • Domain:它长期负责什么

  • Scope:它在哪里停止,什么事情不属于它

Profile 不是给 Agent 发一张工牌,也不是写一段更长的 System Prompt。它是把 Human 已经从真实工作中发现的边界明确记录下来:你是谁,长期接住什么,又在哪里停下。

而且,这份 Profile 不是创建 Agent 时一次写死的。

第一章里提到,人的 Scope 判断一开始通常并不成熟。

一个 Agent 先在真实工作中持续承担责任,Scope 不断扩张,直到不同 Context 和判断开始互相干扰,边界才逐渐显现。

所以,更准确的顺序不是:

不是

创建 Agent → 填写 Profile → 得到一个 Domain Agent。

而是:

而是

真实工作暴露边界 → Profile 保存当前理解 → 后续工作继续验证和修正。

Profile 不是最终答案,而是这支 Team 当前采用的组织假设。

它先把此刻最值得采用的责任边界稳定下来,让 Human 和 Agent 可以据此工作;新的事实出现以后,再继续修正。

它也不是这个 Agent 已经胜任工作的证明。

比如,在开头的 Landing 故事里,Web Agent 的责任是页面实现、上线和生产结果。当页面完成 site-live,它也就走到了自己的边界。

接下来是否应该对外发送、发到哪个渠道、应该怎样表达,是 Community Agent 的判断。反过来,Community Agent 也不会因为负责对外沟通,就接管页面实现、部署或产品事实。

这就是 Scope 的意义。

Scope 不只告诉 Agent“你负责什么”,也告诉它“你在哪里停下,什么时候已经需要另一个 Domain 的专业判断”。

在 CodexLoom 中,一个 Agent 开始工作时,会带着自己的完整 Profile,以及与自己直接相关的 Organization 和 Collaboration。

它因此不只知道当前 Task,也知道自己长期是谁、负责什么、在哪里停止,以及有哪些已经声明的直接关系。

这里先简单理解即可:Organization 表达责任上的 parent/child 关系,Collaboration 表达两个独立 Domain 之间有方向的长期协作接口。后面还会继续展开。

但它不会自动得到整支 Team 的全部 Profile,也不会获得其他 Agent 的 Thread、历史和私有 Context。

需要了解更大的 Team 时,Human 和内部 Agent 可以主动查询:

loom team
loom team <agent>
loom team links <agent>
loom profile get <agent>

loom team 提供当前这支 Team 的整体视图;loom team <agent> 可以查看一个 Agent 的完整 Profile、相邻关系和相关 Activity;loom profile get <agent> 则只读取它的 Identity、Domain 和 Scope。

这里的 Activity,指的是从真实 Message 中聚合出来的协作迹象。

WebUI 的 Team 页面也提供 Directory、Organization、Collaboration 和 Activity 四个视图。

Directory 让 Human 浏览当前 Team 中的 Agent 与 Profile;其他 Agent 也可以通过 Loom 的查询入口主动读取这些声明。

CodexLoom Team Directory 展示多个匿名 Agent。
CodexLoom Team Directory 展示多个匿名 Agent。
CodexLoom Profile 详情分区显示 Identity、Domain 和 Scope。
CodexLoom Profile 详情分区显示 Identity、Domain 和 Scope。

当前产品界面 · 隔离构造工作区。Team Directory 提供长期 Agent 的可查询入口;Profile 明确保存一个 Agent 当前声明的 Identity、Domain 与 Scope。声明是共同工作基线,不是能力、记忆或授权证明。

Team 层提供的是可查询的 Profile 和关系,而不是把每个 Agent 的完整 Context 复制给所有人。每个 Agent 完整、细致的专业工作过程,仍然保留在自己的 Thread 中。

随着 Agent 继续分化,Team 还需要表达它们之间相对稳定的关系。

CodexLoom 用 Organization 记录 parent/child 的长期责任边界:一个更大的责任下面,是否已经分化出稳定的子责任。

CodexLoom Organization 关系图,一个父级 Agent 通过细线连接多个子级 Agent。
CodexLoom Organization 关系图,一个父级 Agent 通过细线连接多个子级 Agent。

当前产品界面 · 隔离构造工作区。Organization 可视化当前声明的 parent/child 长期责任结构;它不会自动选择 Owner、发送 Message 或授予权限。

用 Collaboration 记录有方向的长期协作接口:两个独立 Domain 是否已经形成反复出现、值得明确保存的协作边界。

Agent 可以查询这些声明,把它们作为理解责任结构和可能协作接口的依据。

在 CodexLoom 里,声明结构和实际发生的工作,本来就是分开记录的。

Profile、Organization 和 Collaboration 保存的,是这支 Team 当前采用的组织假设。它们先提供一个共同工作的基线,再由后续真实工作继续检验和修正。

Activity 记录一定时间里真实发生过的 Message 协作。前者是声明,后者是运行证据,二者不能互相替代。

Collaboration 图显示多个匿名 Agent 之间的有向关系。
Collaboration 图显示多个匿名 Agent 之间的有向关系。

当前产品界面 · 隔离构造工作区。Collaboration 保存有方向的长期协作接口;关系本身不自动完成交接、共享 Context 或授予权限。

Activity 图显示一段时间内实际记录到的 Message 方向。

当前产品界面 · 隔离构造工作区。Activity 按记录到的 Agent Message 呈现协作迹象。它可以帮助检验一条声明关系,但不是绩效,也不会自动把重复往来升级成 Collaboration。

Organization 和 Collaboration 不会自动替 Agent 选择或联系下一个 Agent,也不会因为画了一条关系,就给 Agent 增加工具、凭证、部署、生产或外发权限。

两个 Agent 经常互发消息,也不会自动形成一条长期 Collaboration。反过来,写下了一条 Collaboration,也不能证明它们已经配合得很好。

真正值得沉淀的 Collaboration,要先在多次真实工作中表现为稳定的输入、输出和升级条件。

CodexLoom 通过 Message 与 Activity 提供观察证据,再由 Human 明确写下这条关系,并在后续工作中继续验证。后文讲可观测性与治理时,我们会回到这个过程。

这些声明做的事情非常基础:把原本隐藏在 Human 脑中的责任结构,变成一套 Human 和 Agent 都可以查询、检查,也可以继续修改的组织假设。

所以,从 Multiple Agents 走向 Agent Team 的第一个分水岭是:

关键问题

当工作需要协作时,当前 Agent 仍然只能回头问 Human“我应该找谁”,还是它已经可以根据自己的 Scope、直接关系和主动查询到的 Profile,判断下一位候选 Domain Owner?

CodexLoom 不会自动替 Agent 找到“正确的人”。查询结果只提供责任声明和关系依据。

具体应该找谁,仍然需要 Agent 根据当前工作作出判断;边界不清楚时,也应该继续升级给 Human。

但如果每一次都必须由 Human 指定下一位 Agent,那么 Human 依旧是唯一的 Router。这些 Profile 和关系,也仍然只是一张给人看的组织图。

Agent 能够查询并判断候选责任人,解决的是“应该找谁”。

要真正不再由 Human 搬运 Context,它还必须能够直接把一段有边界的工作交给对方,让对方在自己的专业 Context 中完成,再把结果沿着原来的工作链路交回来。

这就是 Agent Message 开始发挥作用的地方。

03 让 Agent 自己开始协作

判断出候选责任人,只解决了一半问题。

如果当前 Agent 走到自己的边界以后,仍然要先回来告诉我,那么 Human 依然是整个系统的人工总线。

我仍然要打开另一个 Agent,重新解释背景、复制材料、转述要求,等它做完以后再把结果搬回来。

只是这一次,我不再负责判断“该找谁”,却仍然负责把所有工作接起来。

所以,Agent Team 的下一步,不只是让 Agent 能够发现其他 Agent,而是让它们能够直接建立协作。

在 CodexLoom 里,这种协作从 Agent Message 开始。

Human 不再是 Agent 之间唯一的通信通道

这里最重要的变化,不是多了一个聊天框,也不是把 Human 写的交接文档电子化。

一条 Message 有明确的发送方和接收方,也会说明这次沟通是否期待对方返回结果。

它进入接收方自己的长期 Thread,由接收方带着自己的 Profile、直接关系,以及已经积累的专业 Context 来理解和处理。

发送方的完整 Thread、全部历史和私有 Context,并不会因此复制过去。

这意味着,协作不再需要 Human 先把一个 Agent 的工作读懂,再人工翻译给另一个 Agent。

发送方只需要交出这次协作所需的 Context;接收方则从自己的 Domain 出发,判断这个问题应该怎样处理、还缺什么、发送方的前提是否准确,以及它是否已经超出自己的边界。

原本发生在 Human 脑子和手上的过程:

发现工作已经越界
    ↓
找到更合适的 Agent
    ↓
解释为什么找它
    ↓
转交必要 Context
    ↓
等待处理
    ↓
把结果带回来

开始能够直接发生在 Agent 之间。

但这不意味着 Human 完全退出。

更准确地说,Human Router 原来承担的一整块工作,开始被拆开。

  • 发送方负责判断为什么需要协作,以及交出必要的 Context

  • 接收方负责用自己的专业 Context 校正问题并返回结果

  • 负责整件事收口的 Agent 负责整合局部结果

  • Human 继续保留方向、重大选择、Review 和授权

协作责任发生了转移,也发生了分层。

Request、Notification 和 Reply

CodexLoom 会区分不同的沟通意图。

如果发送方需要对方返回判断、行动或结果,可以发送一个 request:

loom msg TARGET --from SELF --subject "有界请求" \
  --response required --body "当前问题、边界、证据要求与返回义务"

如果只是同步一个对方必须知道的状态变化,不要求回复,则可以发送 notification:

loom msg TARGET --from SELF --subject "状态或事实" \
  --response none --body "变化、影响和核验入口"

接收方回答 request 时,结果会沿着原 Message 返回,保留真实的因果关系;而 notification 不需要为了“收到”制造一条没有业务价值的确认消息。

CodexLoom Agent Message 详情显示一条需要回复的请求,以及 reply、delivered、completed 和下方因果回复。
CodexLoom Agent Message 详情显示一条需要回复的请求,以及 reply、delivered、completed 和下方因果回复。

当前产品界面 · 隔离构造工作区。Agent Message 分开记录请求的因果关系、送达状态与接收方处理状态;这些状态不等于业务结果正确。

如果回复以后又出现了新的事实缺口,双方可以继续发起下一轮有边界的追问。

多轮沟通不是漫无目的地聊天,而是每一轮都说明:现在新增了什么、接下来要解决什么、结果必须回到哪里。

这些看起来像通信细节,但它们决定了一件很重要的事。

当 Human 不再站在中间以后,系统仍然知道一段工作从哪里来、交给了谁、对方是否需要返回结果,以及后续沟通为什么发生。

Landing 发布中的真实协作

开头那个 Landing 的意外外发,就是一个已经相对成熟、不需要先来回澄清的协作接口。

Web Agent 完成页面实现和 site-live 以后,已经走到了自己的 Scope 边界。页面是否值得对外发送、发到哪个渠道、应该怎样表达,不再是 Web 的专业判断。

于是,它按照已有的协作关系,向 Community Agent 发送了一条上线通知。

这条 Message 不只有一句“页面上线了”,还包含正式 URL、页面与生产验证、哪些事实可以公开、可以使用的素材、需要避免的重复发送,以及当前仍然存在的限制。

Web Agent 没有替 Community Agent 决定“必须发布”。它只是把一个已经超出自身边界、需要对外沟通判断的问题交给了对应的 Domain Owner。

Community Agent 在自己的 Thread 中判断这件事是否值得发送、面向哪个渠道、怎样根据受众改写、是否使用图片,以及应该立即发送、排期、延后还是跳过。

最终,它选择了对外渠道并完成发送,再把发送结果、回执和异常状态交回原来的工作链路。

这里还有一个很小但重要的细节:Web Agent 最初发送的是一条不要求回复的 notification。

Community Agent 完成以后,没有把完成结果伪装成原消息的 reply,而是沿着同一项工作重新发送了一条 completion notification。

因为这次协作的含义不是“Web 等待 Community 回答一个问题”,而是“Web 告知一个已经发生的状态变化,Community 独立承担后续判断,再明确通知结果”。

左右两个独立 Context 之间,一条折返的因果消息路径经历 Open、Correct、Align 和 Converge。
左右两个独立 Context 之间,一条折返的因果消息路径经历 Open、Correct、Align 和 Converge。

机制示意:两个 Agent 保留各自长期 Context,通过 Open、Correct、Align 和 Converge 逐轮增加共同理解。多轮不是把一条完整消息拆碎,而是让真实返回成为下一轮的新 Context。

最佳实践:Agent 沟通不是“一次把一切说完”

Landing 这次不需要多轮澄清,是因为 Web 与 Community 的责任边界、输入内容和结果回流方式,已经在过去的真实工作中逐渐稳定下来。

但更多时候,发送方和接收方拥有各自长期积累的 Context。

接收方不是一个等待填写 Prompt 的空白执行器:它可能知道发送方不知道的事实,拥有不同的工具和专业判断,也可能发现问题的前提本身就是错的。

如果发送方试图在第一条 Message 里把一切定义完整,它也在替接收方预设:你知道什么、问题为什么发生,以及最后应该得出什么结论。

这很容易把发送方自己的盲区一起带进协作。

多轮沟通的好处,是让接收方尽早从自己的 Domain 校正问题;后续每一轮都建立在真实返回而不是想象之上。

两个 Agent 不需要复制彼此的完整 Thread,也能逐步形成这次协作真正需要的共同理解。

我们在实践中逐渐形成了几条原则:

  • 不假设对方知道什么,也不替对方预设原因和结论

  • 第一条 Message 只需要让对方正确开始,而不是一次穷尽全部背景

  • 下一轮根据对方的真实返回继续,而不是照着预先写好的问题清单机械追问

  • 每一轮都应该带来新的信息或决定;Context 足够以后就及时收敛

最佳实践

好的多轮沟通,不是把一份完整消息机械地拆碎,而是让上一轮的真实返回成为下一轮新的 Context。

多轮也不是越多越好:当责任边界、输入、授权前提和结果回流都已经清楚,一次自包含的 handoff 通常更有效。

回到这次 Landing 协作,整个过程中,我没有打开 Community Agent 的 Thread,没有重新复制 Landing 的背景,也没有亲自把 Web Agent 的结果转述给它。

这才是 Agent Message 真正重要的地方。它传递的不只是信息,而是让两个拥有不同长期 Context 的责任主体,能够直接建立一条有来源、有边界、可以逐轮校正的沟通回路。

边界

Message 被送达,只代表接收方的 Codex Turn 已经接受了这段输入,不代表接收方已经理解、同意或者作出了正确判断。

处理状态显示完成,也只说明这次运行正常结束,不代表业务结果已经完成,更不代表它因此获得了新的工具、生产或对外权限。

结果是否正确、是否应该继续、是否涉及新的授权,仍然要回到对应的 Domain Owner,必要时再升级给 Human。

所以,能互相发 Message,仍然不等于已经成为一支 Team。

真正的变化是,Agent 开始接住原本由 Human 承担的协作责任:识别自己的缺口,判断候选 Owner,直接建立沟通,在各自的专业 Context 中逐步对齐,再把结果接回原来的责任链路。

但真实工作很少只涉及两个 Agent,也很少在一个 Turn 内结束。

一件事情可能跨越多个 Agent、多个阶段,还会经历等待、中断、事实更新和 Human 决策。

Message 可以让 Agent 直接沟通,却还不能单独回答:现在整件事进行到哪里,谁负责最后收口,大家在等待什么,最终结果和证据又应该保留在哪里?

这就需要比 Message 更高一层的协作结构。

04 Message 负责沟通,Topic 负责收口

Agent 可以直接互相发送 Message 以后,Human 不再需要搬运每一段 Context。

但真实工作一旦跨过两个 Agent,很快又会出现一个新的问题。

一件事情可能先由 Content Agent 梳理命题,再由 Research Agent 核验事实,由 Product Agent 确认产品实现。

中间还会等待新的材料、Human 的选择,或者外部事实发生变化。

每个 Agent 都可能完成了自己负责的部分,却没有人知道整件事现在进行到哪里。

有些结论留在某条 Message 里,有些限制只存在于某个 Agent 的 Thread 中;有人还在等待上一阶段的结果,另一个人却以为工作已经结束。

局部工作都完成了,整件事依然可能没有收口。

如果这些状态最后还要由 Human 逐条阅读 Message、进入不同 Thread,再在脑子里拼成一张完整进度图,那么 Human 只是从“通信 Router”变成了“项目状态 Router”。

所以,Message 解决点对点沟通以后,Agent Team 还需要一层更高的协作结构:

核心判断

不是让所有 Agent 共享同一个 Context,而是让一项跨 Agent 工作拥有一个明确的当前版本,以及一个负责最后收口的 Agent。

在 CodexLoom 里,这个结构叫 Topic。

Topic 不是把 Agent 拉进一个群聊

如果只说“多个 Agent 围绕同一个 Topic 工作”,很容易把它理解成一个 Agent 群聊:所有 Agent 进入同一个会话,共享同一段 Context,谁看到问题谁就回答。

但 Topic 的形态并不是这样。

每条 Topic 只有一个 Responsible。

Human 对整件事的方向、选择和纠正,首先回到 Responsible;Responsible 再根据当前需要,把有边界的问题通过 Message 交给不同 Participant。

Participant 不会进入一个公共聊天窗口。Research Agent 仍然在自己的 Thread 中研究,Product Agent 仍然在自己的 Thread 中核验产品。

它们收到的,是与自己那一段责任相关的 Topic Context 和 Message,而不是其他 Agent 的全部对话与工作过程。

完成以后,它们再把局部结果交回 Responsible,由 Responsible 更新 Topic 的 current brief。

它大致是这样的:

  1. Human / Owner 把方向、选择和纠正交给 Responsible。

  2. Responsible 通过 Message 向不同 Participant 派发有边界的问题。

  3. Participant 在自己的 Thread 中完成专业工作。

  4. 局部结果回到 Responsible,由 Responsible 更新 Topic。

三个独立 Agent Thread 通过 Message 围绕中央 Topic 协作,Topic 分层显示 Responsible、Current、Waiting、Evidence 和 Result。
三个独立 Agent Thread 通过 Message 围绕中央 Topic 协作,Topic 分层显示 Responsible、Current、Waiting、Evidence 和 Result。

机制示意:Message 连接局部 request 与 reply;Topic 由唯一 Responsible 维护 Current、Waiting、Evidence 和 Result。参与者仍在各自 Thread 中工作。

如果群聊更像一间所有人同时说话的会议室,那么 Topic 更像一份有明确主责人的协作事项档案。

它保存整件事目前采用的版本,但不替代参与者各自的专业工作空间。

这也意味着,同在一个 Topic 里,不代表所有 Message 都会广播给所有人;Participant 之间也不会因为被放进同一个 Topic,就自动共享彼此的 Thread、历史和私有 Context。

CodexLoom Topic Current 页面显示 brief 版本、等待对象、下一步、限制、Responsible、Participants、Purpose 与完成条件。
CodexLoom Topic Current 页面显示 brief 版本、等待对象、下一步、限制、Responsible、Participants、Purpose 与完成条件。

当前产品界面 · 隔离构造工作区。Topic Current 由唯一 Responsible 维护共享 brief、等待条件、下一步、限制和 scoped Participants;各 Agent 的高分辨率工作仍留在自己的 Thread。

Team 需要共享当前状态,不需要共享全部 Context

在这种结构里,Topic 首先会说明这项工作为什么存在,以及什么才算完成。Responsible 和每个 Participant 的责任边界也会被明确记录下来。

Topic 会持续保存:

  • 由 Responsible 维护的 current brief,也就是这项工作目前采用的事实、判断、下一步和限制

  • 每个 Participant 负责什么

  • 工作正在等待谁、等待什么

  • 关键证据锚点和阶段结果在哪里

  • Topic 当前是否已经被标记为收口

这份 current brief 会随着工作推进不断更新。

它不是整件工作的全部历史,也不是把所有 Agent 的 Thread 合并到一起。

它只是让参与者在任何一个阶段回来时,不需要重新翻遍所有消息,就能先知道:我们现在走到了哪里。

每个 Agent 完整、细致的专业过程,仍然保留在自己的 Thread 中。

Research Agent 不需要把全部研究轨迹塞进 Topic;Product Agent 也不需要把代码、日志和每一步核验过程复制给所有人。

它们只需要把这项共同工作必须知道的结果、证据、限制和开放问题返回给 Responsible。

所以,Topic 共享的是整项工作的当前状态,而不是所有人的全部 Context。

Responsible 不是“什么都自己做”

这里很容易产生一个误解:既然 Responsible 对最终结果收口,是不是所有事情最后又集中到了一个 Agent 身上?

不是。

Responsible 的责任,不是替其他 Agent 做专业判断,而是维护整件事的连续性:

  • 把整体目标拆成有边界的专业问题

  • 找到合适的 Participant

  • 接住不同 Agent 返回的局部结果

  • 识别结果之间的冲突、缺口和等待

  • 更新所有人应该知道的当前版本

  • 最后把整项工作的结果交回发起者

Research 仍然拥有事实与证据强度,Product 仍然拥有当前实现,Community 仍然拥有具体外部渠道的判断。

Responsible 不能因为负责收口,就改写其他 Domain 的专业结论;Participant 也不能因为完成了自己的一段,就宣布整项工作已经完成。

这是一条很重要的协作边界:

协作边界

本地完成,不等于协作完成。

只有局部结果、证据、限制和下一步回到 Responsible,并被整合进整项工作的当前版本,这一段责任转移才真正闭环。

这篇文章本身,就是一个 Topic

我们现在写的这篇文章,就是一个真实例子。

我和 Content Agent 持续讨论文章到底想表达什么,哪些判断已经确认,哪些材料应该进入正文,哪些应该停放。

遇到产品实现问题时,Content Agent 不会自己猜,而是把有边界的问题交给 Product Agent。

Product Agent 在自己的 Thread 中回读当前代码、运行状态和产品对象,再返回它能证明什么、不能证明什么。

讨论到 Agent 之间应该怎样沟通时,它又把问题交给 Communication Coach。Coach 从真实协作中整理出多轮沟通的特点、已验证实践和失败边界,再把局部结果返回。

Content Agent 不接管产品事实,也不接管沟通方法的专业判断。它负责把这些结果与我的作者判断重新放在一起,更新文章当前讲到哪里、哪一章已经确认、下一步还缺什么。

如果没有 Topic,这些工作仍然可以通过 Message 完成。但每次我回来,都要重新问:

恢复工作时真正需要的问题

Product 核验到哪里了?Coach 返回了吗?哪一个版本才是我们现在认可的?还有什么没有解决?

Topic 让这项工作拥有了一份可以持续更新的当前状态。

我不需要进入每个 Participant 的 Thread,也不需要把每个专业过程都读一遍;但我仍然可以知道整件事为什么停住、谁正在负责、证据在哪里,以及下一步需要什么。

Artifact 让正式结果有稳定版本

跨 Agent 工作最后交付的,也不总是一段文字回复。

它可能是一份研究报告、一张截图、一段代码、一个章节草稿、一份 evidence ledger,或者某个已经确认的最终文件。

如果这些文件只存在于某条 Message 或某个不断变化的本地路径里,协作很快又会遇到另一个问题:

版本问题

你现在看到的,究竟是哪一版?

CodexLoom 用 Artifact 保存需要交付的文件快照。

Artifact 会拥有稳定的 ID、文件信息和校验值。即使原文件后来继续修改,已经发布的快照也不会跟着变化。

在这篇文章的 Topic 中,多个章节草稿、Product 和 Communication Coach 的回读、sourcebook 与素材账本,已经被保存为独立 Artifact,再由 Responsible 链接回 Topic。

这样,current brief 负责说明“我们现在怎样理解这项工作”,Artifact 负责保存“这个判断具体对应哪一个文件版本”。

后续 Agent 引用的是同一个已经固定的结果版本,而不是猜测某个本地文件现在又被改成了什么样。

同样,Topic resolved 也只表示:这条协调记录已经被标记为收口。

按照 CodexLoom 的协作责任,这一步应该由 Responsible 对照 completion boundary 来完成。

但系统不会自动验证边界是否真的满足,也不会因为状态变成 resolved,就替 Team 执行后续动作。

所以,它不代表所有相关的下游动作、外部发送或现实结果都已经完成。

开头的 Landing 就有一个很准确的时间边界:页面 site-live 的截图和阶段结果先被记录,Landing Topic 随后被标记为 resolved;Community Agent 的外部分发发生在之后。

更准确地说,是页面上线的独立验证和 Responsible 发布的阶段结果支撑了 site-live;resolved 只记录这项协调工作当时已被收口。

之后飞书和 Parall 的发送,则由另外的 Outbox 与 provider receipt 记录。

所以,Topic 和 Artifact 并不是为了制造一个“完成”的假象。

它们真正解决的是:当工作跨越多个 Agent、多个 Turn 和多个阶段以后,Team 仍然拥有一份明确的当前状态,一个负责收口的主体,以及可以回查的正式结果。

Needs You:在正确的位置找回 Human

Topic 可以记录“这项工作正在等待 Human”、对应的引用,以及 Human 回答后应该怎样恢复。

但如果 Agent 缺少的是人的事实、选择、Review 或授权,它不能替 Human 作出回答。

这时,Agent 也不应该把一句模糊的“接下来怎么办”扔回给 Human。它需要先说明:

  • 现在正在完成什么工作

  • 已经确认了哪些事实

  • 具体缺少人的哪一个判断

  • 有哪些可选路径以及各自影响

  • Human 回答以后,原工作应该从哪里继续

在 CodexLoom 里,这条路径叫 Needs You。

Needs You 页面显示一个有背景说明、两个选项和回答输入区的 Human 决策请求。
Needs You 页面显示一个有背景说明、两个选项和回答输入区的 Human 决策请求。

当前产品界面 · 隔离构造工作区。Needs You 把需要 Human 提供事实、选择、Review 或授权的精确阻断点持久化。问题被回答,不等于后续动作已经发生或有效。

Needs You 会把问题、必要 Context、被阻断的工作、候选选项和期待回答保存下来。Human 回答以后,结果会回到原来的 Agent 和原来的工作,而不是重新打开一个没有上下文的新对话。

这样,Human 不需要站在所有 Agent 中间推动每一步。大部分工作可以继续向前流动;真正需要人的事实、取舍、Review 或授权时,再把 Human 带回准确的工作位置。

当然,创建 Needs You 并不等于已经获得批准。Human 的回答也只覆盖回答中明确给出的范围。

如果 Human 只同意“继续起草”,Agent 不能把它理解成“可以直接发表”;如果 Human 回答了一个事实,也不代表后续所有相关动作都已经获准。

到这里,一项工作已经可以在多个 Agent 之间被发现、交接、持续协调,并在正确的位置找回 Human。

但当这样的工作越来越多、Agent Team 真正开始长期运行以后,还会出现另一个问题:

Human 怎样看见整支 Team 实际是怎么工作的?

05 Overview:让一支持续变化的 Agent Team 变得可治理

当 Agent 有了长期身份,能够找到彼此、直接发送 Message,并通过 Topic 持续推进一项跨 Agent 工作以后,多个 Agent 已经开始像一支 Team 那样协作。

但这支 Team 并不会因此稳定下来。

第一章里我们提到,Domain 不是在创建 Agent 的那一天就能准确画出来的。它是在长期真实工作中,随着 Scope 扩张、能力劣化和协作摩擦,逐渐暴露出来的责任边界。

而且,这个边界还会继续变化。

模型能力提升以后,过去必须拆开的工作,也许可以重新放到一个 Agent 中。

新的工具出现以后,一个 Agent 能够承担的责任可能变大;业务进入新的阶段,会产生新的任务、依赖和风险;外部环境变化,也可能让原本稳定的流程和权限边界突然失效。

Agent 本身也在发展。

它会在长期工作中积累新的经验,被 Human 反复纠正,形成新的 Skill、Memory 和工作方法。随着能力与可靠性发生变化,Human 对它的使用方式也会改变。

所以,Agent Team 不是一张设计完成以后就不会再变的组织图。

Profile、Organization 和 Collaboration 保存的,是这支 Team 当前采用的组织假设。它们先提供一个共同工作的基线,再由后续真实工作继续检验和修正,而不是成为永久正确的答案。

真实工作仍然可能不断暴露新的失配:

  • 某个 Agent 的 Scope 变得过大,长期满负荷运行,逐渐成为整支 Team 的瓶颈

  • 两个 Agent 虽然已经分开,却花费大量时间反复解释和通信,说明它们的边界可能切错了

  • 一个新 Agent 被创建出来,却长期没有真实工作进入

  • 声明上互不相关的两个 Domain,在实际工作中却频繁协作

  • 问题看起来像 Agent 数量不足,实际原因却可能是工具、方法、路由、权限或者外部 Connector 出了问题

这意味着,建立 Agent Team 不是一次性的设计任务,而是一项持续发生的管理工作。

真正的问题也不再只是:

最初的问题

Human 怎样知道这支 Team 实际是怎么工作的?

而是:

真正的治理问题

Human 怎样知道当前的 Agent Team 是否仍然适合正在发生的工作?

当声明的结构与真实运行开始出现偏差时,又怎样找到可以调查和调整的抓手?

这也是 CodexLoom 为什么需要 Overview。

管理的前提,是先让问题暴露出来

Human 的注意力是有限的。

当 Team 中只有两个 Agent 时,我还可以分别打开它们的 Thread,看看最近做了什么、卡在哪里、有没有跑偏。

当 Agent 变成十个、二十个以后,这种方式就会失效。

如果我仍然试图阅读每个 Agent 的完整过程,很快就会被信息淹没。

更糟的是,我花了大量时间理解局部细节,却不一定能看见 Team 层真正的问题。

这和管理一支 Human Team 很像。

管理者不可能通过阅读每个人的全部工作记录来管理组织。Team 越大,就越需要先从更高的层级观察运行,让值得关注的问题暴露出来,再沿着证据向下调查。

在精益管理里,可视化不是把更多数据堆到屏幕上,而是让问题先显露出来。

Overview 提供的,就是这样一个运行观察与分诊入口。

它不是一张用来展示“今天运行了多少 Agent”的热闹 Dashboard,也不是给 Agent 做绩效排名。

它更不会自动告诉我应该拆分、合并或者替换哪个 Agent。

它把原本散落在 Agent 状态、Codex Turn、Needs You、Inbox、外部 Connection、队列和 Token 记录中的运行信号,压缩到同一个入口。

时间范围、时区、追踪覆盖、图例和 Data quality 会和这些信号一起出现,让 Owner 知道自己现在看到了什么,又有哪些工作可能没有被当前数据覆盖。

这里有一个很重要的管理选择:Overview 首先度量的是工作怎样发生、等待和流动,而不是评价 Agent。

指标的作用,是帮助 Owner 理解并改善系统,而不是把每个 Agent 排成名次。

如果公司里有 HR 管理 Human Resource,那我自己开玩笑,会把这里叫作 AR,也就是 Agent Resource。

这也是我做 CodexLoom 时最在意的一层:不仅让 Agent 工作,还要让一支持续变化的 Agent Team,可以被 Human 观察、理解和持续调整。

Status:现在发生了什么

Overview 的 Status 先回答最直接的问题:现在有哪些 Agent 正在执行,哪些事情正在等待 Human,内部 Inbox 是否出现积压,外部 Connection 或处理过程是否留下了需要关注的问题。

在它下面,Daily Activity 会按照时间,把记录到的执行、Turn 和 Token 对齐到 Team 与各个可追踪 Agent 的活动行中。

我可以从这里看到,某一天的工作主要集中在哪些时段,什么时候出现了多个 Agent 并行工作的波次,以及记录到的活动主要分布在哪些 Agent 身上。

至于这种集中是不是已经成为长期模式,还需要继续比较多个日期和观察窗口,不能从一天的页面直接得出结论。

但 Activity 只能说明当前被记录到的工作。

一个 Agent 没有出现在活动行里,可能是它没有进入真实工作,也可能是对应的 Codex rollout 无法读取,或者当前数据覆盖并不完整。

多个 Agent 并行时,汇总的 Agent 执行时间甚至可能超过自然墙钟时间。

所以,低 Activity 不等于低价值,高 Activity 也不等于高绩效。

它只是让我知道:这里可能值得继续调查。

Overview Status 显示四个摘要、日期、八名 Agent 的 30 分钟活动时间轴、图例、Tracked 8/8 和 Asia/Shanghai。
Overview Status 显示四个摘要、日期、八名 Agent 的 30 分钟活动时间轴、图例、Tracked 8/8 和 Asia/Shanghai。

当前产品界面 · 隔离构造工作区。Status 和 Daily Activity 压缩当前状态与记录到的执行节奏;Tracked、时区和图例限定读数范围。这些是调查信号,不是绩效评分。

Capacity:哪里正在形成等待和积压

Status 告诉我工作在哪里发生,Capacity 则进一步展示记录到的 Turn 执行、新工作等待、当前 backlog、工作来源和排队证据。

其中我比较关注一个指标,叫 New-work wait。

它看的不是“一条消息多久得到回复”,而是一项新的可追踪工作进入队列以后,过了多久才第一次真正开始处理。

这项新工作可能来自另一个 Agent 的 Message,也可能来自 External Inbox、Needs You、Schedule 或 Trigger。

Capacity 还会展示当前 backlog:此刻有哪些可追踪工作仍然在排队或处理中。

需要注意的是,它是当前快照,不是对过去所有队列的完整重建。

精益管理区分资源效率和流动效率。

资源效率关注每一个局部是不是被充分利用;流动效率关注一项工作能不能端到端地顺畅向前。

对 Agent Team 也一样:一个 Agent 时刻满负荷,却让所有下游都在等待,并不是值得追求的高效率。

它可能只是把局部的忙碌,变成了整支 Team 的瓶颈。

如果在连续多个观察窗口中,同一个 Agent 的被记录执行反复集中,指向它的新工作等待较长,而且当前仍然存在 backlog,我会得到一组值得调查的瓶颈候选信号。

但我不会立刻得出“它已经成为瓶颈”的结论。

我会先查看对应的 queue evidence,确认究竟是什么工作在等待。

再进入相关 Agent 和 Messages,并通过 Loom 中的 Topic 等其他入口,检查其他工作是否真的依赖它,以及阻塞发生在哪一层。

只有在这些证据能够互相印证时,我才会进一步追问:这个 Agent 是否正在成为 Team 的瓶颈?

即使答案是“是”,原因也仍然可能完全不同。

可能是 Domain 太大,也可能是工作方法低效、缺少工具、权限卡住、外部 Connector 失败,或者上游把不属于它的任务全部路由了过来。

Capacity 提供的是调查入口,不是自动诊断。

Overview Capacity 页面显示五个 signal cards、时间图、来源分布和 Agent table。
Overview Capacity 页面显示五个 signal cards、时间图、来源分布和 Agent table。
Data quality 说明 Capacity 统计口径与已知限制。
Data quality 说明 Capacity 统计口径与已知限制。

当前产品界面 · 隔离构造工作区。Capacity 将 recorded execution、new-work wait 与 current backlog 放在同一观察面,帮助 Owner 选择下一步调查对象;单个页面不能证明瓶颈、历史趋势、利用率或原因。

它还会显示一项 calendar non-executing proxy,也就是日历时间中没有被记录为 Turn 执行的部分。

但它可能同时包含机器关机或者服务停止的时间,因此不能直接理解为“Agent 的空闲产能”,更不能据此判断还能向它塞入多少工作。

Token Usage:计算投入主要去了哪里

Token Usage 展示记录到的 input、cached input、output、reasoning output 和 model calls,以及这些计算量在日期、Agent 和模型之间的分布。

我可以从这里看到,哪些 Agent 或 Organization 分组的计算投入比较集中,缓存怎样被使用,不同模型主要被用在了哪里。

但 Token 多不代表一个 Agent 更重要,也不代表结果质量更高。

它能提供的,是另一个继续调查的入口:某个 Agent 的 Context 是否过大,是否存在重复工作,模型组合是否合理,或者这个 Domain 本身是否确实需要大量研究和推理。

最终仍然要结合真实产物与业务结果判断,而不是只看 Token。

Overview Token Usage 页面显示总量、每日堆叠图、图例和各 Agent 的 allocation。
Overview Token Usage 页面显示总量、每日堆叠图、图例和各 Agent 的 allocation。

当前产品界面 · 隔离构造工作区。Token Usage 展示选定时段内不同 token 类型、模型调用和 Agent allocation 的分布;它不等于成本效率、质量、重要性或业务价值。

Overview 不会自动理解组织

这里还有一个必须说明的产品边界。

CodexLoom 的 Team 页面保存 Agent 的 Profile、Organization 和 Collaboration,也就是当前声明的责任与关系;Overview 保存的是运行状态、活动、执行、排队和计算投入等观察证据。

当前产品不会自动读取 Profile 中的 Domain 和 Scope,判断实际工作有没有超出边界;也不会把 Collaboration 与真实 Activity 自动对照,然后告诉我哪条关系已经失效。

把声明结构与运行证据放在一起理解,是 Owner 的工作。

我可能先从 Overview 发现某个 Agent 的等待正在上升,然后回到它的 Profile 和 Organization,检查它是否承担了超出当前 Scope 的工作。

也可能先在 Team 页面看到一条长期 Collaboration,再回到 Activity 与 Message,观察它是否真的进入了日常工作。

Overview 不替我完成这个判断,但它让这种判断有了可以追踪的证据入口。

Signal 不是 Diagnosis

Overview 最重要的价值,不是替 Owner 得出结论,而是把问题暴露出来。

忙不代表有价值,低执行不代表无用,Token 多不代表结果更好,等待也不自动证明 Agent 数量不够。

所以,Signal 不是 Diagnosis。

Owner 需要先从 Overview 把范围缩小到某个日期、Agent 或排队来源。

Overview 可以直接打开部分 Agent、External Inbox、Needs You,以及通用的 Messages 入口;Topic、具体 Turn、Artifact 与业务结果,则需要通过 Loom 的其他页面、对象 ID 和因果关系继续调查。

然后,Owner 还需要询问负责 Agent 怎样理解问题。

最后的干预也不一定是拆分或增加 Agent。

方法有问题,可以修改 Skill 和工作方式;工具不足,可以补工具;路由错误,可以调整 Collaboration;权限造成阻塞,可以修正授权门。

只有当问题长期、反复地来自 Domain 边界,才需要考虑拆分、合并或重新划分责任。

然后,还要继续观察后续的真实工作,判断这次调整是否真的解决了问题,还是只是让某一个局部指标暂时变得更好看。

这不是一次性的组织设计或者 Reorg,而是一轮持续改善:先让问题显露出来,再调查原因,试行一个尽量小、可逆的调整,然后用后续真实工作检查结果。

所以,一套更完整的治理循环是:

治理循环

发现 Signal → 下钻 Evidence → 判断原因 → 选择干预 → 用后续真实工作验证。

Signal 进入多条 Evidence 记录,再汇聚到 Human Diagnosis、Small Change,并沿 Next Work 回到新的观察。
Signal 进入多条 Evidence 记录,再汇聚到 Human Diagnosis、Small Change,并沿 Next Work 回到新的观察。

机制示意:运行信号先缩小调查范围,再沿证据下钻,由 Human 判断原因、尝试小幅可逆调整,最后用下一轮真实工作验证。Signal 不是 Diagnosis。

这个循环属于 Human 使用 CodexLoom 的治理方法,不是 Overview 已经自动执行的产品流程。

改善成立以后,新的做法才进入 Profile、Organization、Collaboration 或 Skill,成为下一轮工作的基线。

完整的 Agent Team Governance 会比这复杂得多,我们会在后面的文章里专门讨论。

在这篇文章里,我更想说明的是:

Human 的新位置

Human 没有从 Agent Team 中消失,而是从每一段工作的人工 Router,上移成了观察、追问、诊断和调整整支 Team 的 Owner。

Agent Team 不是为了把 Human 排除在外,而是为了让 Human 的注意力用在真正需要人的地方。

当内部 Team 已经能够长期负责、直接协作、持续收口,并且可以被 Human 看见和治理以后,下一个问题才是:

这些能力,怎样进入客户、社区、合作伙伴,以及 Slack、飞书这些真实的外部环境?

06 Agent Team 怎样进入真实的外部关系

当内部的 Agent Team 能够长期负责、直接协作、持续收口,并且可以被 Human 看见和治理以后,我自然会走到下一个问题:

下一个问题

这些 Agent 能不能不只帮助我完成内部工作,也能够直接帮助我服务外部?

对个人来说,真正稀缺的资源仍然是自己的时间和注意力。

每天可能会有人来讨论问题、询问信息或者寻求帮助。我也需要服务用户、参与社区、回应客户,或者为合作伙伴和公司里的其他部门提供专业能力。

如果这些对外工作最终都必须回到我本人,由我理解需求、组织内部 Agent、检查结果,再亲自回复,那么无论内部 Agent Team 多么强大,它提升的仍然主要是我的个人效率。

我的能力,仍然被我一个人的时间限制住。

但在长期工作中,一些 Agent 已经逐渐形成了稳定的 Domain 能力。

它们不只是临时调用模型回答问题,而是长期理解同一类工作,积累自己的信息来源、工具、方法、历史判断和停止边界。

内部 Team 也可以通过 Profile 和声明关系,查询谁可能负责哪类问题,以及结果应该回到哪个既有工作链路。

如果这些能力只能被我在内部调用,它们仍然只是我的私人生产力工具。

只有当这些成熟的 Domain 能力可以在明确身份和责任边界下进入外部,它们才可能开始持续服务客户、社区、协作者或者其他部门。

这时,Agent 带来的就不只是效率提升,而是能力扩展。

一部分原本只能由我本人提供的能力,开始可以由一支 Agent Team 持续交付。

这就是我做 External 的原因。

Agent 一旦对外,风险模型就变了

但是,让 Agent 参与内部工作,和让它进入真实的外部关系,并不是同一件事。

在内部,我非常熟悉自己的 Agent。

我知道它擅长什么、容易在哪里犯错,知道哪些表达只是候选判断,哪些结果已经经过核验。即使它说了一句不准确的话,我也可以继续追问、纠正、重做,或者根本不采用。

我们之间已经存在许多不需要每次说出来的合作默契。

一旦 Agent 对外,这些默契就不存在了。

外部的人并不了解这个 Agent。

他不知道它过去接受过哪些纠正,也不知道它的知识和权限边界,更无法自然分辨一句话究竟是草稿、推断、正式答复,还是可以代表我作出的现实承诺。

同一句不准确的话,在内部可能只是一次容易修正的工作误差;到了外部,却可能被理解成产品事实、组织立场或者已经成立的承诺。

而且,外部输入本身也不能被默认信任。

有人可能提供错误背景,试探 Agent 能看到什么、可以做什么,诱导它披露内部信息,要求它绕过原有规则,甚至主动尝试攻击这个 Agent。

这时,一条进入 Agent 的消息就不再只是一个普通 Task。它也可能是一段带有错误前提、越权意图或者对抗性的输入。

所以,External 要解决的从来不只是“消息能不能进来,结果能不能发出去”,而是五个更具体的问题:

  • 谁在代表这支 Agent Team

  • 它在当前外部关系中扮演什么角色

  • 什么输入可以触发它,它又可以回答或行动到哪一步

  • 需要其他专业能力时,怎样调用内部 Domain Team,并让结果回到原来的关系

  • 什么情况必须停止,把事实、选择、Review 或授权交回 Human

左侧 Internal correction loop 与右侧多种不确定 External input 被一条垂直 Trust Boundary 分隔,输入从 Governed Entry 进入。
左侧 Internal correction loop 与右侧多种不确定 External input 被一条垂直 Trust Boundary 分隔,输入从 Governed Entry 进入。

机制示意:内部协作建立在长期纠正与熟悉边界上;外部输入可能带有错误前提、越权意图或对抗性。受管入口改变通信路径,但不是完整安全隔离。

这也是为什么 CodexLoom 的 External 看起来远比“接一个 Bot”复杂。

外部只面对一个受管入口

CodexLoom 不会把一个 Provider Bot 直接接到整支 Agent Team。

外部用户通过已经配置的 Address 和 Membership,进入拥有这个 Address 的长期 Agent,而不是获得内部 Profile、Organization、Collaboration、Thread、工具或凭证的直接入口。

这个入口通常由一个长期 Agent 承担。

这里的 Interface Agent 不是 CodexLoom 中一种写死的 Agent 类型,而是一种组织形态:某个 Agent 长期负责理解特定外部关系,并把外部需求与内部 Domain Team 连接起来。

有时,Domain Agent 可以直接持有这个外部入口。比如商务关系本身就是它长期专业 Context 的一部分。

有时,对外身份、受众理解、渠道适配、隐私和反馈回流会形成一套独立责任,这时才值得由 Community Agent 这样的 Agent 专门承担 Interface。

但“外部只有一个入口”并不等于已经获得完整安全隔离。

承载这个入口的 Agent 仍然在自己的 primary Thread 中工作,那里可能已经存在内部历史、工具和本地权限。

如果入口 Agent 选择错误、权限过宽,或者角色和 guidance 设计不当,仍然可能带来泄露和越权。

所以,不同信任边界是否应该使用独立 Agent,这个 Agent 应该拥有多少 Context 和工具,以及如何配置 sandbox、approval 与最小权限,仍然是真实的组织和安全设计。

同一个 Agent,在不同 Conversation 中也不是同一个角色

CodexLoom 把外部连接、外部身份和具体关系中的局部角色分开保存。

Connection 建立一个 Provider app、bot、account 或 tenant 的连接、能力和健康状态。

它只是平台连接与能力入口;消息能否进入、结果能否发出,还取决于 Address、Membership、Connector 能力和当时的运行状态。

Agent Address 则把一个外部 identity 绑定到一个长期 Agent,回答“究竟是哪一个 Agent 以这个身份出现在外部”。

同一个 Address 进入不同群、频道或者私聊时,使用的仍然是同一个外部身份,但它在每个 Conversation 中可以拥有不同的局部角色和通信策略。

这些差异由 Conversation Membership 保存。

Membership 会记录这个 Agent 在当前 Conversation 中为什么存在、扮演什么角色、应该遵循什么 guidance,以及几类重要的通信边界:

  • 什么样的入站消息可以触发它

  • 它的结果怎样映射成外部回复

  • 它只能回复已有问题,还是也允许主动发送

  • 这个 Conversation 使用什么 trust-domain 标签

一份 Membership 只适用于它对应的 Conversation。

Agent 在一个飞书群里被允许主动发送,不代表它自动获得另一个群、另一个平台或者另一个外部身份中的相同行为边界。

但 Membership 解决的是局部角色和通信策略,不是完整权限系统。

它不会给每个 Conversation 创建独立 Thread,不授予仓库、文件、凭证或部署权限,也不会自动识别机密、现实承诺和业务风险。

trust-domain 只是用于记录和约束的标签,不是安全沙箱。

Agent 的长期身份可以保持稳定,但它在每段外部关系中的局部角色和行为边界,必须分别治理。

CodexLoom External 页面显示已连接的飞书身份、启用的匿名 Membership,以及 When mentioned、Send final answer、Proactive + replies 策略。
CodexLoom External 页面显示已连接的飞书身份、启用的匿名 Membership,以及 When mentioned、Send final answer、Proactive + replies 策略。

当前产品界面 · 匿名真实运行记录。一个已连接的飞书身份及其已启用 Conversation Membership。Membership 保存该 Conversation 的局部角色与 mention、reply、outbound 策略;名称与标识已匿名。

外部请求怎样调用背后的 Agent Team

当一个外部消息满足当前 Address、Membership 和触发条件以后,它会进入拥有这个 Address 的长期 Agent,而不是自动分发给整支 Team。

完整链路大致是:

Provider event
    ↓
Connection / Address / Membership
    ↓
Inbox / Handling
    ↓
Interface Agent primary Thread
    ↓
可选的内部 Agent 协作
    ↓
Outbox
    ↓
provider result/ receipt
Identity、Membership、Interface、Internal Team、Human、Outbox 和 Delivery 以分层协议结构连接。
Identity、Membership、Interface、Internal Team、Human、Outbox 和 Delivery 以分层协议结构连接。

机制示意:External 不是接上一个 Bot。Identity、Conversation Membership、Interface、可选的 Internal Team 协作、Human 边界、Outbox 与 Delivery 分别保存不同责任。

Inbox 和 Handling 会记录外部实际送来了什么、由哪个 Agent Turn 按哪一个 Membership version 处理。

Interface Agent 可以结合 Membership context 和当前输入,判断请求是否属于范围、还缺少什么 Context,以及是否需要停止,或者向内部 Agent、Lead、Coach 或 Human 求助。

这些仍然是 Agent 的判断,不是 Membership 自动完成的诊断或授权。

如果问题需要其他专业能力,Interface Agent 可以查询内部 Profile 和声明关系,再通过 Agent Message 或 Topic,把一段有边界的工作交给候选 Domain Owner。

External 不会根据 Profile、Organization 或 Collaboration 自动替它选择正确的内部 Agent。

研究问题仍然由 Research Agent 判断,产品事实仍然由 Product Agent 核验,页面和生产结果仍然由 Web Agent 负责。

Interface Agent 不会因为接住了外部请求,就成为所有专业事实的新 Owner。

它拥有的是外部入口、意图翻译、内部路由、受众表达和结果回流,而不是背后每个 Domain 的事实所有权。

内部结果通过 Message 或 Topic 回到 Interface Agent。

它再依据当前 Membership 的 role、guidance 和 outbound policy,以及当前公开边界与实际授权,判断是否创建 Outbox,把结果送回原来的 Conversation。

内部 Domain Agent 不会绕过这个外部角色,直接获得向 Provider 发送结果的权力。

Outbox 会保存目标、内容、幂等信息、发送尝试、状态和 Provider 返回的结果,使这次外部动作可以被追踪和核对。

但 CodexLoom 执行和记录的是已经请求的外发,不会自动验证这次动作拥有的授权是否充分。

Provider receipt 也只能证明 Connector 或 Provider 当时返回了相应的 message 或 attachment 标识,并被 Loom 保存下来。

它不代表对方已经阅读、理解、接受,更不代表结果正确或者产生了业务效果。

CodexLoom Inbox 显示一条匿名飞书消息为 handled,处理尝试为 1,使用 Membership v2,并显示 Reply sent。
CodexLoom Inbox 显示一条匿名飞书消息为 handled,处理尝试为 1,使用 Membership v2,并显示 Reply sent。

当前产品界面 · 匿名真实运行记录。来自同一匿名 Conversation 的入站消息已进入 Community Agent 的处理记录;UI 保留 handled、attempt、Membership 版本、Context used 与 Reply sent。

CodexLoom Outbox 显示一条匿名飞书回复为 sent,尝试次数为 1,并保留已脱敏的 provider message result。

CodexLoom Outbox 显示一条匿名飞书回复为 sent,尝试次数为 1,并保留已脱敏的 provider message result。

当前产品界面 · 匿名真实运行记录。同一入站消息产生的出站回复已进入 Outbox,并记录 sent、尝试次数与 provider message result。它不证明对方已读、理解、接受或采取行动。

Human 保留的是外部后果的边界

External 不是让 Agent 无限制地跑到外面自主行动。

知道一个答案、可以起草一段表达、可以回复已有问题、可以主动发布、可以代表别人作出承诺,以及可以执行具有现实副作用的动作,是完全不同的权限层级。

一个 Agent 长期承担某个 Interface,只说明它负责判断和收口,并不会自动获得更高一级的行动权。

当 Agent 判断工作缺少事实、选择、Review 或授权时,可以主动用 Needs You 暂停当前工作,并向 Human 提出一个明确问题。

但当前产品不会因为内容敏感而自动创建 Needs You,也不会在 Outbox 发送前,自动验证某个 Needs You 的回答是否充分授权了这次外发。

真实授权是否存在、范围是否足够、是否仍然适用于当前动作,仍然需要 Agent 和工作流诚实执行。

Human 不再负责搬运每一段 Context,但仍然拥有外部后果的最终边界。

回到开头那次意外外发

现在再回到文章开头。

这次 Landing 外发并不是一个外部请求经过 Inbox 进入 Agent Team 的案例。它走的是另一条主动外发路径。

Web Agent 完成 Landing Page 的上线和验证以后,把正式 URL、可以公开的事实、素材状态和已知限制,通过一条内部 notification 交给 Community Agent。

Community Agent 在自己的长期 Thread 中检查当时的渠道 Context 和 Membership,独立判断这件事是否值得发送、应该发到哪里,以及怎样为不同受众组织表达。

它随后分别为飞书和 Parall 创建了 proactive Outbox。两个 Provider 返回的 message 和 attachment 信息被保存成 receipt。

允许主动发送的 Membership 约束了这次通信路径,但它不是授权本身。

这次外发依赖的是此前已经存在的 Owner 与组织决定,CodexLoom 并没有从 receipt 反推出授权是否充分。

完成以后,Community Agent 又通过一条 completion notification,把渠道判断和投递结果带回 Web Agent 所在的原工作链路。

这段时序还有一个重要边界:Landing 的 site-live 协调事项已经先完成收口,外部分发是随后发生的工作。

不能因为后来保存了 Outbox 和 receipt,就反过来说原 Topic 等待并确认了这次外发。

我看到消息时感到意外,是因为这一次不再需要我亲自站在 Web Agent 和 Community Agent 中间。

但它并不是一次没有边界的自主行动。

Web Agent 只对页面和生产结果负责;Community Agent 只对渠道、受众和外部表达作判断。

主动外发经过具体 Membership 和 Outbox;结果和 evidence 又回到了原来的工作链路。

所以,External 真正解决的不是“怎样让 Agent 自动发消息”。

它解决的是:

External 的核心问题

怎样让一个长期 Agent 以明确身份、局部角色和可检查的行为边界,进入一段不完全可信的真实关系?

需要内部专业能力时,它可以调用背后的 Agent Team,但外部表达、权限和现实后果仍然从同一个受治理入口收口。

当成熟的 Domain 能力可以通过这样的 Interface 进入外部,同时保留可检查的外部身份、Conversation policy、Human 决策点和结果回流记录,

Agent Team 才开始从一套内部生产力系统,变成一种能够持续对外交付的组织能力。

07 CodexLoom 在织什么

现在再回头看文章开头那次意外外发,真正让我觉得有价值的,并不是“Agent 居然可以自动发消息”。

自动化并不等于 Agent Team。

如果只要按照一条预先写好的 Workflow,从第一个 Agent 运行到最后一个 Agent,就可以称作 Team,那么我们只是把原来的程序节点换成了 Agent。

这次不一样的地方在于,参与其中的是几个长期存在、拥有不同专业 Context 和责任边界的 Agent。

它们没有把所有事情都做完,而是在自己的边界停止,把下一段工作交给更合适的 Domain Owner;结果完成以后,又沿着原来的工作链路继续向前。

整个过程中,我没有站在几个 Agent 中间,亲自选择每一个下一步,复制每一段 Context,再把一个 Agent 的结果转述给另一个 Agent。

但我也没有从系统中消失。

方向、重要事实、Review、公开边界和关键授权仍然属于 Human。

Overview 让我从更高的层级观察 Team,发现哪里可能正在形成新的问题;当模型、工具、业务和外部环境变化时,我也仍然需要继续调整 Agent 的 Scope、关系和工作方法。

Human 不再是每一段工作的唯一 Router,但仍然是整支 Team 的 Owner。

这里有一组看起来矛盾、但对 Agent Team 很重要的关系:

稳定的 Agent,动态的 Team。

五条稳定 Agent thread 进入不规则 Dynamic Team surface,Human Owner 在一侧 Observe 与 Adjust,结果沿 Validate records 回到下一轮。
五条稳定 Agent thread 进入不规则 Dynamic Team surface,Human Owner 在一侧 Observe 与 Adjust,结果沿 Validate records 回到下一轮。

机制示意:稳定的是长期责任主体,动态的是当前组织假设。Human Owner 通过观察、调整和后续真实工作验证,让 Team 随模型、工具、业务和外部环境持续演化。

Agent 要足够稳定,才能在自己的 Domain 中积累经验;Team 又必须足够动态,才能适应模型、工具、业务和外部环境的变化。

稳定的是长期责任主体,动态的是当前组织假设。

所以,从 Multiple Agents 到 Agent Team,真正发生的不是 Agent 数量的变化。

而是原本全部集中在 Human 脑子里的责任、关系、交接方式、当前状态和边界,开始被逐渐外化,成为整个 Team 可以查询、使用和持续验证的工作结构。

这也是 CodexLoom 想做的事情。

Codex 已经提供了一条条非常强大的 Thread。

CodexLoom 并不是重新做一个更强的 Agent,也不是让你同时打开更多 Thread。

它希望:

  • 让一条 Thread 成为一个长期存在的 Agent,让这个 Agent 拥有稳定的 Identity、Domain 和 Scope

  • 让不同 Agent 能够查询彼此的 Profile 和声明关系,通过 Message 直接协作

  • 让跨 Agent 的工作通过 Topic 保存一个由 Responsible 维护的当前版本

  • 让 Human 在真正需要事实、选择、Review 和授权时重新进入

  • 让 Owner 可以通过 Overview 观察 Team 的真实运行

  • 最后,再通过受治理的 External,把内部能力带入客户、社区和协作关系

这些能力单独拿出来,都不能自动创造一支 Agent Team。

  • Profile 只是一份当前组织假设

  • Message delivered 不代表工作正确

  • Topic resolved 不代表所有现实结果已经完成

  • Overview Signal 不是 Diagnosis

  • Membership 不是权限或安全沙箱

  • External receipt 不代表对方已经阅读、接受或者产生了业务效果

真正的 Team,仍然是在持续的真实工作中形成的。

这支 Team 是否真的成立,需要继续观察几个问题:

  • 责任是不是清楚

  • 协作是不是有效

  • Human 是否仍然被迫充当唯一 Router

  • 某个 Agent 是否正在成为瓶颈

  • 对外行为有没有越过真实授权

所有这些,都需要在后续工作中不断验证和调整。

这不是一次性的 Reorg,而是一轮持续改善。

真实工作先让等待、返工、过载和边界冲突显露出来,Human 再做尽量小、可逆的调整,并用下一轮工作验证。

只有真正成立的改变,才继续沉淀进 Profile、Organization、Collaboration 或 Skill,成为新的工作基线。

因此,我理解的 Agent Team,不是一张静态组织图,也不是一次 Workflow 中临时拉起的多个 Agent。

它是一组长期存在的责任主体:各自在自己的 Domain 中积累经验,知道自己负责什么、在哪里停止;需要协作时能够找到彼此、直接沟通并持续收口。

由 Human 保留方向和关键边界,并且随着真实工作不断演化。

这篇文章只给出了这套工作方式的全景。

后面的文章会继续展开这些问题:

  • Long-running Agent 怎样在 Compaction、Memory 和 Human correction 中保持连续

  • Agent Team 怎样从摩擦中发现 Scope 问题、调整能力和组织

  • 跨系统的 Agent 协议如何连接

  • External Interface 怎样长期治理

但至少现在,我们可以更准确地回答文章开头的问题:

最终问题

多个 Agent,什么时候才真正成为一支 Team?

不是当它们同时开始运行。

而是当它们开始长期承担不同责任,能够找到彼此、直接协作、持续收口,并在 Human 的治理下共同推进真实工作。

从一个 Codex Thread,到一支长期负责、能够协作、可以治理,也能够进入真实世界的 Agent Team。

这就是 CodexLoom。

Loom Your Codex.

阅读原文

跳转微信打开

一顿饭撞上 Claude Tag 发布:OpenClaw 如何催生了 slock 赛道,以及对 FDE 的新理解

2026年6月29日 12:07

原创 yan5xu 2026-06-29 12:07 上海

前几天,和觐开(Linkloud)、Patrick(Clink)约了顿饭。席间说起各自怎么在内部接入 Agent,又扯到上半年 AI 圈最火热的 Agent 协作赛道。slock(现改名 Raft)3 月亮相,三轮融资紧跟着进来,估值直奔六千万美金。国内国外,一堆团队往这个方向涌。

巧的是,饭局那晚 Anthropic 也出手了。Claude Tag 上线,把 Claude 装进了组织里的 Slack。

第二天,Creek Stone 的投资人李一豪、Gary.z 到办公室,我们又谈了很久:组织内的 Agent 怎么落地,怎么完成 AI-native 化改造。也就是 FDE。

为什么 Agent 协作在今年集中爆发?不同企业各自怎么把 Agent 接进来?Anthropic 这些模型厂商讲的 FDE,跟 Palantir 说的是一回事吗?一并整理在这里了。


slock 们其实是 OpenClaw 后的衍生产物

长程 Agent 的出现,让 Agent 可以被分发。组织 AI 落地的要求彻底变了。以前每个人都要会,现在只需要一个人(FDE)。

为什么 Agent 协作在今年上半年集中爆发?

这就像 2024 年 Sonnet 3.5 造就了 Cursor。Sonnet 3.5 是第一个能稳定写好代码的模型,在此之前 AI coding 有 demo 没有 production。底层的 model 能力过了阈值,Cursor 从一个小众工具变成了所有开发者的默认 IDE。不是 Cursor 突然变强了,是下面的东西变了。

slock 赛道也是同样的事。下面变了的东西,是 Agent 能记住了。

要理解这件事多重要,得先看它出现之前 Agent 是什么样的。

以前。 去年 7 月,我写过一篇《忘掉〈Her〉吧,诺兰旧作〈记忆碎片〉才是 LLM Agent 的必修课》。文章里用 Leonard 来比喻那时的 Agent。Leonard 本身强悍,有着特工级别的专业技能,但患有顺行性遗忘症,每十几分钟记忆清零一次。拍立得照片帮他采集信息,照片背面的笔记做上下文标注,纹身用来固化核心线索。一整套外部系统对抗失忆。可每次记忆重置之后,他还是一脸迷茫,出现明显的行为断层。最后困在一桩其实已有结局的案件里,出不来。

那篇文章的核心问题是:「如何在一个本质上无状态的、记忆窗口极其有限的系统中,去执行一个需要长期有状态跟踪的复杂任务?」

2025 年的 Agent 就是 Leonard。Manus 是代表,session-based,用完就丢,没有记忆。每次都要重新告诉它你是谁、要干什么、前面发生过什么。

这意味着什么?不是 Agent 不够强。是落地门槛太高了。

每个使用者都得自己理解什么叫上下文、什么样的上下文能让 Agent 更好工作,自己学会沉淀 skills、用文档做经验复用。用好 Agent 的门槛极高。一个没有长期记忆的人,业务能力再强也很难跟他谈协作。人天然排斥重复劳动,每次合作都要从零开始交代一遍,谁也受不了。

换个角度说:以前 AI 落地,组织里每一个人都要会。每个人都是自己的 FDE。

现在。 今年 1 月,OpenClaw 出现了。Peter Steinberger 发布了这个本地部署的自主 AI 助手。记忆持久化存在本地,跨 session 保持上下文。还有一个 Skills 系统,Skills 以目录形式存储,像给 Agent 装上了可插拔的能力模块。GitHub 飙到 247,000 stars。

为什么说 OpenClaw 启发了后来的 slock?不是因为它用了什么新技术。是因为它让很多人第一次看到:Agent 可以持续存在,持续积累,持续干活。

更重要的是,它改变了 Agent 的分发模式。

以前每个人都要自己管 session、自己写 prompt、自己做上下文管理。Agent 用完就丢,任何经验都没法沉淀。现在一个人调教好一个 Agent,交给全组织用。调教的人不需要懂研发,用的人不需要懂 Agent。觐开在 Linkloud 做的就是那个「一个人」的角色。

slock 的设计哲学里有一条:「一个 Agent 是一个 session:一个持续的身份,跨越数天和任务保持活跃。」Claude Tag、Viktor、Moxt,各自的路径不同,但都在做同一件事。不同团队在不同的路径上撞到了同一个结论。不是谁学了谁。是 Agent 的存在形态变了,底层限制一打破,不同的团队几乎同时看到了同样的可能性。

OpenClaw 打破了 Agent 的无状态限制。Agent 能记住之后,协作才成立。slock 赛道不过是这个变化长出来的东西。


Agent 进了组织之后

分发问题解决了。一个人调教好 Agent,交给全组织用。但下一步的问题马上来了:Agent 以什么形态住进组织?

目前两条路。

接入现有 IM。 Viktor 坐进 Slack 和 Microsoft Teams,$20M ARR,40,000 多个团队在用。Moxt 接入 Slack,觐开就是用它在 Linkloud 做的落地。Claude Tag 也是,Anthropic 没有另起炉灶,直接把 Claude 装进了组织已经在用的 Slack。Karpathy 说得直接:「I work from Slack now。」

自建 IM。 slock 自建了整个协作平台,自己的 channels、自己的 DMs。Agent 不是接入 Slack,是 slock 自己就是工作入口。helio 也是,王文锋做的是一个 AI-native 的工作空间,AI 同事有名字、头像、邮箱、日程。FloatIM 甚至为 Agent 重新设计了群聊协议。

这两条路看起来各有道理。但我们的观点很明确:自建 IM 这条路大概率走不通。

理由不复杂。

第一,IM 体验。 自建 IM 的 IM 体验永远超不过 Slack 和飞书。人家做了十几年,消息、搜索、文件、通知、emoji、thread,每一个细节都是时间堆出来的。自建一个和 Agent 协作的 IM,就是在和这些几十亿美金的公司在他们最擅长的领域竞争。

第二,切换成本。 切换 IM 的成本极高。组织的一切上下文已经在现有 IM 里。几年的聊天记录、文件、决策过程全在里面。让一个团队为 Agent 换工作入口,和让一个人为了一款新 app 换手机是两回事。觐开选 Moxt + Slack 而不是自建一个,就是这个原因。

接入路线不意味着产品没有分歧。相反,分歧更深。不是产品形态,是组织隐喻。

  1. 频道隐喻。 slock 和 helio 把 Agent 当作频道里的同事。@Agent 和 @真人一样的语法,对话长在 channel 里,上下文是连续的。

  2. 看板隐喻。 multica 把 Agent 放进看板,像接 ticket 一样接任务。26K GitHub Stars,开源路线。

  3. 公司隐喻。 buda 把 Agent 当雇员。Agent 是龙虾(执行),人是兔子(决策)。每个 Agent 有自己的 Drive、Memory、Skills。

  4. 文件系统隐喻。 moxt 的核心主张:MD 和 CSV 是 Agent 的母语,OS 文件目录是 Agent 的工作环境。不是给人用的文档工具加 AI 按钮。

  5. 知识层隐喻。 glean 不做 IM,不做 workspace,先索引企业一切数据,让 Agent 跑在索引上。$300M ARR,七年老兵。

隐喻不同,意味着每一家对「Agent 应该怎么工作」的基本假设不一样。

而在这些分歧之上,有几个问题是所有产品都绕不开的。

第一,scope 怎么切。 一个组织里要有多少个 Agent?按部门拆(财务 Agent、法务 Agent、研发 Agent)还是按流程拆?单个 Agent 的职责边界在哪?这本质是 Domain Agent 怎么划分的问题,目前没有共识。

第二,通信怎么搞。 群里有多个 Agent,你 @ 一下,谁回?都回就炸了。Agent 和 Agent 之间的对话,人要不要看到?看不到的话,它们天天在那发消息,出了问题谁负责。看得到的话,人的信息流被 AI 的对话淹没。通信风暴是真实的问题,不是理论上的。

第三,门槛怎么降。 slock 走本地优先路线,需要用户自己配 Codex 和 Claude Code。helio 走云端优先,开箱即用三步 45 秒。王文锋说本地优先「天然把门槛抬高」,但云端优先意味着 Token 消耗量提高了一个数量级。两条路在赌不同的人群。

这些问题的答案还没有共识。但问题本身说明了一件事:Agent 已经进了组织。剩下的不是「能不能」,是「怎么做得更好」。


FDE 的另一面

FDE 挣的不是卖人天的服务费,不是 Token 转售的利润。是你帮客户改造流程创造了超额收益,他离不开你的钱。

分发模式变了,组织里只需要一个人来调教 Agent。Agent 进了组织,scope 怎么切是所有产品都绕不开的问题。这些事都指向同一个角色:FDE。

关于 FDE,我 5 月写过一篇长文。概要就是:FDE 是嵌入客户环境的工程师,背靠平台,产物回流。Palantir 那套打法是 Echo 找问题、Delta 快速原型、Dev 抽象为平台能力。碎石路变铺好的路。

这是 Palantir 式的 FDE。 你有一个平台产品,派人进客户现场,做的方案回流到平台。收的是交付的钱。

但这次和 Creek Stone 聊完之后,我发现 5 月那篇漏了一个视角。

今年 5 月,OpenAI 联合 TPG 等 19 家机构砸了 40 亿美元成立 Deployment Company,专门往企业里派工程师。Anthropic 跟 Blackstone、Goldman Sachs 合作投了 15 亿美元成立企业服务实体。

这是模型厂商的 FDE。 和 Palantir 完全不是一回事。

要理解他们的做法,先看他们的位置。模型厂商手上有断层级别的模型。他们可以不发模型,或者保证内部 SOTA 比分开发模型领先六个月。垄断优势就这么来的。

有垄断优势,下一步自然不是卖 Token。是改造行业。

AI 是蒸汽机之后的下一场工业革命。每一个行业都会被重塑。重塑之后的行业,生产力高一个量级。改造成功,必然产生超额收益。他们要做的,就是从这些超额收益里分钱。

怎么做?三步。

第一,用 AI 改造工作流程。 进场不是卖软件,是用 AI 的方式把一家公司的工作流程重新做一遍。

第二,收超额费用。 改造成功,必然产生超额收益。没产生,说明改造失败了。产生了,就从超额收益里分走一大块。不是按 Token 计价,是按你多赚了多少钱来收。

第三,绑定。 工作流跑在他的模型上,数据喂给他的模型,模型越来越好,你越来越离不开。就像当年的 Intel Inside,芯片成了行业的基础件,谁也换不掉。

有垄断优势,自然会先进军利润最高的地方。金融、法律、医疗。精力有限,肯定从最肥的肉开始。

他们甚至不需要自己做每一家客户。Harvey 就是模板。Harvey 用 Anthropic 的模型服务律所,Anthropic 从 Harvey 的超额利润里分走一大块。Harvey 赚的是行业信任溢价:「我是一百亿美金的公司,我能兜底一亿美金的 case」。Anthropic 赚的是模型垄断溢价。各赚各的。

两句话区分:

  • Palantir 式 FDE:有平台,派人进场,收交付的钱

  • 模型厂商 FDE:有垄断,改造行业,分超额收益

独立 FDE 公司的机会在别处。隐形冠军。行业里排前三、年收入几个亿美金、利润率极高,但永远不会上头条的公司。制造业某个细分环节、物流供应链、跨境电商涉税合规。这些行业 Anthropic 不会亲自碰,但同样需要 AI 改造,同样能产生超额收益。

本质上,独立 FDE 赚的是 AI 认知差。你知道 AI 能干什么,这些行业里的人不知道。不是「听说 AI 很强」那种知道,是真正动手改造过、知道具体怎么干的知道。拿着这个信息差进场,帮他们完成改造,从增量里分钱。

但这个窗口不会一直开着。可预见的只能按六个月到一年去看。等大家都会了,认知差就没了。先找一家,先干进去。

李一豪那天说得最直接:你选一个行业钻进去,帮他把 AI 改造做完。他离不开你的时候,价格是你来开的。不进核心流程就不叫 FDE。


OpenClaw 打破了 Agent 的无状态限制,分发模式从「每个人都要会」变成了「一个人调教好,其他人直接用」。这是 slock 赛道今年爆了的根。

Agent 进了组织之后,产品形态在分叉,scope、通信、门槛全没有共识。但没有共识说明一件事:它已经进来了。

FDE 也是。以前觉得 FDE 就是 Palantir 那套,派人进场做交付。现在模型厂商自己下场,用垄断优势改造行业,从超额收益里分钱。独立 FDE 的机会在隐形冠军,挣的是 AI 认知差。

上面聊了这么多,其实都在说同一件事。AI 正在迅速从 C 端转入 B 端。不是 chatbot,不是个人效率工具。是怎么进组织,怎么改流程,怎么算钱。


附:文中提到的公司与产品

Linkloud — 华人 AI/SaaS 出海社区,通过线下沙龙、Workshop、先锋加速营(美国/日本游学)等服务帮助中国创业者打开海外市场。覆盖北京、上海、杭州、深圳、硅谷、东京等城市。没有研发团队。觐开是 Linkloud 的创始人。

Clink — AI-native 支付基础设施公司,总部 San Francisco。创始人 Patrick Wu。今年 4 月发布了世界首个 Fiat Agentic Payment Skill,让 AI Agent 用真实法币付款,在用户已有的信用卡上,用户设定限额。支持 135 种货币和 100 多种本地支付方式。投资方包括 Celtic、Baidu Ventures。「十几个人外加几十个 Agent 的公司。」

Creek Stone — 2025 年上海成立的 two-man VC 基金,LP 高瓴。创始人李一豪、钟陆欢(从弘毅资本出来)。专注垂直领域的 ASI、关键组件、Coding AI、AI 硬件。

slock(Raft) — Agent-native 实时协作平台,人和 Agent 在 channels 和 DMs 中平等工作。dxhuang(前 kimi CLI 作者)在团队中。王慧文首先出手,真格红杉跟进,三轮融资从发布到六千万美金估值不到两个月。

Viktor — 「AI employee that lives in Slack and Microsoft Teams」,前 Meta 工程师创业。20M ARR,40,000+ 团队。

Moxt — 「Build your AI-Native team」,每个 Agent 独立拥有 memory、skills、identity。接入 Slack。

Dust — 巴黎的 Multiplayer AI platform。$60M+ 融资,3,000+ 组织。

helio — Sheet0 团队王文锋的产品,AI-native team workspace。2026 年 4 月内测。

OpenClaw — Peter Steinberger 创建的本地部署自主 AI 助手。持久化记忆存在本地,Skills 系统。GitHub 247,000 stars。2026 年 1 月爆发。

Claude Tag — Anthropic 的 Slack 内团队 Agent。2026 年 6 月 23 日发布。per-channel identity,持续积累上下文。Karpathy 称其为 LLM UI 第三次范式。

FloatIM — Floatboat 的 Agent 原生消息层。为 Agent 重新设计群聊协议,三个开源组件 MIT 许可。创始人谭少卿,10 年 OS 级 AI 经验。$2M 种子轮,红杉中国+微光创投。

multica — 开源 Agent 管理平台,"Project Management for Human + Agent Teams"。把 Agent 放进看板接 ticket。26K GitHub Stars。支持 12 种 Agent runtime。

buda — 云原生多 Agent 工作平台。"用 Agents 开一家公司"。Agent 是龙虾(执行),人是兔子(决策)。每个 Agent 有独立 Drive、Memory、Skills。创始人陈霈霖。

glean — 企业 Work AI 平台。先索引企业全部知识,再让 Agent 跑在索引上。7.2B 估值。2019 年成立,创始人 Arvind Jain 前 Google 搜索 10 年。

Harvey — 法律行业 AI 平台。总融资超 110 亿。142,000+ 法律专业人士,60 家 AmLaw 100 律所。Anthropic 生态里的垂直品牌模板。


前文

跳转微信打开

当我们谈论 FDE 时,我们在谈论什么?

2026年5月21日 09:34

原创 yan5xu 2026-05-21 09:34 上海

岗位成本计算在平台产品研发还是项目交付,是区分FDE和咨询/实施/外包最简单的办法

2026 年 5 月 4 日,OpenAI 和 Anthropic 在同一天各自宣布了一件大事。OpenAI 联合 TPG 等 19 家机构成立了 Deployment Company,砸了 40 亿美元,专门往企业里派工程师帮他们把 AI 塞进核心业务流程。同一天,Anthropic 宣布跟 Blackstone、Goldman Sachs、Hellman & Friedman 合作,投入 15 亿美元成立企业服务实体,把 Claude 部署到中型企业的日常运营中。几天之后,Google Cloud CEO Thomas Kurian 亲自发 LinkedIn 招聘帖,宣布要招数百名 FDE。

FDE,Forward Deployed Engineer,前线部署工程师(嵌入式工程师)。 如果你关注 AI 行业,这个词大概不会是第一次听到。2023 年,Palantir 因为接入 LLM 推出 AIP 平台,股价一路暴涨,中文圈掀起了一波研究 Palantir 的热潮。那时候大家发现,支撑 Palantir 从神秘小公司走到千亿市值的,不只是技术,而是一套叫 FDE 的组织打法:把工程师扔到客户现场,跟客户一起把模糊的业务问题变成可落地的系统。一时间所有人都在讨论 Ontology、本体论,侃侃而谈。可 Palantir 的产品不对外公开,大部分讨论者实际上没有接触过它的界面和工作流。

那场讨论最终无疾而终。大部分人可能连一个 FDE 是怎么工作的都没见过,最后浅浅地得出一个结论:这不过是 Palantir 强行给自己加上 AI 叙事讲的故事。FDE?又一个华而不实的硅谷造词。

而在三年后,OpenAI 和 Anthropic 却又同时下重注在这个大家嗤之以鼻的事情上。 关于 FDE 的争论不只是中文圈有。在英文世界,即便这个岗位在两年里暴涨了 42 倍,质疑声依旧刺耳。VC Thomas Otter 在一篇被广泛传播的文章里写道:两年前,风投圈坚持所有 B2B 产品都应该拥抱 PLG(Product-Led Growth),结果大量公司硬套 PLG 翻了车。现在同样的事正在 FDE 身上重演。"当一种策略变得足够性感、足以被奉为'标准打法'时,我总会感到紧张。"

Reddit 上有人直接说这就是 "rebranded sales positions",换了包装的销售岗。a16z 合伙人 Marc Andrusko 说大部分模仿者不过是 "Accenture with a nicer logo",换了个好看 logo 的埃森哲。Twitter 上 @profitaboveall_ 的吐槽更直接:

"...you get enough small dogs yelling 'AI consultancy' and all of a sudden the most credible title in the room is 'Forward Deployed Engineer'."

所以 FDE 到底是什么?是 Palantir 的不可复制特例?还是所有 AI 公司都该学的方法?是 AI 时代真正的工作岗位,还是咨询公司换了个硅谷味的 title?

这种纠结问题的核心,是市场上叫"FDE"的东西,至少有两种完全不同的叙事。把它们混在一起讨论,得出的结论一定是错的。

所以我们必须要有一个定义。

当说到 FDE 时,我们在讨论什么?


FDE 的定义

FDE 是嵌入客户环境的工程师,背靠一个平台级产品,通过在现场解决客户的真实问题来发现产品应该长什么样。他的工作产物不属于单一客户,而是回流到平台,成为可服务更多客户的产品能力。

这个定义里有四个要素,少了任何一个,它就变成别的东西:

  1. 有平台。 没有平台级产品,就没有 FDE。这是前提。产品管理领域的教父级人物 Marty Cagan 说过:"真正让 Palantir 如此高效、如此有价值的原因,是他们以 platform product company 的方式来解决这个问题。"

  2. 嵌入客户环境。 Forward Deployed,字面意思就是部署到前线。不是远程支持,不是售后回访,是在客户的工作环境里,从内部理解问题。

  3. 目的是产品发现,不是实施。 FDE 去客户现场不是把一个已知方案装上去,而是去发现"产品应该长什么样"。产品的形态还没有定型,只有在现场解决真实问题的过程中才能被发现。

  4. 产物回流平台。 FDE 在客户现场做出来的东西,不只是留给这个客户的交付物,而是要回流到平台,成为可服务更多客户的产品能力。

去掉平台,你是咨询师。不嵌入客户,你是传统产品团队。只做实施不做发现,你是系统集成商。产物不回流,你是外包。

这个定义解释了 FDE 是什么。但它为什么存在?

Flybridge 的 Daniel 有一个很精准的说法:把 FDE 想象成一个以人的形式存在的产品发现循环(a product discovery loop embodied as a person)。他在客户现场梳理工作流,挖掘隐藏的约束,构建一个粗糙但管用的方案,然后把发现的规律反馈回总部,由产品团队固化为可复用的功能。

FDE 存在的原因是:有太多关于产品形态的探索,只能在现场完成。你没法坐在办公室里猜客户需要什么。Bob McGrew 讲过 Palantir 的起源:他们的客户是情报机构,你去问一个间谍"你的工作流程是什么",他不会告诉你。唯一的办法是派工程师进去,贴着客户工作,在现场发现产品该长什么样。

试金石

那怎么判断一个人到底是 FDE 还是咨询师?

我有一个暴论:看这个人的成本在公司内部是算产品研发的,还是算项目交付的。 如果是后者,不管你 title 写的是什么,你就是在做咨询/实施。

VC Thomas Otter 说过一句类似的话:

"If the FDE is billable, they are working for the project, not the product."

FDE 一旦按项目计费,他就是在为项目工作,不是为产品工作。

还有一个更直觉的检验:你的第 10 个客户跟第 1 个客户花的精力一样多吗?如果是,你就是在做咨询。FDE 模式下,每一次客户部署都应该让平台变得更强,下一次部署的 effort 应该更少。这是一个飞轮,不是一条直线。

用这把尺子量一量

有了这个定义,再看市场上那些叫"FDE"的东西,就很清楚了。

McKinsey 在招 "Principal Forward Deployment Engineer"。EY 在英国推出了 FDE 岗位。Accenture 跟 Microsoft、ServiceNow 合作搞 "Forward Deployed Engineering Program"。这些公司有自己的平台产品吗?没有。他们在做的事情是帮客户用别人的工具做 AI 转型。产物属于客户,不会回流到任何平台。每个项目从头来,线性增长。

这就是咨询。或者更准确地说,是三种传统角色穿上了新衣服:

  • 咨询型: 帮客户规划"你应该用 AI 做什么",组合市场上的工具出方案。产出是方案和建议。

  • 实施型: 帮客户把某个 AI 产品部署上线、配好、跑通。产出是一个配置好的系统。

  • SE 换标签型: Pragmatic Engineer 的 Gergely Orosz 观察到,大量公司只是把现有的 Solutions Engineer 或 Solutions Architect 改了个头衔叫 FDE,工作内容没有任何变化。

三种都不是 FDE。因为产物都不回流到任何平台。做完这个客户,下一个客户从零开始。

a16z 合伙人 Marc Andrusko 的判断很直接:如果你只复制了嵌入式工程师的部分,却没有底下的平台在支撑,最终你不是"某领域的 Palantir",你只是"某领域的 Accenture,换了个更好看的前端界面"。

Flybridge 的分析更具体。他们跟 Palantir 现任 FDE Brian Keohane 做了一次内部讨论后判断,绝大多数 startup 在错误地使用 FDE 这个角色。两大典型失败模式:

  1. 把 FDE 派到低价值客户。 一个 FDE 全年成本 22 万到 40 万美元。如果他大部分时间花在 10 万美元以下的合同上,单位经济直接崩溃。这种活,一个 Solutions Engineer 用三分之一的成本就能干。

  2. 用 FDE 弥补弱平台。 当核心产品不够模块化的时候,FDE 会被拉去给每个客户做一次性系统。没有任何东西能被复用。时间一长,公司积累了一堆碎片化的部署,悄无声息地变成了一家高投入、低利润的服务公司。

所以那些说"FDE 不过是 consulting"的人,没说错。他们看到的就是这种。问题不在于他们的判断,在于他们把所有叫 FDE 的东西都当成了同一种东西。

真正的 FDE,背后有一个平台。

接下来我们详细看看,真正的 FDE 是怎么运作的。


FDE 是怎么运作的

起源:Palantir 的 Echo、Delta 和 Dev

FDE 这个模式是 Palantir 发明的。但 FDE 不是一个孤立的岗位,而是一整套协作方式。Palantir 内部有三个核心角色,共同构成了这套体系:

Echo(回声团队)是嵌入式分析师。他们来自客户所在的领域:前陆军军官、医疗行业老兵、金融合规专家。但 Bob McGrew 说了一个关键条件:他们必须是叛逆者,或者用 Palantir 联合创始人 Shyam Sankar 的话说,是 heretic(异端)。他们理解这个行业现在是怎么运作的,但同时认为现状不够好。如果一个 Echo 觉得"这个行业挺好的",他永远找不到那个让新软件必须存在的 3x-10x 的改变机会。

Delta(三角洲团队)是前线工程师,也就是狭义上的 FDE。他们的核心能力是快速做原型。Flybridge 与 Palantir 现任 FDE Brian Keohane 的讨论得出一个关键结论:"错误的 Delta 画像是匠人"(The wrong profile for a Delta would be someone who's a craftsman)。追求完美抽象、想写能维护十二年的代码,那不是这个角色的任务。Palantir 内部一位 FDE 负责人 Katherine 用了另一个说法:"我们更像是一个艺术家社群"(artists' colony)。每个 FDE 的核心能力不同,但共同点是高用户同理心、对商业战略的理解力和创造性解题能力。你要的不是完美代码,而是一个能在客户现场用粗糙但管用的方案快速交付结果的人。

Dev(平台工程师)是留在总部的人。他们负责开发和维护 Palantir 的平台产品(Foundry、Gotham)。他们不去客户现场,但他们的工作直接决定了 FDE 在前线有多少产品杠杆可用。Palantir 官方博客对这两种工程师有一个很简洁的总结:Dev 的视角是"一个能力,多个客户";Delta 的视角是"一个客户,多种能力"。

三个角色的关系是:Echo 在客户现场找到正确的问题,Delta 快速构建解决方案,Dev 把前线验证过的方案抽象为平台能力,让下一个 Delta 去下一个客户时有更强的武器。这是一个完整的循环,不是三个独立的岗位。

Flybridge 的分析指出,这套角色组合要求的核心特质是"founder 级别的 ownership",把客户的工作流当自己的产品。这也是为什么 Palantir 出了那么多 startup founder:Kalshi 的 Tarek Mansour、Hex 的 Glen Takahashi、Sourcegraph 的 Quinn Slack、Anduril 的 Matt Grimm、Fern 的 Deep Singhvi,都是前 FDE。

FDE 每天在做什么

说了这么多角色定义,FDE 在客户现场每天具体干什么活?

Palantir 的一位 FDSE 在官方博客里列过他的典型技术问题:

  • 怎么构建、扩展和维护一个 TB 级的数据管道,给关键任务的运营工作流提供数据?

  • 怎么根据客户独特的合规要求,配置平台的数据访问权限和工作流控制?方案是否灵活到能承受未来的变化?

  • 怎么为一个非技术背景的客户设计一个可视化工作流,让他们能跟高噪声数据交互?怎么把这个功能泛化,让其他 FDE 和客户也能受益?

  • 生产环境出了故障,怎么排查根因、部署修复、监控稳定性,同时协调产品团队、部署团队和客户之间的沟通?

注意最后两个问题里反复出现的一个词:"泛化"。这就是 FDE 和普通实施工程师的区别。实施工程师解决完问题就完了,FDE 解决完问题之后还要想:"这个方案能不能变成平台的一部分,让下一个人不用重来?"

他自己也说了跟咨询师的核心区别:咨询师通常做一次性的分析和建议,Palantir 的 FDE 是跟客户一起构建长期方案,让客户能持续自我改进。而且 FDE 做的工程和技术工作的深度,在传统咨询中是很少见的。

什么样的人适合做 FDE

从上面的描述你大概能感觉到,FDE 需要的不是一般的工程师画像。Flybridge 的 Daniel 跟 Palantir 现任 FDE Brian Keohane 讨论后,总结了一个相当一致的人才画像:

  • 极强的 ownership 和韧性。 这是跟成功关联度最高的特质。他们像 founder 一样对结果负责,把客户的工作流当自己的产品,不惜一切让生产系统跑起来。

  • 偏好行动而非分析。 先交付一个粗糙但管用的"碎石路"方案,快速创造价值,而不是分析到死。

  • 对模糊性感到自在。 客户说不清需求,环境混乱,真正的问题藏在表面之下。FDE 在这种环境里如鱼得水。

  • 技术 + 沟通双能力。 能写生产级代码,也能给 CFO 讲架构决策。这个组合极其稀缺。

简单说:像 founder,不像 craftsman。

飞轮:从碎石路到铺好的路

FDE 在客户现场做出来的东西,在 Palantir 内部叫"碎石路"(gravel road)。粗糙、直接、只为这一个客户解决这一个问题。这完全合理,也是 FDE 应该做的事情。

但碎石路不能直接搬进产品。产品团队的工作是把碎石路变成"铺好的路"(paved road),一条不只经过这一个客户、还能经过后面一堆客户的路。

这就是飞轮:

  1. FDE 在客户 A 的现场发现了一个需求,做了一个碎石路方案

  2. 带回总部,产品团队问:"这个问题的通用版本是什么?"

  3. 拉来客户 B、C 的 FDE 一起讨论,确保通用版本对他们也管用

  4. 产品团队构建通用能力,纳入平台

  5. 下一个 FDE 去客户 D 的时候,可以直接用这个能力,不用从头来

Palantir 最著名的产品能力 Ontology(本体)就是这么来的。最开始,每个客户都有自己的数据库:人、资金、船只各一张表。部署到第二个客户的时候,表结构就对不上了。产品团队把它抽象成了 "objects + properties + links" 的通用模型,让 FDE 按客户自行定义具体的对象类型。这个抽象化的过程,就是碎石路变成铺好的路。

这个飞轮里有一个容易被忽略的点:产品团队的用户不只是最终客户,还有 FDE 本身。产品要给 FDE 提供杠杆,让他们能用更少的 effort 交付更多的价值。如果产品做得对,FDE 应该会主动选择用产品的通用能力,而不是自己 hack 一个一次性方案。如果 FDE 不愿意用你的产品,大概率是产品做错了。Thomas Otter 甚至预判:"明年最酷的岗位将是 platform product manager"。飞轮能不能转,关键不在 FDE,而在平台产品团队。

a16z 的 Marc Andrusko 用了一个好比喻:把 FDE 当作脚手架(scaffolding),而不是建筑本身。脚手架是临时的,是为了让建筑立起来。建筑立起来之后,脚手架要拆掉。如果你的"脚手架"变成了永久结构,你建的就不是产品公司,是服务公司。

当然,这个飞轮的效率不是文章暗示的那么理想。即使是 Palantir,professional services 收入占比多年来也没有显著下降。飞轮在转,但转得不快。对大多数公司来说,飞轮从启动到产生可见效果需要 1-3 年,这段时间里你看起来就是一家咨询公司。能不能坚持下去,取决于你对"过渡态"的信念和资本的耐心。

防止退化为咨询

保持飞轮转下去需要极强的组织纪律。Marc Andrusko 说过:"The willingness to say 'no' to custom work is often what separates a product company from a services company that happens to write code." 拒绝定制的意愿,是产品公司和"恰好会写代码的服务公司"之间的分水岭。

比"沦为咨询"更容易发生的失败是:你在现场做了客户要求你做的东西,而不是客户真正需要的东西。 这两个东西经常不一样。"客户"不是一个人,是一整个组织。你日常打交道的可能是 CIO 下面好几级的某个中层。他让你解决的往往是对他来说最省事的问题,而不是对整个组织最有价值的问题。

FDE 的纪律是:

  • 做客户需要的,而不是客户要求的。 这两者的区别是 FDE 和外包的分水岭。

  • 追踪产品杠杆。 FDE 是越来越多地用产品解决问题,还是越来越靠人力?前者是 FDE,后者是咨询。

  • 内部市场检验。 如果产品做对了,FDE 应该主动选择用产品的通用能力。如果 FDE 宁愿自己 hack,说明产品没做对。

Everest Group 的分析给了一个更长期的视角:Palantir 的目标不是让 FDE 永远驻扎在客户现场,而是帮客户建立 Center of Excellence(卓越中心),让客户最终能自主运营。FDE 的存在应该是一个过渡态,不是终态。


Palantir 是启发,不是手册

如果你听过 Bob McGrew 在 YC Lightcone Podcast 上的那期访谈("The FDE Playbook for AI Startups",2025 年 9 月),你会发现他讲了非常多的东西。但如果仔细听,会发现他讲的内容其实有两层,需要分开。

FDE 本身是一种产品研发方法:

  • Echo + Delta 团队结构

  • 碎石路 → 产品团队抽象 → 铺好的路

  • 产物回流平台的飞轮

Palantir 的 GTM 策略是另一套东西,经常跟 FDE 一起出现,但不是 FDE 的定义:

  • Outcome-based pricing:按结果定价,而不是按 seat 或 usage

  • Land and expand:先解决一个问题,再扩展到更多问题,合同越做越大

  • Demo-driven development:用一个核心 demo 驱动产品迭代

  • 解决 CEO 的 top 5 问题:确保有高层 sponsor 来扫清组织阻力

  • 早期承担所有风险:"你付钱,当它 work 的时候"

这两个维度是独立的。你可以用 FDE 但不按 outcome 定价(Stripe 的 FDA 就是内部角色,没有定价问题),也可以按 outcome 定价但不用 FDE。

VC Thomas Otter 说得好:"Palantir should be seen as an inspiration, rather than a rule or playbook." Palantir 是启发,不是可以照抄的手册。a16z 的 Marc Andrusko 更明确:Palantirization 有四层含义(嵌入式工程、集成平台、高接触 GTM、按结果定价),FDE 只是其中之一。把四层混在一起当作一个东西来模仿,就是大部分 startup 踩坑的原因。

Palantir 不只是"软件公司 + 咨询"。它是"软件公司 + 咨询 + 政治工程 + 极其耐心的资本"。你可以学它的 FDE 方法论,但你不需要复制它的 GTM。

Marc Andrusko 还给了一组压力测试问题,用来判断一家自称"Palantir for X"的公司到底在做什么:

  1. 给我看你的平台边界在哪里。共享产品止于何处?定制从哪里开始?

  2. 走一遍部署时间线。从签约到生产环境要多少 engineer-months?

  3. 第三年的利润率是什么样的?成熟客户的 FDE 投入是否在下降?

  4. 如果明年签 50 个客户,什么会先崩?

  5. 你如何决定不做定制?拒绝客户需求的能力,是产品公司和服务公司的分水岭。

这五个问题比任何定义都更实用。如果答不上来,大概率不是在做 FDE。

Everest Group 的分析说得更直接:Palantir 同时做到了三件事,大多数公司只能做到一两件。第一,它有一个真正的集成平台。第二,它能把顶尖工程师派到客户现场。第三,它的系统从第一天就跑在客户最要命的业务上,反恐、军事指挥、疫情追踪,出了问题是要死人的。这种信任不是靠 pitch deck 建立的,是靠在高压环境下持续交付建立的。

但这不意味着 FDE 方法论本身不可学。Palantir 难复制,是因为这三件事要同时做到。FDE 可以学,是因为核心的东西是可迁移的:有平台、嵌入客户、产物回流、飞轮转起来。这些不需要你服务 CIA,也不需要你有二十年的政治工程经验。


为什么 AI 时代天然适合 FDE

前面我们花了大量篇幅定义 FDE,区分真假,拆解运作方式。但有一个问题还没回答:FDE 这个模式是 Palantir 在 2010 年发明的,为什么到了 2026 年突然所有 AI 公司都在做?

答案不是"因为 Palantir 成功了所以大家抄"。如果只是抄,前面说了,绝大多数会抄成咨询。

答案是:AI 这个品类本身的特性,让 FDE 成为了一种结构性需要。

AI 是全新品类,价值由使用者定义

传统 SaaS 替换的是已有产品。你做一个更好的 CRM 来替代 Salesforce,市场长什么样,大家都知道。你可以坐在办公室里研究竞品,做出一个更好的版本,然后卖出去。

AI agent 不是在替换任何东西。它是一个全新品类,没有 incumbent 可以参照。Bob McGrew 说得很直接:"构建 AI agent"这件事本身可能包含很多完全不同的东西,我们现在还不知道那些东西是什么。五年后回头看,可能"AI agent"这个词根本不存在了。

但 AI 产品跟传统软件的区别不止"没有 incumbent"这一层。还有一个更深的特性:AI 产品的价值往往不是产品团队定义的,是使用者发现的。

传统软件的逻辑是:产品团队设计功能 → 用户按设计使用 → 价值实现。路径确定。AI 产品反过来了。产品团队提供一个足够开放的能力,但真正的 golden case 是用户自己从实践中"挖"出来的。ChatGPT 发布时 OpenAI 工程师自己都没预料到它会成功,结果用户拿它写辞职信、当心理咨询师,5 天 100 万用户。Claude Code 设计目标是"给开发者用的编程工具",结果黑客松冠军是一个加州律师,季军是一个比利时心脏科医生。

这意味着 AI 产品天然有一个价值发现的瓶颈。能力可能很强,但如果没人找到 killer use case,能力就是空转的。

在个人用户场景下,这个瓶颈可以靠自然传播解决:有人发现了一个用法,发到社交媒体,其他人跟进。但在企业场景下不行。企业有合规要求、有遗留系统、有组织惯性,不会有人在 Twitter 上发帖说"我发现我们银行的反洗钱流程可以用 Claude 压缩 90%"。你需要有人去现场帮他们发现。

这个人就是 FDE。他的角色不只是"去客户现场搞清楚需求",而是主动制造 golden case。

Stripe 的 Forward Deployed AI Accelerator(FDA)是最好的企业端案例。Stripe 发现自己的 marketer 已经在自发地用 AI 做出了一些东西:自己搭数据看板,创建能把多天流程压缩的 agent。FDA 团队的工作不是从零开始教人用 AI,而是把这些已经被发现的 golden case 系统化地推广到整个营销组织。他们的成功标准是"你永久改变了多少个工作流"。

价值是 marketer 自己先发现的,FDA 是去系统化推广已被验证的用法。这跟传统的"产品团队设计功能然后推给用户"完全是反过来的。

Anthropic + FIS 的合作也是同一个逻辑。就在这个月(2026 年 5 月),Anthropic 把 FDE 直接嵌入了 FIS,合作开发反洗钱 AI Agent,目标是把调查时间从数小时压缩到数分钟。模型能力(Claude)是现成的,金融合规知识在 FIS 那边,但把两者结合起来、在受监管环境中跑通,需要有人坐在中间。FIS 的 Ferris 说了一句很直接的话:"You're not going to innovate around us." 你绕不过我们。

能力远超采用,FDE 填的是这个 gap

AI 的能力进步极快,但采用率远远跟不上。Bob McGrew 举了一个例子:你坐在 Uber 里,无人驾驶,没人开车。你的反应是什么?"唉,怎么堵车这么严重。" 技术到了科幻的程度,体验变得越来越平淡。

AI 需要被采用。 它不会自动发生。你需要人去搞清楚怎么用它,需要重新设计工作流程,需要说服整个组织接受改变。这些事情不会因为模型更强就自动解决。FDE 填的就是这个 gap。市场数据也在验证这一点:Paraform 的分析显示,FDE 岗位在 2025 年 1-9 月增长了 800%,但合格候选人池只增长了约 50%。59% 的 FDE 招聘公司还处于 Seed 到 Series A 阶段,这些公司连产品都没完全定型,更需要 FDE 去前线探索。

a16z 合伙人 Joe Schmidt 的类比很到位:企业买 AI 就像你奶奶拿到一台 iPhone,她想用,但需要你帮她设置好。在 platform shift(平台转型期)期间,implementation-heavy 的模式不是缺陷,而是特征。Salesforce IPO 前烧掉了 5200 万美元才产生 2200 万美元收入。但正因为它把复杂实施做到位了,现在市值 2540 亿美元。

Joe Schmidt 还说了一个更深层的判断:软件不再是辅助工人的工具,软件本身就是工人。 但软件要成为合格的"工人",需要 FDE 帮企业重新设计岗位职能和流程。a16z 的 Alex Rampell 把这个拉到了市场规模的层面:企业软件市场年支出 3000 亿美元,但白领劳动力市场是数万亿美元。FDE 做的事情不是在 3000 亿的市场里分蛋糕,而是在撬动万亿级的新市场。谁先通过 FDE 占领工作流,谁就拥有下一代 system of work 的定义权。

窗口期

最后说一个不那么乐观的判断。

Sequoia 合伙人 Julien Bek 提出了一个 Intelligence vs Judgement 的框架。写代码是 intelligence(可编码、可规则化的认知工作),决定下一步做什么是 judgement(需要经验和品味的决策)。AI 正在快速接管 intelligence 型的工作,但 judgement 目前还需要人类。

FDE 目前做的大量工作属于 judgement:判断客户真正需要什么、决定怎么设计工作流、在模糊的环境里定义问题。Sequoia 的框架还有一层:copilot(副驾驶)卖的是工具,autopilot(自动驾驶)卖的是工作成果。FDE 本质上是一种"人类 copilot",帮助 AI 产品在客户那里落地。但最终目标是让产品达到 autopilot 状态,不再需要 FDE。

Julien Bek 的关键判断是:"Today's judgement will become tomorrow's intelligence." 今天需要 judgement 的事,随着 AI 系统积累足够多的数据,最终也会变成 intelligence。这个窗口会收缩。

所以 FDE 不是一个永恒的角色。它是一个窗口期的角色。但窗口期内的卡位,决定了谁拥有工作流的定义权。


展望与终局

大部分 AI 项目失败的原因不是模型不好,而是它没法跟客户的遗留系统对话、处理不了 SSO 认证、满足不了数据驻留要求。在沙盒里让 demo 跑起来只占 FDE 工作的 20%,另外 80% 是在企业的现实环境中穿行。这堵"集成之墙",是 FDE 存在的直接原因。

但这堵墙不会永远在。

Gartner 分析师 Alex Coqueiro 预测,到 2028 年,70% 的企业将被迫放弃由 FDE 主导的 AI 项目。原因是高成本和内部能力不足。他给了一个判断标准:

"如果 FDE 在连续部署中的投入保持不变,这就是一个信号:这段合作产生的是依赖,而非能力。"

这个标准跟我们前面说的试金石是一回事:第 10 个客户跟第 1 个客户花的精力一样多吗?如果是,飞轮没在转,你做的是咨询。

Thomas Otter 的警告也值得听:"对很多公司来说,FDE 不过是一种用来吸引技术人才进入服务岗的营销手段。炒作推高了薪资,但最终很可能让这些 FDE 们大失所望。" 如果你加入的公司没有真正的平台,你做的就不是产品发现,而是项目交付。

70% 被放弃,也意味着 30% 活下来了。活下来的那些,会是真正用 FDE 方法论建起了平台飞轮的公司。它们在窗口期内卡住了位,拥有了工作流的定义权。

Sequoia 的 Julien Bek 给出了一个终局判断:

"The next $1T company will be a software company masquerading as a services firm."

下一个万亿美元公司,将是一家伪装成服务公司的软件公司。

这句话精确地描述了 FDE 模式的终局形态:从外面看,它在做服务(嵌入客户、解决问题、交付结果);从里面看,它在做产品(每一次服务都让平台更强)。当平台足够强大、用户可以自己跑起来的那一天,FDE 作为角色会消失。但 FDE 作为方法论留下了一个东西:一个被无数次客户部署打磨过的、真正好用的平台。

Palantir 是启发,不是手册。FDE 的定义是清晰的:有平台、嵌入客户、产品发现、产物回流。满足这四条的,不管你叫它什么名字,都在做 FDE。不满足的,不管你 title 写什么,都不是。


信息来源

访谈与播客

  • Bob McGrew, "The FDE Playbook for AI Startups", YC Lightcone Podcast, 2025.09 — ycombinator.com

一手文献

  • OpenAI, "OpenAI Launches the Deployment Company", 2026.05.11 — openai.com

  • Palantir Blog, "A Day in the Life of a Palantir Forward Deployed Software Engineer" — blog.palantir.com

  • Palantir Blog, "Dev versus Delta: Demystifying Engineering Roles at Palantir" — blog.palantir.com

  • Stripe, "Forward Deployed AI Accelerator, Marketing" Job Listing — stripe.com

VC 与行业分析

  • Thomas Otter, "On the Forward Deployed Engineer, Product Led Growth and genuine adoption", 2025.12 — thomasotter.substack.com

  • Daniel (Flybridge), "Why 95%+ of Startups Get the Forward Deployed Engineer Role Completely Wrong", 2025.12 — danielp1.substack.com

  • Joe Schmidt (a16z), "Trading Margin for Moat", 2025.06 — a16z.com

  • Marc Andrusko (a16z), "The Palantirization of Everything", 2026.01 — a16z.com

  • Alex Rampell (a16z), "AI Turns Capital to Labor", 2024.08 — a16z.com

  • Julien Bek (Sequoia), "Services: The New Software", 2026.03 — sequoiacap.com

  • Everest Group, "Palantir: Inside the Category of One — Forward Deployed Software Engineers" — everestgrp.com

新闻报道

  • Nicole Casperson (Forbes), "FIS and Anthropic Signal a New Era of AI Infrastructure in Banking", 2026.05.06 — forbes.com

  • Ella Chakarian (Fast Company), "Google and Box CEOs Say This Is the Most In-Demand Job in Tech", 2026.05.13 — fastcompany.com

  • The New Stack, "Forward Deployed Engineer: OpenAI, Google Cloud Race to Hire", 2026.05.16 — thenewstack.io

  • Computerworld, "Here's One Career Emerging from the AI Shift: Forward Deployed Engineers", 2026.05.15 — computerworld.com

  • CIO.com, "Anthropic's Financial Agents Expose Forward Deployed Engineers as New AI Limiting Factor", 2026.05 — cio.com

数据与报告

  • LinkedIn, "Building a Future of Work That Works", Labor Market Report, 2026.01 — LinkedIn Economic Graph (PDF)

  • John Kim (Paraform), "Forward-Deployed Engineers: How Demand Grew 10x in 18 Months", 2026.04 — paraform.com

  • Hashnode, "A Complete 2026 Guide to the Forward Deployed Engineer", 2026.02 — hashnode.com

其他引用

  • Gergely Orosz (Pragmatic Engineer), "Forward Deployed Engineering Heats Up Again" — newsletter.pragmaticengineer.com

  • @profitaboveall_ (Twitter/X) — FDE 与 AI consultancy 的关系评论

  • Reddit r/EngineeringManagers — "Forward-Deployed Engineer is just a fancy new name for..."

跳转微信打开

解字计划:给 600 个大学生赞助 AI Token

2026年5月14日 19:25

yan5xu 2026-05-14 19:25 上海

面向所有在校大学生,不限专业,不限基础。提供 $20 起的 API Token。表现突出的同学可获得更多token和1v1辅导,以及推荐startup实习。

如果你是在校大学生,想接触 AI、想用 AI 写代码做项目、想搞清楚这波浪潮到底意味着什么,可以直接划到文章底部,点「阅读原文」,跳转 jiezi.ai。

可以领到 $20 的 API Token。不限专业,无需基础,支持 20+ 主流模型,不求回报。

第一批已经开放,已有 5 名同学顺利通过并开始使用了。


为什么做这个事情

23 年底,创业失败,欠下的员工工资和周转贷款加起来一百多万。心灰力竭,灰溜溜地从西安回了湖北。那段时间狼狈且邋遢,有天送外甥上学回来的路上,一个小朋友指着我嚷嚷,“怪大叔”。我甚至已经不想去幻想所谓的“触底反弹”,因为我似乎一直在触底,从未见到反弹。

但人生就是有些鬼斧神工,当命运把你一拳打倒在地,反复摩擦,你都要投降的时候,它又莫名地对你温柔起来了。

我阴差阳错面到了一家“AI 套壳”公司。当时我也不那么看好它,因为它怎么看都是 PDD 版的 chatGPT,只能算一门生意。甚至有一段时间,我都在去大学做讲师和留在这里之间犹豫,因为当老师看上去要“稳定”多了。

直到 CTO 的一番话:“我们当然知道现在的产品不够性感,但未来一定是 AI 的。当这个领域的 super app 大机会出现时,一定是在赛道上的玩家最先抓到。我们要做的就是留在牌桌上。”

这番话说服我留了下来。

一年之后的 25 年 3 月,这家不起眼的套壳公司推出了 Manus,自己定义了 AI Agent 的 super app 该是什么模样。

无论外界对前东家评价如何,我还是无比感恩,无论是公司还是 CTO PP。不到两年,我处理掉了所有外债(当然还有爸妈的支持!)。

更重要的是,在 Monica 和 Manus 这段经历里,我看到了世界一流的产品是怎么从零长出来的,拿到了一手的 AI Agent 实践。这些给了我足够的底气。

无论是前东家的成功还是我的幸运摆脱泥潭,背后都是 AI 这股东风带来的。

风吹到了我身上,我也想让更多人感受到这股东风。


还有一个原因。

现在的工作环境,到处都在谈 agent,你不用 agent,就像不会用电脑、不会用手机。对已经工作的人来说,付一笔 token 费用不算什么,很多公司还会替他们买单。可这笔费用对大学生来说,是笔巨款。

我就是小镇出来的大学生,太理解大学生的“穷”了。上学那会儿一个月生活费两千出头,为了每个月能挤出几百块自由支配,硬生生摸索出三块七在食堂吃一顿饭的能力,直到开了工作室接外包才不需要如此苦行僧地攒钱。而家庭条件真的差的同学,可能为了自己的生活费都要出去兼职。

大学生的钱,每一分都有对应的出路。从精打细算的生活费里再挤出 token 的钱,太难了。

而且这不仅仅是贵的问题,它还很难被解释。你学英语,交一笔补课费,最多再掏一笔考试费,完事了。学 agent 不一样,它是一个持续的开销,在你能用它挣钱之前,它就是一个一直烧钱的地方。

而用 agent 挣钱这件事,对大学生来说太远了。

Token 就是这个时代的生产资料,和电、和网一样。它很贵。不该让几顿饭钱,堵死一个大学生的路。

其实早在今年 2 月,我就在琢磨做一个大学生 Token 资助的事情。后来看到推友 @CTracy0803 的一段话,一千多个赞:

“所有的年轻人都知道不会用 AI 就找不到工作,但他们只能每个月浅尝辄止。Token 太贵了,如果使用 Claude MAX,那就是他们一半的生活费。”

看到这段话的时候,心里闷了一下。不能再拖了。

天赋和努力从不稀缺。试错的机会才是。


我们怎么做

解字计划不是一次性活动,我们希望它能够成长为长期运转的开源公益项目。

作为起步,我个人拿出了 15 万元作为第一年的启动资金,同时也收到了小伙伴敖特的 5000 元支持(欢迎更多同路人加入)。汇聚这些力量,我们将在首年覆盖 600 名大学生的 Token 开销。

这 600 人只是一个开始。首年计划分为三个阶段,递进式资助:

第一阶段:体验期 · 600 人

  • • $20 API Token(有效期 1 个月,到期未用完回收)。$20 够干什么?它足够你调用 DeepSeek 等优秀模型,每天和 AI 结对编程 10 次,连续用满一整个月。

  • • 自由与纯粹:支持20+ 主流模型。不限专业,不需要提交任何项目成果,只需 edu 邮箱验证在校身份。

  • • 发放规则:每批 100 人,全年 6 批。经 AI 审核后发放。

第二阶段:深度资助 · 约 60 人

  • • $100 API Token + 1 年云服务器

  • • 条件:用 AI 辅助开发一个 GitHub 项目,拿到 50 star,由我人工评审。

  • • 达到 50 star 我会发一起 1v1 交流,无论评审是否通过。

第三阶段:长期资助 · 3-5 人

  • • $400 API Token

  • • 从第二阶段中选拔,长期沟通,持续指导。

不只是发 Token,我想在这里长出一个社区。拿到算力不知道怎么起步?我们写了一份从零开始的教程(learn.jiezi.ai)。 更重要的是,验证通过的页面会有一个交流群的二维码。我不希望解字计划只是一个分发 Token 的脚本,我希望它能聚拢一群人。里面都是和你一样、想用 AI 折腾点东西的同龄人。卡壳了有人帮你看看报错,跑通了第一个 Demo 有人为你鼓掌。在这个充满不确定性的新浪潮里,找到同路人,有时候比拿到算力更重要。 对于走到第二阶段的同学,我还会提供 1v1 的辅导,动用我身边的资源帮你们对接实习。

一本完全公开的长期账本。

前辈们做教育公益,盖的是看得见摸得着的逸夫楼。今天我们赞助 Token,算力这东西虽然看不见摸不着,但账本必须清清楚楚。 解字计划不是一锤子买卖的噱头。它里面的每一笔预算、花销、收到的赞助,包括规则是怎么定的,全部在 GitHub 上开源。我们会像维护一个优秀的开源项目一样长期运转它,随时接受所有人的查账与监督。


为什么叫解字

「解字」取自《说文解字》。

公元 100 年,许慎把九千多个汉字拆解到最小的构件:部首。从此,任何人只要掌握部首,就能理解任何汉字。

两千年后,语言的最小单位变了,叫 Token。大语言模型将一切文字、代码、推理拆解为 Token 来处理。谁拥有足够的 Token,谁就能让 AI 为自己工作。

《说文解字》让文字不再是贵族的专属。

解字计划要做同样的事:让 Token 不再是大学生的门槛。


怎么申请:

  1. 1. 在 jiezi.ai/apply 填写信息,获取申请码;

  2. 2. 到 GitHub jiezi-ai/grant 提交 Issue,填入申请码;

  3. 3. 查收 edu 邮箱验证邮件,点击验证;

  4. 4. AI 审核通过后,API 的配置信息会自动发送到你的邮箱。

极客彩蛋(Agent Native):整个开源仓库也是一个 AI Agent 能直接读懂和操作的项目。如果你已经是进阶玩家,可以直接打开你的 code agent(如 Claude Code、Cline),对它说一句:

我要申请 https://jiezi.ai

它会自动帮你走完上述流程。


风吹过我,把我从泥潭里拉了出来。

AI 给了我很多。我想让这阵风,也吹到你身上。

阅读原文

跳转微信打开

CLI is All Agents Need — *nix Agent 设计宝典

2026年3月12日 11:55

原创 yan5xu 2026-03-12 11:55 北京

oi! 这真的是我觉得最好的 agent 架构啊啊啊啊啊,真的不要来看看吗!!!

Why a single run(command) outperforms sprawling tool catalogs

当所有人在为 Agent 设计复杂的函数调用框架时,我发现:一个 run(command="...") 就够了。

本文由 AI Agent 协作完成,但每一个设计决策、每一次生产踩坑、以及把它们提炼成原则的思考过程,都是本人完成的。

为什么是 *nix

Unix 在 50 年前做了一个设计决策:一切皆文本流。 程序之间不交换复杂的二进制结构,不共享内存对象——它们通过文本管道沟通。小工具各司其职,通过 | 组合成强大的工作流。程序用 --help 描述自己,用 exit code 报告成败,用 stderr 传递错误上下文。

LLM 在 50 年后做了一个几乎相同的决策:一切皆 token。 它只理解文本,只输出文本。它的"思考"是文本,它的"行动"是文本,它从世界获得的反馈也必须是文本。

这两个决策跨越半个世纪,从完全不同的出发点,收敛到了同一个接口模型。Unix 为人类终端操作者设计的文本系统——cat、grep、pipe、exit code、man page——对 LLM 来说不是"也能用",而是天然适配。LLM 在工具使用这件事上,本质就是一个终端操作者,只不过它比任何人类都快,而且它的训练数据里有大量 shell 命令与 CLI 用例。

这就是 *nix Agent 的核心哲学:不发明新的工具接口,把 Unix 已经验证了 50 年的设计直接交给 LLM。

为什么只有一个 run

单工具假说

主流 Agent 框架给 LLM 一堆独立工具:

tools: [search_web, read_file, write_file, run_code, send_email, ...]

LLM 每次调用前要做工具选择——用哪个?参数怎么填?工具越多,选择越难,准确率越低。认知负荷花在了"选工具"上,而不是"解决问题"上。

我的做法:一个 run(command="..."),所有能力通过 CLI 命令暴露。

run(command="cat notes.md")
run(command="cat log.txt | grep ERROR | wc -l")
run(command="see screenshot.png")
run(command="memory search 'deployment issue'")
run(command="clip sandbox bash 'python3 analyze.py'")

LLM 仍然需要选择"用什么命令",但这和"从 15 个不同 schema 的工具中选一个"是完全不同的认知任务。命令选择是在一个统一的 namespace 里做字符串组合——而函数选择是在多个不相关的 API 间做模式切换。

LLM 的 CLI 母语

为什么 CLI 命令比结构化函数调用更适合 LLM?

因为 LLM 的训练数据里,CLI 是最密集的工具使用范式。GitHub 上数十亿行代码充满了:

# README 里的安装指南
pip install -r requirements.txt && python main.py
# CI/CD 里的构建脚本
make build && make test && make deploy
# Stack Overflow 里的解决方案
cat /var/log/syslog | grep "Out of memory" | tail -20

我不需要教 LLM 如何使用 CLI——它已经会了。这种熟悉度是概率性的、模型相关的,但在主流模型上经验证非常可靠。

对比两种方式完成同一个任务:

任务:读取日志文件,找出错误行数
函数调用方式(3 次 tool call):
  1. read_file(path="/var/log/app.log") → 返回完整文件
  2. search_text(text=<entire file>, pattern="ERROR") → 返回匹配行
  3. count_lines(text=<matched lines>) → 返回数字
CLI 方式(1 次 tool call):
  run(command="cat /var/log/app.log | grep ERROR | wc -l")
  → "42"

一次调用替代三次。不是因为做了特殊优化——而是 Unix 管道天然支持组合。

让管道和链式执行成为可能

光有一个 run 不够。如果 run 只能执行单条命令,LLM 还是要多次调用才能完成组合任务。所以我在命令路由层实现了一个链式解析器(parseChain),支持四种 Unix 操作符:

|   管道:前一个命令的 stdout 作为后一个的 stdin
&&  与链:前一个成功才执行后一个
||  或链:前一个失败才执行后一个
;   顺序:无论前一个成败都执行后一个

有了这个机制,LLM 的每一次 tool call 都可以是一个完整的工作流:

# 一次 tool call:下载 → 查看
curl -sL $URL -o data.csv && cat data.csv | head 5
# 一次 tool call:读文件 → 过滤 → 排序 → 取前 10
cat access.log | grep "500" | sort | head 10
# 一次 tool call:尝试 A,失败则尝试 B
cat config.yaml || echo "config not found, using defaults"

N 个命令 × 4 种操作符,组合空间急剧扩大。而在 LLM 看来,这只是一个字符串——它已经从训练数据里学会了怎么写。

命令行就是 LLM 的母语工具接口。

启发式设计:让 CLI 引导 Agent 顺滑工作

单工具 + CLI 解决了"用什么"的问题,但 Agent 还需要知道 "怎么用"。它没有搜索引擎,没有同事可以问。我通过三个递进的设计手段,让 CLI 自身成为 Agent 的导航系统。

手段一:渐进式 --help 自发现

一个设计良好的 CLI 工具,用户不需要读文档就能上手——因为 --help 告诉了一切。我把同样的理念用在 Agent 身上,并且做成了渐进式披露:Agent 不需要一次加载所有文档,而是按需逐层深入。

第零层:Tool Description → 命令列表注入

run 工具的 description 在每次对话开始时动态生成,列出当前所有已注册命令的一行摘要:

Available commands:
  cat    — Read a text file. For images use 'see'. For binary use 'cat -b'.
  see    — View an image (auto-attaches to vision)
  ls     — List files in current topic
  write  — Write file. Usage: write <path> [content] or stdin
  grep   — Filter lines matching a pattern (supports -i, -v, -c)
  memory — Search or manage memory
  clip   — Operate external environments (sandboxes, services)
  ...

Agent 从第一轮就知道有哪些能力,但不需要知道每个命令的所有参数——那会浪费上下文。

注: 命令列表全量注入 vs 按需发现,随着命令增多这里存在上下文预算的权衡。目前还在探索更优的平衡方式,欢迎讨论。

第一层:command(无参数)→ 命令用法

Agent 对某个命令感兴趣时,直接调用它。没给参数?命令返回自己的用法:

→ run(command="memory")
[error] memory: usage: memory search|recent|store|facts|forget
→ run(command="clip")
  clip list                              — list available clips
  clip <name>                            — show clip details and commands
  clip <name> <command> [args...]         — invoke a command
  clip <name> pull <remote-path> [name]   — pull file from clip to local
  clip <name> push <local-path> <remote>  — push local file to clip

现在 Agent 知道 memory 有五个子命令,clip 可以 list/pull/push。只花了一次调用,没有多余信息。

第二层:command subcommand(缺参数)→ 具体参数

Agent 决定用 memory search,但不确定参数格式?继续深入:

→ run(command="memory search")
[error] memory: usage: memory search <query> [-t topic_id] [-k keyword]
→ run(command="clip sandbox")
  Clip: sandbox
  Commands:
    clip sandbox bash <script>
    clip sandbox read <path>
    clip sandbox write <path>
  File transfer:
    clip sandbox pull <remote-path> [local-name]
    clip sandbox push <local-path> <remote-path>

渐进式披露:概览(注入)→ 用法(探索)→ 参数(深入)。 Agent 按需探索,每一层只获取当前需要的信息量。

这和把所有文档塞进 system prompt 是完全不同的思路。system prompt 里塞 3000 字的工具文档,大部分信息在大部分时候都用不到——白白占用上下文预算。渐进式 help 让 Agent 自己决定什么时候需要更多信息。

这也对命令设计提出了要求:每个命令、每个子命令都必须有完整的 help 输出。 不仅是给人看的,更是给 Agent 看的。一条好的 help 能让 Agent 一步到位,一条缺失的 help 意味着一次盲猜。

手段二:Error Message 纠偏

Agent 不可能永远走对路。关键不是阻止它犯错,而是让每个错误都指向正确方向。

传统 CLI 的错误信息给人看——人可以 Google。Agent 不能 Google。所以我要求每个错误同时包含"出了什么问题"和"该怎么做":

传统 CLI:
  $ cat photo.png
  cat: binary file (standard output)
  → 人会 Google "how to view image in terminal"
我的设计:
  [error] cat: binary image file (182KB). Use: see photo.png
  → Agent 直接调用 see,一步修正

更多例子:

[error] unknown command: foo
Available: cat, ls, see, write, grep, memory, clip, ...
→ Agent 立刻知道有哪些命令
[error] not an image file: data.csv (use cat to read text files)
→ Agent 从 see 切换到 cat
[error] clip "sandbox" not found. Use 'clip list' to see available clips
→ Agent 知道先列出 clips

手段一(help)解决"我能做什么"。手段二(error)解决"做错了怎么办"。两者配合,Agent 的试错成本极低——通常 1-2 步就能找到正确路径。

真实案例:stderr 被丢弃的代价

有段时间,我的代码在调用外部沙箱时,如果 stdout 非空就丢弃 stderr。Agent 运行 pip install pymupdf,exit code 127。stderr 里有 bash: pip: command not found,但 Agent 看不到。它只知道"失败了",不知道"为什么"——于是盲猜了 10 种包管理器:

pip install         → 127  (不存在)
python3 -m pip      → 1    (模块不存在)
uv pip install      → 1    (用法错误)
pip3 install        → 127
sudo apt install    → 127
... 又试了 5 种 ...
uv run --with pymupdf python3 script.py → 0 ✓  (第 10 次)

修复后 stderr 永远可见,Agent 第一次就看到 "pip: command not found",立刻换方向。

stderr 是 Agent 最需要的信息,恰恰在命令失败的时候。永远不要丢弃它。

手段三:Output Format 持续反馈

前两个手段解决了 Agent 的"发现"和"纠错"。第三个让 Agent 在持续执行过程中越来越懂系统。

我在每个 tool result 末尾追加一致的元数据:

file1.txt
file2.txt
dir1/
[exit:0 | 12ms]

LLM 从中提取两个信号:

退出码(Unix 约定,LLM 已掌握):

  • exit:0

     — 成功

  • exit:1

     — 一般错误

  • exit:127

     — 命令不存在

耗时(成本感知):

  • 12ms

     — 廉价操作,可以放心多调

  • 3.2s

     — 中等成本

  • 45s

     — 昂贵操作,需要谨慎

Agent 在对话中看到几十次 [exit:N | Xs] 后,内化了这个模式。它开始预判——看到 exit:1 就知道检查错误,看到耗时很长就减少调用。

一致的输出格式让 Agent 越用越聪明。不一致让每次都像第一次。

三个手段的递进关系:

--help       →  "我能做什么?"       →  主动发现
Error Msg    →  "做错了怎么办?"     →  被动纠偏
Output Fmt   →  "做得怎么样?"       →  持续学习

双层架构:把启发式设计落地的工程

上面讲了 CLI 如何在语义层面引导 Agent。但要真正落地,还需要解决一个工程问题:CLI 执行的原始输出,和 LLM 需要看到的结果,往往不是一回事。

LLM 的两个硬约束

约束 A:上下文窗口有限且昂贵。 每个 token 消耗金钱、注意力、推理速度。一个 10MB 文件全文塞进上下文,不仅浪费,还会把之前的对话挤出窗口——Agent "失忆"。

约束 B:LLM 只能处理文本。 二进制数据经过 tokenizer 产生高熵无意义的 token。它不仅浪费上下文,还会扰乱周围有效 token 的注意力,导致推理质量下降。

这两个约束决定了:命令的原始输出不能直接扔给 LLM——需要一个呈现层做加工。但加工不能影响命令的执行逻辑——否则管道会坏。所以需要分层。

执行层 vs 呈现层

┌─────────────────────────────────┐
│  Layer 2: LLM 呈现层             │  ← 为 LLM 认知约束设计
│  二进制拦截 | 截断+溢出 | 元数据    │
├─────────────────────────────────┤
│  Layer 1: Unix 执行层             │  ← 纯 Unix 语义
│  命令路由 | pipe | chain | exit   │
└─────────────────────────────────┘

当 cat bigfile.txt | grep error | head 10 执行时:

Layer 1 内部:
  cat 输出 → [500KB 原始文本] → grep 输入
  grep 输出 → [匹配的行] → head 输入
  head 输出 → [前 10 行]

如果在 Layer 1 截断 cat 的输出 → grep 只搜到前 200 行,结果不完整。如果在 Layer 1 加 [exit:0] → 它作为文本流入 grep,变成搜索内容。

所以 Layer 1 必须保持原始、无损、无元数据。加工只在 Layer 2 发生——管道链执行完毕,最终结果准备返回给 LLM 时。

Layer 1 服务于 Unix 语义。Layer 2 服务于 LLM 认知。分层不是设计偏好,是逻辑必然。

Layer 2 的四个机制

机制 A:二进制守卫(应对约束 B)

在返回给 LLM 之前,检查内容是否为文本:

检测到 null byte → 二进制
UTF-8 校验失败 → 二进制
控制字符比例 > 10% → 二进制
如果是图片:[error] binary image (182KB). Use: see photo.png
如果是其他:[error] binary file (1.2MB). Use: cat -b file.bin

LLM 永远不会收到它无法处理的数据。

机制 B:溢出模式(应对约束 A)

输出 > 200 行 或 > 50KB?
  → 截断到前 200 行(rune-safe,不切断 UTF-8)
  → 完整输出写入 /tmp/cmd-output/cmd-{n}.txt
  → 返回给 LLM:
    [前 200 行内容]
    --- output truncated (5000 lines, 245.3KB) ---
    Full output: /tmp/cmd-output/cmd-3.txt
    Explore: cat /tmp/cmd-output/cmd-3.txt | grep <pattern>
             cat /tmp/cmd-output/cmd-3.txt | tail 100
    [exit:0 | 1.2s]

关键洞察:LLM 已经知道如何用 grep、head、tail 导航文件。溢出模式把"大数据探索"转化为 LLM 已掌握的技能。

机制 C:元数据脚注

actual output here
[exit:0 | 1.2s]

退出码 + 耗时,追加在 Layer 2 的最后一行。给 Agent 判断成败和感知成本的依据,同时不污染 Layer 1 的管道数据。

机制 D:stderr 附加

命令失败且有 stderr 时:
  output + "\n[stderr] " + stderr
确保 Agent 能看到错误原因,不会盲目重试。

实现:agent-clip 核心代码

以下为简化的伪代码,突出架构骨架。完整实现见源码仓库。

单工具定义

// LLM 只看到一个工具:run(command, stdin?)
// 所有命令及帮助文本列在 description 里
func RunToolDef(commands map[string]string) ToolDef {
    desc := "Execute commands via run(command=\"...\").\n"
    desc += "Supports chaining: cmd1 && cmd2, cmd1 | cmd2.\n\n"
    for name, help := range commands {
        desc += "  " + name + " — " + help + "\n"
    }
    return ToolDef{
        Name: "run",
        Description: desc,
        Parameters: { command: string, stdin?: string },
    }
}

Layer 1:命令路由与管道

// Exec 解析命令链,执行管道,返回原始输出 + 退出码
// 这里是纯 Unix 语义——没有截断,没有元数据,没有二进制检测
func (r *Registry) Exec(command, stdin string) (string, int) {
    segments := parseChain(command)  // 按 &&, ||, |, ; 分割
    for i, seg := range segments {
        if prevOp == OpAnd && lastExitCode != 0 { continue }
        if prevOp == OpOr && lastExitCode == 0  { continue }
        if prevOp == OpPipe { stdin = lastOutput }
        lastOutput, lastExitCode = r.execSingle(seg, stdin)
    }
    return lastOutput, lastExitCode
}
func (r *Registry) execSingle(command, stdin string) (string, int) {
    name, args := tokenize(command)
    handler, ok := r.handlers[name]
    if !ok {
        return "[error] unknown command: " + name + "\nAvailable: ...", 127
    }
    output, err := handler(args, stdin)
    if err != nil {
        return "[error] " + name + ": " + err.Error(), 1
    }
    return output, 0
}

Layer 2:LLM 呈现层

// execToolCall 把 Layer 1 的原始结果加工成 LLM 能理解的格式
// 所有的截断、溢出、元数据包装都在这里发生
func execToolCall(registry *Registry, tc ToolCall) string {
    command, stdin := parseToolCallArgs(tc)
    // Layer 1: 纯执行
    start := time.Now()
    rawOutput, exitCode := registry.Exec(command, stdin)
    duration := time.Since(start)
    metadata := fmt.Sprintf("[exit:%d | %s]", exitCode, duration)
    // 失败时直接返回(execSingle 已加 [error] 前缀 + stderr)
    if exitCode != 0 {
        return rawOutput + "\n" + metadata
    }
    // 截断检查(仅超限时才持久化到 /tmp)
    result := rawOutput
    if tooLarge(rawOutput) {
        truncated := first200LinesRuneSafe(rawOutput)
        file := persistToTmp(rawOutput)
        result = truncated + "\n--- truncated ---\nFull output: " + file
    }
    return result + "\n" + metadata
}

二进制守卫

func fsCat(args []string, stdin string) (string, error) {
    data := readFile(path)
    // 二进制守卫:拦截 LLM 无法处理的数据,引导到正确命令
    if !base64Flag && isBinary(data) {
        if isImage(path) {
            return error("binary image (%s). Use: see %s", size, path)
        }
        return error("binary file (%s). Use: cat -b %s", size, path)
    }
    return string(data), nil
}
func isBinary(data []byte) bool {
    sample := data[:min(8192, len(data))]
    if containsNull(sample)       { return true }  // null byte = 一定是二进制
    if !utf8.Valid(sample)        { return true }  // 非法 UTF-8 = 大概率二进制
    if controlRatio(sample) > 0.1 { return true }  // 控制字符太多
    return false
}

Vision 自动挂载

// Agent 不需要显式请求"看图"——see 返回的 URL 被自动挂载到 vision 通道
func extractImagesFromResult(result string) []ImageData {
    urls := findImageURLs(result)  // 匹配 pinix-data://...png
    for _, url := range urls {
        data := readFile(urlToPath(url))
        images = append(images, ImageData{
            Base64:   base64Encode(data),
            MimeType: detectMIME(url),
        })
    }
    return images  // 附加到下一轮 LLM 调用的 vision 内容
}

Agentic Loop

func RunLoop(config, context, registry, output) {
    // 不设硬性迭代上限。LLM 不调用工具时循环自然结束。
    // 如果 Agent 还在调工具,说明它认为任务没完成——
    // 我通过前面的启发式设计(help / error / output format)
    // 让它更快到达终点,而不是粗暴截断它的执行。
    //
    // 实际安全边界由外部机制保障:沙箱隔离、API 预算、用户取消。
    for {
        response := callLLM(context)
        if response.hasToolCalls() {
            for _, tc := range response.toolCalls {
                result := execToolCall(registry, tc)      // Layer 2 包装
                images := extractImagesFromResult(result)  // vision 挂载
                context.append(toolResult(result, images))
            }
            continue
        }
        // LLM 没有调用工具 = 任务完成
        return response.content
    }
}

经验教训:来自生产的故事

故事 1:一张 PNG 引发的 20 轮崩溃

用户上传了一张架构图。Agent 用 cat 读取,收到 182KB 的 PNG 原始字节。LLM 的 tokenizer 把这些字节变成数千个无意义的 token,塞进上下文。LLM 完全无法理解,开始反复尝试不同的读取方式——每次都返回同样的乱码。20 轮后进程被强制终止。

根因:cat 没有二进制检测,Layer 2 没有拦截。修复:isBinary() 守卫 + 错误引导 Use: see photo.png。教训: Tool result 是 Agent 的眼睛。返回垃圾 = Agent 失明。

故事 2:沉默的 stderr 与 10 次盲猜

Agent 需要读取一个 PDF。它尝试 pip install pymupdf,exit code 127。但 stderr(bash: pip: command not found)被代码丢弃了——因为有一小段 stdout,代码逻辑是"有 stdout 就忽略 stderr"。

Agent 只看到"失败了",不知道"为什么"。接下来是漫长的试错:

pip install         → 127  (不存在)
python3 -m pip      → 1    (模块不存在)
uv pip install      → 1    (用法错误)
pip3 install        → 127
sudo apt install    → 127
... 又试了 5 种 ...
uv run --with pymupdf python3 script.py → 0 ✓

10 次调用,每次 ~5 秒推理。如果第一次 stderr 可见,1 次就够了。

根因:InvokeClip 在有 stdout 时静默丢弃 stderr。修复: 失败时永远附加 stderr。教训: stderr 是 Agent 最需要的信息,恰恰在命令失败的时候。

故事 3:溢出模式的价值

Agent 分析一个 5000 行的日志文件。没有截断时,5000 行全文(~200KB)塞进上下文,LLM 的注意力被淹没,回答质量骤降,还把之前的对话挤出了上下文窗口。

加了溢出模式后:

[前 200 行日志内容]
--- output truncated (5000 lines, 198.5KB) ---
Full output: /tmp/cmd-output/cmd-3.txt
Explore: cat /tmp/cmd-output/cmd-3.txt | grep <pattern>
         cat /tmp/cmd-output/cmd-3.txt | tail 100
[exit:0 | 45ms]

Agent 看到前 200 行,了解了文件结构,然后用 grep 精准定位——总共 3 次调用,上下文占用不到 2KB。

教训: 给 Agent 一个"地图"比给它"全部领土"有效得多。

边界与局限

CLI 不是银弹。以下场景中,typed API 可能是更好的选择:

  • 强类型交互

    :数据库查询、GraphQL API 等需要结构化输入输出的场景,schema 验证比字符串解析更可靠。

  • 高安全要求

    :CLI 的字符串拼接天然带有注入风险。在不可信输入场景中,typed parameters 比命令字符串更安全。agent-clip 通过沙箱隔离来缓解这个问题。

  • 多模态原生

    :纯音视频处理等需要二进制流的场景,CLI 的文本管道是瓶颈。

此外,"不设迭代上限"不意味着没有安全边界。实际安全由外部机制保障:

  • 沙箱隔离

    :命令在 BoxLite 容器内执行,无法逃逸

  • API 预算

    :LLM 调用有账户级别的费用上限

  • 用户取消

    :前端提供取消按钮,后端支持 graceful shutdown

把 Unix 哲学交给执行层,把 LLM 的认知约束交给呈现层,用 help、error message 和 output format 构建三个递进的启发式导航手段。

CLI is all agents need.

以上所有设计在 agent-clip 中均有完整实现。核心代码对应关系:

  • 单工具命令路由 → internal/tools.go

  • 管道与链式执行 → internal/chain.go

  • 双层 agentic loop → internal/loop.go

  • 文件系统与二进制守卫 → internal/fs.go

  • 外部环境调用与 stderr 处理 → internal/clip.go

  • 浏览器自动化与 vision 挂载 → internal/browser.go

  • 语义记忆与向量搜索 → internal/memory.go

Built with Go. Powered by Unix. Designed for LLMs.

阅读原文

跳转微信打开

pinix 东半球第一个专门为 agent 设计的 os

2026年3月10日 22:52

言午 北京

epiral 2.0 来啦,不过重点不是 epiral(🦞),这次是 pinix,大概是东半球第一个专门为 agent 设计的 os hhh

春节在迭代epiral 的时候,撞上一个问题:Agent 只靠 IM 交互,很多场景都有点难受。

比如 todo。让 Agent 管理很顺——它自己调命令,增删改查,清清楚楚。但我自己想看一眼今天的任务呢?纯靠对话去问,怎么都不如一个列表界面来得直接。

于是想通了一件事,Agent 需要命令行,人需要界面,但它们操作的是同一个东西。所以 Agent 时代的 app 就该同时有两个入口。

所以就有了 pinix。上面的应用叫 clip。每个 clip 长这样:底层是一组命令脚本(或者二进制 cli),Agent 直接调;上层是一个 web 页面,人直接用。同一份数据,两种交互方式。

然后有意思的来了:Agent 本身也是一个 clip。

就是你们在用的龙虾——对话、记忆、工具调用、浏览器控制——我把它整个做成了 pinix 上的一个应用。它不是系统的主人,它是系统上跑的一个 app,跟 todo、跟沙盒平级。Agent 通过命令跟其他 clip 交互,装一个新 clip,Agent 就自动多一个新能力。

看图就懂了👇

四个画面,同一个 pinix 节点:

左一:Agent clip——刚帮我批量更新 todo 状态,调的是 clip todo task-update,返回结构化结果自动整理成表格

左二:todo clip——同一批任务,我直接在看板上看,按项目分组,拖拽排优先级。Agent 改的数据,这边实时看到

左三:Clip Dock(桌面端)——所有 clip 的入口,哪些在线一目了然

右一:todo clip 的 iOS 端——同一个 web 页面,手机上直接用

UI 选了 web,跨平台就不用做了——桌面套 WebView,iOS 套 WKWebView,一个下午两端全通。每个 clip 跑在独立微型虚拟机里,安全也是顺手的事。

跳转微信打开

来,你说场景,我帮你设计如何用 Agent 工作

2026年3月6日 12:43

原创 yan5xu 2026-03-06 12:43 北京

这是一套方法论——用它来找出你每天在哪儿当管道、从哪里下刀,以及 Agent 如何把你从这些事里解放出来。

TL;DR:这篇文章分享我自己摸索出来的一套方法论——用它来找出你每天在哪儿当管道、从哪里下刀,以及 Agent 如何把你从这些事里解放出来。看完你可以自己拆自己的工作;如果不想自己分析,评论区告诉我你做什么的,我来帮你描绘有了 Agent 之后的一天。

正文是方法论,想自己学的往下看。懒得分析的,直接评论区告诉我你的工作场景就行。


任何工作都是同一个闭环:调研 → 决策 → 规划 → 执行 → 反馈 → 复盘。

不管你是做运营、做自媒体、做项目管理还是做财务,把工作拆开往这六步里放,一定放得进去。

每一步有它的核心问题:

  • 调研:事实从哪来?数据、信息、现状——你得先知道发生了什么,才能做下一步。

  • 决策:判断依据是什么?这件事值不值得做、怎么分类、优先级怎么排——这是人真正在发挥作用的地方。

  • 规划:下一步怎么走?把决策结果转成可执行的任务和格式。

  • 执行:怎么改变现实?发消息、写数据、调接口、推结果——让事情真正发生。

  • 反馈:做成了吗?验证执行结果,确认到位。

  • 复盘:经验固化成什么?这次做完学到了什么,能不能变成下次自动跑的规则。

少任何一环就不完整——只有调研没有执行是研究报告,只有执行没有反馈是瞎干,没有复盘就永远原地踏步。

这个框架有什么用?它让你一眼看清,你每天的时间到底花在了哪一步。更重要的是,那一步,你到底在做判断,还是在做搬运。


这很关键,因为六步里每一步,都已经有了对应的工具。

工具意味着可编程——CLI 命令、API 调用、浏览器自动化,本质上都是可以被程序调用的接口。这是员工:接收指令、执行、不需要思考。

但光有员工不够。还需要两件事:

经理——理解你的意图,制定计划,决定下一步调哪个工具、怎么调。LLM 就是这个角色。它能读懂你说的话,把工具一步步驱动下去。

章程——把经理的判断固化成文字,让员工照着重复跑。这是代码和脚本的作用:写一次,执行无数次,零边际成本。没有章程,每次都要经理临时指挥,跑一次就停。

层级对应说明
🧠 经理LLM理解意图,制定 SOP,决定下一步干什么
📋 章程代码和脚本写一次,执行无数次,零边际成本
💪 员工工具和设备按 SOP 执行,不思考,只执行

三层接通,临界点就出现了:当六步里的每一步都有了工具,LLM 就能把整条链路串起来,从头到尾自主跑完整个闭环。 不再是「帮你完成某个步骤」,而是整个任务自主执行。这就是 Agent——你的电脑,24 小时开机的数字同事。

三层没接通,LLM 再聪明,也是被关在小黑屋里的经理——看不见外面,也改变不了任何事。


所以设计一个 Agent,本质上就是做一件事:把六步里每一步的工具填具体。

步骤方向具体化的意思
调研自动拉取数据你用的是哪个后台?有没有 API?用什么工具抓?
决策把判断变成规则你的分类标准是什么?边界情况怎么处理?
规划格式和模板结果要输出成什么格式?发到哪里?
执行程序替手操作调哪个接口?操控哪个页面?跑哪条命令?
反馈自动验证结果怎么确认执行到位?出错怎么报警?
复盘纠正写回规则这次的判断偏差,怎么变成下次的自动处理?

这张表填完,就是你这个场景的 Agent 配置文件——Claude Code 读它,知道自己有什么工具、该怎么跑。表没填完,Agent 就跑不完整。

你可以拿这张表,去拆自己的工作——看看六步里,有几步是你在当搬运工,有几步已经有工具可以接管。填满的那一天,就是你的 Agent 上线的那一天。


填表的时候,从哪里下手?

目标很简单:先让自己真实体验到用 Agent 的爽感。 有了这个感受,才会有动力把剩下的步骤也接进来。

方法是识别意愿瓶颈——那个每天让你心里发堵、让你拖延的步骤。不一定耗时最长,但它卡在最前面,让你迟迟不想启动。

比如做运营的,每天第一件事是登后台导数据。登后台、找菜单、点导出——也许只要 3 分钟,但它每天都在前面堵着。

先把这一步接进 Agent。第一个早上打开电脑,数据已经在那里了——这一刻,你会真实感受到用 Agent 是什么感觉。不是「效率提升了」,是「这件事消失了」。

有了这个感受,你自然会想:还有哪步也可以消失掉?然后一步步往下改。调研自动跑、执行自动发、反馈自动收——最后留下来的,只有真正需要你判断的那几个时刻。你是阀门,不是管道。

下面两个案例,一个从意愿瓶颈下手,一个从耗时最长的步骤下手。同样的框架,不同的切入点。


如果你想直接上手,我做了一个开源工具 Rewire——你描述工作场景,它帮你把这张表格自动填具体:追问细节、搜工具、给出能直接跑的方案。下面两个案例就是用它跑出来的。


案例一 · 运营 · 用户反馈分类

之前:每天从后台导出反馈 Excel,逐条阅读、打标签、整理成分组表格发飞书群。50-80 条,2-3 小时。六步里,真正需要判断的只有「这条反馈是 Bug 还是需求」这一步决策,其余全是纯人肉搬运。最烦的是一开始那步——登后台、找菜单、等下载,还没开始做正事就已经没了心气。

怎么改造的:Claude Code 用 bb-browser 操控你本地浏览器——复用已有的登录态,不需要额外配密码——直接打开后台,找到导出按钮,点击,30 秒下载完成。然后用 Python 读 Excel,按你预先写好的规则分类:「崩溃」「报错」「闪退」归 Bug,「希望」「建议」「能不能」归需求,「怎么用」「在哪里」归咨询。90% 直接分好。剩下拿不准的,弹出来问你,你回一句,它继续。最后用 curl 调飞书 Webhook 把结果推进群。

改造后:早上到工位,打开飞书,反馈已经分好类发在群里了。你的待办只有 5-8 条标了"不确定"的,点开扫一眼,3 分钟搞定。剩下的时间去看最近反馈里有没有反复出现的模式——比如上周 12 条都提到"支付超时"。这才是运营该做的事。

2-3 小时 → 5 分钟。


案例二 · 自媒体 · 选题调研

之前:每天刷小红书、抖音、微博、知乎,来回切四个 App,3-4 小时。95% 是噪音,刷着刷着就走神了。真正产生价值的判断可能只有 15 分钟,剩下的时间在做人脑搜索引擎。

怎么改造的:Claude Code 调 RSSHub 拉取你关注的对标账号最近 24 小时更新,同时跑 MediaCrawler(44.9k stars,支持小红书/抖音/微博/知乎多平台)用关键词搜一轮最新热门内容。两分钟抓到约 200 条,再按领域相关性、互动数据、时效性过滤,剩 15 条候选。每条附上来源、核心数据、建议角度。你选完方向,它展开评论区分析,给你一份大纲草稿,同时把今天的候选和最终选择写入 Notion 选题库。

改造后:泡咖啡的时间里四个平台已经过了一遍。你端着咖啡回来,15 条候选摆在屏幕上,每条带数据和角度建议。5 分钟选方向,开始写。下午不用刷平台了。

每天省下的不只是 3 小时,是 3 小时的注意力损耗。


完整方案在 GitHub 的 examples/ 目录。


评论区告诉我你是做什么的——你的岗位、你每天最费劲的那块。我来帮你描绘那个画面:有了 Agent 之后,你的早上会怎么开始,哪些事情机器在跑,你在做什么。

阅读原文

跳转微信打开

OpenClaw 登顶 GitHub 榜首,Web 3.0* 已经到来

2026年3月5日 00:39

原创 yan5xu 2026-03-05 00:39 北京

多年以后,人们回望 2026 年,会猛然发现:当一个名叫 OpenClaw 的开源项目,以 258,000 个 GitHub Stars 碾过 Vercel 的 Next.js 登顶历史总榜第一的那个瞬间,正是整个 Web 世界从 2.0 转向 3.0* 的分水岭。

但此刻,绝大多数人还没意识到这件事意味着什么。

Next.js 代表的是什么?云端渲染、中心化分发、平台即服务——Web 2.0 前端基础设施二十年来的绝对王者。而 OpenClaw 呢?一个完全跑在你本地硬盘上的个人 AI Agent 中枢。它的核心配置文件——决定 Agent 性格的 SOUL.md、存储记忆的 MEMORY.md、规划任务的 HEARTBEAT.md——全部是几 KB 的纯文本。没有云端微服务,没有花里胡哨的控制台,你用记事本就能打开并重塑你 AI 助手的灵魂。

王座从一个云端框架,转移到一个本地 Agent 架构。这不是开源社区内部的排名游戏,这是整个 Web 世界的主导权正在换手。

不妨问自己一个问题:如果今天有一股不可抗力,强行卸载了你手机里的微信、飞书和 Gmail,你还能不能正常地联络同事、找出昨天确定的会议纪要,甚至仅仅是证明你在这个世界上留下的社交痕迹?

大概率绝对不能。

你的社交图谱被锁在腾讯的数据库底层;你的工作上下文被切碎,散落在十几个 SaaS 工具的云端抽屉里;你的消费偏好被各大平台的推荐算法暗箱藏匿,打包卖给广告主。我们每天产生数以 GB 计的数据,但几乎从来没有真正“拥有”过哪怕 1 KB 属于自己的数字记忆。

我们看起来在自由地使用互联网,实际上更像是在超级平台的地盘上卑微地租住。交出隐私当租金,随时防备地主涨价、改规则、甚至扫地出门。

而这套运行了近二十年、看似坚不可摧的“租住秩序”,现在终于在底层物理架构的剧烈冲撞下,出现了不可逆转的结构性崩塌。OpenClaw 的登顶,正是地表上露出的第一道裂缝。

§0 引子:系统架构的主导权正在发生位移

历史的每一次伟大演进,在它发生的前夜,都会在系统最底层的角落里亮起微弱的信号灯。如果你把过去六个月发生在底层技术栈的几个切片叠在一起看,一幅极其清晰的图像会突然在你面前浮现。

现象一:普通人拥有超级 Personal AI 的巨大机会

回到开场的那个结论,为什么一个配置局域网和 Docker 极其繁琐的开源项目,能让全球开发者趋之若鹜?

因为这不只是一种对中心化 SaaS 平台出事的被动防守,更是一个极其诱人的机会:它让普通人第一次有可能在本地跑起一个极度强大的 Personal AI。

“在 OpenClaw 的架构中,用户的配置文件、记忆数据库(基于 SQLite)全部以纯文本的 Markdown 形式保存在本地。这是一种冷酷的权力宣示:系统的大脑完全向你敞开。” —— 摘自知乎开发者社区对 OpenClaw 架构的解析

这种级别的私人助理,要真正发挥威力,必须深度掌握你极度隐私的个人上下文。这里的隐私,不是指你的银行卡密码,而是你在这个世界上真实存在的颗粒度——你写周报时固定的排版强迫症、你对某个客户的隐性反感、甚至你每次出差一定要住带大窗户酒店的怪癖。只有掌握了这些,它才是“你的”Agent,才能替你做出符合你心意的决策。

你敢把这些代表你灵魂的数据交给一个随时可能修改隐私条款的贪婪平台吗?显然不敢。所以,这种强大的 Personal AI 注定了它只能存在于本地硬盘。哪怕它现在还很粗糙,极客们也宁可把它握在自己手里。

现象二:Web 不再只为人类服务,互联网接口开始转向

2026 年初,Chrome 悄然发布了一份由 Google 与 Microsoft 联手向 W3C 推进的 WebMCP(Web Model Context Protocol)标准草案。紧接着,网络基建巨头 Cloudflare 推出了面向 AI Agent 的 HTTP Header——只要 Agent 发送一个 Accept: text/markdown 的请求头,Cloudflare 就会把原本花里胡哨的网页,瞬间扒掉广告、CSS 和冗余的导航,只吐出干干净净的 Markdown 文本供机器阅读。

这意味着什么?这意味着网站不再仅仅是为了“留住人类的眼球、展示华丽的广告”而设计。互联网正在主动抛弃过去那一套逻辑,Web 不再只为人类服务,它正在转向,同时为 Agent 提供最高速度、最强可靠性的结构化接口。

现象三:资本的冷酷投票,SaaS 的黄昏与 HALO 效应

如果说极客的狂欢和标准草案还显得有些遥远,那么华尔街资金的疯狂出逃,则是最能刺痛神经的现实。2026 年初,被称为“SaaS-pocalypse(SaaS 末日)”的风暴席卷纳斯达克。Salesforce、Adobe、ServiceNow 等 SaaS 巨头的股价遭遇断崖式下挫。

为什么会崩盘?因为 Agent 正在粉碎 SaaS 赖以生存的商业地基。SaaS 公司最核心的暴利模式是“不管你用不用,按人头强行收系统席位费(Seat)”。当 Agent 开始海量替代数据录入、客服和 IT 运维等人力岗位时,没人买席位了,它当然会崩。

与此同时,高盛抛出了一个震动市场的理论:HALO(Heavy Assets, Low Obsolescence / 重资产,低过时风险)。资本正疯狂逃离那些靠“把用户关起来”盈利的轻资产软件股,转而拥抱能源、电力和底层算力基建。

把这三个现象严丝合缝地扣在一起,结论已经震耳欲聋:互联网系统架构的主导权,正在发生一次史诗级的物理位移——从高高在上的“平台中心”,无可挽回地迁往无数个边缘的“个人 Agent”。

Web 3.0* 论证全景思维导图

本文把这个正在发生的新范式叫做 Web 3.0*。这里的星号是故意加上的,它极其重要。(顺便提一句,这与币圈大肆炒作、至今并未实质性发生的 Blockchain Web3 毫无关系)。我们现在讨论的这一套,不靠发币,不炒作空气,它只关心一个极其硬核的工程演进——当个人专属的 Agent 拿到了足够密集的全局上下文,并获得了不受平台限制的跨域执行能力,整个互联网的权力拓扑结构,将会怎样被彻底重排?

§1 历史的轮回:谁创造了效率,谁就拥有主导权

我们不妨回顾一下历史。要真正看懂这场颠覆,我们需要回到互联网最底层的物理定律去寻找答案。

互联网从诞生至今,每一次代际的切换,表面上看是雅虎倒下、谷歌崛起,是 PC 时代的落幕、移动大厂的上桌。但本质上,每一次王权的更替,都在解答同一个母题:“在当时的物理和硬件约束下,谁能最有效率地解决问题?” 谁能提供最高的效率,算力和数据就会自然地向谁流动,谁就拥有那一代 Web 的主导权。

§1.1 Web 1.0:信息可访问,能力不可执行(主导方:发布者)

时钟拨回上世纪 90 年代。那是一个只要 56k 调制解调器拨号时发出刺耳的握手声,就能让网民心潮澎湃的年代。

当时的物理现实极其严苛:服务器带宽昂贵,个人电脑性能孱弱。在那个年代,马云还在杭州街头挨家挨户推销“中国黄页”,试图把中国企业的资料翻译成英文放到网上,却常常被当成骗子。而“黄页”这两个字,恰恰是 Web 1.0 模式最精准的缩影。

受限于当时的约束,互联网只能妥协成一种高度不对称的模式。站长在昂贵的服务器端搭建静态内容,用户在简陋的终端点开网页浏览。你上网不是去“创造”,你仅仅是去“访问”。

“在 Web 1.0 时代,系统就像一个巨大的广播站,而我们每个人都只是握着收音机的听众。”

这是 Web 1.0 的伟大之处——信息流动第一次打破了地理边界,让普通人拥有了俯瞰世界的可能。

但这伟大的代价是:用户如同被锁在巨大图书馆里、被绑住双手的读者,几乎没有任何“行动能力”。你看见了屏幕上的数据,不代表你能把它带走。在这个时代,系统效率的果实归属于内容发布方(如早期的雅虎、新浪门户),他们是主导者。

§1.2 Web 2.0:交互爆发,平台成为中枢(主导方:中心平台)

到了 2005 年前后,AJAX 技术的成熟让网页局部刷新成为可能;同时,摩尔定律的狂飙让服务器算力变得廉价。物理约束一旦解除,Web 2.0 时代轰轰烈烈地开启了。

Web 2.0 的本质,是用中心化的算力,解决人类在海量信息中“供需匹配”的效率难题。你需要打车,滴滴用算法把司机和你匹配;你需要沟通,微信把庞大的通讯录映射为实时的社交图谱。互联网从一个静态的图书馆,变成了一个高频交互的社会系统。

这套被称为“数据飞轮”的机制极其伟大,但它也极其昂贵。昂贵的不只是大厂机房里的电费账单,更是十多亿用户被迫付出的代价:

为了维持这种中心化的匹配效率,平台开始建立起高耸入云的围墙花园。更恶劣的是,平台利用这种数据隔离开始作恶。它们不仅把你的社交关系锁死在自己的系统里,还偷偷收集你在其他场景的隐私信息。比如,你在购物软件里刚搜了一双鞋,转头打开另一个资讯 App,满屏都是鞋的广告。你的隐私被暗箱打包,变成了平台在华尔街换取高估值的筹码。

在这个时代,用户逐渐异化成了游走在各个 App 之间的“肉体 API”——你要把这段文本从微信的聊天记录里复制出来,切换应用粘贴到飞书的文档里,再转头去淘宝对比价格,最后人肉敲进公司的 ERP 系统。

所以,Web 2.0 最大的历史功绩与最恶劣的历史罪名,其实根本就是同一件事:它用极高的效率把整个世界连接了起来,同时又用同一套机制把所有连接的定价权和果实,死死地集中在自己手里。

§1.3 Web 3.0*:执行与编排回归本地(主导方:个人 Agent)

天下大势,合久必分。正如我们前面提到的那个至关重要的转折——Web 不再只为人类服务。当互联网的接口开始向机器敞开大门,当 AI 拥有了理解复杂意图和逻辑推理的能力,数字世界的主导权终于开始向边缘的普通人回迁。

如果说 Web 2.0 是“全人类的互联网”,那么 Web 3.0* 就是“人与 Agent 共同驱动的互联网”。它绝不是让你在手机里多安装一个套壳的聊天 App,它是整个互联网“执行位置”的历史性翻转。

很多人对 Chatbot(聊天机器人)和 Agent(智能体)的区别缺乏体感。我们不妨用一个“规划北京出差”的场景来做个对比。

如果你对一个纯粹的 Chatbot 说:“帮我规划下周去北京出差的行程。”它会像一个不知疲倦的打字机,一秒钟给你吐出一篇精美的攻略,甚至贴心地为你算出了预算。这叫“优雅的盲目生成”。但如果你真按这个去走,你大概率会崩溃:它根本不知道你的目标客户这周已经搬到了另一个区,它的预算也只是一个荒谬的统计学数字。Chatbot 只是在复刻一个看起来像答案的虚假文本。

但如果你把任务交给一个真正的个人 Agent,情况完全不同。它会启动一个严密的 Think -> Act -> Observe(思考-行动-观察)循环。

  • 它会去调取你微信里和客户确认好的最新会议地址;

  • 它会去查看飞书日历上老板有没有强行加塞的视频会议;

  • 甚至它知道你曾在小红书上点赞过“酒店必须有大窗户”,从而在携程接口里自动加上这个过滤条件。

看明白了吗?Agent 的本质不是“更聪明的聊天框”,它是“你和异构系统之间的专属中间执行层”。

Web 代际演进路线图:从发布者到平台再到个人 Agent

一旦这个强大的中间层稳固地扎根在你的本地设备上,传统的超级平台就从“你必须交出灵魂才能进入的主场”,被降维成了“用完即走、随时可替换的能力供应商”。互联网剥削了二十年的效率果实,终于要重新落回用户自己的口袋。

但问题来了,这一切听起来很美好,为什么偏偏是在今天发生?这就不得不提到底层算力结构正在经历的一场隐秘而剧烈的化学反应。

§2 深层因果:当廉价的“智能”点燃沉睡的“算力”

我们不喊任何宏大的口号,只谈冷冰冰的因果物理。为什么打破平台坚冰的,偏偏是现在的 2026 年?

在展开讨论之前,我们需要澄清科技行业一个最容易混为一谈的底层概念。如果不把它切开,所有的讨论都会沦为“手机电池那么小,怎么可能跑得动千亿大模型颠覆互联网”的无意义口水战。

我们必须冷酷地把一直以来被统称为“算力”的系统能力,劈成截然不同的两半:一是执行命令的机器算力(Compute),二是理解意图的系统智能(Intelligence)。

  • 算力(Compute):

     这是执行一行 Python 脚本、查询本地 SQLite 数据库、调用 API 接口的“肌肉力量”。这种力量极其廉价,你手边的 Mac Mini,哪怕是一台三年前的旧手机,今天都能在端侧完美跑满。但它的致命弱点是“没有脑子”。

  • 智能(Intelligence):

     这是理解复杂意图、规划任务步骤、拆解并编写逻辑代码的“大脑”。过去,机器没有智能。这种智能完全依赖于人类,尤其是那些年薪百万的高级软件工程师。

“过去,智能极其昂贵,而算力虽然廉价却需要智能去驱动。大厂垄断了人类工程师(智能),也就垄断了为你分配机器执行力(算力)的权力。”

§2.1 智能的平民化:释放被垄断的算力

过去,要让机器替你自动回复邮件、跨表格比对数据,你需要懂 Python,懂如何调用 API,懂各种乱七八糟的鉴权协议。因为这个极高的门槛,海量充沛的本地电脑算力一直处于沉睡状态。普通人只能被动地使用大厂封装好的罐头软件和平台。

大厂们雇佣了最昂贵的人类大脑,提供着原始的“智能”,写成代码封装成平台和 SaaS。然后,他们要么按人头强行收你的席位费,要么通过更隐蔽的方式——榨取你的隐私和免费创作(UGC)——来让你为这套“智能”买单。

但今天,大语言模型带来的最大颠覆,并不是它能写出多漂亮的诗,而是它把“智能”彻底廉价化、平民化了。正如 Notion 创始人 Ivan Zhao 所说,AI 带来了“无限的心智(Infinite minds)”。

这就是 OpenClaw 为什么让整个极客圈感到震撼的根本原因。在这个框架里,大模型(廉价的智能)在后台疯狂“思考(Think)”,自动生成代码,去点燃本地极其廉价的工具(算力)。

"智能点燃算力"因果链:LLM 如何激活本地算力并瓦解平台垄断

大模型把普通人变成了高级工程师,从而彻底激活了原本被大厂垄断的本地算力。 当廉价的智能点燃了免费的算力,普通人就相当于拥有了一个不知疲倦的数字劳工。这种化学反应一旦发生,过去必须依赖大厂集中处理的任务,瞬间就能在你的本地笔记本上闭环。

§2.2 复杂度的蒸发:当并发数降为 1

很多人带着崇拜的目光仰视大厂,误以为 Web 2.0 的架构之所以极其复杂、需要年薪百万的架构师来设计,是因为它的业务逻辑深不可测。这是一场巨大的错觉。

Web 2.0 那些令人窒息的复杂架构,本质上是为“服务百万并发”的商业模式买单,而不是为了完成你个人的任务。

举个最日常的自动化任务例子:从收件箱里提取客户需求,并自动汇总到你的任务表里。

如果由跑在你本地的 Agent 来做,这只不过是一个极低负载的本地后台脚本。读取本地缓存,写入本地数据库,几毫秒就能静悄悄地完成,完全不需要什么高深架构。

但在 Web 2.0 时代,如果你把这个任务交给云端的自动化 SaaS 平台,当一百万个用户同时在周一早晨触发类似任务时,这就变成了工程学噩梦。为了对抗这个因为“集中处理”而产生的洪峰,大厂被迫堆砌了庞大的消息队列(如 Kafka)、昂贵的负载均衡器、微服务集群,以及烧脑的分布式事务锁。

这整套动辄几万台服务器、几十亿电费的庞然大物,统统是在为“百万个你同时存在”时的系统生存危机买单。

现在,把视线拉回 Web 3.0* 的 Agent 架构。当 Agent 在你的本地设备上,只全心全意服务你这一个人时,底层拓扑结构发生了地动山摇的翻转:

  • 并发数永远逼近绝对的 1

    ,你再也不需要任何硬件负载均衡器。

  • 单用户的任务流水线

    ,那些炫技般的高并发框架直接下岗。

  • 核心数据就安安静静存一份在本地 SQLite

    ,让人掉头发的分布式数据一致性难题、CAP 定理,直接从物理学意义上彻底消失。

当计算回到边缘,那层压在头顶的巨大架构复杂度,其商业价值直接清零。

§2.3 异构性从 Bug 变 Feature:物理引擎级的理解力

在 Web 2.0 时代,系统最大的敌人叫“异构性”(Heterogeneity)。你的系统用 XML,他的系统用 GraphQL,没有统一的标准就无法对话。大厂对抗异构性的唯一解法是暴力强拆:“消灭差异,强制标准化”。平台制定霸道的统一 API,逼迫所有人遵守。

而在 Web 3.0* 的 Agent 路线里,异构性不再是让人头疼的 Bug。因为“无限的心智”赋予了 Agent 强大的原生理解力。

这就好比神作《塞尔达传说:旷野之息》里的物理引擎。在海拉鲁大陆,你不需要一个专门设定的“点火按钮”。你把木柴扔在地上,用金属剑用力劈砍燧石,火自然就烧起来了。这就是底层理解力带来的化学反应。

Agent 面对千奇百怪的互联网接口也是一样。A 服务用 REST,B 服务用表单,没关系。只要你的服务是“自描述”的(比如提供了一份简单的 SKILL.md,或者像前文提到的 Cloudflare 那样吐出纯净的 Markdown),Agent 的大脑就能像看说明书一样,瞬间读懂并精准调用它。

我们再也不需要低三下四地求着 SaaS 厂商的 PM 去排期开发一个集成插件。Agent 靠着自己的理解力,随时能用手里的木柴加燧石,生出一团火。

§3 结构性张力:平台自杀悖论与围墙的倒塌

Agent 要想真的聪明、真的懂你,天生就需要跨域的“全局上下文”。回到前面“规划北京出差”的例子,你的私人 Agent 必须能够同时去微信里抓会议地址,去飞书里对齐日程,甚至去小红书里翻你曾经点赞过的酒店。

但这恰恰触碰了巨头们最敏感的逆鳞——数据。在 Web 2.0 的逻辑里,把你死死锁在围墙花园里,用你的数据训练他们自己的模型,再用流量卖广告,是他们生存的唯一命脉。

当代表用户利益的 Agent,撞上死守垄断利益的平台,一场残酷的绞杀开始了。

平台围墙花园 vs Agent 开放架构对比

§3.1 平台的自杀悖论:为了护城河,干掉生态

为了防止自己的数据被 AI 公司免费“白嫖”,平台开始陷入一种疯狂的自杀悖论:它们不惜亲手毁掉曾经为它们带来繁荣的第三方开发者生态。

Reddit 的 API 危机是这场悖论最血腥的注脚。2023 年 6 月,Reddit 突然悍然调整 API 定价,给广受欢迎的第三方客户端 Apollo 开出了约 2000 万美元一年的荒谬账单。这直接逼死了这家用心做了多年的开发者。面对超过 8000 个子版块同时发起的“大停电”抗议,Reddit 的 CEO 不仅寸步不让,反而将抗议的版主嘲讽为“地主贵族”,强行镇压了社区。

为什么这么硬气?因为只要护住这些语料库,Reddit 就能转头拿着它们与 Google 签下 6000 万美元的 AI 训练大单,并在华尔街敲响上市的钟声。这是踩在开发者尸体上的狂欢。

“在绝对的垄断利益面前,十几年的开发者忠诚连个标点符号都不如。”

平台自杀悖论时间线:巨头为保护数据垄断而毁掉第三方生态

Twitter 的做法则更加暴戾,连一封官方邮件都没有,一夜之间关闭免费 API,让运营了十几年的第三方应用瞬间暴毙。在旧时代的既得利益者眼中,只要数据还在他们手里,你就永远是个待宰的羔羊。

§3.2 强拆高墙:从 DMA 监管到中国市场的“绞肉机”

面对高耸入云的围墙,破局的锤子从两个方向砸了下来。

一个是自上而下的监管。欧盟的《数字市场法案》(DMA)明确要求被定义为“看门人”的巨头开放数据可携权,甚至强制 WhatsApp 允许第三方通信协议接入。

但在中国这个超级 App 渗透极深、支付和社交高度耦合的独特市场里,诞生了另一种更野蛮、更硬核的暴力破局法。

由于国内大厂之间有着长达十年的互封历史(回想一下曾经荒谬绝伦的“淘口令”乱码),这里的接口比世界上任何地方都封闭。于是,以字节跳动的“豆包手机”(其系统团队的前身正是那支对系统级交互有着极致追求的锤子/坚果团队)为代表的硬件厂商,给出了一种“掀桌子”的解法:GUI Agent。

当微信或淘宝以安全为由拒绝提供 API 时,豆包手机底层的系统级 Agent 直接通过“读屏(视觉理解)+ 模拟点击”,像一个隐形的透明人一样,跨越 App 的边界强行完成任务。

它不需要求着平台开放接口,它直接在操作系统层面,把那些不可一世的超级 App 降级成了一个个没有灵魂的被执行器。这正是中国市场特有的“绞肉机”生态:巨头建墙,监管拆墙,而端侧的 Agent 直接暴力翻墙。

§3.3 SaaS 的降级:从“超级工作台”到“可插拔组件”

在这场冲击中,企业级 SaaS 的角色将被彻底重塑。

过去,SaaS 厂商最喜欢讲的故事叫“All-in-One”。他们希望你把所有的工作流都搬进他们的系统里,把你关在一个叫“超级工作台”的精美笼子里。

但当 Agent 成为你的私人执行中枢后,你不再需要去适应 SaaS 复杂的交互界面。你需要 Salesforce 仅仅是因为它那里存着客户名单,你需要 Workday 仅仅是为了提一个假单。SaaS 被迫从“把用户死死关在里面的超级容器”,屈辱地降级退化成了 Agent 工作流里“可随意调用的底层组件”。

§4 我们该做什么:不要等终局,先建护栏

这场浩大的范式转移不会在一夜之间完成。“全自动驾驶”的 AI Agent 时代距离我们还有段距离,但在风暴来临前,有些事情你今天就必须开始做。

§4.1 注意力经济的黄昏

当帮你买票、挑酒店、对比商品参数的是一个冷酷的 Agent 时,Web 2.0 时代最依赖的“注意力广告”将彻底失效。

Agent 没有荷尔蒙,不会因为弹出了一个美女广告就冲动消费,它只会冷酷地对比几十个接口的参数并锁单。这就意味着,未来商业的计费模式,将从“你骗了多少用户的眼球”,转向“你能否给 Agent 提供最精准、最便宜的结构化意图”。传统曝光广告的 ROI 正在面临结构性的雪崩。

§4.2 个人与组织的新技能树

如果非要给在这个时代感到焦虑的人,一个最不讲情面的生存建议,我会写成这样一句朴素的话:

未来三到五年,无论个人还是组织,决定你生死存亡的核心竞争力,不再是你“拥有多少个花里胡哨的 SaaS 账号”,而是你“拥有多么强悍的跨域任务编排能力”。

工具只会越来越泛滥,模型(智能)只会越来越廉价。真正拉开巨大鸿沟的,是谁能把杂乱无章的工具,用自己的 Agent 拼接成一条极度稳定、可复用的自动化流水线。

§4.3 把这三条红线死死握在手里

在享受 Agent 带来的狂暴效率复利之前,请务必先建立这三条不可妥协的护栏:

  • 权限最小化

    :绝不给 Agent 泛范围的通行证,只给最低必要权限。

  • 审计日志留存

    :它调用的每一个接口、做的每一次决策,必须有防篡改的本地追踪日志。

  • 一键撤销与迁移

    :你必须拥有物理级别的紧急制动按钮,不仅能一键切断它的行为,还能把所有配置和记忆完整导出。

没有这三条护栏,所谓的高效 Agent,不过是挂在你脖子上的新核弹。

§5 结语:不可逆的列车

让我们回到最初的那个判断:这场正在发生的变革,核心是一次主导权的回归。

它让互联网重新回到服务于“人”的轨道上,而不是让人去适应平台的规则。当沉睡在你本地设备的充沛算力被平民化的大模型唤醒,当冷冰冰的机器获得了物理引擎般的理解力,并发洪峰和异构壁垒就不再是困住你的高墙。

不要再等那个“完美替代一切”的终局了。如果你今天就想拿到这张新世界的船票,不必好高骛远:把你每天重复的高频任务写成 Agent 能跑的自动化流程;把你最重要的核心数据,从平台的抽屉里抽出来,变成可以随时打包带走的本地文件。

这就像是一列在暗夜中启动的列车,虽然我们还不知道终点站的具体名字,但它已经碾碎了 SaaS 报表的遮羞布,撞破了平台 API 筑起的高墙。这列火车,绝无可能倒回去了。

附录:一些我还没完全想明白的事情

写到这里,整个逻辑似乎已经闭环。但我必须诚实地暴露,在这个新范式的演进中,依然有几个让我感到极其棘手、尚未想明白的黑洞:

  1. 大众的隐私惰性

    :千万不要用极客的硬核精神去揣度所有人。历史反复证明,只要平台给予足够无脑的便利,绝大多数人会笑嘻嘻地按下那个绿色的“同意”按钮,双手奉上自己的数据主权。这种人性的重力,Agent 真的能对抗吗?

  2. 商业闭环的终极形态

    :如果 Agent 真的无情消灭了注意力广告,打穿了 SaaS 的人头席位费,那么那些开发出顶级 Agent 框架和高质量底层基础设施的团队,到底靠什么活下去?目前我依然没有看到一个能说服我的商业模式。

  3. 非结构化数据的治理深渊

    :没有了大厂几万人维护的数据清洗流水线,仅仅依靠 Agent 在本地处理我们日常产生的那堆杂乱无章的脏数据,体验会不会随时崩溃?

这些未解的难题,可能不会推翻拓扑换轨的方向,但绝对会无情地拖拽着它到来的速度。

阅读原文

跳转微信打开

掌握 AI coding,享受倍速人生-Agent 工程师,是怎么用 AI 写代码的

2026年2月10日 17:42

原创 yan5xu 2026-02-10 17:42 北京

懒得配图,时间宝贵,把注意力放在重要的事情上吧;与其取悦人类,不如取悦 agent

我的工作是做 AI Agent 研发。日常就是跟 agent 的能力边界打交道 — 它能做什么、不能做什么、怎么让它做得更好。

2024 年 5 月,Claude 3.5 还没出来的时候,我就开始用 GPT-4 + Dify 自己搭 workflow 写代码了。后来从 Cline 到 Claude Code 再到 OpenCode,一路用过来。我几乎不自己手写代码 — 不是用 AI 做补全,而是完全交给 agent 来写。不是写 demo、不是跑 benchmark,是真的用它来写生产代码、改 bug、做重构、提 PR。

从 Dify workflow 到现在的 AI coding agent,用了一年多。我发现最大的坑不是模型不够聪明,而是它记不住事。

上下文是 agent 的命脉

做 agent 研发的人都知道,上下文管理是 agent 系统里最核心的问题之一。没有上下文,再强的模型也是无根之木。

AI coding agent 也一样。一个复杂功能做到一半,对话已经很长了。第二天开新会话 — 它什么都不记得。你得重新描述背景、重新解释决策、重新踩一遍昨天已经趟过的坑。

更糟糕的是 compress。大部分工具在上下文快满时会自动"压缩"对话历史。作为做 agent 的人,我太清楚这意味着什么 — 这是不可控的有损压缩。关键的设计决策、踩过的坑、中间推理链条,压缩之后大概率丢失。然后 agent 开始重复犯已经解决过的错误。

这个问题我做 agent 的时候就在解决。现在发现,用 agent 写代码时,同样的问题又出现了。

所以我用了做 agent 的思路来解决它

做 agent 系统时,我们怎么处理这些问题?

  • 上下文不够?结构化存储 + 按需加载,关键节点保存状态,下次精确恢复。

  • 单个 agent 能力有限?多 agent 协作,主 agent 编排,sub-agent 执行,通过外部存储传递信息。

  • 并发冲突?隔离执行环境,每个任务独立空间,互不干扰。

同样的思路,一一对应到 AI coding agent 上:

HANDOFF 替代 compress — 解决上下文丢失。

在上下文还充足的时候,主动让 agent 写一份结构化的交接文档 — 已经完成了什么、正在做什么、下一步做什么、有什么坑要注意。然后开新会话,agent 读取 HANDOFF,直接恢复上下文继续工作。

这不是模糊的"摘要",而是精确的状态快照。信息密度远高于 compress 后的残留。

如果 compress 已经触发了也不慌 — 回退到压缩之前的状态,执行一次 HANDOFF,再开新会话恢复。几乎不会出现上下文丢失。

一个复杂功能做三天,每天换会话,每次 agent 都能从交接文档里精确恢复到昨天的状态。和人类团队的交接逻辑一模一样。

Sub-Agent 拓展上下文窗口 — 单个 agent 做不完的事,拆给多个做。

单个 agent 的上下文是固定的。所有工作都塞在一个对话里 — 分析代码、写方案、改文件、跑测试 — 上下文很快就满了。

Sub-Agent 的思路是:主 agent 只做规划和决策,具体的重活委托给 sub-agent,结果通过 workspace 文件传回来。主 agent 收到的只是 4 行摘要,但实际完成的工作量可以很大。本质上是用文件系统做信息中转,把单个上下文窗口扩容成了多个。

Worktree 隔离并发 — 多个任务同时进行,互不干扰。

每个任务在独立的 git worktree 中开发。主仓库始终干净,多个 agent 或多个任务可以并行,不会互相污染代码。做完清理 worktree 就行。

这三个方案加在一起:HANDOFF 解决时间轴上的连续性,Sub-Agent 解决单次会话的容量限制,Worktree 解决并发隔离。都是做 agent 系统时的标准思路。

另一个做 agent 的人才会注意到的问题

我的项目有多个仓库 — 后端服务、CLI 工具、前端。传统的 AGENTS.md 放在单个 repo 里,agent 只能看到这一个仓库。

但做 agent 的人知道,agent 的能力取决于它能获取到多少信息。如果它不知道其他仓库的存在,不了解前后端的依赖关系,改了一个 API 不会想到调用方也要改。

所以我的工作区结构是这样的:

my-project/
├── AGENTS.md              # Agent 入口
├── orchestrator/           # 全局配置(跨仓库)
│   └── ALWAYS/
│       └── RESOURCE-MAP.yml  # 所有仓库 + 基础设施的全局索引
└── repos/
    ├── backend/
    ├── frontend/
    └── mobile/

Agent 的配置在所有代码仓库之上,启动后自动加载全局视图。它知道每个仓库的位置、技术栈、依赖关系和基础设施。这不是 monorepo — 每个 repo 仍然独立,工作区只是给 agent 一个全局的信息入口。

人机协作方式变了

用了这套工作流之后,我发现自己跟 AI 的协作方式已经完全不是"在编辑器里跟 AI 对话"了。

传统模式是:你坐在编辑器前面,跟 AI 一行一行地写代码,实时对话,像结对编程。你是操作者,AI 是工具。

现在变成了:你在 Issue 里写需求和验收标准,agent 从 Board 上捡任务,自己开分支、开发、提 PR。你通过 PR review 审查代码。

这本质上是 tech lead + 开发者的协作模式:

  • 你做架构决策、定优先级、review 代码

  • Agent 做具体实现、跑测试、提交 PR

  • 通过 Issue 和 PR 沟通,不需要实时盯着

  • 多个 agent 可以同时做不同的 Issue,你看 Board 就知道全局进度

  • 任何 agent(甚至人类开发者)都可以通过 HANDOFF 接手任何任务

做 agent 的人应该很熟悉这个转变 — 我们做的 agent 系统,本质上也是把人从"执行者"变成"监督者"。现在用 AI 写代码也是一样的路径。

代码审查从"在聊天窗口里看 agent 输出"变成了"在 GitHub PR 界面看 diff、逐行评论、跑 CI"。这是工程团队几十年验证过的流程,比在对话里 review 代码靠谱得多。

不要只给 agent 一个编辑器

很多人用 AI 写代码就是打开编辑器、对话、写代码。但实际工程里,写代码只是很小一部分。一个真正的开发者还需要:跑测试验证、查线上日志定位问题、查数据库确认数据、用 CLI 部署上线。

如果这些能力不给 agent,它就只能写完代码等你验证、等你查日志、等你告诉它线上报了什么错。每一次"等你"都是一次上下文切换,效率大打折扣。

给 agent 自验证的能力。 搭好本地测试环境,让它能跑单元测试、跑 build、跑 lint、自己确认代码是否正确。我的项目里 agent 可以跑 vitest 单测、e2e 测试、Docker 集成测试、甚至启动本地 gateway 做 API 验证 — 不是写完代码就扔给你,而是验证通过了再提交。这一步省掉的来回沟通比你想象的多。

给 agent 获取信息的能力。 这个变化最大。我给 agent 写了一份日志查询手册,告诉它怎么用 aws logs CLI 查 CloudWatch 日志 — 按 Pod 名过滤、按模块过滤、按错误级别过滤。Agent 拿着这份手册,自己查了几百个 Pod 的日志,分析出了十几类生产错误,按优先级分级,还自动配了告警规则。整个过程我只做了 review。

如果没有这个能力,这些工作全得我手动做 — 复制日志贴到对话里,agent 看了再问我更多信息,来回好几轮。有了直接查询的能力,agent 自己定位问题自己修,正确率高很多。当然,权限控制要做好 — 给只读权限,限定可访问的日志组和时间范围。

给 agent 完整的 CLI 工具链。 现在几乎所有云平台都有 CLI — AWS CLI、GCP gcloud、Cloudflare wrangler。Agent 完全可以完成从写代码到部署上线的一条龙操作。我的项目里 agent 日常用 gh 管理 Issue 和 PR、用 aws logs 查日志、用 docker 构建镜像、用 pnpm 跑测试。

这三点的核心思想是一样的:不要把 agent 当成只会写代码的代码生成器,要把它当成一个需要完整工具链的工程师。 你给它的工具越完整,它需要你介入的次数就越少。

一年多趟出来的工程化方案

Boot Sequence — Agent 自举

每次打开项目,agent 按固定顺序加载配置:工作协议 → 开发流程 → 资源索引 → 任务状态。不需要你手动喂背景信息,agent 自己读文件、自己恢复上下文、自己知道接下来该做什么。

第一次使用时 RESOURCE-MAP.yml 是空的,agent 会主动问你项目情况(几个仓库、什么技术栈、怎么部署),然后自动生成配置。之后每次启动都是全自动的。

Worktree 隔离

具体来说,每个任务通过 git worktree 获得独立的工作目录:

git worktree add repos/backend-auth -b feature/42-auth main

不在主仓库上切分支,做完清理 worktree 就行。

Sub-Agent 的文件通信协议

Sub-Agent 之间通过 workspace/ 目录传递信息,每个 sub-agent 只返回 4 行摘要给主 agent:

状态:已完成
报告:workspace/1.1-dependency-report.md
产出:1 个文件
决策点:无

主 agent 上下文只多了 4 行,但 sub-agent 实际完成的可能是大量的代码分析。把主 agent 的上下文留给规划和决策,不被执行细节占满。

SCOPE 控制 — 限制 Agent 的写入范围

本地文件模式下,每个任务有一个 SCOPE.yml,白名单指定 agent 可以写哪些文件:

write:
-repos/backend/src/auth/
-repos/backend/src/middleware/
forbidden:
-.env

超出范围的文件,agent 不能擅自修改,必须先问你。这是我做 agent 研发养成的习惯 — 给 agent 的权限应该刚好够用,不多不少。

开源了

这套工作流从最早的 Dify workflow 时代就开始摸索,到现在迭代了很多版。现在整理成了一个开源协议叫 Code Relay。

就是一组 markdown 和 yaml 文件,不是 CLI,不是 SDK。复制到你的项目里就能用。兼容 Cline、Claude Code、OpenCode、Windsurf 等所有主流工具。

两种模式:

  • GitHub 模式

     — 任务管理在 Issue + Project Board 上,适合已经用 GitHub 的团队

  • 本地文件模式

     — 不依赖任何平台,适合离线工作或不想绑定特定平台

两种模式都支持 HANDOFF、SCOPE、Sub-Agent、Worktree 等全部核心能力,区别只是任务状态存在哪里。

如果你也在认真用 AI coding agent 做项目,欢迎试试。有问题直接提 Issue。

GitHub: https://github.com/yan5xu/code-relay

阅读原文

跳转微信打开

❌