01-Agent概述
01-Agent概述
01-从大模型应用走向Agent
基础课里,我们已经能让程序稳定地调用大模型:把提示词组织好、把上下文拼进去、把返回的 JSON 校验一遍,再接进业务系统。这一套组合拳掌握之后,你就能搞定单次调用,也能搞定不太复杂的工作流。
但你迟早会碰到一类需求,用这套方法怎么写都难以实现。比如「帮我排查一下线上这个接口为什么变慢了」,你根本没法提前把步骤写死:要先看哪个日志、要不要去查数据库、查完发现是缓存问题还要不要再去看缓存配置,这些都得看前一步的结果才知道。
这一篇,我们就从这个「步骤没法提前写死」的问题出发,讲清楚 Agent 到底是什么。
一、Agent 到底是什么
我们先把定义给出来,然后,再慢慢拆解。
Agent 是这样一类大模型应用:你给它一个目标和一组工具,它自己决定每一步做什么、调用哪个工具,拿到结果后再决定下一步,如此循环,直到它认为目标达成。
这个定义里有三个关键词:目标、工具、循环。我们一个个看。
先说目标。
「把这段中文翻译成英文」「总结这篇文章」等都是明确的指令,也就是说,指令说的是「做这个动作」。而给 Agent 的是一个目标:「帮我把这个仓库的单元测试补全,覆盖率到 80%」。目标说的是「达到这个状态」,至于中间要读哪些文件、写多少个测试用例、跑几次测试,目标里一个字都没提。
再说工具。
基础课讲过,大模型本身只能进 Token出 Token,它不会联网、不会读文件、不会执行任何动作。所以,要想让模型真的「做事」,就得给它配上一批能操作外部世界的函数,比如执行 Shell 命令、读写文件、调用某个 API。这些函数就是工具(Tool)。模型的输出不再只是给人看的文字,还可以是一条「我要调用 read_file 这个工具,参数是 path=src/main.py」的指令。
最后说循环。
这是 Agent 和普通大模型应用最根本的区别。普通大模型应用是「一问一答」,模型回一次就结束了。Agent 不是回一次就完事,模型先根据目标决定这一步做什么、调用哪个工具,然后,程序把这个工具执行掉,再把执行结果喂回给模型;模型看到结果后,判断离目标还差多少,于是决定下一步再调哪个工具,程序又去执行工具调用、又把结果喂回来……「模型决策 → 程序执行工具调用 → 结果反馈」这三步就这样一圈一圈重复,每一圈都比上一圈更接近目标,直到某一轮模型判断目标已经达成,才不再要求调用工具,循环结束。
把这三点合起来,Agent 的核心特征就清楚了:
- 模型自己做决策:下一步做什么,是模型看着当前情况决定的,不是你在代码里写死的。
- 能操作外部环境:通过工具,模型可以真正改变外部世界的状态,而不只是输出文字。
- 过程是循环的:一次调用解决不了的任务,通过多轮「决策—行动—观察」逐步推进。
- 自己判断何时结束:任务算不算完成,也是模型根据目标和当前结果来判断的。
其实,你已经天天在用这样的产品了。Cursor、Claude Code 这类编程助手就是典型的 Agent:你说一句「给这个接口加上分页」,它自己去搜相关文件、读代码、动手改、跑测试,测试挂了再回头改。这一整串动作,没有哪一步是事先编排好的。
二、单次调用、工作流与 Agent
Agent 这个词现在被滥用,很多其实只是普通的大模型应用也自称 Agent。为了把它认清楚,我们把大模型应用开发分为三档。
第一档:单次调用的应用。
你发一段提示词,模型回一段结果,结束。翻译、摘要、改写、分类,大多是这一档。这里没有「下一步」的概念,模型也不参与任何流程决策,它只负责根据输入生成输出。网页版的 ChatGPT、DeepSeek 对话,本质上就是这一档。
第二档:工作流(Workflow)。
无法通过一次调用完成的任务,就拆成几步,用代码把这几步串起来。举个客服场景的例子:

这里模型被调了两次,但每一步干什么、下一步干什么,全是你在代码里写死的。 模型只负责它那一环(分类、生成),流程不归它管。这一档已经能解决相当多的业务问题了,而且它有个巨大的好处,即行为可预测:同样的输入,永远走同样的路径,出了问题也好排查。
第三档:Agent。
到这一档,你不再规定路径。你把目标和一组工具交给模型,接下来该调哪个工具、拿到结果要不要再调一次、什么时候算干完,全由模型自己判断。程序进入一个循环,模型思考、调工具、看结果、再思考,直到它认为任务完成。
对于这三档的差别,我们用一句话概括:
单次调用的应用里没有流程;工作流里流程是你规划的,模型只是流程中的一个执行者;Agent 里流程是模型自己一步步算出来的,你只给目标和工具。
这里要特别强调一点:这三档没有高下之分,只有适不适合。 不是说 Agent 就比工作流「高级」,就该优先用它。恰恰相反,能用固定工作流解决的,就绝对不要上 Agent,因为工作流可预测、好调试、成本可控。什么时候才真的需要 Agent,我们留到本模块第 4 篇专门讲。这里你先建立一个认识:Agent 是用来对付那种「步骤没法提前写死」的任务的,它是解决特定问题的方案,不是你为了追求高大上而故意使用的手段。
三、工具调用和循环执行
理解了 Agent 是什么,我们再往深一层,看看它为什么必须要有「工具」和「循环」这两样东西。搞懂这个,你才算真正理解 Agent 的运行机制。
先看工具为什么是必需的。
回到基础课那句话:大模型可以看做是一个「Token 进、Token 出」的函数,它没有手也没有脚。你让它「帮我查一下北京今天的天气」,它并不能真的联网,只能根据训练时记住的东西编一个答案给你,而这个答案很可能是错的,甚至是它凭空编造的(也就是幻觉)。
所以要想让模型的能力落到实处,就得在它和外部世界之间架一座桥,这座桥就是工具。你给它一个 get_weather(city) 函数,并在提示词里告诉它「你可以调用这个函数来查天气」。这样一来,模型遇到天气问题时,就不再自己瞎编,而是输出一个「我要调用 get_weather,参数 city=北京」的请求,由你的程序负责去调那个天气 API,把返回的数据喂给模型,模型再基于真实数据回答。
工具让模型从「只会说」变成了「能做事」,这是 Agent 成立的第一个前提。
再看循环为什么是必需的。
有了工具,是不是调一次就够了?对简单任务是够的,但对复杂任务远远不够。因为复杂任务有个特点:下一步该做什么,取决于上一步的结果,而上一步的结果在开始时是不知道的。
还是拿开头那个「排查接口变慢」的例子。你没法提前规划路径,因为:
- 先看应用日志,如果发现是数据库查询慢,下一步就该去看 SQL 和索引;
- 但如果日志里没有慢查询,反而看到大量超时,下一步可能就要去查下游服务;
- 如果查下游服务时发现它已经挂了,下一步就要去定位是哪个服务、为什么挂。
每一步都是分叉的,走哪条岔路,得看前一步观察到了什么。这种任务,人类工程师也是走一步看一步的。Agent 模仿的正是这个过程,它靠一个循环来实现模仿人类思考和解决问题的过程:
# Agent 的核心循环:决策 → 行动 → 观察 → 再决策……直到目标达成
while not 目标达成:
# 1. 决策:模型看着「目标 + 已经发生的事」,决定下一步做什么
决策 = 模型(目标, 历史)
# 2. 判断:模型是要调用工具,还是认为任务已经完成
if 决策.要调用工具:
# 3. 行动:程序去执行工具调用
结果 = 执行工具(决策.工具名, 决策.参数)
# 4. 观察:把结果追加到历史里,进入下一轮
历史.append(结果)
else:
break # 模型认为干完了,退出循环这段伪代码就是整个 Agent 的基本骨架,后面第 3 篇我们会把它写出来跑通,从零实现一个最小Agent。
你现在只要记住这个循环的意义:它让模型能够根据每一步的真实反馈,动态地调整后续动作。 这正是固定工作流做不到的,工作流的路径在代码里已经定死了,没法根据中间结果改变执行路径。
工具解决「能不能做事」,循环解决「能不能根据反馈持续做事」。两样凑齐,模型才从一个「问答机器」变成了一个「能围绕目标持续行动的系统」。
四、Agent 模型决策的边界
到这里你可能会有点兴奋:既然模型能自己决策,那是不是把什么都交给它就行了?
要讲清楚这个问题,先得认识大模型的一个根本特性:它是概率性的,不是确定性的。
同样一段输入,模型两次的输出可能不一样;你让它进行稍微复杂的计算,它可能算错;你让它严格按格式返回,它偶尔会多一个字段或少一个逗号。这不是 bug,而是它的工作方式决定的,基础课讲采样和温度时已经解释过原因。
而我们写的代码恰恰相反,它是确定性的:一段做加法的代码,输入 2 和 3,永远返回 5,运行一万次都一样。
所以 Agent 开发有一条极其重要的设计原则:
凡是能用确定性代码保证的事情,就不要交给模型去决策。
我们用一个具体例子体会这句话。
假设做一个「自动处理退款」的 Agent,用户说「我要退款」,Agent 需要判断这笔订单能不能退。这里有一条硬规则:下单超过 7 天的订单不允许退款。
这条规则该谁来管?
错误的做法是把规则写进提示词,指望模型每次都记得算日期、算得对、还严格执行。这么做迟早出事,模型某次可能把日期算错,某次可能被用户一句「我这个是特殊情况」就说服了,把不该退的给退了。
正确的做法是这条规则用代码写死。模型只负责理解用户意图(「哦,用户想退款,订单号是 12345」),然后调用一个 check_refund_eligibility(order_id) 工具,能不能退由这个工具里的确定性代码来计算,计算完把「可以退」或「不可以退,因为超过 7 天」的结论返回给模型。模型拿着这个确凿的结论,再决定下一步怎么跟用户说。
看出分工了吗?
- 模型负责它擅长的:理解模糊的自然语言、在多个选项里做判断、组织回复。
- 代码负责它擅长的:精确计算、执行不容违反的业务规则、操作数据库这类要求百分百可靠的动作。
这条边界怎么划分,是 Agent 工程里反复要做的决定,也是区分「玩具 Demo」和「能上生产的 Agent」的关键。一个新手常犯的错误,就是把太多本该由代码兜底的逻辑,塞进提示词里让模型「看着办」,结果做出来的东西时好时坏,根本没法用在真实业务上。
五、Agent 自主性的合理范围
最后聊一个更宏观的问题:既然给了模型决策权,这个权限到底该给多大?这就是 Agent 自主性(Autonomy) 的问题。
自主性不是一个「有」或「没有」的开关,而是一个可以从低到高连续调节的范围。
低自主性的一端,模型每做一个动作都要人来确认。比如一个数据库运维 Agent,它想执行一条 DELETE 语句,会先把语句和影响的行数展示给你看,你点「确认」它才执行。这种模式最安全,但需要人一直盯着,效率很低。
高自主性的一端,你给个目标就不管了,模型自己一路做到底,中间不打扰你。这种模式效率最高,但风险也最大,一旦它中途判断失误又没人干预,可能造成不可挽回的后果,比如删错了数据、发错了消息、花超了预算。
现实中的 Agent 产品,几乎都是在自主性从低到高之间找一个合适的位置,而且往往是按动作的风险高低分级的:
- 只读、无副作用的动作(查数据、读文件、搜索网页):放开让模型自己做,做错了也就是浪费一点时间和 Token,损失可控。
- 有副作用但可恢复的动作(改一个文件、提交一段代码):可以让模型自己做,但要留好恢复手段,比如用 Git 管理,改错了能回滚。
- 不可逆或高风险的动作(删库、转账、给客户群发消息、执行线上部署):必须停下来等人工确认,绝不能让模型自己拍板。
Claude Code 就是个很好的例子。它读文件、跑测试这类动作会自己做,但真要执行一条有风险的命令时,默认会停下来问你一句要不要执行。这就是在自主性和安全性之间做的权衡。
所以「合理的自主性」不是越高越好,也不是越低越好,而是要根据动作的风险和可恢复性来定:低风险的放开、高风险的收紧。这个判断贯穿整个 Agent 开发,我们在讲权限、审批和可靠性的时候,会给出更系统的做法。
现在你只要记住一个原则:给模型的自主权,应该和这个动作出错时你能承受的代价相匹配。
本篇小结

02-一个Agent由什么组成
上一篇我们弄清了 Agent 是什么:给它目标和工具,让它自己循环决策、直到达成目标。但「目标、工具、循环」只是从外部看到的行为,如果你要动手做一个 Agent,就得知道它内部由哪些组件构成,每个组件负责什么,它们之间又是怎么配合的。
这一篇就来拆解 Agent 的内部结构。我们会把它拆成四个组成部分:模型与指令、工具与外部环境、状态与记忆、运行时与控制循环,最后再看它们如何协同成一个能持续工作的整体。把这张「组件图」看懂了,下一篇从零写代码时,你就知道每一行对应的是哪个组件。
一、模型、指令和目标:Agent 的大脑
Agent 的核心是大模型,它扮演「大脑」的角色,负责所有的思考和决策。但光有模型还不够,你得告诉它「你是谁、你要干什么、有哪些规矩」。这就引出了两样东西:指令和目标。
指令通常放在 System Prompt 里,它设定的是 Agent 长期不变的内容。基础课讲过 System 和 User 的分工,在 Agent 这里,System Prompt 承担的责任更重,一般包含这么几块内容:
- 角色和能力:「你是一个数据库运维助手,可以查询和修改公司的订单数据库。」
- 行为准则和边界:「执行任何删除操作前必须先确认」「不允许查询用户的支付密码字段」。
- 流程性的规则:什么情况下算任务完成、遇到不确定时该问用户还是自己决定、工具出错后要不要重试,这些决定循环怎么往下走的规矩。
这里要特别澄清一点:「有哪些工具、每个工具怎么调用、调用请求长什么格式」通常不写在 System Prompt 里。 现在主流做法是通过 API 单独的 tools 参数把工具定义传给模型,模型也会以结构化的方式返回调用请求,不需要你在提示词里手写一遍。这块属于下一个模块「工具调用 Tool Use」的内容,这里先不展开。
目标通常来自用户当前这一次的请求,是变化的。比如「帮我把上个月未发货的订单查出来,导成一张表」。目标是这一趟任务的终点,模型每一步都要拿当前情况和这个目标对照,判断还差多少、下一步该往哪走。
Agent的系统指令非常重要,后面会有单独的一篇来讲如何编写。 Agent 要基于指令连续决策几十轮,指令里任何一处含糊,都会被循环不断放大。
举个例子,如果你在 System 里没写清楚「任务完成后要明确说『任务已完成』」,模型可能已经做完了却不声明结束,导致循环停不下来,白白多运行好几轮、多消耗不少 Token。所以写 Agent 的系统指令时,除了交代清楚角色和边界,还要把「什么情况下该停」「遇到不确定的情况该问用户还是自己决定」这类流程性的规则也写清楚。
二、工具与外部环境:Agent 的手脚
模型负责思考,但思考的结果要落地,得靠工具去操作外部环境。
工具,前面说过,就是一批模型可以调用的函数。一个工具在实现上通常包含三部分:
- 一个名字:比如
query_database。 - 一段描述和参数说明:告诉模型这个工具是干什么的、需要传哪些参数、每个参数什么含义。模型完全靠这段描述来判断该不该调、怎么调,所以描述写得好不好,直接决定模型用得对不对。
- 背后的实际代码:模型请求调用后,真正执行的那段程序。
外部环境,指的是工具所操作的一切外部对象。它的范围很广:
- 文件系统(读写文件)
- 数据库(增删改查)
- 网络(搜索、调用第三方 API)
- 操作系统(执行 Shell 命令、管理进程)
- 甚至是浏览器、另一个 Agent
这里要建立一个重要认识:Agent 的能力上限,很大程度上是由它能操作的环境决定的,而不只是由模型本身的聪明程度决定的。
一个模型再强,如果你只给它一个查天气的工具,它也做不了订机票的事。反过来,给一个中等能力的模型配上一套设计良好、覆盖全面的工具,它能完成的任务反而更多。这就是为什么 Agent 开发常说「一半的功夫花在工具设计上」。
下一模块我们会详细介绍工具调用Tool Use。这一篇你只要先理解它在整个结构里的位置就可以,即工具是模型和真实世界之间的接口层。
三、状态、记忆和上下文:Agent 的笔记本
第三个组件,是 Agent 用来「记事」的部分。这部分最容易被初学者忽略,但它恰恰是 Agent 能不能完成长任务的关键。
基础课里讲过:大模型 API 是无状态的。 模型处理这一次请求时,只看你这次传进去的内容,它不记得上一轮发生了什么。可是 Agent 要循环几十轮,如果每一轮模型都「失忆」,那根本无法工作,它会忘了自己的目标、忘了刚才已经查过什么、忘了上一步工具返回了什么。
所以 Agent 必须自己维护一套「记忆」,在每一轮把该带的信息重新拼进请求里。这套记忆可以分成几个层次,对应的粒度和存活时间各不相同:
第一层,当前任务的执行状态。 指的是「为了这个目标,我已经做了哪些事、得到了哪些结果、现在进行到哪一步」。它其实就是那份不断增长的对话历史加工具调用记录。这一层的信息,是模型下一步决策的直接依据。
第二层,跨会话的长期记忆。 有些信息需要跨越单次任务保存下来。比如用户的偏好(「这个用户习惯用中文回复」)、项目的长期事实(「这个项目的数据库用的是 PostgreSQL」)、以往任务积累的经验。这部分通常存在向量库里,用到时再检索出来。
第三层,为单次模型调用组装出来的上下文。 注意,前两层是 Agent「拥有」的全部信息,但每一轮调模型时,你不可能、也不应该把所有信息一次性全部放进去。你得从中挑选出这一步最相关的部分,拼成这一次的上下文。为什么不能全部放入?有两个原因:一是上下文窗口有上限,放不下;二是基础课讲过,放入过多反而会让模型漏掉中间的关键信息(Lost in the Middle),模型注意力分散,执行效果不升反降。
把这三层理清楚,你就能看出「状态」「记忆」「上下文」这三个词的区别:
状态是当前任务进行到哪的实时快照;记忆是需要长期保存、跨任务复用的信息;上下文是每一轮真正喂给模型的那部分内容,它是从状态和记忆里挑选、组装出来的。
这三者怎么设计、怎么存储、怎么在有限的窗口里挑出最有价值的信息,是后面「记忆系统」和「上下文工程」两个模块的核心内容。它们撑起了 Agent 处理长任务的能力,在开发时值得投入精力把它们做好。
四、运行时:Agent 的骨架
前面三个组件(大脑、手脚、笔记本)是「零件」,但要让它们动起来、协调起来,还需要一套「骨架」把它们组织在一起持续运转。这套骨架就是运行时(Runtime)。
Runtime是 Agent 真正跑起来的引擎。上一篇给过它的伪代码,这里我们把每一轮里发生的事说得更细一点,它其实是三个动作在不停重复:

这三段不是我们自己发明的,它来自 2022 年的 ReAct(Reasoning + Acting)这篇论文。这是目前 LLM Agent 领域最通用的一种架构模式,绝大多数框架和文献都沿用它,原文里的三个词是 Thought — Action — Observation,Thought有人把它翻译成推理,有人翻译成思考,我们这里翻译成决策,不管翻译成什么,意思都是差不多的。
在这个循环中的行动和观察,都是运行时完成的,而不是模型完成的。 模型只会说「我要调用 query_database」,至于工具执行完的结果怎么包装成一条消息、追加到状态的哪个位置、下一轮怎么带回给模型,全是运行时的活儿。
这个循环看似简单,但要做到生产级别,还要在循环之外处理很多工程问题:
- 终止条件:什么时候跳出循环?除了模型主动声明「任务完成」,还必须有兜底的强制终止,比如「最多循环 50 步」「Token 花超了预算就停」「运行超过 5 分钟就停」。没有这些兜底,一旦模型陷入「反复调同一个工具」的死循环,程序就永远停不下来。
- 异常处理:工具调用会失败(API 超时、参数错了、没权限)。运行时要捕获这些异常,把错误信息也当成一种「观察结果」喂回给模型,让模型有机会换个思路重试,而不是整个程序直接崩溃。
- 权限控制:上一篇讲过自主性要分级。这个分级就落在运行时里,某个工具被调用前,运行时要检查它属于哪一档风险,如果是高风险的不可逆操作,就在这里拦下来、等人工确认后再放行。
- 中断与恢复:长任务跑到一半,可能被用户主动叫停、需要人工确认,也可能遇到进程崩溃、机器重启。运行时要能在这些点上安全地停下来,并把当前状态持久化保存;等条件满足或人工介入后,再从断点接着往下跑,而不是从头重来。
所以运行时不只是一个 while 循环那么简单,它是把安全、稳定、可控这些工程要求,真正落地的地方。
你可以这样理解它们的关系:模型决定「想做什么」,而运行时决定「允不允许做、做失败了怎么办、什么时候必须停」。 一个 Agent 可不可靠,很大程度上就取决于运行时这一层是否足够健壮。
五、四个组件如何协同
Agent的四个组件讲完了,我们用一个例子,把它们组合在一起走一遍。
这个例子是:用户对一个运维 Agent 说「帮我看看订单库里有没有状态卡在『支付中』超过一小时的订单,有的话列出来」。
第 0 步,运行时启动,把 System 指令(你是运维助手、有哪些规矩)、工具定义(通过 tools 参数传入)和用户的目标,一起放进初始的状态里。
第 1 轮:
- 决策:运行时把当前状态写进上下文交给模型,此时状态里只有指令、工具定义、目标,还没有任何执行记录。模型推理后判断,要回答这个问题得查数据库,于是输出「我要调用
query_database,参数是一条查询卡单订单的 SQL」。 - 行动:运行时先做权限检查,发现这是个只读查询、风险低,放行,然后执行这个工具调用,去查订单库(这就是操作外部环境)。
- 观察:查询返回了 3 条记录。运行时把这个结果写回状态,供下一轮使用。
第 2 轮:
- 决策:模型看到当前状态里已经有了刚才查到的 3 条订单,判断目标达成了,于是不再要求调工具,而是直接组织一段回复:「查到 3 笔支付中超过一小时的订单,分别是……」,并声明任务完成。
- 行动 / 观察:没有工具要调,这两步自然跳过。运行时检测到模型声明了完成,满足终止条件,跳出循环。
最后,运行时把模型的回复交付给用户。任务结束。
把这个过程串起来看,四个组件的分工就一目了然了:
模型负责想(下一步做什么、做完没有);工具和环境负责做(真正去查、去改);状态和记忆负责记(把发生的一切存下来,供下一轮参考);运行时和控制循环负责管(驱动流程、检查权限、处理失败、决定何时停)。
理解了这套协同关系,你再去看任何一个 Agent 产品或框架,都能很快对应起来:它的模型是哪个、工具有哪些、记忆存在哪、循环和终止条件怎么设计的。下一篇,我们就把这套结构用最少的代码亲手实现一遍。
本篇小结

03-从零实现一个最小Agent
前两篇讲清楚了 Agent 是什么、由哪些部件组成,但概念听得再明白,也不如自己动手把它跑一遍。
这一篇,我们就用最少的代码,从零实现一个能真正工作的最小 Agent。
我们不用任何 Agent 框架(LangGraph 之类留到后面模块讲),只用最基础的模型调用 API,把上一篇讲的四个部件亲手拼起来。
代码不长,但五脏俱全,跑通它,你就能从代码层面彻底理解 Agent 的运行机制。
一、最小 Agent 的核心结构
我们要做的 Agent 很简单:回答「北京和上海今天的温差是多少度」这类问题。 别看问题简单,它逼着 Agent 必须做多步:先查北京的气温,再查上海的气温,最后算差值。没有一步能提前写死,正好用来演示那个循环。
回顾上一篇,一个 Agent 至少要有三样东西:
- 模型:负责决策,是大脑。
- 工具:负责做事,是手脚。我们这个例子里准备两个工具:查天气的
get_weather和做计算的calculator。 - 循环:把「模型决策 → 执行工具 → 结果喂回」串起来,转到任务完成为止。
所以整个程序的骨架就是这样:

接下来我们就照着这个骨架,一块一块把代码填进去。我们用的是 OpenAI 兼容的 Chat Completions 接口,这套接口 DeepSeek、Qwen、GLM 等国产模型也都支持,换个 base_url 和模型名就能切换。
二、定义系统指令与任务目标
第一步,把 Agent 的「身份」和「这次的任务」准备好。
系统指令(System Prompt)设定 Agent 是谁、能干什么、有什么规矩。任务目标就是用户这次的问题。在 Chat Completions 接口里,它们分别对应 system 和 user 两条消息。
import os
import json
from openai import OpenAI
# 从环境变量读取密钥,绝不硬编码(基础课强调过)
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
MODEL = "gpt-5.6" # 生产环境应锁定到带日期的快照 ID
SYSTEM_PROMPT = """你是一个查询助手,可以调用工具来查天气、做计算。
工作规则:
1. 需要外部信息时,调用相应的工具,不要自己编造数据。
2. 一步做不完的任务,就分成多步,一次调一个工具,拿到结果再决定下一步。
3. 当你已经拿到足够的信息、能够回答用户的问题时,直接用自然语言给出最终答案,不要再调用工具。
"""
# 这份 messages 列表就是上一篇说的「状态」,它会随着循环不断增长
messages = [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": "北京和上海今天的温差是多少度?"},
]这里有两个细节值得说一下。
一是系统指令里那条「拿到足够信息就直接回答,不要再调工具」。上一篇提过,如果不把「什么时候该停」写清楚,模型可能干完了还不声明结束。
二是那个 messages 列表。它就是上一篇说的「状态」,是 Agent 的记忆载体。每一轮我们都会往里追加内容,再整个发给模型,模型才「记得」之前发生了什么。基础课讲多轮对话时说过,API 是无状态的,「记忆」全靠每次把历史重新发过去,Agent 这里是同一个道理。
三、注册工具并描述给模型
第二步,准备工具。一个工具有两面:一面是给模型看的描述,一面是给程序执行的代码。
先看给程序执行的代码。这就是两个普通的 Python 函数(为了演示,天气数据直接写死了):
def get_weather(city: str) -> str:
"""查询某个城市今天的天气。真实项目里这里会调用天气 API。"""
fake_data = {
"北京": "晴,气温 12 度",
"上海": "多云,气温 19 度",
}
return fake_data.get(city, f"查不到 {city} 的天气")
def calculator(expression: str) -> str:
"""计算一个数学表达式,比如 '19 - 12'。"""
try:
result = eval(expression) # 演示用,生产环境要用安全的表达式求值
return str(result)
except Exception as e:
return f"计算出错:{e}"
# 用一个字典把工具名映射到实际函数,执行时靠它找到对应的代码
TOOL_FUNCTIONS = {
"get_weather": get_weather,
"calculator": calculator,
}再看给模型看的工具描述。模型并不能直接看到上面的 Python 代码,它只能通过一段结构化的描述,知道有哪些工具、每个工具干什么、需要传什么参数。这段描述用 JSON Schema 来写(基础课讲结构化输出时接触过 Schema):
TOOLS_SCHEMA = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "查询指定城市今天的天气和气温",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "城市名称,比如 北京"}
},
"required": ["city"],
},
},
},
{
"type": "function",
"function": {
"name": "calculator",
"description": "计算一个数学表达式,用于加减乘除等运算",
"parameters": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "要计算的表达式,比如 19 - 12",
}
},
"required": ["expression"],
},
},
},
]这段 Schema 极其重要,因为模型完全靠它来判断该不该调、怎么调。description 写得含糊,模型就可能选错工具或传错参数。
四、接入模型并解析它的决策输出
第三步,把消息和工具描述发给模型,看它怎么决策。
def call_model(messages):
"""调用模型,把工具描述一起带上"""
response = client.chat.completions.create(
model=MODEL,
messages=messages,
tools=TOOLS_SCHEMA,
)
return response.choices[0].message给模型带上 tools 参数之后,它的回复就有了两种可能。要么它决定调用某个工具,要么它觉得信息够了、直接给文字答案。
我们的代码必须把这两种情况分开处理。
模型返回的这条 message,怎么看它是想调工具还是想直接回答?答案是看它有没有 tool_calls 字段:
- 如果
message.tool_calls有内容,说明模型决定调用工具。里面会告诉你工具名(function.name)和参数(function.arguments)。 - 如果
message.tool_calls是空的,说明模型给的是最终文字答案,答案在message.content里。
光看文字有点抽象,我们把这条 message 打印出来看看。第一轮模型决定去查北京天气时,它长这样:
{
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_9xKp2mQv",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"北京\"}"
}
}
]
}这里有三个地方要留意:
content是null(有些模型会给空字符串,或者附带一小段说明),因为模型这一轮不是在回答,而是在下达调用指令。id就是这次调用的编号,执行完工具后回传结果时要原样带上它(也就是后面会讲的tool_call_id),这样模型才知道哪个回复是针对哪个工具调用的tool_calls是个数组,模型也可能一次要求调多个工具,那样数组里就会有多项,每项都有自己的id。
注意这里我们没有让模型输出自然语言再自己用正则去解析,而是用了接口原生的 Function Calling 能力,模型会以结构化的方式告诉你它要调什么。这比让模型「用文字说它想调用某工具、再自己解析那段文字」要可靠得多,是现在的主流做法。Function Calling是什么、底层机制是什么,下个模块会细讲。
等到信息够了,模型返回的消息就变成了这样。tool_calls 为空,答案在 content 里:
{
"role": "assistant",
"content": "北京今天 12 度,上海今天 19 度,两地温差是 7 度。",
"tool_calls": null
}五、编写Runtime:决策—行动—观察
万事俱备,现在把它们组装进Runtime的那个循环。
def run_agent(messages, max_steps=10):
for step in range(max_steps): # 终止条件之一:最多循环 max_steps 步
print(f"\n===== 第 {step + 1} 轮 =====")
# 【决策】把当前状态(messages)交给模型,让它推理出下一步
message = call_model(messages)
# 把模型这一轮的输出,先追加进状态
messages.append(message)
# 【判断】模型是要调工具,还是给最终答案?
if not message.tool_calls:
# 没有工具调用 —— 说明模型认为任务完成了
print("模型给出最终答案,结束循环")
return message.content # 【结果交付】
# 有工具调用 —— 逐个执行(模型可能一次要求调多个)
for tool_call in message.tool_calls:
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
print(f"模型决定调用工具:{name},参数:{args}")
# 【行动】找到对应的函数并执行
func = TOOL_FUNCTIONS[name]
result = func(**args)
print(f"工具返回:{result}")
# 【观察】把工具结果作为一条 tool 消息,写回状态
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": result,
})
# for 循环结束后,带着新拿到的工具结果,进入下一轮 while
# 跑满 max_steps 还没结束,强制退出
return "达到最大步数,任务未能完成"这段代码不长,但它是一个 Agent 的完整骨架。把它和上一篇那张「决策—行动—观察」的图对一下:
- 决策:
call_model(messages),模型看着当前状态推理出下一步。 - 行动:
func(**args),真正去执行工具。 - 观察:把工具返回的结果
append进messages,它是下一轮决策的依据。 - 循环:
for step in range(...)驱动它一轮轮转下去,每一轮的推理都建立在上一轮的观察之上。
这里特别说明一下,工具调用结果那条消息的格式有几条硬性要求:
role 必须是 "tool",还要带上 tool_call_id。
这个 ID 是把「哪个工具调用」和「哪条返回结果」对应起来的凭据,模型靠它知道这条结果是在回应刚才哪一次调用。
少了它,一轮里并行调用多个工具时结果就对不上号,接口会直接报错。关于工具调用的详细格式和规范,下一个模块讲工具调用时会专门展开。
六、设置终止条件与结果交付
上面的代码里,其实已经藏了两个终止条件,这里单独拎出来强调一下。
第一个终止条件:模型主动声明完成。 也就是模型返回的消息里没有 tool_calls,说明它认为信息够了、给出了最终答案。这是正常的、我们期望的结束方式。
第二个终止条件:达到最大步数(max_steps)。 这是兜底方案。上一篇强调过,模型有可能陷入「反复调同一个工具」的死循环,或者一直判断不出任务该结束。如果没有这个上限,程序就会永远转下去。除了步数,实际项目里通常还会加上 Token 预算上限、总耗时上限。
结果交付就简单了:正常结束时,把 message.content 返回给调用方;异常结束(跑满步数)时,返回一个明确的失败信息,让上层知道任务没完成,而不是假装成功。
现在把主程序拼起来跑一下:
if __name__ == "__main__":
answer = run_agent(messages)
print(f"\n最终答案:{answer}")运行后,你会看到这样的过程(模型每次决策可能略有不同,但主线是类似的):
===== 第 1 轮 =====
模型决定调用工具:get_weather,参数:{'city': '北京'}
工具返回:晴,气温 12 度
===== 第 2 轮 =====
模型决定调用工具:get_weather,参数:{'city': '上海'}
工具返回:多云,气温 19 度
===== 第 3 轮 =====
模型决定调用工具:calculator,参数:{'expression': '19 - 12'}
工具返回:7
===== 第 4 轮 =====
模型给出最终答案,结束循环
最终答案:北京今天 12 度,上海今天 19 度,两地温差是 7 度。我们从没在代码里写过「先查北京、再查上海、然后相减」这个流程。是模型自己看着目标,一步步决定的。你把问题换成「北京、上海、广州三地气温的平均值」,同样这套代码,模型会自己多查一个城市、改用平均值的算式,完全不用改一行代码。这正是 Agent 和固定工作流最本质的区别。
七、从最小实现看懂完整的运行机制
麻雀虽小,五脏俱全。回头看这几十行代码,上一篇讲的四个部件,全都能对应上:
- 模型、指令和目标:
MODEL、SYSTEM_PROMPT、用户那条user消息。 - 工具与外部环境:
get_weather、calculator两个函数,以及给模型看的TOOLS_SCHEMA。 - 状态和记忆:
messages列表,它随循环不断增长,装着所有发生过的事。 - 运行时和控制循环:
run_agent函数,驱动流程、判断分支、控制终止。
真实生产级的 Agent,比这个复杂得多,但复杂的地方主要是在这个骨架上「加细节」:
- 工具从 2 个变成几十个,除了自己写的函数,还要接入 MCP、命令行这类外部能力,并处理调用失败、超时、重试;
- 该记住的信息不能只堆在
messages里,要能跨轮次、跨会话地提取、存储、召回和更新,用得上时再取回来; - 上下文会越堆越长,要在有限的窗口里挑出这一步真正该给模型的内容,并对历史做裁剪或压缩,不然会撑爆上下文窗口;
- 循环本身也要更可靠:高风险工具调用前加权限检查和人工确认,还要能安全地停下、出错时兜底;
- 这个最小实现其实是最朴素的「边想边做」,任务更复杂时还能先规划再执行、反思自检,或者拆成多个子 Agent 分工,组织决策的方式也不止一种。
这些「细节」,恰好就是后面各个模块的主题:工具调用、记忆系统、上下文工程、运行时、架构模式。我们会在后面详细的讲解。
本篇小结

04-什么时候应该使用Agent
前三篇讲了 Agent 是什么、由什么组成、怎么写出来。到这里你已经有能力写一个 Agent Demo 了。
但这一篇要泼一盆冷水:大多数时候,你其实不需要 Agent。
这话听起来有点反常识。前面费那么大劲讲 Agent,怎么最后又说不需要?但恰恰是理解了什么时候该用、什么时候不该用,你才算真正弄懂了 Agent。
很多团队一上来就奔着 Agent 去,结果做出来的东西又慢、又贵、又不稳定,最后发现用一个固定工作流几十行代码就能解决。所以,该不该上Agent,很有必要单独拿一节课来讲一讲。
一、Agent 擅长什么样的任务
先说 Agent 真正的用武之地。什么样的任务,值得把决策权交给模型?有三个共同特征,符合得越多,越适合用 Agent。
第一,路径没法提前确定。 这是最核心的一条,前面反复强调过。任务的下一步取决于上一步的结果,而结果在开始时是未知的。比如排查线上故障、根据代码库现状做重构,你没法预先画出一张固定的流程图,因为走哪条岔路要看现场情况。
第二,任务需要多步、且步数不固定。 有的任务可能三步搞定,有的要绕二十步。这种「步数动态变化」的特点,正是循环存在的意义。如果一个任务永远是固定的三步,那用工作流把这三步串起来就好,不需要循环。
第三,环境会给出反馈,而且这个反馈能指导下一步。 Agent 的价值在于「根据反馈修正」。像写代码这种任务就特别适合:改完跑测试,测试挂了能看到具体报错,模型据此再改。有明确的、可观察的反馈信号,模型的循环才有意义;如果做完一步根本得不到有效反馈,那循环也就没什么可依据的了。
按照页以上三个特征,我们能想象到的一些应用场景:
- 编程类:Codex、Cursor、Claude Code。改代码、修 bug、写测试,路径不定、多步、有测试反馈,三条全中,所以编程是目前 Agent 落地最成功的领域。
- 深度调研类:给一个开放性问题,Agent 自己去搜、去读、去交叉验证、写成报告。搜到什么决定下一步搜什么,路径同样不定。
- 运维排查类:看日志、查监控、定位问题根因,典型的走一步看一步。
- 计算机操作类:像基础课提过的 OpenClaw,操作电脑完成一整套任务,界面上出现什么决定下一步点哪里。
这些场景的共性,都是「问题空间开放、路径不可预知」。这才是 Agent 该出手的地方。
二、用任务复杂度和自主性来定位
上面三条特征偏定性,实际做技术选型时,可以用两个维度把任务放到一张图上,看它落在哪个区域,判断会更清晰。这两个维度是任务复杂度和需要的自主性。
先明确这两个词在这里的含义:
- 任务复杂度:完成任务需要多少步、这些步之间的关系是简单串行还是充满分叉和依赖。
- 需要的自主性:这些步骤和它们的走向,有多少是必须由模型临场决定的,而不是能提前定好的。
把这两个维度画成一张图,四个区域各对应一种合适的方案:

- A 区(低复杂度、低自主性):翻译、摘要、分类这类任务。一次模型调用就够了。
- B 区(高复杂度、低自主性):任务要好几步,但每一步和下一步走向都是确定的。比如「收到工单 → 分类 → 检索知识库 → 生成回复 → 存档」,这就是固定工作流,用代码把步骤串起来,模型充当其中一个执行者。大量看起来「很复杂」的业务,其实都落在这个区,用工作流就是最优解。
- D 区(高复杂度、高自主性):路径不定、步数不定、要靠反馈修正,这才是 Agent 的主场。
- C 区(低复杂度、高自主性):任务本身不复杂,却硬要给模型很高的自主权。这个区里大多是设计过度,应该往 A 区里放。
再次强调一下,别一看到「任务有点复杂」就往 D 区(Agent)放。 先问自己一句,这个任务的路径是固定的还是不定的?如果路径固定,哪怕步骤再多,它也属于 B 区,用工作流实现。只有当路径真的没法提前确定、必须靠模型临场判断时,才轮到上 Agent。
三、固定工作流优先原则
上面那张图其实指向一条业界公认的重要原则:
能用固定工作流解决的,就不要用 Agent。优先选择能满足需求的、最简单、最可控的方案。
固定工作流的路径是你在代码里写死的,这带来几个实打实的好处:
- 行为可预测:同样的输入,永远走同样的路径,出同样的结果。
- 好调试:出了问题,你知道是哪一步、哪一行出的错,一步步排查就行。
- 成本可控:调几次模型、花多少 Token,基本是确定的,能提前算出来一个估算值。
- 延迟稳定:走几步是固定的,响应时间波动小。
而 Agent 把路径决定权交给了模型,换来了灵活,但同时也把上面这四条好处几乎全丢了:
模型每次走的路可能不一样(不可预测),出错时你得回放整个决策轨迹才知道它为什么跑偏(难调试),一次任务调几次模型说不准(成本不可控),慢的时候可能要转十几轮(延迟高且不稳定)。
所以,选型的正确顺序应该是:
- 先看单次调用能不能解决。能,就用单次调用。
- 不能,再看拆成固定的几步、用工作流串起来行不行。行,就用工作流。
- 只有当路径实在没法固定、必须靠模型临场决策时,才上 Agent。
这个顺序背后的道理是:你引入的每一分「模型自主性」,都是在拿可控性去换灵活性。
这笔交易只有在你确实需要那份灵活时才划算。如果任务本来路径就固定,你却上了 Agent,等于白白付出了不可控的代价,却没换来任何好处。所以这种把决策权交给模型的做法,应该留到确实遇到「路径无法预先确定」这个瓶颈的时候再使用。
有时候上 Agent 不是因为需求真需要,而是因为它是新技术、写进方案里好看、或者团队想练手。技术选型应该由问题驱动,而不是由「想用某个技术」驱动。先有值得用 Agent 解决的问题,再考虑用 Agent,顺序不能反。
本篇小结

05-从差旅助手看Agent设计
前四篇里,我们把 Agent 是什么、由什么组成、怎么从零实现讲清楚了,也讨论了什么时候应该用 Agent。
对于大部分读者来说,可能都没有开发过Agent产品,甚至只用过Claude Code、Codex这类编程Agent,其他Agent产品了解很少。
这对于后面学习Agent开发的相关技术,非常不利。如果连这些技术的应用场景、要解决什么问题,都不清楚,那么,谈何深入理解技术。
因此,在正式开始讲解工具调用、分层记忆、上下文工程、Runtime、架构模式等等之前,我们先来看下,一个典型的Agent产品长什么样子。
本节课我们聚焦一个具体场景:设计一个差旅助手 Agent。通过这个产品,把 Agent 的典型交互形态和典型功能需求讲清楚。
这个例子会贯穿整个课程,后面每讲一项技术,我们都会回到这个案例里,看它到底解决了差旅助手的哪一个需求。
一、差旅助手要解决什么问题
差旅助手面向的是需要频繁出差的员工。这个场景的痛点很具体。
一个员工要出差,通常需要做这些事:查公司的差旅标准(什么职级能坐什么舱位、酒店住宿上限是多少)、安排行程、搜索符合标准的航班和酒店、比价、预订、保存行程单、回来后报销。这些步骤分散在多个系统里,员工需要来回切换,反复填写相同的信息。
差旅助手的目标,是让员工用对话的方式完成从“我要去深圳出差”到“行程已预订”的全过程。员工只需要描述需求,剩下的搜索、比价、政策校验、预订执行,都由 Agent 来完成。
对于差旅助手这样一个产品,摆在设计者面前的第一个架构选择是:它应该作为一个原生 Agent 来构建,还是嵌入到企业已有的系统里?
要回答这个问题,先得把“原生”和“嵌入”这两个概念的含义讲清楚。
嵌入已有系统的 Agent,可以理解成“给现有产品加一个 AI 模块”。企业已经有一套 OA 系统,员工在上面提交出差申请、查看审批进度、填写报销单。现在要加差旅助手,做法是在 OA 系统里挂一个对话框入口,用户在对话框里说需求,Agent 调用 OA 系统已有的接口去完成操作。Agent 是作为一个功能增强层存在的,底下的数据结构、权限体系、业务流程都没有变。
原生 Agent 则反过来,差旅助手不是某个功能模块,它本身就是一个完整的对话式产品。用户打开它就能完成从需求描述到行程预订的全过程,Agent 直接对接差旅政策库、航班搜索接口、酒店搜索接口、预订系统、审批流,自己管理对话状态和任务执行。
那么,差旅助手应该选哪条路线?
判断的标准可以归结为一个问题:Agent 在你的产品中是“功能”还是“核心”。
如果企业的核心诉求是在现有 OA 系统里增加一个便捷的出差申请入口,员工可以通过对话快速填写申请单、查询审批进度,那么嵌入已有系统的路线更合适。开发成本低,上线快,不需要重建一套权限和流程体系。
但如果企业的核心诉求是让 Agent 真正替代员工完成差旅安排的全过程:搜索、比价、政策校验、预订、变更、报销,那么这个 Agent 需要深度对接差旅政策库、航司 API、酒店 API、审批引擎、财务系统。
这些系统分散在不同部门,接口标准不统一,权限模型各异。在这种复杂度下,嵌入已有系统的路线会很快碰到宿主系统接口能力的天花板,而原生 Agent 路线虽然前期投入更大,但后续的扩展空间也更大。
当然,选择原生路线不意味着所有东西都要从零造。差旅助手仍然需要对接企业已有的差旅政策库、调用航司和酒店的 API、接入企业的审批流。原生指的是 Agent 本身的运行架构是独立完整的,而不是说它不依赖任何外部系统。这些外部系统通过工具调用的方式接入,后面讲工具调用的时候会详细展开。
不管是原生Agent还是嵌入已有系统的Agent,只是产品形态的不同,底层用到的技术,比如工具调用、分层记忆、上下文工程等等,都是一样的。
二、差旅助手的产品交互形式
在讨论差旅助手的交互形态之前,我们先看一个已经在实践中被验证过的 Agent 产品:Claude Code。
Claude Code 本质上是一个编码 Agent (垂直领域的Agent),用户通过对话框告诉它要改什么代码、修什么 bug,它在本地环境中执行文件读写、运行命令、搜索代码等操作。
虽然它的使用场景和差旅助手完全不同,但它的对话框内的交互设计,对任何其他 Agent 产品都有参考价值。
这里要注意的是,虽然都是对话框,但是,垂直Agent的对话框,跟ChatGPT、DeepSeek这类聊天助手的对话框是不同的。
垂直Agent的对话框只是用户的输入入口,它所承载的功能远不止有文字聊天这么简单。
借鉴Claude Code,用户和差旅助手的交互入口,我们也选择对话框。
员工不需要学习新界面,打开就能用自然语言描述需求。而且差旅需求本身就很适合用自然语言表达。“下周三去深圳,待三天,帮我看看合适的航班和酒店”,这句话用表单填写反而更麻烦。
但纯文字对话不够用。差旅场景涉及大量结构化信息和关键决策点,如果全部靠文字来交流,效率很低,还容易出错。
所以,对话框内需要支持几种非文字的交互组件,你可以对比Claude Code。
交互卡片。 当 Agent 搜索到多个航班选项后,它不应该用文字罗列,而是弹出一张航班列表卡片,每个选项显示时间、价格、航司、是否直飞,用户直接点选。酒店选项同理。这种卡片让用户做选择时一目了然,不需要在文字里来回翻找。

权限确认。 查航班、查政策这些只读操作,助手可以自己做。但真正下单订票、改签、退票,这些花钱而且不可逆的操作,必须停下来让用户确认。拿下单举例,在正式下单之前,Agent 必须弹出一张确认卡片,完整展示行程摘要:航班信息、酒店信息、总价、退改政策,用户点击确认后才执行下单。

需求澄清。 用户说“下周三去深圳”,这句话缺少出发城市、具体日期、偏好舱位等信息。Agent 不应该靠猜,而应该用选择题卡片的方式追问。比如:“你的出发城市是哪里?A 北京 B 上海 C 广州 D 其他___”,用户点选或者填写即可。这种结构化澄清比反复文字对话高效得多。

进度展示。 搜索航班和酒店需要时间。Agent 应该流式展示当前在做什么,比如 “正在搜索北京到深圳的航班……”,让用户知道系统在工作,而不是面对一个静止的界面。

中断和回滚。 用户在任何时候都应该能取消当前操作。如果 Agent 正在搜索,用户可以说“算了,先不订了”,或者直接点击停止按钮,Agent 应该立即停止并回到初始状态。

这些交互设计的共同目标可以概括为一句话:让 Agent 的自主性变得可观察、可干预、可信任。
三、差旅助手应该具备哪些能力
交互形态确定之后,接下来要梳理功能需求。
下面这份清单,覆盖了差旅助手从理解需求到完成预订的完整流程。
每一条功能背后,都对应着后面要讲的技术问题。
下面功能罗列中,我们会稍微提到一些后面才讲到的技术名词,这里你能看懂就看,看不懂就略过,等后面学到了,再回过头来再读一遍。
1. 理解用户意图
虽然我们的Agent的功能是差旅助手,但是,对于一个开放的对话框,你无法想象到用户会说出什么话、提出什么问题、布置什么任务。
【闲聊 / 寒暄】
“在吗?”
“今天天气真好,适合出差哈哈”
“你是什么模型做的呀?”
【咨询政策】
“我是 P7,出差能坐商务舱吗?”
“深圳出差住宿一晚最多能报多少?”
“高铁和飞机都能选的话,公司有什么限制?”
【简单查询】
“明天北京到上海有哪些早班航班?”
“我上周那张去广州的机票订单号是多少?”
“查一下我这个月已经出差几次了。”
【复杂任务】
“帮我安排下周三去深圳出差三天,订往返机票和酒店,要靠窗、离客户公司近一点。”
“把原定周五回北京的航班改签到周六下午,顺便延住一晚。”
“这次深圳出差的机票、酒店、打车发票都整理好,帮我提交报销。”如果靠一套逻辑处理所有的需求,那么,这套逻辑的复杂程度将无法想象。因此,为了解耦,我们要先做意图识别,然后,将需求路由到不同的子Agent来处理。
每个子Agent负责一件事情,这样上下文不会过多而稀释模型注意力、工具列表也不会太多导致模型选错工具、Runtime 也不会过于复杂(这些都在后面会讲到,这里不懂没关系),任务执行的准确率、完成率就会提高很多。
2. 收集和确认需求
判断出意图之后,Agent 需要收集完成这个任务所需的参数。
订机票需要出发地、目的地、日期、舱位偏好;订酒店需要城市、入住日期、退房日期、酒店品牌偏好、价格上限。
用户第一次说的话通常不完整。Agent 需要记住已经收集到的信息,识别出还缺哪些参数,然后主动追问。这个过程中,短期记忆负责记住当前对话中已经确认的信息,避免重复询问。需求澄清机制负责在信息不足时向用户提问,而不是靠猜测。
3. 查询企业差旅政策
企业员工出差,必须符合公司的差旅标准。比如:P6 职级可以坐经济舱,P7 可以坐超级经济舱,住宿标准是每晚不超过 600 元。这些政策通常写在公司的差旅制度文档里,格式可能是 PDF、Word 或网页。
Agent 需要根据用户的职级和行程信息,从这些文档中检索出适用的条款。这就是 RAG(检索增强生成) 要解决的问题。
4. 搜索航班和酒店
差旅助手需要调用外部 API 来搜索航班和酒店。这就是工具调用。
Agent 需要知道有哪些工具可用、每个工具需要什么参数、返回结果怎么解析。
工具调用不是简单地发一个 HTTP 请求。Agent 需要处理 API 超时、返回空结果、参数校验失败等各种异常情况。
5. 记住用户偏好
一个员工经常出差,他的偏好是稳定的:喜欢靠窗座位、偏好某家航空公司的航班、习惯住某个品牌的酒店、通常从哪个机场出发。
如果每次都要重新询问这些信息,体验会很差。
短期记忆负责当前对话,长期记忆负责跨对话的用户画像。两者如何分层、如何存储、如何检索,是后面「分层记忆」模块要讲的重点。
6. 制定行程方案
用户说“帮我安排下周去深圳出差三天”,这个请求包含多个子任务:订往返机票、订三晚酒店、可能还需要接送机。
Agent 需要把这些子任务拆解成一个可执行的计划,然后逐步完成。
这就是 Plan-And-Execute 架构的典型场景。Agent 先制定一个完整的计划,然后按步骤执行。在执行过程中,如果某个步骤失败了,比如某个航班没座位了,它需要重新规划。
除此之外,Reflection 机制让 Agent 能够检查自己的执行结果,发现不合理的地方并修正。这些都是「Agent架构模式」模块要讲的内容。
7. 执行预订
搜索和预订是两回事。搜索是只读操作,预订是有副作用的操作,涉及支付和订单创建。
Agent 在执行预订之前,必须让用户确认。确认之后,调用预订接口,处理可能的失败,座位被占、价格变动、支付失败。
权限确认机制要确保每笔预订都经过用户明确授权。如果预订失败,Agent 需要根据错误类型决定是重试、换方案还是转人工。
这些都是「Runtime」模块要讲的内容。
8. 管理多轮对话的上下文
差旅助手的对话可能很长。用户可能先问政策,再搜航班,然后对比酒店,最后才决定预订。这中间穿插着澄清、确认、取消等操作。Agent 需要在整个过程中保持对上下文的准确理解。
上下文窗口是有限的。当对话历史超过模型能处理的长度时,Agent 需要决定哪些信息保留、哪些信息摘要、哪些信息丢弃。这就是上下文工程要解决的问题。它直接影响 Agent 在长对话中的表现。
9. 复杂任务的协作
一个“帮我安排下周去深圳出差”的请求,可能同时涉及机票、酒店、接送机、差旅审批。如果用一个 Agent 来处理所有事情,它的 Prompt 会变得很长,注意力会被稀释,准确率会下降。
Multi-Agent 架构把复杂任务拆给多个专门的 Agent:一个负责意图识别和路由,一个负责航班搜索,一个负责酒店搜索,一个负责政策校验,一个负责预订执行。每个 Agent 只关注自己那部分上下文,准确率更高,也更容易维护。
四、功能需求对应后面要讲的技术
把上面的功能清单整理一下,可以看到差旅助手这个产品涉及的技术点非常密集。
- 理解用户想干什么 → 意图识别
- 从差旅政策文档中找到适用条款 → RAG
- 搜索航班、酒店、执行预订 → 工具调用
- 记住当前对话和用户偏好 → 分层记忆(短期记忆、长期记忆)
- 管理长对话,不丢失关键信息 → 上下文工程
- 工具调用超时、失败、任务取消、权限确认 → Runtime
- 多步骤任务拆解和执行 → Plan-And-Execute
- 检查执行结果,发现错误并修正 → Reflection
- 搜索失败后调整策略重试 → ReAct
- 复杂任务拆给多个专门 Agent → Multi-Agent
- ......
这些技术不是孤立的概念,它们是为了解决Agent产品中的具体问题而存在的。后面几篇,我们会逐个展开,讲清楚每个技术解决什么问题、怎么实现、有哪些工程细节和踩坑教训。
本篇小结

