Copilot与Claude协作：基于Antigravity的多智能体编排实战

如果你的团队也纠结过“Copilot好用还是Claude更强”，那你一定能懂我前段时间的处境。单拉一个出来好像都能干活，可真放进复杂项目里，Copilot写代码快但容易埋头猛冲，Claude想得周到却总在动手时略拖节奏。与其让它们单打独斗，不如干脆做个多智能体系统，让Copilot和Claude各管一段，再配一个编排框架统一调度。这就是我这篇文章要聊的：基于Antigravity框架，把Copilot与Claude集成到同一个协作工作流里，搭建一个真正能跑的多智能体系统。

文章适合两类人看：一类是已经在用Copilot或Claude写代码，但对“多Agent协作”只停留在概念阶段的开发者；另一类是想搭企业级AI流水线，却不知道怎么把多个模型服务接进统一编排框架的架构师。下面是实操记录，环境基于某开源社区版Antigravity框架（下文统称Antigravity），集成方式同样适用于其他编排内核。

1. Antigravity框架与整体设计思路

1.1 为什么选Antigravity而不是自己攒

先说我自己的背景。我之前试着用消息队列加几个Python脚本硬凑过“多智能体”，结果非常难看：每个Agent都有自己的调用方式，上下文靠文件互相传，一个环节卡住全线停摆。后来换成Antigravity，结构一下就清晰了。

Antigravity本身不是模型，而是一个“智能体编排框架”。它做的事情跟导演类似：告诉每个演员什么时候上台、什么时候说话、说完话把麦克风传给谁。框架负责Agent的注册、调度、上下文维护、工具调用和错误重试，你只需要专注定义“每个Agent是谁、擅长什么、归谁管”。

它的几个核心设计值得先说清楚：

• 一切皆Agent：无论底层接的是Copilot、Claude还是本地模型，在框架里都被包装为统一接口的Agent对象。
• 事件总线通信：Agent之间不直接互相调函数，而是通过事件发布/订阅进行解耦。谁关心某类事件，谁就订阅。
• 上下文内存区：每个任务或会话有独立上下文，可以跨Agent共享，也能按Agent隔离。
• 适配器机制：Copilot、Claude都有各自的适配器插件，接入时只需填API配置，不需要改业务代码。

选了Antigravity而不是自研，最大的理由是生态。框架自带“任务队列”“断点续跑”“Token用量统计”这些模块。我自己写少说要一个月，用框架两周就能把核心流程跑通，后面维护成本也低得多。

1.2 多智能体的角色拆解与协作约定

搭建之前一定要先想清楚角色划分，否则代码写得再好也是乱的。我当时参考了一个比较成熟的互联网工作流，把整个研发过程拆成三类Agent：

这个分工不是拍脑袋。Claude的长板在于长上下文理解和复杂推理，适合做规划与审查；Copilot生来就是干补全和快速产出的，放到编码位最合适。让强者干强项，整体效率才能上去。

协作约定也要提前订好。我这里定了三条：

• 编码Agent只相信自己上下文里拿到的任务指令，不允许跨Agent读全局上下文，避免跑偏。
• 规划Agent输出必须带“验收标准”，否则编码Agent不知道怎么算完成。
• 审查Agent发现问题时不直接改代码，只输出问题报告，由编码Agent回头修改，保持职责单一。

这三条约定在Antigravity里用配置就能固化下来。后面你会发现，越早把这些规则写进系统，后期跑起来越省心。

2. 环境部署与依赖装配

2.1 安装Antigravity核心库

实操第一步永远是搭环境。Antigravity核心库可以通过包管理器直接安装，我的环境是Python 3.11，Windows 11和Ubuntu 22.04双系统都跑通了。安装命令如下：

pip install antigravity-core antigravity-adapters-copilot antigravity-adapters-claude

三个包分别是核心框架、Copilot适配器、Claude适配器。安装时注意Python版本最好不小于3.10，否则部分异步特性会报错。装完之后验证一下版本，保证三者匹配：

python -c "import antigravity; print(antigravity.__version__)"

我踩过一个坑：第一次安装时没指定版本，结果antigravity-core自动装到了最新版，而两个适配器还是旧版，运行时直接抛“接口不兼容”的异常。后来统一锁版本，比如全部用1.4.x，问题就消失了。建议你装完后马上执行以上验证命令，别急着往下走。

2.2 配置两套模型服务的接入凭证

Antigravity的适配器并不直接内置模型，而是通过API方式接入服务。所以配置环节需要准备两样东西：Copilot服务的访问令牌，以及Claude平台的API密钥。建议单独建一个环境变量文件，不要写死在代码里。

我在项目根目录创建了.env文件，内容大致是：

COPILOT_API_BASE="https://your-copilot-endpoint.example.com/v1" COPILOT_API_KEY="sk-xxxxxxxxxxxxxxxxx" CLAUDE_API_KEY="sk-ant-xxxxxxxxxxxxxxxxx" CLAUDE_MODEL="claude-sonnet-4-5"

这里有一点需要特别提醒：不同渠道的Copilot接口地址差异很大，有的是标准OpenAI兼容格式，有的是厂商私有格式。Antigravity的Copilot适配器默认按OpenAI兼容格式请求，如果你的渠道不是，需要在配置里加一行api_style="compat"或者自定义适配器。CLAUDE_MODEL则根据自己的账号权限来，一般选平衡型模型，性价比最好。

写完.env后加载环境变量。我用的是python-dotenv，非常省事：

pip install python-dotenv

加载代码就一行：

from dotenv import load_dotenv load_dotenv()

密钥管理这事我建议不要省，尤其是要提交到代码仓库的项目。.env文件必须加入.gitignore，密钥一旦泄露，账户安全、配额消耗都是不小的麻烦。

2.3 验证连通性的最小Demo

配置完先别急着搭复杂流程，跑一个最小Demo确认两端连通。我写了一个最简单的单Agent调用：

from antigravity import Agent, Runner agent = Agent( name="ping-copilot", backend="copilot", system_prompt="你是一个简单的回显助手，用户说什么你就重复什么。", ) runner = Runner(agent=agent) result = runner.run("hello antigravity") print(result.output)

如果输出里能看到“hello antigravity”或者合理回显，说明Copilot适配器通了。然后把backend改成claude，再进行一次同样的调用，确认Claude侧也正常。

我当时卡在这步好一阵子，原因是Claude适配器默认请求模型名跟我账号实际可用模型不一致，报“model not found”。后来在Agent初始化里显式指定了model="claude-sonnet-4-5"才解决。如果你用的模型名比较特殊，建议在构造函数里直接传参覆盖默认值。

这个最小Demo看似简单，但意义很大。它排除了“配置没生效”“密钥错误”“模型名不对”这三类最常见问题，后面所有复杂系统都是在这个连接基础上搭建的。

3. 双模型接入：编写核心集成代码

3.1 规划Agent：让Claude负责拆解需求

环境通了以后，开始真正写核心代码。先是规划Agent，底层模型选Claude，因为它的长上下文理解能力强，适合把一个模糊需求切成清晰任务。

Antigravity里定义一个Agent有很多参数，我先给规划Agent配置了这些关键项：

from antigravity import Agent planner = Agent( name="planner", backend="claude", model="claude-sonnet-4-5", temperature=0.2, system_prompt=""" 你是一个资深研发规划师。请将用户输入的原始需求拆解为可执行的任务清单。 输出必须采用PJSON(Prompt JSON)格式，包含： - tasks: 数组，每个元素包含任务ID、任务描述、验收标准、依赖关系； - risk_points: 数组，列出可能踩坑的技术点。 """, )

temperature设0.2是为了让输出尽量稳定，不要每次拆出来的计划都不一样。如果你希望规划结果更有发散性，可以调到0.5，但以我的经验，规划类任务越低越好。

Antigravity的PJSON格式是这个框架的特色，相当于给模型一个明确的结构化输出协议。哪怕模型本身支持JSON输出，我仍建议在system prompt里把字段含义写清楚，否则Claude可能把“验收标准”写成一句空话，比如“确保功能正常”，而不是“输入正常参数时返回200，异常参数时返回400与错误码”。后者才是有用的验收标准。

这道Agent的输入是用户的一句话需求，输出是一份结构化计划。我们把它保存到共享上下文里，供编码Agent取用。

3.2 编码Agent：让Copilot负责落地实现

编码Agent是给我最大惊喜的环节。Copilot在代码补全场景下极其顺手，但直接让它写一整个模块时，它又容易“自嗨”，写出来的代码能跑但常常不符合规范。解决办法是：严格要求它先读取规划Agent的输出，一次只实现一个任务。

coder = Agent( name="coder", backend="copilot", temperature=0.1, system_prompt=""" 你是一个严格按计划执行的编码员。 规则： 1. 只读取上下文中的current_task，不要自行扩展功能； 2. 生成完整的代码文件，并标注文件路径； 3. 必须包含必要的错误处理； 4. 验收标准未满足前，不要声称任务完成。 """, )

注意这里的“只读current_task”。初始版本我把整个任务清单都塞给了它，结果Copilot擅自调整了实现顺序，甚至跳过了一个低优先级任务。后来改成“一任务一指令”，用Antigravity的上下文隔离功能把无关信息挡在外面，效果立刻稳定。

编码Agent的调用逻辑是循环式的：从任务队列弹出一个任务，写入上下文，让它生成代码，保存文件，再弹出下一个。文件落盘操作不归模型管，由框架的执行器负责。简单说，模型只负责以文本形式输出“我要创建什么文件、代码是什么”，执行器解析之后真正在本地创建文件。

这种设计的好处是模型不需要碰文件系统，减少了权限问题和平台绑定。任务完成事件会发布到总线上，触发后续的审查Agent。

3.3 审查与总结Agent：闭环的关键

审查Agent是我认为整套系统最值得加的一道关。以前人肉写代码还能靠肉眼找bug，让模型批量生成时，如果没人把关，垃圾代码会越积越多。审查Agent用Claude，把它放在编码Agent之后，形成一个“写—审—改”闭环。

reviewer = Agent( name="reviewer", backend="claude", model="claude-sonnet-4-5", temperature=0.0, system_prompt=""" 你是严格的代码审查员。任务是检查编码Agent产出的代码。 输出分为三块： - bugs: 可能导致运行错误的问题列表； - risks: 潜在的性能风险、安全风险； - suggestions: 具体的修改建议。 注意：你只提交报告，不修改代码。 """, )

温度设为0.0，是为了保证审查结果可复现。审查报告写回上下文后，如果存在较高严重级别的问题，工作流指令会自动把报告连同原始代码重新发给编码Agent，让它“根据审查建议修改”。这个循环最多跑三轮，超过三轮就通知主流程人工接管，防止无限死循环。

最后是总结Agent。它负责把这些过程成果沉淀成文档，包括提交信息、更新模块说明、变更记录。Copilot对这种“基于已有内容写摘要”的任务完成得又快又好。它会在所有代码生成完毕、审查通过之后被触发，直接产出一段面向人的汇报文字。

四个Agent各司其职，主流程代码反而很短。核心就是把这些Agent组合进一个工作流，然后启动它。

4. 完整协作流水线：从需求输入到代码入库

4.1 定义会话与任务队列

现在把上面四个Agent真正组装起来。Antigravity中会话（Session）是贯穿任务始终的状态容器，所有Agent共享Session ID，但上下文读取范围受各自权限限制。

我创建的会话非常简单：

from antigravity import Session session = Session.new( project_name="demo-project", description="Copilot与Claude协作实验项目", )

Session创建后会自动生成一个上下文内存区。规划Agent把任务清单写入session，编码Agent再从session中获取属于它的任务。关键是要设置上下文可见范围：规划Agent的可见范围是“全部”，编码Agent的可见范围是“task: [当前任务ID]”，审查Agent的可见范围是“result: [当前任务ID]”。

这个可见范围配置乍一看繁琐，但它正是避免多Agent聊天跑题的核心。没有它，四五个Agent的高频事件会把上下文搅得一团糟。

任务队列我用Antigravity内置的Queue组件：

from antigravity import Queue queue = Queue.new(session=session, maxsize=20) for task in planner_output["tasks"]: queue.push(task)

队列是按依赖关系排好的，先做底层模块，再做上层业务。每完成一个任务，队列会发布task.completed事件，审查Agent监听这个事件后自动启动。

4.2 编排流程：用Flow描述协作规则

Antigravity的编排核心叫Flow。它定义“什么事件触发什么Agent，Agent输出交给谁”。我配置的Flow大致长这样：

from antigravity import Flow, trigger flow = Flow(session=session) @flow.on("session.started") def on_start(ctx): ctx.emit("planning.requested", payload=ctx.input) @flow.on("planning.completed") def on_plan_done(ctx): for task in ctx.payload["tasks"]: queue.push(task) ctx.emit("coding.requested", task_id=task["id"]) @flow.on("coding.completed") def on_code_done(ctx): ctx.emit("review.requested", task_id=ctx.task_id) @flow.on("review.completed") def on_review_done(ctx): if ctx.payload["highest_severity"] == "critical": ctx.emit("coding.requested", task_id=ctx.task_id, with_review=True) else: ctx.emit("task.archived", task_id=ctx.task_id) @flow.on("all_tasks_archived") def on_all_done(ctx): ctx.emit("summary.requested") flow.start()

这段逻辑其实就是在翻译我前面讲的协作约定。Antigravity用事件驱动的方式把这整套串联起来，每个Agent只对事件做出响应，不需要知道其他Agent存在。这跟微服务架构很像，只不过这里的“服务”是AI角色。

编码Agent收到coding.requested后会取任务ID，从队列中弹出具体任务指令，然后请求Copilot生成代码。执行器解析返回内容，把代码文件落盘；文件路径写进任务结果；结果再触发审查。

我第一次把这段流程跑通时非常激动，因为整个链路里我只手动输入了一句“做一个Todo List命令行工具”，然后规划、编码、审查、总结全跑完了。虽然第一次生成的代码还有小问题，但骨架完全正确，修修补补就行。

4.3 上下文管理与状态同步的实战要点

上下文管理是多智能体系统最容易翻车的环节，没有之一。模型不是无状态函数，它需要靠上下文来维持对任务的连贯理解。但上下文不是越多越好，而是“够用且准确”。

我的方案是三级上下文体系：

• 会话级上下文：存放项目背景、技术栈、全局约定，规划Agent和总结Agent读取。
• 任务级上下文：存放当前任务描述、相关代码片段，编码Agent和审查Agent读取。
• 临时上下文：存放单次调用的输入输出，调用结束即销毁，比如审查报告。

Antigravity对此有原生的ContextScope支持：

from antigravity import ContextScope with ContextScope(scope="task", task_id=task_id): result = runner.run(coder, task_payload)

进入这个with块之后，Agent只能看到该任务范围内的信息。这样做不仅是为了正确性，也直接决定Token消耗。一个只有任务级上下文的调用，可能消耗几千Token；而如果把整个会话所有历史都带进去，一次调用可能上万甚至几万Token。跑几十个任务后，费用差距相当明显。

关于状态同步，我建议所有跨Agent的状态都通过Session内存区流转，不要依赖外部文件。Antigravity的Session自带线程安全，事件回调并发执行时状态不会写乱。文件只作为最终产物存在，不作为中间状态存储。

5. 常见问题与排查经验

5.1 高频问题速查表

我搭这套系统前后花了一周，踩的坑不少，整理成一个速查表，各位可以直接对照排查。

5.2 上下文膨胀与截断处置

上下文膨胀是多Agent系统里最隐蔽的性能杀手。任务流一旦有几十个任务，如果不做截断，会话级上下文里会堆积几十份任务报告和代码片段，后续Agent每次调用都要带着这一大坨内容，响应变慢、费用飙升。

我的处置方式是对任务级数据做“摘要化储存”。例如编码Agent每完成一个任务，框架只把文件路径、生成文件数、冒烟测试结果这几项结构化字段存入任务记录，代码全文不留在上下文中。审查Agent需要看代码时，再按需从文件系统读取。

再一个有效技巧是“滑动窗口截断”。只保留最近N个任务的关键信息，更早的内容压缩成一行摘要。比如：

task 01: todo_cli.py 创建，包含增删改查，审查通过 task 02: model.py 创建，含Task类与存储接口，审查发现2个风险已修复

这种摘要本身可以由总结Agent生成。一次生成，后续反复复用，性价比极高。

5.3 并发冲突与调用配额管理

多Agent系统里各Agent的执行顺序虽然是事件驱动，但某些场景下（比如多个任务并行审查）会同时发起多个模型调用。Copilot和Claude的API都有并发限制，超出限制会报429限流错误。

我一开始没注意，结果跑大任务集时被连续限流，整个流水线原地打转。后来做了两件事：

第一，在Antigravity的Runner里设置并发数上限。最稳妥的是将Copilot侧与Claude侧分别设并发为1，虽然速度慢点，但稳定性极高，基本不会触达配额限制。

第二，增加退避重试策略。Antigravity自带指数退避选项，开启后遇到限流会自动等待2秒、4秒、8秒再重试，而不是直接失败。配置方式如下：

runner = Runner( agent=coder, retry_policy={ "max_retries": 5, "backoff_factor": 2.0, "retry_on_http_429": True, }, )

这套策略加上之后，流水线的成功率明显提升。实测下来，并发设成1、开启退避重试，一个包含20个任务的流程跑完大约需要15到25分钟，全程零人工干预。

说到并发，还有个小细节：框架的任务队列默认是串行处理的，只有在你显式开启并行执行时才并发。并行能提速但也容易把上下文搅乱、把配额打爆。我的建议是先串行跑通，再根据需求谨慎开启并行。

写在最后

这套系统上线后，我又迭代了几个版本，加入了一些小技巧。比如给编码Agent挂上“单元测试生成器”工具，让它在写完代码后顺手补测试；再把审查Agent的规则库从“泛泛而谈”改成了“只检查空指针、资源泄漏、异常吞噬、索引越界”等具体模式，审查质量肉眼可见地提升。

最有意思的是，后来我把规划Agent的输入方式改了一下，支持直接粘贴产品需求文档，甚至能解析飞书文档里的需求条目。这一改，整个团队的提需求方式都变了，产品经理写完文档直接扔给系统，剩下的由Agent们接力完成。

如果你也想搭一个类似的系统，我的建议是先别贪多。把Copilot和Claude两个Agent串成一个“规划—编码”的最小闭环，跑通后再加审查和总结。系统越小，问题越容易定位；等你吃透了Antigravity的事件流和上下文机制，再往上面加角色就顺水推舟了。

多智能体系统的搭建，真正的难点从来不是某个模型调用，而是如何让多个模型在同一套规则下有序协作。抓紧把框架跑起来，你会有完全不一样的感受。