Nota do autor: neste artigo, explico de uma vez o que é o Antigravity Orchestrator, como despachar subagentes por meio do /swarm e em que ele se diferencia do LangGraph e do CrewAI em termos de posicionamento.
Resumo: O Antigravity Orchestrator é o motor de coordenação multiagente integrado à plataforma Google Antigravity — e não um framework leve que dá para instalar separadamente via pip. Neste artigo, vamos entender como ele funciona e onde ele faz sentido a partir de quatro aspectos: a matriz de produtos, as três camadas de abstração, os três modos de orquestração e o mecanismo de enxame do /swarm.
Conclusão primeiro: O Antigravity Orchestrator pode ser entendido como o “cérebro de agendamento de tarefas escondido dentro da plataforma Antigravity”. Quando você digita comandos de barra como /swarm ou /teamwork no IDE, no Web App ou no CLI, ele aciona em segundo plano a Task API e o Workflow Runtime do SDK, divide uma grande tarefa em várias subtarefas, entrega cada uma a subagentes que trabalham em paralelo e, no final, consolida tudo em entregáveis. Em novembro de 2026, o Orchestrator chegou oficialmente ao Antigravity junto com o Gemini 4 Neon. No dia 10 de novembro, quando o Gemini 4 Carbon foi aberto por completo, Sundar Pichai demonstrou ao vivo a capacidade do /swarm, e foi aí que essa funcionalidade entrou no radar do público.
Vale a pena investir tempo aprendendo isso? Depende de duas condições. Primeira: a sua tarefa consegue ser dividida em partes independentes entre si e que podem rodar em paralelo. Segunda: você aceita trabalhar com uma plataforma otimizada para o Gemini e cujo motor central é de código fechado. Quando as duas condições se sustentam, o Orchestrator reduz de forma significativa o custo de montar a colaboração multiagente. Se você precisa de uma solução independente de modelo e totalmente open source, bibliotecas Python como LangGraph e CrewAI continuam sendo escolhas mais adequadas.

Mapa de conhecimento e índice de leitura do Antigravity Orchestrator
A tabela abaixo apresenta a estrutura de conhecimento do artigo completo, as dependências entre as seções e o problema que cada uma delas resolve. A ordem geral vai de “a que ele pertence” para “como ele funciona” e, por fim, “devo usá-lo? como começar?”.
| Nº | Tema | Problema que resolve | Relação com as seções anterior e seguinte |
|---|---|---|---|
| 1 | Contexto da plataforma Antigravity | Em qual ecossistema de produtos o Orchestrator opera | Fornece o contexto da plataforma para a Seção 2 |
| 2 | As três camadas de abstração do Orchestrator | O que ele é, tecnicamente | Os mecanismos das Seções 3 e 4 são construídos sobre essas três camadas |
| 3 | Os três modos de orquestração | Quais as diferenças entre /swarm, /teamwork e /run-workflow | Entre os três modos, o /swarm é escolhido para aprofundamento na Seção 4 |
| 4 | O mecanismo de enxame do /swarm | Como o agente principal divide tarefas e despacha subagentes | Combina casos reais para embasar a comparação da Seção 5 |
| 5 | Comparação com frameworks como LangGraph | Em quais condições escolhê-lo, e em quais não | Apresenta os critérios de escolha e conecta com o caminho de início da Seção 6 |
| 6 | Caminho de início e código | Como começar do zero | Concretiza, em código, os conceitos apresentados até aqui |
| 7 | Melhores práticas e implicações | Como controlar a escolha de modelo, permissões e custos | Fecha o ciclo com recomendações acionáveis |
Se você só quer entender o que é, ler da Seção 1 até a 3 já basta. Se está preparando uma escolha técnica, recomendo focar nas Seções 4 e 5. Se quer colocar a mão na massa, pode pular direto para as Seções 6 e 7.
🎯 Dica técnica: a forma mais rápida de entender a orquestração multiagente é executar você mesmo o fluxo de “dividir — paralelizar — consolidar”. A Seção 6.3 traz uma implementação simulada baseada em uma interface compatível com OpenAI, na qual você pode usar a APIYI (apiyi.com) para invocar diferentes modelos com uma única chave API, atuando como agente principal e como subagentes.
To Know: termos essenciais para entender o Antigravity Orchestrator
| Termo | Explicação concisa |
|---|---|
| Agente (Agent) | Instância de modelo capaz de invocar ferramentas e concluir tarefas de múltiplas etapas de forma autônoma |
| Agente principal (Orchestrator Agent) | Coordenador geral responsável por analisar e decompor tarefas, despachar subagentes e consolidar resultados |
| Subagente (Subagent) | Agente que assume uma subtarefa específica; pode ser criado dinamicamente em tempo de execução ou predefinido |
| Fan-out / Fan-in | Fan-out significa distribuir uma tarefa para vários executores; fan-in significa consolidar de volta os vários resultados |
| Artifacts | Entregáveis finais produzidos pelo agente, como código, arquivos e aplicativos executáveis |
| Workflow Runtime | Motor de execução baseado em grafos do SDK da Antigravity, responsável pelo gerenciamento de estado e pelo agendamento dos nós |
1 A plataforma onde vive o Antigravity Orchestrator: o que é o Antigravity
1.1 De onde vem o nome Antigravity
“Antigravity” significa literalmente “antigravidade”, transmitindo a ideia de libertar o desenvolvimento das amarras da codificação tradicional individual, como se “voasse” em condições de imponderabilidade. Muitos desenvolvedores acreditam que o nome pode ter se inspirado no easter egg import antigravity do Python. Esse easter egg vem de uma tirinha do xkcd; executar essa linha de código abre a tirinha no navegador. A Google posiciona o Antigravity como uma plataforma de desenvolvedores para a “agent-first era” (a era dos agentes em primeiro lugar), ou seja, os agentes são os protagonistas do trabalho, enquanto as pessoas ficam responsáveis por descrever os objetivos e revisar os resultados.
1.2 Antigravity é uma matriz de produtos
Muita gente, ao ouvir falar do Antigravity pela primeira vez, acha que se trata de uma IDE. Na verdade, é um conjunto de produtos voltados para diferentes cenários, e as capacidades do Orchestrator estão distribuídas entre essas formas de produto:
| Produto | Formato | Uso principal |
|---|---|---|
| Antigravity App | Aplicação web | Programação de agentes com recursos completos direto no navegador |
| Antigravity IDE | Aplicativo desktop | Baseado em um fork do VS Code, com integração profunda de capacidades de agente |
| Antigravity CLI | Ferramenta de linha de comando | Agente de terminal escrito em Go |
| Antigravity SDK | Biblioteca Python | Desenvolvimento de agentes personalizados |
| Antigravity Extensions | Plugin de IDE | Embutir capacidades de agente em editores existentes |
Essa tabela revela um fato importante: os comandos de barra aparecem em interfaces interativas como o App, a IDE e o CLI, enquanto o SDK carrega a interface programável. Quando a Seção 2 abordar as três camadas de abstração, você verá como esses dois lados se encaixam.
1.3 Linha do tempo de lançamento do Antigravity Orchestrator
O Orchestrator não surgiu do nada; é resultado da evolução gradual da plataforma Antigravity ao longo de um ano. Em ordem cronológica, os principais marcos são:
- 18 de novembro de 2025: lançamento do Antigravity IDE no mesmo dia do Gemini 3 Pro.
- Maio de 2026 (Google I/O): lançamento do Gemini 3.5 Flash, além do Gemini Spark baseado no runtime da Antigravity.
- 18 de junho de 2026: o Gemini CLI de código aberto foi descontinuado, com migração completa para o Antigravity CLI proprietário.
- Novembro de 2026: o Gemini 4 Neon e o Orchestrator entraram oficialmente na Antigravity.
- 10 de novembro de 2026: abertura completa do Gemini 4 Carbon, com demonstração do
/swarmpor Sundar Pichai.
Essa linha do tempo revela uma tendência clara: a Google está unificando as capacidades de agente do terminal, da IDE e do navegador sob o runtime da Antigravity, e o Orchestrator é a camada de coordenação sobre esse runtime.
2 O que é o Antigravity Orchestrator: decompondo as três camadas de abstração
2.1 O que o Antigravity Orchestrator realmente é
Alguns artigos chamam o Antigravity Orchestrator de “framework de enxame leve”, o que pode fazer parecer que se trata de uma biblioteca independente. Uma descrição mais precisa seria: ele é o motor de coordenação multiagente embutido na plataforma Antigravity. Na base, corresponde ao Workflow Runtime e à Task API do SDK; no topo, é acionado por meio de comandos de barra ou da API do SDK. O “leve” fica por conta da experiência de uso: o usuário precisa de um único comando e não precisa escrever à mão a estrutura do grafo nem a máquina de estados.
2.2 A estrutura de três camadas do Antigravity Orchestrator
As capacidades do Orchestrator se dividem em três camadas, de cima para baixo. Cada camada superior invoca a inferior, e quanto mais fundo, mais perto dos detalhes da execução:
Layer 1: Comandos de barra /swarm, /teamwork, /plan
↓ Voltado ao usuário: um único comando dispara a orquestração
Layer 2: SDK API Agent, Subagent, Task API
↓ Voltado ao desenvolvedor: define agentes e tarefas em código
Layer 3: Workflow Runtime Motor de execução de grafos, Fan-out/Fan-in, gerenciamento de estado
Voltado ao runtime: cuida do escalonamento, do paralelismo e do estado
O benefício direto dessa divisão em camadas é “um mesmo motor, várias portas de entrada”. Um gerente de produto pode digitar /swarm direto no IDE, enquanto um engenheiro de backend pode escrever a mesma lógica de orquestração usando o SDK — no fim, ambos são executados pelo Workflow Runtime. Com isso em mente, as diferenças entre os três modos apresentados adiante ficam fáceis de entender: eles aparecem apenas como entradas diferentes na Layer 1 e correspondem a formatos de grafo diferentes na Layer 3.

3 Os três modos de orquestração do Antigravity Orchestrator
O Orchestrator oferece três modos de orquestração, que se diferenciam por dois pontos: se os subagentes precisam interagir continuamente entre si e se o fluxo é definido antecipadamente. Escolher o modo errado é o problema mais comum entre quem está começando, então veja primeiro a comparação:
| Modo | Como acionar | Formato de colaboração | Tarefas adequadas |
|---|---|---|---|
| Swarm (modo enxame) | /swarm |
Despacha vários subagentes de uma só vez para trabalhar em paralelo, com consolidação no final | Tarefas grandes que podem ser divididas em partes independentes |
| Teamwork (modo equipe) | /teamwork |
Uma equipe de agentes colabora continuamente, com múltiplas rodadas de interação | Projetos complexos que exigem discussões repetidas e dependências mútuas |
| Workflow (modo fluxo de trabalho) | /run-workflow |
Grafo direcionado predefinido, com suporte a ramificações, loops e roteamento condicional | Tarefas com fluxo fixo que precisam ser reproduzidas de forma estável |
Na hora de decidir, faça as perguntas na ordem abaixo. Se o fluxo é sempre igual, escolha Workflow. Se o fluxo não é fixo, mas as subtarefas quase não precisam se comunicar entre si, escolha Swarm. Se as subtarefas precisam se alinhar constantemente — por exemplo, quando o frontend muda uma interface e o backend precisa se ajustar em seguida — então escolha Teamwork. O Swarm tem o maior paralelismo e o menor tempo de espera, mas também é o que mais exige da capacidade de dividir a tarefa de forma independente.
4 O mecanismo de enxame /swarm do Antigravity Orchestrator
4.1 O fluxo de trabalho em cinco etapas do /swarm
O /swarm é a capacidade mais representativa do Orchestrator, e o fluxo completo se divide em cinco etapas:
- O usuário emite o comando
/swarm, acompanhado da descrição da tarefa. - O agente principal (Orchestrator Agent) analisa a tarefa e a decompõe automaticamente em várias subtarefas.
- Para cada subtarefa, são criados dinamicamente subagentes — os “subagentes dinâmicos autoclonados”.
- Os subagentes executam em paralelo, e os resultados convergem de volta para o agente principal.
- O agente principal integra as saídas e gera os Artifacts finais.
As etapas 2 e 5 são as que determinam a qualidade final. Se a decomposição não for bem feita, os subagentes acabam repetindo trabalho entre si ou deixando lacunas; se a capacidade de integração for insuficiente, as partes não se encaixam em um todo utilizável. Por isso, o agente principal geralmente precisa rodar em um modelo com raciocínio mais poderoso.
4.2 Subagentes dinâmicos e subagentes estáticos
O Antigravity Orchestrator suporta dois tipos de subagentes, que podem ser combinados na mesma tarefa:
- Subagente dinâmico autoclonado: criado sob demanda em tempo de execução, herda parte do contexto do agente principal e serve bem para aquelas subtarefas desmembradas na hora.
- Subagente estático personalizado: agente especializado definido previamente, com instruções de sistema e um conjunto fixo de ferramentas, ideal para etapas especializadas que se repetem com frequência, como revisão de código e geração de testes.
Outro aspecto do design que merece atenção: cada subagente pode usar um modelo diferente. Por exemplo, usar o Carbon nas partes que exigem raciocínio profundo e o Hydrogen nas partes rápidas e simples. Essa prática de “atribuir modelos conforme a dificuldade da tarefa” é a estratégia central para controlar custos em sistemas multiagentes — a seção 7 detalha isso.
4.3 Estudo de caso: como o Pelican Campus Quest foi decomposto
O caso /swarm demonstrado por Sundar Pichai é um excelente exemplo didático. A tarefa recebida pelo agente principal era: “construir um jogo 3D de mundo aberto para explorar o campus do Google em Mountain View pedalando um GBike”. Ele dividiu a tarefa em três frentes paralelas:
- Modelagem de assets 3D: o subagente usa o Blender, tomando como referência materiais gerados pelo Omni / Nano Banana.
- Construção da engine do jogo: o subagente usa Three.js com shaders WebGL.
- Sistema de áudio: o subagente usa a Web Audio API em conjunto com a música do Lyria.
No final, as três partes foram integradas automaticamente em um jogo jogável direto no navegador. Esse caso se encaixa bem no Swarm porque os três blocos — modelo, engine e áudio — precisam apenas combinar os formatos no nível das interfaces e, durante o desenvolvimento, praticamente não ficam esperando uns pelos outros. É exatamente o que a seção 3 chama de “decomponibilidade”.
5 Antigravity Orchestrator vs. LangGraph, CrewAI e AutoGen
5.1 Critérios da comparação
A comparação a seguir olha apenas para as diferenças de posicionamento, sem entrar em desempenho, já que as formas de cada um são completamente distintas: um é uma plataforma completa, os demais são bibliotecas Python. As dimensões comparadas incluem posicionamento do produto, abstração de agentes, integração com navegador, vinculação a modelos, forma de implantação e nível de código aberto.

| Dimensão | Antigravity | LangGraph | CrewAI | AutoGen |
|---|---|---|---|---|
| Posicionamento | IDE + plataforma completa | Biblioteca Python | Biblioteca Python | Biblioteca Python |
| Modelo de agente | Auto-clonagem dinâmica + estático | Nós de grafo | Definição de papéis | Agentes de conversação |
| Integração com navegador | Extensão nativa do Chrome | Não tem | Não tem | Não tem |
| Vinculação a modelos | Otimizado para Gemini | Independente de modelo | Independente de modelo | Independente de modelo |
| Implantação | Cloud Run / Docker | Por conta própria | Por conta própria | Por conta própria |
| Código aberto | SDK aberto, núcleo fechado | Totalmente aberto | Aberto | Aberto |
| Recomendação de acesso a múltiplos modelos | Dentro do ecossistema Gemini | Acesso unificado via APIYI apiyi.com | Idem | Idem |
5.2 Como escolher
O LangGraph segue na frente quando o assunto é controle sobre a estrutura de grafo e código totalmente aberto, mas exige montar por conta própria a integração com a IDE, a operação do navegador e o pipeline de implantação. O Antigravity Orchestrator leva vantagem no quesito “pronto para uso”: um único comando /swarm cuida da divisão, da execução paralela e da consolidação, além de operar o navegador nativamente. A definição de papéis do CrewAI é intuitiva, e o AutoGen se destaca em conduzir a colaboração por meio de diálogos — ambos também exigem que você resolva implantação e toolchain por conta própria.
Disso decorre uma regra simples: se o time já usa Gemini a fundo e quer capacidades multiagente direto na IDE, escolha o Antigravity; se precisa alternar entre vários modelos ou exige auditabilidade do motor central, fique com as bibliotecas de código aberto.
💡 Dica de escolha: se optar pelo caminho das bibliotecas de código aberto, vale padronizar a camada de acesso a modelos em uma interface compatível com OpenAI. Pela APIYI (apiyi.com), uma única chave API permite alternar entre GPT, Claude, Gemini e outros modelos dentro do LangGraph ou do CrewAI, facilitando atribuir modelos diferentes a nós diferentes no mesmo grafo de orquestração.
6 Caminho para começar do zero com o Antigravity Orchestrator
6.1 Ordem de aprendizado recomendada
Seguindo a lógica de “primeiro aprender a usar, depois aprender a escrever e, por fim, aprender a ajustar”, o caminho de introdução pode ser dividido em sete etapas:
- Conceitos: entender o que é o Antigravity e por que ele é necessário (seções 1 e 2 deste artigo).
- Instalação: escolher uma entre as três opções disponíveis — Web App, download do IDE ou instalação via linha de comando.
- Primeiro agente: escrever um agente Hello World usando o SDK.
- Entender o Orchestrator: compreender a relação entre o Workflow Runtime e a Task API.
- Primeiro Swarm: executar o
/swarmna prática, no IDE ou na CLI. - Aprofundar nos subagentes: comparar os resultados dos subagentes dinâmicos e dos subagentes estáticos.
- Melhores práticas: seleção de modelos, gerenciamento de permissões e controle de custos.
6.2 Escrevendo o primeiro agente com o SDK do Antigravity
O agente mínimo do SDK precisa apenas de um objeto de configuração e de uma chamada de conversa:
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())
Se você precisar de saída em streaming, basta iterar diretamente sobre o response. Adicionar ferramentas ao agente também é simples — é só passar funções Python comuns para o parâmetro tools:
import sys
# Resposta em streaming
async for token in response:
sys.stdout.write(token)
sys.stdout.flush()
# Ferramenta personalizada
def get_weather(city: str) -> str:
return f"It's sunny in {city}."
config = LocalAgentConfig(tools=[get_weather])
As anotações de tipo na assinatura da função ajudam o agente a entender o significado de cada parâmetro. Em projetos reais, vale a pena escrever docstrings bem claras para as funções de ferramenta: assim, o agente principal consegue decidir com mais facilidade qual ferramenta entregar a qual subagente na hora de decompor as tarefas.
6.3 Simulando o fan-out e o fan-in do enxame com uma interface compatível com OpenAI
O motor central do Orchestrator é de código fechado, mas a ideia de “dividir — paralelizar — consolidar” pode ser reproduzida com qualquer modelo. O código abaixo simula uma versão mínima do /swarm: o agente principal fica responsável por decompor e consolidar, enquanto os subagentes executam em paralelo. Não se trata de uma implementação do Antigravity, e sim de um exemplo didático para ajudar a entender o processo de cinco etapas da seção 4.1.
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # interface da APIYI compatível com OpenAI
)
PLANNER_MODEL = "your-reasoning-model" # Agente principal: um modelo com forte raciocínio; confira a lista de modelos da plataforma
WORKER_MODEL = "your-fast-model" # Subagente: um modelo rápido e de baixo custo
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
Ver o código completo da simulação do enxame
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # uma única chave para invocar modelos de vários provedores
)
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:
# Etapa 2: o agente principal decompõe a tarefa (antes do fan-out)
plan = await ask(
PLANNER_MODEL,
"你是主代理。把任务拆成互相独立、可并行的子任务,每行一个,不要编号。",
task,
)
subtasks = [s.strip("- ").strip() for s in plan.splitlines() if s.strip()]
subtasks = subtasks[:max_workers]
# Etapas 3-4: cria um subagente para cada subtarefa e executa em paralelo (fan-out)
results = await asyncio.gather(*[
ask(WORKER_MODEL, "你是只负责单一子任务的子代理,输出简洁可交付的结果。", s)
for s in subtasks
])
# Etapa 5: o agente principal consolida os resultados (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("为一个浏览器小游戏设计美术、玩法和音效三部分方案")))
Este código demonstra dois pontos-chave: o agente principal e os subagentes usam modelos diferentes, e as subtarefas são executadas em paralelo por meio de asyncio.gather. Se você compará-lo com a seção 4, vai entender quais tarefas o Orchestrator automatiza para você na Layer 3, incluindo o gerenciamento de estado, as retentativas em caso de falha e a consolidação dos artefatos.
🚀 Início rápido: o exemplo acima pode ser executado diretamente — basta obter uma chave na APIYI (apiyi.com) e substituir os dois nomes de modelo por outros disponíveis na plataforma. Novos usuários recebem créditos de teste gratuitos, suficientes para algumas rodadas de experimentos de decomposição e consolidação.
7 Melhores práticas e impacto do Antigravity Orchestrator
7.1 Seleção de modelos: estratificação por dificuldade da tarefa
O custo de um sistema multiagente cresce exponencialmente com o número de subagentes, por isso a estratificação de modelos é o princípio fundamental. As etapas de decomposição e integração, que determinam a qualidade global, devem ficar a cargo de modelos com forte capacidade de raciocínio, como o Carbon no Antigravity; já a conversão de formatos, o código boilerplate e as consultas simples podem ir para modelos rápidos, como o Hydrogen. Ao reproduzir uma arquitetura semelhante fora do Antigravity, você pode adotar essa mesma ideia de estratificação: via APIYI apiyi.com, especifique modelos diferentes para cada papel dentro do mesmo conjunto de código, compare qualidade e custo e só então fixe a configuração.
7.2 Gerenciamento de permissões: limite o escopo de ferramentas dos subagentes
Os subagentes dinâmicos herdam parte do contexto do agente principal; se as permissões de ferramentas não forem restringidas, um subagente pode executar operações que vão além de sua responsabilidade. A abordagem mais segura é: colocar as capacidades de escrever arquivos, executar comandos e controlar o navegador em subagentes estáticos personalizados, definindo claramente suas instruções de sistema e conjunto de ferramentas; os subagentes dinâmicos ficam apenas com tarefas de leitura ou de geração. Operações que envolvem o ambiente de produção devem manter sempre uma etapa de confirmação humana.
7.3 Controle de custos: estime antes de aumentar o paralelismo
Quanto maior o paralelismo do /swarm, menor o tempo de espera, mas maior também o consumo de tokens. A recomendação é começar com tarefas pequenas para observar quantas subtarefas o agente principal costuma gerar e quanto cada uma consome, antes de decidir liberar para tarefas maiores. Para equipes sensíveis a orçamento, vale validar primeiro a estratégia de decomposição em bibliotecas de orquestração open source com modelos de baixo custo; o APIYI apiyi.com, com cobrança por uso, facilita o controle dos custos de experimentação — depois de confirmar que o fluxo funciona, migre para o Antigravity para obter todos os recursos da plataforma.
7.4 Impacto do Antigravity Orchestrator para os desenvolvedores
O surgimento do Orchestrator significa que a orquestração multiagente está migrando de “grafos escritos à mão por engenheiros” para “disparados por um único comando do usuário”. Isso reduz a barreira de entrada, mas também traz aprisionamento à plataforma: o Gemini CLI open source já foi descontinuado, o motor central é fechado e otimizado principalmente para o Gemini. Para desenvolvedores individuais e equipes centradas no Gemini, é um ganho claro de eficiência; para equipes que precisam de múltiplos modelos, auditoria e implantação privada, frameworks open source combinados com uma camada unificada de acesso a modelos continuam sendo a opção mais flexível.
O método de decisão final é simples: pegue uma tarefa real que você tem em mãos e tente dividi-la em três subtarefas independentes entre si. Se for possível, o /swarm provavelmente vai economizar muito do seu tempo; se não for, o modo Teamwork ou Workflow, ou até mesmo um agente único, é o ponto de partida mais adequado.

Referências
-
xkcd 353 – Python: a origem do easter egg
import antigravity- Link:
xkcd.com/353 - Descrição: ajuda a entender a origem cultural do nome Antigravity
- Link:
-
Vídeo de introdução do Google Antigravity: demonstração oficial para iniciantes
- Link:
youtube.com/watch?v=nTOVIGsqCuY - Descrição: ideal para desenvolvedores que estão conhecendo o Antigravity pela primeira vez
- Link:
-
Tweet de Sundar Pichai: demonstração da capacidade /swarm
- Link:
twitter.com/sundarpichai/status/2120198811297694192 - Descrição: demonstração oficial no lançamento do Gemini 4 Carbon
- Link:
-
Versão jogável do Pelican Campus Quest: jogo de navegador gerado pelo /swarm
- Link:
aistudio.google.com/apps/bundled/pelican-campus-quest - Descrição: experimente na prática o resultado final do modo swarm
- Link:
Autor: Equipe Técnica APIYI
Intercâmbio técnico: sinta-se à vontade para entrar em contato conosco pela página inicial da APIYI em apiyi.com; para mais materiais, acesse o centro de documentação em docs.apiyi.com
