# Agentes de código em paralelo: Claude Code e Codex juntos

URL: https://agentvera.dev/pt/blog/parallel-coding-agents/ · Publicado: 2026-09-20

Rode Claude Code e Codex lado a lado como agentes de código em paralelo: divida o trabalho, evite conflitos de arquivo com worktrees e passe saídas entre agentes.

**Resumo:**

- Divida o trabalho por fronteiras de arquivos, dê a cada agente um objetivo mensurável e decida de antemão para onde vai a saída de cada um.
- Um layout de exemplo usa o Claude Code como arquiteto, o Codex como testador trabalhando só em tests/ e um terminal para o servidor de desenvolvimento.
- Os fluxos passam a última resposta de um agente para o próximo por um template {{output}}, e um limite de turnos evita loops; comece com dois agentes.

Agentes de código em paralelo significa rodar mais de um agente de código com IA no mesmo projeto ao mesmo tempo. Um agente escreve uma feature, outro escreve os testes, um terceiro atualiza a documentação. Bem configurado, você divide um trabalho que antes fazia um passo de cada vez. Mal configurado, os agentes sobrescrevem os mesmos arquivos, o contexto incha e você perde a noção de quem fez o quê.

Este post mostra um jeito prático de rodar o Claude Code e o Codex lado a lado: como dividir o trabalho, como evitar conflitos de arquivo e como levar a saída de um agente para o próximo.

## Por que agentes de código em paralelo?

O gargalo com um único agente é a espera. Enquanto ele pensa, lê arquivos e roda testes, você espera ou vai fazer outra coisa. Agentes em paralelo aproveitam esse tempo de espera.

Eles compensam mais quando você tem:

- **Trabalho independente:** um endpoint no backend e um formulário no frontend que não se tocam.
- **Escrever e conferir:** um agente escreve o código, outro escreve testes para a mesma mudança.
- **Pesquisa e implementação:** um agente compara opções de bibliotecas enquanto outro edita o código existente.
- **Pontos fortes diferentes:** o Claude Code e o Codex vêm com modelos e conjuntos de ferramentas diferentes; testar as duas abordagens no mesmo problema pode te levar lá mais rápido. Para ver como os dois diferem, leia [Claude Code vs Codex](/pt/blog/claude-code-vs-codex/ "Claude Code vs Codex: uma comparação honesta").

## Três regras para dividir o trabalho

O sucesso do trabalho em paralelo depende de como você o divide.

### 1. Defina fronteiras de arquivos de antemão

Dois agentes editando o mesmo arquivo é a falha mais comum. Escreva no papel de cada agente quais pastas ele pode tocar. Por exemplo, um agente trabalha só em `src/api/`, o outro só em `tests/`.

### 2. Dê um objetivo a cada agente

Em vez de “melhore o módulo de autenticação”, dê um objetivo mensurável como “mude o tratamento de sessão para refresh tokens”. Um objetivo claro deixa o agente parar cedo e torna a saída fácil de conferir.

### 3. Decida para onde vai a saída

Se o resultado de um agente alimenta outro, desenhe isso de antemão. Ele vai escrever um arquivo de plano, fazer commit ou mandar a resposta direto para o próximo agente?

## Evite conflitos de arquivo com git worktrees

Quando fronteiras de pastas não bastam, a opção mais robusta é uma árvore de trabalho separada por agente. Git worktrees abrem pastas separadas em branches diferentes do mesmo repositório:

```bash
git worktree add ../acme-web-auth -b auth-refactor
git worktree add ../acme-web-tests -b auth-tests
```

Cada agente trabalha na própria pasta e nunca toca nos arquivos do outro. Quando terminam, você faz merge das branches por um pull request normal. Explico isso em detalhes em [git worktrees para agentes em paralelo](/pt/blog/git-worktree-parallel-agents/).

No AgentVera, as worktrees ficam no painel da direita: crie uma a partir de uma branch nova ou existente, veja quantas mudanças ela tem e quanto está à frente ou atrás da branch principal, e inicie um agente direto nela.

## Configuração de exemplo: Claude Code escreve, Codex testa

Um layout inicial simples e eficaz:

| Agente | Ferramenta | Papel | Trabalha em |
| --- | --- | --- | --- |
| Architect | Claude Code | Planeja e implementa a feature | Worktree `auth-refactor` |
| Tester | Codex | Escreve testes de integração para a mudança | Mesma worktree, só `tests/` |
| Dev server | Terminal | Roda `pnpm dev` | Pasta principal |

Passos da configuração:

1. Adicione a pasta do projeto ao AgentVera.
2. No diálogo New agent, escolha Claude Code, chame-o de “Architect” e escreva as fronteiras de arquivos no papel dele.
3. Faça o mesmo com o Codex como “Tester”.
4. Inicie o servidor de desenvolvimento num agente Terminal.
5. Dê a tarefa ao Architect; quando ele terminar o turno, passe a saída dele ao Tester.

Em vez de fazer o último passo à mão, monte um fluxo. Os [fluxos](/pt/features/flows/) enviam a última resposta de um agente para outro por um template `{{output}}` e esperam o agente de destino terminar o turno se ele estiver ocupado.

## Acompanhando agentes em paralelo

À medida que o número de agentes cresce, o trabalho de verdade passa a ser acompanhá-los. Fique de olho em:

- **Status:** qual agente está trabalhando, qual está esperando por você, qual deu erro?
- **Tamanho do contexto:** conversas longas custam mais tokens a cada turno.
- **Pedidos de aprovação:** um agente esperando permissão fica parado enquanto os outros seguem.

O [workspace](/pt/features/workspace/) do AgentVera mostra os agentes lado a lado numa grade. Cada painel tem o status, o tamanho do contexto ao vivo e uma caixa de mensagem. Agentes esperando aprovação aparecem na barra de status, e ⇧⌘A pula para o que está esperando há mais tempo.

## Contexto e custo

Trabalhar em paralelo também multiplica o uso de tokens. A primeira requisição de cada agente carrega as definições de ferramentas, o system prompt e os plugins. Em conversas longas, essa base é relida a cada turno.

Para manter o custo sob controle:

- Inicie os agentes para tarefas simples com um conjunto menor de ferramentas.
- Compacte conversas longas com `/compact`.
- Ao passar saídas entre agentes, envie só a parte necessária.

Para números medidos, veja [como reduzir o uso de tokens do Claude Code](/pt/blog/claude-code-token-usage/).

## Erros comuns

**Dois agentes num arquivo.** A correção mais rápida é uma worktree ou uma fronteira de pasta rígida.

**Tarefas vagas.** Tarefas abertas como “conserte o código” fazem o agente ler arquivos sem fim e inflar o contexto.

**Fazer merge sem conferir.** Rode os testes e revise os diffs antes de fazer merge do que os agentes em paralelo produziram. O code review automático economiza tempo aqui.

**Começar tudo de uma vez.** Comece com dois agentes e adicione um terceiro quando a divisão estiver funcionando.

## Um exemplo de ponta a ponta: migrando para refresh tokens

Dividir o trabalho parece fácil no papel; veja como isso fica numa tarefa real. O objetivo: mudar o tratamento de sessão de um app web para access tokens de curta duração com refresh tokens rotativos.

### Dividindo a tarefa

Primeiro, quebre o trabalho em partes independentes. Esta tarefa tem três:

- **Lado do servidor:** emissão, validação e rotação de tokens (`src/auth/`).
- **Testes:** testes de integração para o novo fluxo (`tests/api/`).
- **Docs:** refletir as mudanças de API no README.

O lado do servidor e os testes olham para o mesmo comportamento, mas ficam em pastas diferentes. A documentação só faz sentido depois que o lado do servidor estiver definido. Então rode os dois primeiros em paralelo e o terceiro depois.

### Instruções de papel

Mantenha o papel de cada agente curto e rígido. Para o Architect:

```text
Work only under src/auth/. Don't change tests.
Run pnpm test auth after every change.
When you're done, summarize your changes as a bullet list.
```

Para o Tester:

```text
Work only under tests/. Don't touch application code.
Write integration tests for the behaviors in the summary you receive.
```

A última linha do papel do Architect importa: o resumo dele vira a entrada do Tester pelo fluxo. Quanto mais organizado o resumo, menos arquivos o Tester precisa ler.

### Passagem e acompanhamento

Quando o Architect termina o turno, o fluxo envia a última resposta dele ao Tester por um template. Se o Tester estiver ocupado, o fluxo espera o turno dele terminar, e o limite de turnos da conexão impede que os dois agentes entrem num loop sem fim. Enquanto isso, você pode acompanhar os logs do servidor de desenvolvimento no agente de terminal ou deixar um terceiro agente preparando a documentação.

### Quando não usar paralelismo

Nem todo trabalho se paraleliza. Fique com um agente trabalhando passo a passo quando:

- A mudança está concentrada num arquivo ou em poucos arquivos muito acoplados.
- A tarefa ainda não está clara; pesquisa e plano vêm primeiro.
- A saída de um agente é pré-requisito para o outro, e o segundo trabalho é curto.

Nesses casos, um pipeline em etapas funciona melhor que o paralelismo. Explico isso em [fluxo de trabalho com agentes de IA](/pt/blog/ai-agent-workflow-pipeline/).

## Checklist

Antes de uma sessão em paralelo:

- [ ] O objetivo de cada agente está escrito em uma frase?
- [ ] As fronteiras de arquivos estão no papel?
- [ ] Se conflitos são prováveis, cada agente tem a própria worktree?
- [ ] Se a saída de um agente alimenta outro, o fluxo ou o arquivo de plano está pronto?
- [ ] Há um agente ou terminal para rodar os testes?

## Conclusão

Agentes de código em paralelo economizam tempo de verdade em trabalho que se divide bem. O segredo é separar os agentes e definir a passagem entre eles. Worktrees separam arquivos, fluxos levam as saídas e papéis bem escritos separam as responsabilidades.

O AgentVera foi feito para montar isso numa só janela: Claude Code, Codex e outras CLIs rodam lado a lado com os próprios logins. Você pode [começar no plano gratuito](/pt/) e conferir os [planos](/pt/pricing/) quando precisar de mais.

## Perguntas frequentes

**O Claude Code e o Codex podem trabalhar no mesmo projeto ao mesmo tempo?** Sim. Cada um roda na própria sessão de terminal. A configuração mais segura é dividir o trabalho por pasta ou dar a cada agente a própria git worktree, para que nunca editem os mesmos arquivos.

**Agentes em paralelo precisam de contas separadas?** Não. Cada CLI usa o próprio login. Você pode abrir vários agentes numa conta; os limites de uso enchem por conta.

**Quantos agentes devo rodar ao mesmo tempo?** Quantos você conseguir acompanhar. De dois a quatro agentes é administrável na maioria dos projetos; além disso, fluxos e notificações ajudam.

**Os agentes podem usar a saída uns dos outros?** Com os fluxos do AgentVera, a última resposta de um agente é enviada a outro por um template, então você não copia e cola à mão.

---

**Sobre o AgentVera.** AgentVera é um app desktop para macOS, Windows e Linux, desenvolvido pela Solviera Teknoloji. Ele roda 18 agentes de programação com IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) lado a lado, por projeto, em terminais reais com as instalações e logins de CLI do próprio usuário. O plano gratuito tem agentes ilimitados. Baixar: https://agentvera.dev/pt/download/ · Preços: https://agentvera.dev/pt/pricing/