多数人对AI Agent的理解还停留在"聊天机器人的升级版"，这个思路在一段时间里这么理解其实也没什问题，比如问一个问题，拿到一个回答。但很快就能看出来单轮提示-响应的交互根本没有任何的意义，而真正有意义的跃迁发生在AI开始具备这些能力的时候：思考、规划、行动、观察、循环往复，这和我们处理复杂问题的方式几乎一致。
这就是Agentic AI的内核，而要构建这样的系统就必须理解支撑它运转的几种核心设计模式。
本文拆解当下重塑AI系统构建方式的4种核心 Agentic 模式，分析每种模式的工作机制、适用场景，以及如何将它们组合出真正可用的系统。
为什么 Agentic 模式现在如此重要？传统大语言模型（LLM）聪明但脆弱。面对一个查询，它能一次性给出响应，却无法自我纠正、反复迭代或制定执行计划。这类模型不具备像人那样的外部交互能力，无法浏览网页，无法生成缩略图、写脚本、剪视频再把成品发布到 YouTube 频道，更不用说并行完成这些操作。
Agentic 模式就是针对这些局限的解法。
它把一个静态的语言模型改造成动态推理引擎：将复杂任务拆解为多个简单子任务，再由多 Agent 协作逐一完成。在这个过程中，Agent 可以调用外部工具、校验自身输出、与其他 Agent 协同工作——单轮提示根本不可能覆盖这些场景。
模式1：Reflection 让 Agent 学会自我审视在报社工作，主编让你写一篇特稿。写完之后交稿前你会自己通读一遍，排查事实错误、找出论证薄弱的地方、核实信源、修改结论，这一轮自审就是"反思"。
LLM 可以做同样的事，审视自己生成的内容在返回结果之前迭代改进。
最简单的形态下，Reflection 是一个两步循环。第一步，Agent 生成初始输出（代码、文章、研究报告等）；第二步，同一个 Agent 或另一个专职"评审"Agent 对输出进行分析，识别缺陷和可改进之处。这个循环可以反复执行，直到输出质量达到预设阈值。
Figure: Reflection based Agentic Pattern
代码示例：
# Agent生成响应，批评它，然后改进它。 # 安装: pip install ollama # 需要: Ollama在本地运行 → https://ollama.com # 先拉取模型: ollama pull llama3.2 import ollama MODEL = "llama3.2" def generate(prompt: str) -> str: response = ollama.chat( model=MODEL, messages=[{"role": "user", "content": prompt}] ) return response["message"]["content"] def reflect_and_improve(task: str, iterations: int = 2) -> str: print(f"📝 Task: {task}\n") # 步骤1: 生成初始回答 draft = generate(task) print(f"--- Draft ---\n{draft}\n") for i in range(iterations): # 步骤2: 批评草稿 critique_prompt = f""" You are a strict reviewer. Here is a task and a draft response. Task: {task} Draft: {draft} Identify weaknesses or errors in the draft, then write an improved version. """ draft = generate(critique_prompt) print(f"--- Iteration {i + 1} ---\n{draft}\n") return draft if __name__ == "__main__": final = reflect_and_improve( task="Explain what a Large Language Model is in 3 sentences." ) print(f"✅ Final Answer:\n{final}")
典型应用场景包括：代码生成中的"生成-测试-定位Bug-重新生成"循环；创意写作中对语调和清晰度的反复打磨；数据分析中对逻辑缺陷的自查与修正；数学推理中逐步验证并修复中间步骤的错误。
模式2：Tool Use，给 Agent 装上手脚工具使用让 Agent 能够与训练数据之外的真实世界交互。
Tool Use（也叫 Function Calling）的基本流程是这样的：Agent 收到任务后判断是否需要借助外部工具；如果需要，生成一个结构化的工具调用请求；工具执行后返回结果；Agent 将结果纳入推理链继续处理。
Figure: Tool-Use Agentic Pattern
代码示例：
# 模式2: 工具使用 # Agent决定何时调用外部工具（搜索、计算器、天气） # 并将其结果纳入最终回答。 # 安装: pip install ollama requests # 需要: Ollama在本地运行 → https://ollama.com # 先拉取模型: ollama pull llama3.2 import ollama import requests import json MODEL = "llama3.2" # ── 定义的工具 ────────────────────────────────────────────────────────────── def get_weather(city: str) -> str: """Fetch current weather for a city using the free Open-Meteo API.""" # 步骤1: 将城市名称地理编码为经纬度 geo = requests.get( "https://geocoding-api.open-meteo.com/v1/search", params={"name": city, "count": 1} ).json() if not geo.get("results"): return f"Could not find location for '{city}'." lat = geo["results"][0]["latitude"] lon = geo["results"][0]["longitude"] # 步骤2: 获取天气 weather = requests.get( "https://api.open-meteo.com/v1/forecast", params={ "latitude": lat, "longitude": lon, "current_weather": True } ).json() current = weather["current_weather"] return ( f"Weather in {city}: {current['temperature']}°C, " f"wind speed {current['windspeed']} km/h." ) def calculator(expression: str) -> str: """Safely evaluate a basic math expression.""" try: result = eval(expression, {"__builtins__": {}}) return f"Result of '{expression}' = {result}" except Exception as e: return f"Error evaluating expression: {e}" # 工具注册表 - 将工具名称映射到函数 TOOLS = { "get_weather": get_weather, "calculator": calculator, } # 发送给模型的工具描述，让它知道有哪些可用工具 TOOL_DESCRIPTIONS = """ You have access to the following tools. Call a tool by responding with JSON in this exact format: {"tool": "<tool_name>", "args": {"<arg>": "<value>"}} Available tools: 1. get_weather(city: str) — Returns the current weather for a city. 2. calculator(expression: str) — Evaluates a math expression like "12 * 9". If you don't need a tool, just answer directly in plain text. Only call ONE tool per response. """ # ── Agent循环 ───────────────────────────────────────────────────────────────── def run_tool_agent(user_query: str) -> str: print(f"🧠 Query: {user_query}\n") messages = [ {"role": "system", "content": TOOL_DESCRIPTIONS}, {"role": "user", "content": user_query} ] for step in range(5): # 最多5步 response = ollama.chat(model=MODEL, messages=messages) reply = response["message"]["content"].strip() # 尝试从模型的响应中解析工具调用 try: call = json.loads(reply) tool_name = call.get("tool") args = call.get("args", {}) if tool_name in TOOLS: print(f"🔧 Calling tool: {tool_name}({args})") tool_result = TOOLS[tool_name](**args) print(f"📦 Tool result: {tool_result}\n") # 将结果反馈给模型 messages.append({"role": "assistant", "content": reply}) messages.append({"role": "user", "content": f"Tool result: {tool_result}\nNow answer the original question."}) continue except (json.JSONDecodeError, TypeError): pass # 没有工具调用 - 这是最终答案 print(f"✅ Final Answer:\n{reply}") return reply return "Agent did not reach a conclusion." if __name__ == "__main__": run_tool_agent("What is the weather in Tokyo? Also what is 144 divided by 12?")
适用场景很广：研究类 Agent 从多源浏览和综合网络内容；个人助理 Agent 管理待办、邮件或在应用中下单；金融 Agent 拉取股票与市场实时行情；新闻提取 Agent 从多个渠道聚合最新信息。
模式3：Planning，行动之前先想清楚假设有人接到开发一个应用的任务，上来就开始写代码，没有任何规划。这种做法显然令人不安。
好的工程师先拆解问题，列出可执行的步骤序列，然后逐步推进。Agent 也应该如此。Planning 模式赋予 Agent 的正是这种"先想后做"的能力。
Planning 有两种主要变体。
第一种是 ReAct（Reason + Act）。这是目前最流行的规划方式，Agent 在"推理—行动—观察"三个环节之间交替循环：先思考下一步该做什么，然后执行动作（调用工具或完成某个步骤），接着观察执行结果，再进入下一轮推理，直到任务完成。
Figure: ReAct based Planning Pattern
第二种是 Plan-and-Execute。与 ReAct 那种"边走边拆"的风格不同，Plan-and-Execute 要求 Agent 在动手之前一次性生成完整的执行计划，然后按顺序逐步执行。
Phase 1 — Planning:"Here are the 5 steps I'll take to complete this task: …"
Phase 2 — Execution:Step 1 → [execute] → resultStep 2 → [execute] → result…Step 5 → Final output
代码示例：
# 模式3: 规划 (ReAct — 推理 + 行动) # Agent推理下一步该做什么，行动（使用工具）， # 观察结果，然后再次推理——直到任务完成。 # 安装: pip install ollama requests # 需要: Ollama在本地运行 → https://ollama.com # 先拉取模型: ollama pull llama3.2 import ollama import requests import re MODEL = "llama3.2" # ── 模拟工具 ───────────────────────────────────────────────────────────────── def search_web(query: str) -> str: """Simulated web search (replace with real search API in production).""" mock_db = { "transformer architecture": "Transformers use self-attention mechanisms to process sequences in parallel.", "who invented transformers": "The Transformer architecture was introduced by Vaswani et al. in the paper " "'Attention Is All You Need' (2017) at Google Brain.", "applications of transformers": "Transformers are used in NLP (BERT, GPT), computer vision (ViT), " "speech recognition, and drug discovery.", } for key, value in mock_db.items(): if key in query.lower(): return value return f"No results found for '{query}'." def summarize(text: str) -> str: """Use the LLM itself to summarize a piece of text.""" response = ollama.chat( model=MODEL, messages=[{"role": "user", "content": f"Summarize this in one sentence:\n{text}"}] ) return response["message"]["content"].strip() TOOLS = { "search_web": search_web, "summarize": summarize, } # ── ReAct系统提示词 ──────────────────────────────────────────────────────── REACT_PROMPT = """You are a reasoning agent. Solve tasks step by step using this loop: Thought: Think about what to do next. Action: <tool_name>(<argument>) Observation: [result of the action] ... repeat as needed ... Final Answer: <your complete answer> Available tools: - search_web(query) — Search for information on a topic. - summarize(text) — Summarize a block of text into one sentence. Always start with a Thought. End with Final Answer when done. """ # ── ReAct Agent循环 ─────────────────────────────────────────────────────────── def parse_action(text: str): """Extract tool name and argument from 'Action: tool_name(argument)'""" match = re.search(r"Action:\s*(\w+)\((.+?)\)", text, re.DOTALL) if match: return match.group(1).strip(), match.group(2).strip().strip('"').strip("'") return None, None def run_react_agent(task: str) -> str: print(f"🎯 Task: {task}\n") messages = [ {"role": "system", "content": REACT_PROMPT}, {"role": "user", "content": f"Task: {task}"} ] for step in range(8): # 最多8个ReAct步骤 response = ollama.chat(model=MODEL, messages=messages) reply = response["message"]["content"].strip() print(f"[Step {step + 1}]\n{reply}\n") # 检查Agent是否已达到最终答案 if "Final Answer:" in reply: final = reply.split("Final Answer:")[-1].strip() print(f"✅ Final Answer:\n{final}") return final # 解析并执行动作 tool_name, argument = parse_action(reply) if tool_name and tool_name in TOOLS: observation = TOOLS[tool_name](argument) print(f"🔭 Observation: {observation}\n") # 将交互追加到消息历史 messages.append({"role": "assistant", "content": reply}) messages.append({"role": "user", "content": f"Observation: {observation}"}) else: # 未找到有效动作 - 要求Agent继续 messages.append({"role": "assistant", "content": reply}) messages.append({"role": "user", "content": "Continue your reasoning."}) return "Agent reached maximum steps without a final answer." if __name__ == "__main__": run_react_agent( "Who invented the Transformer architecture and what are its main applications?" )
Planning 模式的适用场景集中在几类任务上：涉及多个相互依赖步骤的研究任务，需要在执行前完成规划；软件开发中，需要先做架构设计再进入编码阶段的工作流程；业务流程自动化中，在关键决策节点反复推理和修正的场景。
模式4：多 Agent 协作，分工、专精、协同没有谁能精通所有领域。团队存在的意义在于每个成员各有专长，协作产出任何个体都无法独立完成的成果。
AI Agent 遵循同样的逻辑。多个具备不同专长的 Agent 各司其职，协作完成单一 Agent 难以应对的复杂任务。
这一模式有几种架构上的变体。
第一种：Orchestrator + SubAgents。一个中央编排器接收任务、完成分解，然后将子任务分配给多个专业子 Agent 并行处理，最后汇总所有结果。
第二种：Peer Agents（对等辩论/协作）。多个 Agent 独立处理同一任务，之后对比各自的结论，这个类似于研究者之间通过辩论逼近真相的过程。在对精度要求极高的任务中，这种模式尤其有价值。
第三种：Sequential Pipeline（顺序流水线）。把它想象成一个专业分工团队在同一任务上依次接力。Agent A 产出结果交给 Agent B，Agent B 加工后交给 Agent C，直到最终输出。
[Data Collector] → [Analyst] → [Fact Checker] → [Writer] → Final Report
代码示例：
# 模式4: 多Agent协作 # 一个编排器Agent分解任务并将子任务委派给 # 专业化Agent（研究员、分析师、写手）。 # 每个Agent都有一个专注的角色和系统提示词。 # 安装: pip install ollama # 需要: Ollama在本地运行 → https://ollama.com # 先拉取模型: ollama pull llama3.2 import ollama MODEL = "llama3.2" # ── 基础Agent ───────────────────────────────────────────────────────────────── def run_agent(system_prompt: str, user_message: str) -> str: """Run a single agent with a given role and task.""" response = ollama.chat( model=MODEL, messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_message} ] ) return response["message"]["content"].strip() # ── 专业化Agent ───────────────────────────────────────────────────────── def researcher_agent(topic: str) -> str: """Gathers key facts and background on a topic.""" system = ( "You are a research specialist. When given a topic, provide 4–5 key facts, " "background context, and important figures or milestones. Be concise and factual." ) print("🔍 Researcher Agent working...") result = run_agent(system, f"Research this topic: {topic}") print(f" Done.\n") return result def analyst_agent(research: str) -> str: """Identifies trends, insights, and implications from research.""" system = ( "You are a data analyst and critical thinker. Given research notes, " "extract 3 key insights or trends and explain their implications. " "Be analytical and structured." ) print("📊 Analyst Agent working...") result = run_agent(system, f"Analyze these research notes:\n{research}") print(f" Done.\n") return result def writer_agent(topic: str, research: str, analysis: str) -> str: """Writes a polished short article from research and analysis.""" system = ( "You are a professional tech writer. Given a topic, research notes, and analysis, " "write a clear, engaging 150-word summary suitable for a technical blog. " "Use simple language and a logical structure." ) print("✍️ Writer Agent working...") result = run_agent( system, f"Topic: {topic}\n\nResearch:\n{research}\n\nAnalysis:\n{analysis}\n\nWrite the blog summary." ) print(f" Done.\n") return result # ── 编排器 ─────────────────────────────────────────────────────────────── def orchestrator(topic: str) -> str: """ Central orchestrator that: 1. Delegates research to the Researcher Agent 2. Sends research to the Analyst Agent 3. Passes both outputs to the Writer Agent 4. Returns the final polished output """ print(f"🎬 Orchestrator: Starting pipeline for topic → '{topic}'\n") print("=" * 55) # 步骤1: 研究 research = researcher_agent(topic) # 步骤2: 分析 analysis = analyst_agent(research) # 步骤3: 写作 final_article = writer_agent(topic, research, analysis) print("=" * 55) print(f"\n✅ Final Output:\n\n{final_article}") return final_article if __name__ == "__main__": orchestrator("The rise of Agentic AI systems in 2024")
多 Agent 协作的落地场景十分多样：软件项目中由架构师、编码者、审查者、测试者组成 Agent 团队；金融分析中由数据采集、量化分析、叙述撰写等 Agent 分工配合；内容创作流水线中由研究、写作、编辑、SEO 各环节的 Agent 接力完成；客户支持系统中由分诊、专家处理、升级等 Agent 协同响应。
模式之间如何组合四种模式并非互斥。在实际生产系统中，最成熟的方案往往将它们分层叠加。
以一个 AI 竞争情报平台为例：
每种模式各自弥补一类短板——Reflection 提升输出质量，Tool Use 拓展交互能力，Planning 应对多步骤复杂任务，Multi-Agent 解决规模和专业分工的问题。四层叠合，一个简单的 LLM 就变成了可以上生产的自主系统。
总结单轮提示的时代正在过去。取而代之的是具备思考、行动、自检和协作能力的 AI——与一支配合默契的工程团队所做的事情，本质上没有区别。
Reflection、Tool Use、Planning、Multi-Agent Collaboration，这四种模式构成了这次转移的基础构件，理解它们的意义不停留在理论层面；它直接决定了最终产出的是一个演示用的原型，还是一个能在生产环境中持续运行的系统。
https://avoid.overfit.cn/post/9e1443a3841e498d912f10040cceef60
by Rishabh Mathur