Você é o CEO agora: Como liderar uma equipe de dev IA no Claude Code
Imagine isso. Você abre seu terminal, digita algumas frases, e de repente sua tela se divide em múltiplos painéis - cada um sendo um desenvolvedor IA autônomo trabalhando em uma parte diferente do seu projeto. Eles conversam entre si. Eles assumem tarefas. Eles questionam as ideias uns dos outros. E você simplesmente relaxa e assiste tudo se desenrolar como um jogo de estratégia em tempo real.
Isso são os Agent Teams no Claude Code. E isso acabou de se tornar realidade.
O que são Agent Teams?
Agent Teams permitem coordenar múltiplas instâncias do Claude Code trabalhando juntas. Uma sessão atua como o líder da equipe - coordena o trabalho, atribui tarefas e sintetiza resultados. Os demais são companheiros de equipe - sessões independentes, cada uma rodando em sua própria janela de contexto, comunicando-se diretamente entre si.
Eis o que torna isso diferente de subagentes: subagentes rodam dentro de uma única sessão e só podem reportar ao agente principal. Eles não conseguem conversar entre si. Agent Teams são instâncias Claude Code completamente independentes que enviam mensagens diretamente umas para as outras. Use subagentes quando precisar de trabalhadores rápidos e focados que reportam de volta. Use Agent Teams quando os companheiros de equipe precisam compartilhar descobertas, desafiar uns aos outros e se coordenar por conta própria.
Você mantém o controle o tempo todo. O Claude nunca cria uma equipe sem sua aprovação - ou você solicita uma, ou o Claude sugere uma e aguarda sua confirmação antes de prosseguir.
Ative em 30 segundos
Agent Teams são experimentais e desativados por padrão. Ative com um destes dois métodos:
Opção 1: Variável de ambiente
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
Opção 2: Arquivo de configuração
Adicione ao seu settings.json:
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
}
}
Pronto. Você agora é um gerente de equipe.
Lance sua primeira equipe
Sem arquivos de configuração. Sem YAML. Simplesmente descreva a tarefa e a estrutura de equipe desejada em linguagem natural. O Claude cria a equipe, lança os companheiros e coordena o trabalho com base no seu prompt.
Este exemplo funciona bem porque os três papéis são independentes e podem explorar o problema sem esperar um pelo outro:
Estou projetando uma ferramenta CLI que ajuda desenvolvedores a rastrear
comentários TODO em sua base de código. Crie uma equipe de agentes para
explorar isso de diferentes ângulos: um companheiro em UX, um em
arquitetura técnica, um fazendo o papel de advogado do diabo.
Pressione Enter e assista. O Claude cria uma equipe com uma lista de tarefas compartilhada, lança um companheiro para cada ângulo, deixa-os explorar, sintetiza suas descobertas e faz a limpeza quando o trabalho termina.
O terminal do líder lista todos os companheiros e no que estão trabalhando. Parece um painel de projeto se atualizando em tempo real.
Duas formas de acompanhar a ação
Você escolhe como sua equipe aparece na tela:
Modo in-process é o padrão. Todos os companheiros rodam dentro do seu terminal principal. Use Shift+Cima/Baixo para selecionar um companheiro e digite para enviar uma mensagem diretamente. Funciona em qualquer terminal - nenhuma configuração extra necessária.
Modo split-pane é o grande destaque. Cada companheiro ganha seu próprio painel visível. Você literalmente assiste múltiplos desenvolvedores IA codando lado a lado em tempo real. Requer tmux ou iTerm2 e não funciona no terminal integrado do VS Code, Windows Terminal ou Ghostty.
Se você quer aquela sensação de jogo de estratégia em tempo real - o modo split-pane é a escolha certa. Assistir três agentes investigando simultaneamente sua base de código de diferentes ângulos em painéis separados é genuinamente emocionante.
Controle sua equipe como um profissional
Uma vez que uma equipe está rodando, você fala com o líder em linguagem natural. Ele cuida da coordenação, atribuição de tarefas e delegação com base nas suas instruções.
Mas aqui vem a jogada de mestre - o Delegate Mode. Pressione Shift+Tab para alternar entre os modos de permissão. Quando uma equipe de agentes está ativa, o ciclo inclui o Delegate Mode, que restringe o líder a ferramentas de coordenação apenas. Sem código, apenas lançamento, envio de mensagens e gerenciamento de tarefas. Isso resolve o problema comum do líder tentar implementar tarefas por conta própria em vez de delegar.
Você também pode contornar o líder completamente. Use Shift+Cima/Baixo para selecionar qualquer companheiro e enviar uma mensagem diretamente. Você não está preso a uma cadeia de comando - pode intervir onde quiser, exatamente como um gerente real indo até a mesa de alguém.
A lista de tarefas compartilhada
Nos bastidores, a equipe funciona com uma lista de tarefas compartilhada. Tarefas têm três estados: pendente, em andamento e concluída. Tarefas podem ter dependências - quando um companheiro completa uma tarefa da qual outras dependem, as tarefas bloqueadas são automaticamente desbloqueadas.
Companheiros assumem tarefas de forma autônoma. Quando um termina seu trabalho, pega a próxima tarefa não atribuída e não bloqueada da lista. Sem necessidade de microgerenciamento.
Toda a configuração da equipe e tarefas são armazenadas localmente em ~/.claude/teams/{team-name}/config.json.
Onde Agent Teams dominam
Agent Teams são mais eficazes para tarefas onde a exploração paralela agrega valor real. Aqui estão os casos de uso mais fortes diretamente do guia:
Pesquisa e revisão de código
Múltiplos companheiros investigam simultaneamente diferentes aspectos de um problema, depois compartilham e questionam mutuamente suas descobertas. Um único revisor tende a gravitar para um tipo de problema por vez. Divida os critérios em domínios independentes e tudo recebe atenção minuciosa ao mesmo tempo:
Crie uma equipe de agentes para revisar a PR #142. Lance três revisores:
- Um focado em implicações de segurança
- Um verificando impacto de performance
- Um validando cobertura de testes
Que cada um revise e reporte suas descobertas.
Três agentes, três ângulos, todos rodando ao mesmo tempo. Parece comandar uma equipe de operações especiais.
Novos módulos ou funcionalidades
Companheiros possuem cada um uma parte separada sem pisar no trabalho dos outros. Quando as fronteiras são claras, é aqui que Agent Teams brilham:
Crie uma equipe de agentes para construir a nova funcionalidade
de dashboard. Um companheiro na camada de API, um nos componentes
frontend, um na suite de testes.
Quando o companheiro de API termina as definições de tipos, ele envia uma mensagem diretamente ao companheiro de frontend. O companheiro de testes pede ao companheiro de API para subir um servidor de dev. Eles se coordenam sozinhos sem você precisar mover um dedo.
Debugging com hipóteses concorrentes
Em vez de testar teorias uma por uma, lance companheiros que perseguem cada um uma hipótese diferente em paralelo. Eles convergem para a resposta mais rápido - e podem questionar as descobertas uns dos outros ao longo do caminho.
Pense nisso como um debate entre especialistas onde você é o juiz.
Coordenação entre camadas
Mudanças que abrangem frontend, backend e testes - cada uma gerida por um companheiro diferente. Este é o cenário clássico de "muitas peças em movimento para um único cérebro", e Agent Teams lidam com isso magnificamente.
Quando NÃO usar Agent Teams
Nem toda tarefa precisa de uma equipe. Agent Teams adicionam sobrecarga de coordenação e usam significativamente mais tokens do que uma sessão única. Funcionam melhor quando os companheiros podem operar independentemente.
Pule equipes e use uma sessão única ou subagentes para:
- Tarefas sequenciais onde cada passo depende do anterior
- Edições no mesmo arquivo onde múltiplos agentes criariam conflitos
- Trabalho com muitas dependências que impedem execução paralela
- Tarefas de rotina que um único agente lida perfeitamente
Você não reuniria uma equipe de cinco pessoas para renomear uma variável. A mesma lógica se aplica aqui.
Custos de tokens: O preço do poder
Esta é a seção mais importante. Agent Teams usam significativamente mais tokens do que uma sessão única. Cada companheiro tem sua própria janela de contexto, e o uso de tokens escala com o número de companheiros ativos.
Para pesquisa, revisão de código e desenvolvimento de novas funcionalidades, os tokens extras geralmente valem a pena. Para tarefas de rotina, uma sessão única é muito mais econômica.
Pense nisso como contratar freelancers - você os traz para os grandes projetos, não para tarefas do dia a dia.
Seu CLAUDE.md continua funcionando
Boa notícia - CLAUDE.md funciona normalmente com Agent Teams. Os companheiros leem arquivos CLAUDE.md do seu diretório de trabalho, então qualquer orientação específica do projeto se aplica automaticamente a toda a equipe. Nenhuma configuração extra necessária.
Limitações conhecidas
Agent Teams são experimentais e a documentação é transparente sobre isso. Limitações atualmente conhecidas incluem problemas com retomada de sessão, coordenação de tarefas e comportamento de encerramento. Você só pode rodar uma equipe por sessão, equipes aninhadas não são suportadas, e o modo split-pane é limitado a tmux e iTerm2.
O líder às vezes tenta implementar tarefas por conta própria em vez de delegar. Duas soluções: diga explicitamente "espere seus companheiros completarem suas tarefas antes de prosseguir" no seu prompt, ou use o Delegate Mode (Shift+Tab) para restringi-lo a ferramentas de coordenação.
São os primeiros dias - mas a experiência central já parece algo fundamentalmente novo.
Abordagens relacionadas
Agent Teams convivem com outras estratégias de trabalho paralelo no Claude Code:
Subagentes são sua opção de delegação leve. Eles lançam agentes auxiliares para pesquisa ou verificação dentro da sua sessão - melhor para tarefas que não precisam de coordenação entre agentes.
Sessões paralelas manuais usando git worktrees permitem rodar múltiplas sessões Claude Code por conta própria sem coordenação automatizada de equipe.
A progressão é clara: subagentes para tarefas solo rápidas, Agent Teams quando colaboradores precisam realmente trabalhar juntos.
Começando: Sua primeira missão
Aqui está a progressão recomendada:
Semana um: Ative Agent Teams e comece com uma revisão de código. Três revisores, três ângulos - segurança, performance, cobertura de testes. Baixo risco, alto retorno. Observe como eles se coordenam e pegue o ritmo do fluxo.
Semana dois: Tente uma exploração de pesquisa. Dê à equipe uma questão de design aberta com três perspectivas diferentes. Assista-os questionarem mutuamente suas ideias.
Semana três: Parta para uma implementação de funcionalidade com limites claros. Um companheiro por camada, cada um com seu próprio território.
Até lá, você terá um instinto para saber quando equipes agregam valor e quando uma sessão solo é a melhor opção.
O veredito final
Agent Teams transformam o Claude Code de um único desenvolvedor em um esquadrão coordenado que você lidera em tempo real. Você descreve o que quer, atribui papéis, assiste múltiplos agentes IA iniciarem em painéis separados, assumirem tarefas, enviarem mensagens uns para os outros e entregarem resultados em paralelo.
É experimental. Consome tokens. Tem arestas. E é a coisa mais empolgante que aconteceu no desenvolvimento assistido por IA este ano.
Ative. Lance uma equipe. Assista seu terminal ganhar vida.
Você não está mais apenas escrevendo código. Você está liderando o show.
