面试官灵魂拷问：Agent三大范式ReAct/Plan-and-Execute/Reflection 怎么选？

Han619

401人浏览 · 2026-03-21 18:18:39

Han619 · 2026-03-21 18:18:39 发布

面试被问Agent范式只会背概念？项目里不知道选ReAct还是Plan-and-Execute？这篇一次性讲透三大范式核心逻辑+落地代码+场景选型，从原理到实战一步到位，看完直接用在面试和开发里！

先理清2个核心概念

在开始三大范式之前，先搞懂两个贯穿始终的关键词：

设计范式：Agent的顶层执行流程，相当于「做事的总框架」，决定整体怎么跑。
推理模式：Agent每一步的思考决策逻辑，相当于「单步怎么干活」。

三大范式，就是三种不同的框架+决策组合，也是Agent开发最核心的三种架构。

一、基础范式：ReAct 边想边干（单步迭代）

核心原理

ReAct是所有Agent的基础原型，逻辑闭环：

思考(Reason) → 行动(Action) → 观察(Observe) → 再思考

没有提前规划，边规划边执行，完全根据上一步结果实时调整，灵活度拉满。

核心特点

✅ 优点：实现简单、灵活应变、调试方便、新手零门槛
❌ 缺点：长流程易跑偏、容易忘记初始目标、复杂任务效率低

适用场景

简单/中等任务、实时决策场景、单轮工具调用、入门级Agent

（如：信息查询、简易问答、单次工具执行）

💡 生活化例子：新手煮番茄鸡蛋面：

思考：想吃番茄鸡蛋面，需先确认家里食材是否可用。
行动：打开冰箱查看番茄、鸡蛋、面条状态。
观察：番茄新鲜、鸡蛋未过期，面条够吃，无葱花（可省略）。
再思考：无需采购，下一步洗番茄、打鸡蛋、烧水下面。
再行动：洗切番茄、打鸡蛋，烧水煮面。
再观察：面条粘连、番茄块偏大。
再思考：搅拌面条、切小番茄，面条半熟时加番茄鸡蛋调味。
再行动：调整操作并调味，观察到食材熟透、味道适中后关火盛出。

整个过程无提前计划，完全边想边干，根据上一步观察结果（如面条粘连）实时调整行动，完美契合ReAct「思考→行动→观察→再思考」的闭环，凸显其灵活应变的核心特点。

🔧 实战代码示例（LangChain实现）

基于Python+LangChain，实现最经典的ReAct Agent，支持工具调用（可直接复制运行）：

# 安装依赖：pip install langchain openai python-dotenv
from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import DuckDuckGoSearchRun
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv

# 加载环境变量（需在.env文件中配置OPENAI_API_KEY）
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# 1. 初始化大模型（指定API_KEY，避免报错）
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, api_key=api_key)

# 2. 定义工具（以 DuckDuckGo 搜索为例，可替换为自己的工具）
search_tool = DuckDuckGoSearchRun()
tools = [search_tool]  # 可添加多个工具，如文件读取、代码执行等

# 3. ReAct标准提示词模板（明确流程，引导Agent按思考→行动→观察执行）
react_prompt = PromptTemplate.from_template("""
你是一个智能助手，严格按照 思考→行动→观察 的流程执行用户任务，不要跳过任何步骤。
可用工具：{tools}
工具名称及使用说明：{tool_names}
用户问题：{input}
思考：你需要先分析问题，判断是否需要使用工具，以及使用哪个工具，{agent_scratchpad}
行动：如果需要使用工具，格式为 `工具名称(参数)`；如果不需要工具，直接输出最终答案。
观察：执行工具后，根据返回结果，再次思考是否需要继续执行或直接输出答案。
""")

# 4. 创建ReAct Agent，配置执行器（verbose=True，可查看完整执行流程，方便调试）
react_agent = create_react_agent(llm, tools, react_prompt)
agent_executor = AgentExecutor(agent=react_agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 5. 执行任务（可替换为自己的需求）
if __name__ == "__main__":
    try:
        response = agent_executor.invoke({"input": "2026年人工智能Agent技术的最新发展方向，重点说明工业领域的应用"})
        print("\n🏁 最终结果：", response["output"])
    except Exception as e:
        print(f"执行报错：{e}")

💡 代码说明：配置.env文件（写入OPENAI_API_KEY=你的密钥），运行后可看到Agent「思考→搜索→观察→总结」的完整流程，新手可直接复用，替换工具和任务即可。

二、进阶范式：Plan-and-Execute 先规划后执行

核心原理

为解决ReAct长任务跑偏的痛点设计，核心是规划与执行解耦，分为两个独立模块：

规划器（Planner）：先把大目标拆成完整、可执行的步骤清单，明确每一步要做什么。
执行器（Executor）：严格按步骤逐一执行，执行完成后汇总所有结果，生成最终答案。

全程不随意改计划，复杂任务稳定性拉满，适合需要严格控方向的场景。

核心特点

✅ 优点：长流程不跑偏、目标明确、可控性强、支持并行执行
❌ 缺点：灵活度低、突发场景易卡壳、实现复杂度比ReAct高

适用场景

长流程复杂任务、流程固定场景、多步骤数据分析、报告生成、项目式任务

（如：行业分析报告、多步骤数据处理、完整项目开发规划）

💡 生活化例子：周末家庭大扫除：

规划（规划器）：目标是彻底打扫客厅，提前拆分3步：擦桌面、拖地板、整理杂物。
执行（执行器）：严格按规划执行，先擦桌面，再拖地板，最后整理杂物，不随意调整步骤。

全程先定好完整计划，再分步执行，规划与执行完全分离，不临时打乱节奏，完美契合其核心特点。

🔧 实战代码示例（规划+执行分离）

基于LangChain实现规划与执行分离，可直接复用，支持自定义目标和步骤：

from langchain.chains import LLMChain
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# 初始化大模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, api_key=api_key)

# ---------------------- 1. 规划器模块：生成可执行步骤 ----------------------
# 提示词优化：让步骤更具体，可直接执行，避免模糊表述
plan_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是专业的任务规划师，擅长将复杂目标拆分成3-5个具体、可执行的步骤，步骤需明确「做什么」「怎么做」，不冗余、不模糊，只输出步骤，不执行任何步骤。"),
    ("user", "目标：{goal}，请拆分成3-5个可执行步骤，每个步骤不超过20字，清晰易懂。")
])
plan_chain = LLMChain(llm=llm, prompt=plan_prompt)

# ---------------------- 2. 执行器模块：按步骤执行 ----------------------
execute_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是高效执行者，严格按照给定步骤执行任务，执行过程简洁明了，返回该步骤的具体执行结果，不添加额外说明。"),
    ("user", "步骤：{step}，请严格执行该步骤，返回执行结果。")
])
execute_chain = LLMChain(llm=llm, prompt=execute_prompt)

# ---------------------- 3. 总执行逻辑（规划→执行→汇总） ----------------------
def plan_and_execute(goal):
    # 第一步：生成规划
    plan = plan_chain.invoke({"goal": goal})
    print("📝 生成任务规划：\n", plan["text"])
    print("-"*50)
    
    # 第二步：分步执行（过滤空步骤，避免报错）
    steps = [step.strip() for step in plan["text"].split("\n") if step.strip()]
    result = []
    for idx, step in enumerate(steps, 1):
        print(f"✅ 执行步骤{idx}：{step}")
        step_res = execute_chain.invoke({"step": step})
        result.append(f"步骤{idx}：{step}\n执行结果：{step_res['text']}")
        print(f"步骤{idx}结果：{step_res['text']}\n")
    
    # 第三步：汇总所有步骤结果，生成最终答案
    final_prompt = f"请汇总以下步骤的执行结果，输出完整、连贯的最终答案，不要遗漏关键信息：\n{chr(10).join(result)}"
    final_res = llm.invoke(final_prompt)
    return final_res.content

# 执行复杂任务（可替换为自己的目标）
if __name__ == "__main__":
    try:
        goal = "写一篇2026年Agent技术的行业分析报告，重点包含核心应用场景和发展趋势"
        final_output = plan_and_execute(goal)
        print("🏁 最终汇总结果：\n", final_output)
    except Exception as e:
        print(f"执行报错：{e}")

💡 代码说明：规划器生成清晰步骤，执行器逐一落地，最后自动汇总，适合复杂任务；可修改提示词，调整步骤数量和执行细节，适配自己的项目需求。

三、增强范式：Reflection （反思迭代）

核心原理

Reflection不是独立范式！ 它是叠加在ReAct/Plan-and-Execute上的质量增强模块，核心逻辑闭环：

生成结果 → 评估检查 → 修正优化 → 输出最终结果

专门解决Agent输出的「幻觉、事实错误、逻辑漏洞」，把「做完任务」升级成「做好任务」，相当于给Agent加了一个「自我检查」的功能。

核心特点

✅ 优点：大幅提升输出质量、减少错误、严谨性拉满，适配高要求场景
❌ 缺点：增加LLM调用次数、token消耗更高、需限制最大迭代次数，避免死循环

适用场景

高严谨性场景：生产代码、商业报告、法律文书、精准数据分析、面试答题等

💡 搭配方式：ReAct+Reflection（步骤级检查）、Plan-and-Execute+Reflection（任务级检查）

💡 生活化例子（ReAct+Reflection全过程）：学生写一篇短文

ReAct环节（边想边干）：思考要写短文，先写开头→行动写开头→观察开头偏生硬、无重点→再思考调整开头，补充核心观点→行动修改开头、写正文。
Reflection环节（反思纠错）：写完后反思→检查出正文有语病、逻辑不连贯→行动修正语病、梳理逻辑→再次检查无问题，完成短文。

全程先按ReAct边想边干完成初稿，再用Reflection反思纠错，完美体现两者叠加的核心逻辑。

🔧 实战代码示例（ReAct+Reflection叠加）

在ReAct基础上叠加反思模块，实现「生成→检查→优化」的闭环，提升输出准确性：

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# 初始化大模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, api_key=api_key)

# ---------------------- 1. 基础生成（ReAct核心逻辑，简化版） ----------------------
def generate_answer(query):
    """基于ReAct逻辑，生成初始回答"""
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是智能助手，按照ReAct逻辑回答问题：先思考问题，再给出详细、准确的答案，不遗漏关键信息。"),
        ("user", "回答问题：{query}")
    ])
    chain = prompt | llm
    return chain.invoke({"query": query}).content

# ---------------------- 2. 反思检查模块（核心：找出错误，给出修改意见） ----------------------
def reflection_check(answer, query):
    """检查初始回答的错误、幻觉、逻辑漏洞，给出具体修改意见"""
    check_prompt = ChatPromptTemplate.from_messages([
        ("system", "你是严格的审核员，负责检查回答的准确性、完整性和逻辑性，重点关注以下3点：1. 是否有事实错误/幻觉；2. 逻辑是否连贯；3. 是否遗漏关键信息。请先指出错误，再给出具体修改意见，不要直接修改答案。"),
        ("user", "问题：{query}\n当前回答：{answer}\n请严格检查，指出错误并给出修改意见。")
    ])
    chain = check_prompt | llm
    return chain.invoke({"answer": answer, "query": query}).content

# ---------------------- 3. 反思迭代总流程（控制迭代次数，避免死循环） ----------------------
def react_with_reflection(query, max_iter=2):
    """ReAct+Reflection 叠加逻辑，最多迭代2次，平衡质量和效率"""
    # 初始生成（ReAct逻辑）
    answer = generate_answer(query)
    print("📄 初始回答：\n", answer, "\n")
    
    # 迭代反思修正
    for i in range(max_iter):
        print(f"🔍 第{i+1}次反思检查...")
        feedback = reflection_check(answer, query)
        print("反思意见：\n", feedback, "\n")
        
        # 判断是否需要继续优化（如果没有错误，直接退出迭代）
        if "无错误" in feedback or "无需修改" in feedback:
            print("✅ 回答无错误，停止迭代。")
            break
        
        # 根据反思意见，优化回答
        optimize_prompt = ChatPromptTemplate.from_messages([
            ("system", "基于反思意见，修改初始回答，修正所有错误，保持逻辑连贯，不添加额外冗余内容。"),
            ("user", "反思意见：{feedback}\n原回答：{answer}\n请修改原回答，输出优化后的版本。")
        ])
        optimize_chain = optimize_prompt | llm
        answer = optimize_chain.invoke({"feedback": feedback, "answer": answer}).content
        print(f"✅ 第{i+1}次优化后回答：\n", answer, "\n")
    
    return answer

# 执行高要求任务（可替换为自己的需求，如面试答题、代码解释等）
if __name__ == "__main__":
    try:
        query = "详细解释Agent的Plan-and-Execute范式的原理与工程实现，要求准确、无错误，重点说明规划器和执行器的核心作用"
        final_result = react_with_reflection(query)
        print("🏁 最终优化结果：\n", final_result)
    except Exception as e:
        print(f"执行报错：{e}")

💡 代码说明：可调整max_iter（最大迭代次数），迭代次数越多，输出越严谨，但token消耗越高；适合对输出质量要求高的场景，如面试答题、生产级代码注释等。

三大范式核心对比（一张表看懂）

对比维度	ReAct	Plan-and-Execute	Reflection
核心逻辑	边想边干，单步迭代	先规划，后执行（解耦）	生成→评估→修正，质量增强
规划与执行	耦合（一起做）	解耦（分开做）	叠加其他范式使用，不改变原有关系
灵活度	极高	低	不改变原有范式的灵活度
长任务稳定性	差，易跑偏、忘目标	极高，不偏离目标	提升原有范式的稳定性
实现难度	低，新手友好	中等，需拆分模块	低（直接叠加，无需修改原有逻辑）
核心价值	快速完成灵活、简单任务	复杂、长流程任务稳定落地	纠错提效，杜绝幻觉，提升输出质量
Token消耗	低	中	高（多轮LLM调用）