Google Antigravity 2.0 深度实战：从 Agent-First 工作平台到本地 SDK 开发——AI 编程工具格局的重构与开发者实践指南

引言：AI 编程工具的 Agent 时代真正到来

2026 年 5 月 20 日，Google I/O 2026 大会上，谷歌发布了 Antigravity 2.0，这不是一个简单的版本迭代——它是一次根本性的定位重构。从去年的"智能体式 IDE"到今年的"Agent-First 通用工作平台"，谷歌清晰地传达了一个信号：AI 编程工具的竞争维度已经从"谁的补全更快"升级为"谁的 Agent 更强"。

在 Cursor、Claude Code、Codex 等选手各占一方的 2026 年，Antigravity 2.0 带来了三件武器：独立桌面应用、Antigravity CLI、以及最值得关注的开源 Antigravity SDK。本文将从架构设计、核心概念、代码实战、性能优化四个维度，带你深入理解这套工具的技术内核，并给出可直接落地的开发实践。

一、Antigravity 2.0 架构全景：从 IDE 到 Agent 操作系统

1.1 定位重构：为什么从 IDE 转向 Agent-First？

Antigravity 1.0 的定位是"AI 原生 IDE"，本质上还是在 VS Code 范式上加了一层智能体封装。但谷歌很快发现，开发者的真实工作流远不止编码——需求分析、文档撰写、测试编排、部署运维，这些环节都在呼唤 Agent 的介入。把 Agent 锁死在 IDE 里，就像把一个能干的全栈工程师关在编辑器里一样荒谬。

Antigravity 2.0 的核心变化：

这个转变的底层逻辑是：当 Agent 足够智能时，IDE 只是它的一个输出窗口，而不是它的全部世界。

1.2 技术架构分层

Antigravity 2.0 的架构可以划分为四个层次：

┌─────────────────────────────────────────────────┐
│           用户交互层 (Interaction)               │
│   Desktop App  |  CLI  |  AI Studio Mobile      │
├─────────────────────────────────────────────────┤
│           Agent 编排层 (Orchestration)           │
│   Project Manager | Scheduler | Slash Commands   │
│   Multi-Agent Coordinator | Permission Boundary  │
├─────────────────────────────────────────────────┤
│           Agent 运行时 (Antigravity Runtime)     │
│   Tool Execution | Context Manager | Hook System │
│   Stream Output | Structured Output | Memory     │
├─────────────────────────────────────────────────┤
│           基础设施层 (Infrastructure)             │
│   Gemini 3.5 Flash | Managed Agents (Cloud)      │
│   Local Sandbox | MCP Protocol | File System     │
└─────────────────────────────────────────────────┘

关键设计决策：

• Antigravity Runtime 是整个系统的核心引擎，它同时驱动桌面应用、CLI 和 SDK。这意味着你在 SDK 中创建的 Agent，和 Antigravity 桌面版中运行的 Agent 使用的是同一套执行引擎——这保证了行为一致性。
• Gemini 3.5 Flash 作为默认推理模型，相比上一代推理速度提升 12 倍。这不是简单的模型升级，而是专门针对 Agent 场景优化了推理延迟——Agent 需要频繁决策，低延迟比高智能更重要。
• MCP 协议 的深度集成使得工具扩展变得标准化，目前已支持 1.1 万+ 工具接入。

二、Project 模型：多 Agent 协作的组织基础

2.1 从 Workspace 到 Project

Antigravity 1.0 的 Workspace 模型把 Agent 和代码仓库强绑定——一个 Workspace 对应一个 repo，一个 Agent 对应一次会话。这种模型在单项目开发时足够用，但在实际工作中，开发者经常需要跨项目操作：修改 API 的同时更新文档，重构后端的同时调整前端。

Antigravity 2.0 引入的 Project 模型解耦了 Agent 与仓库的关系：

# Project 模型的概念结构（非真实 API，用于理解）
class Project:
    name: str
    folders: list[Folder]         # 一个项目可关联多个文件夹
    agents: dict[str, AgentConfig]  # 每个 Agent 有独立配置
    permissions: PermissionBoundary # 项目级权限边界
    schedules: list[Schedule]      # 定时任务

class Folder:
    path: str
    readonly: bool                 # 可设为只读，保护代码
    allowed_tools: list[str]       # 该文件夹允许使用的工具

class AgentConfig:
    name: str
    model: str                     # 可为不同 Agent 选不同模型
    system_prompt: str
    tools: list[str]
    max_iterations: int

这种设计的核心好处是权限隔离。你可以让"文档 Agent"只读代码目录、只写 docs 目录；让"测试 Agent"可以执行 shell 命令但不能修改源码。多 Agent 并行工作时，互不干扰。

2.2 多 Agent 并行的调度策略

Antigravity 2.0 的多 Agent 协调不是简单的"同时开多个窗口"，而是有一套调度机制：

并行模式（Parallel）： 多个 Agent 同时启动，各自独立执行任务。适合互不依赖的工作，比如同时修改不同模块的代码。

管道模式（Pipeline）： Agent 之间形成依赖链，上游 Agent 的输出作为下游的输入。比如"需求 Agent"生成 PRD → "架构 Agent"生成设计文档 → "编码 Agent"实现代码 → "测试 Agent"编写测试。

监督模式（Supervisor）： 一个主 Agent 负责任务拆解和分发，子 Agent 执行具体工作并汇报结果。主 Agent 可以根据执行情况动态调整策略。

在实践中，通过斜杠命令控制 Agent 的行为模式：

/goal "实现用户登录功能"     # 连续执行模式：Agent 会一步步推进直到目标完成
/grill-me "这个API设计合理吗" # 澄清模式：Agent 先提问确认需求，再开始工作
/browser "打开文档网站"       # 显式调用浏览器能力
/schedule "每天9点运行测试"   # 设置定时任务

/grill-me 是一个很有意思的设计。大多数 AI 编程工具倾向于"你说了我就做"，但实际上模糊的需求是最大的效率杀手。/grill-me 让 Agent 先当需求分析师，把模糊的需求拆解清楚再动手——这避免了"写了一半发现方向错了"的浪费。

三、Antigravity SDK 深度实战：20 行代码构建本地 Agent

3.1 SDK 设计哲学

Antigravity SDK 是本次发布中最让我兴奋的部分。它解决了 AI Agent 开发的一个核心矛盾：API 调用式的 Agent 服务延迟高、定制性差、强依赖网络，但完全自研 Agent 又门槛太高。

SDK 的设计原则：

1. AI-Friendly First：代码结构要让 AI 能读懂、能修改。用 Pydantic V2 模型、结构化输出、明确命名。
2. Same Runtime：SDK 创建的 Agent 和 Antigravity 产品线用的是同一个 Runtime，行为一致。
3. Security by Default：所有内置工具默认启用，但 Shell 访问默认需确认。
4. Extensible：四类工具集（内置、自定义函数、MCP、技能包）+ 钩子系统。

3.2 最小可用 Agent：20 行代码起步

from antigravity import Agent, Runner

# 创建一个基础 Agent
agent = Agent(
    name="code-reviewer",
    model="gemini-3.5-flash",
    instructions="""你是一个严格的代码审查员。
    审查代码时关注：
    1. 潜在的 bug 和边界情况
    2. 性能瓶颈
    3. 安全漏洞
    4. 代码可读性和维护性
    用中文给出审查意见。"""
)

# 运行 Agent
result = Runner.run(agent, "审查以下代码：\n" + open("main.py").read())
print(result.final_output)

这就是一个功能完整的 Agent——它拥有文件读写、代码编辑、Shell 执行等内置工具，可以自主规划执行步骤。

3.3 自定义工具：让 Agent 能做更多事

内置工具覆盖了通用场景，但真实项目往往需要特定工具。SDK 提供了三种扩展方式：

方式一：自定义 Python 函数

from antigravity import Agent, Runner, function_tool
from pydantic import BaseModel

class DeployConfig(BaseModel):
    """部署配置"""
    environment: str  # staging | production
    version: str
    rollback_on_failure: bool = True

@function_tool
async def deploy_service(config: DeployConfig) -> str:
    """部署服务到指定环境"""
    import subprocess
    
    cmd = f"kubectl apply -f k8s/{config.environment}/ --record"
    if config.rollback_on_failure:
        cmd += " && kubectl rollout status deployment/app"
    
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    
    if result.returncode != 0:
        if config.rollback_on_failure:
            subprocess.run("kubectl rollout undo deployment/app", shell=True)
        return f"部署失败，已回滚：{result.stderr}"
    
    return f"部署成功：{config.environment} 环境，版本 {config.version}"

# 注册工具到 Agent
agent = Agent(
    name="devops-agent",
    instructions="你是一个 DevOps 助手，负责服务部署和运维。",
    tools=[deploy_service]
)

result = Runner.run(
    agent, 
    "把当前版本 v2.3.1 部署到 staging 环境"
)

方式二：MCP 服务器连接

MCP（Model Context Protocol）是 Anthropic 提出的工具通信协议，Antigravity SDK 原生支持：

from antigravity import Agent, MCPServerStdio

# 连接 GitHub MCP 服务器
github_mcp = MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
    env={"GITHUB_TOKEN": "ghp_xxx"}
)

# 连接数据库 MCP 服务器
db_mcp = MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-postgres"],
    env={"DATABASE_URL": "postgresql://localhost/mydb"}
)

agent = Agent(
    name="fullstack-agent",
    instructions="你是一个全栈开发助手，可以操作 GitHub 和数据库。",
    mcp_servers=[github_mcp, db_mcp]
)

# Agent 现在可以创建 PR、查询数据库、合并代码...
result = Runner.run(
    agent,
    "查看最近的 PR，如果有数据库迁移相关的，帮我验证 SQL 是否正确"
)

方式三：Agent 技能包

技能包是预打包的工具组合，适合特定领域的任务：

from antigravity import Agent, SkillPack

# 使用 Web 开发技能包
web_skill = SkillPack.load("antigravity-skills/web-development")

agent = Agent(
    name="web-dev",
    skills=[web_skill]  # 包含 Figma转代码、组件生成、样式优化等工具
)

3.4 安全策略与钩子系统

Agent 有了 Shell 执行能力就像给了它一把双刃剑——用好了效率爆炸，用不好就是安全灾难。SDK 提供了两层防护：

声明式策略控制：

from antigravity import Agent, Policy

agent = Agent(
    name="safe-agent",
    policies=[
        Policy.allow("file_read"),           # 允许读文件
        Policy.allow("file_write", paths=["/tmp/work"]),  # 只允许写特定目录
        Policy.confirm("shell_exec"),        # Shell 执行需人工确认
        Policy.deny("shell_exec", pattern="rm -rf"),  # 禁止危险命令
    ]
)

钩子系统——生命周期的拦截器：

from antigravity import Agent, Hook

async def log_tool_usage(context):
    """记录每次工具调用"""
    print(f"[Hook] Agent {context.agent.name} 调用了 {context.tool_name}")
    print(f"[Hook] 参数: {context.arguments}")

async def approve_destructive_ops(context):
    """审批破坏性操作"""
    if context.tool_name == "file_write" and "DELETE" in str(context.arguments):
        # 弹出确认对话框
        approved = await ask_user_confirmation(context)
        if not approved:
            return Hook.REJECT  # 拒绝执行
    return Hook.CONTINUE

async def sanitize_output(context):
    """清洗输出中的敏感信息"""
    import re
    context.result = re.sub(r'\b\d{16}\b', '[CARD_MASKED]', context.result)
    return Hook.CONTINUE

agent = Agent(
    name="production-agent",
    hooks={
        "before_tool_call": [log_tool_usage, approve_destructive_ops],
        "after_tool_call": [sanitize_output],
    }
)

钩子系统的精妙之处在于它不是简单的"允许/拒绝"二元判断，而是可以在运行时修改数据、注入上下文、甚至替换工具实现。这为生产环境的审计、合规、监控提供了完整的扩展点。

3.5 会话管理与状态持久化

Agent 的对话不是无状态的——SDK 支持会话 ID 恢复：

from antigravity import Agent, Runner

agent = Agent(name="long-running-task")

# 第一次运行
result1 = Runner.run(agent, "开始重构用户模块")
session_id = result1.session_id

# ... 几小时后，继续同一个会话 ...

# 恢复会话，Agent 记得之前的上下文
result2 = Runner.run(
    agent, 
    "继续之前的重构，处理剩余的接口",
    session_id=session_id
)

对于 Managed Agents（云端版本），这种持久化更加彻底——即使关闭了 Agent 实例，已编译的文件、记忆日志和项目状态都会保留。这解决了长时间运行任务的断点续传问题。

3.6 结构化输出：让 Agent 的结果可编程

Agent 不只是聊天，它需要产出结构化数据供下游系统消费：

from antigravity import Agent, Runner
from pydantic import BaseModel
from typing import list

class CodeReview(BaseModel):
    """代码审查结果"""
    severity: str  # critical | warning | suggestion
    file: str
    line: int
    issue: str
    suggestion: str

class ReviewReport(BaseModel):
    """审查报告"""
    total_issues: int
    critical_count: int
    reviews: list[CodeReview]
    summary: str
    approved: bool

agent = Agent(
    name="reviewer",
    output_type=ReviewReport  # 声明输出类型
)

result = Runner.run(agent, "审查 src/ 目录下的所有 Python 文件")
report: ReviewReport = result.final_output

# 结构化数据可以直接用于自动化流程
if not report.approved:
    for review in report.reviews:
        if review.severity == "critical":
            send_alert(f"严重问题：{review.file}:{review.line} - {review.issue}")

这比传统 AI 工具的"文本输出 → 正则提取"模式优雅太多了。Pydantic 模型既作为类型约束，也作为文档——Agent 知道需要输出什么结构，下游系统知道怎么消费。

四、Managed Agents：云端 Agent 的生产级部署

4.1 一次 API 调用启动云端 Agent

对于不需要本地文件系统的场景，Managed Agents 提供了云端运行方案：

import google.generativeai as genai

genai.configure(api_key="your-api-key")

# 一行代码启动云端 Agent
response = genai.managed_agent(
    task="监控 GitHub 仓库的 Issues，对新 Issue 进行分类并分配标签",
    tools=["github", "email"],
    environment="linux",  # 隔离 Linux 环境
    persistent=True       # 持久化状态
)

agent_id = response.agent_id
print(f"Agent 已启动，ID: {agent_id}")

Managed Agents 运行在隔离的 Linux 环境中，具备完整的持久化能力。这意味着：

• 关闭连接后，Agent 仍在云端运行
• 下次连接时，编译文件、日志、项目状态都在
• 可以通过 agent_id 随时查询状态或下发新指令

4.2 与 Google 生态的深度集成

Managed Agents 的杀手级特性是与 Google 生态的无缝连接：

# AI Studio 移动端 → 桌面端工作流
# 在手机上整理想法，回到桌面看到可运行原型

# Android 原生编译
response = genai.managed_agent(
    task="生成一个带用户登录的 Android 应用",
    output_format="android_apk",
    deploy_to_play_console=True,  # 直接推到 Play Console 测试轨道
    workspace_integration=True     # 连接 Google Workspace 数据
)

从构想到测试的链路被压缩到了极致——在手机上描述想法，Agent 生成 Android 应用，自动推到 Play Console 内测。这在传统开发流程中至少需要一天的工作量。

五、Antigravity CLI：Gemini CLI 的继任者

5.1 迁移指南

谷歌已正式宣布 Antigravity CLI 是 Gemini CLI 的唯一继任者。对于已经在使用 Gemini CLI 的开发者，迁移路径非常简单：

# 旧版 Gemini CLI
gemini "帮我写一个 HTTP 服务器"

# 新版 Antigravity CLI
antigravity "帮我写一个 HTTP 服务器"

# 区别：更快、支持多 Agent、支持定时任务

Antigravity CLI 的关键升级：

5.2 CLI 实战场景

# 场景1：代码审查
antigravity /grill-me "审查当前分支的变更，重点关注安全问题"

# 场景2：定时运维
antigravity /schedule "每天早上8点检查服务健康状态并发送报告" --cron "0 8 * * *"

# 场景3：多 Agent 协作
antigravity --agents "frontend,backend,testing" \
  "前端实现登录页面，后端实现 JWT 认证，测试编写集成测试"

# 场景4：浏览器辅助
antigravity /browser "打开 API 文档，找到分页查询的参数说明"

CLI 模式特别适合服务器环境和 CI/CD 集成。你可以在 GitHub Actions 中这样使用：

name: AI Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Antigravity CLI
        run: npm install -g @google/antigravity-cli
      - name: Run AI Review
        env:
          ANTAGRAVITY_API_KEY: ${{ secrets.ANTIGRAVITY_API_KEY }}
        run: |
          antigravity "审查这个 PR 的代码变更，输出 JSON 格式的审查报告" \
            --output json > review_report.json
      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const report = require('./review_report.json');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report.summary
            })

六、性能优化：让 Agent 跑得更快、更准

6.1 推理延迟优化

Agent 编程和聊天补全最大的区别是调用频率。一次编码任务，Agent 可能需要 20-50 次工具调用，每次都涉及一次推理。如果单次推理延迟是 2 秒，50 次就是 100 秒——用户根本等不了。

Gemini 3.5 Flash 的 12 倍提速是基础，但 SDK 层面还有这些优化空间：

流式输出 + 提前决策：

from antigravity import Agent, Runner, RunnerConfig

config = RunnerConfig(
    stream=True,              # 流式输出
    early_stop=True,          # 工具调用就绪时立即返回，不等完整响应
    max_turns=30,             # 限制最大轮次，防止死循环
    concurrency=3,            # 并行执行独立工具调用
)

result = Runner.run(agent, task, config=config)

for event in result.stream():
    if event.type == "tool_call":
        print(f"调用工具: {event.tool_name}")
    elif event.type == "tool_result":
        print(f"工具返回: {event.result[:100]}...")
    elif event.type == "final_output":
        print(f"最终结果: {event.output}")

6.2 上下文管理优化

Agent 最大的性能杀手不是推理慢，而是上下文爆炸。一个大型项目的代码量动辄几十万行，全部塞进上下文窗口既不现实也不高效。

SDK 提供了多层次的上下文管理策略：

from antigravity import Agent, ContextPolicy

agent = Agent(
    name="efficient-agent",
    context_policy=ContextPolicy(
        # 1. 自动压缩：对长上下文进行摘要压缩
        auto_compress=True,
        compress_threshold=80000,  # 超过 80k token 自动压缩
        
        # 2. 选择性加载：只加载相关文件
        selective_load=True,
        max_files=50,              # 最多加载 50 个文件
        
        # 3. 优先级排序：最近修改的文件优先
        priority="recent_changes",
        
        # 4. 向量检索：对超大项目使用 RAG
        use_rag=True,
        embedding_model="gemini-embedding-003",
    )
)

6.3 可观测性：知道 Agent 在做什么

生产环境中，你必须知道 Agent 的每一步操作。SDK 内置了可观测性支持：

from antigravity import Agent, Runner, TraceConfig

config = TraceConfig(
    log_tool_calls=True,       # 记录工具调用
    log_token_usage=True,      # 记录 token 用量
    log_reasoning=True,        # 记录推理过程
    export_format="opentelemetry",  # 兼容 OTLP 协议
)

result = Runner.run(agent, task, trace_config=config)

# 查看 token 用量
print(f"总 token: {result.usage.total_tokens}")
print(f"推理 token: {result.usage.reasoning_tokens}")
print(f"工具调用次数: {result.usage.tool_calls}")
print(f"总耗时: {result.usage.latency_seconds}s")

这些数据对于成本控制和性能调优至关重要。如果发现某个 Agent 的工具调用次数异常多，可能是指令不够清晰；如果 token 用量居高不下，可能是上下文压缩策略需要调整。

七、竞品对比：Antigravity 2.0 vs Cursor vs Claude Code

Antigravity 2.0 的差异化优势集中在三个点：多 Agent 协同、本地 SDK、云端托管。它的定位不是"更好的 Cursor"，而是"AI Agent 的操作系统"——Cursor 是编辑器，Claude Code 是命令行工具，而 Antigravity 是平台。

但要注意，Antigravity 目前也有短板：对非 Google 生态的集成不够完善，SDK 还在研究预览阶段，社区生态远不如 Cursor 成熟。选择哪个工具，取决于你的核心需求是什么。

八、实战案例：构建一个多 Agent 代码审查系统

把前面学到的知识点串起来，我们构建一个完整的多 Agent 代码审查系统：

"""
多 Agent 代码审查系统
- Security Agent：检查安全漏洞
- Performance Agent：分析性能瓶颈
- Style Agent：审查代码风格
- Supervisor Agent：汇总各 Agent 结果，给出最终建议
"""

import asyncio
from antigravity import Agent, Runner, function_tool, MCPServerStdio
from pydantic import BaseModel
from typing import list

# ========== 定义输出结构 ==========

class Issue(BaseModel):
    severity: str      # critical | warning | info
    file: str
    line_range: tuple[int, int]
    description: str
    suggestion: str

class AgentReport(BaseModel):
    agent_name: str
    issues: list[Issue]
    summary: str

class FinalReview(BaseModel):
    approved: bool
    total_issues: int
    critical_issues: list[Issue]
    agent_reports: list[AgentReport]
    overall_assessment: str

# ========== Security Agent ==========

@function_tool
async def check_sql_injection(code: str) -> list[str]:
    """检查 SQL 注入风险"""
    patterns = [
        "f\"SELECT", "f\"INSERT", "f\"UPDATE", "f\"DELETE",
        "f'SELECT", "f'INSERT", "+ SELECT", "format(SELECT"
    ]
    found = []
    for i, line in enumerate(code.split("\n"), 1):
        for pattern in patterns:
            if pattern.lower() in line.lower():
                found.append(f"Line {i}: 可能的 SQL 注入 - {pattern}")
    return found

@function_tool
async def check_hardcoded_secrets(code: str) -> list[str]:
    """检查硬编码的密钥"""
    import re
    patterns = [
        (r'password\s*=\s*["\'][^"\']+["\']', "硬编码密码"),
        (r'api_key\s*=\s*["\'][^"\']+["\']', "硬编码 API Key"),
        (r'secret\s*=\s*["\'][^"\']+["\']', "硬编码 Secret"),
    ]
    found = []
    for pattern, desc in patterns:
        matches = re.finditer(pattern, code, re.IGNORECASE)
        for m in matches:
            found.append(f"{desc}: {m.group()[:30]}...")
    return found

security_agent = Agent(
    name="security-reviewer",
    instructions="""你是一个安全审查专家。审查代码时重点检查：
    1. SQL 注入、XSS 等注入攻击
    2. 硬编码的密钥和凭证
    3. 不安全的加密算法
    4. 权限提升风险
    使用提供的工具进行检查，并给出详细的安全报告。""",
    tools=[check_sql_injection, check_hardcoded_secrets],
    output_type=AgentReport
)

# ========== Performance Agent ==========

@function_tool
async def analyze_complexity(code: str) -> dict:
    """分析代码时间复杂度"""
    # 简化的复杂度分析
    nested_loops = 0
    for line in code.split("\n"):
        stripped = line.strip()
        if stripped.startswith("for ") or stripped.startswith("while "):
            indent = len(line) - len(line.lstrip())
            if indent > 4:  # 嵌套循环
                nested_loops += 1
    
    return {
        "nested_loops": nested_loops,
        "estimated_complexity": f"O(n^{nested_loops + 1})" if nested_loops else "O(n)",
        "risk_level": "high" if nested_loops >= 2 else "medium" if nested_loops == 1 else "low"
    }

performance_agent = Agent(
    name="performance-reviewer",
    instructions="""你是一个性能优化专家。审查代码时重点检查：
    1. 时间/空间复杂度问题
    2. 不必要的数据库查询（N+1 问题）
    3. 内存泄漏风险
    4. 缓存使用是否合理
    使用提供的工具进行分析，并给出性能优化建议。""",
    tools=[analyze_complexity],
    output_type=AgentReport
)

# ========== Style Agent ==========

style_agent = Agent(
    name="style-reviewer",
    instructions="""你是一个代码风格审查专家。审查代码时重点检查：
    1. 命名规范（变量、函数、类）
    2. 函数长度和复杂度
    3. 注释和文档完整性
    4. 代码重复（DRY 原则）
    直接给出风格审查报告。""",
    output_type=AgentReport
)

# ========== Supervisor Agent ==========

supervisor_agent = Agent(
    name="review-supervisor",
    instructions="""你是代码审查的总负责人。你会收到多个审查 Agent 的报告，需要：
    1. 汇总所有问题
    2. 识别跨领域的关联问题（如安全+性能的双重风险）
    3. 按优先级排序
    4. 给出最终的批准/拒绝决定和整体评估
    只有关键问题为 0 且警告问题不超过 3 个时才批准。""",
    output_type=FinalReview
)

# ========== 执行审查 ==========

async def review_code(code_path: str):
    code = open(code_path).read()
    task = f"审查以下代码：\n```\n{code}\n```"
    
    # 并行运行三个专业 Agent
    results = await asyncio.gather(
        Runner.run_async(security_agent, task),
        Runner.run_async(performance_agent, task),
        Runner.run_async(style_agent, task),
    )
    
    # 汇总结果交给 Supervisor
    reports = [r.final_output for r in results]
    summary_task = "以下是三个审查 Agent 的报告，请汇总给出最终审查意见：\n\n"
    for report in reports:
        summary_task += f"## {report.agent_name}\n{report.summary}\n\n"
    
    final = Runner.run(supervisor_agent, summary_task)
    return final.final_output

# 运行
if __name__ == "__main__":
    review = asyncio.run(review_code("src/main.py"))
    
    print(f"审查结果：{'✅ 通过' if review.approved else '❌ 需修改'}")
    print(f"总问题数：{review.total_issues}")
    print(f"关键问题：{len(review.critical_issues)}")
    print(f"\n总体评估：\n{review.overall_assessment}")

这个案例展示了 Antigravity SDK 的核心能力：多 Agent 并行协作、结构化输出、自定义工具、监督模式。三个专业 Agent 各司其职并行工作，Supervisor Agent 负责汇总决策——这不是简单的 AI 对话，而是一个完整的自动化工作流。

九、迁移与落地建议

9.1 从 Gemini CLI 迁移

# 1. 安装 Antigravity CLI
npm install -g @google/antigravity-cli

# 2. 迁移配置
antigravity migrate --from gemini-cli

# 3. 验证
antigravity --version
antigravity "测试连接"

9.2 渐进式采用 SDK

不要一上来就把整个项目交给 Agent。建议分三个阶段：

阶段一：辅助审查（1-2 周）

• 用 SDK 构建代码审查 Agent
• 只读不写，让 Agent 出建议，人做决策
• 建立信任和认知基线

阶段二：辅助编码（3-4 周）

• 让 Agent 处理样板代码、单元测试、文档
• 人工审查 Agent 输出，逐步调整指令
• 配置安全策略，限制写入范围

阶段三：自主执行（5+ 周）

• 对于低风险任务（文档更新、样式调整），允许 Agent 自主执行
• 通过钩子系统监控关键操作
• 定期审查 Agent 的执行日志

9.3 成本估算

以 Gemini 3.5 Flash 的定价为基准：

• 单次代码审查（~10 轮工具调用）：约 0.02 美元
• 全项目重构（~100 轮工具调用）：约 0.20 美元
• 7x24 定时监控 Agent（~500 次/天调用）：约 1 美元/天

相比人力成本，这个定价基本可以忽略。但要注意 token 用量的监控——上下文膨胀是最大的成本风险。

十、总结与展望

Antigravity 2.0 不只是一个 AI 编程工具的版本更新，它代表了一种新的思路：把 AI Agent 从编辑器的附属品提升为开发流程的独立参与者。

三个核心观点：

1. 多 Agent 是必然方向。单 Agent 无论多强，都无法同时兼顾安全和效率、速度和质量。分工协作才是工程化的正道。

2. SDK 开源是关键一步。闭源的 AI 工具最终都会遇到定制化瓶颈。Antigravity SDK 的 Apache 2.0 开源，意味着开发者可以在自己的基础设施上构建 Agent——这在企业级场景中是刚需。

3. Agent 操作系统正在成型。从桌面应用到 CLI 到 SDK 到云端托管，Antigravity 正在构建一个完整的 Agent 运行生态。未来，开发者可能不再"写代码"，而是"管理 Agent"——设计工作流、配置策略、审查结果。

当然，Antigravity 2.0 还不完美。SDK 还在研究预览阶段，对非 Google 生态的支持有限，社区规模尚小。但方向是对的，架构是扎实的。对于关注 AI 编程工具演进的开发者来说，这值得深入研究。

如果你已经在使用 Cursor 或 Claude Code，不需要立刻切换。但建议你花一个下午试试 Antigravity SDK——即使不用 Antigravity 的产品，SDK 中的 Agent 设计模式（声明式策略、钩子系统、结构化输出）也是你在任何 AI Agent 开发中都能借鉴的。

代码已经准备好了，Agent 已经就位，剩下的就是你的想象力。

本文基于 Google I/O 2026 发布的 Antigravity 2.0 相关资料撰写，部分 API 为概念示例，实际使用请参考官方文档。SDK 目前处于 Research Preview 阶段，API 可能会有调整。