一句话与三层框架
loop 让一个工作单元在没有你的情况下变正确;graph 决定哪些单元根本不该存在。
四个动作:产出 → 检查 → 修正 → 重复直到通过。关键是检查——一个能"在你不看的时候失败"的判定条件。没有它,你拥有的不是 loop,只是一台调度器(scheduler)。
节点 = 一个边界清晰的工作单元;边 = 依赖关系。它决定什么先跑、什么并行、什么永远不跑、结果往哪回流。这是 loop 给不了的东西。
把人类放到"后果最高、可逆性最低"的那一步——批准合并、决定哪些修复上线。而不是审中间产物、不逐步确认。人在图中间会变成图里最慢的节点。
为什么只搭 loop 会卡住
loop 的天花板在于:它只能让一个单元变好,却无法决定"该有哪些单元、以什么顺序、哪两个步骤其实不需要互相等待"。结果就是你得到一个很棒的 agent,用错误的顺序、一次一步地跑着错误的三个步骤——每一步都对,整体却慢且形状不对。这时候去调 loop 没用,因为问题根本不在任何一个单元内部。而人们恰恰在这一刻怪罪模型。
四条最反直觉的洞察
- "没有报错"不等于"正确"。absence of an error is not evidence of correctness。把 loop 建在这个假象上,你会得到一个自信地重复犯同一个错误、直到预算烧光、日志还全程干净的系统的系统。
- "然后"不是一条边。绝大多数无谓等待,都来自把"先做 A 再然后做 B"当成依赖。问一句:下一步真的读了上一步的输出吗?说不出跨过去的那个变量,就没有边,等待就是纯浪费。
- 不是所有节点都是模型。合并、排序、去重、对比 before/after——这些都有唯一正确答案、几行代码就够。能用代码就别用模型,否则是在为"不该有的成本、延迟和方差"付租金。
- 人按"爆炸半径"而非"置信度"开门。置信度是模型唯一能影响的输入,是最弱的变量;强变量是"如果错了,撤销有多贵"。迁移、删除、碰生产数据或钱的那条车道,永远不开,与分数无关。
五块拼图
① Loop:一个能失败的检查
剥掉一切,loop 只有四部分:produce → check → correct → repeat until green。检查是全部。没有"能在你离开房间时失败"的东西,你拥有的只是调度器。听起来像废话,但几乎没人先写检查——大家先建工作,再在末尾挂一个"让另一个模型看看输出"的评审,这是两个乐观主义者在互相点头。
先写条件,且写成程序能求值的形式。否则你搭的是一个"自信地重复错误直到预算耗尽、日志却全程干净"的系统。
② Graph:工作本身的形状
graph 是"什么跑、什么并行跑、什么等待、什么永远不跑、结果往哪回流"。只有两样东西:节点(一个边界清晰的工作:一个输入进、一个输出出)和边(依赖:这个节点的输出喂给那个节点的输入)。
诊断法:对现有流水线里的每一支箭头问一句——"下一步真的读了上一步的输出吗?"如果你说不出跨过去的变量名,就没有边,等待就是纯浪费。多数链条里有两三支这样的箭头,找到它们通常是最大的单点提速。
③ 四种节点,其中一种不是模型
splitter(切分器)· worker(执行者)· code node(代码节点)· gate(闸门)。就这四种。
- splitter 把工作切成单元、站在最前面。它做的决定比任何节点都多——按错误的维度切(比如按文件夹),四个 worker 会审计同一批三个文件;按爆炸半径切,每个人看到别人看不到的东西。
- worker 各做各的单元、各带各的视角、各用各的上下文。共用上下文会让它们收敛——第一个写下发现,其余全读它,四个报告围绕同一件事,你花四份钱买一个意见加三个回声。
- code node 是最常被遗忘的存在。合并、排序、去重、对比——这些不是推理,各有唯一正确答案、几行代码。判断标准:如果你能不用 judge / decide / assess / summarize 这些词描述这个变换,它就是代码。
- gate 决定一个单元过不过、往哪回流。
④ 两条返回路径,人人都跳过第二条
没有回头路的 graph 只是流水线:产出输出然后遗忘,下周从同一处、带着同样的盲点重新开始。真正能工作的 graph 有两条返回路径:
- 修正边(短):gate 把一个单元退回产生它的那一步,修复当前这一次运行。
- 学习边(长):一个被接受的结果,作为约束回流到 splitter,修复之后每一次运行。
几乎人人都建了第一条、跳过第二条。标志是:一个系统很快,却永远不变得更聪明。学习边携带的不是输出,而是从输出推导出的约束——它落进的是"塑造工作如何被切分"的 brief,而不是 worker 的指令。一个被确认的原因变成一条规则,下一次破坏就从这一次结束的地方开始。
⑤ 退回单元,而不是退回整批
返回路径上最贵的错误。四个切片被移植,一个测试失败。如果整批退回,三个正确的切片被重写——它们的下一版只是"不同"而非"更好",因为你根本没对它们做错任何事。然后你重新验证全部四个,其中任何一个这次都可能因为无关原因失败。你把一次失败转化成了四个不确定的结果,还为此付费。一次运行里做两次,就永远不收敛。
退回要带范围行(scope line):没有它,被退回的单元会膨胀——agent 打开文件、发现两个相邻问题、顺手也修了,于是一个切片级的修正变成一个没人评审的四文件 diff。还要封顶三次尝试:一个单元失败三次修正,问题在产生它的计划里,而 loop 看不到计划。
开门按爆炸半径,不按置信度
多数教程造一个置信度分数、设阈值、超过就放行。这是错的变量。置信度是模型唯一能影响的输入,是最弱的一环。强变量是"如果错了,撤销有多贵"。按撤销成本给工作分级:
- 可逆且局部——文案改动、测试、有覆盖的隔离函数。一次坏合并的成本只是一次 revert,这条车道可以先开。
- 可逆但很宽——共享工具、schema 新增、十几个调用方碰到的东西。用确定性检查 + 干净轨迹来把关。
- 难以逆转——迁移、删除、写生产数据、动钱。这条车道不开,无论分数多高。
第三行不是"设得很高的阈值",而是一条"永不开启的车道"。区别在于:阈值会被调整,关闭的车道不会。在开启的车道里,gate 按顺序读证据:确定性结果 → 本次运行的轨迹 → 这个节点以前被回滚过的频率 → 最后才是模型自己的评估。
从哪开始
拿一件你反复做的事。画出 splitter、车道、merge、一个 gate、一条回头边。先建 gate——一旦有什么能响亮地失败,一切都会变容易;没有 gate 的 graph 只是更快地产出未经验证的输出。然后是车道。最后是学习边,因为你没法从"被接受的结果"里推导约束,除非已经有什么在接受结果。
Loops and Graphs:如何不再盯梢 Agent、只在最后一步批准
你检查你的 agent 走的每一步。不是因为你愿意,而是因为没有别的东西在做这件事。
从那张椅子上起身需要两样东西,而几乎每个人只造了其中一样。
一个 loop 让一个工作单元在没有你的情况下变正确。一个 graph 决定哪些单元根本该存在。
下面是两者的分野、那些并不显然的机制,以及那个"只批准一样东西而非每样东西"的节点。
一个 loop 是一个能失败的检查
剥掉一切,一个 loop 就是四部分:产出、检查、修正、重复直到通过。
检查是全部。没有一样"能在你离开房间时失败"的东西,你拥有的不是一个 loop,而是一台调度器。
这听起来像废话,却几乎没人先写检查。他们先建工作,然后在末尾栓上一个评审——那个评审是另一个被要求"看一眼输出"的模型。两个乐观主义者在互相点头。
先写条件,并且把它写成程序能求值的形式。
最后一条会抓住那些谨慎的人。没有报错,不等于正确。把 loop 建在这个上面,你会得到一个自信地重复同一个错误、直到预算烧光、日志全程干净的系统。
没人警告过你的天花板
一个 loop 让一个工作单元变得更好。这是它的全部工作,而且它做得非常好。
它无法决定哪些单元存在、它们的顺序,也注意不到五个步骤里有两个根本不需要互相等待。
于是你得到一个很棒的 agent,用错误的顺序、一次一步地跑着错误的三个步骤。每一步都正确。结果仍然慢、仍然形状不对,而调 loop 修不好它,因为问题不在任何一个单元内部。
这就是人们开始怪罪模型的时刻。也是下一层开始值回票价的时刻。
Graph 是它上面的那一层
一个 graph 是工作的形状:什么跑、什么并行跑、什么等待、什么永远不跑、结果往哪回流。
两样东西,仅此而已。一个节点是一个工作单元:一个有边界的工作,一个输入进、一个输出出。一条边是一个依赖:这个节点的输出喂给那个节点的输入。
每一次无谓等待背后的错误,是把"然后"当成一条边。"总结这个文件然后查一下天气"——这两者之间没有边。天气并不消费那份总结。那是两个独立的节点被线性脚本串了起来,而串起它们的只是你打字时的先后顺序。
所以,对既有流水线里的每一支箭头问一句:下一步真的读了上一步的输出吗?如果你说不出跨过去的那个变量,就没有边,等待就是纯浪费。
多数链条里有两三支这样的箭头,找到它们通常是可获得的、最大的一笔提速。
四种节点,其中一种不是模型
splitter、worker、code node、gate。这就是全部词汇。
splitter 把工作切成单元,站在最前面。它做的决定比任何节点都多,因为按错误的维度切分,会浪费下游的一切。按文件夹切一个仓库,四个 worker 审计的是同一批三个文件;按爆炸半径切,每个人看到的是别人看不到的东西。
worker 各做一个单元、各带一个视角、各用各的上下文。最后那点最常被跳过。给四个审计员一个共享窗口,他们会收敛:第一个写下一条发现,其余全读它,四份报告围绕同一件事。你花四份钱,买了一个意见加三个回声。
code node 是那个被人忘记的存在。合并、排序、去重、对比每一次 export 的前后。这些没有一样是推理。各有唯一正确答案、各是几行代码,把它们跑过模型,只是给一个本没有成本的步骤加上了成本、延迟和方差。如果你能不用 judge、decide、assess、summarize 这些词描述这个变换,它就是代码。
一个每条边都是 agent 的 graph,是在为它自己的布线付租金。
loop 到底住在哪
一句话解决整个困惑:loop 住在节点内部,graph 住在节点之间。
在一个单元内部:产出、检查、修正、重复直到通过。
在单元之间:切分、扇出、合并、把关、退回。第二份清单里的任何一样,都无法从单个单元内部表达出来。
所以你不必二选一。节点里没有 loop 的 graph,是并行地产出未经验证的工作——比串行还糟,因为量更大。没有 graph 环绕的 loop,是一个没人设计过的队列里、一个很棒的步骤。
两条返回路径,以及人人都跳过的那一条
没有回头路的 graph 是一条流水线。它产出输出然后遗忘。下周它从同一处、带着同样的盲点重新开始。
能工作的 graph 有两条返回路径,干的是不同的活。
修正边很短。一个 gate 把一个单元退回产生它的那一步,它修复的是你正在跑的这一次。
学习边很长。一个被接受的结果作为约束回流到 splitter,它修复的是之后每一次运行。
几乎人人都建第一条、跳过第二条。标志是一个很快、却永远不变得更聪明的系统。
学习边携带的不是输出,而是从输出推导出的约束。注意它落在哪:不是 worker 的指令里,而是塑造工作如何被切分的 brief 里。一个被确认的原因变成一条规则,下一次破坏就从这一次结束的地方开始。
退回单元,而不是退回整批
这是返回路径上最贵的错误,值得说清楚。四个切片被移植,一个测试失败。如果整批退回,三个正确的切片被重写。它们的下一版只是"不同",而非"更好",因为你对它们没做错任何事。现在你重新验证全部四个,其中任何一个这次都可能因为无关的原因失败。你把一次失败转化成了四个不确定的结果,还为此付了钱。一次运行里做两次,它就永远不收敛。
从外面看,这像模型在反复失败。其实是返回路径在摧毁正确的工作。
退回时要带四样东西,各司其职。范围行(scope line)比它看起来更重要:没有它,被退回的单元会膨胀——agent 打开文件、注意到两个相邻问题、顺手也修了,你那个切片级修正变成一个没人评审的四文件 diff。还要封顶三次尝试:一个单元失败三次修正,问题在产生它的计划里,而 loop 看不到计划。
按爆炸半径开门,不按置信度
多数教程造一个置信度分数、设一个阈值、让高于它的都通过。这是错的变量。
置信度是那个决定里最弱的输入,原因容易被忽略:它是模型唯一能影响的输入。强变量是"如果错了,会怎样"。按撤销错误的成本给工作排序:
- 可逆且局部。一次文案改动、一个测试、一个带覆盖的隔离函数。一次坏合并的成本只是一次 revert,所以这条车道可以先开。
- 可逆但很宽。一个共享工具、一次 schema 新增、任何十几个调用方碰到的东西。用确定性检查 + 干净轨迹来把关。
- 难以逆转。迁移、删除、任何写生产数据或动钱的东西。这条车道不开,无论分数多高。
第三行不是一条设得很高的阈值。它是一条永不开启的车道,区别很重要,因为阈值会被调整,而关闭的车道不会。
在一条开启的车道里,gate 按顺序读证据:确定性结果,然后本次运行的轨迹,然后这个节点的产出以前被回滚过的频率,最后才是模型自己的评估。
从你自己的活开始
拿一件你反复做的事。画出 splitter、车道、merge、一个 gate、一条回头边。
先建 gate。一旦有什么能响亮地失败,一切都会变容易;没有 gate 的 graph 只是更快地产出未经验证的输出。
然后是车道。最后是学习边,因为你没法从被接受的结果里推导约束,除非已经有什么在接受结果。
把人类放到一个步骤上——后果最高、可逆性最低的那一步。批准合并。选择哪些修复上线。而不是审中间产物,不是确认每一步。图中间的人类会成为图里最慢的节点,而 graph 会精确地以"一个人读东西的速度"运行。
三句话撑起整门学问
Measure the path, not only the answer it landed on.
度量那条路径,而不只是它最终落到的答案。
A verdict that does not change what runs next is a report.
一个不改变"下一步跑什么"的结论,只是一份报告。
Any failure you do not turn into a permanent constraint, you will meet again.
任何你没有固化成永久约束的失败,你都会再次遇见。
大多数人会继续调那一个 loop,然后管它叫系统。而那些围着它画出 graph 的人,会跑起一支舰队,并且永远搞不懂为什么别人觉得跟上这么难。