Harness、Loop 与 ReAct 架构：三者之间的联系与演进

关注

原创最新推荐文章于 2026-10-27 16:18:41 发布 352 阅读 AI 写同款· GEO 优化 ›

Agent、Harness、Loop：智能体开发核心概念与工程实践在智能体开发中，Agent、Harness、Loop 是三个基础且高频的概念。Agent 作为决策核心，负责根据状态选择动作；Harness 提供工程化支撑，包括工具管理、权限控制与可观测性；Loop 则控制执行节奏，确保任务逐步推进。理解这三者的原理与配合，能显著提升智能体系统的可控性与稳定性。它们广泛应用于自动化任务、数据分析、API 编排等场景，是构建生产级智能体的关键。本文深入拆解这三个概念，分享实际开发中的经验与避坑指南。阅读详情

1. 引言

在构建复杂 AI Agent 系统的过程中，我们经常会遇到三个高频词汇：Harness（框架/套件）、Loop（循环） 和 ReAct（推理与行动）。它们看似独立，实则层层嵌套、互为支撑。本文将从概念出发，梳理三者之间的内在联系，帮助你在设计 Agent 时做出更清晰的架构决策。

2. 三个概念的核心定义

2.1 Harness：Agent 的"运行容器"

Harness 是承载 Agent 运行的最小骨架，它定义了：

输入输出协议：Agent 如何接收任务、如何返回结果；
工具调用接口：Agent 如何调用外部工具（搜索、计算、代码执行等）；
状态管理：Agent 运行过程中的上下文如何保存与传递；
终止条件：何时停止循环、何时判定任务完成。

一句话总结：Harness 是"壳"，它规定了 Agent 怎么跑起来、跑多久、跑到哪算完。

2.2 Loop：Agent 的"迭代引擎"

Loop 是 Agent 反复执行"思考 → 行动 → 观察"的循环过程。它通常包含四个阶段：

感知：获取当前状态或外部反馈；
决策：根据当前状态决定下一步动作；
执行：调用工具或执行代码；
评估：判断是否达成目标，未达成则回到第 1 步。

一句话总结：Loop 是"引擎"，它驱动 Agent 不断迭代，直到任务收敛。

2.3 ReAct：一种具体的"推理-行动"模式

ReAct（Reasoning + Acting）是一种将推理轨迹与行动轨迹交织在一起的 Agent 模式。它的核心思想是：

推理（Reasoning）：用自然语言描述当前思考过程；
行动（Acting）：基于推理结果调用工具；
观察（Observation）：获取工具返回结果，再进入下一轮推理。

一句话总结：ReAct 是"驾驶策略"，它决定了 Agent 在每一轮循环中如何思考、如何行动。

3. 三者之间的关系：层层嵌套

3.1 从抽象到具体

Harness（容器）
 └── 内部运行一个或多个 Loop（迭代引擎）
      └── 每个 Loop 采用某种策略（如 ReAct）驱动

Harness 是最外层：它定义了 Agent 的整体运行框架；
Loop 是中间层：它在 Harness 内部反复执行；
ReAct 是最内层：它规定了 Loop 每一轮的具体行为方式。

3.2 一个类比：工厂流水线

概念	类比	职责
Harness	工厂厂房	提供场地、水电、安全规范
Loop	流水线传送带	让工件不断流转、反复加工
ReAct	工人的操作手册	规定每一步怎么思考、怎么动手

3.3 代码层面的对应关系

# Harness：定义 Agent 的整体运行框架
class Harness:
    def __init__(self, loop, max_iterations=10):
        self.loop = loop
        self.max_iterations = max_iterations

    def run(self, task):
        return self.loop.execute(task, max_iterations=self.max_iterations)

# Loop：驱动迭代执行
class Loop:
    def __init__(self, strategy):
        self.strategy = strategy  # 可以是 ReAct、Plan-and-Execute 等

    def execute(self, task, max_iterations):
        for i in range(max_iterations):
            result = self.strategy.step(task)
            if result.is_done:
                return result
        return Result(success=False, error="Max iterations exceeded")

# ReAct：具体的推理-行动策略
class ReActStrategy:
    def step(self, task):
        thought = self.think(task)      # 推理
        action = self.act(thought)      # 行动
        observation = self.observe(action)  # 观察
        return self.evaluate(observation)

4. 三者在实际框架中的体现

4.1 LangChain 中的对应关系

Harness：AgentExecutor 是运行容器，负责管理 Agent 与工具的交互；
Loop：AgentExecutor 内部有一个 while 循环，反复调用 Agent 直到输出最终答案或达到 max_iterations；
ReAct：create_react_agent 创建的正是 ReAct 模式的 Agent，它使用 hwchase17/react 提示词模板驱动推理与行动。

from langchain.agents import AgentExecutor, create_react_agent

# Harness + Loop + ReAct 三者合一
agent = create_react_agent(llm, tools, prompt)  # ReAct 策略
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=8,  # Loop 的终止条件
    verbose=True
)

4.2 LangGraph 中的对应关系

Harness：StateGraph 是运行容器，定义了节点和边的流转；
Loop：图中的条件边（conditional edges）实现循环，例如"审阅不通过则回到写作节点"；
ReAct：图中的每个节点可以是一个 ReAct 步骤，也可以整体作为一个 ReAct Agent 节点。

4.3 LlamaIndex 中的对应关系

Harness：QueryEngine / ChatEngine 是运行容器；
Loop：Refine 响应模式会多次调用 LLM 逐步精炼答案，形成一个小型循环；
ReAct：LlamaIndex 的 ReActAgent 直接实现了 ReAct 模式，用于工具调用型 Agent。

5. 三种架构的对比与选型

维度	Harness	Loop	ReAct
抽象层级	最高	中间	最低
关注点	整体框架、协议、边界	迭代过程、终止条件	单步推理与行动策略
可变性	相对固定	可配置（迭代次数、反馈来源）	可替换（ReAct / Plan-and-Execute / Reflexion）
典型问题	“Agent 怎么跑起来？”	“跑几轮？怎么判断结束？”	“每一步怎么思考？”

选型建议

需要稳定的任务执行框架 → 先设计好 Harness；
需要反复迭代直到成功 → 配置合适的 Loop（如 CI 驱动的修复循环）；
需要灵活的工具调用与推理 → 采用 ReAct 模式；
需要先规划后执行、路径稳定 → 采用 Plan-and-Execute 模式（Loop 的另一种策略）。

6. 三者协同的完整示例

以下是一个"AI 修复代码 Bug"的完整流程，展示三者如何协同：

class BugFixHarness:
    """Harness：整体运行框架"""
    def __init__(self, loop):
        self.loop = loop

    def run(self, issue):
        result = self.loop.execute(issue)
        if result.success:
            self.submit_pr(result.patch)
        return result

class BugFixLoop:
    """Loop：迭代引擎，由 CI 反馈驱动"""
    def __init__(self, strategy, max_iterations=5):
        self.strategy = strategy
        self.max_iterations = max_iterations

    def execute(self, issue):
        for i in range(self.max_iterations):
            patch = self.strategy.generate_patch(issue)
            ci_status = self.run_ci(patch)
            if ci_status == "green":
                return Result(success=True, patch=patch)
        return Result(success=False, error="CI 始终未通过")

class ReActBugFixer:
    """ReAct：单步推理-行动策略"""
    def generate_patch(self, issue):
        thought = self.analyze(issue)       # 推理：分析 Bug 原因
        action = self.read_code(thought)    # 行动：读取相关代码
        observation = self.observe(action)  # 观察：理解代码逻辑
        return self.write_patch(observation) # 行动：生成修复补丁