O Google Antigravity lança o /swarm: uma leitura dos 4 tipos de papéis na transição da programação por IA da execução com um único agente para a colaboração em equipe com múltiplos agentes

Nota do autor: este artigo reúne o blog oficial e a documentação de uso do Google Antigravity para explicar como o /swarm divide o trabalho entre vários agentes, como eles colaboram, como funciona a gestão visual e quais são os limites de uso.

Em 10 de novembro de 2026, o Gemini 4 Carbon foi liberado oficialmente. No mesmo dia, a equipe do Google Antigravity lançou o recurso de colaboração multiagente /swarm (Preview). Com esse comando, uma única conversa vira uma pequena equipe de engenharia de IA: um agente divide as tarefas, outro escreve o código, outro faz as verificações e outro ainda fica de olho para perceber quando o progresso trava.

O recurso tem respaldo público. O blog oficial do Antigravity e a documentação de uso do Swarm já estão no ar, e o Google afirma que seus engenheiros já usam o recurso internamente há cerca de 5 semanas. O ponto central do /swarm não é abrir várias janelas de chat ao mesmo tempo: a ideia é montar um sistema de colaboração capaz de decompor tarefas por conta própria, executar em paralelo, compartilhar o progresso, verificar o trabalho um do outro e continuar corrigindo o que for preciso.

Valor principal: ao terminar a leitura, você vai entender como o /swarm executa as tarefas na prática, como cada papel se encaixa, como observar e intervir no processo e quais são os limites reais de cota e permissões.

Termos-chave do /swarm no Google Antigravity

O /swarm introduz vários nomes de papéis. Vale alinhar esses conceitos primeiro — assim fica bem mais fácil entender os mecanismos que vêm depois.

O que é o Google Antigravity /swarm: visão geral das informações principais

O /swarm foi anunciado junto com a abertura oficial do Gemini 4 Carbon, mas são coisas diferentes. O primeiro é um recurso de orquestração multiagente dentro do Antigravity; o segundo é um modelo. A tabela abaixo reúne o que a documentação oficial já tornou público.

Por que um único agente tem dificuldade com tarefas de engenharia de grande porte

Um único agente se sai muito bem quando lida com uma função ou um bug. Mas quando a tarefa cresce para dezenas de arquivos, dependências entre vários módulos ou execuções repetidas de testes, esse agente precisa guardar todos os detalhes no mesmo contexto. Quanto mais o contexto se estende, mais fácil é as restrições iniciais serem empurradas para fora pelos detalhes de execução que vêm depois.

A distribuição de tarefas é outro ponto delicado. Um único agente só executa em sequência: se a alteração no módulo A não terminou, a investigação no módulo B tem que esperar. Muitas tarefas de engenharia podem, por natureza, ser divididas e rodar em paralelo — corrigir os testes que falham em pacotes diferentes, por exemplo — e fazer isso em série é perda de tempo.

O ponto mais fácil de esquecer é a verificação. Quando o agente que escreveu o código é quem revisa o próprio código, ele tende a repetir as mesmas premissas e não percebe desvios de raciocínio. A prática em times humanos é pedir que outra pessoa faça o code review; o /swarm traz essa divisão de trabalho para o fluxo de programação com IA.

Como o /swarm do Google Antigravity inicia um time de Agents

De acordo com a documentação oficial, depois que você roda /swarm <task>, o processo avança nesta ordem:

1. A conversa atual vira o Coordinator: o Agent com quem você está conversando passa a ser o coordenador, responsável por entender a tarefa como um todo.
2. Divisão do trabalho: o Coordinator analisa a estrutura da tarefa e a quebra em várias subtarefas.
3. Criação de Workers independentes: cada trabalho ganha um Worker, e cada Worker recebe um contexto próprio e uma descrição pública da tarefa.
4. Execução e verificação: os Workers modificam código ou fazem investigações; o Verifier confere as alterações no código, roda os testes e devolve os problemas ao Worker correspondente.
5. Ciclo de correção: o Worker ajusta o que foi apontado e, depois da alteração, passa por nova verificação.
6. Relatório final: o Coordinator junta os resultados de cada membro e apresenta o relatório ao usuário.

O contexto de cada Worker é isolado e contém apenas as informações da sua parte da tarefa, o que reduz o problema de contaminação mútua em contextos longos. A descrição da tarefa é pública, então os outros membros sabem quem está fazendo o quê, e a divisão de responsabilidades fica com limites bem claros.

/swarm divisão de papéis na equipe: Coordinator, Worker, Verifier e Monitor

Na documentação oficial, uma equipe do Swarm costuma reunir quatro tipos de papéis. Vale deixar claro desde já: essa é a organização típica descrita oficialmente, não uma arquitetura fixa que se aplica a toda tarefa. Quantos Workers criar e se membros extras são necessários é o Coordinator quem decide, de acordo com a tarefa.

Os mecanismos de Verifier e Monitor no /swarm

O blog oficial chama o Verifier de “agente de verificação adversarial”. A função dele é achar problemas: revisar as alterações dos outros agentes, rodar testes e questionar mudanças que não fazem sentido. O Worker recebe o feedback, corrige e submete de novo à checagem — execução e verificação formam um ciclo fechado.

O Monitor cuida de outro tipo de risco. Quando vários agentes colaboram, pode aparecer a situação em que todo mundo está esperando e ninguém empurra o trabalho adiante. O Monitor fica dormindo por padrão e, ao detectar que a equipe inteira parou de agir com a tarefa ainda pendente, acorda os membros envolvidos. Com ele, a equipe não precisa depender inteiramente da intervenção manual do usuário quando trava.

No /swarm, papéis diferentes podem usar modelos diferentes

O Google recomenda no blog oficial distribuir os modelos conforme as características de cada papel, em vez de colocar todos os agentes no modelo mais caro:

• Usar Gemini 4 Carbon: desenho da arquitetura geral, coordenação de tarefas, revisão de segurança, auditoria de código complexo
• Usar modelos mais rápidos e leves: implementação de código rotineira, alterações paralelas em arquivos
• Usar um agente de verificação dedicado: testes e validação automatizados

Nos exemplos da documentação oficial também há usos em que modelos distintos ficam responsáveis, respectivamente, pela implementação do código e pela verificação independente. É uma lógica de equilíbrio entre custo e capacidade: as decisões complexas vão para o modelo forte, e o volume grande de execução fica com o modelo rápido.

💡 Sugestão de escolha: se você também quer combinar modelos por papel no seu próprio pipeline multiagente, comece testando pelo APIYI apiyi.com, com a mesma chave API, como cada modelo se sai nas etapas de planejamento, implementação e revisão. Depois de definir quem é o candidato certo para cada papel, consolide a configuração — na hora de trocar, basta alterar o parâmetro model.

/swarm Como vários agentes colaboram sem atrapalhar uns aos outros

Quadro de mensagens compartilhado: a conversa aberta entre os agentes

Todos os agentes usam um mesmo quadro de mensagens compartilhado (Shared Message Board), que só cresce: o processo de colaboração e o andamento das tarefas ficam registrados ali. As mensagens apenas são acrescentadas, nunca sobrescritas, então o histórico de comunicação da equipe permanece inteiramente rastreável. Um agente pode hibernar enquanto espera pelos colegas e é acordado quando precisa de alguma entrada — segundo o Google, ficar parado esperando não consome tokens.

Essa abordagem é bem mais transparente do que deixar os agentes se chamarem nos bastidores. O feedback que o Verifier passa ao Worker e as decisões de coordenação do Coordinator ficam todos à vista, de modo que, ao revisar o que aconteceu, o usuário consegue enxergar exatamente em qual etapa o problema apareceu.

Espaço de trabalho compartilhado x cópia de trabalho independente

É aqui que o blog oficial e a documentação de uso dizem coisas diferentes — um ponto fácil de errar. O blog destaca que Workers em paralelo podem atuar em Git Worktrees isolados, para não mexerem no mesmo diretório ao mesmo tempo. Já a documentação traz regras mais detalhadas:

• Por padrão: os Workers compartilham o espaço de trabalho atual.
• Isolamento sob demanda: quando vários Workers precisam alterar ou compilar o projeto simultaneamente, o Coordinator pode atribuir a eles cópias de trabalho de código separadas.
• Remover significa apagar: ao remover um Worker, a cópia de trabalho dele é excluída, então é preciso primeiro mesclar (merge) ou commitar os resultados.

Ou seja, a descrição correta é esta: o sistema organiza cópias de trabalho isoladas conforme a necessidade das tarefas paralelas, e não que todo agente já tenha, por natureza, seu próprio Git Worktree totalmente independente. Para tarefas que só investigam e não mexem em arquivos, o espaço compartilhado resolve; quando vários Workers editam código e rodam builds ao mesmo tempo, as cópias independentes ajudam a reduzir conflitos de arquivo.

Como observar e controlar o time do /swarm no Antigravity

Quando vários agentes trabalham em paralelo, o maior medo do usuário é não saber o que está acontecendo lá dentro. Por isso, o Antigravity oferece três visões principais, e o CLI tem atalhos correspondentes.

O seu controle não se resume a olhar o resultado final. Por esses pontos de acesso, você pode conferir o histórico de trabalho de cada agente, entrar direto em um Worker para intervir e até ajustar o que foi pedido ao Coordinator. O Alt + J e o Ctrl + K mostram que a aprovação de chamadas de ferramentas continua nas mãos de quem usa: quando um agente precisa executar uma operação sensível, ele para e espera a sua confirmação.

/swarm consegue resolver quais tarefas complexas de engenharia

O Google divulgou três tipos principais de uso interno: migração de vários pacotes, investigação de causa raiz entre subsistemas e redesenho de arquiteturas de software complexas. O que elas têm em comum: muito trabalho, possibilidade de dividir em partes e necessidade de verificação.

Os exemplos da documentação oficial de uso estão mais próximos do dia a dia de desenvolvimento:

• Alterar vários API Handlers separadamente, configurando testes para cada um;
• Investigar em paralelo a causa raiz da lentidão na inicialização de uma CLI;
• Agrupar por pacote os testes que falham em um projeto grande e distribuir para Agents diferentes corrigirem;
• Deixar que modelos diferentes cuidem da implementação do código e da verificação independente.

O Google também mostrou uma demonstração oficial: com a colaboração multi-Agent do Antigravity, o Carbon processou 7 PDFs públicos de planejamento urbano, extraiu 206 vistas de desenhos de engenharia e gerou um modelo arquitetônico interativo em Three.js com cerca de 906.000 faces triangulares, tudo ao longo de 10 rodadas de iteração noturna. É um caso oficial do Google, sem validação independente de terceiros, mas mostra como os multi-Agents dividem o trabalho em tarefas de longa duração.

Custo, permissões e limitações do Preview do /swarm

Consumo de cota com multi-Agents

Agents ociosos, só esperando, não consomem Tokens, mas isso não quer dizer que o /swarm economize dinheiro. Cada Worker é um Agent independente, e quando vários trabalham ao mesmo tempo, a cota é consumida bem mais rápido do que em uma conversa única. O próprio Google faz esse alerta.

Tem também uma armadilha comum: quando um Worker esgota a cota, ele pausa, e mesmo que a cota seja restabelecida depois, ele não retoma a execução automaticamente. É preciso intervir manualmente. Antes de começar uma tarefa grande e demorada, vale estimar se a cota vai ser suficiente.

Permissão da função Swarm ≠ permissão do modelo Carbon

Esse é o ponto que mais confunde. Poder usar o /swarm não significa poder usar o Carbon dentro do Swarm.

Em outras palavras, usuários do Pro conseguem experimentar o mecanismo de colaboração do Swarm, mas os modelos que os Agents podem usar continuam limitados pelas permissões de modelo de cada assinatura.

Análise de impacto: o /swarm leva a programação com IA de assistente para time

Impacto para os desenvolvedores

• Mudança de papel: o desenvolvedor deixa de ser “quem faz perguntas ao modelo” e passa a ser “quem organiza um time de IA”. A qualidade da divisão das tarefas e os critérios de aceitação influenciam diretamente o resultado.
• Verificação no começo do processo: com o mecanismo Verifier, testes e revisões viram etapas padrão do fluxo, e não um remendo feito depois da geração.
• Gestão de custos ganha importância: com vários Workers em paralelo, você precisa prestar atenção na cota, na combinação de modelos e no tamanho das tarefas, e não só na experiência de uma conversa isolada.

Impacto para o setor

• Colaboração entre vários modelos como direção de implantação: um modelo mais forte cuida do planejamento e da revisão, enquanto modelos mais rápidos executam o trabalho em lote. Essa divisão de papéis deve ser adotada por cada vez mais frameworks de Agent.
• O foco da competição passa para a entrega de tarefas: a disputa entre modelos está saindo da pontuação em perguntas e respostas de uma única rodada e indo para a capacidade de planejar, executar, verificar e entregar tarefas de longa duração.

Reproduzindo a ideia do /swarm multiagente com a API: um exemplo mínimo

Se você quer testar no seu próprio projeto a ideia de “coordenador que divide + trabalhadores que executam”, dá para montar um protótipo mínimo usando uma interface compatível com a OpenAI. O código abaixo só demonstra a estrutura de colaboração e não é a implementação do /swarm do Antigravity. Troque os nomes dos modelos por modelos disponíveis na sua conta.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

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

plan = ask("STRONG_MODEL", "把“修复 3 个 API Handler 的失败测试”拆成独立子任务，每行一个")
for task in [t for t in plan.splitlines() if t.strip()]:
    print(ask("FAST_MODEL", f"完成这个子任务并给出补丁：{task}"))

import concurrent.futures as cf
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface compatível com OpenAI da APIYI
)

COORDINATOR_MODEL = "STRONG_MODEL"   # Planejamento e consolidação; use um modelo com forte capacidade de raciocínio
WORKER_MODEL = "FAST_MODEL"          # Execução em lote; use um modelo rápido e leve
VERIFIER_MODEL = "REVIEW_MODEL"      # Revisão independente; o ideal é que seja diferente do Worker
board = []                           # Quadro de mensagens compartilhado, somente com acréscimo

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

def worker(task, max_rounds=3):
    patch = ask(WORKER_MODEL, "你是 Worker，只负责分配给你的子任务。", task)
    for i in range(max_rounds):
        review = ask(VERIFIER_MODEL,
                     "你是 Verifier，检查补丁问题。没有问题只回复 PASS。",
                     f"任务：{task}\n补丁：\n{patch}")
        board.append(f"[Verifier] {task[:20]}... 第{i+1}轮：{review[:60]}")
        if review.strip().startswith("PASS"):
            return patch
        patch = ask(WORKER_MODEL, "根据审查意见修复补丁。",
                    f"任务：{task}\n原补丁：{patch}\n意见：{review}")
    return patch + "\n# 未通过验证，需人工检查"

goal = "为 users、orders、payments 三个 API Handler 补充输入校验并修复失败测试"
plan = ask(COORDINATOR_MODEL, "你是 Coordinator，把目标拆成互不重叠的子任务，每行一个。", goal)
tasks = [t.strip() for t in plan.splitlines() if t.strip()]
board.append(f"[Coordinator] 拆分为 {len(tasks)} 个子任务")

with cf.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(worker, tasks))

summary = ask(COORDINATOR_MODEL, "汇总各 Worker 结果，列出完成情况与风险。",
              "\n\n".join(results))
print("\n".join(board))
print(summary)

🚀 Comece rápido: para montar protótipos com vários papéis como esse, recomendamos pegar sua chave API e o crédito gratuito de teste para novos usuários no APIYI (apiyi.com). A plataforma oferece uma interface compatível com a OpenAI, então você chama modelos da OpenAI, Claude, Gemini e outros com o mesmo código. Assim fica fácil validar se a combinação “modelo forte planeja, modelo rápido executa, modelo de outra família revisa” funciona bem no seu projeto.

Perguntas frequentes (FAQ)

Google Antigravity /swarm: principais pontos (Key Takeaways)

• Mecanismo de execução: /swarm <task> transforma a conversa atual em um Coordinator, que divide a tarefa e cria Workers independentes
• Divisão típica de papéis: Coordinator, Worker, Verifier e Monitor; em geral, cada 2 a 4 Workers ganham um Verifier
• Forma de colaboração: comunicação aberta por um quadro de mensagens compartilhado em modo append-only (só acrescenta); Agents ociosos, em espera, não consomem Tokens
• Regras do espaço de trabalho: por padrão, o workspace é compartilhado; quando há modificações em paralelo, cópias de trabalho independentes são alocadas conforme a necessidade
• Controle visual: três visões (Board, Members e Graph), além de operações de CLI como /swarm board e /agents
• Limites da realidade: ainda em Preview, com consumo rápido de cota quando há vários Workers; a permissão do Swarm não equivale à permissão do Carbon
• Prática por conta própria: com a APIYI (apiyi.com), dá para combinar vários modelos por uma interface unificada e montar o seu próprio protótipo com múltiplos papéis

Resumo

Os pontos centrais do /swarm do Google Antigravity:

1. Do paralelo à colaboração: o valor do /swarm está no ciclo completo formado por divisão de tarefas, contextos independentes, verificação adversarial e acompanhamento do progresso. A execução em paralelo é só uma parte disso.
2. Isolamento sob demanda: o workspace compartilhado e as cópias de trabalho independentes se alternam conforme a necessidade da tarefa, e o usuário precisa ficar de olho no momento certo de fazer o merge.
3. Capacidade e custo andam juntos: vários Agents aumentam a capacidade de lidar com tarefas de engenharia complexas, mas também trazem maior consumo de cota e uma gestão de recursos mais complicada. Por enquanto, ainda é Preview.

Para quem desenvolve, o /swarm indica uma mudança na forma de trabalhar: em vez de só fazer perguntas ao modelo, você passa a organizar uma equipe de IA capaz de dividir o trabalho, executar, verificar e entregar. Mesmo que você não vá usar o Antigravity agora, a ideia de “atribuir modelos por papel e manter a verificação independente da execução” também vale para os seus próprios sistemas de Agents. Recomendamos validar rapidamente o efeito de combinações de vários modelos pela APIYI (apiyi.com), que oferece cota gratuita para testes e uma interface unificada para múltiplos modelos.

📚 Referências

1. Documentação oficial do Google Antigravity Swarm: mecanismo de execução do /swarm, configuração de papéis, cópias de trabalho e operações via CLI
2. Link: antigravity.google/docs/swarm

3. Descrição: fonte primária sobre os detalhes de Coordinator, Verifier e Monitor, além das visões Board / Members / Graph

4. Blog oficial do Google Antigravity: Gemini 4 Carbon in Google Antigravity

5. Link: antigravity.google/blog/gemini-4-carbon-in-google-antigravity

6. Descrição: informações sobre o lançamento do /swarm, a arquitetura multiagente e recomendações de distribuição de modelos por papel

7. Anúncio oficial do Google: Gemini 4 Carbon is now available

8. Link: blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available

9. Descrição: alcance da liberação oficial do Carbon e contexto do lançamento da prévia do /swarm

10. Página de benefícios das assinaturas Google AI: permissões de modelo no AI Pro e no Ultra

11. Link: one.google.com/about/google-ai-plans

12. Descrição: diferenças entre os níveis de assinatura e o acesso ao modelo Carbon

13. Reportagem do The Verge sobre o lançamento: Google releases Gemini 4 Carbon with agent swarm feature

14. Link: theverge.com/ai-artificial-intelligence/1030787/google-gemini-4-carbon-public-rollout
15. Descrição: contexto do lançamento e restrições de acesso, sob a ótica de um veículo independente

Autor: Equipe técnica da APIYI
Troca de experiências: fale com a gente na página inicial da APIYI (apiyi.com) para trocar ideias sobre práticas multiagente. Mais materiais de integração estão disponíveis na central de documentação em docs.apiyi.com

Artigos relacionados

• Análise do lançamento do Gemini 4 Carbon: com 59 pontos, supera o Opus 5.5 e vence em 15 de 17 testes, mas não é possível invocá-lo: O Gemini 4 Carbon lidera o índice de inteligência da Artificial Analysis com 59 pontos e vence 15 de 17 comparações oficiais, mas não tem ID de modelo na API nem prazo de lançamento; este artigo explica a pontuação, por que ele ainda está indisponível e sugere o gemini-4-argon aos desenvolvedores chineses.