智能体时代的降维打击：这5种工作流模式你认识几个？

小可爱awo

375人浏览 · 2026-05-24 17:53:07

小可爱awo · 2026-05-24 17:53:07 发布

在这里插入图片描述

🍃 予枫：个人主页
📚 个人专栏: 《Java 从入门到起飞》《读研码农的干货日常》《Java 面试刷题指南》

💻 Debug 这个世界，Return 更好的自己！

引言

当下AI已全面迈入Agentic时代，智能体不再是单一的简易工作流调用。多数开发者仍局限于传统链式Workflow认知，难以适配复杂企业级场景。本文基于LangGraph框架，深度拆解业界公认的5大经典Agentic Workflow模式，搭配完整实战代码与场景解析，帮你突破开发瓶颈，落地高质量AI Agent应用。

一、AGENTIC时代：WORKFLOW与AGENT的核心演进

随着ReAct推理范式普及，AI Agent完成了从固定工作流到自主智能推理的迭代升级。Anthropic、LangChain等头部框架统一了行业认知，将传统Workflow与自主Agent共同纳入Agentic范畴，二者互补适配不同业务场景。

1.1 两种核心模式的适配差异

✨ AGENT模式
适配复杂多变的业务场景，具备自主推理、自主选工具的能力，灵活性拉满，适合无固定流程、需要动态决策的需求。

✨ WORKFLOW模式
依托预设流程执行任务，优势是高效、稳定、结果可预测，无需盲目追求极致智能，是企业标准化场景的最优解。

1.2 打破传统认知误区

很多人对Workflow的印象仅停留在「输入→LLM1→LLM2→输出」的简单链式调用，但这只是最基础的形态。主流AI框架已迭代出5类高阶Workflow模式，可完美适配90%以上的企业级AI开发场景。

二、五大经典AGENTIC WORKFLOW模式实战拆解

本文所有案例均基于LangGraph框架实现，附带完整可运行代码、场景分析及架构逻辑，全程干货无废话。

2.1 PROMPT CHAINING（提示词链式模式）

核心思想

将复杂任务拆解为多步可验证的子任务，按照固定顺序执行，后一步依赖前一步的输出结果，每一步均可单独校验、纠错、回滚。

适用场景

阶梯式内容处理：文档初译→校对→润色
合规审核流程：内容检测→分类→风险处置
长文本多轮摘要、结构化信息提取

流程架构图

完整实战代码

import { StateGraph, StateSchema, GraphNode, ConditionalEdgeRouter } from "langgraph";
import { z } from "zod";
import { llm } from "./llm-config";

// 定义状态结构
const State = new StateSchema({
  topic: z.string(),
  joke: z.string(),
  improvedJoke: z.string(),
  finalJoke: z.string(),
});

// 第一步：生成初始内容
const generateJoke: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(`Write a short joke about ${state.topic}`);
  return { joke: msg.content };
};

// 校验节点：判断内容是否合格
const checkPunchline: ConditionalEdgeRouter<typeof State, "improveJoke"> = (state) => {
  if (state.joke?.includes("?") || state.joke?.includes("!")) {
    return "Pass";
  }
  return "Fail";
};

// 第二步：内容优化
const improveJoke: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(
    `Make this joke funnier by adding wordplay: ${state.joke}`
  );
  return { improvedJoke: msg.content };
};

// 第三步：最终润色
const polishJoke: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(
    `Add a surprising twist to this joke: ${state.improvedJoke}`
  );
  return { finalJoke: msg.content };
};

// 构建工作流
const chain = new StateGraph(State)
  .addNode("generateJoke", generateJoke)
  .addNode("improveJoke", improveJoke)
  .addNode("polishJoke", polishJoke)
  .addEdge("__start__", "generateJoke")
  .addConditionalEdges("generateJoke", checkPunchline, {
    Pass: "improveJoke",
    Fail: "__end__"
  })
  .addEdge("improveJoke", "polishJoke")
  .addEdge("polishJoke", "__end__")
  .compile();

模式优势

可控性极强，分步可校验、可纠错、可回滚，适合标准化、流程化的递进式任务，产出结果稳定可控。

2.2 PARALLELIZATION（并行化模式）

核心思想

将大任务拆解为多个独立子任务，通过多LLM节点同时并行执行，最终统一汇总整合结果，大幅提升处理效率。包含子任务并行、同任务多次执行择优两种形态。

适用场景

多维度素材生成：同步生成文案、标题、配图
多维度质量审核：从语法、逻辑、合规多维度并行检测
多源数据并行拉取、对比校验

流程架构图

完整实战代码

import { StateGraph, StateSchema, GraphNode } from "langgraph";
import { z } from "zod";
import { llm } from "./llm-config";

// 定义状态结构
const State = new StateSchema({
  topic: z.string(),
  joke: z.string(),
  story: z.string(),
  poem: z.string(),
  combinedOutput: z.string(),
});

// 并行任务1：生成段子
const callLlm1: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(`Write a joke about ${state.topic}`);
  return { joke: msg.content };
};

// 并行任务2：生成故事
const callLlm2: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(`Write a story about ${state.topic}`);
  return { story: msg.content };
};

// 并行任务3：生成诗歌
const callLlm3: GraphNode<typeof State> = async (state) => {
  const msg = await llm.invoke(`Write a poem about ${state.topic}`);
  return { poem: msg.content };
};

// 结果汇总节点
const aggregator: GraphNode<typeof State> = async (state) => {
  const combined = `Here's a story, joke, and poem about ${state.topic}!\n\n` +
    `STORY:\n${state.story}\n\n` +
    `JOKE:\n${state.joke}\n\n` +
    `POEM:\n${state.poem}`;
  return { combinedOutput: combined };
};

// 构建并行工作流
const parallelWorkflow = new StateGraph(State)
  .addNode("callLlm1", callLlm1)
  .addNode("callLlm2", callLlm2)
  .addNode("callLlm3", callLlm3)
  .addNode("aggregator", aggregator)
  .addEdge("__start__", "callLlm1")
  .addEdge("__start__", "callLlm2")
  .addEdge("__start__", "callLlm3")
  .addEdge("callLlm1", "aggregator")
  .addEdge("callLlm2", "aggregator")
  .addEdge("callLlm3", "aggregator")
  .addEdge("aggregator", "__end__")
  .compile();

模式优势

多任务同步执行，大幅缩短响应耗时，多维度输出一致性强，适合批量、多维度的并行处理场景。

2.3 ROUTING（路由模式）

核心思想

通过规则匹配或LLM智能判断，根据输入内容动态分发任务至对应处理分支，实现不同场景的差异化处理，是企业级AI应用最常用的模式。

适用场景

智能客服系统：价格咨询、退货售后、产品咨询分支分流
文本分类处理：根据内容类型分发翻译、总结、改写任务
多场景AI问答：精准匹配对应知识库与回答逻辑

流程架构图

完整实战代码

import { StateGraph, StateSchema, GraphNode, ConditionalEdgeRouter } from "langgraph";
import { z } from "zod";
import { llm } from "./llm-config";

// 定义路由规则结构体
const routeSchema = z.object({
  step: z.enum(["poem", "story", "joke"]).describe("路由分支选择")
});

const router = llm.withStructuredOutput(routeSchema);

// 定义状态结构
const State = new StateSchema({
  input: z.string(),
  decision: z.string(),
  output: z.string(),
});

// 各分支处理节点
const llmCall1: GraphNode<typeof State> = async (state) => {
  const result = await llm.invoke([{
    role: "system",
    content: "你是专业的故事创作者",
  }, {
    role: "user",
    content: state.input
  }]);
  return { output: result.content };
};

const llmCall2: GraphNode<typeof State> = async (state) => {
  const result = await llm.invoke([{
    role: "system",
    content: "你是专业的喜剧段子手",
  }, {
    role: "user",
    content: state.input
  }]);
  return { output: result.content };
};

const llmCall3: GraphNode<typeof State> = async (state) => {
  const result = await llm.invoke([{
    role: "system",
    content: "你是专业的诗歌创作者",
  }, {
    role: "user",
    content: state.input
  }]);
  return { output: result.content };
};

// 路由决策节点
const llmCallRouter: GraphNode<typeof State> = async (state) => {
  const decision = await router.invoke([
    { role: "system", content: "根据用户需求，分发至对应创作分支" },
    { role: "user", content: state.input },
  ]);
  return { decision: decision.step };
};

// 路由分发逻辑
const routeDecision: ConditionalEdgeRouter<typeof State, "llmCall1" | "llmCall2" | "llmCall3"> = (state) => {
  if (state.decision === "story") return "llmCall1";
  if (state.decision === "joke") return "llmCall2";
  return "llmCall3";
};

// 构建路由工作流
const routerWorkflow = new StateGraph(State)
  .addNode("llmCall1", llmCall1)
  .addNode("llmCall2", llmCall2)
  .addNode("llmCall3", llmCall3)
  .addNode("llmCallRouter", llmCallRouter)
  .addEdge("__start__", "llmCallRouter")
  .addConditionalEdges("llmCallRouter", routeDecision, ["llmCall1", "llmCall2", "llmCall3"])
  .addEdge("llmCall1", "__end__")
  .addEdge("llmCall2", "__end__")
  .addEdge("llmCall3", "__end__")
  .compile();

模式优势

适配多场景差异化处理，支持规则/LLM双路由逻辑，灵活度高，可大幅提升AI应用的场景适配能力。

2.4 ORCHESTRATOR-WORKER（编排器-工作者模式）

核心思想

通过中央编排器动态拆解任务、规划执行方案，再分发给多个工作者节点并行执行，最终汇总合成最终结果，任务拆解无需提前预设，全程动态生成。

适用场景

复杂报告、论文结构化撰写（先搭大纲，再分章节撰写）
多文件代码生成（动态拆解文件模块，分模块开发）
批量多文档解析、处理、整合

流程架构图

完整实战代码

import { StateGraph, StateSchema, GraphNode, ReducedValue } from "langgraph";
import { z } from "zod";
import { llm } from "./llm-config";

// 定义章节结构
type SectionSchema = {
  name: string;
  description: string;
};
const sectionsSchema = z.object({
  sections: z.array(z.object({
    name: z.string(),
    description: z.string()
  }))
});

const planner = llm.withStructuredOutput(sectionsSchema);

// 主状态结构
const State = new StateSchema({
  topic: z.string(),
  sections: z.array(z.custom<{sections: SectionSchema[]}>()),
  completedSections: new ReducedValue(
    z.array(z.string()).default(() => []),
    { reducer: (a, b) => a.concat(b) }
  ),
  finalReport: z.string(),
});

// 工作者状态结构
const WorkerState = new StateSchema({
  section: z.custom<SectionSchema>(),
  completedSections: new ReducedValue(
    z.array(z.string()).default(() => []),
    { reducer: (a, b) => a.concat(b) }
  ),
});

// 编排器：任务拆解规划
const orchestrator: GraphNode<typeof State> = async (state) => {
  const reportSections = await planner.invoke([
    { role: "system", content: "为报告生成详细的章节大纲" },
    { role: "user", content: `报告主题：${state.topic}` },
  ]);
  return { sections: reportSections.sections };
};

// 工作者：子任务执行
const llmCall: GraphNode<typeof WorkerState> = async (state) => {
  const section = await llm.invoke([
    {
      role: "system",
      content: "根据章节名称和描述撰写内容，使用Markdown格式，无多余开场白",
    },
    {
      role: "user",
      content: `章节名称：${state.section.name}，章节描述：${state.section.description}`,
    },
  ]);
  return { completedSections: [section.content] };
};

// 合成器：汇总所有子任务结果
const synthesizer: GraphNode<typeof State> = async (state) => {
  const completedReportSections = state.completedSections.join("\n\n---\n\n");
  return { finalReport: completedReportSections };
};

// 动态分配工作者任务
const assignWorkers = (state: typeof State) => {
  return state.sections.map((section) => ({
    node: "llmCall",
    input: { section }
  }));
};

// 构建编排工作流
const orchestratorWorker = new StateGraph(State)
  .addNode("orchestrator", orchestrator)
  .addNode("llmCall", llmCall)
  .addNode("synthesizer", synthesizer)
  .addEdge("__start__", "orchestrator")
  .addConditionalEdges("orchestrator", assignWorkers, ["llmCall"])
  .addEdge("llmCall", "synthesizer")
  .addEdge("synthesizer", "__end__")
  .compile();

模式优势

动态适配复杂未知任务，无需提前定义子任务数量，灵活度五大模式最高，适配大型复杂AI生成场景。

2.5 EVALUATOR-OPTIMIZER（评估-优化模式）

核心思想

模拟人类「创作-审核-修改」的迭代逻辑，由生成器产出内容，评估器按照既定标准校验，不达标则循环优化，直至满足质量要求。

适用场景

文案润色、创意内容迭代优化
代码编写、审查、BUG修复
翻译内容精细化打磨（信达雅标准）
搜索结果、AI回答质量排序优化

流程架构图

完整实战代码

import { StateGraph, StateSchema, GraphNode, ConditionalEdgeRouter } from "langgraph";
import { z } from "zod";
import { llm } from "./llm-config";

// 定义评估规则结构体
const feedbackSchema = z.object({
  grade: z.enum(["funny", "not funny"]).describe("内容质量评级"),
  feedback: z.string().describe("优化反馈建议")
});

const evaluator = llm.withStructuredOutput(feedbackSchema);

// 定义状态结构
const State = new StateSchema({
  joke: z.string(),
  topic: z.string(),
  feedback: z.string(),
  funnyOrNot: z.string(),
});

// 内容生成器
const llmCallGenerator: GraphNode<typeof State> = async (state) => {
  let msg;
  if (state.feedback) {
    msg = await llm.invoke(
      `Write a joke about ${state.topic} but take into account the feedback: ${state.feedback}`
    );
  } else {
    msg = await llm.invoke(`Write a joke about ${state.topic}`);
  }
  return { joke: msg.content };
};

// 内容评估器
const llmCallEvaluator: GraphNode<typeof State> = async (state) => {
  const grade = await evaluator.invoke(`Grade the joke ${state.joke}`);
  return { funnyOrNot: grade.grade, feedback: grade.feedback };
};

// 迭代路由逻辑
const routeJoke: ConditionalEdgeRouter<typeof State, "llmCallGenerator"> = (state) => {
  if (state.funnyOrNot === "funny") {
    return "Accepted";
  } else {
    return "Rejected + Feedback";
  }
};

// 构建迭代优化工作流
const optimizerWorkflow = new StateGraph(State)
  .addNode("llmCallGenerator", llmCallGenerator)
  .addNode("llmCallEvaluator", llmCallEvaluator)
  .addEdge("__start__", "llmCallGenerator")
  .addEdge("llmCallGenerator", "llmCallEvaluator")
  .addConditionalEdges(
    "llmCallEvaluator",
    routeJoke,
    {
      "Accepted": "__end__",
      "Rejected + Feedback": "llmCallGenerator"
    }
  )
  .compile();

模式优势

通过闭环迭代优化大幅提升内容质量，适配无标准答案、有明确评判标准的场景，产出效果更贴合业务需求。

三、五大WORKFLOW模式核心对比与选型指南

模式	核心优势	复杂度	适用场景关键词
提示词链式	可控、稳定、可校验	低	阶梯式、标准化、流程化任务
并行化	高效、多维度同步输出	低	多子任务、多维度、批量处理
路由	灵活分流、场景适配强	中	多场景、分类分发、智能客服
编排器-工作者	动态拆解、适配复杂任务	高	大型报告、多模块、未知子任务
评估-优化	迭代精进、质量可控	中	内容优化、代码打磨、质量迭代