Qual a diferença entre usar um agente e usar vários?
Um fluxo com um agente é uma sessão de agente de IA trabalhando numa tarefa, numa cópia de trabalho: você manda o prompt, ele trabalha, você revisa e só então começa a próxima. Um fluxo multiagente roda várias sessões ao mesmo tempo, cada uma na sua tarefa e no seu workspace, ou várias tentativas da mesma tarefa.
Nenhum dos dois é mais avançado. Um agente troca velocidade por simplicidade; vários agentes trocam atenção por vazão. O panorama completo está em desenvolvimento multiagente.
Como o trabalho sequencial se compara ao paralelo?
No sequencial, as tarefas terminam uma depois da outra; no paralelo, tarefas independentes andam juntas, e você espera pela mais longa em vez de todas em fila. A revisão, porém, continua sendo um diff de cada vez.
| Dimensão | Um agente | Vários agentes |
|---|---|---|
| Ordem do trabalho | Uma tarefa, depois a próxima | Tarefas independentes ao mesmo tempo |
| Espera | A soma de todas as tarefas | Perto da tarefa mais longa, mais o seu tempo de revisão |
| Cópias de trabalho | Uma basta | Uma por agente, senão um sobrescreve o outro |
| Carga de revisão | Um diff por vez, conforme chega | Vários diffs chegando quase juntos |
| Uso | O uso de uma sessão | Cada agente consome a própria assinatura ou cota de API |
| Conflitos | Nenhum entre agentes | Nenhum durante o trabalho se isolados; possíveis no merge |
| Quando uma tentativa dá errado | Tudo o que vem depois espera | As outras tarefas continuam |
| Melhor para | Trabalho pequeno, acoplado ou exploratório | Tarefas independentes e tentativas concorrentes |
Quanto custa coordenar vários agentes?
Coordenar custa atenção, uso e trabalho de merge. Agente em paralelo não é vazão de graça; cada um acrescenta algo para você gerenciar.
- Tempo de revisão. Cada agente gera um diff, e todo diff deveria ser lido antes do merge. Esse costuma ser o gargalo de verdade.
- Uso. Cada agente gasta da assinatura ou da chave de API do próprio fornecedor. Três agentes na mesma tarefa são três sessões de uso, não uma.
- Conflitos de merge. Workspaces separados impedem que um agente sobrescreva o outro durante o trabalho. Não impedem que duas branches mexam nas mesmas linhas; isso você resolve no merge.
- Contexto dividido. Cada agente só sabe o que o prompt e o workspace dele dizem. Prompt vago é multiplicado, não corrigido.
- Troca de contexto. Acompanhar cinco sessões custa mais do que uma, a não ser que algo avise qual delas precisa de você.
O Tallos foi feito para baixar esses custos: um workspace paralelo por tarefa, status dos agentes na barra lateral, revisão de diff com comentários que voltam para o agente, e squads com limite de rodadas e de membros, mais um histórico de execuções com custo estimado quando os agentes informam o uso.
Quando um agente só já basta?
Um agente basta quando o trabalho é pequeno, muito acoplado ou ainda está nebuloso. Colocar mais agentes nessas tarefas aumenta a coordenação sem aumentar o progresso.
- Mudanças pequenas, que terminam antes de você configurar uma segunda tarefa.
- Passos acoplados, em que cada mudança depende da anterior: a migration, depois o código que usa, depois os testes.
- Exploração: pedir ao agente para explicar código, rastrear um bug ou esboçar opções.
- Pouco tempo para revisar: se hoje você só consegue ler um diff com calma, rode um agente.
- Orçamento de uso apertado: uma sessão gasta menos do que várias.
Quais padrões funcionam com vários agentes?
Quatro padrões cobrem quase todo trabalho multiagente: tarefas independentes, melhor de N, construir + revisar, e um líder que divide o trabalho. Os três últimos são templates de squads no Tallos.
| Padrão | Como funciona | Bom para | No Tallos |
|---|---|---|---|
| Tarefas independentes | Tarefas diferentes, um agente e um workspace para cada | Um backlog de correções e ajustes sem relação | Um workspace por tarefa, qualquer agente em cada |
| Melhor de N | O mesmo objetivo para vários agentes; fica o melhor resultado | Problemas difíceis sem caminho óbvio | Template de squad "3 tentativas, escolhe a melhor" |
| Construir + revisar | Um agente constrói, outro revisa; repetem até o revisor aprovar | Mudanças que pedem um segundo par de olhos | Template de squad "Construir + revisar" |
| Líder divide | Um líder quebra o objetivo, os membros pegam partes, o líder junta | Features que envolvem API, UI e testes | Template de squad "Líder divide o trabalho" |
O melhor de N transforma divergência em sinal: onde as tentativas concordam, a abordagem provavelmente está certa; onde divergem, você achou a parte difícil. Veja o squad melhor de três. O construir + revisar coloca um revisor no ciclo antes de o diff chegar em você; veja construir e revisar. O líder divide serve para features maiores, como em entregar uma feature.
Comece com dois agentes em duas tarefas independentes. Depois aumente.
Como sair de um agente para vários?
Acrescente agentes um de cada vez e deixe a sua capacidade de revisão ditar o ritmo.
- 1
Escolha duas tarefas independentes
Tarefas que mexem em partes diferentes do código, para as branches dificilmente conflitarem.
- 2
Dê um workspace para cada
No Tallos, cada tarefa ganha sua git worktree e sua branch, então os agentes nunca dividem arquivos.
- 3
Escreva prompts autossuficientes
Diga o objetivo, os arquivos envolvidos e como conferir o resultado, incluindo quais testes rodar.
- 4
Revise antes de aumentar
Leia os dois diffs, devolva comentários de linha, faça o merge. Se a revisão ficou corrida, fique em dois.
- 5
Teste o melhor de N numa tarefa difícil
Rode um squad com três tentativas e deixe o líder recomendar uma. A decisão de aceitar ou descartar continua sua.
- 6
Defina limites
Squads começam com 5 rodadas e 4 membros trabalhando ao mesmo tempo; aumente só quando a tarefa pedir.
Tem um passo a passo em seu primeiro squad e o guia completo em como rodar agentes de IA em paralelo.
Perguntas frequentes
Rodar vários agentes de IA é mais rápido do que rodar um?
Em tarefas independentes, normalmente sim no tempo de relógio, porque o trabalho anda junto. Em tarefas acopladas muitas vezes não, e o tempo de revisão não diminui; o ganho real depende das suas tarefas e da sua revisão.
Rodar mais agentes custa mais?
Sim. Cada agente gasta da própria assinatura ou chave de API, então vários usam mais do que um. O Tallos usa as contas que você já tem e não revende acesso a modelos; os limites do squad e o custo estimado no histórico ajudam a manter o gasto visível.
Agentes em paralelo sobrescrevem as mudanças uns dos outros?
Não, se cada um tiver sua cópia de trabalho. O Tallos dá a cada tarefa uma git worktree separada numa branch própria; conflitos ainda podem aparecer depois, no merge de branches que mexeram nas mesmas linhas.
Quantos agentes devo rodar ao mesmo tempo?
Quantos você conseguir revisar direito. Comece com dois e só aumente quando a revisão dos diffs continuar cuidadosa, e não corrida.
O que é melhor de N?
Melhor de N é dar o mesmo objetivo a vários agentes que trabalham de forma independente, comparar os resultados e ficar com o melhor. No Tallos, é o template de squad "3 tentativas, escolhe a melhor".
Agentes diferentes podem trabalhar juntos no mesmo projeto?
Podem. Cada membro do squad pode usar um agente e um modelo diferentes, então o Claude Code pode construir enquanto o Codex revisa, ou Claude Code, Codex e Gemini CLI podem fazer uma tentativa cada.
Quais são os limites de um squad?
Por padrão, um squad roda até 5 rodadas com até 4 membros trabalhando ao mesmo tempo. Dá para subir até o máximo de 20 rodadas e 12 membros.
