想象你走进一家餐厅。以前的 AI 就像一位技艺高超的大厨——你点菜,他做菜。你问“宫保鸡丁怎么做”,他能把步骤背得滚瓜烂熟;你不问他,他就安静地站在厨房里,绝不会主动拿起锅铲。而 Agent 范式带来的变化,就像这位大厨突然升级成了“餐厅老板”:他不仅会做菜,还会自己看当天的客流规划菜单(规划)、记住熟客的口味偏好(记忆)、打电话给供应商订新鲜食材(工具使用),甚至遇到突发状况能临场调整方案——从头到尾,你只需要说一句“今晚我要招待一位爱吃辣的老朋友”。 这就是 Agent 范式的本质:AI 从“被动应答的工具”,进化为“主动完成任务的工作伙伴”。它不再局限于回答你的问题,而是能理解目标、拆解步骤、调动资源、持续行动,直到把事情办成。

岗位关联

理解 Agent 范式,是 AI 从业者从“会用模型”迈向“会造系统”的关键一步。它决定了你未来构建的应用是从模型调用升级为智能体协作。

目录
  1. 可视化演示
  2. Agent范式定义
  3. 从模型到Agent演进
  4. 规划能力
  5. 记忆能力
  6. 工具使用
  7. 技术栈成熟度
  8. 影响与未来
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态展示Agent从感知到行动的完整闭环流程,以及规划推理、记忆机制和工具使用三大核心能力,通过节点流动粒子直观理解Agent架构。

本节配有交互动效(进入视口后自动加载,约 3KB)。

Agent完整流程 感知→规划/记忆→工具调用→行动,全链路闭环 Agent=LLM+Planning+Memory+Tools Agent通过感知环境、制定计划、检索记忆、调用工具来完成复杂任务

Agent范式定义

餐厅老板要撑起一家店,靠的不只是炒菜手艺,还得有定菜单的脑力、记熟客的人情味、以及联系供应商的门路。Agent 范式也是如此:它把 AI 从“单一能力的模型”升维成“多能力协同的工作体”。那这个“工作体”到底由什么构成?我们可以把它抽象成一个四元组:一个核心大脑加上三种关键能力。大脑是基础模型,负责理解和生成;三种能力分别是规划、记忆和工具使用。

在技术定义上,Agent 是一个能够感知环境、做出决策并采取行动以实现目标的自主系统。它和传统的“输入-输出”程序有本质区别:传统程序像自动售货机——投币、出饮料,流程固定;而 Agent 像便利店店员——看到货架空了会主动补货(自主决策),下雨天会主动把伞架挪到门口(环境交互),并且从早到晚持续营业(持续运行)。

回到餐厅的比喻:模型决定了这位“老板”的聪明程度,而规划、记忆、工具决定了这家餐厅能不能真正运营起来。缺少任何一项,AI 都只是一间“有厨师却没生意”的厨房罢了。

Agent=⟨M,P,R,T⟩\displaystyle \text{Agent} = \langle \mathcal{M}, \mathcal{P}, \mathcal{R}, \mathcal{T} \rangle
这个公式把 Agent 拆成四个部分:$\mathcal{M}$ 是模型(大脑),$\mathcal{P}$ 是规划,$\mathcal{R}$ 是记忆,$\mathcal{T}$ 是工具。四个部分协同工作,才构成完整的 Agent。
  1. 模型($\mathcal{M}$)Agent 的推理中枢,相当于餐厅老板的头脑,负责理解任务、生成方案。
    M:context→reasoning\displaystyle \mathcal{M}: \text{context} \rightarrow \text{reasoning}
  2. 规划($\mathcal{P}$)把大目标拆成小步骤的能力,像老板把“招待客人”拆成订菜、备菜、上菜一样。
    P:Goal→{s1,s2,…,sn}\displaystyle \mathcal{P}: \text{Goal} \rightarrow \{s_1, s_2, \dots, s_n\}
  3. 记忆($\mathcal{R}$)存储和调用历史信息,像老板记住熟客的口味偏好。
    R:history→context\displaystyle \mathcal{R}: \text{history} \rightarrow \text{context}
  4. 工具($\mathcal{T}$)调用外部资源的能力,像老板打电话给供应商订食材。
    T:action→result\displaystyle \mathcal{T}: \text{action} \rightarrow \text{result}

从模型到Agent演进

还记得那位只会等你点菜的大厨吗?从模型到 Agent 的演进,本质就是这位大厨一步步当上老板的过程。第一阶段,他被动应答——你问什么他答什么,像早期的聊天机器人,一次一问。第二阶段,他开始能多轮对话——记得你刚才说过什么,像能和你闲聊的服务员。第三阶段,他成为 Agent——你给他一个目标,他自己想办法完成,像掌控全局的餐厅老板。

这个演进背后,是三个维度的跃迁。第一是从被动到主动:传统模型像弹簧,压一下弹一下;Agent 像永动机,自己就会往前跑。第二是从单轮到多轮:模型处理的是孤立的请求,Agent 处理的是连续的对话流和任务链。第三是从指令到任务:模型忠实执行你给的指令,Agent 则理解指令背后的意图,自行规划路径。

从大厨到老板的升级,不是换了个更大的锅,而是换了一套工作模式。AI 行业同样如此:Agent 范式不是把模型调大,而是把模型放进一个能够让能力流转起来的系统里。

\displaystyle \text{Model}: \text{Prompt} \rightarrow \text{Response} \qquad \text{Agent}: \text{Goal} \rightarrow \text{Action}^{\*} \rightarrow \text{Done}
一句话对比:模型是“你问我答”的咨询窗口,Agent 是“你交代我办”的执行者。$\text{Action}^{\*}$ 表示 Agent 会自主选择最优行动序列。
  1. 模型路径Prompt 进、Response 出,一次交互就结束,像售货员完成一笔交易。
    Prompt→Response\displaystyle \text{Prompt} \rightarrow \text{Response}
  2. Agent 路径Goal 进,经过一连串主动行动,最终达成 Done,像项目经理从头跟到尾。
    \displaystyle \text{Goal} \rightarrow \text{Action}^{\*} \rightarrow \text{Done}
  3. 行动序列$\text{Action}^{\*}$ 不是固定脚本,而是 Agent 根据情况自主选择的最优行动组合。
    \displaystyle \text{Action}^{\*} = \{a_1, a_2, \dots, a_k\}

规划能力

餐厅老板接到“招待客人”这个模糊目标后,脑子里会自动浮现一张清单:确认人数、定菜单、买菜、备料、烹饪、上菜。这个“自动浮现清单”的本领,就是 Agent 的规划能力。规划是 Agent 的“项目经理”,专门负责把模糊的大目标拆解成清晰的小步骤,并排好执行顺序。

规划能力有三个层次。第一是任务分解:把大目标拆成子任务,像把大象装进冰箱分三步。第二是动态调整:计划赶不上变化,老板发现虾不够新鲜,立刻换成鱼——Agent 在遇到障碍时会重新规划路径。第三是反思优化:做完一单生意,老板会复盘哪里慢了、哪里出错,Agent 同样会回头审视自己的行动结果,在下一次做得更好。

规划能力让 Agent 不再“走一步看一步”,而是“谋定而后动”。就像一位好老板,永远比客人多想三步——这也是 Agent 与传统 AI 拉开差距的核心原因。

Goal⇒{s1,s2,⋯ ,sn}s.t.  ⋃i=1nsi=Goal\displaystyle \text{Goal} \Rightarrow \{s_1, s_2, \cdots, s_n\} \quad \text{s.t.} \; \bigcup_{i=1}^{n} s_i = \text{Goal}
这条公式表示:Agent 会把总目标拆成若干子任务 $s_i$,并且这些子任务合起来恰好覆盖总目标——不遗漏、不冗余。
  1. 拆解目标将 Goal 分解为一个子任务集合,像把旅行计划拆成订票、订酒店、排行程。
    Goal⇒{s1,s2,⋯ ,sn}\displaystyle \text{Goal} \Rightarrow \{s_1, s_2, \cdots, s_n\}
  2. 覆盖约束所有子任务的并集等于总目标,保证没有遗漏的关键步骤。
    ⋃i=1nsi=Goal\displaystyle \bigcup_{i=1}^{n} s_i = \text{Goal}
  3. 顺序约束子任务之间可能存在先后依赖,像先订票才能排行程。
    si≺sj(若 si 是 sj 的前提)\displaystyle s_i \prec s_j \quad (\text{若 } s_i \text{ 是 } s_j \text{ 的前提})

记忆能力

你去一家餐厅次数多了,服务员会记得你“少盐多辣、爱喝温水”。这份“记得”,就是 Agent 的记忆能力。没有记忆的 AI 像金鱼,谈完就忘;有了记忆的 Agent 像老友,越聊越懂你。

Agent 的记忆分为两层。短期记忆就像一个便签本,用来临时记录当前对话的上下文——比如你刚说过“我要订周五晚上的位子”。但便签本空间有限,这就是模型的“上下文窗口”限制:窗口满了,旧信息就被挤掉了。长期记忆则像一个档案馆,把重要的信息存到外部存储器里,需要用的时候再调出来。上下文管理就是开锁师傅的活——决定哪些内容留在便签本上,哪些归档进档案馆,避免重要信息被“挤丢”。

记忆能力决定了 Agent 能否“越用越懂你”。一个没有长期记忆的 Agent 每次都是从零开始的陌生人;而拥有记忆的 Agent,能成为真正懂业务的资深伙伴。

Memt+1=f(Memt,Obst+1)∧∣Context∣≤W\displaystyle \text{Mem}_{t+1} = f(\text{Mem}_t, \text{Obs}_{t+1}) \quad \wedge \quad \lvert \text{Context} \rvert \leq W
公式表示记忆是不断更新的:新记忆 $\text{Mem}_{t+1}$ 由旧记忆和最新观察共同决定,同时上下文长度必须小于等于窗口上限 $W$。
  1. 记忆更新$f$ 是一个更新函数,把旧记忆和新观察融合成新记忆,像老板把新客人的口味补记到本子上。
    Memt+1=f(Memt,Obst+1)\displaystyle \text{Mem}_{t+1} = f(\text{Mem}_t, \text{Obs}_{t+1})
  2. 窗口约束上下文长度受限于窗口上限 $W$,超过即遗忘,像便签本写满了必须撕掉几页。
    ∣Context∣≤W\displaystyle \lvert \text{Context} \rvert \leq W
  3. 长期记忆超出窗口的关键信息写入外部存储,使用时按需检索回填。
    Retrieved=Search(Query,Memlong)\displaystyle \text{Retrieved} = \text{Search}(\text{Query}, \text{Mem}_{\text{long}})

工具使用

餐厅老板再能干,也不可能自己种菜、养猪、发电。他需要打电话给供应商、需要请维修工、需要打开收银系统——这些外部资源,就是 Agent 的“工具”。工具使用能力,让 Agent 不再只靠“脑内知识”硬撑,而是学会调用外部资源解决问题。

工具使用有三种典型形态。第一种是 API 调用:Agent 向天气服务请求数据、向支付接口发起转账,像老板给供应商打电话下定单。第二种是代码执行:需要算一笔复杂的账时,Agent 直接写代码跑一遍,像老板用计算器清点成本。第三种是信息检索:遇到不确定的事实,Agent 搜索网络或查阅数据库,像老板上网查新菜谱。工具调用遵循一个选择逻辑——从可用工具集合中挑出最能解决当前问题的那个。

工具使用让 Agent 从“知道”走向“做到”。就像老板不能光会背菜谱,还得真能把菜端上桌——Agent 要想真正完成任务,就必须学会调用外部世界的资源。

\displaystyle t^{\*} = \arg\max_{t \in \mathcal{T}} \text{Score}(\text{state}, t)
这个式子的意思是:Agent 会综合当前状态,对每个候选工具打分,选出得分最高的那个来执行——像老板根据“今天客人多不多”决定是叫外卖还是自己炒。
  1. 候选工具集$\mathcal{T}$ 是所有可用工具的集合,包括 API、代码解释器、搜索引擎等。
    T={t1,t2,…,tm}\displaystyle \mathcal{T} = \{t_1, t_2, \dots, t_m\}
  2. 状态评估$\text{Score}$ 是打分函数,综合考虑当前任务状态与工具匹配度。
    Score:(state,t)→R\displaystyle \text{Score}: (\text{state}, t) \rightarrow \mathbb{R}
  3. 最优选择$\arg\max$ 负责选出得分最高的工具 $t^{\*}$。
    \displaystyle t^{\*} = \arg\max_{t \in \mathcal{T}} \text{Score}(\text{state}, t)

技术栈成熟度

餐厅老板的生意能做多大,取决于整个餐饮供应链成不成熟——供应商是否可靠、厨具是否好用、行业规范是否清晰。同样,Agent 范式的发展,也依赖技术栈的成熟度。今天这个领域,正处于“供应链快速完善”的爆发期。

技术栈成熟的三个标志值得关注。第一是框架涌现:从 LangChain 到 AutoGen,各种 Agent 开发框架如雨后春笋般出现,就像标准化厨房设备走进市场,让“开店”变得简单。第二是生态构建:模型服务、工具市场、记忆存储方案等周边组件逐渐配套,像餐饮行业的食材配送、餐具消毒、门头装修都有专门服务商。第三是标准化:接口协议、通信规范开始形成统一标准,像餐饮店通用的卫生评级——标准有了,行业才值得信任。

技术栈的成熟,决定了 Agent 范式能否从“极客玩具”变成“工业级工具”。就像只有餐饮供应链成熟了,才能开出一万家连锁店——Agent 的规模化落地,正在等待技术栈的进一步成熟。

Maturity∝Frame×Eco×Std\displaystyle \text{Maturity} \propto \text{Frame} \times \text{Eco} \times \text{Std}
这条公式用乘积关系说明:技术栈成熟度与框架丰富度(Frame)、生态活跃度(Eco)、标准化程度(Std)三者都成正比,任何一项为零,整体成熟度都无从谈起。
  1. 框架丰富度$\text{Frame}$ 代表可用的 Agent 开发框架数量与质量,框架越多,开发门槛越低。
    Frame=#{frameworks available}\displaystyle \text{Frame} = \#\{\text{frameworks available}\}
  2. 生态活跃度$\text{Eco}$ 代表周边工具、模型、社区贡献者的繁荣程度。
    Eco=组件数×社区活跃度\displaystyle \text{Eco} = \text{组件数} \times \text{社区活跃度}
  3. 标准化程度$\text{Std}$ 代表接口规范和协议的统一水平,标准越高,互操作性越强。
    Std=遵循标准的接口数接口总数\displaystyle \text{Std} = \frac{\text{遵循标准的接口数}}{\text{接口总数}}

影响与未来

当每一位“餐厅老板”都能独当一面时,整个餐饮行业的工作方式就变了。Agent 范式对 AI 应用开发的影响,正在重演这场变革。以前开发一个 AI 应用,就像做一道固定菜——需求分析、设计流程、编码实现、测试上线,每一步都要人工写死。现在有了 Agent,开发者只需要“声明目标”——告诉系统“我要一个能自动处理客户投诉的应用”,剩下的事交给 Agent 自己规划。

未来的方向更加激动人心。人机协作模式将从“人指挥机器”升级为“人设定目标,机器自主执行,人负责决策和把关”。多 Agent 协作将让不同的 Agent 像餐厅的厨师、服务员、采购员一样各司其职、互相配合。多模态能力则让 Agent 不仅能读文字,还能看图、听声、操作软件——真正成为“全能员工”。应用开发的成本结构也会发生变化。

从大厨到老板,从单店到连锁,Agent 范式描绘的不仅是 AI 技术的进化,更是一种生产方式的重构。未来的 AI 世界里,最好的工作方式也许就是:人类负责“想清楚要什么”,Agent 负责“稳妥地做到”。

Costdev≈业务复杂度自动化率\displaystyle \text{Cost}_{\text{dev}} \approx \frac{\text{业务复杂度}}{\text{自动化率}}
这个近似公式想表达:随着 Agent 自动化率提升,开发同样复杂业务的人力成本会不断下降——复杂度是分子,自动化率是分母。
  1. 业务复杂度分子 $\text{业务复杂度}$ 代表要解决的问题本身的困难程度。
    Costdev⋅自动化率≈业务复杂度\displaystyle \text{Cost}_{\text{dev}} \cdot \text{自动化率} \approx \text{业务复杂度}
  2. 自动化率分母 $\text{自动化率}$ 代表 Agent 能自主完成的工作占比,比例越高成本越低。
    自动化率=Agent 自主完成任务数总任务数\displaystyle \text{自动化率} = \frac{\text{Agent 自主完成任务数}}{\text{总任务数}}
  3. 成本趋势自动化率接近 1 时,开发成本趋近于业务复杂度本身,人力开支大幅压缩。
    lim⁡自动化率→1Costdev≈业务复杂度\displaystyle \lim_{\text{自动化率} \to 1} \text{Cost}_{\text{dev}} \approx \text{业务复杂度}

AI 应用场景

智能客服 Agent 升级

阶段:Agent 核心能力综合应用(记忆 + 工具使用)

解决的问题:传统客服机器人只能按预设话术回答固定问题,遇到“我的订单为什么还没到”这种需要查系统的请求就卡壳。拥有记忆的 Agent 能记住用户历史订单(长期记忆),实时查询物流 API(工具使用),并在多轮对话中保持上下文一致(短期记忆),真正像人工客服一样解决问题。

具体案例:某电商平台部署售后 Agent,用户反映“上周买的硬盘读不出来”。Agent 先检索订单记录确认购买信息,调用客服知识库判断属于质量问题,自动生成退货申请并推送物流单号给用户。全程无需人工介入,售后处理时长从 20 分钟缩短到 3 分钟。

研发提效 Agent

阶段:规划能力 + 工具使用

解决的问题:传统编程中,开发者接到“写一个数据处理模块”的任务,要自己查文档、写代码、调试、写测试。研发 Agent 把任务拆解成“设计接口、编写代码、运行测试、修复报错”四个子步骤,自主调用代码解释器执行代码、读取编译器报错信息、迭代修复,开发者只需最后审核代码质量。

具体案例:某 SaaS 公司引入编码 Agent 处理重复性 CRUD 接口开发。开发者用自然语言描述需求:“为订单表生成增删改查接口并附带权限校验”。Agent 自主生成代码、编写单元测试、执行测试并修复了 3 处边界错误,20 分钟交付了以往需要一整天的开发量。

Python 演示

python43 行
class SimpleAgent:    """一个极简 Agent 演示:规划 + 记忆 + 工具使用"""     def __init__(self, name):        self.name = name        self.memory_list = []        self.plan_list = []        self.tool_calls = 0     def plan(self, goal):        """规划:把目标拆解为可执行步骤"""        self.plan_list = ["理解需求", "收集信息", "制定方案", "执行方案", "检查结果"]        return self.plan_list     def use_tool(self, tool_name, query):        """工具使用:模拟调用外部工具获取结果"""        self.tool_calls += 1        if tool_name == "search":            return f"[搜索] 找到关于 '{query}' 的资料"        elif tool_name == "calculate":            return f"[计算] 完成运算,获得结果"        return "[未知工具] 无结果"     def run(self, goal):        """运行:ReAct 循环 思考 -> 行动 -> 观察"""        self.memory_list.append(f"目标: {goal}")        steps = self.plan(goal)        for idx, step in enumerate(steps):            self.memory_list.append(f"步骤{idx + 1}: {step}")            result = self.use_tool("search", step)            self.memory_list.append(f"观察: {result}")            print(f"[{self.name}] {step} ... 已完成")        self.memory_list.append("目标完成!")        return self.memory_list  if __name__ == "__main__":    agent = SimpleAgent("旅行规划师")    records = agent.run("规划一次杭州三日游")    print("\n记忆档案:")    for record in records:        print(" -", record)    print(f"\n工具调用次数: {agent.tool_calls}")
目的:用不到 40 行代码演示 Agent 的最小工作闭环——规划步骤、调用工具、记录记忆,最后输出完整的执行档案。
  1. self.memory_list = []用列表模拟 Agent 的“记忆档案”,记录所有关键过程信息
  2. self.plan_list = []存储规划出的步骤列表,是“任务分解”的落地容器
  3. def plan(self, goal)规划方法:把笼统目标展开成有序的执行步骤
  4. def use_tool(self, tool_name, query)工具方法:用一个字典式分支模拟 API 调用
  5. def run(self, goal)主循环:把规划、行动、观察串起来形成 ReAct 闭环
  6. agent = SimpleAgent("旅行规划师")实例化一个具名的 Agent,像给餐厅老板起个字号

常见误区

误区我看 ChatGPT 能一直聊下去,还能记住我之前说的话,这不就是 Agent 吗?感觉 Agent 只是营销上的新词,实际没区别。

正解聊天机器人解决的是“对话”问题,Agent 解决的是“做事”问题。一个会聊天的服务员和一个会运营餐厅的老板,你能说只是称呼不同吗?Agent 必须具备规划、记忆、工具使用三大能力,并且持续行动直到达成目标——聊天机器人只会说话,Agent 会做事。

为何常见:因为当前主流产品都以对话界面呈现,让人误以为“能对话”就是核心差异。实际上对话只是 Agent 的交互形式之一,不是它的本质能力。

误区GPT 这么聪明,什么都能答,直接把所有任务丢给它不就行了?为什么还要规划、记忆、工具这些复杂的东西?

正解模型再聪明,也受限于训练数据的时间和知识边界。它不知道今天的天气(需要工具),记不住上周的对话(需要记忆),面对复杂任务时容易“一口吃成胖子”(需要规划)。就像最好的厨师也代替不了采购员和记账员的工作——模型只是 Agent 的“大脑”,不是完整的人。

为何常见:人们习惯用“智力”衡量 AI,误以为智商高就万事俱备。但现实任务需要的是组织能力、记忆力和动手能力,这些恰恰是模型本身不具备的。

误区有了 Agent,我只要说一句“帮我做一份市场调研报告”,它就自动搞定一切,我可以完全放手了。

正解Agent 能自主执行,但仍然需要人的监督与校准。方向跑偏了要纠正、结果需要审核、关键决策仍需人类把控。像老板把餐厅交给店长打理,但重要菜品和财务还得亲自盯。目前的 Agent 自动化率不是 100%,人为介入不是 bug,而是设计的一部分。

为何常见:“自主”这个词让人联想到科幻片里的全面解放,产生了不切实际的期待。实践中 Agent 更适合定位为“需要督导的得力下属”而非“无人驾驶系统”。

误区Agent 的记忆能力不就是上下文窗口大小吗?窗口越长,记住的东西越多,性能就一定越好。

正解上下文窗口和记忆能力是两个概念。窗口只是短期记忆的容量上限,把窗口无限拉长,不仅推理成本暴涨,还会出现“迷失在中间”效应——太长的上下文反而让模型抓不住重点。真正的记忆能力靠的是“筛选什么该记、什么该忘”的管理策略,而非一味扩容。像老板的便签本写得再满,不如一个筛选过重点的客户档案。

为何常见:厂商宣传时强调窗口长度,给了人们“越长越强”的直觉。但在真实 Agent 系统中,记忆管理的核心是检索质量和信息优先级,不是原始容量。

面试题

Q1. Agent 范式中,Agent 的核心组成通常包括?

单选题 · easy

  • A.模型、规划、记忆、工具← 正确答案
  • B.数据、标签、训练、部署
  • C.输入、输出、损失、梯度
  • D.编码、解码、掩码、注意

答案:A。Agent 的四元组是模型 + 规划 + 记忆 + 工具,对应“大脑 + 项目经,理 + 档案库 + 工具箱”。B 是传统机器学习流程,C 是训练过程组件,D 是 Transformer 结构组件,都不是 Agent 的核心组成。

Q2. 从模型到 Agent 的演进中,最本质的转变是什么?

单选题 · easy

  • A.参数规模开始变得更大了
  • B.从被动响应变为主动行动← 正确答案
  • C.从文字输入变为图像输入
  • D.从单机部署变为云端部署

答案:B。模型是被动的——你问它才答;Agent 是主动的——你给目标它自己去执行。能多模态(C)、部署方式(D)、参数规模(A)都是技术变化,不是范式本质。

Q3. 规划能力中“任务分解”的核心作用是?

单选题 · easy

  • A.让复杂目标拆成小步骤← 正确答案
  • B.让模型参数数量变更多
  • C.让工具调用次数减少
  • D.让记忆容量变得无限大

答案:A。任务分解是把大目标拆成可执行子任务,像老板把“招待客人”拆成买菜、备菜、上菜。它与参数数量无关,也不直接减少工具调用或扩大记忆容量。

Q4. 短期记忆与长期记忆的核心区别是什么?

单选题 · mid

  • A.容量大小与持续时长不同← 正确答案
  • B.一个存储文本一个存图片
  • C.一个运行 CPU 一个跑 GPU
  • D.一个在线一个是完全离线

答案:A。短期记忆是上下文窗口内的临时信息,容量小、时效短;长期记忆存外部存储,容量大、可跨越会话。存储介质(CD)、硬件(B)和在线状态(D)都不是本质区别。

Q5. ReAct 循环中“观察”环节的作用是什么?

单选题 · mid

  • A.获取工具执行后的结果← 正确答案
  • B.对用户输入进行分词
  • C.对模型参数做正则化
  • D.将数据写入训练集

答案:A。在思考→行动→观察的循环里,观察是读取工具调用返回的结果,作为下一轮思考的依据。B 是预处理、C 是训练技巧、D 是数据收集,与推理循环无关。

Q6. Agent 的核心能力包括以下哪些?

多选题 · mid

  • A.规划与任务的分解← 正确答案
  • B.记忆与上下文管理← 正确答案
  • C.工具调用与环境交互← 正确答案
  • D.自动安装显卡驱动

答案:ABC。Agent 三大核心能力是规划、记忆、工具使用,对应 A、B、C。安装显卡驱动是运维自动化,不是 Agent 能力的通用组成部分。

Q7. 上下文窗口受限导致的信息丢失问题,主要靠什么缓解?

单选题 · mid

  • A.长期记忆与外部存储← 正确答案
  • B.增加 GPU 显存的容量
  • C.把学习率调得更大
  • D.减少模型的层数深度

答案:A。窗口有限时,把重要信息写入长期记忆、需要时检索回填,是主流的缓解方案。B 只解决计算资源,C、D 是训练手段,与推理期记忆无关。

Q8. 衡量 Agent 技术栈成熟度的关键标志是什么?

单选题 · hard

  • A.工具链和标准逐渐统一← 正确答案
  • B.开源项目数量完全归零
  • C.社区讨论的热度下降
  • D.实际应用的案例消失

答案:A。技术栈成熟的标志是框架涌现之后走向标准化、生态完善,像餐饮业有了统一卫生评级。B、C、D 都是生态衰退的信号,与“成熟”相反。

Q9. Agent 记忆管理面临的主要挑战有哪些?

多选题 · hard

  • A.如何筛选重要信息存储← 正确答案
  • B.如何避免上下文被噪声稀释← 正确答案
  • C.如何更新过时的长期记忆← 正确答案
  • D.如何让模型加速过拟合

答案:ABC。记忆管理三难:存什么(筛选)、怎么不被旧信息干扰(上下文纯度)、如何更新(记忆刷新),对应 A、B、C。过拟合是训练问题,不属于记忆管理挑战。

Q10. Agent 范式对 AI 应用开发模式的影响体现在哪些方面?

多选题 · mid

  • A.从编写流程变为声明目标← 正确答案
  • B.从堆砌功能变为编排能力← 正确答案
  • C.从单次响应变为持续任务← 正确答案
  • D.从需求明确变为彻底删库

答案:ABC。Agent 让开发者不再写死每一步逻辑,而是声明目标让 Agent 自行编排;应用从一次性问答变为长期执行的任务体,对应 A、B、C。D 是无意义的干扰项。