【重大进展】本文对比的三套方案均为本周(2026/11/2–11/10)新动态,非旧闻重炒。OpenAI 给出原生 multi-agent 原语,Microsoft 发布 agent-framework-gov0.3.0,AgentScope 2.0 持续活跃。
如果你上个月还在纠结“用 LangChain 还是 AutoGen”,这个月战场已经换人了。过去我们谈 Agent 编排,绕不开一堆胶水代码:自己起线程、自己管队列、自己处理失败重试。本周,三股力量几乎同时亮牌——OpenAI 把编排直接做进了 API,Microsoft 用 Go 把“技能”拆成乐高,AgentScope 则把模块化推到极致。它们指向同一个问题:当 Agent 要拉帮结派干大事,最小的那层“编排接口”到底长什么样?
这篇文章不堆参数,我们直接拆到“你写哪几行代码、剩下的谁替你扛”这一层,给你一份能落地的选型地图。
本周三件大事
- OpenAI Responses API 原生 multi-agent
:新增 spawn_agent/wait_agent原语,并支持max_concurrent_subagents=3(并发子 agent 上限)。关键词是“托管式”——你只声明 agent 与依赖,调度、并发、隔离、计费全交给平台。 - Microsoft
agent-framework-gov0.3.0(11/3 发布):带来 Composable Skills(可组合技能)模型,把能力拆成可复用、可组合的 skill 单元;框架用 Go 实现,主打类型安全、云原生、可嵌入现有 Go 服务。 - AgentScope 2.0
(本周活跃):模块化 Agent 框架,强调模块可插拔、流程可编程、轻量易扩展,适合研究者与自建玩家。
三件事放在一起看,信号很明确:Agent 编排正在从“你自己写调度器”走向“框架 / 平台替你写调度器”。区别只在于——谁来写、写多少。
三方阵营速览
平台托管派
代表:OpenAI 原生 multi-agent
定位:你画组织架构图,平台当 HR 和后勤
云原生派
代表:agent-framework-go
定位:用 Go 把能力拆成乐高,塞进你自己的服务
研究自建派
代表:AgentScope 2.0
定位:模块随便插、流程自己编,轻量可控
一句话总结:OpenAI 卖“省心”,Microsoft 卖“可控”,AgentScope 卖“自由”。
三套最小接口
判断一套编排方案,最有效的问题是:它对外的“最小编排接口”是什么?也就是你最少要写什么,才能让它跑起一个多 agent 协作?
OpenAI 原生 multi-agent
最小编排接口:spawn_agent / wait_agent
你写什么:声明 agent 与依赖关系
谁调度:平台托管
运行时:跨语言(HTTP)
agent-framework-go
最小编排接口:Composable Skills(skill 组合)
你写什么:实现 / 组合 skill 单元
谁调度:你的 Go 进程
运行时:Go
AgentScope 2.0
最小编排接口:可插拔模块 + 可编程流程
你写什么:拼装模块、编排工作流
谁调度:你的进程
运行时:Python(待核实)
注意这里“最小接口”的颗粒度完全不同:OpenAI 给你的是“动词”(派发 / 等待),Microsoft 给你的是“名词”(技能单元),AgentScope 给你的是“插槽”(模块)。这决定了后面所有差异。
OpenAI 声明式
OpenAI 的思路最激进:把多 agent 当成 API 的一等公民。你不再自己起进程或线程,而是声明式地描述“有一个协调者,它下面挂三个干活的”。
核心两个原语:
spawn_agent:派发一个子 agent,平台负责把它真正跑起来; wait_agent:阻塞等待某个子 agent 的结果。
并发上限通过 max_concurrent_subagents=3 控制——这是平台侧的硬约束,你不用自己写信号量。最舒服的地方在于:隔离、重试、计费都被托管了。你拿到的是“结果”,不是“一堆要运维的容器”。
代价也很明显:你的 agent 逻辑跑在 OpenAI 的运行时里,数据驻留、模型供应商、合规边界这些都不归你管。它是“托管式”的极致,也是“黑盒式”的极致。
Go 技能组合
Microsoft 走的是另一条路。agent-framework-go v0.3.0 的核心是 Composable Skills——把“能干活的能力”拆成一个个 skill 单元,再像搭乐高一样组合。
它解决的痛点是:Go 团队不想为了接 Agent 就引入一套动态语言运行时。框架用 Go 写,天然类型安全,可以 import 进你现有的微服务,跟着你的 K8s、你的可观测体系一起跑。所谓“云原生”,不是口号,是说它生来就该住进你的 Go 服务里。
和 OpenAI 不同,这里没有托管平台替你扛调度——并发是你 Go 程序的 goroutine 模型,计费是你自己的云账单。你换来了对数据、模型、运行时的完全掌控。
AgentScope 拼装
AgentScope 2.0 是第三种气质:模块化、可编程、轻。它把 Agent 拆成可插拔的模块,工作流由你用代码显式编排,强调“易扩展”。
它的目标用户很明确——研究者和喜欢自己动手的玩家。你不需要迁就某个平台的约束,模块随插随用,流程想怎么串就怎么串。代价是:基础设施(并发、隔离、重试)得你自己兜,它给你的是“自由度”而不是“省心度”。
并发模型差异
三套方案的并发,是三种哲学:
- OpenAI
:平台托管并发, max_concurrent_subagents=3是平台强制的上限。你写spawn_agent三次,平台自己决定哪三个同时在跑,你不需要碰任何线程原语。 - Microsoft
:并发模型就是 Go 的并发模型。skill 组合跑在你的进程里,要并行就起 goroutine,要限流就自己加 channel/ 信号量。框架不替你做全局调度。 - AgentScope
:并发由你编排的工作流决定。模块之间并行还是串行,写流程时你自己定,框架提供的是拼装能力而非调度器。
一句话:OpenAI 把并发“收编”了,Microsoft 和 AgentScope 把并发“下放”了。
子 agent 生命周期
- OpenAI
: spawn_agent创建、平台运行、wait_agent回收,生命周期完全由平台管理。子 agent 之间天然隔离,每次执行独立计费——你不用担心一个子 agent 崩了拖垮全局。 - Microsoft
:skill 单元的生命周期就是你的 Go 函数 / goroutine 的生命周期。子 agent 是不是“独立进程”由你决定,框架只保证 skill 组合的接线是类型安全的。 - AgentScope
:模块在 workflow 实例化时创建、流程结束时销毁,生命周期跟着你的程序走。
核心区别:OpenAI 的“子 agent”是平台资源,另外两家的“子 agent”是你进程里的对象。
记忆如何传递
多 agent 协作最难的不是“派活”,是“记忆怎么传”——父 agent 的上下文、子 agent 的中间结论,怎么在它们之间流动?
- OpenAI
:状态与隔离由平台托管,你通过声明“依赖关系”告诉平台谁需要谁的结果。具体传递机制(上下文窗口如何拼接、是否存在共享记忆)待核实,但这层复杂度被平台吞掉了。 - Microsoft
:skill 之间靠结构化 Input/Output(Go struct)传递。记忆就是你显式传进去的字段,类型安全意味着传错了编译期就能发现。 - AgentScope
:模块通过可编程工作流显式传递状态,数据流写在流程里,清清楚楚。
OpenAI 让你“少想一步”,Microsoft / AgentScope 让你“想清楚每一步”。
托管还是自建
这是读者最关心的决策点。先给结论:
选托管(OpenAI 原生 multi-agent、LangChain Deep Agents 这类托管 / 半托管),当你——
-
想用最少代码把多 agent 跑起来,验证想法优先于掌控细节; -
不想自己运维调度器、队列、隔离、重试; -
接受平台托管带来的模型 / 数据 / 计费的约束,换来省心。
选自建(agent-framework-go、AgentScope 这类可嵌入 / 可定制框架),当你——
-
技术栈是 Go(或要嵌入现有 Go 服务),要类型安全和统一运行时; -
对数据驻留、模型供应商、合规有硬要求,必须自己掌控; -
做研究或要高度定制的编排逻辑,框架的“插槽”比“黑盒”更合你意。
一个常见误区:以为托管一定更弱。其实对 80% 的团队,托管方案能让你省下写一个调度器的一到两周,先把业务跑通;自建则是当你碰到托管的天花板(定制、合规、成本)时才值得。
OpenAI 伪代码
下面用伪代码示意 OpenAI 原生 multi-agent 的“最小写法”——注意你只声明和等待,调度全交给平台:
# OpenAI Responses API 原生 multi-agent(伪代码示意)
from openai import OpenAI
client = OpenAI()
# 声明一个协调 agent 与若干子 agent(此处略去 agent 定义)
coordinator = client.agents.create(name="coordinator", instructions="拆分任务并派发")
# 派发子 agent:平台负责并发调度,上限 max_concurrent_subagents=3
task_a = client.spawn_agent(
parent=coordinator,
agent="researcher",
input="调研竞品定价",
max_concurrent_subagents=3, # 平台侧并发硬约束
)
task_b = client.spawn_agent(
parent=coordinator,
agent="coder",
input="生成爬虫脚本",
max_concurrent_subagents=3,
)
# 等待结果:隔离、计费由平台托管
result_a = client.wait_agent(task_a)
result_b = client.wait_agent(task_b)
# 汇总交给协调 agent 收尾
final = coordinator.run(input=f"综合结论:{result_a} / {result_b}")
你写了十几行,没碰任何线程、队列、重试。这就是“托管式”的体感。
Go 框架伪代码
同一需求,用 agent-framework-go 怎么写?差别在于:你定义 skill、组合 skill,并发和调度都在你自己的 Go 进程里:
// Microsoft agent-framework-go v0.3.0(伪代码骨架)
package main
import"github.com/microsoft/agent-framework-go"
// 1) 定义可组合技能(skill 单元),类型安全
var ResearchSkill = agent.Skill{
Name: "research",
Run: func(ctx context.Context, in agent.Input) (agent.Output, error) {
// 调用模型或工具,返回结构化结果
return agent.Output{Text: "..."}, nil
},
}
var CodeSkill = agent.Skill{ /* 类似定义 coder 技能 */ }
func main() {
// 2) 组合技能:框架负责编排与类型安全的接线
pipeline := agent.Compose(ResearchSkill, CodeSkill)
// 3) 嵌入现有 Go 服务,并发由你的 runtime 调度
srv := agent.NewServer(pipeline)
srv.Listen(":8080") // 云原生、可嵌入
}
两种写法的本质差异一眼可见:左边你“请求平台派活”,右边你“在自己的服务里拼能力”。前者的边界是 API,后者的边界是你的进程。
怎么选型落地
给一份能直接照做的行动清单:
- 你是 Go 技术栈、要把 Agent 塞进现有微服务、要类型安全和统一运维
→ 直接上 agent-framework-gov0.3.0,用 Composable Skills 把老能力翻新成 agent。 - 你做研究、要轻量、要模块随便插、不想被平台绑死
→ 选 AgentScope 2.0,享受可编程工作流的自由。 - 你想用最少代码验证多 agent 想法、能接受平台托管约束
→ 用 OpenAI 原生 multi-agent, spawn_agent/wait_agent一把梭。 - 进阶玩法
:用 OpenAI 托管做“前端调度 + 快速试错”,把核心、敏感、要定制的环节用 agent-framework-go或 AgentScope 自建,形成“托管调度 + 自建能力”的混合架构。
没有银弹,但有清楚的边界:要省心找平台,要可控找 Go,要自由找 AgentScope。


