从零理解 Antigravity Orchestrator:3 层架构、3 种编排模式与蜂群机制详解

从零理解 Antigravity Orchestrator:3 层架构、3 种编排模式与蜂群机制详解

作者注:用一篇文章讲清 Antigravity Orchestrator 是什么、如何通过 /swarm 派发子代理,以及它和 LangGraph、CrewAI 的定位差异。

摘要:Antigravity Orchestrator 是 Google Antigravity 平台内置的多代理协调引擎,而不是一个可以单独 pip 安装的轻量框架。本文从产品矩阵、三层抽象、三种编排模式和 /swarm 蜂群机制四个方面,帮你搞清楚它的工作方式和适用范围。

结论先行:Antigravity Orchestrator 可以理解为“藏在 Antigravity 平台里的任务调度大脑”。你在 IDE、Web App 或 CLI 中输入 /swarm、/teamwork 这样的斜杠命令,它会在底层调用 SDK 的 Task API 和 Workflow Runtime,把一个大任务拆成多个子任务,交给并行工作的子代理完成,最后汇总成交付物。2026 年 11 月,Orchestrator 随 Gemini 4 Neon 正式进入 Antigravity。11 月 10 日 Gemini 4 Carbon 全面开放时,Sundar Pichai 现场演示了 /swarm 能力,这项功能从此进入公众视野。

是否值得投入学习,取决于两个条件。第一,你的任务能否拆成相互独立、可以并行的部分。第二,你能否接受一个以 Gemini 为优化目标、核心引擎闭源的平台。两个条件都满足时,Orchestrator 能明显降低多代理协作的搭建成本。如果你需要模型无关、完全开源的方案,LangGraph、CrewAI 这类 Python 库仍然更合适。

antigravity-orchestrator-explained-from-zero-image-0


Antigravity Orchestrator 知识地图与阅读索引

下表列出全文的知识结构、章节之间的依赖关系,以及每一节要解决的问题。整体顺序是从“它属于什么”到“它怎么工作”,再到“我该不该用、怎么开始”。

编号 主题 解决的问题 与前后章节的关系
1 Antigravity 平台背景 Orchestrator 运行在哪个产品体系里 为第 2 节提供平台语境
2 Orchestrator 三层抽象 它在技术上到底是什么 第 3、4 节的机制都建立在这三层之上
3 三种编排模式 /swarm、/teamwork、/run-workflow 有何区别 从三种模式中选出 /swarm 在第 4 节深入
4 /swarm 蜂群机制 主代理如何拆任务、派子代理 结合真实案例,为第 5 节的对比提供依据
5 与 LangGraph 等框架对比 什么条件下选它,什么条件下不选 给出选型判断,衔接第 6 节的上手路径
6 入门路径与代码 从零开始怎么上手 将前文概念落到代码层面
7 最佳实践与影响 模型选择、权限、成本如何控制 收束为可执行的建议

如果只想了解它是什么,读完第 1 到第 3 节就够了。如果准备做技术选型,建议重点阅读第 4、5 节。如果要动手实践,可以直接跳到第 6、7 节。

🎯 技术建议:理解多代理编排最快的方法是亲手跑一遍“拆分—并行—汇总”的流程。第 6.3 节给出了一个基于 OpenAI 兼容接口的模拟实现,可以通过 API易 apiyi.com 用一个 Key 调用不同模型来充当主代理和子代理。

To Know:理解 Antigravity Orchestrator 的必备术语

术语 简明解释
代理(Agent) 能调用工具、自主完成多步任务的模型实例
主代理(Orchestrator Agent) 负责分析和拆解任务、派发子代理并整合结果的总协调者
子代理(Subagent) 承接某个子任务的代理,可以运行时动态创建,也可以预先定义
Fan-out / Fan-in 扇出指把一个任务分发给多个执行者,扇入指把多个结果汇聚回来
Artifacts 代理最终产出的交付物,例如代码、文件、可运行的应用
Workflow Runtime Antigravity SDK 中基于图的执行引擎,负责状态管理和节点调度

1 Antigravity Orchestrator 所在的平台:Antigravity 是什么

1.1 Antigravity 这个名字从哪来

“Antigravity”直译为“反重力”,寓意让开发摆脱传统单人编码的束缚,像失重一样“飞起来”。不少开发者认为这个名字可能借用了 Python 的 import antigravity 彩蛋。这个彩蛋源自一幅 xkcd 漫画,执行这行代码会在浏览器中打开那张漫画。Google 把 Antigravity 定位为“agent-first era”(代理优先时代)的开发者平台,也就是说,代理是工作的主体,人负责描述目标并审核结果。

1.2 Antigravity 是一个产品矩阵

很多人第一次听到 Antigravity,会把它当成一个 IDE。实际上它是一组面向不同场景的产品,Orchestrator 能力分布在这些产品形态之中:

产品 形态 主要用途
Antigravity App Web 应用 在浏览器内进行全功能代理编程
Antigravity IDE 桌面应用 基于 VS Code 分支,深度集成代理能力
Antigravity CLI 命令行工具 用 Go 编写的终端代理
Antigravity SDK Python 库 开发自定义代理
Antigravity Extensions IDE 插件 把代理能力嵌入现有编辑器

这张表说明了一个关键事实:斜杠命令出现在 App、IDE、CLI 这类交互界面中,而 SDK 承载的是可编程接口。第 2 节讲三层抽象时,会看到这两者是如何上下衔接的。

1.3 Antigravity Orchestrator 的发布时间线

Orchestrator 并非凭空出现,它是 Antigravity 平台一年来逐步演进的结果。按时间顺序,几个关键节点如下:

  • 2025 年 11 月 18 日:Antigravity IDE 与 Gemini 3 Pro 同日首发。
  • 2026 年 5 月(Google I/O):发布 Gemini 3.5 Flash,以及基于 Antigravity 运行时的 Gemini Spark。
  • 2026 年 6 月 18 日:开源的 Gemini CLI 停止服务,全面迁移到闭源的 Antigravity CLI。
  • 2026 年 11 月:Gemini 4 Neon 与 Orchestrator 正式进入 Antigravity。
  • 2026 年 11 月 10 日:Gemini 4 Carbon 全面开放,Sundar Pichai 演示 /swarm。

从这条时间线可以看出一个明显的趋势:Google 正在把终端、IDE 和浏览器端的代理能力统一收拢到 Antigravity 运行时之下,Orchestrator 则是这套运行时之上的协调层。


2 Antigravity Orchestrator 是什么:三层抽象拆解

2.1 Antigravity Orchestrator 的本质定位

有些文章把 Antigravity Orchestrator 称为“轻量级蜂群框架”,这个说法容易让人误以为它是一个独立的库。更准确的描述是:它是 Antigravity 平台内置的多代理协调引擎。底层对应 SDK 中的 Workflow Runtime 和 Task API,上层通过斜杠命令或 SDK API 触发。所谓“轻量”,体现在使用体验上:用户只需要一条命令,不必手写图结构和状态机。

2.2 Antigravity Orchestrator 的三层结构

Orchestrator 的能力自上而下分为三层。上层调用下层,越往下越接近执行细节:

Layer 1: 斜杠命令        /swarm、/teamwork、/plan
    ↓  面向使用者,一条命令触发编排
Layer 2: SDK API         Agent、Subagent、Task API
    ↓  面向开发者,用代码定义代理与任务
Layer 3: Workflow Runtime  图执行引擎、Fan-out/Fan-in、状态管理
       面向运行时,负责调度、并行与状态

这种分层带来的直接好处是“同一套引擎,多种入口”。产品经理可以在 IDE 里直接敲 /swarm,后端工程师可以用 SDK 写出相同的编排逻辑,两者最终都由 Workflow Runtime 执行。理解了这一点,后面三种模式之间的差异就很容易看懂:它们只是在 Layer 1 上呈现为不同的入口,在 Layer 3 上对应不同的图形态。

antigravity-orchestrator-explained-from-zero-image-1


3 Antigravity Orchestrator 的三种编排模式

Orchestrator 提供三种编排模式,区别在于子代理之间是否需要持续交互,以及流程是否事先确定。选错模式是新手最常遇到的问题,因此先看对比:

模式 触发方式 协作形态 适用任务
Swarm 蜂群模式 /swarm 一次性派发多个子代理并行工作,最后汇总 可以拆成独立部分的大型任务
Teamwork 团队模式 /teamwork 代理团队持续协作,多轮交互 需要反复讨论、互相依赖的复杂项目
Workflow 工作流模式 /run-workflow 预定义有向图,支持分支、循环、条件路由 流程固定、需要稳定复现的任务

判断时可以按下面的顺序提问。如果流程每次都一样,选 Workflow。如果流程不固定,但子任务之间几乎不需要沟通,选 Swarm。如果子任务之间需要来回对齐,比如前端改接口后后端要跟着调整,就选 Teamwork。Swarm 并行度最高、等待时间最短,但对任务的可拆分性要求也最高。


4 Antigravity Orchestrator 的 /swarm 蜂群机制

4.1 /swarm 的五步工作流程

/swarm 是 Orchestrator 最具代表性的能力,完整流程分为五步:

  1. 用户发出 /swarm 指令,并附上任务描述。
  2. 主代理(Orchestrator Agent)分析任务,自动拆解为若干子任务。
  3. 为每个子任务动态创建子代理,即“动态自克隆子代理”。
  4. 子代理并行执行,结果汇聚回主代理。
  5. 主代理整合输出,生成最终的 Artifacts。

第 2 步和第 5 步决定了最终质量。拆得不干净,子代理之间会互相重复或遗漏;整合能力不足,各部分就无法拼成一个可用的整体。因此主代理通常需要使用推理能力更强的模型。

4.2 动态子代理与静态子代理

Antigravity Orchestrator 支持两类子代理,可以在同一个任务中混合使用:

  • 动态自克隆子代理:在运行时按需创建,继承主代理的部分上下文,适合临时拆出来的子任务。
  • 静态自定义子代理:预先定义好的专用代理,拥有固定的系统指令和工具集,适合反复出现的专业环节,例如代码审查、测试生成。

另一个值得注意的设计是,每个子代理可以使用不同的模型。例如用 Carbon 处理需要深度推理的部分,用 Hydrogen 处理快速、简单的部分。这种“按任务难度分配模型”的做法,是多代理系统控制成本的核心手段,第 7 节会具体展开。

4.3 案例:Pelican Campus Quest 是如何被拆解的

Sundar Pichai 演示的 /swarm 案例是一个很好的教学样本。主代理收到的任务是:“构建一个在 Google Mountain View 园区骑 GBike 探索的开放世界 3D 游戏”。它把任务拆成了三条并行线:

  • 3D 资产建模:子代理使用 Blender,并参考 Omni / Nano Banana 生成的素材。
  • 游戏引擎构建:子代理使用 Three.js 与 WebGL 着色器。
  • 音频系统:子代理使用 Web Audio API 配合 Lyria 音乐。

最终三部分被自动整合成一个可以在浏览器中游玩的游戏。这个案例之所以适合 Swarm,是因为模型、引擎、音频三块只需要在接口层面约定好格式,在开发过程中几乎不必互相等待,这正是第 3 节所说的“可拆分性”。


5 Antigravity Orchestrator 对比 LangGraph、CrewAI、AutoGen

5.1 比较口径

下面的比较只看定位差异,不比较性能,因为几者的形态完全不同:一个是完整平台,其他是 Python 库。比较维度包括产品定位、代理抽象、浏览器集成、模型绑定、部署方式和开源程度。

antigravity-orchestrator-explained-from-zero-image-2

维度 Antigravity LangGraph CrewAI AutoGen
定位 完整 IDE + 平台 Python 库 Python 库 Python 库
代理模型 动态自克隆 + 静态 图节点 角色定义 对话代理
浏览器集成 原生 Chrome 扩展 无 无 无
模型绑定 针对 Gemini 优化 模型无关 模型无关 模型无关
部署 Cloud Run / Docker 自行部署 自行部署 自行部署
开源 SDK 开源,核心闭源 完全开源 开源 开源
多模型接入建议 Gemini 生态内 可经 API易 apiyi.com 统一接入 同左 同左

5.2 选型判断

LangGraph 在图结构的可控性和完全开源方面保持领先,但需要自己搭建 IDE 集成、浏览器操作和部署链路。Antigravity Orchestrator 在“开箱即用”上更有优势,一条 /swarm 就能完成拆分、并行和整合,还能原生操作浏览器。CrewAI 的角色定义方式直观,AutoGen 擅长以对话驱动协作,两者同样需要自行处理部署和工具链。

据此可以得出一个简单的规则:团队已经深度使用 Gemini,并希望在 IDE 中直接获得多代理能力,就选 Antigravity;需要在多家模型之间切换,或者对核心引擎的可审计性有要求,就选开源库。

💡 选择建议:如果走开源库路线,模型接入层建议统一为 OpenAI 兼容接口。通过 API易 apiyi.com,一个 Key 就能在 LangGraph 或 CrewAI 中切换 GPT、Claude、Gemini 等模型,便于在同一个编排图里给不同节点分配不同模型。


6 从零上手 Antigravity Orchestrator 的路径

6.1 推荐学习顺序

按照“先会用、再会写、最后会调”的思路,入门路径可以分为七步:

  1. 概念:理解 Antigravity 是什么、为什么需要它(本文第 1 至 2 节)。
  2. 安装:在 Web App、IDE 下载、命令行安装三种方式中任选一种。
  3. 第一个代理:用 SDK 写一个 Hello World 代理。
  4. 理解 Orchestrator:了解 Workflow Runtime 与 Task API 的关系。
  5. 第一个 Swarm:在 IDE 或 CLI 中实际运行 /swarm。
  6. 深入子代理:对比动态子代理和静态子代理的效果。
  7. 最佳实践:模型选择、权限管理与成本控制。

6.2 用 Antigravity SDK 写第一个代理

SDK 的最小代理只需要一个配置对象和一次对话调用:

from google.antigravity import Agent, LocalAgentConfig

config = LocalAgentConfig(
    system_instructions="You are an expert assistant.",
)
async with Agent(config) as agent:
    response = await agent.chat("Hello!")
    print(await response.text())

如果需要流式输出,可以直接迭代 response。给代理添加工具也很简单,只需把普通 Python 函数传入 tools:

import sys

# 流式响应
async for token in response:
    sys.stdout.write(token)
    sys.stdout.flush()

# 自定义工具
def get_weather(city: str) -> str:
    return f"It's sunny in {city}."

config = LocalAgentConfig(tools=[get_weather])

函数签名中的类型注解会帮助代理理解参数含义。实际项目中建议为工具函数写清楚 docstring,这样主代理在拆解任务时更容易判断该把哪个工具交给哪个子代理。

6.3 用 OpenAI 兼容接口模拟蜂群的扇出与扇入

Orchestrator 的核心引擎是闭源的,但“拆分—并行—汇总”这个思路可以用任何模型复现。下面的代码模拟了一个最小版的 /swarm:主代理负责拆解和整合,子代理并行执行。它不是 Antigravity 的实现,而是帮助理解第 4.1 节五步流程的教学示例。

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # API易 OpenAI 兼容接口
)

PLANNER_MODEL = "your-reasoning-model"  # 主代理:推理强的模型,以平台模型列表为准
WORKER_MODEL = "your-fast-model"        # 子代理:速度快、成本低的模型

async def ask(model: str, system: str, prompt: str) -> str:
    resp = await client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content
查看完整的蜂群模拟代码
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # 一个 Key 调用多家模型
)

PLANNER_MODEL = "your-reasoning-model"
WORKER_MODEL = "your-fast-model"

async def ask(model: str, system: str, prompt: str) -> str:
    resp = await client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

async def swarm(task: str, max_workers: int = 3) -> str:
    # Step 2:主代理拆解任务(Fan-out 之前)
    plan = await ask(
        PLANNER_MODEL,
        "你是主代理。把任务拆成互相独立、可并行的子任务,每行一个,不要编号。",
        task,
    )
    subtasks = [s.strip("- ").strip() for s in plan.splitlines() if s.strip()]
    subtasks = subtasks[:max_workers]

    # Step 3-4:为每个子任务创建子代理并行执行(Fan-out)
    results = await asyncio.gather(*[
        ask(WORKER_MODEL, "你是只负责单一子任务的子代理,输出简洁可交付的结果。", s)
        for s in subtasks
    ])

    # Step 5:主代理整合结果(Fan-in)
    merged = "\n\n".join(f"【{s}】\n{r}" for s, r in zip(subtasks, results))
    return await ask(
        PLANNER_MODEL,
        "你是主代理。整合子代理的产出,消除重复与冲突,输出最终方案。",
        f"原始任务:{task}\n\n子代理产出:\n{merged}",
    )

if __name__ == "__main__":
    print(asyncio.run(swarm("为一个浏览器小游戏设计美术、玩法和音效三部分方案")))

这段代码演示了两个关键点:主代理和子代理使用不同的模型,子任务通过 asyncio.gather 并行执行。把它和第 4 节对照着看,就能理解 Orchestrator 在 Layer 3 中自动帮你完成了哪些工作,包括状态管理、失败重试和产物整合。

🚀 快速开始:上面的示例可以直接运行,只需在 API易 apiyi.com 获取 Key,并把两个模型名替换为平台上可用的模型。新用户有免费测试额度,足够完成几轮拆分与整合实验。


7 Antigravity Orchestrator 的最佳实践与影响

7.1 模型选择:按任务难度分层

多代理系统的成本会随子代理数量成倍增长,因此模型分层是首要原则。拆解和整合这类决定全局质量的环节交给强推理模型,例如 Antigravity 中的 Carbon;格式转换、样板代码、简单查询交给快速模型,例如 Hydrogen。在 Antigravity 之外复现类似架构时,也可以照搬这种分层思路,通过 API易 apiyi.com 在同一套代码里为不同角色指定不同模型,对比质量和花费后再固定配置。

7.2 权限管理:限制子代理的工具范围

动态子代理会继承主代理的部分上下文,如果工具权限没有收紧,一个子代理就可能做出超出职责的操作。更稳妥的做法是:把需要写文件、执行命令、操作浏览器的能力放在静态自定义子代理中,明确它的系统指令和工具集;动态子代理只承担只读或生成类任务。涉及生产环境的操作,应保留人工确认环节。

7.3 成本控制:先估算再扩大并行度

/swarm 的并行度越高,等待时间越短,但 token 消耗也越多。建议先用小任务观察主代理通常会拆出几个子任务、每个子任务消耗多少,再决定是否放开到更大的任务。对于预算敏感的团队,可以先在开源编排库中用低价模型验证拆分策略,按量计费的 API易 apiyi.com 便于控制试验成本,确认流程可行后再迁移到 Antigravity 获取完整的平台能力。

7.4 Antigravity Orchestrator 对开发者的影响

Orchestrator 的出现意味着多代理编排正在从“工程师手写图结构”转向“用户一条命令触发”。这降低了使用门槛,同时也带来了平台绑定:开源的 Gemini CLI 已经停止服务,核心引擎闭源,主要针对 Gemini 优化。对于个人开发者和以 Gemini 为主的团队,这是效率上的明显提升;对于需要多模型、可审计、可私有部署的团队,开源框架加统一模型接入层仍然是更灵活的组合。

最终的判断方法很简单:拿你手头一个真实任务,试着把它拆成三个互不依赖的子任务。如果拆得开,/swarm 很可能为你节省大量时间;如果拆不开,Teamwork 或 Workflow 模式,乃至单代理,才是更合适的起点。

antigravity-orchestrator-explained-from-zero-image-3


参考资料

  1. xkcd 353 – Python:import antigravity 彩蛋的出处

    • 链接: xkcd.com/353
    • 说明:帮助理解 Antigravity 名称的文化来源
  2. Google Antigravity 入门视频:官方入门演示

    • 链接: youtube.com/watch?v=nTOVIGsqCuY
    • 说明:适合第一次接触 Antigravity 的开发者
  3. Sundar Pichai 推文:/swarm 能力演示

    • 链接: twitter.com/sundarpichai/status/2120198811297694192
    • 说明:Gemini 4 Carbon 开放时的官方演示
  4. Pelican Campus Quest 可玩版:/swarm 生成的浏览器游戏

    • 链接: aistudio.google.com/apps/bundled/pelican-campus-quest
    • 说明:直观感受蜂群模式的最终产物

作者:APIYI 技术团队
技术交流:欢迎在 API易 apiyi.com 首页联系我们,更多资料可访问 docs.apiyi.com 文档中心

延伸阅读

类似文章