Single Agent vs Multi-Agent — 什么时候该用哪种

开场

一个反直觉的数据：我复盘了自己搭过的 14 个 Agent 项目，其中 9 个最终稳定运行的版本是 Single Agent，只有 5 个真正需要 Multi-Agent。而那 9 个项目里，有 6 个最初是用 Multi-Agent 设计的，后来因为维护成本太高才简化回来。大部分人高估了 Multi-Agent 的必要性，低估了 Single Agent + 好的 tool use 的能力。

问题背景

2026 年的 AI 社区有一个明显的趋势：Multi-Agent 被过度营销。每个框架都在推 Multi-Agent，每个 demo 都是好几个 Agent 协作，但到了生产环境，很多团队发现 Multi-Agent 系统的调试成本、延迟和不可预测性远超预期。

核心问题不是"Multi-Agent 行不行"，而是"我的场景到底需不需要"。

错误决策的代价很具体：

• 不该用 Multi-Agent 却用了：延迟增加 2-5 倍，token 成本增加 3-8 倍，debug 时间增加一个数量级
• 该用 Multi-Agent 却没用：单个 Agent 的 prompt 膨胀到 5000+ token，上下文窗口挤占严重，输出质量下降

核心框架：四维决策模型

我用四个维度来判断一个项目该用 Single 还是 Multi-Agent。

维度一：任务复杂度

核心指标：这个任务需要几套不同的 system prompt？

# Single Agent：一个 system prompt 覆盖所有能力
single_agent_prompt = """你是全栈助手。你可以：
1. 搜索网络获取信息
2. 分析数据并生成图表
3. 撰写报告
根据用户需求选择合适的工具。"""

# Multi-Agent：每个 Agent 有独立的、精调过的 system prompt
research_prompt = """你是专业研究员。只做信息搜集和事实核查。
输出格式：JSON，包含 source、confidence、data 三个字段。
不要做分析，不要给建议。"""

analyst_prompt = """你是数据分析师。基于提供的研究数据做深度分析。
关注趋势、异常值和因果关系。
不要重新搜索，只用给你的数据。"""

判断标准：

• 1-2 套 prompt 能搞定 → Single Agent
• 3 套以上，且每套差异很大 → Multi-Agent

维度二：模型需求

核心指标：所有子任务都适合用同一个模型吗？

这是很多人忽略的维度。不同子任务对模型的要求不同：

子任务	推荐模型	原因
复杂推理/规划	Claude Opus 4.6 ($5/$25)	需要强推理能力
常规文本生成	GPT-4.1 ($2/$8)	性价比好，质量够用
简单分类/提取	GPT-4.1-mini ($0.4/$1.6)	速度快，成本低
代码生成	Claude Sonnet 4.5 ($3/$15)	代码质量高

如果所有子任务都能用同一个模型高效完成，Single Agent 更合理。如果不同子任务适合不同模型，Multi-Agent 的价值就出来了——每个 Agent 用最适合的模型，整体成本反而可能更低。

维度三：状态管理

核心指标：Agent 之间需要共享多少上下文？

# 低状态依赖 → 适合 Multi-Agent
# 每个 Agent 独立工作，只传结果
result_a = agent_a.run(task_a)  # 只需要原始输入
result_b = agent_b.run(task_b)  # 只需要原始输入
final = aggregator.merge(result_a, result_b)

# 高状态依赖 → 适合 Single Agent
# 每一步都需要之前所有步骤的上下文
step1 = agent.run(task, context=[])
step2 = agent.run(task, context=[step1])  # 需要 step1 的全部结果
step3 = agent.run(task, context=[step1, step2])  # 需要前两步

状态传递是 Multi-Agent 系统最大的隐性成本。每次跨 Agent 传递上下文，都在消耗额外的 token。如果上下文依赖很重，不如让一个 Agent 在同一个对话里把事做完。

维度四：容错需求

核心指标：一个子任务失败，是否应该影响其他子任务？

Multi-Agent 天然支持隔离：Agent A 挂了，Agent B 继续跑。Single Agent 则是一荣俱荣、一损俱损。

如果你的场景需要部分成功（比如同时分析 10 个竞品，其中 2 个数据源挂了，剩下 8 个应该正常出结果），Multi-Agent 是更好的选择。

实现细节

Single Agent 的正确打开方式

不是把所有逻辑塞进一个 prompt，而是用 tool use 做能力扩展：

from openai import OpenAI
import json

client = OpenAI()

# 定义工具集
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "搜索网络获取最新信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "搜索关键词"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "analyze_data",
            "description": "对结构化数据做统计分析",
            "parameters": {
                "type": "object",
                "properties": {
                    "data": {"type": "string", "description": "JSON 格式的数据"},
                    "analysis_type": {"type": "string", "enum": ["trend", "comparison", "distribution"]}
                },
                "required": ["data", "analysis_type"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "generate_report",
            "description": "生成结构化分析报告",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "sections": {"type": "array", "items": {"type": "string"}}
                },
                "required": ["title", "sections"]
            }
        }
    }
]

def smart_single_agent(user_request: str) -> str:
    """Single Agent + tool use：一个 Agent 调度多个工具"""
    messages = [
        {"role": "system", "content": "你是商业分析助手。根据用户需求，调用合适的工具完成任务。"},
        {"role": "user", "content": user_request}
    ]

    # 循环执行 tool calls 直到任务完成
    while True:
        response = client.chat.completions.create(
            model="gpt-4.1",
            messages=messages,
            tools=tools,
        )
        msg = response.choices[0].message

        if msg.tool_calls:
            messages.append(msg)
            for tool_call in msg.tool_calls:
                # 执行工具并把结果喂回去
                result = execute_tool(tool_call.function.name,
                                     json.loads(tool_call.function.arguments))
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": json.dumps(result, ensure_ascii=False)
                })
        else:
            return msg.content  # 没有 tool call，说明任务完成

这种模式的 token 消耗大约在 2,000-5,000 per request，延迟 3-8 秒，成本 $0.01-$0.03。

Multi-Agent 的最小可行架构

如果确实需要 Multi-Agent，从最简单的两层开始：

import asyncio
from dataclasses import dataclass

@dataclass
class AgentConfig:
    name: str
    model: str
    system_prompt: str
    temperature: float = 0.3

# 每个 Agent 用最适合的模型和参数
AGENTS = {
    "researcher": AgentConfig(
        name="researcher",
        model="gpt-4.1-mini",  # 搜索提取不需要强模型
        system_prompt="搜索并提取关键事实。输出 JSON 格式。",
        temperature=0.1
    ),
    "writer": AgentConfig(
        name="writer",
        model="claude-sonnet-4-5",  # 写作需要好的模型
        system_prompt="基于研究数据撰写深度分析文章。",
        temperature=0.7
    ),
    "reviewer": AgentConfig(
        name="reviewer",
        model="gpt-4.1",  # 审核用中等模型就够
        system_prompt="检查文章的事实准确性，输出修改建议。",
        temperature=0.1
    ),
}

async def multi_agent_pipeline(topic: str) -> str:
    """最小可行 Multi-Agent：三个 Agent，各用最佳模型"""
    # Step 1: 研究（用便宜快速的模型）
    research = await call_agent(AGENTS["researcher"], topic)
    # Step 2: 写作（用强写作模型）
    draft = await call_agent(AGENTS["writer"], research)
    # Step 3: 审核（用中等模型）
    review = await call_agent(AGENTS["reviewer"], draft)
    return review

实战经验

成本对比（真实项目数据）

我拿同一个任务（竞品分析报告生成）分别用两种架构跑了 100 次：

指标	Single Agent	Multi-Agent (3 Agents)
平均延迟	6.2s	9.8s
平均 token 消耗	3,200	5,800
平均成本	$0.018	$0.024
输出质量评分 (GPT-4 评分)	7.8/10	8.4/10
失败率	2%	5%

Multi-Agent 的质量确实更高（8.4 vs 7.8），但成本高了 33%，延迟多了 58%，失败率也更高。对这个具体任务，如果质量差的那 0.6 分不关键，Single Agent 是更好的选择。

复杂度阈值

我的经验法则：

• 工具数 <= 5，prompt < 3000 token → Single Agent
• 工具数 > 5，或需要 3 种以上不同 system prompt → 考虑 Multi-Agent
• 需要动态决策（if-else 分支超过 3 层） → Multi-Agent + Manager
• 需要不同模型做不同子任务 → Multi-Agent

踩过的坑

坑 1：为了"解耦"拆 Agent。软件工程的解耦原则不能直接搬到 Agent 系统。Agent 之间的通信成本远高于函数调用。拆之前先算一下跨 Agent 的 token 开销。

坑 2：Multi-Agent 的调试地狱。5 个 Agent 协作，出了 bug，你不知道是哪个 Agent 的 prompt 问题、模型问题、还是 Agent 间通信的格式问题。我的解决方案：每个 Agent 必须输出结构化日志，包含 input/output/token_count/latency，问题出在哪里一查就知道。

坑 3：Agent 数量失控。一个项目从 3 个 Agent 膨胀到 12 个，因为每发现一个新需求就加一个 Agent。后来砍回 5 个，把相似职责的 Agent 合并，系统反而更稳定。

对比选型

维度	Single Agent	Multi-Agent
适合场景	任务相对统一，工具调度为主	子任务差异大，需要不同专长
开发周期	1-3 天	1-3 周
维护成本	低（一个 prompt + 一组工具）	高（多个 prompt + 通信协议 + 状态管理）
延迟	低	中-高
token 成本	低	中-高
输出质量上限	中-高	高
可观测性	简单	需要专门的 tracing 工具
推荐框架	OpenAI Agents SDK	LangGraph / CrewAI

总结

三条 takeaway：

1. 默认从 Single Agent 开始——用 tool use 扩展能力，而不是加 Agent。Single Agent 能解决的问题，不要用 Multi-Agent
2. Multi-Agent 的真正价值是"专业分工 + 模型差异化"——如果所有 Agent 用同一个模型、做同类型的事，Multi-Agent 没有意义
3. 用四维模型做决策——任务复杂度、模型需求、状态管理、容错需求，至少两个维度指向 Multi-Agent 再考虑

下次有人跟你说"这个项目需要 Multi-Agent"，先问：Single Agent + 好的 tool use 是不是已经够了？如果答案是"够了"，那就别折腾。

你的项目是 Single 还是 Multi？踩过什么坑？来一人独角兽俱乐部聊聊。