这类主题最值得先看的不是概念列表，而是它到底能帮你解决什么实际问题。如果你正在接触大模型应用开发，或者想把 AI 能力集成到自己的业务流程里，那么从“提示词工程”到“循环工程”，再到“AI Agent”这条线，本质上是在解决一个核心问题：如何让 AI 从“一次问答”变成“持续、自主地完成复杂任务”。这不仅仅是换个说法，而是开发范式的转变，直接关系到你的项目能不能从演示 Demo 走向稳定、可用的生产系统。

很多人一上来就研究各种 Agent 框架和工具，但往往忽略了最基础的“循环”逻辑设计，导致 Agent 要么卡死，要么跑偏。这篇文章我会结合一线开发经验，拆解从 Prompt Engineering 到 Loop Engineering，再到构建完整 AI Agent 的学习路径和实操要点。重点不是罗列概念，而是告诉你每一步该做什么、为什么做、以及怎么判断做对了。

1. 先理清 Prompt、Loop、Agent 到底在解决什么问题

很多人会把这三个词混着用，但它们在工程实践中的定位完全不同。理解这个差异，是决定你学习路线和项目架构的第一步。

1.1 Prompt Engineering：让模型“听懂”单次指令

提示词工程的核心是沟通效率。它解决的是“如何用一段文本，让大模型最准确地理解并执行一个具体任务”。比如，写一段文案、总结一篇文章、把数据转换成表格。

关键判断标准：

• 任务完成度：模型输出是否完全覆盖了你的要求？
• 输出稳定性：同样的提示词，多次运行的结果是否一致、可靠？
• 格式规范性：输出是否符合你指定的 JSON、Markdown 等格式？

实操建议： 不要追求“万能提示词”。我建议针对每类任务，沉淀 3-5 个经过验证的、高稳定性的提示词模板。这些模板就是你的“原子能力库”。例如，一个用于信息提取的模板，应该明确指定输出字段、格式和空值处理逻辑。

1.2 Loop Engineering：让任务“跑完”一个完整流程

循环工程的核心是流程控制。当单个任务无法一步完成时，就需要引入“循环”。它解决的是“如何让 AI 根据中间结果，决定下一步做什么，直到达成最终目标”。这是从静态问答到动态工作流的关键跃升。

典型场景：

• 复杂问题拆解：用户问“如何优化我的网站 SEO？”，这需要拆解成分析现状、检查技术指标、评估内容、给出具体建议等多个步骤。
• 工具链调用：先让 AI 判断“需要查天气”，然后调用天气 API 获取数据，再根据数据生成出行建议。
• 迭代优化：写一段代码 -> 运行测试 -> 根据报错信息修改代码 -> 再次测试。

关键判断标准：

• 终止条件：循环什么时候该结束？是达成了目标，还是超过了最大步数（防止死循环）？
• 状态管理：每一步的输入、输出、中间状态如何传递和保存？
• 错误处理：某一步失败了（如 API 调用超时），是重试、跳过还是整体失败？

实操建议： 设计循环时，我一般会先画一个简单的状态流程图。重点不是图画得多漂亮，而是明确三个点：触发条件（什么情况下进入下一步）、执行动作（这一步具体做什么）、出口判断（怎么算这一步成功了，下一步去哪）。先用最简单的while循环和条件判断把逻辑跑通，再考虑引入更复杂的框架。

1.3 AI Agent：具备“感知-决策-执行”循环的自主系统

AI Agent 是前两者的集大成者。你可以把它理解为一个内置了 Loop Engineering 能力，并能自主调用工具、管理记忆、与人或环境交互的智能体。它的核心是“自主性”。

关键组件与层级： 根据你提供的热词，比如llm、agent、rag、harness的层级，一个典型的 AI Agent 架构可以这么理解：

1. LLM（大语言模型）：是 Agent 的“大脑”，负责理解和生成，提供基础智能。
2. RAG（检索增强生成）：是 Agent 的“长期记忆和知识库”，让大脑能获取超出其训练数据的最新、专有信息。
3. Agent 核心：是“决策中枢”，它利用大脑（LLM）和记忆（RAG），结合当前目标（Goal）和状态（State），决定下一步行动（Action）。这就是 Loop Engineering 发生的地方。
4. Harness/基础设施层：是包裹在核心之外的“躯干和工具包”。它不代替 Agent 做决策，但提供稳定运行所需的一切：工具调用（Tools）、状态管理（State Management）、记忆存储（Memory）、任务队列（Orchestration）、可观测性（Logging & Monitoring）等。你提到的harness正是这个角色。

关键判断标准：

• 目标达成率：给定一个复杂目标（如“写一份包含市场分析和竞品对比的产品规划”），Agent 能否独立分解并完成？
• 工具调用准确率：需要外部信息或操作时，能否正确选择并调用工具（如搜索、计算、读写文件）？
• 交互流畅性：在多轮对话中，能否保持上下文连贯，理解用户的后续指令或反馈？
• 系统稳定性：长时间运行是否会内存泄漏？遇到意外输入是否会崩溃？

2. 学习路线：从提示词到自主 Agent 的四个阶段

不要一上来就扎进最火的 Agent 框架里。按照“理解、拆解、组装、优化”的顺序，路径会更清晰。

2.1 第一阶段：夯实 Prompt Engineering 基础

这是所有 AI 应用的起点。目标不是成为提示词艺术家，而是建立可靠的单次任务交付能力。

核心学习内容：

1. 基础模式：零样本（Zero-Shot）、少样本（Few-Shot）、思维链（Chain-of-Thought）提示。
2. 结构化输出：如何让模型稳定输出 JSON、XML 或特定格式的文本。这是后续自动化处理的前提。
3. 角色扮演：通过系统提示词（System Prompt）为模型设定身份和边界，比如“你是一个严谨的代码审查助手”。
4. 模板化与参数化：将提示词抽象成模板，动态注入变量。这是工程化的第一步。

实操项目：

• 构建一个“会议纪要生成器”，输入录音转写文本，输出结构化的纪要（包含议题、结论、待办项）。
• 关键验证点：输出是否每次都是合法的 JSON？待办项能否被正确提取并指派？

2.2 第二阶段：掌握 Loop Engineering 设计模式

当单次提示解决不了问题时，引入循环。这是从“问答”到“工作流”的质变。

核心学习内容：

1. ReAct 模式：这是最经典的 Agent 推理模式。Reason（思考下一步做什么）、Act（执行动作，如调用工具）、Observe（观察结果），然后循环。很多框架底层都是这个思想。
2. 规划与执行：让模型先制定一个分步计划（Plan），再按步骤执行（Execute）。适合复杂、可预定义步骤的任务。
3. 反思与迭代：在循环中加入一个“反思”步骤，让模型评估当前结果的好坏，并决定是继续、修改还是重试。
4. 状态机实现：用代码将上述模式实现出来，管理好任务状态（如pending,running,completed,failed）。

实操项目：

• 实现一个“自助数据分析助手”：用户用自然语言提问（如“上个月销售额最高的产品是什么？”），Agent 需要：a) 理解问题；b) 判断需要查询数据库；c) 生成 SQL（或调用查询接口）；d) 执行查询；e) 将结果用自然语言解释给用户。
• 关键验证点：循环能否在“生成 SQL”和“解释结果”之间正确流转？如果 SQL 执行出错，能否捕获错误并尝试修正或告知用户？

2.3 第三阶段：集成工具与记忆，构建完整 Agent

让 Agent 能“动手”和“记住事情”。这时你需要引入框架和基础设施。

核心学习内容：

1. 工具调用：如何让 LLM 理解工具的功能描述，并生成正确的调用参数。OpenAI 的 Function Calling、LangChain 的 Tools 是标准做法。
2. 记忆机制：
   • 短期记忆：对话上下文，通常由模型的上下文窗口长度限制。
   • 长期记忆：通过向量数据库实现的 RAG，让 Agent 能记住历史对话、知识文档。
3. Agent 框架选型：根据你的技术栈和场景选择。
   • LangChain / LangGraph：生态最丰富，组件齐全，适合快速原型和复杂工作流编排。学习曲线稍陡。
   • AutoGen：微软出品，擅长多 Agent 协作对话。
   • Semantic Kernel：微软出品，与 .NET 生态结合紧密。
   • LlamaIndex：专注于 RAG 和数据连接，常与 LangChain 配合使用。
   • Spring AI：如果你是 Java/Spring 生态的开发者，这是最自然的选择，它提供了将 AI 能力集成到 Spring 应用中的一套抽象。
4. 基础设施层：开始关注harness提到的东西——任务队列、日志、监控、持久化存储。对于简单项目，可以先用内存存储和文件日志；对于生产环境，需要考虑数据库、消息队列和专业的 APM 工具。

实操项目：

• 开发一个“个人知识库问答 Agent”：它能读取你本地的 Markdown 文档（RAG），回答基于文档内容的问题，对于不知道的内容，可以自主选择调用搜索引擎工具去查找。
• 关键验证点：Agent 能否正确判断问题是否在知识库内？调用搜索工具时，参数是否正确？多轮对话中，它能否引用之前提到过的信息（记忆）？

2.4 第四阶段：面向生产环境的优化与测试

这是区分玩具项目和可用系统的关键。目标是让 Agent 可靠、高效、可维护。

核心学习内容：

1. 性能优化：
   • 缓存：对频繁且结果不变的 LLM 调用或工具调用结果进行缓存。
   • 流式输出：对于生成时间长的内容，采用流式响应提升用户体验。
   • 异步处理：将耗时的工具调用（如网络请求）异步化，避免阻塞主循环。
2. 稳定性保障：
   • 超时与重试：为 LLM 调用和工具调用设置合理的超时和重试机制。
   • 熔断与降级：当某个工具或模型持续失败时，能暂时屏蔽或启用备用方案。
   • 输入验证与清理：对用户输入和工具返回结果进行清洗和验证，防止注入攻击或脏数据导致 Agent 行为异常。
3. 测试：
   • 单元测试：测试单个工具函数、提示词模板。
   • 集成测试：测试一个完整的循环或工作流。
   • 端到端测试：模拟真实用户场景，输入一系列问题，验证最终输出和目标达成情况。这就是“AI Agent 测试”的核心。
   • 评估：如何定量评估 Agent 的表现？可以设计评估指标，如任务完成率、步骤效率、工具调用准确率等。
4. 可观测性：这是生产部署的命脉。你需要记录详细的日志，追踪每个 Agent 运行时的决策链（Chain-of-Thought）、工具调用记录、耗时和 Token 消耗。这能帮你快速定位问题，比如 Agent 为什么陷入了死循环，或者为什么某个工具调用总是失败。

3. 环境准备与工具链搭建

理论清楚了，我们落到具体的操作环境。一个高效的开发环境能让你事半功倍。

3.1 核心开发环境

1. Python：目前 AI Agent 生态最主流的语言。建议使用 Python 3.9+。使用venv或conda创建独立的虚拟环境。
2. 代码编辑器：VS Code是首选，拥有最丰富的 AI 和 Python 插件生态。
   • 如何导入/使用 AI Agent 项目：在 VS Code 中，通常就是打开项目文件夹。对于特定的 Agent 框架，可能需要安装对应的扩展来获得更好的语法高亮、代码补全和调试支持。例如，使用Continue这样的开源 AI 编码助手，可以直接在 VS Code 中通过扩展市场安装，它能在你编写 Agent 代码时提供上下文感知的建议。
3. 版本控制：Git 是必须的。将你的提示词模板、Agent 配置、测试用例都纳入版本管理。

3.2 关键工具与库安装

在你的项目虚拟环境中，根据阶段逐步安装：

# 第一阶段：基础提示词与 LLM 调用 pip install openai langchain-openai # 使用 OpenAI API # 或使用开源模型 # pip install ollama langchain-ollama # pip install transformers # 第二阶段：引入循环与工作流 pip install langchain langgraph # LangChain 核心及工作流编排 # 第三阶段：工具、记忆与 RAG pip install langchain-community # 社区工具 pip install chromadb # 向量数据库（用于 RAG 记忆） pip install beautifulsoup4 requests # 网页抓取工具示例 pip install sqlalchemy # 数据库工具示例 # 第四阶段：测试与监控 pip install pytest pytest-asyncio # 测试框架 # 日志和监控根据你的后端技术栈选择，如 loguru, prometheus-client

3.3 模型 API 配置

• 云端 API：如 OpenAI GPT、Anthropic Claude、Google Gemini。你需要获取 API Key 并设置环境变量。

  export OPENAI_API_KEY='your-key-here'

• 本地模型：如通过 Ollama、LM Studio 或 vLLM 部署 Llama、Qwen 等开源模型。你需要先下载并启动模型服务，然后将 API Base URL 指向本地。

  注意：本地部署能更好地控制成本和数据隐私，但对硬件（尤其是 GPU 显存）有要求。起步阶段，建议先用云端 API 快速验证想法，复杂度上去后再考虑本地化。

4. 从零构建一个任务规划与执行 Agent

我们用一个具体的例子，把前三个阶段串联起来：构建一个“智能任务规划与执行 Agent”。它能理解用户模糊的目标（如“策划一次团队建设活动”），自动拆解成具体步骤，并尝试执行其中可自动化的部分（如查询天气、生成邮件草稿）。

4.1 第一步：定义原子能力（Prompt Engineering）

首先，我们创建几个可靠的、单次提示词就能完成的任务函数。

import openai from langchain_openai import ChatOpenAI import json # 初始化 LLM llm = ChatOpenAI(model="gpt-4-turbo-preview", temperature=0) def plan_task(goal: str) -> dict: """规划任务：将模糊目标拆解为具体步骤列表。""" prompt = f""" 请将以下用户目标拆解为一个具体的、可执行的任务步骤列表。 每个步骤应包含：`id`（序号），`description`（步骤描述），`status`（状态，初始为`pending`），`dependencies`（依赖的步骤id列表，如果没有则为空列表）。 目标：{goal} 请以 JSON 格式输出，键为 `steps`，值是一个步骤对象的列表。 """ response = llm.invoke(prompt) # 这里需要解析 LLM 返回的 JSON，实际应用中需加入健壮的解析和错误处理 try: plan = json.loads(response.content) return plan except json.JSONDecodeError: # 处理解析失败，可以加入重试或更复杂的修复逻辑 print("Failed to parse plan JSON.") return {"steps": []} def execute_step(step_description: str, context: dict) -> str: """执行单个步骤：根据步骤描述和上下文，执行并返回结果。""" # 这里可以根据 step_description 判断需要调用哪个工具 # 例如，如果描述包含“查询天气”，则调用天气工具 # 如果描述包含“撰写邮件”，则调用邮件生成工具 # 本例中，我们简单让 LLM 模拟执行 prompt = f""" 你是一个任务执行助手。请模拟执行以下步骤，并返回执行结果摘要。 步骤描述：{step_description} 当前已知上下文：{context} 请直接返回一个简短的执行结果，例如：“已查询到北京明日晴，气温15-22度。”或“邮件草稿已生成，主题为‘团队建设活动邀请’。” """ response = llm.invoke(prompt) return response.content def update_context(old_context: dict, step_id: int, result: str) -> dict: """更新上下文：将步骤执行结果整合到全局上下文中。""" new_context = old_context.copy() new_context[f"step_{step_id}_result"] = result return new_context

4.2 第二步：实现任务执行循环（Loop Engineering）

现在，我们将原子能力组装成一个循环，驱动任务一步步完成。

def run_agent_loop(goal: str): """Agent 主循环""" print(f"开始处理目标：{goal}") # 1. 规划 plan = plan_task(goal) steps = plan.get("steps", []) if not steps: print("任务规划失败。") return # 初始化上下文和步骤状态映射 context = {"goal": goal} step_status = {step["id"]: step for step in steps} # 2. 执行循环 max_iterations = 20 # 防止死循环 for i in range(max_iterations): # 找出所有未完成且依赖已满足的步骤 ready_steps = [] for step in steps: if step_status[step["id"]]["status"] == "pending": # 检查依赖是否都已完成 deps_satisfied = all(step_status[dep_id]["status"] == "completed" for dep_id in step.get("dependencies", [])) if deps_satisfied: ready_steps.append(step) if not ready_steps: # 没有可执行的步骤了，检查是否全部完成 if all(step_status[s["id"]]["status"] == "completed" for s in steps): print("所有任务步骤已完成！") break else: print("存在未完成步骤，但依赖可能无法满足，或存在循环依赖。") break # 执行第一个就绪的步骤（更复杂的调度器可以优化顺序） current_step = ready_steps[0] print(f"执行步骤 {current_step['id']}: {current_step['description']}") try: result = execute_step(current_step["description"], context) print(f"步骤结果：{result}") # 更新步骤状态和上下文 step_status[current_step["id"]]["status"] = "completed" context = update_context(context, current_step["id"], result) except Exception as e: print(f"步骤 {current_step['id']} 执行失败：{e}") step_status[current_step["id"]]["status"] = "failed" # 这里可以加入失败重试逻辑或整个任务的中止逻辑 print(f"最终上下文：{context}") return context # 运行示例 if __name__ == "__main__": run_agent_loop("策划一次下周的团队建设活动")

这个简单的循环实现了核心逻辑：规划 -> 选择可执行步骤 -> 执行 -> 更新状态和上下文 -> 循环。这就是一个最基础的 Agent 循环引擎。

4.3 第三步：集成真实工具与记忆

上面的execute_step函数是模拟的。现在我们来集成真实工具，并加入 RAG 记忆。

集成天气查询工具：

import requests def get_weather(city: str) -> str: """调用真实天气 API（示例使用和风天气，需申请key）""" # 注意：此处为示例，需要替换为真实的 API Key 和 URL api_key = "YOUR_HEFENG_KEY" url = f"https://devapi.qweather.com/v7/weather/3d?location={city}&key={api_key}" try: resp = requests.get(url, timeout=10) data = resp.json() # 解析天气数据... forecast = data.get("daily", [{}])[0] return f"{city}明日天气：{forecast.get('textDay', '未知')}，气温{forecast.get('tempMin')}到{forecast.get('tempMax')}度。" except Exception as e: return f"查询天气失败：{e}" # 在 execute_step 函数中加入工具调用判断 def execute_step_enhanced(step_description: str, context: dict) -> str: """增强版的步骤执行器，能调用真实工具。""" # 简单的工具路由逻辑 if "天气" in step_description or "weather" in step_description.lower(): # 从描述或上下文中提取城市信息（这里简化处理） city = "北京" # 实际应用中需要从描述中解析或从上下文获取 return get_weather(city) elif "邮件" in step_description or "email" in step_description.lower(): # 调用 LLM 生成邮件草稿 prompt = f"根据以下上下文，撰写一封邮件草稿。上下文：{context}" response = llm.invoke(prompt) return f"邮件草稿已生成：\n{response.content}" else: # 默认用 LLM 模拟 prompt = f"模拟执行步骤：{step_description}。上下文：{context}" response = llm.invoke(prompt) return response.content

集成 RAG 记忆： 假设我们有一个存储了公司过往团建活动方案的向量数据库。

from langchain_chroma import Chroma from langchain_openai import OpenAIEmbeddings from langchain.schema import Document # 初始化向量数据库（假设已有存储） embeddings = OpenAIEmbeddings() vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings) def retrieve_related_memories(query: str, k=3) -> list: """从记忆库中检索相关历史信息。""" docs = vectorstore.similarity_search(query, k=k) return [doc.page_content for doc in docs] # 在规划或执行步骤时，可以检索相关记忆作为上下文 def plan_task_with_memory(goal: str) -> dict: """带记忆检索的任务规划。""" related_info = retrieve_related_memories(goal) memory_context = "\n".join(related_info) if related_info else "无相关历史信息。" prompt = f""" 以下是过往相关的活动信息，供参考： {memory_context} --- 请基于以上参考信息，将以下用户目标拆解为一个具体的、可执行的任务步骤列表。 目标：{goal} 请以 JSON 格式输出，键为 `steps`，值是一个步骤对象的列表。 """ # ... 后续调用 LLM 和解析 JSON 的代码与之前类似

通过以上三步，我们从一个简单的提示词函数，发展成了一个具备基础规划、循环执行、工具调用和记忆检索能力的 AI Agent。这就是从 Prompt Engineering 到 Loop Engineering，再到 AI Agent 的完整构建过程。

5. 生产环境部署与测试要点

当你的 Agent 在本地能跑通后，要让它真正可用，还需要跨越以下几个关键环节。

5.1 部署架构考虑

对于简单的 Agent，可以封装成一个 REST API 服务（使用 FastAPI、Flask 等）。对于复杂的、长时间运行或需要调度的 Agent，你需要一个更健壮的架构：

• 任务队列：使用 Celery、Dramatiq 或 Redis Queue 来处理异步任务，避免 HTTP 请求超时。
• 状态持久化：将 Agent 的运行状态（步骤、上下文）存入数据库（如 PostgreSQL、Redis），而不是内存，以便服务重启后能恢复。
• Agent 编排：对于涉及多个 Agent 协作或复杂工作流的场景，可以使用LangGraph或Prefect、Airflow这类工作流编排工具来可视化和管理执行流程。

5.2 全面的测试策略

AI Agent 的测试比传统软件更复杂，因为 LLM 的输出具有不确定性。

1. 单元测试：测试你的工具函数、提示词模板（给定固定输入，检查输出格式和关键内容）。
2. 集成测试：测试一个完整的“规划-执行”循环。使用 Mock 对象来模拟 LLM 和外部 API 的响应，确保逻辑正确。

   # 使用 pytest 和 pytest-mock def test_agent_loop_with_mock(mocker): # Mock LLM 的规划响应 mock_plan_response = '{"steps": [{"id": 1, "description": "Mock step", "status": "pending", "dependencies": []}]}' mocker.patch.object(llm, 'invoke', return_value=type('obj', (object,), {'content': mock_plan_response})()) # Mock 工具执行 mocker.patch('your_module.execute_step_enhanced', return_value="Mock execution result") result = run_agent_loop("test goal") # 断言最终状态或上下文符合预期 assert "Mock execution result" in str(result)

3. 端到端测试：在接近真实的环境中，用一组有代表性的用户目标（测试集）来运行整个 Agent。评估指标包括：
   • 任务完成率：有多少目标被成功拆解并执行完毕？
   • 步骤准确率：拆解出的步骤是否合理、可执行？
   • 工具调用准确率：需要调用工具时，是否调用了正确的工具并传入了正确的参数？
   • 人工评估：对于关键输出（如生成的邮件、报告），进行人工抽样评审。

5.3 监控与可观测性

这是生产系统的眼睛。你需要记录：

• 日志：详细记录每个循环的决策、工具调用、LLM 请求和响应（注意脱敏）、耗时、Token 使用量。
• 指标：
  • Agent 平均完成时间、成功率、失败率。
  • LLM API 调用延迟、错误率、Token 消耗成本。
  • 工具调用的成功率和延迟。
• 追踪：为每个用户会话或任务分配一个唯一 ID，追踪其完整的执行链路。这能帮你快速复现和诊断问题，比如“为什么这个用户的请求陷入了死循环？”

5.4 安全与合规

• 输入过滤：对用户输入进行严格的清洗和检查，防止 Prompt 注入攻击（用户输入恶意指令劫持 Agent 行为）。
• 输出审查：对 Agent 的最终输出，特别是涉及外部通信（如邮件、消息）的内容，可以加入一层人工审核或基于规则的自动过滤。
• 权限控制：Agent 调用的工具（如数据库、文件系统、外部 API）必须有最小权限原则，不能拥有过高权限。
• 数据隐私：如果处理用户敏感数据，确保符合相关法律法规，考虑数据脱敏、本地化部署模型等方案。

6. 常见问题与排查思路

在开发和运行 Agent 过程中，你一定会遇到各种问题。以下是几个典型场景的排查顺序：

6.1 Agent 陷入死循环或步骤不推进

• 先看日志：检查每一步的“思考”（Reason）输出，看 Agent 卡在哪一步的决策上。是规划不合理，还是某个步骤执行失败但状态没更新？
• 检查终止条件：你的循环退出条件是否清晰？是否设定了最大迭代次数？依赖关系图是否有环？
• 简化测试：用一个极其简单的目标（如“问好”）测试，看最基本的循环是否能走通。

6.2 工具调用总是失败

• 先验证工具本身：脱离 Agent 环境，直接用代码调用工具函数，确认其能正常工作（网络、API Key、参数格式）。
• 检查工具描述：给 LLM 的工具描述（Function Description）是否清晰、准确？LLM 是否可能误解了工具的用途或参数？
• 检查参数解析：LLM 生成的调用参数是否符合工具函数的接口要求？做好类型转换和错误处理。

6.3 输出结果质量不稳定

• 固化提示词：确保你的系统提示词和关键任务提示词是经过精心设计和测试的模板，减少随机性。
• 调整温度参数：对于需要确定性和一致性的步骤（如规划、工具调用），将 LLM 的temperature参数设为 0 或接近 0。对于需要创造性的步骤（如文案生成），可以适当调高。
• 引入投票或自洽：对于关键输出，可以让 LLM 多次生成并选择最佳答案，或者让 LLM 对自己生成的答案进行一致性检查。

6.4 处理长上下文和记忆丢失

• 优化上下文窗口：定期总结之前的对话历史，将冗长的上下文压缩成摘要，再放入新的上下文窗口。
• 善用 RAG：将需要长期记忆的、非对话式的知识（如产品文档、历史数据）存入向量数据库，让 Agent 在需要时检索，而不是全部塞进上下文。
• 分层记忆设计：区分短期（最近几轮对话）、中期（本次会话主题）、长期（知识库）记忆，采用不同的管理策略。

从 Prompt Engineering 到 Loop Engineering，再到构建 AI Agent，是一个从“点”到“线”再到“体”的能力进化过程。最务实的起步方式，不是去追最新的框架，而是先想清楚你要用 Agent 解决的那个具体、细分的业务问题是什么。然后，用最基础的循环和控制逻辑，搭配一两个可靠的提示词和工具，把它跑通。在这个过程中，你会自然遇到状态管理、错误处理、效率优化这些“基础设施层”的问题，这时再去有目的地学习 LangGraph、LlamaIndex 这些框架，或者设计你自己的任务队列和监控系统，理解才会深刻，方案才会扎实。