如果你还在用 AI「生成代码」，那你只用了它 10% 的能力。真正高效的开发团队，已经把 AI 变成「自主执行系统」——72% 的工程团队采用 Agentic workflows，开发效率提升 30-50%。
本文亮点：
- ✅ 7 种核心工作流模式详解
- ✅ 每种模式配完整可运行 Python 代码
- ✅ 选择指南 + 8 个关键实践
- ✅ 基于 Anthropic 最新工程实践
从「代码生成器」到「自主执行系统」
2026 年，AI 编程的最大变化不是模型更强了，而是工作流变了。
传统模式下，你给 AI 一个指令，它返回代码，你复制粘贴，手动调试。这叫「单次提示」——效率提升有限，错误率高，每一步都要你盯着。
Agentic Coding 完全不同：你给 AI 一个目标，它自己规划、执行、测试、迭代，直到任务完成。你从「指挥每一行代码」变成「指挥整个任务」。
这背后的核心是工作流模式——把 AI 包装成一个能自主思考、行动、反思的系统。Anthropic 的研究显示：用正确工作流包装的弱模型，比强模型的单次提示效果更好。
传统 AI 编程 vs Agentic Coding：差距在哪？
| 维度 | 传统模式 | Agentic 工作流 |
|---|---|---|
| 输入方式 | 模糊指令（"帮我写个登录页"） | 明确规格（输出、约束、验证标准） |
| 执行过程 | 一次性输出，你手动调试 | 分阶段执行，每步可检查 |
| 错误处理 | 出错了你重来 | AI 自己测试、修正、迭代 |
| 影响范围 | 一改错，全局影响 | 分步提交，错误只影响当步 |
| 效率提升 | 10-20% | 30-50%（实测数据） |
差距的核心：传统模式靠你控细节，Agentic 模式靠你控流程。
7 种核心工作流模式：从简单到复杂（附完整代码）
模式 1：Prompt Chaining（提示链）——入门首选
原理：把复杂任务拆成固定序列，每一步输出成为下一步输入。AI 不需要一次想完所有事，只做当前这一步。
适用场景：任务步骤明确、顺序固定、不需要动态决策。比如：调研 → 列大纲 → 写初稿 → 优化。
完整代码实现：
# prompt_chaining.py - 提示链模式完整实现
# 依赖：pip install openai
import os
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def prompt_chain(topic: str) -> str:
"""
三步提示链：调研 → 大纲 → 最终报告
每步输出成为下一步输入
"""
# Step 1: 调研并列出关键事实
step1_response = client.chat.completions.create(
model="gpt-4o-mini", # 调研用便宜模型即可
messages=[
{"role": "system", "content": "你是一个研究助手。列出 10 个关键事实，用 JSON 格式输出。"},
{"role": "user", "content": f"请调研主题：{topic}，列出 10 个关键事实。"}
],
response_format={"type": "json_object"}
)
facts = step1_response.choices[0].message.content
# Step 2: 基于事实创建大纲
step2_response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "你是一个大纲规划师。基于给定事实创建结构大纲。"},
{"role": "user", "content": f"基于以下事实创建报告大纲：\n{facts}"}
]
)
outline = step2_response.choices[0].message.content
# Step 3: 基于大纲写最终报告
step3_response = client.chat.completions.create(
model="gpt-4o", # 最终写作用强模型
messages=[
{"role": "system", "content": "你是一个专业作家。基于大纲写完整报告，2000 字左右。"},
{"role": "user", "content": f"基于以下大纲写完整报告：\n{outline}"}
]
)
return step3_response.choices[0].message.content
# 使用示例
if __name__ == "__main__":
report = prompt_chain("2026 年 AI Agent 发展趋势")
print(report)
# 保存结果
with open("report.md", "w", encoding="utf-8") as f:
f.write(report)
关键规则：
- 每步只做一件事
- 步骤之间用明确格式传递信息（如 JSON）
- 单步可独立测试和优化
模式 2：Routing（路由）——分类分发
原理：先分类输入，再分发到专家处理器。不同类型问题走不同路径。
适用场景：处理多类型输入，比如客服系统（账单、技术、通用咨询分开）。
完整代码实现：
# routing.py - 路由模式完整实现
# 依赖：pip install openai
import os
import json
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# 定义专家处理器
EXPERT_PROMPTS = {
"billing": "你是一个账单专家。回答账单、支付、退款相关问题。给出具体金额和日期。",
"technical": "你是一个技术支持专家。回答产品使用、故障排查问题。给出步骤化解决方案。",
"general": "你是一个通用客服。回答其他问题，保持友好专业。"
}
def classify_input(user_input: str) -> str:
"""分类输入为 billing/technical/general"""
response = client.chat.completions.create(
model="gpt-4o-mini", # 分类用便宜快速模型
messages=[
{"role": "system", "content": "将用户问题分类为 billing/technical/general，只返回类别名。"},
{"role": "user", "content": user_input}
],
max_tokens=10
)
return response.choices[0].message.content.strip().lower()
def route_and_respond(user_input: str) -> str:
"""路由到对应专家并返回响应"""
# Step 1: 分类
category = classify_input(user_input)
print(f"分类结果：{category}")
# Step 2: 分发到专家处理器
expert_prompt = EXPERT_PROMPTS.get(category, EXPERT_PROMPTS["general"])
response = client.chat.completions.create(
model="gpt-4o", # 处理用强模型
messages=[
{"role": "system", "content": expert_prompt},
{"role": "user", "content": user_input}
]
)
return response.choices[0].message.content
# 使用示例
if __name__ == "__main__":
test_cases = [
"我的账单为什么扣了两次钱？",
"APP 登录一直失败怎么办？",
"你们公司地址在哪里？"
]
for case in test_cases:
print(f"\n用户问题：{case}")
answer = route_and_respond(case)
print(f"回答：{answer[:100]}...")
关键规则：
- 分类用便宜快速模型，处理用强模型
- 每条路径可独立优化
- 成本和速度都能控制
模式 3：Parallelisation（并行执行）——效率翻倍
原理：独立子任务同时执行，最后汇总结果。
适用场景：任务可拆成独立部分，比如分析长文档（三段同时分析）、多方案对比。
完整代码实现：
# parallelisation.py - 并行执行模式完整实现
# 依赖：pip install openai asyncio
import os
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
async def analyze_section(section_text: str, focus: str) -> dict:
"""分析文档的一个部分"""
response = await client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": f"分析文档片段，聚焦：{focus}。返回 JSON：{{'key_points': [], 'summary': ''}}"},
{"role": "user", "content": section_text}
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
async def parallel_analyze(document: str) -> dict:
"""
并行分析文档的三个部分
"""
# 将文档拆分为三部分（简化处理，按字数均分）
chunk_size = len(document) // 3
sections = [
document[:chunk_size],
document[chunk_size:2*chunk_size],
document[2*chunk_size:]
]
# 并行执行三个分析任务
results = await asyncio.gather(
analyze_section(sections[0], "关键观点"),
analyze_section(sections[1], "支撑证据"),
analyze_section(sections[2], "结论和建议")
)
# 汇总结果
summary = {
"key_points": [],
"section_summaries": []
}
for i, result in enumerate(results):
summary["key_points"].extend(result.get("key_points", []))
summary["section_summaries"].append({
"section": i + 1,
"summary": result.get("summary", "")
})
return summary
# 使用示例
if __name__ == "__main__":
# 模拟长文档
long_doc = "..." * 1000 # 实际使用时替换为真实文档
# 运行并行分析
result = asyncio.run(parallel_analyze(long_doc))
print(f"提取 {len(result['key_points'])} 个关键点")
print(json.dumps(result, indent=2, ensure_ascii=False))
关键规则：
- 子任务必须独立（不互相依赖）
- 用 asyncio 或多线程实现并行
- 汇总步骤要清晰定义
模式 4：Orchestrator–Workers（协调者 - 工人）——动态拆解
原理：中心协调者动态分解任务，决定需要哪些子任务，分发给工人执行，最后汇总。
适用场景：任务步骤不固定，需要 AI 自己判断做什么。比如：修改代码（文件数量、改动类型不确定）。
完整代码实现：
# orchestrator_workers.py - 协调者 - 工人模式完整实现
# 依赖：pip install openai
import os
import json
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def orchestrator(task: str) -> list:
"""
协调者：分析任务，动态决定子任务列表
"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "你是一个任务协调者。分析任务，拆分为子任务列表。返回 JSON：{'subtasks': [{'id': 1, 'description': '', 'file': ''}]}"},
{"role": "user", "content": f"任务：{task}"}
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)["subtasks"]
def worker(subtask: dict, context: str = "") -> str:
"""
工人：执行具体子任务
"""
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "你是一个代码工人。执行具体任务，返回修改后的代码或说明。"},
{"role": "user", "content": f"任务：{subtask['description']}\n上下文：{context}"}
]
)
return response.choices[0].message.content
def orchestrator_workers_flow(task: str) -> dict:
"""
完整流程：协调者规划 → 工人执行 → 汇总结果
"""
# Step 1: 协调者规划
print(f"任务：{task}")
subtasks = orchestrator(task)
print(f"拆分为 {len(subtasks)} 个子任务")
# Step 2: 工人执行（顺序执行，实际可并行）
results = []
context = ""
for subtask in subtasks:
print(f"执行子任务：{subtask['description']}")
result = worker(subtask, context)
results.append({
"subtask_id": subtask["id"],
"result": result
})
context += f"\n已完成：{subtask['description']}\n结果：{result[:200]}"
# Step 3: 汇总
return {
"task": task,
"subtasks_completed": len(subtasks),
"results": results
}
# 使用示例
if __name__ == "__main__":
task = "为 Python 项目添加用户认证功能，包括登录、注册、JWT token"
result = orchestrator_workers_flow(task)
print(f"\n完成 {result['subtasks_completed']} 个子任务")
for r in result["results"]:
print(f"子任务 {r['subtask_id']}: {r['result'][:100]}...")
关键规则：
- 协调者负责规划和汇总
- 工人只执行具体任务
- 子任务数量动态决定
模式 5：Evaluator–Optimizer（评估者 - 优化者）——质量循环
原理：生成者产出内容 → 评估者批评 → 生成者改进 → 循环直到达标。
适用场景：首次输出质量不够，需要迭代优化。比如：写文章、生成方案。
完整代码实现：
# evaluator_optimizer.py - 评估者 - 优化者模式完整实现
# 依赖：pip install openai
import os
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def generator(task: str, feedback: str = None) -> str:
"""生成者：产出内容"""
messages = [
{"role": "system", "content": "你是一个内容生成者。产出高质量内容。"}
]
if feedback:
messages.append({"role": "user", "content": f"根据以下反馈改进内容：\n{feedback}\n\n原始任务：{task}"})
else:
messages.append({"role": "user", "content": task})
response = client.chat.completions.create(
model="gpt-4o",
messages=messages
)
return response.choices[0].message.content
def evaluator(content: str, criteria: list) -> dict:
"""评估者：批评内容"""
criteria_str = "\n".join([f"- {c}" for c in criteria])
response = client.chat.completions.create(
model="gpt-4o-mini", # 评估用便宜模型
messages=[
{"role": "system", "content": f"你是一个严格的评估者。按以下标准评估内容：\n{criteria_str}\n\n返回 JSON：{{'approved': bool, 'feedback': ''}}"},
{"role": "user", "content": content}
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
def evaluator_optimizer_loop(task: str, criteria: list, max_iterations: int = 3) -> str:
"""
完整循环：生成 → 评估 → 改进 → 直到达标或达到最大迭代次数
"""
output = None
feedback = None
for i in range(max_iterations):
print(f"\n[迭代 {i+1}/{max_iterations}]")
# 生成
output = generator(task, feedback)
print(f"生成内容长度：{len(output)} 字")
# 评估
evaluation = evaluator(output, criteria)
print(f"评估结果：{'通过' if evaluation['approved'] else '需改进'}")
if evaluation["approved"]:
print("内容达标，退出循环")
break
feedback = evaluation["feedback"]
print(f"改进建议：{feedback[:100]}...")
return output
# 使用示例
if __name__ == "__main__":
task = "写一篇 500 字的 Python 学习指南"
criteria = [
"内容准确，无技术错误",
"结构清晰，有标题和段落",
"包含至少 2 个代码示例",
"语言流畅，适合初学者"
]
final_content = evaluator_optimizer_loop(task, criteria, max_iterations=3)
print(f"\n=== 最终内容 ===\n{final_content}")
关键规则：
- 评估标准要明确（准确性、清晰度、完整性）
- 最大迭代次数设上限（避免死循环）
- 评估者可用便宜模型，生成者用强模型
模式 6：ReAct（推理 + 行动）——边想边做
原理：AI 先思考下一步做什么 → 执行工具调用 → 观察结果 → 再思考 → 循环。
适用场景：需要动态决策的任务，比如搜索调研、API 调用。
完整代码实现：
# react_agent.py - ReAct 模式完整实现
# 依赖：pip install openai duckduckgo-search
import os
import json
from openai import OpenAI
from duckduckgo_search import DDGS
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# 可用工具
TOOLS = {
"web_search": lambda q: list(DDGS().text(q, max_results=3)),
"calculate": lambda expr: eval(expr) # 简化版，生产环境用安全计算器
}
TOOL_DESCRIPTIONS = {
"web_search": "搜索网络获取最新信息。参数：query（搜索词）",
"calculate": "执行数学计算。参数：expression（数学表达式）"
}
def react_agent(question: str, max_iterations: int = 5) -> str:
"""
ReAct 循环：Thought → Action → Observation → 循环
"""
messages = [
{"role": "system", "content": """你是一个 ReAct 助手。按以下格式思考：
Thought: 分析当前情况，决定下一步
Action: 选择工具（web_search 或 calculate）
Action Input: {"query": "..."} 或 {"expression": "..."}
Observation: 等待工具返回结果
当有足够信息时，返回：
Thought: 信息足够
Final Answer: 最终答案"""},
{"role": "user", "content": question}
]
for i in range(max_iterations):
print(f"\n[迭代 {i+1}/{max_iterations}]")
# 获取 AI 的思考和行动
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
max_tokens=500
)
ai_response = response.choices[0].message.content
print(f"AI 响应：{ai_response[:200]}...")
# 检查是否有 Final Answer
if "Final Answer:" in ai_response:
final_answer = ai_response.split("Final Answer:")[1].strip()
return final_answer
# 解析 Action
if "Action:" in ai_response and "Action Input:" in ai_response:
action_line = ai_response.split("Action:")[1].split("Action Input:")[0].strip()
input_str = ai_response.split("Action Input:")[1].split("\n")[0].strip()
try:
action_input = json.loads(input_str)
except:
messages.append({"role": "assistant", "content": ai_response})
messages.append({"role": "user", "content": "Action Input 格式错误，请用 JSON 格式"})
continue
# 执行工具
if action_line == "web_search":
observation = TOOLS["web_search"](action_input.get("query", ""))
observation = f"搜索结果：{observation}"
elif action_line == "calculate":
try:
result = TOOLS["calculate"](action_input.get("expression", "0"))
observation = f"计算结果：{result}"
except Exception as e:
observation = f"计算错误：{e}"
else:
observation = f"未知工具：{action_line}"
print(f"Observation: {observation[:100]}...")
# 添加对话历史
messages.append({"role": "assistant", "content": ai_response})
messages.append({"role": "user", "content": f"Observation: {observation}\n继续思考下一步"})
else:
messages.append({"role": "assistant", "content": ai_response})
messages.append({"role": "user", "content": "请继续，使用 Action 调用工具或返回 Final Answer"})
return "达到最大迭代次数，未能完成任务"
# 使用示例
if __name__ == "__main__":
question = "2026 年诺贝尔奖得主是谁？他们的年龄总和是多少？"
answer = react_agent(question)
print(f"\n=== 最终答案 ===\n{answer}")
关键规则：
- 每步明确记录 Thought-Action-Observe
- 工具调用要有 fallback（搜索失败改查询词）
- 循环直到任务完成
模式 7：Multi-Agent Collaboration（多智能体协作）——最强模式
原理：多个持久身份的专家智能体协作，各自有专属角色、工具、专业领域。
适用场景：复杂系统，需要多视角协作。比如：研究报告（调研、批评、写作三个智能体）。
完整代码实现：
# multi_agent_collab.py - 多智能体协作模式完整实现
# 依赖：pip install openai
import os
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
class Agent:
"""智能体基类"""
def __init__(self, name: str, role: str, tools: list = None):
self.name = name
self.role = role
self.tools = tools or []
def act(self, task: str, context: str = "") -> str:
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": f"你是{self.name}，{self.role}。专注你的专业领域。"},
{"role": "user", "content": f"任务：{task}\n上下文：{context}"}
]
)
return response.choices[0].message.content
# 定义三个专家智能体
research_agent = Agent(
name="Researcher",
role="研究专家，负责搜集信息、整理事实、提供数据支撑"
)
critic_agent = Agent(
name="Critic",
role="批评专家，负责评估信息质量、标记可信/存疑、指出逻辑漏洞"
)
writer_agent = Agent(
name="Writer",
role="写作专家，负责基于可信信息撰写最终报告"
)
def multi_agent_collaboration(topic: str) -> str:
"""
多智能体协作流程：
1. Researcher 调研主题
2. Critic 评估证据质量
3. Writer 基于可信证据写作
"""
print(f"\n=== 开始多智能体协作：{topic} ===")
# Step 1: Researcher 调研
print("\n[Researcher 工作中...]")
research_output = research_agent.act(f"调研主题：{topic}，列出 10 个关键事实和数据来源")
print(f"Researcher 完成，输出 {len(research_output)} 字")
# Step 2: Critic 评估
print("\n[Critic 评估中...]")
critic_output = critic_agent.act(
"评估以下研究结果的质量，标记每个事实为 可信/存疑/需验证，并说明理由",
research_output
)
print(f"Critic 完成，输出 {len(critic_output)} 字")
# Step 3: Writer 写作
print("\n[Writer 写作中...]")
final_report = writer_agent.act(
f"基于以下研究和评估撰写最终报告，只使用标记为'可信'的事实，2000 字左右",
f"研究结果：\n{research_output}\n\n评估意见：\n{critic_output}"
)
print(f"Writer 完成，输出 {len(final_report)} 字")
return final_report
# 使用示例
if __name__ == "__main__":
topic = "2026 年 AI Agent 在医疗领域的应用现状"
report = multi_agent_collaboration(topic)
print(f"\n=== 最终报告 ===\n{report[:500]}...")
# 保存完整报告
with open("multi_agent_report.md", "w", encoding="utf-8") as f:
f.write(f"# {topic}\n\n{report}")
关键规则：
- 每个智能体有固定角色（不重新分配）
- 智能体之间可传递工作、可批评对方
- 协调机制要清晰（谁传给谁）
选择指南：哪种模式适合你？
| 任务特点 | 推荐模式 | 理由 | 代码复杂度 |
|---|---|---|---|
| 步骤明确、顺序固定 | Prompt Chaining | 最简单，易控制 | ⭐ |
| 多类型输入需要分类处理 | Routing | 分担压力，成本可控 | ⭐⭐ |
| 可拆成独立部分 | Parallelisation | 效率翻倍 | ⭐⭐ |
| 步骤不固定，需要动态判断 | Orchestrator–Workers | 灵活适应 | ⭐⭐⭐ |
| 首次输出不够好 | Evaluator–Optimizer | 质量保障 | ⭐⭐ |
| 需要边想边调 | ReAct | 动态决策 | ⭐⭐⭐ |
| 多视角复杂任务 | Multi-Agent | 专业协作 | ⭐⭐⭐⭐ |
Anthropic 的核心建议：能用 Prompt Chaining 就别用 Multi-Agent。越复杂的模式，成本和延迟越高。只在任务真的需要时才用复杂模式。
8 个关键实践：避免 Agentic Coding 的常见错误
根据 Blink Blog 的工程团队实践，这 8 个规则能避免最昂贵的错误：
-
先写规格，再给指令：模糊指令（"帮我做个设置页"）让 AI 自己猜，几乎必错。明确规格：输出是什么、约束是什么、怎么验证成功。
-
先用 Plan Mode，再执行：Claude Code 的 Plan Mode（Shift+Tab）让 AI 先规划不写代码，你审计划，错了免费改。
-
每步提交，分步确认：别让 AI 跑 45 分钟再检查。每完成一个逻辑单元就 commit，错误范围最小。
-
控制上下文：AI 会"忘记"早期指令。用
/clear（重置）或/compact（压缩）保持上下文新鲜。 -
在决策点介入，不是只在结尾：AI 选库、改组件时，你先确认。错误选择到结尾才发现，代价是重做。
-
每次改动后测试：给 AI 验证方式（测试用例），它自己发现错误，不用你盯着。
-
用 CLAUDE.md/AGENTS.md 配置：把代码风格、测试框架、架构规则写成配置文件，AI 每次自动读取，不用猜。
-
限制影响范围：模糊指令（"重构认证系统"）让 AI 满代码库改。明确范围："把 token-refresh 逻辑从 auth.ts 提到 token-refresh.ts"。
你的下一步：从今天开始用 Agentic Workflow
如果你还在用 AI「生成代码」，今天试试这个流程：
- 打开 Claude Code 或 Cursor
- 先写明确规格：输出、约束、验证标准
- 进入 Plan Mode：让 AI 规划，你审核
- 分步执行：每步 commit，每步测试
- 对比效率：记录时间，看提升多少
72% 的团队已经用 Agentic workflows 效率提升 30-50%。你还在等什么？
互动引导：
- 你用过哪种 Agentic 模式？效果如何？
- 在评论区分享你的实践，我们一起讨论。
- 关注我，获取更多 AI 编程实战教程。
声明：本文代码示例可在 GitHub 获取完整版本，欢迎 Star 和 PR。
关键词：agentic-workflow, ai-programming, developer-efficiency, llm-agents
