Entenda o Antigravity Orchestrator do Zero: Arquitetura de 3 Camadas, 3 Modos de Orquestração e Mecanismo de Enxame Explicados em Detalhes

Entenda o Antigravity Orchestrator do Zero: Arquitetura de 3 Camadas, 3 Modos de Orquestração e Mecanismo de Enxame Explicados em Detalhes

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.

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


Table of Contents

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 /swarm por 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.

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


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:

  1. O usuário emite o comando /swarm, acompanhado da descrição da tarefa.
  2. O agente principal (Orchestrator Agent) analisa a tarefa e a decompõe automaticamente em várias subtarefas.
  3. Para cada subtarefa, são criados dinamicamente subagentes — os “subagentes dinâmicos autoclonados”.
  4. Os subagentes executam em paralelo, e os resultados convergem de volta para o agente principal.
  5. 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.

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

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:

  1. Conceitos: entender o que é o Antigravity e por que ele é necessário (seções 1 e 2 deste artigo).
  2. Instalação: escolher uma entre as três opções disponíveis — Web App, download do IDE ou instalação via linha de comando.
  3. Primeiro agente: escrever um agente Hello World usando o SDK.
  4. Entender o Orchestrator: compreender a relação entre o Workflow Runtime e a Task API.
  5. Primeiro Swarm: executar o /swarm na prática, no IDE ou na CLI.
  6. Aprofundar nos subagentes: comparar os resultados dos subagentes dinâmicos e dos subagentes estáticos.
  7. 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.

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


Referências

  1. 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
  2. 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
  3. 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
  4. 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

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

Artigos relacionados

Similar Posts