Agent三大范式详解：ReAct、Plan-and-Execute、Reflection

目录

一、什么是Agent范式

Agent范式，本质上是：

🤖 大模型如何“思考 + 行动”的策略设计

不同范式，决定了：

  • 如何拆解任务
  • 是否调用工具
  • 是否自我纠错

二、ReAct范式

2.1 核心思想

👉 Reason（推理） + Act（行动）循环执行

模型边思考边调用工具：

1
Thought → Action → Observation → Thought → ...

2.2 架构图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌─────────────┐
│   User Query │
└──────┬──────┘
       ↓
┌─────────────┐
│   Thought    │ 🧠
└──────┬──────┘
       ↓
┌─────────────┐
│   Action     │ 🔧（调用工具）
└──────┬──────┘
       ↓
┌─────────────┐
│ Observation  │ 👀
└──────┬──────┘
       ↓
     循环...

2.3 代码实现（简化版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class ReActAgent:

    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools

    def run(self, query):
        context = query
        
        while True:
            # 1. 思考
            thought = self.llm.generate(f"Thought: {context}")
            
            # 2. 判断是否结束
            if "Final Answer" in thought:
                return thought
            
            # 3. 选择工具
            action = self.llm.generate(f"Action: {thought}")
            
            # 4. 执行工具
            result = self.tools.call(action)
            
            # 5. 反馈结果
            context += f"\nObservation: {result}"

2.4 面试要点

  • 本质：动态决策系统
  • 核心能力：工具调用
  • 缺点：不稳定、成本高

三、Plan-and-Execute范式

3.1 核心思想

👉 先规划 → 再执行

3.2 架构图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌─────────────┐
│   User Query │
└──────┬──────┘
       ↓
┌─────────────┐
│   Planner    │ 🧠（生成计划）
└──────┬──────┘
       ↓
┌─────────────┐
│   Executor   │ ⚙️（逐步执行）
└──────┬──────┘
       ↓
┌─────────────┐
│ Final Answer │
└─────────────┘

3.3 代码实现（简化版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class PlanExecuteAgent:

    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools

    def run(self, query):
        # 1. 生成计划
        plan = self.llm.generate(f"Create a step-by-step plan: {query}")
        
        steps = plan.split("\n")
        results = []

        # 2. 执行计划
        for step in steps:
            result = self.tools.call(step)
            results.append(result)

        # 3. 汇总结果
        return self.llm.generate(f"Summarize: {results}")

3.4 面试要点

  • 本质：任务分解系统
  • 优点：稳定、可控
  • 缺点：计划错误会影响全局

四、Reflection范式

4.1 核心思想

👉 生成 → 评估 → 修正

4.2 架构图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌─────────────┐
│ Initial Answer│
└──────┬──────┘
       ↓
┌─────────────┐
│ Reflection   │ 🔍（自我评估）
└──────┬──────┘
       ↓
┌─────────────┐
│ Improvement  │ 🔧（优化）
└──────┬──────┘
       ↓
┌─────────────┐
│ Final Answer │
└─────────────┘

4.3 代码实现（简化版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class ReflectionAgent:

    def __init__(self, llm):
        self.llm = llm

    def run(self, query):
        # 1. 初始答案
        answer = self.llm.generate(query)

        # 2. 反思
        critique = self.llm.generate(
            f"Critique the following answer:\n{answer}"
        )

        # 3. 优化
        improved = self.llm.generate(
            f"Improve answer based on critique:\n{critique}"
        )

        return improved

4.4 面试要点

  • 本质：自我纠错系统
  • 优点：质量高
  • 缺点：成本高、延迟大

五、三种范式对比（面试重点）

维度 ReAct Plan-Execute Reflection
思考方式 边想边做 先规划 事后反思
灵活性 ⭐⭐⭐⭐ ⭐⭐ ⭐⭐⭐
稳定性 ⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐⭐
成本 高 中 很高
是否可纠错 ❌ ❌ ✅

六、工业级Agent架构（进阶）

现实系统通常不会单独使用某一种范式，而是组合：

1
Plan → ReAct → Reflection

执行流程：

  1. Planner：拆解任务
  2. ReAct：执行复杂步骤（调用工具）
  3. Reflection：优化结果

实际例子（面试加分）

1
2
3
4
5
比如一个AI写论文Agent：

* Plan：生成论文大纲
* ReAct：查资料 + 写内容
* Reflection：润色 + 校对

七、总结

1
2
3
ReAct：边想边做（灵活，但不稳定），偏“执行策略”
Plan-Execute：先想后做（稳定，但不灵活），偏“任务拆解”
Reflection：做完再想（质量高，但成本高），偏“结果优化”

🎯 标准面试回答（精简有逻辑版）

Agent开发主要有三种常见范式：ReAct、Plan-and-Execute 和 Reflection。

第一，ReAct范式，核心是“推理+行动”交替进行，模型在执行过程中边思考边调用工具，适合处理动态、多步骤任务，但缺点是成本高、稳定性较差。

第二，Plan-and-Execute范式，是先生成完整计划再逐步执行，优点是结构清晰、可控性强，但如果计划出错会影响整体效果，灵活性较低。

第三，Reflection范式，是在生成结果后进行自我评估和优化，相当于引入了一个“自我纠错”机制，能够显著提升结果质量，但代价是推理成本更高。

实际工业中，通常会将三者结合使用，比如先用Plan拆解任务，用ReAct执行复杂步骤，最后用Reflection优化结果，从而在效率、稳定性和质量之间取得平衡。