🤯 面试被问 AI Workflow 和 Agent 有啥区别？3 张图 + 2 段代码讲清楚！

🤯 面试被问 AI Workflow 和 Agent 有啥区别？3 张图 + 2 段代码讲清楚！

摘要：Workflow 和 Agent 到底有啥区别？为什么 Coze 工作流和 ReAct Agent 看起来都在"执行任务"，本质却完全不同？本文从面试翻车经历出发，结合 Anthropic 官方定义、ReAct 框架、完整代码示例和实战选型指南，帮你彻底搞懂这对最容易混淆的 AI 概念。

📌 前言

上周面试，面试官笑眯眯地问了一句：

"你说说 AI Workflow 和 Agent 有什么区别？"

我心想这不简单嘛，都是让 AI 干活呗。结果说了三分钟，面试官表情逐渐凝固……

后来我翻了 Anthropic 的《Building Effective Agents》、LangChain 的文档、还有 ReAct 论文，又在 Coze 和 LangGraph 上分别做了两个项目，才真正搞明白：这俩东西看起来都在"执行任务"，但底层逻辑完全不同。

今天把我的理解整理出来，附完整代码和实战选型经验，帮你下次面试不再翻车。

🎯 本文适合谁

• 面试时被问过 Agent 相关概念的同学
• 用过 Coze / Dify / LangChain 但分不清 Workflow 和 Agent 的开发者
• 想搞清楚 Agentic AI 底层逻辑、做好技术选型的技术人

📚 一、先说结论：一张图看懂本质区别

1┌─────────────────────────────────────────────────────┐
2│                    AI 系统光谱                        │
3│                                                     │
4│  简单 LLM 调用 ──→ Workflow ──→ Agent               │
5│  (更多控制)                          (更多自主)        │
6│                                                     │
7│  确定性 ◄─────────────────────────────► 不确定性      │
8│  可预测 ◄─────────────────────────────► 可探索        │
9│  固定轨道 ◄──────────────────────────► 自由路径        │
10└─────────────────────────────────────────────────────┘
11

💡 这张图来自 Anthropic《Building Effective Agents》，是理解两者区别最核心的框架。

一句话总结：

📚 二、Workflow：一条精心设计的流水线

2.1 什么是 Workflow？

Workflow 本质上是一套自定义的流程，你可以把它想象成工厂里的流水线。

每一步都有明确的输入和输出，每个节点的逻辑是固定的。当条件满足，就会进入下一个环节。

在技术上，它通常是一个编排好的 AI 工作流引擎——由 AI 调用、条件判断、循环逻辑组成的图谱。

2.2 你一定用过的 Workflow

如果你用过 Coze 构建工作流，那你已经在玩 Workflow 了：

1输入节点 → LLM 节点 → 条件判断 → 图片生成 → 输出节点
2

比如我之前做的「AI 照相馆」项目，需求很简单：用户上传照片，系统自动判断是证件照还是艺术照，然后调用对应的模型生成处理后的照片。

一开始我想用 Agent 来做，觉得"智能"一点更好。结果踩了个大坑：

踩坑记录：Agent 在判断照片类型时，有时候会"自作主张"——明明是证件照，它觉得用户可能想要艺术效果，就走了艺术照的分支。客户反馈"怎么生成的和我想的不一样"。后来换成 Workflow，用固定的条件判断节点，每次结果都稳定可控。

最终的 Workflow 设计：

1📸 用户上传照片（输入）
2    ↓
3🧠 LLM 分析照片风格（提取特征）
4    ↓
5🔀 条件判断：证件照 or 艺术照？
6    ├─ 证件照 → 调用证件照模型 → 返回标准证件照
7    └─ 艺术照 → 调用风格迁移模型 → 返回艺术照
8    ↓
9📤 输出处理后的照片
10

关键教训：流程确定、要求稳定的场景，Workflow 比 Agent 靠谱得多。

2.3 用代码理解 Workflow（LangChain.js）

下面是一个完整的 Workflow 示例——简历筛选链路，用 LangChain 的 LCEL（LangChain Expression Language）实现：

1import { ChatOpenAI } from "@langchain/openai";
2import { ChatPromptTemplate } from "@langchain/core/prompts";
3import { StringOutputParser } from "@langchain/core/output_parsers";
4
5// ====== Workflow：简历筛选链路 ======
6// 每一步都是固定的，上一步输出 = 下一步输入
7
8const model = new ChatOpenAI({ modelName: "gpt-4" });
9
10// 第一步：提取简历信息
11const extractPrompt = ChatPromptTemplate.fromTemplate(`
12  请从以下简历中提取关键信息，以 JSON 格式返回：
13  - skills: 技能列表
14  - experience: 工作经历
15  - education: 教育背景
16
17  简历内容：{resume}
18`);
19
20// 第二步：匹配岗位需求
21const matchPrompt = ChatPromptTemplate.fromTemplate(`
22  根据以下候选人信息和岗位需求，给出匹配度分析：
23
24  候选人：{candidate_info}
25  岗位需求：{job_requirements}
26
27  请输出：匹配度分数(0-100) + 匹配原因 + 缺失技能
28`);
29
30// 第三步：生成评估报告
31const reportPrompt = ChatPromptTemplate.fromTemplate(`
32  根据以下匹配分析，生成一份简洁的简历评估报告：
33
34  {match_result}
35`);
36
37// 组装 Workflow 链路（pipe = 流水线传送带）
38const resumeWorkflow = extractPrompt
39  .pipe(model)           // 第一步：LLM 提取信息
40  .pipe(new StringOutputParser())
41  .pipe(matchPrompt)     // 第二步：匹配岗位
42  .pipe(model)
43  .pipe(new StringOutputParser())
44  .pipe(reportPrompt)    // 第三步：生成报告
45  .pipe(model)
46  .pipe(new StringOutputParser());
47
48// 执行 Workflow
49const result = await resumeWorkflow.invoke({
50  resume: "张三，3年React开发经验，熟悉TypeScript...",
51  job_requirements: "高级前端工程师，要求3年以上React经验..."
52});
53

💡 注意：pipe 就像传送带，数据从一头进去，按预设路径流出来。每一步干什么、先干什么后干什么，都是写死的。

2.4 Workflow 的 5 种经典模式

Anthropic 在《Building Effective Agents》中总结了 5 种常见的 Workflow 模式：

📚 三、Agent：一个会思考的探索者

3.1 什么是 Agent？

Agent 和 Workflow 的逻辑完全不同。

它不是走在一条预设的轨道上，而是站在一个开放的空间里，自己去探索怎么做。

从技术上讲，一个 Agent 具备三大核心能力：

1┌─────────────────────────────────────┐
2│           Agent 核心能力              │
3├─────────────────────────────────────┤
4│  🔍 感知环境                         │
5│     理解输入、识别可用工具、评估当前状态  │
6├─────────────────────────────────────┤
7│  🗺️ 规划路径                         │
8│     动态生成任务链，而非预定义流程       │
9├─────────────────────────────────────┤
10│  ⚡ 执行行动                         │
11│     调用工具、完成子任务、持续调整       │
12└─────────────────────────────────────┘
13

3.2 ReAct：Agent 的经典范式

ReAct（Reasoning + Acting）是 Agent 领域最经典的框架之一，来自 Princeton 和 Google Research 2022 年的论文。

核心思想：把推理（Reasoning）和行动（Acting）交织在一起，形成一个循环：

1┌──────────┐
2│  Thought │ ← 思考：我该做什么？
3└────┬─────┘
4     ↓
5┌──────────┐
6│  Action  │ ← 行动：调用工具执行
7└────┬─────┘
8     ↓
9┌──────────┐
10│ Observe  │ ← 观察：获取行动结果
11└────┬─────┘
12     ↓
13   循环，直到任务完成
14

3.3 用代码理解 Agent（LangChain ReAct）

下面是一个完整的 ReAct Agent 示例——旅行规划助手：

1import { ChatOpenAI } from "@langchain/openai";
2import { createReactAgent } from "@langchain/langgraph/prebuilt";
3import { tool } from "@langchain/core/tools";
4import { z } from "zod";
5
6// ====== Agent：旅行规划助手 ======
7// 没有预设流程，Agent 自己决定调用什么工具、按什么顺序
8
9const model = new ChatOpenAI({ modelName: "gpt-4" });
10
11// 定义 Agent 可以使用的工具
12const searchFlights = tool(
13  async ({ from, to, date }) => {
14    // 模拟搜索机票 API
15    return `${from}→${to}，${date}，经济舱约 ¥3500-5000`;
16  },
17  {
18    name: "search_flights",
19    description: "搜索机票价格，输入出发地、目的地、日期",
20    schema: z.object({
21      from: z.string().describe("出发城市"),
22      to: z.string().describe("目的地城市"),
23      date: z.string().describe("出发日期"),
24    }),
25  }
26);
27
28const searchWeather = tool(
29  async ({ city, month }) => {
30    return `${city} ${month}月：平均气温 25-30°C，多云为主`;
31  },
32  {
33    name: "search_weather",
34    description: "查询目的地天气",
35    schema: z.object({
36      city: z.string(),
37      month: z.number(),
38    }),
39  }
40);
41
42const searchVisa = tool(
43  async ({ from, to }) => {
44    return `中国公民前往日本：需要办理旅游签证，约 5-7 个工作日`;
45  },
46  {
47    name: "search_visa",
48    description: "查询签证要求",
49    schema: z.object({
50      from: z.string(),
51      to: z.string(),
52    }),
53  }
54);
55
56// 创建 ReAct Agent（不是 Chain！没有固定流程！）
57const travelAgent = createReactAgent({
58  llm: model,
59  tools: [searchFlights, searchWeather, searchVisa],
60});
61
62// 执行：Agent 会自己决定先查什么、再查什么
63const result = await travelAgent.invoke({
64  messages: [{
65    role: "user",
66    content: "帮我规划7月从北京到东京的旅行，预算5000元"
67  }]
68});
69

💡 关键区别：Workflow 的代码里，你能清楚看到"先干什么后干什么"。Agent 的代码里，你只定义了目标和可用工具，调用顺序是 Agent 自己决定的。

3.4 Agent 的执行过程（真实日志）

当你运行上面的 Agent，它可能走这样的路径：

1Thought: 用户预算5000元，我需要先了解机票和住宿的大致开销
2Action:  search_flights({ from: "北京", to: "东京", date: "2026-07-15" })
3Observe: 北京→东京，2026-07-15，经济舱约 ¥3500-5000
4
5Thought: 机票就占了大部分预算，我需要看看有没有更便宜的方案
6         同时查一下天气，看看7月去东京合不合适
7Action:  search_weather({ city: "东京", month: 7 })
8Observe: 东京 7月：平均气温 25-30°C，多云为主
9
10Thought: 天气还行。但预算紧张，我需要查签证费用，综合评估
11Action:  search_visa({ from: "中国", to: "日本" })
12Observe: 中国公民前往日本：需要办理旅游签证，约 5-7 个工作日
13
14Thought: 综合来看，机票+签证就接近5000了，住宿会超预算。
15         我建议用户考虑特价机票或者缩短行程...
16

看到了吗？ Agent 的路径是动态生成的——它发现预算不够，自动调整了策略。如果用 Workflow，流程是"查机票 → 查天气 → 查签证 → 生成计划"，不会根据中间结果灵活调整。

📚 四、核心区别对比：5 个维度深度拆解

一个比喻说清楚

Workflow 是有轨电车 🚋：路线固定、效率高、准时到站，但不能临时改道。

Agent 是老司机 🚗：知道目的地在哪，但遇到修路会绕行、发现近路会抄近道、甚至目的地变了也能自己调整。

📚 五、实战选型：什么时候用 Workflow，什么时候用 Agent？

5.1 Anthropic 的官方建议

Anthropic 在《Building Effective Agents》中给出了一个非常重要的原则：

**"Don't use agents when a workflow will do."**能用 Workflow 解决的问题，就不要上 Agent。

为什么？因为 Agent 的成本、延迟、不可控性都更高。简单就是最好的。

5.2 选型决策树

1你的任务可以拆成固定步骤吗？
2│
3├─ 是 → 步骤之间需要动态决策吗？
4│       ├─ 否 → ✅ 用 Workflow
5│       └─ 是 → ✅ 用 Workflow + Agent 混合
6│
7└─ 否 → 任务目标明确但路径不确定？
8        ├─ 是 → ✅ 用 Agent
9        └─ 否 → 先想清楚需求再来 😅
10

5.3 实战选型速查表

5.4 一个真实的技术选型故事

我在做一个智能客服项目时，最初方案是纯 Agent——觉得"智能"一点用户体验好。

结果发现两个问题：

1. 成本爆炸：每次对话 Agent 要调用 5-8 次 LLM（理解意图 → 查知识库 → 生成回复 → 检查质量 → 优化话术），token 费用是 Workflow 的 3 倍
2. 回复不稳定：同一个问题，Agent 两次回答可能不一样，客户投诉"怎么每次说的都不一样"

最终方案：Workflow 做主流程 + Agent 做异常处理

1用户消息 → Workflow 意图识别 → 分流
2                                ├─ 常见问题 → Workflow 固定回复（稳定、低成本）
3                                ├─ 复杂问题 → Agent 动态处理（灵活、智能）
4                                └─ 无法识别 → 转人工
5

这样既保证了 80% 常见问题的稳定回复，又让 20% 复杂问题有 Agent 的灵活性。

📚 六、未来趋势：Workflow + Agent 融合

纯 Workflow 太死板，纯 Agent 太不可控。未来的 AI 工程一定是两者结合：

1┌─────────────────────────────────────┐
2│           Agent（上层）              │
3│     灵活性 + 智能性 + 自主决策        │
4│     负责"做什么"——目标规划、动态调整   │
5├─────────────────────────────────────┤
6│          Workflow（底层）             │
7│     稳定性 + 可控性 + 确定性执行       │
8│     负责"怎么做"——标准化流程、工具调用  │
9└─────────────────────────────────────┘
10

Workflow 是骨架，Agent 是大脑。

用 LangGraph 实现这个架构：

1import { StateGraph, Annotation } from "@langchain/langgraph";
2
3// 定义状态
4const State = Annotation.Root({
5  input: Annotation<string>(),
6  taskType: Annotation<string>(),    // Agent 决定任务类型
7  result: Annotation<string>(),
8});
9
10// Workflow 节点：固定的处理流程
11async function processStandardTask(state) {
12  // 标准任务走固定流程，稳定高效
13  return { result: [`标准流程处理：${state.input}`](https://xplanc.org/primers/document/zh/03.HTML/EX.HTML%20%E5%85%83%E7%B4%A0/EX.input.md) };
14}
15
16// Agent 节点：动态决策
17async function agentDecide(state) {
18  // Agent 根据输入决定走哪个分支
19  const model = new ChatOpenAI({ modelName: "gpt-4" });
20  const decision = await model.invoke(
21    [`判断这个任务是"标准"还是"复杂"：${state.input}`](https://xplanc.org/primers/document/zh/03.HTML/EX.HTML%20%E5%85%83%E7%B4%A0/EX.input.md)
22  );
23  return { taskType: decision.content };
24}
25
26// 构建混合图谱
27const graph = new StateGraph(State)
28  .addNode("agent_decide", agentDecide)          // Agent 做决策
29  .addNode("standard_process", processStandardTask) // Workflow 做执行
30  .addEdge("__start__", "agent_decide")          // 先让 Agent 判断
31  .addConditionalEdges("agent_decide", (state) => {
32    return state.taskType === "standard"
33      ? "standard_process"   // 标准任务 → Workflow
34      : "complex_process";   // 复杂任务 → Agent 处理
35  })
36  .compile();
37

💡 重点总结

1. Workflow = 流水线：预设轨道，确定性执行，适合流程化、重复性任务
2. Agent = 探索者：动态决策，自主适应，适合开放性、不确定性任务
3. ReAct 框架：Agent 的经典范式，Thought → Action → Observe 循环
4. 选型原则：能用 Workflow 就别用 Agent（Anthropic 官方建议）
5. 实战经验：80% 标准流程用 Workflow + 20% 异常场景用 Agent
6. 未来趋势：Workflow（骨架）+ Agent（大脑）融合，既稳定又智能

❓ 常见问题 FAQ

Q1：Coze 工作流是 Agent 吗？

不是。Coze 工作流是典型的 Workflow——你在可视化界面里拖拽节点、连线，本质上是在编排一条固定的流程。Coze 也有 Bot 模式，那个更接近 Agent。

Q2：Workflow 和 Agent 哪个更贵？

Agent 通常更贵。因为 Agent 每一步都要调用 LLM 做推理，还可能多次调用工具。Workflow 的调用次数是固定的，成本可预测。

Q3：LangChain 的 Chain 和 Agent 有什么区别？

Chain = Workflow（固定链路，pipe 串联），Agent = 自主决策（动态选择工具和调用顺序）。

Q4：ReAct 和 Function Calling 有什么关系？

Function Calling 是 OpenAI 提供的工具调用能力，ReAct 是一种 Agent 推理框架。ReAct Agent 通常用 Function Calling 来执行 Action，但 ReAct 的核心是"推理+行动"的循环，不只是工具调用。

Q5：2025 年主流方案会是纯 Agent、纯 Workflow、还是融合？

大概率是融合。纯 Workflow 太死板，纯 Agent 太贵且不可控。业界已经在用 LangGraph 等框架构建 Workflow + Agent 混合架构。

🔗 参考资料

• Anthropic - Building Effective Agents
• ReAct: Synergizing Reasoning and Acting in Language Models (arXiv:2210.03629)
• LangChain 官方文档
• LangGraph 官方文档
• Coze 工作流文档

💬 交流讨论

你在实际项目中更倾向用 Workflow 还是 Agent？遇到过哪些坑？评论区聊聊，我会逐一回复！

你觉得 2025 年主流方案会是哪个？评论区扣个数字：

• 扣 1：纯 Agent（自主智能才是未来）
• 扣 2：纯 Workflow（稳定可控最重要）
• 扣 3：两者融合（取长补短才是正道）

觉得有用？点个赞👍收藏⭐关注👆，下一篇我会用 LangGraph 从零实现一个同时包含 Workflow 和 Agent 的智能客服系统，附完整可运行代码！

标签：AI Agent、Workflow、LangChain、ReAct、LangGraph、Agentic AI、面试

《🤯 面试被问 AI Workflow 和 Agent 有啥区别？3 张图 + 2 段代码讲清楚！》 是转载文章，点击查看原文。