Executar vários agentes no Antigravity abre caminho para fluxos de trabalho de IA rápidos e paralelos, mas coordenação, isolamento de tarefas e timing exigem planejamento cuidadoso. Este artigo detalha os padrões reais que funcionam, as armadilhas comuns que desperdiçam horas e como combinar agentes simultâneos com ferramentas de geração de imagens e texto por IA para resultados mais ricos e automatizados.
Executar vários agentes no Antigravity parece simples até que o terceiro agente trava sem aviso e você passa quarenta minutos tentando descobrir por que o resultado saiu pela metade. A execução paralela é um dos recursos mais poderosos do Antigravity, mas exige um modelo mental específico. Este artigo mostra o que realmente funciona em produção, como equipes reais estruturam seus pipelines de agentes e onde evitar armadilhas que parecem inofensivas à primeira vista.
A maioria dos frameworks de agentes serializa por padrão. Você define uma tarefa, um agente a pega, conclui e só então a próxima começa. O Antigravity inverte essa lógica. Seu escalonador central é construído em torno de um event loop concorrente que trata as tarefas dos agentes como cidadãs de primeira classe, e não como um complemento acoplado a um pool de threads.
No fundo, o Antigravity roda um loop reativo. Quando você registra um agente, não está iniciando um novo processo. Está registrando uma corrotina que o escalonador gerencia. Isso significa que a latência se acumula de forma diferente do que em sistemas com threads. Dez agentes rodando simultaneamente no Antigravity normalmente superam dez chamadas sequenciais, porque o tempo de espera de E/S, que é onde a maioria das chamadas a LLMs gasta 80% do tempo, é compartilhado entre o pool.
A ideia central aqui: concorrente não significa descontrolado. O Antigravity oferece os blocos de construção, mas a lógica de coordenação é totalmente sua.
Antes de adicionar mais agentes, vale entender por que o padrão de agente único existe. Um agente único é previsível. Ele lê um contexto, age sobre ele e devolve um resultado. No momento em que você introduz um segundo agente lendo o mesmo contexto, surge a possibilidade de saídas divergentes. O Antigravity não concilia essas diferenças por mágica. Essa tarefa é sua.
💡 Comece com um agente, observe onde ele passa o tempo esperando e só então decida quais esperas valem a pena paralelizar.
Configurar vários agentes no Antigravity exige três decisões antecipadas: como os agentes são criados, se compartilham estado e como devolvem resultados ao orquestrador.
A abordagem mais direta é a criação explícita no nível da definição da tarefa. Em vez de chamar agentes em sequência, você define um lote de tarefas e deixa o escalonador despachá-las simultaneamente.
tasks = [
agent.create_task("summarize", doc_a),
agent.create_task("summarize", doc_b),
agent.create_task("summarize", doc_c),
]
results = await asyncio.gather(*tasks)
O detalhe crítico: asyncio.gather no Antigravity respeita o tamanho do pool de agentes. Se você definir max_concurrent=3 e despachar 10 tarefas, as três primeiras disparam imediatamente. As outras sete ficam na fila. Isso é controle de taxa intencional, não um bug.
Esta é a decisão que quebra a maioria das configurações com múltiplos agentes. Existem três padrões válidos:
| Padrão | Quando usar | Risco |
|---|---|---|
| Isolado | Cada agente precisa de dados diferentes | Baixo: sem conflitos |
| Leitura compartilhada | Agentes precisam do mesmo contexto base | Médio: inchaço de memória |
| Escrita compartilhada | Agentes atualizam um objeto comum | Alto: condições de corrida |
Tarefas isoladas quase sempre são o padrão certo. Se dois agentes precisam do mesmo dado, passe uma cópia para cada um. O custo de memória vale a previsibilidade.
O estado de escrita compartilhada deve ser tratado como último recurso, não como conveniência. Se você realmente precisar dele, use o StateManager integrado do Antigravity com travamento explícito, em vez de um dict simples do Python.
Quando a saída do Agente A alimenta o Agente B, existe uma dependência. No Antigravity, dependências quebram o paralelismo por definição. Dois agentes que dependem um do outro não podem rodar ao mesmo tempo.
O padrão mais limpo é a passagem explícita de bastão:
summary = await agent_a.run(document)
analysis = await agent_b.run(summary)
Para pipelines grandes com dependências mistas, use uma abordagem de grafo de dependências. Defina quais tarefas são independentes (rodam em paralelo) e quais são sequenciais (rodam em ordem), e deixe o escalonador do Antigravity cuidar do restante.
Três padrões cobrem cerca de 90% dos casos de uso com múltiplos agentes no Antigravity. Eles não são exóticos. São simples, no melhor sentido da palavra.
O padrão fan-out é o mais comum em trabalhos de IA em lote. Uma entrada, muitos agentes em paralelo, um ponto de coleta.
Como funciona:
Esse padrão brilha quando as tarefas são naturalmente paralelas: nenhum agente precisa saber o que os outros estão fazendo. Geração de imagens, resumo de documentos, tarefas de classificação e tradução se encaixam perfeitamente nesse formato.
💡 Para lotes muito grandes, adicione um semáforo para controlar a concorrência máxima:
asyncio.Semaphore(10)garante que você nunca crie mais de 10 agentes ao mesmo tempo, protegendo os limites de taxa das APIs a jusante.
A cadeia de pipeline é a contraparte do fan-out: um fluxo estritamente sequencial em que cada agente se apoia na saída do anterior.
Agent 1 (Research) → Agent 2 (Draft) → Agent 3 (Edit) → Agent 4 (Format)
Melhor para: tarefas em que a qualidade depende de refinamento progressivo. Escrita, geração de código e raciocínio em várias etapas se beneficiam de cadeias de pipeline porque os agentes posteriores podem corrigir os erros dos anteriores.
O risco das cadeias de pipeline é a propagação de erros. Se o Agente 1 devolver uma saída falha, os Agentes 2 a 4 vão construir com confiança sobre essa falha. Adicione validação entre as etapas, mesmo que seja apenas uma verificação simples de tamanho ou de esquema.
O modelo supervisor é o mais sofisticado dos três. Um agente, o supervisor, orquestra um pool de agentes trabalhadores. O supervisor não faz o trabalho em si. Ele planeja, delega, revisa e decide se deve tentar de novo.
As responsabilidades do supervisor:
Para esse padrão, o Kimi K2.6 e o GPT 5.1 são excelentes modelos supervisores. Ambos são feitos especificamente para tarefas de orquestração de agentes, sendo que o GPT 5.1 foi projetado especialmente para criar agentes de IA. Como trabalhadores, modelos mais leves como o Claude 4.5 Haiku ou o GPT 4.1 Mini reduzem custos de forma significativa sem sacrificar a qualidade em tarefas bem delimitadas.
| Função | Modelo recomendado | Motivo |
|---|---|---|
| Supervisor | Kimi K2.6 | Raciocínio forte, feito para agentes |
| Supervisor | GPT 5.1 | Capacidades nativas para criar agentes |
| Trabalhador | Claude 4.5 Haiku | Rápido, com bom custo-benefício |
| Trabalhador | GPT 4.1 Mini | Baixa latência, saída confiável |
| Raciocinador | Deepseek R1 | Raciocínio profundo para subtarefas complexas |
A maioria das falhas com múltiplos agentes no Antigravity cai em duas categorias. Ambas são evitáveis quando você sabe o que observar.
Uma condição de corrida ocorre quando dois agentes escrevem no mesmo recurso ao mesmo tempo e nenhum deles sabe que o outro existe. No Antigravity, isso normalmente aparece como:
A correção é nunca escrever em um recurso compartilhado sem um lock. Na prática, isso significa:
lock = asyncio.Lock()
async def safe_write(lock, data, destination):
async with lock:
destination.append(data)
Para recursos externos, como arquivos ou APIs, serialize as gravações por meio de um único agente gravador dedicado. Os outros agentes passam suas saídas para o gravador, e ele é o único que acessa o recurso.
Esta é menos óbvia. Quando você executa vários agentes simultaneamente, cada um solicita tokens ao mesmo endpoint de modelo. Se você não gerencia o consumo total de tokens concorrentes, vai atingir os limites de taxa em intervalos imprevisíveis.
O padrão aqui é o orçamento de tokens no nível do orquestrador. Antes de criar os agentes, estime o total de tokens exigido pelo lote. Se a estimativa ultrapassar a janela de limite de taxa, introduza um atraso ou reduza o tamanho do lote.
💡 Para cargas paralelas pesadas, o Llama 4 Maverick Instruct e o Deepseek v3.1 oferecem opções de alta vazão com limites de taxa generosos, o que os torna escolhas práticas para pipelines de agentes com grande volume.
Sintomas comuns de colisões de orçamento de tokens:
Se você notar qualquer um desses sinais, verifique seu consumo concorrente de tokens antes de presumir um bug na lógica dos seus agentes.
Configurações com múltiplos agentes ficam especialmente interessantes quando você combina tarefas de geração de texto e de imagem. Um caso de uso comum no mundo real: gerar um lote de artigos e, em seguida, produzir automaticamente as imagens de cada artigo em paralelo.
A abordagem mais limpa atribui agentes separados a tipos de mídia diferentes. Um agente cuida de toda a geração de texto. Um pool de agentes separado cuida de todas as solicitações de geração de imagem. Os dois pools rodam simultaneamente, mas nunca interagem diretamente.
Estrutura típica:
Essa separação importa por um motivo prático: geração de texto e geração de imagem têm perfis de latência muito diferentes. Um texto de 1000 palavras pode levar 8 segundos. Gerar uma imagem pode levar de 15 a 25 segundos. Se você misturar os dois no mesmo pool de agentes, as tarefas rápidas de texto ficarão na fila atrás das tarefas lentas de imagem. Mantê-los separados maximiza a vazão para ambos.
Para fluxos de trabalho que envolvem tanto escrita quanto produção visual, usar um LLM como coordenador e modelos de imagem dedicados como trabalhadores é uma arquitetura muito eficaz. O LLM cuida da decomposição de tarefas, do refinamento de prompts e da revisão de qualidade. Os modelos de imagem fazem a geração em si.
No PicassoIA, isso se traduz em uma divisão natural:
💡 Ao criar pipelines de agentes multimodais, trate a engenharia de prompts como uma tarefa de primeira classe. Atribua um agente LLM exclusivamente ao refinamento de prompts de imagem a partir do conteúdo bruto do artigo, antes de enviá-los aos modelos de imagem. A qualidade da saída melhora bastante com essa etapa.
O estado é o assassino silencioso dos sistemas com múltiplos agentes. Agentes que carregam estado demais se tornam imprevisíveis. Agentes que não carregam estado nenhum se tornam inúteis. O ponto ideal são agentes sem estado com injeção explícita de contexto.
O que isso significa na prática:
Esse padrão, às vezes chamado de estilo de passagem de mensagens, torna os agentes muito mais fáceis de testar, depurar e escalar. Você pode substituir qualquer agente sem atualizar os outros, porque nenhum agente guarda um estado do qual os outros dependam.
Anti-padrões a evitar:
| Anti-padrão | O que dá errado |
|---|---|
| Dict global compartilhado | Conflitos de escrita, perda silenciosa de dados |
| "Memória" do agente entre execuções | Desvio de estado, saídas imprevisíveis |
| Histórico completo da conversa para cada agente | Inchaço de tokens, respostas mais lentas |
| Nomes de modelo fixos dentro dos agentes | Pouca flexibilidade, difícil trocar modelos |
Quando você perceber que está depurando por que a saída de um agente mudou sem ter alterado o código, o desvio de estado quase sempre é o culpado.
Sistemas de produção com múltiplos agentes falham. Chamadas de rede expiram, APIs de modelos devolvem erros e, de vez em quando, um agente produz uma saída que não passa nas suas regras de validação. Incluir a lógica de nova tentativa no orquestrador desde o primeiro dia, em vez de acrescentá-la depois, é o que separa um pipeline confiável de um frágil.
Uma estratégia prática de nova tentativa:
Para tarefas com muito raciocínio, em que um agente produz uma resposta logicamente errada em vez de um erro técnico, vale usar o Deepseek R1 como validador de contingência. Seu raciocínio passo a passo o torna adequado para detectar erros lógicos que outros modelos deixam passar.
Nova tentativa versus fallback:
Nem toda falha justifica uma nova tentativa com o mesmo modelo. Considere um pool de fallback em que as tarefas que falharam são reatribuídas a outro modelo. Uma tarefa que expira no GPT 5 Pro pode terminar com sucesso no Claude 4.5 Sonnet, especialmente se o tempo esgotado foi causado pela profundidade do raciocínio, e não pela conectividade.
Executar vários agentes no Antigravity não se resume a acrescentar mais modelos a um script. Trata-se de pensar em pipelines, em que cada etapa tem uma entrada clara, uma saída clara e um modo de falha claro.
As equipes que mais aproveitam as configurações de múltiplos agentes no Antigravity seguem uma progressão simples:
A coleção de modelos de linguagem de grande porte do PicassoIA oferece toda a gama de modelos necessária para cada papel nessa arquitetura: trabalhadores rápidos, supervisores capazes e raciocinadores profundos. Não importa se você está criando um pipeline de produção de conteúdo, uma ferramenta de pesquisa automatizada ou um fluxo criativo multimodal: os blocos de construção estão todos disponíveis.
Experimente montar seu primeiro pipeline fan-out no PicassoIA hoje. Escolha uma tarefa em lote que você faz manualmente, atribua-a a três agentes paralelos usando o Kimi K2.6 ou o GPT 5.1 e meça a diferença de tempo. O primeiro resultado costuma mudar para sempre a forma como você pensa em automação.
Escolha seu idioma
