什么是 Agent？与大模型有什么本质不同？

面试考察点

1. 概念边界是否清晰：面试官最怕听到的就是 "Agent 就是大模型加个对话框" 这种回答。他真正想确认的是，你能不能分清 LLM 是 "大脑"，而 Agent 是 "大脑 + 感知 + 规划 + 记忆 + 工具 + 反思" 这一套完整的东西。

2. 架构思维：Agent 的核心循环（感知 → 规划 → 执行 → 反思）能不能讲清楚？ReAct、Plan-and-Execute、Reflexion 这几个主流范式能不能区分开？

3. 工程落地意识：有没有真正动手搭过 Agent？工具调用（Function Calling / Tool Use）到底怎么实现的知不知道？踩没踩过 Agent "跑飞了"、"死循环"、"幻觉调用一个根本不存在的工具" 这类坑？

核心答案

先给一句话抓重点：

大模型（LLM）是语言能力的基座，Agent 是基于 LLM 搭出来的、能自主完成多步骤任务的智能体系统。

打个比方，LLM 是 "大脑"，Agent 是 "大脑 + 眼睛 + 手脚 + 工具箱 + 记忆本 + 反思能力"。前者 "能说"，后者 "能做"。

业界公认的 Agent 公式（Lilian Weng 给出的定义）：

Agent = LLM（大脑） + Planning（规划） + Memory（记忆） + Tools（工具使用） + Reflection（反思，可选）

两者的区别看这张表就够了：

2025 年大家都叫它 "Agent 元年"。最直观的感受是，AI 从 "能聊天的助手" 变成了 "能真干活的同事"，像 Manus、Devin、Claude Code 这些工具开始真正出现在生产环境里了。

深度解析

一、Agent 的核心循环

先看一张 Agent 的工作流程图，把整个生命周期串起来：

图里画的就是 Agent 的核心循环，分四步走：感知 → 规划 → 执行 → 反思。

• 感知（Perception）：Agent 接收来自用户或环境的输入，可能是一段文字、一张图、一个文件，也可能是一个外部事件，然后把它解析成 LLM 能理解的形式。
• 规划（Planning）：LLM 作为 "大脑"，把任务拆成可执行的子步骤。简单任务一步搞定，复杂任务可能要拆十几步。
• 执行（Action / Tool Use）：根据规划结果去调外部工具 "干活"。查数据库、调 API、执行代码、读写文件、浏览网页，都算。
• 观察（Observation）：把工具执行的结果再喂回给 LLM，让它知道这一步干得怎么样。
• 反思（Reflection）：高级 Agent 会做自我评估，走错了就调整方案。有没有这一步，是区分 "普通 Agent" 和 "强 Agent" 的关键。

这个循环会一直转下去，直到任务完成或者撞到终止条件。这其实就是 Agent 和 LLM 最根本的区别：LLM 只跑一次前向传播，Agent 跑的是一个循环。

二、三大主流 Agent 框架范式

这块面试官最爱追问，得讲清楚。

1. ReAct（Reasoning + Acting）

边想边干，推理和行动交替进行。每一步都是 "Thought → Action → Observation" 三件套。

适合的场景是简单任务，工具调用次数少（≤3 次）。比如问 "今天北京天气怎么样"，查一次天气 API 就够了。

缺点是长任务容易跑偏，因为每一步只看眼前，没有全局规划。

2. Plan-and-Execute

先把完整计划列出来，再分步执行。规划器和执行器解耦，相当于 "项目经理先排好里程碑，程序员照着干"。

适合长链任务，子任务之间有依赖关系。比如 "帮我调研 XX 技术并写一份报告"。

优点是不容易跑偏，全局视角清晰。缺点是中间环境一旦变了，重新规划的成本很高。后来又演化出了带 "重规划（Re-Plan）" 能力的版本来补这个洞。

3. Reflexion（反思型）

执行过程中加一个自我反思的循环，相当于 Agent 给自己当 "评审员"。失败了不灰心，分析原因再重试。

适合需要高准确率、允许试错迭代的场景，比如代码生成、数学推理。

演进关系

三、Java 代码示例：用 LangChain4j 实现一个工具调用 Agent

光讲概念不够，来看点实战代码。下面用 LangChain4j 实现一个能查天气 + 查订单的 Agent：

Maven 依赖：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

配置文件 application.yml：

langchain4j:
  open-ai:
    chat-model:
      api-key: ${OPENAI_API_KEY}
      model-name: gpt-4o
      temperature: 0.0
      timeout: PT60S

定义工具（Function Calling）：

package com.quanxiaoha.agent.tool;

import dev.langchain4j.agent.tool.Tool;
import org.springframework.stereotype.Component;

/**
 * Agent 可调用的外部工具集
 * 这里的 @Tool 注解会被 LangChain4j 自动解析成 JSON Schema
 * 发给大模型，让模型知道有哪些工具可以用
 */
@Component
public class OrderTools {

    /**
     * 查询订单状态
     * 大模型会根据用户问题，自动决定要不要调这个方法、传什么参数
     */
    @Tool("根据订单号查询订单的当前状态")
    public String queryOrderStatus(String orderId) {
        // 实际项目中这里调订单服务的 RPC / HTTP 接口
        return "订单 " + orderId + " 当前状态：已发货，预计明天送达";
    }

    @Tool("根据城市名称查询当前天气")
    public String getWeather(String city) {
        return city + " 今天晴，气温 25 度，适合出门";
    }
}

组装 Agent：

package com.quanxiaoha.agent.service;

import com.quanxiaoha.agent.tool.OrderTools;
import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.spring.AiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 定义 Agent 接口，LangChain4j 会动态生成实现类
 * @AiService 相当于一个智能代理，内部封装了 LLM 调用 + 工具调用 + 记忆
 */
@AiService
public interface CustomerServiceAgent {

    @SystemMessage("""
        你是一个智能客服 Agent。
        你可以根据用户的问题，自主决定调用哪些工具来完成任务。
        如果工具返回的结果不足以回答用户，请如实告知用户。
        """)
    String chat(@MemoryId String sessionId, @UserMessage String userMessage);
}

调用：

@Service
public class AgentDemo {

    @Autowired
    private CustomerServiceAgent agent;

    public void run() {
        // 同一个 sessionId 下，Agent 会自动维护多轮对话上下文
        String answer1 = agent.chat("user-001", "帮我查一下订单 10086 的状态");
        // Agent 内部：LLM 推理 → 决定调用 queryOrderStatus("10086") → 拿到结果 → 组织语言回答

        String answer2 = agent.chat("user-001", "那我收货的城市今天天气怎么样？");
        // Agent 会结合上一轮上下文，知道 "收货城市" 需要先从订单里取，再调天气工具
    }
}

这段代码背后发生的事情，其实就是 Agent 循环在跑：LLM 收到问题 → 决定调工具 → 拿到工具结果 → 再让 LLM 组织回答 → 输出。LangChain4j 把这个循环封装好了，开发者只要写 "工具" 和 "系统提示词" 就行。

换成 Spring AI，写法略有不同，但思路是一致的：通过 @Tool 注解（Spring AI 1.0 之后）或者 FunctionCallback 注册工具，然后由 ChatClient 自动驱动调用循环。

四、Agent vs LLM：一张图说本质区别

这张图把两者的层次关系画得挺清楚：

• LLM 只是 Agent 的一个组件。Agent 不是 LLM 的替代品，它只是把 LLM 当作 "推理引擎"，嵌进了一个更大的系统里。
• Agent 多出来的，是 "身体"。记忆模块负责跨时间维度保存上下文，工具箱负责跨空间维度操作外部世界，反思模块负责自我纠错。
• 从 "一问一答" 到 "目标驱动的自主循环"，这一步在 AGI 路线图上对应的就是 L2 到 L3 的跨越。

五、行业前沿：2025-2026 的 Agent 圈在发生什么

面试里提一嘴最新趋势，能加分。

1. MCP 协议（Model Context Protocol）

Anthropic 在 2024 年底推出来的开放标准协议。2025 年很快成了跨厂商的通用工具接入层，到 2026 年生态已经有 13000+ MCP Server。

说白了就是，以前每个 Agent 框架都要自己定一套工具接入方式，现在大家统一了。被业界叫做 "AI Agent 的 USB-C 接口"。Claude、ChatGPT，还有各种 IDE（Cursor、Claude Code 等）都已经全面支持。

2. Multi-Agent 系统

一个 Agent 干不了太复杂的活，于是就有了多 Agent 协作。一个负责规划，一个负责写代码，一个负责测试，一个负责 Review。AutoGen、LangGraph、MetaGPT 都是这条线上的代表。

3. Agent 协议之争

• MCP 解决的是 Agent 和工具之间的连接。
• Google A2A（Agent-to-Agent） 解决的是 Agent 之间的协作。
• OpenAI Symphony 是 OpenAI 的编排层方案。

从目前看，大家慢慢形成了 "工具层（MCP）+ 协作层（A2A）+ 编排层" 这样一个三层架构的共识。

4. 编程 Agent 爆发

Cursor、Claude Code、Devin、Manus 这些 "能真干活" 的 Agent 在 2025 年迎来了爆发，从 "Demo 玩具" 走向了 "生产工具"。说白了，Claude Code 这类工具的本质，就是一个跑在终端里、带文件读写、Shell 执行、代码理解能力的 Agent。

面试高频追问

1. Agent 和 RAG 有什么关系？能一起用吗？

   能，而且经常一起用。RAG 可以看成是 Agent 工具箱里的一个 "知识检索工具"。Agent 在规划时发现需要外部知识，就调 RAG 去检索，拿到结果再继续推理。两者不是替代关系，而是包含关系，RAG 是 Agent 的一种工具形态。

2. Agent 怎么避免 "跑飞" 和死循环？

   工程上一般用三招：最大循环次数限制、每步成本预算控制（Token 消耗上限）、人工接管兜底机制。复杂场景还会引入 Guardrails（护栏）做输出校验。

3. Agent 怎么评估效果？

   比评估 LLM 难多了。常用指标有：端到端任务成功率、单步工具调用准确率、平均步数 / Token 消耗、人工评分。业界有 AgentBench、τ-bench 这些基准测试。

4. Function Calling 和 MCP 是一回事吗？

   不是。Function Calling 是大模型的能力，模型能输出结构化的函数调用 JSON。MCP 是工具接入的标准协议，解决的是 "工具怎么注册、怎么发现、怎么调用" 这些工程问题。打个比方，Function Calling 是 "大脑会调工具"，MCP 是 "工具的标准插座"。

常见面试变体

• "Agent 的核心组件有哪些？"
• "ReAct 和 Plan-and-Execute 有什么区别？分别适用什么场景？"
• "Agent 怎么实现记忆？短期记忆和长期记忆的区别？"
• "你在项目里用 Agent 解决过什么问题？踩过哪些坑？"
• "为什么说 2025 年是 Agent 元年？Agent 和之前的对话机器人有什么本质不同？"

记忆口诀

Agent 公式：LLM + 规划 + 记忆 + 工具 + 反思

一句话区分：LLM 是大脑，Agent 是大脑加身体；LLM 一次推完，Agent 跑的是循环。

Agent 循环四步：感知 → 规划 → 执行 → 反思，转起来不停。

总结

回答这道题，核心就一句话：大模型是语言能力的基座，Agent 是基于 LLM 搭出来的、能自主跑通感知-规划-执行-反思循环的智能体系统。面试里把 "循环" 和 "工具使用" 这两个关键差异讲透，再带一点 MCP、Multi-Agent 这些最新趋势，基本就稳了。最后记得强调一句：Agent 不是 LLM 的替代，它只是把 LLM 当核心组件，嵌进了一个更大的系统里。这句话一说，面试官就知道你是真懂，不是背的概念。