# Autonomous Loop Patterns > > 兼容性说明 (v1.8.0): autonomous-loops 保留一个发布周期。 Parent: [AI Agent Ecosystems](https://llms-explorer.com/tree/ai-agent-ecosystems/) · 35 facets · 81 facts · page: https://llms-explorer.com/tree/autonomous-loop-patterns/ ## 自主循环技能 - > 兼容性说明 (v1.8.0): autonomous-loops 保留一个发布周期。 > 规范的技能名称现在是 continuous-agent-loop。新的循环指南应在此处编写，而此技能继续可用以避免破坏现有工作流。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#自主循环技能) - 在循环中自主运行 Claude Code 的模式、架构和参考实现。涵盖从简单的 claude -p 管道到完整的 RFC 驱动的多智能体 DAG 编排的一切。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#自主循环技能) ## 何时使用 - 为你的问题选择正确的循环架构（简单与复杂） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#何时使用) ## 1. 顺序管道 (`claude -p`) - 最简单的循环。 将日常开发分解为一系列非交互式 claude -p 调用。每次调用都是一个具有清晰提示的专注步骤。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#1-顺序管道-claude--p) ## 核心见解 - > 如果你无法想出这样的循环，那意味着你甚至无法在交互模式下驱动 LLM 来修复你的代码。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#核心见解) - claude -p 标志以非交互方式运行 Claude Code 并附带提示，完成后退出。链式调用来构建管道： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#核心见解) ## 关键设计原则 - 每个步骤都是隔离的 - 每次 claude -p 调用都是一个新的上下文窗口，意味着步骤之间没有上下文泄露。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则) - 顺序很重要 - 步骤按顺序执行。每个步骤都建立在前一个步骤留下的文件系统状态之上。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则) - 否定指令是危险的 - 不要说“不要测试类型系统。”相反，添加一个单独的清理步骤（参见去草率化模式）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则) - 退出代码会传播 - set -e 在失败时停止管道。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则) ## 变体 - 使用 --allowedTools 限制： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#变体) ## 2. NanoClaw REPL - ECC 内置的持久循环。 一个具有会话感知的 REPL，它使用完整的对话历史同步调用 claude -p。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#2-nanoclaw-repl) ## 工作原理 - 从 ~/.claude/claw/{session}.md 加载对话历史 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#工作原理) - 每个用户消息都连同完整历史记录作为上下文发送给 claude -p — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#工作原理) - 响应被追加到会话文件中（Markdown 作为数据库） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#工作原理) ## NanoClaw 与顺序管道的选择 - 有关完整详情，请参阅 /claw 命令文档。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#nanoclaw-与顺序管道的选择) ## 3. 无限智能体循环 - 一个双提示系统，用于编排并行子智能体以进行规范驱动的生成。由 disler 开发（致谢：@disler）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#3-无限智能体循环) ## 模式 - 规范分析 - 编排器读取一个定义要生成内容的规范文件（Markdown） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式) - 目录侦察 - 扫描现有输出以找到最高的迭代编号 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式) - 并行部署 - 启动 N 个子智能体，每个都有： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式) - 波次管理 - 对于无限模式，部署 3-5 个智能体的波次，直到上下文耗尽 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式) ## 通过 Claude Code 命令实现 - 创建 .claude/commands/infinite.md： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#通过-claude-code-命令实现) ## 关键见解：通过分配实现唯一性 - 不要依赖智能体自我区分。编排器分配给每个智能体一个特定的创意方向和迭代编号。这可以防止并行智能体之间的概念重复。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键见解通过分配实现唯一性) ## 4. 持续 Claude PR 循环 - 一个生产级的 shell 脚本，在持续循环中运行 Claude Code，创建 PR，等待 CI，并自动合并。由 AnandChowdhary 创建（致谢：@AnandChowdhary）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#4-持续-claude-pr-循环) ## 跨迭代上下文：SHARED\_TASK\_NOTES.md - 关键创新：一个 SHARED_TASK_NOTES.md 文件在迭代间持久存在： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#跨迭代上下文shared_task_notesmd) - Claude 在迭代开始时读取此文件，并在迭代结束时更新它。这弥合了独立 claude -p 调用之间的上下文差距。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#跨迭代上下文shared_task_notesmd) ## CI 失败恢复 - 当 PR 检查失败时，持续 Claude 会自动： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#ci-失败恢复) - 通过 gh run list 获取失败的运行 ID — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#ci-失败恢复) - 生成一个新的带有 CI 修复上下文的 claude -p — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#ci-失败恢复) - Claude 通过 gh run view 检查日志，修复代码，提交，推送 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#ci-失败恢复) - 重新等待检查（最多 --ci-retry-max 次尝试） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#ci-失败恢复) ## 完成信号 - Claude 可以通过输出一个魔法短语来发出“我完成了”的信号： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#完成信号) - 连续三次迭代发出完成信号会停止循环，防止在已完成的工作上浪费运行。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#完成信号) ## 5. 去草率化模式 - 任何循环的附加模式。 在每个实现者步骤之后添加一个专门的清理/重构步骤。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#5-去草率化模式) ## 问题 - 当你要求 LLM 使用 TDD 实现时，它对“编写测试”的理解过于字面： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#问题) - 测试验证 TypeScript 的类型系统是否有效（测试 typeof x === 'string'） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#问题) - 对类型系统已经保证的东西进行过度防御的运行时检查 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#问题) ## 为什么不使用否定指令？ - 在实现者提示中添加“不要测试类型系统”或“不要添加不必要的检查”会产生下游影响： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#为什么不使用否定指令) ## 解决方案：单独的步骤 - 与其限制实现者，不如让它彻底。然后添加一个专注的清理智能体： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#解决方案单独的步骤) ## 关键见解 - > 与其添加具有下游质量影响的否定指令，不如添加一个单独的去草率化步骤。两个专注的智能体胜过一个有约束的智能体。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键见解) ## 6. Ralphinho / RFC 驱动的 DAG 编排 - 最复杂的模式。 一个 RFC 驱动的多智能体管道，将规范分解为依赖关系 DAG，通过分层质量管道运行每个单元，并通过智能体驱动的合并队列落地。由 enitrat 创建（致谢：@enitrat）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#6-ralphinho-rfc-驱动的-dag-编排) ## RFC 分解 - 保持测试与实现在一起（永远不要分开“实现 X” + “测试 X”） — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#rfc-分解) - 仅在实际存在代码依赖关系的地方设置依赖关系 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#rfc-分解) ## 复杂度层级 - 这可以防止对简单更改进行昂贵的操作，同时确保架构更改得到彻底审查。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#复杂度层级) ## 独立的上下文窗口（消除作者偏见） - 每个阶段在其自己的智能体进程中运行，拥有自己的上下文窗口： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#独立的上下文窗口消除作者偏见) - 关键设计： 审阅者从未编写过它要审阅的代码。这消除了作者偏见——这是自我审阅中遗漏问题的最常见原因。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#独立的上下文窗口消除作者偏见) ## 具有驱逐功能的合并队列 - 驱逐恢复： 被驱逐时，会捕获完整上下文（冲突文件、差异、测试输出）并反馈给下一个 Ralph 轮次的实现者： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#具有驱逐功能的合并队列) ## 工作树隔离 - 每个单元在隔离的工作树中运行（使用 jj/Jujutsu，而不是 git）： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#工作树隔离) - 同一单元的管道阶段共享一个工作树，在 research → plan → implement → test → review 之间保留状态（上下文文件、计划文件、代码更改）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#工作树隔离) ## 关键设计原则 - 确定性执行 - 预先分解锁定并行性和顺序 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) - 在杠杆点进行人工审阅 - 工作计划是单一最高杠杆干预点 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) - 关注点分离 - 每个阶段在独立的上下文窗口中，由独立的智能体负责 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) - 带上下文的冲突恢复 - 完整的驱逐上下文支持智能重试，而非盲目重试 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) - 层级驱动的深度 - 琐碎更改跳过研究/审阅；大型更改获得最大审查 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) - 可恢复的工作流 - 完整状态持久化到 SQLite；可从任何点恢复 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#关键设计原则-1) ## 模式组合 - 顺序流水线 + 去草率化 - 最常见的组合。每个实现步骤都进行一次清理。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式组合) - 连续 Claude + 去草率化 - 为每次迭代添加带有去草率化指令的 --review-prompt。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式组合) - 任何循环 + 验证 - 在提交前，使用 ECC 的 /verify 命令或 verification-loop 技能作为关卡。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式组合) - Ralphinho 在简单循环中的分层方法 - 即使在顺序流水线中，你也可以将简单任务路由到 Haiku，复杂任务路由到 Opus： — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#模式组合) ## 常见错误 - 没有退出条件的无限循环 - 始终设置最大运行次数、最大成本、最大持续时间或完成信号。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) - 迭代之间没有上下文桥接 - 每次 claude -p 调用都从头开始。使用 SHARED_TASK_NOTES.md 或文件系统状态来桥接上下文。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) - 重试相同的失败 - 如果一次迭代失败，不要只是重试。捕获错误上下文并将其提供给下一次尝试。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) - 使用负面指令而非清理过程 - 不要说“不要做 X”。添加一个单独的步骤来移除 X。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) - 所有智能体都在一个上下文窗口中 - 对于复杂的工作流，将关注点分离到不同的智能体进程中。审查者永远不应该是作者。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) - 在并行工作中忽略文件重叠 - 如果两个并行智能体可能编辑同一个文件，你需要一个合并策略（顺序落地、变基或冲突解决）。 — [source](https://llms-explorer.com/sources/mdb-context-hub/autonomous-loops/#常见错误) ## Where this helps - Automating a well-defined multi-step coding task, such as a framework migration, by chaining focused claude -p steps instead of one long interactive session. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Running unattended overnight or CI-triggered work, such as a continuous PR loop that opens a PR, waits on CI, and auto-fixes failures without a human watching each iteration. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Generating many independent creative variations in parallel with the infinite agent loop pattern, when the goal is N distinct outputs against one spec rather than a single best-effort attempt. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Large refactors or RFC-scale features that benefit from splitting research, planning, implementation, testing, and review into separate agent processes so no single agent reviews code it wrote itself. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* ## Project ideas - Build a sequential claude -p pipeline that breaks a recurring dev task, such as a dependency bump plus test fix plus changelog entry, into discrete non-interactive steps that each start from a clean context window. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Implement a SHARED_TASK_NOTES.md-style file that persists across claude -p invocations so later steps can read what earlier steps discovered, closing the context gap between isolated calls. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Add a de-sloppification step after an implementer step, as a separate cleanup or refactor agent invocation, instead of stacking negative instructions like “don't over-test” onto the implementer's prompt. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Wire a continuous PR loop script that watches gh run list for CI failures and re-invokes claude -p with the failure context attached, so retries carry new information instead of blindly rerunning. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* ## Antipatterns - Running a loop with no exit condition — no max iteration count, cost cap, wall-clock limit, or completion signal — risking a runaway loop that burns budget on already-finished work. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Piling negative instructions, such as “don't test the type system” or “don't add unnecessary checks,” onto a single implementer prompt instead of adding a dedicated cleanup step, which degrades downstream quality. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Retrying an identical prompt after a failed iteration instead of capturing the failure's error context and feeding it into the next attempt. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Letting parallel sub-agents self-differentiate instead of assigning each one an explicit direction and iteration number, which produces duplicate or converging outputs. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* ## Known issues - Each claude -p call starts a fresh context window, so nothing carries over between steps unless it is explicitly bridged with a file like SHARED_TASK_NOTES.md or filesystem state. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - The most complex pattern, RFC-driven DAG orchestration, depends on running each unit in an isolated worktree, which adds real operational overhead beyond what a simple sequential pipeline needs. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - Completion-signal detection, such as three consecutive iterations signaling done, is a heuristic rather than a guarantee — a loop can plateau on subtly wrong output and still emit the signal. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* - A merge queue with eviction, as used in the DAG-orchestration pattern, needs its own recovery path for captured conflict files, diffs, and test output, or an evicted unit's work is simply lost on the next round. — [source](https://llms-explorer.com/tree/autonomous-loop-patterns/) *(AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.)* ## Context files - [Autonomous Loop Patterns](https://llms-explorer.com/downloads/sources/mdb-context-hub/autonomous-loops.md)