# Como rodar agentes de IA para programação em paralelo

> Para rodar agentes de IA em paralelo, dê a cada agente seu próprio git worktree (um checkout separado, numa branch própria) e seu próprio terminal, e revise cada diff antes do merge. Dá para montar isso na mão com git worktree e tmux, ou usar um ADE como o Tallos, que cria o worktree, abre o agente e acompanha o status de cada tarefa.

- Canonical: https://runtallos.com/pt/rodar-agentes-de-ia-em-paralelo
- English: https://runtallos.com/run-ai-agents-in-parallel.md
- Atualizado em: 2026-09-29

## Em resumo

- Regra número um: um agente, um worktree, uma branch
- Na mão: git worktree + tmux + seu próprio controle
- O Tallos cria o worktree e abre o agente por tarefa
- Status por agente: trabalhando, esperando você, concluído
- Revise cada diff e mescle só os vencedores

## O que significa rodar agentes de IA em paralelo?

Rodar agentes de IA em paralelo é ter dois ou mais agentes de programação — por exemplo Claude Code, Codex e Gemini CLI — trabalhando ao mesmo tempo no mesmo repositório, cada um na sua tarefa ou na sua tentativa da mesma tarefa. Em vez de esperar um agente terminar para começar o próximo, você inicia todos e revisa os resultados conforme chegam.

Os agentes não precisam ser diferentes. Várias sessões da mesma CLI funcionam igual, e esse costuma ser o ponto de partida de quem quer [rodar várias sessões do Claude Code](https://runtallos.com/pt/aprenda/rodar-varias-sessoes-do-claude-code).

## Por que rodar agentes de IA em paralelo?

Você roda agentes em paralelo porque um agente só é sequencial, e a maior parte do seu tempo com ele é esperando. Agentes em paralelo transformam essa espera em entrega.

- **Mais tarefas ao mesmo tempo** — uma correção, uma feature pequena e um mutirão de testes rodam enquanto você revisa a primeira que terminar.
- **Corrida de tentativas** — mande o mesmo prompt para três agentes e fique com o melhor diff. Onde concordam, a resposta provavelmente está certa; onde divergem, você achou a parte difícil.
- **Papéis separados** — um agente constrói enquanto outro revisa ou escreve testes no seu próprio workspace.
- **Aproveite suas assinaturas** — se você paga mais de um agente, o trabalho em paralelo deixa usar os dois lado a lado em vez de escolher um.

## O que dá errado quando você roda agentes em paralelo?

Quase tudo que dá errado vem de agentes dividindo o que não deviam: arquivos, branches, terminais e a sua atenção.

- **Mesmos arquivos** — dois agentes na mesma pasta sobrescrevem as edições um do outro. Nenhum sabe que o outro existe.
- **Mesma branch** — commits de tarefas diferentes se misturam, e o trabalho pela metade de um agente quebra os testes do outro.
- **Mesmas portas** — dois servidores de dev tentam usar a mesma porta, e um deles falha.
- **Setup faltando** — um checkout novo não tem `node_modules`, `.env` nem cache de build até você recriar.
- **Caos de terminais** — uma dúzia de janelas, e você não sabe qual agente está esperando resposta.
- **Revisão acumulada** — cinco diffs chegam juntos. Sem um fluxo de revisão, o caminho mais rápido é mesclar sem ler.
- **Limites de uso** — vários agentes na mesma conta dividem a mesma cota e podem bater no limite mais cedo.

## Quais são os jeitos de rodar agentes em paralelo?

Existem dois jeitos práticos: montar na mão com git worktrees e um multiplexador de terminal, ou usar um ADE que faz a montagem por você. Os dois se apoiam na mesma base — um git worktree separado por agente.

O jeito manual fica assim, para cada tarefa:

```bash
# um worktree + branch por tarefa
git worktree add ../app-fix-login -b fix-login origin/main
git worktree add ../app-billing-tests -b billing-tests origin/main

# recriar o que o git não rastreia
cp .env ../app-fix-login/ && (cd ../app-fix-login && npm install)

# uma janela do tmux por agente
tmux new-session -d -s agents -c ../app-fix-login 'claude'
tmux new-window -t agents -c ../app-billing-tests 'codex'

# depois: revisar, mesclar, limpar
git -C ../app-fix-login diff origin/main
git worktree remove ../app-fix-login
```

| Etapa | Na mão (git worktree + tmux) | ADE (Tallos) |
| --- | --- | --- |
| Criar um workspace isolado | `git worktree add` com caminho e nome de branch | Clique no + do repositório, nomeie a tarefa, escolha o ponto de partida |
| Copiar `.env`, instalar dependências | Na mão ou com um script por repositório | Caminhos compartilhados, um arquivo `.worktreeinclude` e hooks de setup rodam em todo worktree novo |
| Iniciar o agente | Abrir um painel, `cd`, digitar o comando | Escolher o agente ao criar o workspace |
| Saber quem precisa de você | Olhar painel por painel | Status por sessão: trabalhando, esperando você, concluído, ocioso, e aviso quando um agente termina |
| Revisar | `git diff` no terminal | Visão de diff com comentários por linha devolvidos ao agente em lote |
| Entregar | Commit, push e PR por sua conta | Commit, push e PR a partir do workspace |
| Limpar | `git worktree remove` e apagar a branch | Excluir o workspace; worktree e branch vão junto |
| Coordenar agentes | Você é o coordenador | Squads opcionais: um agente líder distribui membros e reporta |

_Os dois jeitos usam git worktrees reais. A diferença é quem faz o controle._

O jeito manual é ótimo para entender como funciona — o guia de [git worktrees para agentes de IA](https://runtallos.com/pt/aprenda/git-worktrees-para-agentes-de-ia) cobre em detalhe. Ele fica caro a partir de três ou quatro agentes, quando o controle vira o trabalho.

## Existe um jeito mais rápido que montar worktrees na mão?

Existe. Um [ADE](https://runtallos.com/pt/o-que-e-um-ade) cria o worktree, abre o agente e acompanha o estado dele por você. No Tallos, uma tarefa nova em paralelo é um nome, um ponto de partida e um agente.

> Rode seus três primeiros agentes em paralelo. Baixe o Tallos para macOS e Windows. → https://runtallos.com/signup

## Como rodar agentes em paralelo no Tallos, passo a passo?

Este é o ciclo completo no Tallos, do app vazio ao pull request mesclado, com três agentes em três tarefas ou três tentativas.

1. **Conecte seus agentes** — Abra Configurações → Conexões. Instale os agentes que você usa com o comando oficial do fornecedor, faça login ou salve uma chave de API e veja os modelos de cada agente.
2. **Adicione o repositório** — Adicione um checkout local. O Tallos usa sua branch padrão como base de onde todo workspace novo parte.
3. **Crie o primeiro workspace** — Clique no + ao lado do repositório, nomeie a tarefa, escolha o ponto de partida e o agente. Se quiser, vincule um item do GitHub, GitLab, Linear ou Jira. O Tallos cria um git worktree e uma branch reais em segundo plano.
4. **Passe a tarefa ao agente** — Agentes suportados abrem numa visão de chat por padrão. Escreva o prompt, arraste arquivos ou screenshots e deixe trabalhar. Troque para o terminal bruto quando quiser.
5. **Repita para cada agente** — Crie um segundo e um terceiro workspace — tarefas diferentes, ou o mesmo prompt com outro agente para uma corrida. Cada um fica isolado.
6. **Acompanhe lado a lado** — Arraste abas para dividir a tela e ver vários agentes, um servidor de dev e um navegador ao mesmo tempo. Os ícones de status mostram quem está trabalhando e quem precisa de você.
7. **Responda quem precisa de você** — Quando um agente espera uma pergunta ou permissão, ele aparece como precisando de você. Responda e ele continua.
8. **Revise cada diff** — Abra o diff de um workspace concluído. Comente linhas e devolva todas as notas ao agente de uma vez. Repita até ficar certo.
9. **Entregue o vencedor** — Faça commit, push e abra um pull request a partir do workspace. Exclua os workspaces que não precisa; worktree e branch vão junto.

Prefere o teclado, ou quer que um agente faça isso? A CLI `tallos` cria os mesmos workspaces:

```bash
tallos worktree create --name fix-login --agent claude --prompt "Corrija a condição de corrida no login"
tallos worktree create --name fix-login-2 --agent codex --prompt "Corrija a condição de corrida no login"
```

Veja como o isolamento funciona em [workspaces paralelos](https://runtallos.com/pt/recursos/workspaces-paralelos) e como ler as mudanças de um agente em [revisão de diff](https://runtallos.com/pt/recursos/revisao-de-diff).

## Quantos agentes de IA dá para rodar em paralelo?

Dá para rodar quantos agentes sua máquina, seus limites de uso e seu tempo de revisão aguentarem — e o tempo de revisão costuma acabar primeiro. Um começo prático é dois ou três agentes, aumentando conforme o hábito de revisão acompanha.

- **Máquina** — cada workspace pode rodar seu servidor de dev, testes e build. Projetos pesados podem ir para uma máquina maior com [workspaces remotos via SSH](https://runtallos.com/pt/recursos/workspaces-remotos).
- **Uso** — cada agente usa sua própria assinatura ou chave de API. O Tallos mostra o uso e as janelas de limite das contas de agentes suportados.
- **Revisão** — diff que você não lê é risco. Adicione agentes só na velocidade em que consegue revisar o que eles produzem.

## O que vem depois de rodar agentes em paralelo?

O próximo passo é deixar um agente coordenar os outros. Uma [squad](https://runtallos.com/pt/recursos/squads) é um agente líder que divide um objetivo entre agentes membros, cada um no seu worktree, confere o trabalho em rodadas e te entrega um relatório final para aceitar ou descartar.

O template “3 tentativas, escolhe a melhor” é a corrida em paralelo com um juiz: três membros tentam o mesmo objetivo e o líder recomenda um, com os motivos. Por padrão, a squad roda até 4 membros ao mesmo tempo por até 5 rodadas, e dá para subir para 12 membros e 20 rodadas. Veja a [squad melhor de três](https://runtallos.com/pt/squads/melhor-de-tres).

## Perguntas frequentes

### Dá para rodar duas sessões do Claude Code no mesmo repositório ao mesmo tempo?

Dá, desde que cada sessão trabalhe no seu próprio git worktree. Na mesma pasta elas sobrescrevem as mudanças uma da outra; em worktrees separados cada uma tem sua branch e seus arquivos.

### Preciso de git worktrees para rodar agentes em paralelo?

Você precisa de algum checkout isolado, e o git worktree é o mais leve porque compartilha o histórico do repositório. O Tallos cria um worktree para cada tarefa automaticamente.

### Só o tmux resolve para rodar agentes de IA em paralelo?

O tmux cuida dos terminais, não do isolamento, do status nem da revisão. Junto com git worktrees funciona bem para poucos agentes; um ADE acrescenta status, revisão de diff e limpeza.

### Como evitar que agentes em paralelo usem a mesma porta?

Rode cada servidor de dev numa porta própria, definida por workspace com variáveis de ambiente ou a flag de porta do seu framework. Cada workspace do Tallos tem seus terminais, então cada servidor fica com sua tarefa.

### Rodar agentes em paralelo faz eu bater no limite de uso mais rápido?

Pode fazer, porque agentes na mesma conta dividem uma cota. Distribua o trabalho entre os agentes que você tem e acompanhe o uso; o Tallos mostra uso e janelas de limite das contas suportadas.

### Como mesclar os resultados de agentes em paralelo?

Revise o diff de cada workspace, fique com os que quiser e abra um pull request de cada branch vencedora. Exclua o resto; no Tallos isso remove o worktree e a branch.

### O Tallos funciona no Windows para agentes em paralelo?

Funciona. O Tallos roda no Windows 10 ou mais recente e no macOS 13 ou mais recente, com os mesmos workspaces, terminais e fluxo de revisão.

---

**Rode seus agentes em paralelo com o Tallos** — Claude Code, Codex, Gemini e mais de 30 agentes — cada um no seu workspace, com squads, chat, terminais e revisão num só app. Usa as assinaturas que você já tem.

https://runtallos.com/signup (macOS 13+ · Windows 10+)