简报 文章 热榜 论文故事 系列 探索实践
第 1 课
← 返回系列列表

Loop Engineering 核心思想

Loop Engineering — 循环工程设计

AI Agent 循环的设计哲学：观察 → 思考 → 行动 → 反馈。

Loop Engineering 核心思想

课程简介

AI Agent 循环的设计哲学：观察 → 思考 → 行动 → 反馈。

🎬 本课程视频：Loop Engineering — 循环工程设计

Loop Engineering 核心思想：Observe→Think→Act→Feedback 循环

一、什么是 Loop Engineering？

传统 AI 应用是"一次请求，一次响应"的模式——用户输入 Prompt，模型生成回答，结束。Loop Engineering 从根本上改变了这个范式：AI 系统在循环中持续运行，观察环境、思考推理、采取行动、收集反馈，然后根据反馈调整下一个循环。

这种架构的关键在于"循环"——不是一次性的调用，而是持续多次的迭代，每次迭代都让系统状态更好。这就像 AlphaGo 下围棋——不是一次就输出最佳落子，而是在每一步棋之后，重新评估棋盘状态，再决定下一步。

Loop Engineering 本质上是让 AI 系统具备"体察-推理-行动-学习"的完整闭环能力。这比简单的 Prompt→Response 模式更接近人类的认知方式。

二、四阶段循环详解

阶段 1：观察（Observe）

系统从外部环境中收集信息。信息来源包括：
- 传感器数据：摄像头画面、麦克风音频、温度计读数
- 数字信号：API 响应、数据库变更日志、消息队列事件
- 用户输入：用户消息、操作、反馈
- 系统状态：当前任务进度、资源使用情况、上次循环的中间结果

观察的核心是将原始信息转化为结构化的状态表示。例如：将一页文档的图像转化为"已处理、待处理、出错"的结构化任务清单。

阶段 2：思考（Think）

系统分析当前状态，制定行动策略。这个阶段是 Loop Engineering 的核心：

  1. 状态评估：当前的目标是什么？距离目标还有多远？有哪些约束条件？
  2. 选项生成：基于当前状态，有哪些可行的下一步行动？
  3. 策略选择：用 LLM 的推理能力评估各选项的预期结果，选择最优策略
  4. 规划：如果需要多个步骤，生成行动序列（Plan）

思考阶段通常由 LLM 驱动——将当前状态描述为文本，让模型生成下一步行动建议。但思考也可以包含程序化的逻辑：规则引擎做初步筛选，LLM 做复杂决策。

阶段 3：行动（Act）

执行选定的行动。行动可以是：
- 调用外部工具：执行 Shell 命令、调用 API、查询数据库
- 修改内部状态：更新变量、写入文件、改变状态机状态
- 生成输出：回复用户、输出结果、发送通知
- 调用子代理：创建一个子 AI Agent 执行子任务

行动的关键是"可观测性"——每次行动后都要能捕获结果，以便进入反馈阶段。

阶段 4：反馈（Feedback）

收集行动的结果，更新系统状态：
- 行动是否成功？检查返回值、错误码、输出内容
- 是否更接近目标？评估当前状态和目标状态的差距
- 是否有意外情况？错误信息、异常状态、超时
- 更新记忆：将经验存入记忆系统，供未来循环参考

反馈阶段的质量决定了整个系统的学习能力和自适应性。

三、状态管理

Loop Engineering 系统的状态管理和传统 Web 应用有本质区别。

传统 Web 应用是无状态的——每次请求独立处理。Loop 系统是有状态的——每个循环之间需要传递信息。状态管理需要关注：

工作内存：当前循环的上下文——用户输入、中间结果、当前的子任务清单。通常保存在内存中或用临时文件存储。

长期记忆：跨会话的知识——用户偏好、历史错误模式、学习到的策略。可以用向量数据库或关系型数据库存储。

状态持久化：系统崩溃时能恢复——定期保存检查点（Checkpoint），记录当前进度、已完成的任务和待处理的任务。

状态一致性问题——循环可能有多个分支和并行操作。需要确保状态更新的原子性和一致性。类似于数据库事务——要么全部提交，要么回滚到上一个检查点。

四、容错与重试

循环系统比单次调用更容易出错——操作越多，失败点越多。

重试策略：
1. 立即重试：对于临时性故障（超时、网络抖动），立即重试 1-2 次
2. 指数退避：失败后等待时间按指数增长（1s、2s、4s、8s…），避免服务器过载
3. 最大重试次数：设置上限（通常 3-5 次），超过后进入错误处理流程
4. 降级：当某个操作不可用时，尝试替代方案

错误处理模式：
1. 重试：对临时错误，重试当前操作
2. 跳过：对非关键操作，跳过当前步骤继续执行
3. 回退：错误影响后续步骤时，回退到上一个安全状态
4. 终止：不可恢复的错误——记录信息、通知人工、终止循环

五、经典案例

案例一：AI 软件工程师（Claude Code 的 Agent 模式）

Claude Code 在 agent 模式下就是一个 Loop Engineering 系统：
1. Observe——读取用户的问题、当前工作目录、文件状态
2. Think——分析任务需求，拆解为子任务，制定执行计划
3. Act——执行搜索、读取文件、编辑代码、运行测试
4. Feedback——检查结果，判断是否需要调整策略

循环持续进行，直到用户确认任务完成。

案例二：自动化网页浏览代理

目标是"帮我从这个电商网站找到最便宜的机械键盘"：
1. Observe——当前网页内容、搜索框位置、已有的搜索结果
2. Think——"先输入关键词搜索 → 打开搜索结果 → 比较价格"
3. Act——在搜索框中输入文字、点击搜索按钮、读取结果
4. Feedback——搜索结果是否正确？有没有更好的筛选方式？继续下一个操作

案例三：视频监控分析系统

  1. Observe——每帧画面的物体检测结果、人脸识别结果
  2. Think——"这个人在这个区域停留超过 10 分钟，可疑"、"这个人脸不在白名单中"
  3. Act——发送报警通知、触发摄像头录制
  4. Feedback——报警是否误报？用户是否确认？更新白名单

六、设计原则

  1. 幂等性优先：每个操作重复执行不应产生副作用
  2. 显式状态：状态变化必须在代码中显式声明，而不是隐式在多个地方修改
  3. 检查点驱动：定期保存状态，确保崩溃后能从最近的检查点恢复而不是从头开始
  4. 可观测性：记录每个循环的输入、输出、耗时和决策——方便调试和优化
  5. 渐进式复杂度：从简单的 Linear Loop（一步接一步）开始，再升级到 Tree Loop（分支探索），最后到 Graph Loop（复杂依赖关系）

七、总结

Loop Engineering 是将 AI 系统从"一次性问答"升级到"持续智能化闭环"的架构范式。Observe→Think→Act→Feedback 四阶段循环、显式状态管理、三层容错机制——这三者构成了 Loop Engineering 的核心骨架。理解这套思想，你就能构建真正自主运行、适应复杂环境的 AI 系统。

八、反思模式（Reflection Pattern）

反思是 Loop Engineering 中最重要的高级模式之一。它让 AI 系统不仅能在当前循环中做决策，还能回顾过去的循环，评估自己的表现，从中学习。

单次反思：每个循环结束后，系统记录做了什么、结果如何、以及下次可以改进的地方。例如：
- 行动：搜索了文件 system.py
- 结果：文件不存在
- 反思：下次搜索前应该先确认项目根目录

定期反思：每隔 N 个循环做一次全面的自我评估——查看整个任务的进度、识别重复出现的错误模式、调整整体策略。

反思触发条件：
- 失败触发：某个操作连续失败 N 次后触发反思——分析失败原因，调整策略
- 循环限制：达到一定循环次数后触发——评估是否有进展，是否需要回到上一步
- 里程碑触发：完成某个子任务后反思——记录经验和教训

九、多 Agent 协作模式

复杂任务往往需要多个 Agent 协作完成。Loop Engineering 可以扩展到多 Agent 系统：

Master-Worker 模式：一个主 Agent 负责任务分解和分配，多个工作 Agent 并行执行子任务，主 Agent 汇总结果。适合数据并行处理的场景。

辩论模式：多个 Agent 从不同角度分析同一问题，互相辩论，最终达成共识。适用于决策类和评估类任务——多个视角能减少单 Agent 的盲区。

流水线模式：Agent A 的输出是 Agent B 的输入——形成处理流水线。适用于多阶段处理任务——先提取信息、再分析总结、最后生成报告。

多 Agent 系统的关键挑战：通信效率、状态一致性（各个 Agent 看到的系统状态是否一致）、冲突解决（Agent 之间意见不一致时如何处理）。

十、循环工程的实际实现

理解理论后，我们来看如何在实际代码中实现 Observe-Think-Act 循环。

简洁的循环实现：

import json
from typing import List, Dict, Any

class LoopEngine:
    def __init__(self, llm, tools: Dict[str, Any]):
        self.llm = llm
        self.tools = tools
        self.state = {"messages": [], "step": 0}
        self.max_iterations = 10

    def observe(self, environment: str) -> str:
        """Observe: 收集当前环境信息"""
        observation = f"Step {self.state['step']}: {environment}"
        self.state["messages"].append({"role": "user", "content": observation})
        return observation

    def think(self) -> str:
        """Think: 分析观察结果，决定行动"""
        response = self.llm.invoke(self.state["messages"])
        self.state["messages"].append({"role": "assistant", "content": response})
        return response

    def act(self, decision: str) -> Any:
        """Act: 执行工具调用"""
        action = self._parse_action(decision)
        if action["tool"] in self.tools:
            result = self.tools[action["tool"]](**action["args"])
            return result
        return {"error": "Unknown tool"}

    def run(self, task: str) -> str:
        """完整的 Observe-Think-Act-Feedback 循环"""
        self.observe(task)
        for _ in range(self.max_iterations):
            decision = self.think()
            result = self.act(decision)
            feedback = self._check_completion(result)
            if feedback["done"]:
                return feedback["summary"]
            self.observe(f"执行结果: {result}\n反馈: {feedback}")
        return {"status": "max_iterations_reached"}

错误处理增强：添加重试逻辑、指数退避、异常分类。不同的错误类型需要不同的处理策略——网络错误应该重试，参数错误应该调整参数，工具不存在应该切换工具。

状态持久化：将循环状态序列化保存——这样系统可以在崩溃后从中断处恢复执行。状态包括已完成的操作、累积的观察结果、待办任务列表。

可观测性：记录每次循环的完整轨迹——输入、思考过程、选择的行动、执行结果、反馈。这些日志是调试和优化的基础。

从理论到实现，Loop Engineering 的核心价值在于它提供了一个结构化框架来构建复杂的 AI 系统——把不可预测的 LLM 行为包装在可控的循环中，用状态管理保证一致性，用容错机制保证可靠性，用反思模式促进持续改进。

延伸阅读

TomABC © 2026 主站 探索实践 AI 内容