当前智能体的几种形式

sivdead2025-10-23 19:05

1. 工作流驱动智能体

工作流智能体就像一条生产线------每个步骤都提前设计好，按固定顺序执行。这是最简单、也是工程实践中最常用的方式。

想象一下自动化客服：用户提问 → 识别意图 → 提取关键信息 → 查询数据库 → 生成回复。这个流程是固定的，每次都一样。开发者预先定义好这些步骤，智能体就按照"剧本"执行。

技术实现上，可以用状态机、DAG（有向无环图）或流程图来描述。

核心特点:

  • 稳定可靠: 流程固定，行为可预测，出问题容易排查。金融、医疗等对稳定性要求高的场景首选这种模式。

  • 缺乏灵活性: 这是最大的问题。遇到预设之外的情况就傻眼了。比如用户问了个冷门问题，工作流没覆盖到，就只能回复"我不理解"。要适应新场景，必须修改代码重新部署。

  • 决策能力有限: 本质上就是if-else逻辑。虽然可以在某些节点调用模型做智能处理（比如理解用户意图），但整体流程还是写死的。

代码示例：智能客服工作流

python 复制代码 
"""
工作流驱动智能体示例：智能客服系统
使用LangGraph构建预定义的处理流程
"""

from typing import TypedDict, Literal
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langgraph.graph import StateGraph, END
import dotenv
import os

dotenv.load_dotenv()

# 定义状态
class CustomerServiceState(TypedDict):
    query: str
    intent: str
    entities: dict
    response: str
    satisfied: bool


# 创建LLM实例
llm = ChatOpenAI(model="gpt-4.1", temperature=0.3)


# 节点1: 意图识别
def intent_classification(state: CustomerServiceState) -> CustomerServiceState:
    """识别用户意图"""
    query = state["query"]

    prompt = f"""分析用户问题的意图，从以下类别中选择一个：
- product_inquiry（产品咨询）
- technical_support（技术支持）
- complaint（投诉）
- order_status（订单查询）

用户问题：{query}

只返回类别名称，不要其他内容。"""

    response = llm.invoke([HumanMessage(content=prompt)])
    intent = response.content.strip()

    return {**state, "intent": intent}


# 节点2: 实体提取
def entity_extraction(state: CustomerServiceState) -> CustomerServiceState:
    """提取关键信息"""
    query = state["query"]

    prompt = f"""从用户问题中提取关键信息，以JSON格式返回。

用户问题：{query}

需要提取：产品名称、订单号、问题描述等。只返回JSON，格式如：
{{"product": "xxx", "order_id": "xxx", "issue": "xxx"}}"""

    response = llm.invoke([HumanMessage(content=prompt)])
    entities_str = response.content.strip()

    try:
        import json

        entities = json.loads(entities_str)
    except:
        entities = {"raw": entities_str}

    return {**state, "entities": entities}


# 节点3: 生成回复
def response_generation(state: CustomerServiceState) -> CustomerServiceState:
    """根据意图生成回复"""
    intent = state["intent"]
    entities = state["entities"]
    query = state["query"]

    # 根据不同意图使用不同的提示词模板
    templates = {
        "product_inquiry": "你是产品顾问。用户询问：{query}。请提供专业的产品介绍。",
        "technical_support": "你是技术支持。用户遇到问题：{query}。请提供解决方案。",
        "complaint": "你是客服经理。用户投诉：{query}。请真诚道歉并提供解决方案。",
        "order_status": "你是订单客服。用户查询：{query}。请说明订单处理流程。",
    }

    template = templates.get(intent, "请回答：{query}")
    prompt = template.format(query=query)

    response = llm.invoke([HumanMessage(content=prompt)])

    return {**state, "response": response.content}


# 节点4: 满意度判断
def satisfaction_check(state: CustomerServiceState) -> CustomerServiceState:
    """判断是否需要转人工"""
    # 这里简化处理，实际可以加入更复杂的规则
    intent = state["intent"]

    # 投诉类自动标记为需要人工
    satisfied = intent != "complaint"

    return {**state, "satisfied": satisfied}


# 构建工作流
def create_customer_service_workflow():
    workflow = StateGraph(CustomerServiceState)

    # 添加节点
    workflow.add_node("intent", intent_classification)
    workflow.add_node("entity", entity_extraction)
    workflow.add_node("response", response_generation)
    workflow.add_node("satisfaction", satisfaction_check)

    # 定义流程
    workflow.set_entry_point("intent")
    workflow.add_edge("intent", "entity")
    workflow.add_edge("entity", "response")
    workflow.add_edge("response", "satisfaction")
    workflow.add_edge("satisfaction", END)

    return workflow.compile()


# 测试
if __name__ == "__main__":
    app = create_customer_service_workflow()

    # 测试案例
    result = app.invoke(
        {
            "query": "我的订单已经3天了还没发货，这是怎么回事？",
            "intent": "",
            "entities": {},
            "response": "",
            "satisfied": False,
        }
    )

    print(f"用户问题: {result['query']}")
    print(f"识别意图: {result['intent']}")
    print(f"提取实体: {result['entities']}")
    print(f"客服回复: {result['response']}")
    print(f"是否满意: {result['satisfied']}")

什么时候用这种模式？

  • 智能客服: 90%的用户问题都是常见问题，用固定流程处理就够了。意图识别、实体提取、回复生成这些环节交给大模型，但整体流程保持固定。成本可控，响应稳定。

  • 数据报表生成: 每天凌晨2点自动跑一遍ETL流程，生成昨日销售报表。这种任务完全不需要"智能决策"，稳定性才是第一位的。

  • IT运维自动化: 数据库备份、日志清理、服务健康检查。这些任务的步骤是固定的，用工作流编排最合适。

  • 审批流程: 请假审批、报销审批。规则明确，流程固定，不需要AI"发挥创造力"。

总结: 如果你的任务有80%以上的场景可以预设流程，就用工作流模式。别被"自主智能体"的概念迷惑------大多数实际业务用工作流就够了，成本低、稳定、好维护。

2. 自主决策型智能体

这是当前研究的热点，也是最"炫酷"的方式。你只需告诉智能体目标和可用的工具，它会自己规划怎么做。

举个例子：你对它说"帮我调研固态电池的最新进展"。它会：

  1. 思考：需要搜索学术数据库
  2. 行动：调用search_arxiv("solid state battery")
  3. 观察：找到3篇论文
  4. 思考：需要读摘要了解详情
  5. 行动：调用read_paper_abstract("论文标题")
  6. 观察：获得技术细节
  7. 思考：可以总结了
  8. 行动：调用summarize_findings(...)
  9. 完成！

这叫ReAct模式（Reasoning + Acting）：思考→行动→观察→再思考，循环往复直到完成任务。

核心特点:

  • 灵活自主: 能动态调整策略。任务执行过程中发现新问题？没关系，它会自己想办法。比如搜索结果不理想，它会换个关键词再搜。这种灵活性是工作流模式不可能做到的。

  • 推理能力强: 能理解复杂、模糊甚至隐含的指令。你说"帮我找找为什么销售额下降了"，它能分解成：查数据→对比历史→分析异常→查外部因素→生成报告。这种多步推理能力很强大。

  • 会用工具 : 通过FunctionCalling，它能调用各种工具：搜索引擎、数据库、API、代码执行器等。关键是它不仅会调用，还能理解返回结果，然后决定下一步做什么。

  • ⚠️ 依赖LLM质量 : 这是最大的坑。LLM有幻觉怎么办？它可能编造一个不存在的函数名。推理出错怎么办？可能陷入死循环重复调用同一个工具。实战中必须加各种限制：最大循环次数、工具名验证、输出格式检查等。

  • ⚠️ 成本和延迟: 一个任务可能需要5-10轮LLM调用，成本是工作流的3-5倍甚至更多，延迟也是累加的。做demo很爽，上生产要算账。

  • ⚠️ 稳定性差: 因为过于灵活，完全依赖模型发挥。一旦模型出问题（尤其国内某些模型会经常性抽风），就会出现各种奇怪的bug，还特别难调试。不像工作流那样可预测。

代码示例

python 复制代码 
"""
自主决策型智能体示例：智能研究助理
使用ReAct模式（Reasoning + Acting）实现自主决策和工具调用
"""

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from langgraph.graph import StateGraph, END, MessagesState
import dotenv

from langchain_core.messages import AIMessage, ToolMessage
from langchain_core.tools import tool
from langgraph.prebuilt import ToolNode

dotenv.load_dotenv()


# 定义工具
@tool
def search_arxiv(query: str) -> str:
    """搜索arXiv论文数据库

    Args:
        query: 搜索关键词

    Returns:
        搜索结果摘要
    """
    # 实际应该调用arXiv API，这里模拟返回
    return """找到3篇相关论文：
1. "Solid-State Battery Breakthrough" (2024) - 提出了新型固态电解质
2. "Advanced Lithium Metal Anodes" (2024) - 解决了锂金属负极问题
3. "High-Energy Density Batteries" (2023) - 实现了500Wh/kg能量密度"""


@tool
def read_paper_abstract(paper_title: str) -> str:
    """读取论文摘要

    Args:
        paper_title: 论文标题

    Returns:
        论文摘要内容
    """
    # 实际应该调用API获取真实摘要，这里模拟
    abstracts = {
        "Solid-State Battery Breakthrough": "本文提出了一种新型硫化物固态电解质，离子电导率达到10 mS/cm...",
        "Advanced Lithium Metal Anodes": "通过界面工程设计，成功抑制了锂枝晶生长，循环寿命提升5倍...",
        "High-Energy Density Batteries": "采用富锂正极材料，实现了500Wh/kg的能量密度，远超传统锂离子电池...",
    }
    return abstracts.get(paper_title, "摘要未找到")


@tool
def summarize_findings(findings: str) -> str:
    """总结研究发现

    Args:
        findings: 收集的研究发现

    Returns:
        结构化的总结报告
    """
    return f"""## 固态电池技术研究总结

### 关键突破
{findings}

### 技术趋势
1. 固态电解质材料创新
2. 界面稳定性改进
3. 能量密度持续提升

### 未来展望
固态电池有望在3-5年内实现商业化应用。"""


# 创建LLM（支持工具调用）
tools = [search_arxiv, read_paper_abstract, summarize_findings]

llm = ChatOpenAI(model="gpt-4.1", temperature=0.3).bind_tools(tools)


# Agent节点：决策和推理
def agent_node(state: MessagesState) -> MessagesState:
    """Agent推理并决定下一步行动"""
    messages = state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response]}


# 条件判断：是否需要调用工具
def should_continue(state: MessagesState) -> str:
    """判断是否继续执行工具调用"""
    last_message = state["messages"][-1]

    # 如果LLM调用了工具，继续执行
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    # 否则结束
    return "end"


# 构建ReAct Agent
def create_research_agent():
    workflow = StateGraph(MessagesState)

    # 添加节点
    workflow.add_node("agent", agent_node)  # Agent推理节点
    workflow.add_node("tools", ToolNode(tools))  # 工具执行节点

    # 设置入口
    workflow.set_entry_point("agent")

    # 添加条件边：agent -> tools 或 end
    workflow.add_conditional_edges(
        "agent", should_continue, {"tools": "tools", "end": END}
    )

    # tools执行后回到agent继续推理
    workflow.add_edge("tools", "agent")

    return workflow.compile()


# 测试
if __name__ == "__main__":
    app = create_research_agent()

    # 用户请求
    user_query = "请帮我调研固态电池最新的技术突破，并总结关键发现"

    print(f"用户请求: {user_query}\n")
    print("=" * 70)
    print("Agent开始自主执行...\n")

    # 运行Agent
    result = app.invoke({"messages": [HumanMessage(content=user_query)]})

    # 显示执行过程
    for i, msg in enumerate(result["messages"], 1):
        print(f"\n--- 步骤 {i} ---")
        if isinstance(msg, HumanMessage):
            print(f"👤 用户: {msg.content}")
        elif isinstance(msg, AIMessage):
            if hasattr(msg, "tool_calls") and msg.tool_calls:
                print("🤖 Agent决策: 调用工具")
                for tool_call in msg.tool_calls:
                    print(f"   📎 工具: {tool_call['name']}")
                    print(f"   📋 参数: {tool_call['args']}")
            else:
                print(f"🤖 Agent回复: {msg.content}")
        elif isinstance(msg, ToolMessage):
            print(f"🔧 工具返回: {msg.content[:100]}...")

    print("\n" + "=" * 70)
    print("✅ Agent执行完成！")
    print("\n最终回复:")
    print(result["messages"][-1].content)

运行示例输出:

lua 复制代码 
用户请求: 请帮我调研固态电池最新的技术突破，并总结关键发现

======================================================================
Agent开始自主执行...

--- 步骤 1 ---
👤 用户: 请帮我调研固态电池最新的技术突破，并总结关键发现

--- 步骤 2 ---
🤖 Agent决策: 调用工具
   📎 工具: search_arxiv
   📋 参数: {'query': 'solid state battery breakthrough 2024'}

--- 步骤 3 ---
🔧 工具返回: 找到3篇相关论文：
1. "Solid-State Battery Breakthrough" (2024) - 提出了新型固态电解质
2. "Advanced Lithium Metal Anodes" (2024) - 解决了锂金属负极问题
3. "High-Energy Density Batteries" (2023) - 实现了500Wh/kg能量密度

--- 步骤 4 ---
🤖 Agent决策: 调用工具
   📎 工具: read_paper_abstract
   📋 参数: {'paper_title': 'Solid-State Battery Breakthrough'}

--- 步骤 5 ---
🔧 工具返回: 本文提出了一种新型硫化物固态电解质，离子电导率达到10 mS/cm...

--- 步骤 6 ---
🤖 Agent决策: 调用工具
   📎 工具: summarize_findings
   📋 参数: {'findings': '1. 新型固态电解质...\n2. 锂枝晶抑制...\n3. 能量密度突破...'}

--- 步骤 7 ---
🤖 Agent回复: [完整的研究总结报告]

======================================================================
✅ Agent执行完成！

关键特性说明:

  1. 自主决策: Agent自己决定调用哪些工具、调用顺序
  2. ReAct循环: 推理 → 行动 → 观察 → 再推理，直到完成任务
  3. 工具组合: 自动组合多个工具完成复杂任务
  4. 动态规划: 根据中间结果调整后续策略

什么时候用这种模式？

  • 研究助理: "帮我调研固态电池最新进展"------这种开放性任务，工作流根本做不了。需要智能体自己决定搜什么、读哪些论文、如何总结。

  • 复杂规划: "规划一次5天东京自由行，预算1万"------需要查航班、比价格、规划路线、估算费用。每个用户需求都不同，无法预设流程。

  • AI编程助手: Cursor、Copilot这些就是自主决策型智能体。你说一句需求，它自己决定要读哪些文件、写什么代码、运行什么测试。

  • 数据分析: "为什么上季度销售下滑？"------需要自主探索数据、生成图表、查外部因素。工作流做不了这种探索式任务。

3. 多智能体协作

听起来很高大上：多个智能体各司其职，像团队一样协作完成任务。比如文档生成；多智能体系统的核心在于协作机制的设计，主要包括以下几种模式：

3.1 共享上下文

多个Agent通过共享状态对象 来协作，按预定顺序依次执行。就像接力赛，每个Agent读取前一个的输出，处理后传给下一个。这个其实跟工作流模式没什么区别，用到了多个模型，所以也可以勉强称作多智能体。

技术实现 ：举例: 在LangGraph中，用一个State对象，所有Agent都能访问。

比如文档生成系统：

  • 研究员写入research_notes字段
  • 架构师读取后写入outline字段
  • 写作者读取后写入draft字段
  • 编辑读取后写入final_document字段
python 复制代码 
"""
多智能体协作示例：技术文档生成系统
展示多个独立Agent通过共享State对象进行协作
"""
from typing import TypedDict, List, Annotated
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langgraph.graph import StateGraph, END, add_messages
import os

# 配置OpenRouter API
os.environ["OPENAI_API_BASE"] = "https://openrouter.ai/api/v1"
# os.environ["OPENAI_API_KEY"] = "your_openrouter_key"

# 定义共享状态
class DocumentState(TypedDict):
    """所有Agent共享的状态对象"""
    # 输入
    topic: str
    requirements: dict
    
    # 各Agent的输出
    research_notes: str  # 研究员的调研笔记
    outline: str  # 架构师的文档大纲
    draft_content: str  # 写作者的初稿
    final_document: str  # 编辑的最终版本
    
    # 执行日志
    messages: Annotated[List[str],add_messages]

# 创建LLM实例
llm = ChatOpenAI(
    model="gpt-4.1",
    temperature=0.4
)

# Agent 1: 研究员
class ResearchAgent:
    """研究员Agent - 收集技术资料"""
    
    def __init__(self):
        self.name = "研究员"
    
    def __call__(self, state: DocumentState) -> DocumentState:
        """执行调研任务"""
        print(f"\n[1/4] {self.name} 开始工作...")
        
        topic = state['topic']
        requirements = state['requirements']
        
        prompt = f"""你是一名专业的技术研究员。

主题：{topic}
目标读者：{requirements.get('audience', '技术人员')}

请收集以下信息：
1. 核心概念和定义
2. 技术背景
3. 关键要点
4. 注意事项

输出格式：
【核心概念】
...
【技术背景】
...
【关键要点】
...
【注意事项】
..."""
        
        response = llm.invoke([HumanMessage(content=prompt)])
        research_notes = response.content
        
        print(f"✅ {self.name} 完成！输出：{len(research_notes)}字符")
        
        return {
            **state,
            "research_notes": research_notes,
            "messages": [response]
        }

# Agent 2: 架构师
class ArchitectAgent:
    """架构师Agent - 设计文档结构"""
    
    def __init__(self):
        self.name = "架构师"
    
    def __call__(self, state: DocumentState) -> DocumentState:
        """设计文档大纲"""
        print(f"\n[2/4] {self.name} 开始工作...")
        
        topic = state['topic']
        research_notes = state['research_notes']
        
        prompt = f"""你是一名文档架构师。

基于以下调研笔记，设计文档大纲：

【调研笔记】
{research_notes}

请设计清晰的文档结构，格式：
# 章节1
- 要点1
- 要点2

# 章节2
..."""
        
        response = llm.invoke([HumanMessage(content=prompt)])
        outline = response.content
        
        print(f"✅ {self.name} 完成！")
        
        return {
            **state,
            "outline": outline,
            "messages": [response]
        }

# Agent 3: 写作者
class WriterAgent:
    """写作者Agent - 撰写文档内容"""
    
    def __init__(self):
        self.name = "写作者"
    
    def __call__(self, state: DocumentState) -> DocumentState:
        """撰写文档"""
        print(f"\n[3/4] {self.name} 开始工作...")
        
        topic = state['topic']
        outline = state['outline']
        research_notes = state['research_notes']
        
        prompt = f"""你是一名技术写作者。

严格按照以下大纲撰写完整的技术文档：

【大纲】
{outline}

【参考资料】
{research_notes}

要求：
1. 使用Markdown格式
2. 包含代码示例
3. 表达清晰、准确
4. 字数：600-800字

请开始撰写："""
        
        response = llm.invoke([HumanMessage(content=prompt)])
        draft = response.content
        
        print(f"✅ {self.name} 完成！文档长度：{len(draft)}字符")
        
        return {
            **state,
            "draft_content": draft,
            "messages": [response]
        }

# Agent 4: 编辑
class EditorAgent:
    """编辑Agent - 润色优化文档"""
    
    def __init__(self):
        self.name = "编辑"
    
    def __call__(self, state: DocumentState) -> DocumentState:
        """编辑和润色"""
        print(f"\n[4/4] {self.name} 开始工作...")
        
        draft = state['draft_content']
        
        prompt = f"""你是一名技术文档编辑。

请优化以下文档：

【初稿】
{draft}

任务：
1. 检查准确性和完整性
2. 优化语言表达
3. 统一格式和风格
4. 修正错误

请输出润色后的最终版本："""
        
        response = llm.invoke([HumanMessage(content=prompt)])
        final = response.content
        
        print(f"✅ {self.name} 完成！最终文档：{len(final)}字符")
        
        return {
            **state,
            "final_document": final,
            "messages": [response]
        }

# 构建多智能体工作流
def create_multi_agent_workflow():
    """创建多Agent协作工作流"""
    workflow = StateGraph(DocumentState)
    
    # 创建Agent实例
    research_agent = ResearchAgent()
    architect_agent = ArchitectAgent()
    writer_agent = WriterAgent()
    editor_agent = EditorAgent()
    
    # 添加节点（每个Agent是一个节点）
    workflow.add_node("research", research_agent)
    workflow.add_node("architect", architect_agent)
    workflow.add_node("writer", writer_agent)
    workflow.add_node("editor", editor_agent)
    
    # 定义执行流程
    workflow.set_entry_point("research")  # 从研究员开始
    workflow.add_edge("research", "architect")  # 研究 → 架构
    workflow.add_edge("architect", "writer")  # 架构 → 写作
    workflow.add_edge("writer", "editor")  # 写作 → 编辑
    workflow.add_edge("editor", END)  # 编辑 → 结束
    
    return workflow.compile()

# 测试
if __name__ == "__main__":
    app = create_multi_agent_workflow()
    
    print("="*70)
    print("多智能体协作文档生成系统")
    print("="*70)
    print("\n架构：研究员 → 架构师 → 写作者 → 编辑")
    print("共享状态：DocumentState\n")
    
    # 初始化状态
    initial_state = {
        "topic": "Python装饰器高级用法",
        "requirements": {
            "audience": "有Python基础的开发者",
            "depth": "中级"
        },
        "research_notes": "",
        "outline": "",
        "draft_content": "",
        "final_document": "",
        "messages": []
    }
    
    # 运行工作流
    print("启动多Agent协作...\n")
    final_state = app.invoke(initial_state)
    
    # 输出结果
    print("\n" + "="*70)
    print("执行摘要")
    print("="*70)
    print(f"执行路径：{' → '.join(final_state['messages'])}")
    
    print("\n" + "="*70)
    print("最终文档")
    print("="*70)
    print(final_state['final_document'])
    
    print("\n" + "="*70)
    print("成本分析")
    print("="*70)
    print("LLM调用次数：4次（研究+架构+写作+编辑）")
    print("Token消耗：约为单Agent的3-4倍")
    print("响应延迟：4个串行调用的累积")
    print("\n建议：对于大多数场景，单Agent就足够了！")

运行示例输出:

markdown 复制代码 
======================================================================
多智能体协作文档生成系统
======================================================================

架构：研究员 → 架构师 → 写作者 → 编辑
共享状态：DocumentState

启动多Agent协作...

[1/4] 研究员 开始工作...
完成！输出：856字符

[2/4] 架构师 开始工作...
完成！

[3/4] 写作者 开始工作...
完成！文档长度：1024字符

[4/4] 编辑 开始工作...
完成！最终文档：1089字符

======================================================================
执行摘要
======================================================================
执行路径：研究员: 已完成调研 → 架构师: 已完成大纲设计 → 写作者: 已完成初稿 → 编辑: 已完成编辑

======================================================================
最终文档
======================================================================
[生成的完整技术文档内容]

======================================================================
成本分析
======================================================================
LLM调用次数：4次（研究+架构+写作+编辑）
Token消耗：约为单Agent的3-4倍
响应延迟：4个串行调用的累积

建议：对于大多数场景，单Agent就足够了！

关键要点:

  1. 独立的Agent: 每个Agent有自己的类和提示词，更进一步的，还可以配置不同的工具
  2. 共享状态 : 通过DocumentState共享所有信息
  3. 状态流转: Agent依次读取和更新状态
  4. 可追溯性: 所有中间结果都保存在状态中

3.2 层级结构协作模式

层级结构是一种更加结构化的多智能体组织形式，模仿了企业管理中的"管理者-执行者"模式。在这种架构中，智能体被分为不同的层级：

  • 管理者智能体（Supervisor）: 位于上层，负责任务分解、规划、调度和监督。它接收用户的高层目标，将其拆解为多个子任务，并分配给合适的执行者智能体。管理者还需要监控执行进度，处理异常情况，协调资源冲突。

  • 执行者智能体（Worker）: 位于下层，每个执行者通常专注于某个特定领域或功能。它们接收管理者分配的子任务，专注于执行，并将结果反馈给管理者。

核心优势:

  • 清晰的职责划分: 管理者负责"思考"（规划和协调），执行者负责"行动"（具体执行），职责边界清晰，避免混乱。

  • 可扩展性强: 可以方便地添加新的执行者智能体来扩展系统能力，而不影响整体架构。

  • 更好的可控性: 管理者智能体可以作为中央控制点，便于监控、调试和干预。

3.3 其他协作模式

  • 黑板模式（Blackboard Pattern）:

    • 所有Agent共享一个"黑板"（公共知识库），并发工作
    • 任何Agent发现黑板上有自己能处理的信息，就主动处理并更新
    • 是事件驱动、异步的，和3.1的串行共享状态不同
    • 经典应用：语音识别系统（语音、语法、语义Agent并发协作）
    • 问题：协调复杂，调试困难，实际项目很少用

  • 网络拓扑模式（Network Topology）:

    • Agent之间形成通信网络，可以点对点直接通信
    • 适用于分布式决策（如多机器人协作）

  • 拍卖与协商模式（Auction & Negotiation）:

    • Agent通过竞价、协商等机制争夺任务或资源
    • 适用于资源受限场景（如云资源调度）

多智能体系统的典型应用:

  • 复杂软件开发项目: 产品经理智能体负责需求分析 → 架构师智能体设计系统 → 前端/后端开发智能体编写代码 → 测试智能体进行质量保证 → DevOps智能体负责部署。

  • 智能内容创作平台: 研究智能体收集素材 → 大纲智能体规划结构 → 写作智能体生成内容 → 编辑智能体优化表达 → SEO智能体优化关键词 → 审核智能体检查合规性。

  • 企业决策支持系统: 数据分析师智能体处理数据 → 财务分析智能体评估成本 → 市场分析智能体研究趋势 → 风险评估智能体识别风险 → 决策智能体综合所有信息提供建议。

  • 智能客服与销售系统: 接待智能体识别用户意图 → 技术支持智能体解答技术问题 → 销售智能体推荐产品 → 售后智能体处理投诉 → 升级智能体处理复杂问题。

总结与选型建议

三种模式对比（基于GPT-4.1实测数据）

维度 工作流驱动 自主决策型 多智能体协作
开发难度 ⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐
响应延迟 2-3秒 5-10秒 20-30秒
稳定性 ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐
灵活性 低 高 中
调试难度 容易 中等 困难

我的选型建议

优先级：工作流 > 自主决策 >>> 多智能体

  1. 默认用工作流：如果80%的场景能预设流程，就用工作流。成本低、稳定、好维护。

  2. 开放性任务用自主决策：研究、规划、探索类任务，工作流做不了，用ReAct模式。但要加好限制（最大循环、Token预算、错误处理）。

  3. 基本不用多智能体：除了共享上下文这种，或者研究学习，其他的都不建议使用，目前还非常不成熟，无论是模型能力还是智能体之间的沟通机制。

混合使用

实际项目中，这三种可以混着用：

  • 工作流的某个节点可以调用自主决策型Agent处理复杂输入
  • 自主决策型Agent可以把某个固定流程封装成工具
  • 多Agent系统中，每个Agent内部用工作流实现
相关推荐
AIGC_北苏6 小时前
大语言模型，一个巨大的矩阵
人工智能·语言模型·矩阵
算家计算6 小时前
DeepSeek-OCR本地部署教程：DeepSeek突破性开创上下文光学压缩，10倍效率重构文本处理范式
人工智能·开源·deepseek
言之。6 小时前
Andrej Karpathy 演讲【PyTorch at Tesla】
人工智能·pytorch·python
lang201509286 小时前
Spring Boot RSocket：高性能异步通信实战
java·spring boot·后端
算家计算6 小时前
快手推出“工具+模型+平台”AI编程生态！大厂挤占AI赛道，中小企业如何突围？
人工智能·ai编程·资讯
Moonbit6 小时前
倒计时 2 天｜Meetup 议题已公开，Copilot 月卡等你来拿！
前端·后端
阿里云大数据AI技术6 小时前
云栖实录 | DataWorks 发布下一代 Data+AI 一体化平台，开启企业智能数据新时代
大数据·人工智能
大模型真好玩6 小时前
低代码Agent开发框架使用指南（五）—Coze消息卡片详解
人工智能·coze·mcp
预测模型的开发与应用研究7 小时前
贝叶斯统计结合机器学习在术后院内感染危险因素分析中的应用
人工智能·机器学习
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08Labelme从安装到标注：零基础完整指南092025软件测试面试八股文（含答案+文档）10一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示