STUDY · Loop Engineering
STUDY · LOOP ENGINEERING
写循环的人
你不再逐句 prompt AI,而是设计那个替你 prompt 的循环
重心的第四次迁移
提示词 → 上下文 → Harness → Loop
一个循环做的事
发现工作 · 分派 subagent · 验证结果
持久化状态 · 决定下一步 · 该停就停
11 章 · 8 张图解 · 1 个交互演示 · 13 个来源
STUDY · AGENT ENGINEERING

Loop Engineering:从 prompt 到循环

2026 年年中突然爆火的新概念,被认为是 prompt / context / harness 之后 agent 工程的第四次重心迁移。这篇把它涉及的全部内容讲透:它是什么、从哪来、一个循环由什么构成、靠什么验证与记忆、怎么防失控、和 harness 什么关系、有哪些工具、企业怎么管车队、又带来了哪些新风险。

日期 / 核实2026-06-16
主题Loop · Harness · Sub-agent · 验证 · 自治
阅读约 35 分钟 · 11 章
来源Addy Osmani 等 13 个一手 / 权威来源
01
先把概念钉死

什么是 Loop Engineering

你有没有算过,自己一天到底花多少时间,对着 AI 一句句敲指令、看结果、再敲下一句?

2026 年 6 月,这个动作被一个新词盯上了。事情的起点很小:6 月 7 日,独立开发者 Peter Steinberger 在 X 上发了一句话,大意是「别再手动 prompt 你的 agent 了,去设计那个 prompt 它的循环」[3]。第二天,Google 的工程师 Addy Osmani 写了一篇博客把它系统化,标题就叫《Loop Engineering》[1]。概念迅速发酵,因为它戳中了所有重度使用 coding agent 的人共同的感受。

Anthropic 的 Claude Code 负责人 Boris Cherny 把这种转变说得最传神:「我不再自己 prompt Claude,我让循环来 prompt Claude——我的工作是写那个循环。」[1] 一句话点明了重心的位置变了。

所以 Osmani 给的定义非常干脆:「Loop engineering is replacing yourself as the person who prompts the agent.(循环工程,就是把你这个『负责 prompt agent 的人』替换掉。)你转而去设计那个替你做这件事的系统。」[1] 展开说:你不再逐轮地喂提示,而是搭一个小系统(这个「循环」),让它自己发现工作、把任务分派给 agent(常常是 subagent)、验证结果、持久化进度、决定下一步该干嘛——按计划或者一直跑到目标达成[1][4]

PROMPT 时代 agent 逐轮 prompt 看结果 → 再 prompt 你被绑在循环里 LOOP 时代 循环 Loop agent subagent subagent 设计一次 循环替你 prompt
图 1 · 同样是「人 + agent」,你站的位置变了:从循环那个逐轮敲指令的人,变成循环那个设计循环的人。这就是「重心上移」。

一个好的类比:你从亲自开车,变成了设计自动驾驶系统、并负责定义目的地和刹车的人。

注意这不是「prompt 工程升级版」。它是工作杠杆点的转移——你的影响力不再体现在「这句提示写得多漂亮」,而体现在「这个循环设计得多可靠」。也正因如此,Osmani 反复强调:循环工程比 prompt 工程更难,因为难点跟着杠杆点一起搬了家[1]

02
为什么是现在

四次重心迁移:从 Prompt 到 Loop

这个词不是凭空冒出来的——为什么偏偏是 2026 年中火?

因为它是一条清晰演进线上的最新一站。过去三年,AI 工程的重心迁移了四次,每一次都把人往「离具体操作更远、离系统设计更近」的位置抬一层:

Prompt 工程 Context 工程 Harness 工程 Loop 工程 怎么说 给什么 怎么驾驭一次运行 谁来反复发起运行 2023202420252026
图 2 · 每一层都把人从「具体操作」往「系统设计」抬一级:从打磨一句话,到管理上下文,到设计单次运行的环境,最后到设计反复发起运行的循环

还有一条平行的、藏在循环内部的演进线,它从学术一路走到工程[5]:2022 年的 ReAct(推理 + 行动交替)奠定了「想一步、做一步、看结果」的基本节奏;Reflexion 加了自我反思;Plan-and-Execute 把规划与执行分离;2023 年的 AutoGPT 第一次让大众看到「无人值守的循环」——也第一次让所有人见识了它失控时的无限循环和烧钱。真正让循环变得可靠的,是 2025 年之后的工程实践:Geoffrey Huntley 的 ralph 循环用「每轮重置上下文 + 文件系统存状态」治好了上下文腐烂[4],再到 2026 年产品把目标循环原生内置(如 Claude Code 的 /goal)。

为什么偏偏是现在成立三个条件同时齐备了:模型足够强(能连续做对几十步)、harness 足够成熟(单次运行已经稳)、产品把调度内置(/loop/goal、Codex Automations 让「定时戳一下 agent」成了一条命令)。缺任何一个,循环都跑不起来。2026 年,三者第一次凑齐。

03
L1 · 心脏

解剖一个 Loop:它到底由什么构成

一个能在你睡觉时替你干活的循环,拆开来到底有几个零件?

先看骨架。一个生产级循环的每一轮(每一次「tick」),都要回答六个问题——社区把它叫做迭代契约

契约项它定义什么例子
TRIGGER 触发循环什么时候醒来每 15 分钟 / PR 有新评论 / CI 失败时
SCOPE 边界它能碰哪些东西只动 repo-A 的开放 PR
ACTION 动作每一轮尝试做什么挑一个失败测试,修到它通过
BUDGET 预算资源上限最多 5 个 subagent、token 封顶
STOP 停止什么时候退出成功 / 撞到轮数上限 / 超预算
REPORT 汇报结果发去哪开 PR + 发 Slack + 写状态文件

再看血肉。Addy Osmani 把一个成熟循环的组件归纳为五块,恰好和现代 coding agent 产品里的功能一一对应[1]

心跳Automations
自动化调度
定时把「发现工作 + 分类」跑起来——Codex 的 Automations 标签、Claude Code 的 /loop / /goal、cron、GitHub Actions。这是循环的脉搏。
隔离Worktrees
并行工作互不干扰
每个 subagent 在独立的 git worktree / 分支里干活,避免多个 agent 同时写文件打架。
知识Skills
把项目套路写成 SKILL.md
可复用的「命名提示 + 工具策略 + 验证方式」,循环每轮按需 $name 调用,越攒越值钱。
连接Connectors
接上外部世界
通过 MCP 连 GitHub / Linear / Slack,让循环能自己开 PR、改 ticket、发通知。
分工Sub-agents
创建者与验证者分离
一个 subagent 草拟、另一个 subagent 独立验证(.claude/agents/ / .codex/agents/ 定义)。这是质量的关键,下一章细说。

把它们组装起来,一个典型的「过夜循环」长这样[1]:每天早晨自动化醒来 → 读昨天的 CI 失败、开放 issue、最近的 commit → 对每个值得处理的发现,开一个隔离 worktree、派一个 subagent 草拟修复、再派第二个 subagent 按项目 skills 和测试验证 → 连接器自动开 PR、更新 ticket → 状态文件记下全过程,第二天接着干。你设计这一切一次,之后就不必再手动 prompt 这些步骤了。

① 发现工作 ② 分派 subagent ③ 独立验证 ④ 持久化状态 读 CI 失败 / issue / commit worktree 隔离 maker ≠ checker 写盘 / 看板 ⑤ 决定下一步 继续循环 · 或交还给你 目标达成 / 卡住 ⇒ 交还给你 ✓
图 3 · 循环的五个动作环环相扣:发现 → 分派 → 验证 → 持久化 → 决定,然后要么再转一圈,要么在目标达成或卡住时把活儿交还给你。
交互 · 步进观察一个「修复 CI」的循环
点「下一步」开始。注意:全程没有人逐轮敲指令,循环自己在发现、分派、验证、决定。
04
最容易被低估的一环

验证:循环的生死线

如果没人盯着,循环凭什么知道自己没在批量制造垃圾?

这是循环工程和单次 prompt 最本质的区别。你在场时,是你在用肉眼验证每一步;你不在场时,验证必须被设计进循环本身,否则循环只是在「自我认可地」越跑越远。一句在社区流传的话说得很狠:「你的 coding agent 能跑很快,但坏 commit 也复利得很快。」[4]

验证有三个层级,对应三种成熟度:

Open · 开环 写到自认为完 没有反馈 只配做 demo Closed · 闭环 每次写完跑测试 / lint 红了就回炉 可带护栏上生产 Review · 评审环 后台 reviewer 持续喂回意见 长会话最佳 成熟度 / 可靠性 → 越往右,越敢让它无人值守
图 4 · 三层验证:开环只配 demo,闭环才敢上生产,评审环最适合长会话。验证防的是「agent 反复地跟自己达成一致」。

这里有个关键设计:创建者和验证者必须分离(maker ≠ checker)。让同一个 agent 给自己打分,它会过于宽容;所以循环里通常派两个 subagent——一个负责草拟、一个独立验证[1]。还有个划算的搭配:探索性的活儿用快而便宜的模型,验证这种「错了代价大」的活儿才用强模型,按需付费[1]

最后,停止条件必须是人类可验证的客观判据,而不是模型的主观感觉。比如「test/auth 下所有测试通过且 lint 干净」就是好条件——一个独立的轻量模型能明确判断「完成了没有」[1][4]。Claude Code 的 /goal 正是这个思路:你给一个完成条件,它自主多轮工作直到验证器确认达成[4]

一句话循环里,「完成」永远是一句声明,不是证据——除非你设计了独立的验证去把声明变成证据。这就是为什么验证是循环的生死线。
05
记忆在窗口外

状态:把进度写在磁盘上,而不是上下文里

模型每轮「醒来」都失忆,循环凭什么记得自己昨天干到哪了?

这是长循环必须正面解决的难题。生产级 agent 会「跑成百上千步,常常跨越多个会话和多个用户」[7]——而模型的上下文窗口既装不下这么长的历史,装多了还会「腐烂」(context rot,长上下文里中段信息被忽略)。Osmani 把结论说得斩钉截铁:「模型在运行之间会忘记一切,所以记忆必须落在磁盘上,不能待在上下文里。」[1]

上下文里的记忆 · 每轮蒸发 第 1 轮 第 2 轮 第 3 轮…忘了 → 重复劳动、丢目标 磁盘 / git 上的状态 · 每轮重新锚定 VISION.md目标 / 约束 状态文件 / 看板已做 / 待做 git 历史崩溃可恢复 → 每轮读回,续上
图 5 · 不要让对话越滚越长,而要让状态活在磁盘和 git 里:每轮把上下文重置回固定的「锚文件」,循环就既不会失忆,也不会被腐烂的长上下文拖垮。

具体落地靠一组锚文件(anchor files)[4]

除了「这次任务做到哪」,还有跨会话的长期记忆:用户偏好、学到的约束、历史结论。专门的记忆层(如 mem0)会区分短期(最近几条 / 摘要)和长期(持久偏好 / 进度),并按用户级、agent 级、全局三种作用域来存取[7]。每一轮于是变成:读输入 → 查相关记忆 → 组装提示 → 推理执行 → 把结果写回记忆

提醒记忆不是万能药:即使记忆很强,糟糕的系统提示或工具定义照样会让循环犯错[7]。而且像长文档编辑这类任务,需要混合「本地完整上下文 + 检索记忆」,不能一味为省 token 而极限压缩。
06
护栏即良心

触发与停止:别让循环跑穿你的钱包

让它一直跑——会不会一觉醒来,账单已经四位数?

会,而且真的发生过。先说怎么让它启动,再说更重要的——怎么让它停下

三种触发

三道必须焊死的停止闸

这是循环工程里最不能省的部分。少任何一道,循环都可能变成烧钱机器[4][5]

① 最大轮数每个循环 10–20 轮封顶到顶就停 ② 无进展检测同一个错误 / 输出连续 2–3 次→ 标记 BLOCKED,交还人 ③ 预算上限累计 token / 美元封顶超了立即熔断 缺任何一道,循环都可能无限自旋、子代理爆炸、或把预算一夜烧光 成本已从「生成 token」转移到「循环管理」—— 轮数 = 成本倍数
图 6 · 三道硬闸:最大轮数、无进展检测、预算上限。循环越自主,护栏越是它唯一的良心。

成本的账要重算。在循环时代,成本从「生成 token」转移到了「循环管理」:单次调用可能只花两三千 token,但循环跑 10 轮就是 10 倍,再叠加 subagent 派生、状态读写、观测开销[4]。据报道,Uber 给每位工程师设了每月约 1500 美元的 AI 预算上限;而没有护栏的循环,曾在 4 个月里烧光了整年的预算额度[4]

最阴险的失败模式不是炸得很响,而是无声自旋:循环对着同一个失败测试改了 10 轮、每轮都「以为这次能成」,既没修好也没停下,直到你看见账单。所以「无进展检测」要做成确定性的——数到相同错误出现 2~3 次就果断停,别指望模型自己醒悟。

07
两个词别再混用

Loop 与 Harness:谁站在谁的肩上

Loop 和 Harness,听起来都像「agent 的外壳」,到底什么关系?

这是最容易被混淆的一对概念,但分清它们,整个图景就清楚了。Harness(运行环境)装备的是「单次 agent 运行」——它是包在一次运行外面的完整基础设施:能用的工具、保命的护栏、自纠错的反馈回路、给人看的观测层;展开有七个平面:循环策略、工具面、上下文管理、沙箱隔离、多 agent 路由、观测、模型路由[4][12]

Loop(循环)则站在 harness 之上。harness 让一次运行跑得稳;loop 负责反复发起运行——按计划戳醒 agent、派生 helper、发现新工作、验证、持久化、决定下一步,自己喂自己[3][4]。用 Osmani 的话:harness 装备一次 agent run,loop 是那个「按计划不停戳 agent、派帮手、自我供给」的东西,loop 工程比 harness 高一层楼

LOOP · 反复发起运行 + 发现 / 验证 / 持久化 / 决定 HARNESS · 装备单次运行(工具 / 沙箱 / 护栏 / 观测 / 路由) CONTEXT · 这一轮给模型看什么 PROMPT · 这一句怎么说
图 7 · 四层嵌套:prompt 在最里,loop 在最外。Harness 让一次跑得稳,Loop 让它在你不在时持续跑。

一个好记的分工:harness 是「驾驶舱」——让一次飞行安全可控;loop 是「航空公司的排班系统」——决定这架飞机一天飞几班、飞哪、什么时候该停飞检修。你可以只有驾驶舱(每次手动起飞),但有了排班系统,飞机才能在你睡觉时持续创造价值。

08
今晚就能跑起来

工具与开源全景

想今晚就搭一个循环,有哪些现成的东西可以用?

好消息是,到 2026 年中,循环工程需要的零件大多已经内置进产品里了[1][4]。两大 coding agent 的底层形状几乎一样:

能力Claude CodeOpenAI Codex
调度 / 触发/loop/goal、cron、GitHub ActionsAutomations 标签
状态跟踪Markdown / 经 MCP 接 LinearLinear 连接器
子代理定义.claude/agents/.codex/agents/
隔离git worktree / --worktree内置 worktree
技能SKILL.md + $name同格式

而真正点燃这个概念的,其实是开源社区里那些「土法」循环——它们证明了循环不需要花哨的框架,一段 bash 就能起步[4][5]

至于 CursorGitHub Copilot:它们更偏「IDE 里的协作 agent」和「围绕 PR 的助手」,循环原生性弱于 Claude Code / Codex——能用,但要自己补调度和编排[4]

起步最小的循环可以小到一行命令:/loop 10m 审查 PR #123,CI 红就修,绿且通过审查就停。先把这一行跑通,你就已经在做循环工程了。
09
从一个到一支

企业规模:管理 Agent 车队

一个循环好用,于是你复制了第二个、第十一个——然后呢?

循环一旦好用就会繁殖,单个循环的玩法到了车队规模会立刻翻车。TrueFoundry 总结了车队级的四类新麻烦[6]共享状态(多个循环动同一个仓库/队列,经典并发 bug)、资源争抢(十一个循环抢配额和 GPU,吵闹邻居问题)、fan-out(subagent 并行委派)、触发流水线(发现→分类→修复→发布的有序流水线与背压)。

对付这些,靠的是把「散落的脚本」变成「可治理的车队」:每个循环都注册成一条agent 定义(模型、MCP 服务、skills、指令)进一个目录(registry),从而能按 agent 记身份、按循环设预算和限流[6]。运行时的核心组件是两道网关:

编排Agent Harness
执行、审批、逐步 tracing 的运行时
模型侧AI Gateway
路由、回退、缓存、预算——虚拟模型抽象出端点池,429/503 自动 failover;语义缓存按 agent 隔离命中。
工具侧MCP Gateway
工具访问治理:按工具 RBAC、入站鉴权(哪个循环)与出站鉴权(用谁的凭证)分离、输出审查。
版本Skills / Prompt Registry
skills 和提示都钉死版本,灰度到生产、可一键回滚。

安全上有个干净的框架——在四个钩子上都挂护栏[6]:LLM 输入(提示注入检测)、LLM 输出(PII / 密钥检测)、MCP 调用前(对工具输入查注入)、MCP 调用后(对输出查密钥,按需脱敏 / 拦截)。不可逆动作(合并、删除、部署)一律走组织级人工审批闸;读和写用不同权限的 agent,而不是靠提示里写「请小心」。还有个常被忽略的点:重试只有在工具支持幂等键时才安全——网关能帮你重试,但循环的副作用必须自己设计成可重复执行[6]

loop A loop B loop … N AI Gateway路由/预算/缓存 MCP GatewayRBAC/审查 模型池 GitHub Linear/Slack Registry+ 观测
图 8 · 车队架构:所有循环经 AI Gateway / MCP Gateway 统一出入,registry 管身份与预算、观测让一切可追溯。「一个循环是会在运行中自我改变的软件」,所以治理靠版本与灰度,而不是事后救火。

还要警惕三种「Day-2」失败[6]静默漂移(被弃用的模型仍能通过自己的 checker)、不安全变更(skill 升级回归了没测到的用例)、死重(一个又贵又流行的循环吃掉整张账单)。对策是同一套工程纪律:在线评估、钉版本 + 灰度闸、按循环记账并定期下线低 ROI 的循环。

10
越好用越危险

三个新风险,与一句心法

循环越顺手,有没有什么东西,反而被它悄悄拿走了?

有。Osmani 在文章里专门留了一节给这件事,因为这三个风险有个共同的诡异之处——循环变得越好,它们反而越严重[1]

风险一Verification
验证责任
无人值守的循环,也在无人值守地犯错。你分离了验证 agent,但「完成」终究是一句声明,不是证明——最终的责任无法外包。
风险二Comprehension Debt
理解衰减(理解债)
循环出货越快,你和代码之间的距离就越大。某天出事,你会发现自己已经读不懂「自己的」系统了。
风险三Cognitive Surrender
认知投降
「按下 go 就好」是一种诱人的舒适姿态,它会让你慢慢停止思考。同一个循环,可以加速理解,也可以替代理解。

Osmani 举了个扎心的对照:两个人用同一个循环,会得到完全相反的结果——一个人用它去加速自己已经深刻理解的工作,另一个人用它去逃避理解。工具一样,分野在人[1]。他自己也承认那个向下螺旋:「我要是不亲自评审代码,质量就会下降……于是陷入恶性循环。」

所以这篇所有内容,最后收束成一句心法:Build the loop. Stay the engineer.(把循环造出来,但你仍然要当那个工程师。)

换句话说:循环工程提升的是你的杠杆,不是你的责任豁免。像一个「打算长期留在工程师位置上」的人那样去建循环,而不是像一个「只想按下启动键」的人。

11
收束成行动

从 0 到 1:今晚怎么开始

道理都懂了,那第一步具体做什么?

循环工程最友好的一点是可以渐进,不必一上来就搭车队。按这三级走[4]

Level 0 · 15 分钟
一行命令的循环
/loop 10m 审查 PR #123:CI 红就修,绿且通过审查就停。 体会「设计一次、它自己跑」的感觉。
Level 1 · 1 小时
PROMPT.md + ralph 循环
写一个 PROMPT.md,用 bash 包一个带 max_iter 护栏和测试闸的循环。加上无进展检测。
Level 2 · 持续
多小时 /goal + skills + 云端 + 多 agent
/goal 跑长目标,沉淀 skills,跑在云端会话(关上电脑也不断),再引入 maker/checker 多 agent 监督。

按场景选型

个人开发者,想让 agent 过夜修 CI / 清 issue
Claude Code /loop + /goal
想要最小可控、看懂每一行循环逻辑
ralph 循环(bash + PROMPT.md)
大任务要并行很多 subagent
Mayor / 编队模式(Gas Town 思路)
团队 / 企业多循环长期跑
registry + AI/MCP Gateway 车队治理
循环里最该先做对的一件事
验证闸 + 三道停止

最后,用三句话带走全文:① Loop Engineering = 不再逐轮 prompt,而是设计那个替你 prompt 的循环——agent 工程的第四次重心上移。② 一个循环的灵魂是「验证」和「停止」:没有独立验证就是在批量造垃圾,没有三道闸就是在烧钱。③ 循环放大的是杠杆,不是责任——Build the loop, stay the engineer。

··

参考资料

本文概念、定义与事实核实于 2026 年 6 月;Loop Engineering 是 2026 年 6 月才成形的新概念,部分数字(如个别公司预算、PR 数量)来自社区报道与二手聚合,文中已就确定性措辞标注,具体以各来源原文为准。

阅读 · 右上角 ◐ 切换深浅色 · STUDY 技术笔记