什么是 AI Agent

📅 发布于 2026-07-06

从 ChatBot 到 Agent，AI 应用的范式跃迁

2.1 一个问题引入

如果我问你：ChatGPT 是 AI Agent 吗？

答案是：不是。ChatGPT 是一个出色的 ChatBot（聊天机器人），它能理解你的问题并生成回答。但它不会主动帮你查航班、订外卖、写代码到文件里。

而 AI Agent 可以。

"ChatBot 回答问题，Agent 解决问题。"

2.2 ChatBot vs Agent：核心区别

我们先通过一个动画来看两者的区别。同样的任务："帮我查一下明天北京的天气"

ChatBot 对话流程：

用户：明天北京天气怎么样？ ChatBot：我无法实时查询天气，但你可以... 用户：那帮我订个提醒？ ChatBot：抱歉，我没有这个能力。 → 只能对话，不能行动

Agent 对话流程：

用户：明天北京天气怎么样？ Agent：[思考] 需要调用天气API Agent：[工具调用] weather_api("北京", "2026-07-02") Agent：[观察] 明天北京晴，28°C → 明天北京晴，最高28°C。需要我设个提醒吗？

看到了吗？ChatBot 只能"说"，Agent 能"做"。这个"做"的能力，来自于 Agent 独有的四个核心模块。

2.3 AI Agent 的四大核心模块

一个完整的 AI Agent 由四个核心模块组成，缺一不可：

🧠 Agent 四模块

1. LLM（大脑） 负责理解、推理、决策。是 Agent 的"智力引擎"。

2. 记忆（Memory） 短期记忆（对话上下文）+ 长期记忆（向量数据库）。

3. 规划（Planning） 将复杂任务拆解为子任务，制定执行计划。

4. 工具（Tools） 调用外部 API、数据库、代码执行器等，实现"行动"。

流程： 用户输入 → LLM 理解 → 规划拆解（需要行动）→ 检索记忆 → 调用工具 → 返回结果（LLM 理解也可直接回答）

• 用户输入：起点，接收原始消息
• LLM 理解：理解用户意图
• 规划拆解：需要行动时拆解任务
• 检索记忆：获取相关上下文
• 调用工具：执行具体操作
• 返回结果：输出最终答案（LLM 理解也可直接回答）

2.4 Agent 是怎么工作的？

我们来看 Agent 完成一个任务的完整流程：

1. 感知（Perceive）：用户输入"帮我分析一下最近的房价趋势"，Agent 通过 LLM 理解用户意图。
2. 规划（Plan）：Agent 将任务拆解为：①搜索房价数据 ②整理趋势 ③生成分析报告。制定执行计划。
3. 行动（Act）：Agent 调用搜索工具获取最新房价数据，调用数据库工具存储中间结果。这就是"做"的能力。
4. 观察（Observe）：工具返回数据后，Agent 观察、分析数据，发现"一线城市环比下降2%，二线城市持平"的趋势。
5. 反馈（Feedback）：Agent 将分析结果组织成报告返回给用户，并将本次对话存入记忆，为下次交互提供上下文。

2.5 Agent 的核心闭环

上面的五个步骤可以抽象为一个经典闭环：感知 → 决策 → 行动 → 反馈。这个闭环是所有 Agent 的基础运行模式。

流程： 感知 → 决策 → 行动 → 反馈 →（循环回到感知）

• 感知：接收用户输入或环境变化
• 决策：LLM 推理分析，决定下一步做什么
• 行动：调用工具执行具体操作
• 反馈：观察结果并更新状态，循环回到感知

这个闭环不断循环，让 Agent 能够处理多步骤、多轮交互的复杂任务。后续章节讲的 ReAct 模式、反思机制，都是在这个闭环基础上的演进。

2.6 Agent vs ChatBot vs Copilot

面试中经常被问到这三者的区别，我们用一张表总结：

维度	ChatBot	Copilot	Agent
核心能力	对话回答	辅助完成	自主完成
自主性	无	低（需人引导）	高（自主规划）
工具使用	✗	有限	✓ 完整
记忆能力	短期	短期	短期+长期
典型产品	ChatGPT	GitHub Copilot	Devin, AutoGPT

2.7 从用户输入到输出的完整链路

面试最高频的问题之一：整个 Agent 从用户发出消息到完成任务，中间经历了哪些步骤？ 很多面试官会要求你从接收消息开始，一步一步讲清楚每一步做了什么、为什么需要、哪些模块负责。本节把这条链路彻底拆透。

"能画出完整链路图，面试基本稳了。"

🔗 完整 8 步链路

一条完整的 Agent 执行链路，从用户输入到最终输出，包含 8 个核心步骤：

流程： Step 1 用户输入接收 → Step 2 意图识别 → Step 3 任务分类 →（复杂任务）Step 4 任务拆解 → Step 5 执行调度 →（需要工具）Step 6 工具调用 → Step 7 结果整合 → Step 8 输出返回

• Step 1 用户输入接收：起点，接收原始消息
• Step 2 意图识别：理解用户意图
• Step 3 任务分类：判断复杂度，简单任务直接跳到 Step 5
• Step 4 任务拆解：复杂任务拆解为子任务
• Step 5 执行调度：决定调用模型还是工具，纯推理直接到 Step 7，迭代循环回到 Step 2
• Step 6 工具调用：通过 Function Calling/MCP 调用外部工具
• Step 7 结果整合：整合各步输出
• Step 8 输出返回：格式化返回给用户

注意：Step 5 → Step 2 的回边表示 Agent 在执行调度后，可能发现需要重新理解意图（比如工具返回了新信息），进入迭代循环。这正是 Agent 与 ChatBot 的核心差异——Agent 不是一条直线，而是可以循环迭代的。

📌 每一步详细说明

Step 1: 用户输入接收 做什么：接收用户的原始消息（文本、图片、语音等），进行预处理（格式化、清洗噪声）。为什么需要：这是 Agent 与外部世界的接口，所有后续步骤都基于此输入。负责模块：输入处理模块 + 消息队列。

Step 2: 意图识别 做什么：理解用户想做什么——是简单问答？是代码修改？还是复杂的多步任务？为什么需要：不同的意图决定不同的执行路径。负责模块：LLM（语义理解）+ 规则引擎（关键词匹配）。

Step 3: 任务分类 做什么：判断任务类型和复杂度等级（简单问答 / 代码解释 / 代码修改 / 复杂开发）。为什么需要：复杂度决定是否需要拆解，类型决定调用哪些工具。负责模块：分类器（LLM 推理或规则引擎）。

Step 4: 任务拆解 做什么：将复杂任务分解为有序的子任务序列，并确定依赖关系和执行顺序。为什么需要：LLM 单次调用无法完成复杂目标，必须拆成可执行的小步骤。负责模块：规划模块（Planning）——详见 2.3 节。

Step 5: 执行调度 做什么：决定先做什么后做什么，何时调用模型推理、何时调用外部工具。为什么需要：资源有限，执行顺序影响效率和结果质量。负责模块：调度器（Scheduler）——详见 2.9 节。

Step 6: 工具调用 做什么：通过 Function Calling / MCP 协议调用外部工具（搜索引擎、数据库、代码执行器、API 等）。为什么需要：LLM 本身无法查天气、执行代码、读写文件，必须借助工具。负责模块：工具模块（Tools）+ Function Calling 接口。

Step 7: 结果整合 做什么：收集各子步骤的输出（模型推理结果 + 工具返回数据），整合为逻辑连贯的完整答案。为什么需要：多步执行的结果是碎片化的，必须缝合才能形成有意义的回复。负责模块：LLM（结果合成）+ 记忆模块（中间结果缓存）。

Step 8: 输出返回 做什么：格式化最终结果（文本、表格、代码块、图表等），返回给用户。同时将本次交互存入记忆。为什么需要：用户体验取决于输出质量；记忆存入为下次交互提供上下文。负责模块：格式化引擎 + 记忆写入模块。

来看一段模拟完整链路执行的代码：

# 模拟 Agent 完整执行链路

class AgentChain:
    def __init__(self):
        self.llm = LLMEngine()       # Step 2/5/7 的核心引擎
        self.memory = MemoryStore()   # 记忆模块
        self.tools = ToolRegistry()   # Step 6 的工具集
        self.classifier = TaskClassifier()  # Step 3 分类器
        self.planner = TaskPlanner()        # Step 4 规划器

    def run(self, user_input):
        # Step 1: 用户输入接收
        raw_msg = InputHandler.receive(user_input)
        print(f"[Step1] 收到原始消息: {raw_msg}")

        # Step 2: 意图识别
        intent = self.llm.identify_intent(raw_msg)
        print(f"[Step2] 意图识别结果: {intent}")  # e.g. "数据分析"

        # Step 3: 任务分类
        task_type, complexity = self.classifier.classify(intent)
        print(f"[Step3] 任务类型={task_type}, 复杂度={complexity}")

        # Step 4: 任务拆解（仅复杂任务）
        if complexity == "complex":
            sub_tasks = self.planner.decompose(raw_msg, intent)
            print(f"[Step4] 拆解为 {len(sub_tasks)} 个子任务")
        else:
            sub_tasks = [raw_msg]  # 简单任务无需拆解
            print(f"[Step4] 简单任务，无需拆解")

        # Step 5: 执行调度
        schedule = self.llm.schedule(sub_tasks, self.tools.available_tools())
        print(f"[Step5] 调度计划: {schedule}")

        results = []
        for task in schedule:
            # Step 6: 工具调用（需要时）
            if task.need_tool:
                tool_result = self.tools.call(task.tool_name, task.tool_args)
                print(f"[Step6] 工具 {task.tool_name} 返回: {tool_result}")
                results.append(tool_result)
            else:
                # 纯模型推理
                model_result = self.llm.reason(task.prompt)
                print(f"[Step5→推理] 模型推理结果: {model_result}")
                results.append(model_result)

        # Step 7: 结果整合
        final_answer = self.llm.synthesize(results, original_intent=intent)
        print(f"[Step7] 整合完成: {final_answer}")

        # Step 8: 输出返回
        formatted = OutputFormatter.format(final_answer)
        self.memory.save_interaction(raw_msg, intent, formatted)
        print(f"[Step8] 输出返回给用户")
        return formatted

# 执行示例
agent = AgentChain()
result = agent.run("帮我分析最近北京房价趋势")
# [Step1] 收到原始消息: 帮我分析最近北京房价趋势
# [Step2] 意图识别结果: 数据分析
# [Step3] 任务类型=complex, 复杂度=complex
# [Step4] 拆解为 3 个子任务
# [Step5] 调度计划: [search_housing_data → analyze_trend → generate_report]
# [Step6] 工具 search_api 返回: {...房价数据...}
# [Step5→推理] 模型推理结果: 一线城市环比下降2%
# [Step7] 整合完成: 北京房价分析报告
# [Step8] 输出返回给用户

代码中每一步都打印了日志，你可以清楚地看到一条消息从进入 Agent 到变成最终输出，走过了哪些节点。面试时，能讲出这 8 步并解释每步的作用，就是满分回答。

2.8 意图识别与任务分类

Step 2（意图识别）和 Step 3（任务分类）是整条链路的分叉点——Agent 能否走上正确的执行路径，取决于这两步做得好不好。面试中经常追问：Agent 怎么理解用户意图？怎么判断任务复杂度？

🎯 三种意图识别方法

意图识别的三种方法对比

方法	原理	优点	缺点	适用场景
关键词匹配	匹配预设关键词，如"天气"→查询意图	速度快，成本低	粗粒度，误判率高	简单指令型交互
语义理解	通过 LLM 深层理解用户表达的真实意图	精准，能理解隐含意图	成本高，延迟大	复杂多意图场景
模式识别	基于历史对话模式匹配相似意图	利用经验，越用越准	依赖数据量，新意图难识别	高频重复场景

实际工程中，三者通常组合使用：先用关键词匹配快速筛选常见意图，命中后直接走快速路径；没命中则交给 LLM 做语义理解；长期积累的模式数据用于优化匹配规则。这就是分层意图识别策略。

# 分层意图识别：关键词 → 语义 → 模式

def identify_intent(user_input, context):
    # 第一层：关键词匹配（快路径）
    keyword_intent = match_keywords(user_input)
    if keyword_intent and keyword_intent.confidence > 0.9:
        return keyword_intent  # 高置信度，直接返回

    # 第二层：语义理解（慢路径）
    semantic_intent = llm_understand_intent(user_input, context)
    if semantic_intent.confidence > 0.7:
        # 记录新模式，丰富规则库
        pattern_db.record(user_input, semantic_intent)
        return semantic_intent

    # 第三层：模式识别（兜底）
    pattern_intent = match_patterns(user_input, pattern_db)
    return pattern_intent or semantic_intent

# 示例
print(identify_intent("明天天气咋样", []))
# → Intent(type="查询", sub_type="天气", confidence=0.95)  # 关键词命中

print(identify_intent("我项目里这段代码跑不通，帮我看看", []))
# → Intent(type="代码修改", confidence=0.85)  # 语义理解命中

📊 任务分类矩阵

意图识别之后，Agent 需要对任务进行分类，决定执行策略。不同的任务类型对应不同的处理路径：

任务分类矩阵：类型 → 策略 → 路径

任务类型	典型输入	执行策略	链路路径	复杂度
简单问答	"Python 的 list 怎么排序？"	直接回答	Step 1→2→3→5→7→8	低
代码解释	"这段代码在做什么？"	分析 + 输出说明	Step 1→2→3→5→7→8	中
代码修改	"把这段代码改成异步版本"	理解+定位+修改	Step 1→2→3→4→5→6→7→8	中高
复杂开发	"帮我搭建一个 REST API 项目"	拆解+多步执行	Step 1→2→3→4→5→6→7→8（多轮循环）	高

关键观察：简单问答可以跳过 Step 4（任务拆解）和 Step 6（工具调用），直接走快速路径。而复杂开发任务必须走完全部 8 步，且 Step 5→2 的迭代循环可能执行多轮。

🔀 分类决策流程图

流程： 用户输入 → 意图识别 → 任务分类 →（按类型分支）简单问答→直接回答 / 代码解释→分析+说明 / 代码修改→定位+修改 / 复杂开发→拆解+多步执行

• 用户输入：起点
• 意图识别：理解用户意图
• 任务分类：决策节点，分四个分支
• 简单问答：直接回答
• 代码解释：分析+说明，然后输出
• 代码修改：定位+修改，然后输出
• 复杂开发：拆解+多步执行，然后输出

# 任务分类器：判断复杂度并选择执行路径

class TaskClassifier:
    # 关键词 → 复杂度的映射规则
    COMPLEXITY_RULES = {
        "简单问答": {
            "keywords": ["是什么", "怎么用", "区别", "概念"],
            "path": "direct_answer",
            "complexity": "low"
        },
        "代码解释": {
            "keywords": ["这段代码", "什么意思", "解释一下"],
            "path": "analyze_explain",
            "complexity": "medium"
        },
        "代码修改": {
            "keywords": ["修改", "改成", "优化", "修复", "重构"],
            "path": "locate_modify",
            "complexity": "medium_high"
        },
        "复杂开发": {
            "keywords": ["搭建", "实现", "开发", "创建项目", "从零开始"],
            "path": "decompose_execute",
            "complexity": "high"
        }
    }

    def classify(self, intent):
        # 规则匹配 + LLM 兜底
        for task_type, rule in self.COMPLEXITY_RULES.items():
            if any(kw in intent.raw_input for kw in rule["keywords"]):
                return task_type, rule["complexity"], rule["path"]

        # 规则未命中，交给 LLM 判断
        llm_result = self.llm_classify(intent)
        return llm_result.type, llm_result.complexity, llm_result.path

# 示例
classifier = TaskClassifier()
print(classifier.classify(Intent(raw_input="Python list 怎么排序？")))
# → ("简单问答", "low", "direct_answer")

print(classifier.classify(Intent(raw_input="帮我搭建一个 REST API")))
# → ("复杂开发", "high", "decompose_execute")

2.9 执行调度决策

Agent 拿到子任务列表后，下一步是执行调度——决定先做什么后做什么，什么时候该调用模型（推理/理解/生成文本），什么时候该调用工具（搜索/计算/文件操作）。这是 2.7 节链路中 Step 5 的核心逻辑。

"调度器的质量，决定了 Agent 是'聪明地做事'还是'笨拙地乱撞'。"

🌳 调度决策树

调度决策的核心逻辑可以用一棵决策树描述：

流程： 当前子任务 → 需要外部数据？→（是）调用工具 → 需要逻辑推理？→（是）调用模型 → 需要格式化输出？→（是）调用模型格式化 → 需要验证结果？→（是）工具+模型交叉验证 → 执行完成

• 当前子任务：起点
• 需要外部数据？：决策点，是→调用工具，否→继续判断
• 调用工具：搜索/计算/文件操作
• 需要逻辑推理？：决策点，是→调用模型，否→继续
• 调用模型：理解/推理/生成
• 需要格式化输出？：决策点，是→调用模型格式化，否→继续
• 需要验证结果？：决策点，是→交叉验证，否→完成
• 执行完成：终点

⚡ 模型 vs 工具：何时调用谁？

调用模型（LLM）

• 理解用户意图和上下文
• 逻辑推理和因果分析
• 生成文本、代码、创意内容
• 结果整合与格式化
• 判断下一步做什么

调用工具（Tools）

• 搜索实时信息（天气、新闻）
• 执行代码（运行、测试）
• 读写文件（磁盘操作）
• 调用外部 API（支付、数据库）
• 数学计算（高精度运算）

一个关键原则：模型擅长"思考"，工具擅长"行动"。调度器的核心职责就是判断当前子任务属于哪一类，把任务分给最合适的执行者。

# 调度器实现：根据任务特征分配执行路径

class Scheduler:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools

    def dispatch(self, sub_task):
        """根据子任务特征，决定调用模型还是工具"""

        # 判断1：是否需要外部数据？
        if sub_task.requires_external_data:
            # 搜索、数据库查询、API调用 → 工具
            tool_name = self._select_tool(sub_task)
            result = self.tools.call(tool_name, sub_task.params)
            print(f"[调度] 工具执行: {tool_name} → {result}")
            return result

        # 判断2：是否需要逻辑推理？
        if sub_task.requires_reasoning:
            # 分析、推理、决策 → 模型
            result = self.llm.reason(sub_task.prompt)
            print(f"[调度] 模型推理: {sub_task.prompt} → {result}")
            return result

        # 判断3：是否需要格式化输出？
        if sub_task.requires_formatting:
            result = self.llm.format(sub_task.raw_output)
            print(f"[调度] 模型格式化 → {result}")
            return result

        # 判断4：是否需要验证结果？
        if sub_task.requires_verification:
            # 交叉验证：先工具获取事实，再模型判断一致性
            tool_result = self.tools.call("verify", sub_task.params)
            model_result = self.llm.reason(
                f"验证以下结果是否合理: {tool_result}"
            )
            print(f"[调度] 交叉验证 → 工具:{tool_result}, 模型:{model_result}")
            return model_result

        # 默认：模型处理
        return self.llm.reason(sub_task.prompt)

    def _select_tool(self, sub_task):
        """根据任务类型选择最合适的工具"""
        tool_map = {
            "search": "search_api",
            "database": "db_query",
            "code_execution": "code_runner",
            "file_operation": "file_handler",
            "calculation": "calculator"
        }
        return tool_map.get(sub_task.tool_type, "general_tool")

# 执行示例
scheduler = Scheduler(LLMEngine(), ToolRegistry())

# 搜索类任务 → 调用工具
scheduler.dispatch(SubTask(type="search", requires_external_data=True))
# [调度] 工具执行: search_api → {"北京房价": ...}

# 推理类任务 → 调用模型
scheduler.dispatch(SubTask(type="analyze", requires_reasoning=True))
# [调度] 模型推理: 分析房价趋势 → 一线城市环比下降2%

# 验证类任务 → 工具+模型
scheduler.dispatch(SubTask(type="verify", requires_verification=True))
# [调度] 交叉验证 → 工具:数据查询结果, 模型:验证通过

调度器的核心价值在于避免无谓的调用：如果用户只是问"Python 怎么排序"，不需要调用搜索工具，模型直接回答即可；如果用户问"北京明天天气"，模型无法知道实时数据，必须调用工具。调度器就是在做这个判断。

面试八股

Q1：什么是 AI Agent？它和 ChatBot 的本质区别是什么？

A： AI Agent 是一种能够感知环境、自主规划、使用工具、采取行动来完成目标的 AI 系统。

本质区别在于：自主性。ChatBot 只能被动回答问题（输入→输出），Agent 能主动拆解任务、调用工具、多步执行（感知→规划→行动→反馈）。ChatBot 是"嘴"，Agent 是"手+脑"。

Q2：AI Agent 的四大核心模块是什么？分别有什么作用？

A：

• ① LLM（大脑）：理解意图、推理决策、生成回答
• ② 记忆（Memory）：短期记忆保存对话上下文，长期记忆通过向量库存储经验
• ③ 规划（Planning）：将复杂目标拆解为可执行的子任务序列
• ④ 工具（Tools）：调用外部 API、代码执行器、数据库等，实现"行动"能力

四者协同构成 Agent 的完整能力闭环。缺了 LLM 没有智力，缺了记忆没有连贯性，缺了规划只能做简单任务，缺了工具无法与外部世界交互。

Q3：Agent 的"感知-决策-行动-反馈"闭环是什么意思？

A： 这是 Agent 运行的基本范式：

• 感知：接收用户输入或环境变化
• 决策：LLM 推理分析，决定下一步做什么
• 行动：调用工具执行具体操作
• 反馈：观察行动结果，更新状态，决定是否继续循环

这个闭环可以多轮循环，使 Agent 能处理需要多个步骤才能完成的复杂任务。ReAct 模式（第3章）就是这个闭环的经典实现。

Q4：Agent、ChatBot、Copilot 三者的区别？面试怎么答？

A：

• ChatBot：被动对话，只能回答，不能行动。如 ChatGPT。
• Copilot：辅助人类完成工作，人在主导，AI 是工具。如 GitHub Copilot。
• Agent：自主完成目标，AI 主导，人可监督。能独立规划、决策、执行。

关键区别在于自主性程度：ChatBot 无自主性，Copilot 低自主性（人主导），Agent 高自主性（AI 主导）。

Q5：为什么说 2025-2026 年是 Agent 元年？技术条件发生了什么变化？

A： 几个关键条件同时成熟：

• ① LLM 能力跃升：GPT-4o、Claude 3.5、Gemini 2.0 推理能力大幅提升，足以支撑复杂规划
• ② Function Calling 标准化：OpenAI 等原生支持工具调用，不再需要 hack
• ③ MCP 协议：工具调用标准化，跨框架复用成为可能
• ④ 框架成熟：LangGraph、CrewAI、Google ADK、Spring AI 等生产级框架涌现
• ⑤ 成本下降：模型调用成本大幅降低，多轮 Agent 调用经济可行

Q6：从用户输入到 Agent 输出，完整链路包含哪些步骤？每步的作用是什么？

A： 完整 8 步链路：

• ① 用户输入接收：接收原始消息，预处理清洗
• ② 意图识别：理解用户想做什么（问答/修改/开发），决定执行路径
• ③ 任务分类：判断任务类型和复杂度，决定是否需要拆解
• ④ 任务拆解：将复杂任务分解为子任务序列（仅复杂任务需要）
• ⑤ 执行调度：决定何时调用模型、何时调用工具，安排执行顺序
• ⑥ 工具调用：通过 Function Calling/MCP 调用外部工具获取数据或执行操作
• ⑦ 结果整合：收集各步骤输出，缝合为完整答案
• ⑧ 输出返回：格式化结果返回用户，同时存入记忆

关键：Step 5→2 的回边表示迭代循环，Agent 不是单程直线，而是可以循环调整的。

Q7：Agent 如何判断一个任务是简单问答还是需要多步执行？判断依据是什么？

A： 通过意图识别 + 任务分类两步判断：

意图识别有三种方法：关键词匹配（快但粗糙）、语义理解（精准但成本高）、模式识别（利用历史经验）。实际工程中三者组合使用，形成分层识别策略。

任务分类依据四个维度：

1. 是否需要外部数据？（需要 → 至少涉及工具调用）
2. 是否需要多步操作？（需要 → 必须任务拆解）
3. 输入的复杂度？（单句问答 → 简单，长文+多要求 → 复杂）
4. 是否有依赖关系？（步骤间有先后依赖 → 复杂调度）

简单问答：跳过拆解和工具调用，直接回答。复杂任务：走完 8 步链路，可能多轮迭代。

Q8：Agent 的调度器如何决定"调用模型"还是"调用工具"？

A： 调度决策的核心原则：模型擅长思考，工具擅长行动。

决策树的四个判断节点：

1. 需要外部数据？→ 调用工具（搜索/数据库/API）
2. 需要逻辑推理？→ 调用模型（理解/分析/生成）
3. 需要格式化输出？→ 调用模型（润色/排版）
4. 需要验证结果？→ 工具+模型交叉验证（工具获取事实，模型判断一致性）

实际工程中，调度器还考虑成本和延迟：简单意图先用关键词快速路由（低成本），复杂意图才走完整 LLM 推理链路（高成本但精准）。

课后练习

第 1 题（单选）

AI Agent 与传统 ChatBot 最核心的区别是什么？

A. Agent 使用更大的语言模型，回答更准确 B. Agent 具备自主规划、决策和使用工具的能力 C. Agent 只能回答预设的问题 D. Agent 不需要自然语言处理技术

答案与解析

答案：B

核心区别在于自主性。ChatBot 只能被动回答问题（输入→输出），Agent 能主动拆解任务、调用工具、多步执行（感知→规划→行动→反馈）。模型大小不是本质区别。

第 2 题（单选）

以下哪个不是 AI Agent 的四大核心模块之一？

A. LLM（大语言模型） B. 记忆系统（Memory） C. 规划模块（Planning） D. 语音识别（ASR）

答案与解析

答案：D

AI Agent 的四大核心模块是：LLM（大脑）、记忆（短期+长期）、规划（任务拆解）、工具（调用外部能力）。语音识别是输入方式，不是 Agent 的核心模块。

第 3 题（单选）

Agent 的"感知-决策-行动-反馈"闭环中，"决策"环节主要由哪个模块负责？

A. 工具模块（Tools） B. LLM（大语言模型） C. 记忆系统（Memory） D. 外部 API

答案与解析

答案：B

决策（Decide）主要由 LLM 负责。LLM 接收感知到的信息，结合记忆中的上下文，推理出下一步应该做什么。工具是行动阶段的执行者，记忆是辅助决策的参考。

第 4 题（单选）

关于 Agent、ChatBot、Copilot 三者的自主性，以下说法正确的是？

A. ChatBot 自主性最高，Agent 自主性最低 B. 三者自主性相同，只是应用场景不同 C. Agent 自主性最高，ChatBot 无自主性，Copilot 居中 D. Copilot 自主性最高，因为它能辅助编程

答案与解析

答案：C

自主性排序：Agent > Copilot > ChatBot。Agent 能自主规划和执行，Copilot 需要人类引导（人主导），ChatBot 完全被动响应。

第 5 题（单选）

以下哪个产品最符合"AI Agent"的定义？

A. ChatGPT（网页版聊天） B. GitHub Copilot（代码补全） C. Devin（自主完成开发任务的 AI 工程师） D. Google Translate（机器翻译）

答案与解析

答案：C

Devin 是一个能自主规划、编写代码、调试、部署的 AI 软件工程师，具备完整的 Agent 四模块，属于典型 AI Agent。ChatGPT 是 ChatBot，Copilot 是辅助工具，翻译工具不具备自主性。

第 6 题（单选）

Agent 完整链路中，意图识别发生在哪一步？

A. Step 1（用户输入接收） B. Step 2（意图识别） C. Step 3（任务分类） D. Step 5（执行调度）

答案与解析

答案：B

意图识别发生在 Step 2。Step 1 只是接收原始消息，Step 2 才理解用户想做什么。Step 3 是基于意图结果进行任务分类，Step 5 是根据分类结果安排执行顺序。

第 7 题（多选）

以下哪些是 AI Agent 区别于 ChatBot 的关键特征？（多选）

A. 能使用外部工具（API、数据库、代码执行器） B. 能将复杂任务拆解为子任务并规划执行顺序 C. 能保存长期记忆，跨会话使用经验 D. 能生成更长的文本回复

答案与解析

答案：A、B、C

工具使用、任务规划、长期记忆都是 Agent 的关键特征。"生成更长的文本"只是输出长度差异，不是本质区别——ChatBot 也能生成长文本。

第 8 题（多选）

AI Agent 的记忆系统通常包含哪些类型？（多选）

A. 短期记忆（工作记忆/对话上下文） B. 长期记忆（向量数据库存储的经验） C. 遗传记忆（从父Agent继承） D. 情景记忆（具体事件和交互记录）

答案与解析

答案：A、B、D

Agent 的记忆系统通常包含：短期记忆（上下文窗口）、长期记忆（向量库）、情景记忆（具体交互记录）。"遗传记忆"是生物概念，不适用于 AI Agent。

第 9 题（多选）

以下哪些条件促成了 2025-2026 年 AI Agent 的爆发？（多选）

A. LLM 推理能力大幅提升，足以支撑复杂规划 B. Function Calling 和 MCP 协议标准化了工具调用 C. LangGraph、CrewAI 等生产级框架成熟 D. 量子计算突破了算力瓶颈

答案与解析

答案：A、B、C

Agent 爆发的条件：LLM 能力跃升、工具调用标准化（Function Calling/MCP）、框架成熟（LangGraph/CrewAI/ADK/Spring AI）、成本下降。量子计算与 Agent 爆发无直接关系。

第 10 题（多选）

Agent 的意图识别有哪些方法？（多选）

A. 关键词匹配：快速但粗糙，适合简单指令 B. 语义理解：通过 LLM 精准理解深层意图 C. 模式识别：基于历史对话模式匹配 D. 随机猜测：不依赖任何规则，纯靠运气

答案与解析

答案：A、B、C

意图识别的三种方法：关键词匹配（快但粗）、语义理解（精准但贵）、模式识别（利用经验）。"随机猜测"不是意图识别方法，Agent 不靠运气做决策。

第 11 题（多选）

以下哪些场景应该由调度器决定"调用工具"而非"调用模型"？（多选）

A. 查询实时天气数据 B. 分析房价趋势的因果关系 C. 执行一段测试代码 D. 将多个碎片结果整合为完整报告

答案与解析

答案：A、C

查询实时天气和执行代码都需要外部操作，属于"调用工具"场景。分析因果和整合报告属于"调用模型"（推理和生成）。调度原则：需要外部数据/执行 → 工具，需要推理/生成 → 模型。