2.3 开放循环与闭合循环设计 — 循环工程的两种核心模式

本节导读：理解开放循环（Open Loop）和闭合循环（Closed Loop）的设计理念、适用场景和风险控制策略，学会为不同任务选择合适的循环模式。

学习目标

• 区分开放循环和闭合循环的核心特征
• 掌握每种模式的适用场景和设计原则
• 理解混合循环的设计方法
• 学会根据任务不确定性选择循环类型

核心概念

什么是开放循环和闭合循环？

在循环工程中，"开放"和"闭合"描述的是循环的探索边界——Agent 能在多大程度上偏离原始目标去探索解决方案。

开放循环（Open Loop）：

• Agent 有较大的探索自由度
• 目标描述相对宽泛（如"改善这个模块的代码质量"）
• Agent 可以自主决定修复范围和顺序
• 验证标准可能包含主观判断

闭合循环（Closed Loop）：

• Agent 严格在预定义的范围内工作
• 目标描述精确且可验证（如"让 test/auth.js 全部通过"）
• Agent 只能修改指定的文件和模块
• 验证标准完全确定性

如何选择？

混合循环：实际的最佳实践

在实践中，大多数有效循环是混合型的——外层闭合、内层开放：

# 混合循环示例
loop_design = {
    # 外层：闭合（严格控制范围）
    "outer_loop": {
        "goal": "修复 payment 模块中所有已知的 5 个 Bug",
        "scope": "src/payment/",
        "verifier": "npm test -- --testPathPattern=payment",
        "max_rounds": 8
    },
    # 内层：开放（每个 Bug 的修复方式由 Agent 自主决定）
    "inner_loop": {
        "strategy": "Agent 自主选择修复方法",
        "tools": ["file_edit", "terminal", "search"],
        "exploration_allowed": True
    }
}
​

环境准备 / 前置知识

• 已完成 2.1、2.2 节学习
• 有 Claude Code 的实际使用经验
• 了解软件开发中的范围管理概念

分步实战

步骤 1：实现闭合循环

"""closed_loop.py - 闭合循环实现"""
class ClosedLoop:
    """
    闭合循环：范围严格限定，验证完全确定
    最安全的循环模式，推荐作为起点
    """

    def __init__(self, config):
        self.goal = config["goal"]
        self.allowed_paths = config["allowed_paths"]
        self.verifier = config["verifier"]
        self.max_rounds = config.get("max_rounds", 6)

    def check_scope(self, action):
        """范围检查：Agent 的操作是否在允许范围内"""
        for path in action.affected_files:
            if not any(path.startswith(p) for p in self.allowed_paths):
                return False, f"文件 {path} 超出允许范围"
        return True, "范围检查通过"

    def run(self):
        for i in range(self.max_rounds):
            action = self.agent.propose_action()

            # 范围检查
            in_scope, reason = self.check_scope(action)
            if not in_scope:
                print(f"⚠️ 范围检查失败: {reason}")
                self.agent.reject_action(reason)
                continue

            # 执行
            result = self.agent.execute(action)

            # 确定性验证
            if self.verifier.passes():
                return {"status": "success", "rounds": i + 1}

        return {"status": "max_rounds", "rounds": self.max_rounds}
​

步骤 2：实现开放循环

"""open_loop.py - 开放循环实现"""
class OpenLoop:
    """
    开放循环：Agent 有探索自由度
    适合探索性任务，但需要更强的安全控制
    """

    def __init__(self, config):
        self.goal = config["goal"]  # 宽泛目标
        self.budget = config.get("token_budget", 100000)
        self.time_limit = config.get("time_limit", 600)

    def run(self):
        while self.budget > 0:
            # Agent 自主决定下一步
            action = self.agent.explore()

            # Token 预算检查
            estimated_cost = action.estimate_tokens()
            if estimated_cost > self.budget * 0.3:  # 单步不超过剩余30%
                print(f"⚠️ 单步成本过高，降低预算使用")
                action = action.simplified_version()

            result = self.agent.execute(action)
            self.budget -= result.tokens_used

            # 柔性验证
            progress = self.evaluate_progress(result)
            if progress > 0.9:
                return {"status": "success"}

            if progress < 0.1 and self.stagnation_count > 2:
                return {"status": "stuck"}

        return {"status": "budget_exhausted"}
​

步骤 3：实现混合循环

"""hybrid_loop.py - 混合循环：外层闭合 + 内层开放"""
class HybridLoop:
    """
    混合循环 = 闭合的外壳 + 开放的内核
    外层严格控制范围和停止条件
    内层允许 Agent 自由探索修复方法
    """

    def __init__(self, config):
        self.scope = config["scope"]         # 闭合：限定范围
        self.goal = config["goal"]           # 闭合：明确目标
        self.verifier = config["verifier"]   # 闭合：确定性验证
        self.exploration = config.get("exploration", {
            "max_attempts_per_bug": 3,
            "allow_alternative_fixes": True,
            "allow_refactoring": False
        })

    def run(self):
        bugs = self.discover_bugs_in_scope()

        for bug in bugs:
            print(f"\n🐛 处理 Bug: {bug}")

            # 内层开放循环
            for attempt in range(self.exploration["max_attempts_per_bug"]):
                if self.exploration["allow_alternative_fixes"]:
                    strategy = self.agent.choose_strategy(bug)
                else:
                    strategy = self.agent.simplest_fix(bug)

                fix = self.agent.execute_fix(strategy)

                if self.verifier.passes():
                    print(f"  ✅ Bug {bug} 已修复（策略: {strategy}）")
                    break
            else:
                print(f"  ⚠️ Bug {bug} 未能自动修复，需人工介入")

        return self.generate_report()
​

完整示例：实际场景选择

## 场景选择指南

### 选择闭合循环
- 修复特定文件的 Bug
- 让测试套件通过
- 代码格式化 / Lint 修复
- 类型错误修复
- 文档更新

### 选择开放循环
- 新功能探索性实现
- 架构重构（不确定最佳路径）
- 性能优化（多种策略可能）
- 技术调研（不确定最佳方案）

### 选择混合循环
- 复杂 Bug 修复（范围确定，修复方式不确定）
- 安全漏洞修复（范围确定，需要创造性解决方案）
- 跨模块重构（子目标确定，实现方式灵活）
​

常见问题 FAQ

Q1：开放循环会不会失控？成本太高怎么办？

A：会，所以开放循环必须有三重成本控制：(1) Token 总预算上限；(2) 单步成本限制（不超过总预算的 30%）；(3) 无进展自动停止。实际经验：开放循环的 Token 消耗通常是闭合循环的 3-5 倍。只在任务确实需要探索时使用。

Q2：闭合循环太死板怎么办？目标改了怎么办？

A：闭合循环的限制是 feature 不是 bug。如果目标需要修改，停止当前循环，重新设计。在循环运行过程中动态修改目标会导致验证标准不一致——这是循环工程的大忌。正确做法：设计前想清楚目标，运行中保持稳定。

Q3：能不能让 Agent 自己决定用开放还是闭合循环？

A：目前不推荐。让 Agent 自己决定循环类型等于把设计决策放回了 Agent 手中——这恰恰是循环工程要避免的。循环类型的选择应该由人类工程师在启动循环之前决定。

最佳实践与避坑

• 默认使用闭合循环：闭合循环是最安全、最可预测的选择
• 开放循环设置严格预算：Token 预算 + 时间限制 + 无进展检测
• 混合循环是最佳实践：外层闭合提供安全边界，内层开放保持灵活性
• 不要在循环运行中修改目标：目标应该稳定，验证标准一致
• 记录循环选择的理由：未来优化时可以回顾和调整

本节小结

本节对比了开放循环和闭合循环两种核心设计模式。闭合循环范围严格、验证确定，适合明确的修复任务；开放循环探索自由、验证灵活，适合探索性工作。混合循环结合两者优势——外层闭合保证安全，内层开放保持灵活性。对于初学者，强烈建议从闭合循环开始。

下一节我们将深入验证器设计——循环工程中最关键的组件。

延伸阅读

• AI Builder Club: Loop Engineering Guide
• TrueFoundry: Loop Engineering at Enterprise Grade
• 相关章节：2.4 验证器设计：为什么验证是瓶颈

关键词：Loop Engineering, 开放循环, 闭合循环, 混合循环, 循环模式, 验证器, 探索边界, 成本控制, 教程, 架构

难度：进阶

预计阅读：14 分钟