AI开发范式的变革：从Prompt Engineering到Agent Engineering的能力迁移-酒店常州论坛

AI开发范式的变革：从Prompt Engineering到Agent Engineering的能力迁移

一、Prompt Engineering的黄金时代正在落幕

2023-2024年，Prompt Engineering是整个AI领域"最年轻的高薪技能"。从业者通过精准控制几百个Token的提示词来引导大模型的输出，涌现出一整套工程化方法论：少样本提示、思维链、自一致性、树状搜索。当时的核心假设是"模型能力是固定的，而Prompt是杠杆"——一个精巧的Prompt可以挖掘出模型本身没有被训练体现的能力。

但这个假设在2025-2026年加速失效。原因不在于Prompt Engineering的技巧退化了，而在于模型的能力进化使得"与模型对话"的复杂度本身成为了瓶颈。当GPT-4o或Claude 4已经能理解极其简洁的指令时，过度设计的Prompt反而成为了噪音。更重要的是，真正有价值的AI应用不再局限于"一问一答"的对话模式，而是要求模型能够在多步骤推理、工具调用、状态管理和自主决策之间无缝切换——这些是Prompt Engineering的范式边界之外的领域。

范式迁移的本质在于：开发者的核心技能从"如何与模型交流"转向"如何设计模型与环境之间的交互协议"。正如软件工程从"写函数"演进到"设计系统"，AI开发正在从"写Prompt"演进到"设计Agent"。

二、从单一对话到多步骤自主推理：Agent Engineering的能力堆栈

理解两种范式的差异，不能停留在概念层面。下图对比了Prompt Engineering和Agent Engineering在技术堆栈上的根本性差异：

Prompt Engineering是线性管道：输入→推理→输出。流程完全由开发者预先定义，模型的"推理"是一次性的，不涉及状态管理、不调用外部工具、不具备自我纠错能力。

Agent Engineering是多步骤循环：意图理解→规划→执行→观察→调整→继续执行。这个循环的突破性在于"模型可以在执行过程中重新规划"——当工具调用返回意外结果时，Agent可以动态调整后续策略，而非按照预定的步骤硬走下去。

能力堆栈的五个核心层次

意图分解：将用户的自然语言请求转化为结构化的任务序列。例如"帮我分析Q2销售数据并生成PPT"，在Prompt范式下是一个请求；在Agent范式下需要拆解为"连接数据库获取原始数据→计算同比环比→识别关键洞察→生成图表→组装PPT→发送预览确认"六个子任务。
动态规划：基于当前状态决定下一步行动，而非遵循预定义的流程。规划器需要权衡"继续当前路径"和"换一种方法重试"两种策略——本质上是一个探索-利用平衡问题。
工具编排：管理可用工具的调用节奏、参数传递和结果合并。当一个Agent同时拥有数据库查询、代码执行、文件操作三种能力时，编排器需要判断"什么时候查询数据库、什么时候执行代码、什么时候操作文件"。
记忆管理：在短期对话历史和长期知识库之间建立索引机制。Agent需要记住"当前任务的上下文"（短期）和"用户偏好/历史操作/领域知识"（长期）两种不同类型的信息。
自主循环：将以上四个层次串联成持续运行的ReAct（Reasoning + Acting）循环，直到目标达成或达到最大迭代次数。

三、Agent Engineering的核心骨架：ReAct循环的生产级实现

以下代码展示了从Prompt Engineering到Agent Engineering的技术跃迁——不是"废除Prompt"，而是在Prompt之上构件完整的Agent循环：

""" Agent Engineering核心实现：ReAct循环引擎 这不是"更好的Prompt"，而是在Prompt之上构建的完整自主推理框架 """ import json import uuid from abc import ABC, abstractmethod from dataclasses import dataclass, field from datetime import datetime, timezone from enum import Enum from typing import Any, Optional, Callable class AgentActionType(Enum): """Agent可执行的操作类型""" THINK = "think" # 内部推理 TOOL_CALL = "tool_call" # 调用外部工具 ASK_USER = "ask_user" # 向用户请求澄清 FINISH = "finish" # 完成任务 @dataclass class AgentStep: """Agent执行链路中的一个步骤""" step_id: str action_type: AgentActionType thought: str # Agent的推理过程 action: Optional[str] = None # 执行的工具名 action_input: Optional[dict] = None observation: Optional[str] = None # 工具执行后的观察结果 timestamp: str = field( default_factory=lambda: datetime.now(timezone.utc).isoformat() ) @dataclass class AgentMemory: """Agent的记忆系统：短期+长期""" # 短期记忆：当前会话的对话历史 steps: list[AgentStep] = field(default_factory=list) # 中期记忆：当前任务的上下文状态 task_state: dict[str, Any] = field(default_factory=dict) # 长期记忆指针（实际存储在外部的向量数据库） relevant_knowledge: list[str] = field(default_factory=list) def add_step(self, step: AgentStep) -> None: self.steps.append(step) # 防止上下文无限增长 if len(self.steps) > 20: self._compress_old_steps() def get_recent_context(self, n: int = 10) -> str: """获取最近N步的上下文摘要，用于LLM输入""" context_parts = [] for step in self.steps[-n:]: context_parts.append( f"[{step.action_type.value}] " f"思考: {step.thought[:200]}\n" f"行动: {step.action or '无'}\n" f"观察: {(step.observation or '无')[:200]}" ) return "\n---\n".join(context_parts) def _compress_old_steps(self) -> None: """压缩旧步骤：用摘要替代详细记录""" if len(self.steps) <= 20: return old_steps = self.steps[:-10] summary = f"[已压缩] 前{len(old_steps)}步的摘要：{old_steps[-1].thought[:100]}..." # 在实际系统中，这里会调用一个更小的模型做专门摘要 self.steps = self.steps[-10:] class ToolRegistry: """工具注册表：管理Agent可用的工具集""" def __init__(self): self._tools: dict[str, Callable] = {} self._descriptions: dict[str, str] = {} def register( self, name: str, func: Callable, description: str ) -> None: """注册一个工具""" self._tools[name] = func self._descriptions[name] = description def get_tools_description(self) -> str: """生成供LLM理解的工具描述""" return "\n".join( f"- {name}: {desc}" for name, desc in self._descriptions.items() ) async def execute( self, name: str, **kwargs: Any ) -> tuple[bool, str]: """执行工具并返回结果""" if name not in self._tools: return False, f"工具 '{name}' 不存在或未注册" try: result = await self._tools[name](**kwargs) return True, str(result) except Exception as e: return False, f"工具执行失败: {str(e)}" class ReActAgentEngine: """ ReAct循环引擎：Agent Engineering的核心调度器 与Prompt Engineering的本质区别： - PE：一次LLM调用 = 一次完整推理 - AE：多次LLM调用，每次只做一小步推理 """ def __init__( self, llm_call: Callable[[str], str], # LLM调用接口 tool_registry: ToolRegistry, max_iterations: int = 10, # 防止死循环 ): self.llm_call = llm_call self.tools = tool_registry self.max_iterations = max_iterations async def run( self, user_request: str, context: dict[str, Any] = None ) -> dict[str, Any]: """ 执行Agent循环 返回：最终结果 + 完整执行日志 """ memory = AgentMemory() if context: memory.task_state = context for iteration in range(self.max_iterations): # 构建ReAct提示词 prompt = self._build_react_prompt( user_request=user_request, memory=memory, iteration=iteration, ) # LLM推理：决定下一步做什么 llm_response = self.llm_call(prompt) action = self._parse_action(llm_response) if action is None: # LLM返回格式异常，重试一次 memory.add_step(AgentStep( step_id=str(uuid.uuid4()), action_type=AgentActionType.THINK, thought="LLM返回格式异常，需要重新推理", )) continue # === 执行Action === step = AgentStep( step_id=str(uuid.uuid4()), action_type=action["type"], thought=action.get("thought", ""), action=action.get("tool_name"), action_input=action.get("tool_input"), ) if action["type"] == AgentActionType.FINISH: step.observation = "任务完成" memory.add_step(step) return { "success": True, "result": action.get("final_answer", ""), "iterations": iteration + 1, "steps": [ { "thought": s.thought[:200], "action": s.action, "observation": s.observation, } for s in memory.steps ], } elif action["type"] == AgentActionType.TOOL_CALL: success, result = await self.tools.execute( action["tool_name"], **(action.get("tool_input", {})), ) step.observation = ( f"[成功] {result}" if success else f"[失败] {result}" ) elif action["type"] == AgentActionType.ASK_USER: step.observation = "等待用户反馈" memory.add_step(step) return { "success": False, "needs_clarification": True, "question": action.get("question", ""), "steps": [ {"thought": s.thought, "observation": s.observation} for s in memory.steps ], } memory.add_step(step) # 达到最大迭代次数仍未完成 return { "success": False, "error": f"超过最大迭代次数({self.max_iterations})", "last_state": memory.get_recent_context(5), } def _build_react_prompt( self, user_request: str, memory: AgentMemory, iteration: int, ) -> str: """构建ReAct标准提示词""" return f"""你是一个能够使用工具的自主Agent。 ## 用户请求 {user_request} ## 可用工具 {self.tools.get_tools_description()} ## 已执行的步骤 {memory.get_recent_context() or "（尚未执行任何步骤）"} ## 当前是第{iteration + 1}步 请按照以下JSON格式输出你的下一步决策： ```json {{ "thought": "你对当前状态的分析和推理", "action_type": "think|tool_call|ask_user|finish", "tool_name": "要调用的工具名（仅当action_type=tool_call）", "tool_input": {{"参数": "值"}}, "question": "需要向用户澄清的问题（仅当action_type=ask_user）", "final_answer": "最终回答内容（仅当action_type=finish）" }}

注意：

每次只执行一个动作
如果工具返回错误，分析原因并调整策略
在不确定时，先思考（think）再决定是否执行动作
"""
def _parse_action(self, llm_response: str) -> Optional[dict]:
"""解析LLM的JSON输出为结构化Action"""
try:
# 提取JSON块
if "json" in llm_response: start = llm_response.index("json") + 7
end = llm_response.index("", start) json_str = llm_response[start:end].strip() elif "" in llm_response:
start = llm_response.index("") + 3 end = llm_response.index("", start)
json_str = llm_response[start:end].strip()
else:
json_str = llm_response.strip()

data = json.loads(json_str)

action_type_map = {
"think": AgentActionType.THINK,
"tool_call": AgentActionType.TOOL_CALL,
"ask_user": AgentActionType.ASK_USER,
"finish": AgentActionType.FINISH,
}

action_type = action_type_map.get(
data.get("action_type", ""), AgentActionType.THINK
)

return {
"type": action_type,
"thought": data.get("thought", ""),
"tool_name": data.get("tool_name"),
"tool_input": data.get("tool_input", {}),
"question": data.get("question"),
"final_answer": data.get("final_answer"),
}
except (json.JSONDecodeError, ValueError, KeyError):
return None

这个实现中有几个关键的设计决策：**单步推理**（每次LLM调用只做一步决策而非生成完整方案）、**观察反馈闭环**（工具执行结果作为下一步推理的输入）、**迭代次数上限**（防止Agent在复杂问题上陷入死循环）。这三条原则构成了Agent Engineering区别于Prompt Engineering的技术骨架。 ## 四、范式迁移的能力断层与过渡策略 从Prompt Engineering到Agent Engineering的迁移不是平滑升级，而是一个存在"能力断层"的跨越。以下是三个主要的断层： **调试心智模型的重建。** 在Prompt范式中，调试方法是"调整Prompt再试一次"——反馈回路很短，通常几秒内就能看到效果。在Agent范式中，一个错误可能发生在第7步的工具调用中，而根因是第3步的意图分解错误。调试从"调参数"变成了"系统级的因果链分析"，需要建立全新的追溯工具和日志体系。 **成本模型的非线性增长。** 一个典型的Agent执行一次任务可能需要5-20次LLM调用（每次推理+每次观察分析），成本是单次Prompt调用的5-20倍。这不是简单的"5倍Prompt成本"，而是会从根本上改变定价模型和毛利率计算——对于付费产品来说，Agent范式要求更精准的计费策略和Token消耗预算控制。 **可靠性从"确定性问题"变为"概率问题"。** 在Prompt范式中，同样的Prompt通常产生相似的输出。在Agent范式中，由于每一步的决策都影响后续路径，相同的用户请求在不同时间执行可能走完全不同的执行路径。这对测试和质量保证提出了全新的挑战——传统的"输入-预期输出"测试范式不再适用。 过渡策略的核心建议：**不是所有场景都需要Agent范式**。简单的Q&A、单次文档摘要、代码翻译等场景，Prompt Engineering仍然是最优方案。Agent Engineering适用于"需要多步骤推理+工具调用+状态管理"的复杂场景。判断标准很简单：如果当前任务的Prompt长度超过2000 Token，或者包含超过3个"if-then"条件分支，那么Agent范式才值得引入。 ## 五、总结 从Prompt Engineering到Agent Engineering的范式迁移，是AI开发从"与模型对话"到"设计模型行为"的质变。三个核心结论： **第一，Prompt不会消失，但不再是核心技能。** 在Agent范式中，Prompt的角色从"控制模型输出"转变为"提供行为约束"，其重要性从主导层下降到基础设施层。 **第二，Agent Engineering的核心是"循环设计"而非"Prompt设计"。** 投资精力应该放在观察-思考-行动的循环结构优化上——包括什么时候该思考、什么时候该行动、什么时候该向用户求助——而不是追求某个神奇的Prompt字符串。 **第三，从低风险场景开始迁移。** 先在内部工具、数据分析、代码审查等"出错代价可控"的场景中部署Agent Engineering，积累足够多的生产数据后再扩展到面向客户的场景。这个迁移过程本身，需要在实践中持续迭代。

企业官网建设流程全解析