循环工程：2026年AI工程师必知的范式转变

OpenClaw 的创建者 Peter Steinberger，如今在 OpenAI 工作。昨天他发帖说：

“你不应该再对编程 Agent 进行提示了。你应该设计循环来提示你的 Agent。”

接着，Anthropic 公司 Claude Code 的负责人 Boris Cherny 用不同的方式表达了同样的观点：

“我不再对 Claude 进行提示了。我有循环在运行，它们会提示 Claude 并找出该做什么。我的工作是编写循环。”

两位现今最资深的 AI 工程师。相同的信息。

大多数人读完后的想法是：这到底是什么意思？

我深入研究了这个问题。

以下是全部内容——简单拆解。

没有行话。只有你需要的心智模型。

保存好。它会改变你对 AI 的思考方式。

为什么大多数人从不构建循环

循环听起来很棒。然后你看到账单。

这是别人事先不会告诉你的事。

一个中等编码任务上的单 Agent 循环：50,000–200,000 个 Token。

一个带有编排器和 3 个专家的集群循环：500,000–2,000,000 个 Token。

一个每天早上按计划运行的循环：每周数百万个 Token。

按标准 API 定价，一周认真的循环工程花费超过了大多数人整个月的 AI 预算。

这就是为什么 Peter Steinberger 的回复里满是这样的声音：

“你说得轻松——你有无限的 OpenAI 访问权限。”

他们说得没错。

正常预算下的循环工程很快就会撑不住。

每次重试都要花钱。每次自我纠正都要花钱。每个子 Agent 都要花钱。每次验证都要花钱。

自由探索的开放循环？Token 消耗速度让你心疼。

这是没人谈论的隐藏障碍。

循环并不难设计。

难的是负担得起。

这正是中国大语言模型解决的问题。

像 DeepSeek、Kimi 和 MiniMax 这样的模型让 Agent 循环在经济上变得可行。

自主 Agent 的最大问题不是智能。

而是 Token 燃烧。

循环快速消耗 Token。

单次运行很容易消耗 50K–200K 个 Token。

运行多个 Agent、每天调度循环、或者在大型代码库上工作——成本会迅速飙升。

这就是 DeepSeek 改变局面的地方。

DeepSeek V4 是目前大规模运行循环最便宜的前沿级模型之一。

你得到的是：

→ 1M 上下文窗口——专为大型项目和长时间运行的工作流而构建 → 384K 最大输出——处理更大的生成而不中断 → DeepSeek V4 Flash + Pro 模型 → 极低的 Token 定价 → 用于 Agent 工作流的工具调用 + JSON 输出 → 高并发（Flash 上最多 2500 个请求）

为什么 1M 上下文窗口很重要：

循环需要记忆。

在大型项目上工作的编码循环需要同时保留：

— 之前的运行 — 当前的错误 — 架构文档 — 测试结果 — 代码库上下文

全部在内存中。

大多数模型在途中会丢失上下文。

你的循环开始忘记之前发生的事。

DeepSeek 能保留显著更多的上下文，因此长时间运行的循环能保持连贯。

而且由于定价如此之低：

循环不再让你破产。

旧方式 vs 新方式

过去两年，我们一次对一个任务进行 Agent 提示。

你输入一个提示。Agent 回应。你检查。你修复错误。你再次提示。你就是那个循环。

这种情况开始改变了。

你不是要求 Agent 构建一个着陆页然后自己驱动每一步，而是建立一个循环来处理发现、规划、执行、检查和迭代——直到目标达成。

区别：

旧方式（提示）：

你 → 提示 → Agent → 输出 → 你检查 → 你修复 → 重复

新方式（循环）：

你设定目标 → 循环运行 → Agent 发现 → 规划 → 执行 → 验证 → 迭代 → 完成

你不再提示每一步了。

Agent 替你重复这个循环。

一个提示给 Agent 指令。

一个循环给 Agent 一份工作。

循环工程到底是什么

循环工程是设计可重复的反馈循环的实践，这些循环引导 AI Agent 从尝试到验证的结果——无需持续的人类干预。

循环是你构建的一个设置。

几乎任何 Agent 工具都能运行它。

这只取决于你如何连接。

最简单的情况下，一个 Agent 对自己工作：

→ 研究 → 起草 → 对照目标检查草稿 → 修复薄弱之处 → 再次运行这个循环，直到工作符合要求

每一个循环——无论简单还是复杂——都会经历相同的 5 个阶段：

发现 → 规划 → 执行 → 验证 → 迭代

通过验证 → 交付。

未通过验证 → 再次循环。

这就是全部想法。

本文的其他内容只是如何正确构建这个循环。

单 Agent vs 集群

循环有两种规模：

单 Agent 循环

一个 Agent 自己运行整个循环。

可以想象成一个人重做自己的草稿。

它发现需要什么，规划工作，执行，验证质量，如果有问题则迭代。

适用于：

→ 专注的任务 → 简单的目标 → 有限的范围

一个大脑。一个循环。自我改进。

━━━

集群循环

更大版本是集群循环。

你给编排器 Agent 一个目标。

它将目标分解成小块。

将每个块交给一个专家 Agent。

这些专家将更小的任务交给它们自己的子 Agent。

整个树状结构不断循环，通过发现、规划、执行和验证——直到目标达成。

可以想象成一个完整的团队端到端地运行一个项目。

结构：

→ 编排器拥有目标 → 专家拥有步骤 → 子 Agent 执行狭窄的工作 → 评估关卡确保这不是垃圾

例子：“构建一个生产力应用”

编排器（负责任务） ↓ ↓ ↓ 研究 工程 质量保证 专家 专家 专家 ↓ ↓ ↓ 网页 代码编写者 测试编写者 研究员 + 调试器 + Bug 追踪器

树中的每个 Agent 都运行相同的 5 阶段循环。

发现 → 规划 → 执行 → 验证 → 迭代。

重要的事情：

单 Agent 循环就像一个人重做自己的草稿。

集群循环就像整个团队端到端地运行一个项目。

开放循环 vs 封闭循环

这是 2026 年最重要的实际区别：

并非所有循环都一样。

有两种类型。

开放循环

探索性。有广阔的移动空间。

你给 Agent 一个目标，让它自由行动。

它可以尝试不同的路径，发现新东西，构建你没有完全规范化的东西。

这是令人兴奋的一面。这正是 Peter Steinberger 等人在 OpenAI 所做的。

问题呢？

它消耗大量的 Token。

对于 90% 没有无限 API 预算的人来说，开放循环还不实用。

面对标准宽松的项目，它会变成一台垃圾输出机。

快速。混乱。昂贵。

封闭循环

有边界。人类先设计端到端的路径。

→ 清晰的目标 → 明确的步骤 → 每一步都有评估 → 一个停止或交回给人类的点

Agent 仍然循环——但在你构建的框架内。

每次运行都会变得更好，因为每次传递都滋养下一次。

它能在正常预算下运行，因为路径是紧凑的。

标准让它保持诚实。

没有质量关卡：AI 会偏离。

有质量关卡：AI 会改进。

对于今天的大多数实际工作，封闭循环才是能带来回报的。

你应该用哪一个？

从封闭循环开始。

构建一个可靠运行的紧凑系统。

然后，一旦你有了质量关卡，再把它打开。

每个好循环的 6 个构建块

每个稳固的循环都有这 6 样东西：

现在进入实践部分。

一个循环在概念上有 5 个阶段。

但实际要构建什么才能让它运行呢？

6 样东西。Claude Code 和 Codex 现在都内置了它们。

以下是它们——以及每个在循环内部真正做什么。

1. 自动化

这是在触发发现阶段并启动循环的东西。

循环的心跳。

自动化让循环成为真正的循环——而不仅仅是你做了一次的单次运行。

你定义一个提示、一个节奏和一个目标。

循环按计划运行。结果会呈现给你。你不需要自己去检查。

→ /loop 按节奏重新运行 → /goal 持续运行，直到你写的条件为真

给它：“test/auth 中的所有测试通过且 lint 干净。”

然后走开。

2. 工作树

这让多个执行阶段并行运行而不互相干扰。

并行 Agent 无混乱。

一旦你运行多个 Agent，文件就开始冲突。

两个 Agent 写入同一个文件的问题，和两个工程师不经沟通就提交到同一行代码是一样的。

一个 git 工作树给每个 Agent 自己独立的工作目录，在自己的分支上——相同的仓库历史，零冲突。

一个 Agent 的编辑实际上无法触及另一个 Agent 的检出。

3. 技能

这让发现阶段更快——Agent 在开始工作之前就已经了解你的项目。

不必每次运行都从头解释你的项目。

一个技能是一个包含 SKILL.md 的文件夹——项目约定、构建步骤、“我们因为那次事故不这样做”等。

只写一次。每次循环都读取。

没有技能：循环每次循环都从零重新推导你的整个项目。

有技能：效果累积。Agent 在开始前就知道你的项目。

→ VISION.md — 成功的样子 → ARCHITECTURE.md — 技术栈和文件夹结构 → RULES.md — Agent 永远不允许做的事

4. 插件与连接器

这让执行阶段真实——循环在你的实际环境中行动，而不仅仅是你的文件系统。

一个只能看到文件系统的循环是一个微小的循环。

连接器（基于 MCP）让 Agent 读取你的问题追踪器、查询数据库、访问暂存 API、在 Slack 中发送消息。

这是一个 Agent 说“这是修复方案”和一个循环自行打开 PR、链接 Linear 工单、并在 CI 变绿后通知频道的区别。

5. 子 Agent

这让验证阶段诚实——检查者从不是执行者。

让执行者远离检查者。

写代码的模型在给自己的作业评分时太仁慈了。

第二个 Agent 具有不同的指令——有时是不同模型——会捕获第一个 Agent 自我说服而放过的东西。

有效的分工：

→ 一个 Agent 探索 → 一个 Agent 实现 → 一个 Agent 对照规范验证

这也是 /goal 在底层做的事情。

一个新的模型决定循环是否完成——而不是执行工作的那个。

6. 记忆

这让循环持久——第 47 次运行的发现阶段知道第 1 到 46 次运行已经尝试过什么。

整个循环的脊柱。

一个 Markdown 文件。一个 Linear 看板。任何存在于单次对话之外的东西。

模型会在运行之间忘记一切。

仓库不会。

记忆文件保存：尝试过什么、什么通过了、什么仍待解决。

明天早上循环会从今天停止的地方继续。

听起来简单得不值一提。

每个长时间运行的循环都依赖它。

真实循环示例

实践中循环的样子：

编码循环

读取 VISION.md + ARCHITECTURE.md
↓
规划下一个变更
↓
编辑代码
↓
自动运行测试
↓
如果测试失败 → 读取错误 → 修复 → 重新测试
↓
如果测试通过 → 总结变更
↓
停止

中间没有人类。

Agent 自行编写、测试、修复和验证。

━━━

研究循环

定义研究问题
↓
搜索来源
↓
总结发现
↓
对照来源验证声明
↓
比较冲突信息
↓
综合最终答案
↓
当置信度阈值达到时停止

━━━

内容循环

定义主题 + 受众 + 目标
↓
创建草稿
↓
批评 Agent 审查草稿
↓
根据批评重写
↓
对照成功标准评分
↓
如果分数通过 → 发布
↓
如果分数失败 → 再次重写

━━━

销售外联循环

定义 ICP（理想客户画像）
↓
寻找匹配画像的线索
↓
用公司数据丰富信息
↓
对照标准筛选
↓
个性化信息
↓
质量审查
↓
发送或升级给人类

每个循环都有相同的骨架：

目标 → 行动 → 检查 → 修复 → 重复直到完成。

提示工程师 vs 循环工程师

2026 年正在出现的技能差距：

提示工程师

→ 制作更好的指令 → 语言技能 → 更好的提示 → 更好的单次输出 → 每次运行后仍然手动检查输出 → 你就是反馈循环

循环工程师

→ 设计更好的反馈循环 → 软件工程技能 → 更好的循环 → 可靠的验证结果 → 系统运行、检查和自我纠正 → 系统就是反馈循环

提示工程师 -> “给我写一个函数”

循环工程师 -> “写 → 测试 → 修复直到变绿”

写更好的提示 / 写 VISION.md 手动检查输出 / 测试自动检查 运行一次 Agent / 构建重复系统 为单次输出付费 / 为验证结果付费

工具是相同的。

心态完全不同。

提示工程师向 AI 索要输出。

循环工程师设计能产生验证结果的系统。

2026 年收入最高的 AI 工程师不是在写更好的英文句子。

他们在编写控制 Agent 如何发现、规划、检查自己工作以及知道何时完成的逻辑。

结语

以上就是循环工程。

让我总结一下所有内容：

转变：

→ 两年来我们一次对一个任务进行 Agent 提示 → 现在我们设计循环来运行整个周期

你实际构建的 6 样东西：

→ 自动化 — 心跳，触发发现阶段 → 工作树 — 并行 Agent 无冲突 → 技能 — 每次运行累积的项目知识 → 插件与连接器 — 循环在你的真实工具中行动 → 子 Agent — 执行者和检查者从不是同一个 Agent → 记忆 — 循环在运行之间从不忘记

两种规模：

→ 单 Agent：一个大脑，自我改进 → 集群：编排器 + 专家 + 子 Agent — 每个 Agent 运行相同的循环

两种类型：

→ 开放循环：探索性，强大，昂贵，需要无限预算 → 封闭循环：有边界，可靠，可负担，今天就能带来回报

每个好循环的 5 个部分：

→ 目标 — 精确定义“完成”的含义 → 上下文 — VISION.md、ARCHITECTURE.md、RULES.md → 行动 — 只包含 Agent 实际需要的内容 → 反馈 — 测试、类型检查、lint、结构化错误 → 停止条件 — 当循环知道它已完成时

成本问题：

→ 循环快速消耗 Token → 用 20 美元在 DeepSeek 上的效果远超大多数前沿模型 → 这移除了最后一个真正的障碍

大转变：

→ 提示工程师向 AI 索要输出 → 循环工程师设计能产生验证结果的系统

Peter Steinberger 说得对：

停止对你的 Agent 进行提示。

开始设计循环。

因为一个可靠的循环抵得上一千个完美的提示。

还有一件没人公开说的事。

两个人可以构建完全相同的循环，却得到完全相反的结果。

一个人用它来在自己深刻理解的工作上加快速度。

另一个人用它来完全避免理解工作本身。

循环不知道其中的区别。

你知道。

这就是为什么循环设计比提示工程更难——而不是更容易。

Boris Cherny 的意思不是工作变简单了。

而是杠杆点转移了。

构建循环。

但要像一个打算继续做工程师的人那样构建——而不仅仅是按开始按钮的人。

因为一个可靠的循环抵得上一千个完美的提示。

而且有了 20 美元 17 亿个 Token，你终于能负担得起构建一个了。

• 原文链接： x.com/sairahul1/status/2...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～