AI Agent 架构设计模式全景：ReAct、Plan-Execute 与 Multi-Agent 深度对比

1. 引言：什么是 AI Agent，为什么架构模式很重要

AI Agent 是指能够感知环境、自主决策并执行动作来达成目标的智能系统。一个典型的 Agent 由四个核心组件构成：

架构模式是串联这些组件的"骨架"。一个糟糕的架构会导致 Agent 陷入无限循环、遗忘上下文、或做出前后矛盾的决策。选择正确的架构模式，是用好 AI Agent 的第一步。

2. ReAct 模式（Reasoning + Acting）

2.1 原理概述

ReAct（Reasoning + Acting）由 Google 在 2022 年提出，核心思想是将推理（Thought）和行动（Action）交替进行。Agent 每次只思考当前应该做什么，然后立即执行，再根据观察结果继续思考下一步。

这种"思考—行动—观察"的循环模式模拟了人类处理问题时的直觉反应过程，非常适合那些需要逐步推理、依赖中间反馈的任务。

2.2 Python + LangChain 代码示例

PYTHON
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

# 定义工具
@tool
def search(query: str) -> str:
    """在知识库中搜索信息"""
    knowledge_base = {
        "北京": "北京市，中国的首都，人口约2188万",
        "上海": "上海市，中国最大的城市，人口约2487万",
        "深圳": "深圳市，中国科技中心，人口约1756万",
    }
    return knowledge_base.get(query, f"未找到关于 {query} 的信息")

@tool
def calculator(expression: str) -> str:
    """执行数学计算"""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"计算错误: {e}"

@tool
def text_summarizer(text: str) -> str:
    """对文本进行摘要"""
    return f"摘要结果（原文{len(text)}字）: {text[:100]}..."

# 初始化 LLM 和工具
llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key="your-api-key")
tools = [search, calculator, text_summarizer]

# ReAct Prompt 模板
react_prompt = PromptTemplate.from_template("""
你是一个智能助手，请按以下格式逐步解决问题：

可用工具: {tools}

工具名称: {tool_names}

格式说明:
Question: 用户提出的问题
Thought: 你应该思考该做什么
Action: 要采取的行动，格式为 [{tool_names}] 其中之一
Action Input: 行动的输入
Observation: 行动的结果
... (Thought/Action/Action Input/Observation 可以重复多次)
Thought: 我现在知道最终答案了
Final Answer: 对原始问题的最终回答

开始！

Question: {input}
Thought: {agent_scratchpad}
""")

# 创建 ReAct Agent
agent = create_react_agent(llm=llm, tools=tools, prompt=react_prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=6,
    handle_parsing_errors=True,
)

# 执行任务
result = agent_executor.invoke({
    "input": "北京比深圳多多少人口？请用计算器帮我算出来。"
})
print(f"最终结果: {result['output']}")

2.3 适用场景与局限

适用场景：

局限性：

3. Plan-Execute 模式

3.1 原理概述

Plan-Execute 模式将任务处理分为两个明确阶段：

这种模式借鉴了经典 AI 中的 STRIPS 规划思想，更适合处理复杂、多步骤的长期任务。

3.2 代码示例

PYTHON
from langchain.agents import load_tools
from langchain_openai import ChatOpenAI
from langchain_experimental.plan_and_execute import (
    PlanAndExecute,
    load_agent_executor,
    load_chat_planner,
)

# 初始化 LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key="your-api-key")

# 加载工具
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# 创建规划器
planner = load_chat_planner(llm)

# 创建执行器
executor = load_agent_executor(llm, tools, verbose=True)

# 创建 Plan-Execute Agent
agent = PlanAndExecute(
    planner=planner,
    executor=executor,
    verbose=True,
    max_steps=10,
)

# 执行复杂任务
result = agent.invoke({
    "input": "帮我做三件事：1) 查询今天的重大新闻标题；"
             "2) 计算深圳和北京的人口总数之和；"
             "3) 用一句话总结这三件事的关键信息。"
})
print(f"最终结果:\n{result['output']}")

3.3 适用场景与局限

适用场景：

局限性：

4. Multi-Agent 协作模式

4.1 原理概述

Multi-Agent 模式借鉴了分布式系统的思想：将不同职责分配给多个专门的 Agent，通过协作完成复杂任务。典型的角色分工包括：

LangGraph（LangChain 的图编排框架）是实现 Multi-Agent 模式的主流选择，它通过有向图定义 Agent 之间的消息流转和状态管理。

4.2 LangGraph 代码示例

PYTHON
import operator
from typing import Annotated, TypedDict
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import create_react_agent
from langchain.tools import tool

# 定义全局状态
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]  # 消息累加器
    next_agent: str  # 下一个要调用的 Agent

@tool
def web_search(query: str) -> str:
    """互联网搜索工具"""
    return f"[搜索结果] 关于 '{query}' 的重要信息..."

@tool
def python_executor(code: str) -> str:
    """执行 Python 代码"""
    try:
        result = eval(code)
        return f"执行成功，结果: {result}"
    except Exception as e:
        return f"执行失败: {e}"

# 初始化 LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key="your-api-key")

# 创建专业化 Agent
research_agent = create_react_agent(
    llm, [web_search],
    state_modifier="你是一个专业的研究员，负责搜索和分析信息。"
)

code_agent = create_react_agent(
    llm, [python_executor],
    state_modifier="你是一个高级程序员，负责编写和执行代码。"
)

# 定义 Supervisor 决策逻辑
def supervisor_node(state: AgentState):
    """根据上下文决定下一个 Agent"""
    last_message = state["messages"][-1] if state["messages"] else ""

    # 简单的路由逻辑（生产环境建议使用 LLM 路由）
    if "搜索" in str(last_message) or "查询" in str(last_message):
        return {"next_agent": "research"}
    elif "代码" in str(last_message) or "计算" in str(last_message):
        return {"next_agent": "code"}
    else:
        return {"next_agent": "end"}

# 构建图
workflow = StateGraph(AgentState)

workflow.add_node("supervisor", supervisor_node)
workflow.add_node("research", research_agent)
workflow.add_node("code", code_agent)

# 定义边和条件路由
workflow.set_entry_point("supervisor")
workflow.add_conditional_edges(
    "supervisor",
    lambda s: s["next_agent"],
    {
        "research": "research",
        "code": "code",
        "end": END,
    },
)
workflow.add_edge("research", "supervisor")
workflow.add_edge("code", "supervisor")

# 编译运行
app = workflow.compile()

result = app.invoke({
    "messages": [{"role": "user", "content": "搜索深圳GDP数据，然后用代码计算增长率"}]
})
print(f"最终结果: {result['messages']}")

4.3 适用场景与局限

适用场景：

局限性：

5. 三种模式横向对比

6. 选型指南

在实际项目中，你可以按照以下决策树进行选型：

任务复杂度评估
│
├─ 单步任务 / 对话式交互
│   └─ 选择 ReAct 模式
│       优势：响应快、实现简单、调试方便
│
├─ 多步任务 / 有明确依赖关系
│   └─ 选择 Plan-Execute 模式
│       优势：结构化执行、透明可控
│
└─ 多领域复杂任务 / 需要并行处理
    └─ 选择 Multi-Agent 模式
        优势：专业化分工、高可靠性、可扩展

加分考虑：
- 预算有限 → 优先 ReAct（Token 消耗最少）
- 需要企业级可靠性 → Multi-Agent
- 快速原型验证 → ReAct
- 需要审计追踪 → Plan-Execute

实际操作中，这三种模式并非互斥。许多生产系统会采用混合架构：例如用 Multi-Agent 作为顶层编排，其中每个 Worker Agent 内部使用 ReAct 模式；或在 Plan-Execute 的每个执行步骤中嵌入 ReAct 循环来处理不确定性。

7. 未来展望

AI Agent 架构正朝着以下几个方向快速演进：

8. 总结

架构模式是手段，不是目的。选择时应当回归本质：你的任务需要什么样的智能组织形式？ 理解每种模式的内核，在实践中灵活组合，才能真正构建出高效、可靠的 AI Agent 系统。

参考资料

本文撰写于 2026 年 6 月，技术栈版本参考：LangChain ≥ 0.3.x, LangGraph ≥ 0.2.x, OpenAI API ≥ 1.x。代码示例为教学目的简化，生产环境请结合自身需求调整。