从ReAct到自主闭环：Agentic Coding核心执行引擎的技术演进

一、引言

2023年，姚顺雨等人发表了《ReAct: Synergizing Reasoning and Acting in Language Models》。这篇论文首次提出了一种让大语言模型在"推理"与"行动"之间交替进行的执行范式，成为了此后几乎所有AI Agent系统的理论基石。

三年后的今天，AI编程已经跨越了"代码补全"和"对话式生成"的阶段，进入了Agentic Coding（智能体编程）时代。从ReAct到自主闭环，Agentic Coding的执行引擎经历了多轮技术迭代。这场演进的核心逻辑可以概括为一句话：每一个阶段都在弥补ReAct循环的某个短板。

---

二、ReAct：执行引擎的"元模式"

2.1 为什么是ReAct？

在ReAct出现之前，大模型处理复杂任务主要依赖两种方式：一是链式思维（CoT） prompting，让模型逐步推理但无法与外部交互；二是单纯的工具调用（Function Calling），能执行操作但缺乏推理过程。

ReAct的核心创新在于将两者融合，让模型在一个循环中交替生成三类输出：

• Thought（思考） ：用自然语言拆解当前任务
• Action（行动） ：调用外部工具执行具体操作
• Observation（观察） ：接收工具返回的结果

这个循环反复执行，直到模型认为信息足够，给出最终答案。它让AI从"被动回答问题"进化成了"主动解决问题"。

2.2 ReAct的局限

ReAct虽然奠定了执行引擎的基础范式，但其原始形态存在明显短板：

• 单次循环粒度固定：每一轮都遵循"思考→行动→观察"的固定节奏，无法在不同粒度间灵活切换
• 缺乏自我纠错机制：错误会沿着循环持续传播，没有内置的验证与修正环节
• 人仍在循环中：每一轮都需要人类监督和干预

这些局限驱动了后续的技术演进。

---

三、从ReAct到Agent Loop：让循环"跑起来"

3.1 Agent Loop的诞生

ReAct本质上描述的是"智能体应该如何思考"，而工程化落地需要的是一个能持续运行的执行循环（Agent Loop） 。业界很快发现，ReAct的核心理念可以浓缩为一个极简的循环结构：

# 一个最精简的ReAct Agent Loop
def run_agent_loop(user_input: str, max_steps: int = 10):
    messages = [{"role": "user", "content": user_input}]
    
    for _ in range(max_steps):
        # 1. 调用LLM获取Thought + Action
        response = llm.chat(messages, tools=available_tools)
        
        # 2. 如果模型不再调用工具，说明任务完成
        if not response.tool_calls:
            return response.content
        
        # 3. 执行工具调用，获取Observation
        for tool_call in response.tool_calls:
            result = execute_tool(tool_call.name, tool_call.args)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })
    
    return "达到最大迭代次数"

这段不到30行的核心逻辑，就是所有Agentic Coding工具的执行引擎雏形。从Claude Code到Cursor，从vLLM到各类开源Agent框架，其底层都跑着类似的循环。

3.2 循环的工业化：Harness与编排

单纯的循环很快暴露出问题：没有状态管理、没有错误恢复、没有可观测性。于是，Harness（工程外壳） 的概念应运而生。

Harness为Agent Loop添加了执行环境、工具接口、上下文控制、任务编排、可观测性、评估反馈和治理机制。它把"一个能跑的循环"升级成了"一个能可靠运行的工程系统"。

---

四、自主闭环：让循环"自我修正"

4.1 从"人验证"到"代码验证"

ReAct循环中，Observation来自工具执行结果，但最终答案的质量仍依赖人类判断。自主闭环的核心突破在于：让代码执行结果本身成为验证信号。

一个典型的自主闭环执行引擎，其流程不再是"生成→交付"，而是"生成→执行→验证→修复→再验证"：

Goal → Generate → Execute → Observe → Fix → Repeat → Pass → Deliver

4.2 自我修正闭环的代码实现

以下是一个带自我修正能力的Agent Loop核心实现：

import subprocess
import tempfile

class SelfCorrectingAgentLoop:
    def __init__(self, llm, max_attempts=5):
        self.llm = llm
        self.max_attempts = max_attempts
    
    def run(self, goal: str) -> dict:
        context = {"goal": goal, "attempts": [], "code": None}
        
        for attempt in range(self.max_attempts):
            # 1. 生成代码（首次基于goal，后续基于错误反馈）
            if attempt == 0:
                code = self.generate_code(goal)
            else:
                code = self.repair_code(context["code"], context["last_error"])
            
            # 2. 在沙箱中执行代码
            test_result = self.execute_in_sandbox(code)
            
            # 3. 如果测试通过，闭环完成
            if test_result["passed"]:
                return {"success": True, "code": code, "attempts": attempt + 1}
            
            # 4. 如果失败，记录错误，进入下一轮修复
            context["code"] = code
            context["last_error"] = test_result["error"]
            context["attempts"].append({"code": code, "error": test_result["error"]})
        
        return {"success": False, "attempts": self.max_attempts}
    
    def execute_in_sandbox(self, code: str) -> dict:
        """在隔离环境中执行代码并捕获结果"""
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
            f.write(code)
            f.flush()
            try:
                result = subprocess.run(
                    ["python", f.name],
                    capture_output=True,
                    text=True,
                    timeout=5
                )
                if result.returncode == 0:
                    return {"passed": True, "output": result.stdout}
                return {"passed": False, "error": result.stderr}
            except subprocess.TimeoutExpired:
                return {"passed": False, "error": "执行超时"}

这种"生成-执行-验证-修复"的闭环，正是OpenSquilla 0.4.0引入的"自我验证"机制的核心。AI不再是"口头交付"，而是在交回结果前先用测试为自己跑出可复核的证明。

4.3 闭环的深层价值

自主闭环不仅提升了代码正确率，更重要的是改变了AI编程的信任模型。传统模式下，人类信任AI靠"审查代码"；闭环模式下，信任可以建立在"测试通过"这一客观事实上。这让AI Agent从"辅助工具"向"可信协作者"迈出了关键一步。

---

五、演进趋势：从单循环到多智能体协作

5.1 并行化与专业化

单一Agent Loop在处理复杂项目时面临瓶颈：串行执行、单点失败、上下文过载。演进的下一个方向是多智能体协作。

例如，一个典型的Coding Agent团队可能包含：

• Planner Agent：负责任务分解和计划制定
• Coder Agent：负责代码生成
• Reviewer Agent：负责代码审查
• Executor Agent：负责运行测试和验证

这种多角色分工的闭环系统，能够在保持自我修正能力的同时，大幅提升处理复杂任务的能力。

5.2 从"工程化"到"工业化"

Anthropic在《2026年Agentic Coding趋势报告》中指出，到2026年，Agent已能从单次几分钟的"one-shot task"扩展到连续数天运行的长周期任务。执行引擎正在从"短循环"走向"长循环"，从"单任务"走向"多项目"。

---

六、结语

从ReAct到自主闭环，Agentic Coding执行引擎的演进路径清晰可辨：

• ReAct（2023） ：确立了"推理-行动-观察"的元模式
• Agent Loop（2024） ：将ReAct工程化为可运行的循环
• Harness（2025） ：为循环添加了工程外壳
• 自主闭环（2025-2026） ：引入自我验证和修复机制
• 多智能体协作（2026-） ：从单循环走向多角色协同

每一次演进，都在解决前一个阶段的某个短板。而贯穿始终的主线，是让AI从"被动响应"走向"主动执行"，从"需要监督"走向"可被信任" 。

未来的执行引擎，将不再是几十行Python代码组成的简单循环，而是一个包含规划、执行、验证、记忆、协作的复杂系统。但无论多么复杂，其底层逻辑始终没有离开ReAct奠定的核心思想：让AI像人一样，边想边做，边做边学。