Claude Code Agent Teams: o futuro do desenvolvimento assistido por IA

Em aplicativos de grande porte ou ambientes corporativos, o contexto se esgota mais rápido do que você imagina. Uma decisão de design importante que você tomou há uma hora provavelmente já saiu do contexto, então você precisa ficar reexplicando coisas que o modelo já resolveu. Você está fazendo quase tudo certo, mas o problema é que está pedindo para um único assistente fazer o trabalho de um time inteiro.

As Claude Code Agent Teams foram criadas para mudar isso. A ideia é que, em vez de uma sessão fazer tudo em sequência, você inicia vários agentes especializados que compartilham uma lista de tarefas, trocam mensagens diretamente entre si e executam o trabalho em paralelo.

Neste artigo, vou mostrar como as Agent Teams funcionam, o que cada função especializada faz e como coordená-las em projetos reais de software.

Novo no Claude Code? Domine o básico em uma tarde com o nosso curso Claude Code 101.

O que são as Claude Code Agent Teams?

As Claude Code Agent Teams são uma camada de coordenação que permite que várias sessões do Claude Code trabalhem no mesmo projeto ao mesmo tempo. Uma sessão assume o papel de líder do time e cria outras sessões, chamadas de colegas de equipe, para cuidar de partes específicas do trabalho.

Cada colega roda como uma instância completa e independente do Claude Code com sua própria janela de contexto. Eles compartilham uma lista de tarefas, assumem o trabalho à medida que surge e trocam mensagens diretamente quando precisam se coordenar.

Configurar isso vai além de abrir algumas abas do terminal e rodar o Claude em cada uma. Fazendo só isso, as janelas de chat separadas não enxergam o progresso umas das outras nem combinam quem faz o quê. Já uma equipe de agentes dá a cada sessão uma visão compartilhada do trabalho e um canal de comunicação. O líder mantém todos alinhados.

Na prática, isso significa que você deixa de ser o “pombo-correio” entre sessões. A equipe cuida da própria coordenação e você entra apenas para definir direção e revisar resultados.

Por que as Agent Teams existem

Uma única sessão do Claude Code funciona bem até o projeto ficar grande demais.

Toda sessão do Claude Code tem uma janela de contexto, e essa janela tem limite. Enquanto você trabalha, a sessão vai sendo preenchida com conteúdos de arquivos, saídas de comandos, discussões de design e seu vai e vem de mensagens. Em algum momento, informações mais antigas saem do contexto e o modelo começa a esquecer decisões que você tomou antes na mesma tarefa.

Há três situações comuns em que isso fica evidente:

• Repositórios grandes: uma base de código com centenas de arquivos não cabe toda no contexto. A sessão acaba lendo os mesmos arquivos repetidamente, gastando tokens para reconstruir um entendimento que já tinha.
• Projetos complexos: features transversais, como adicionar autenticação em backend, frontend e testes, exigem que o modelo lide com preocupações demais ao mesmo tempo. Cada nova disputa espaço com todo o resto.
• Múltiplas tarefas simultâneas: pedir para uma sessão implementar uma feature, refatorar um módulo, escrever testes e atualizar a documentação na mesma conversa é receita para problema.

A resposta é a mesma que times humanos encontraram há décadas: divida o trabalho.

Se uma sessão está no limite durante uma refatoração, passe as mudanças de backend para um colega, as de frontend para outro e as atualizações de testes para um terceiro. Cada colega usa só o que precisa para sua parte do trabalho.

A mesma lógica vale para pesquisa. Uma tarefa com três hipóteses concorrentes avança mais rápido quando três colegas investigam cada teoria em paralelo e depois comparam anotações, em vez de uma única sessão percorrê-las em sequência.

Especialização dá profundidade e paralelismo dá velocidade. Combinados, permitem fazer trabalhos que uma única sessão iria alucinar ou levar tempo demais para concluir.

Como funcionam as Claude Code Agent Teams

Uma sessão de equipe passa por cinco etapas, com a orquestração feita dentro do próprio Claude Code.

• Definir o objetivo: descreva em linguagem simples o que você quer, como se fosse orientar um desenvolvedor júnior. O líder lê e decide como desmembrar o trabalho.
• Delegar o trabalho: o líder cria uma lista de tarefas compartilhada e inicia os colegas, cada um com nome, função e prompt inicial. Você pode especificar a estrutura do time ou deixar o líder decidir.
• Executar em paralelo: cada colega assume tarefas, marca como em andamento, conclui e marca como feito. Dependências são respeitadas automaticamente; bloqueio de arquivos evita conflitos. Os colegas podem se enviar mensagens diretamente — sem precisar passar pelo líder.
• Combinar os resultados: o líder reúne o trabalho finalizado, resolve conflitos e produz um único resultado: um PR, relatório, módulo refatorado ou o que o objetivo exigir.
• Revisar o resultado: você revisa o resultado final como faria com qualquer pull request: lê o diff, roda o código, checa os testes.

Funções especializadas nas Agent Teams

As funções dão forma a uma equipe de agentes. Sem elas, você acaba com sessões genéricas fazendo trabalhos sobrepostos. O Claude Code não fornece uma lista fixa — você define as funções no seu briefing ou apontando o líder para uma definição de subagente salva em .claude/agents/.

Agente de planejamento

O agente de planejamento desdobra o objetivo em tarefas antes de qualquer código ser escrito. Ele explora a base de código, mapeia dependências e produz uma lista de tarefas em unidades autocontidas que um único colega consegue concluir sem precisar checar a todo momento.

Na prática, o líder do time muitas vezes faz esse papel. Você também pode rodar um colega dedicado a planejamento quando o trabalho for grande o suficiente para justificar.

Agente de codificação

O agente de codificação escreve a implementação. A maioria dos colegas será de codificação, cada um responsável por uma parte distinta — backend, frontend, banco de dados, recursos de IA. O segredo é manter os escopos sem sobreposição: dois colegas editando o mesmo arquivo vão sobrescrever o trabalho um do outro.

Agentes de codificação funcionam bem em modelos mais baratos. Muitos profissionais rodam o líder em Opus e os colegas em Sonnet, já que a execução não exige o mesmo nível de raciocínio que a coordenação.

Agente de testes

O agente de testes escreve e roda os testes. Ele pode trabalhar com base em um contrato de API acordado enquanto o colega de codificação ainda está construindo o endpoint — assim, quando o código fica pronto, os testes já estão lá.

Você também pode manter um colega de testes rodando a sessão inteira, reexecutando a suíte sempre que um colega de codificação marcar uma tarefa como concluída.

Agente de revisão

O agente de revisão lê diffs e sinaliza bugs, questões de estilo, casos de borda esquecidos e problemas de segurança. Dividir a revisão entre dois colegas com lentes diferentes — um para segurança, outro para performance — funciona especialmente bem, com o líder combinando os achados.

Se você já escreveu uma definição de subagente para o seu projeto, o colega herda automaticamente suas ferramentas e o prompt de sistema.

Agente de documentação

O agente de documentação escreve docstrings, atualizações de README e documentos mais longos como notas de arquitetura ou referências de API. É um bom candidato para ser o último a rodar — quando a codificação e os testes terminam, o formato final do trabalho fica claro.

Por que a especialização melhora os resultados

Uma sessão generalista precisa manter implementação, testes, docs e feedback de revisão no contexto ao mesmo tempo. Um colega especializado carrega só o que precisa, mantendo o contexto pequeno e o raciocínio focado. A especialização também facilita o debug: quando algo dá errado, você sabe exatamente qual sessão checar.

Desenvolvimento em paralelo com Agent Teams

Paralelismo é o ponto central de uma equipe de agentes.

Depois que o líder desmembra o trabalho em tarefas e inicia os colegas, todos passam a rodar ao mesmo tempo. Cada colega é uma sessão separada do Claude Code, então o trabalho não fica em fila atrás de uma única janela de contexto. O tempo total para concluir uma feature com várias partes cai da soma de todas as partes para o tempo da parte mais lenta.

Aqui vão três combinações que funcionam especialmente bem em paralelo.

• Frontend e backend em paralelo: quando você está criando uma feature que usa as duas camadas, o colega de backend pode construir o endpoint da API enquanto o colega de frontend cria o componente que o consome. Eles se coordenam por mensagens diretas. Assim que o backend define o formato da resposta, envia para o frontend e ambos seguem sem precisar esperar o outro terminar.
• Implementação e testes em paralelo: o colega de codificação escreve a implementação enquanto o colega de testes escreve os testes com base no contrato combinado. Quando o colega de codificação marca a tarefa como concluída, os testes já estão prontos para rodar. Isso é bem mais rápido do que a sequência comum de primeiro escrever o código e só depois adicionar testes.
• Documentação e revisão de código em paralelo: assim que um colega de codificação termina uma parte, o colega de documentação já pode começar a escrever docstrings e atualizar o README enquanto o colega de revisão lê o diff em busca de bugs e problemas de estilo. Um não bloqueia o outro, e ambos produzem saídas para o líder combinar.

O limite está em conflitos de arquivo. Dois colegas escrevendo no mesmo arquivo ao mesmo tempo vão sobrescrever o trabalho um do outro, então o líder precisa dividir o trabalho por arquivo ou por módulo. Enquanto as partes estiverem bem separadas, você pode rodar quantos colegas em paralelo sua lista de tarefas comportar.

Claude Code Agent Teams para bases de código grandes

Bases de código grandes tornam as equipes de agentes algo essencial, não só “bom de ter”.

Um repositório com centenas ou milhares de arquivos não cabe em uma única janela de contexto. Uma sessão solo trabalhando em uma base grande gasta boa parte do orçamento apenas redescobrindo o código.

Com as Agent Teams, cada colega carrega apenas os arquivos relevantes para sua parte do trabalho, então a janela de contexto por colega fica pequena e focada. O time como um todo consegue raciocinar sobre o repositório inteiro, mas nenhuma sessão individual precisa fazê-lo.

Isso importa mais em três situações:

• Mudanças transversais: uma refatoração que toca dezenas de arquivos em vários módulos é difícil para uma sessão só sem perder o fio. Dividi-la por módulo e dar cada módulo a um colega mantém o escopo de cada um administrável.
• Auditorias no repositório inteiro: uma revisão de segurança ou auditoria de performance em uma base grande se beneficia de rodar vários colegas em paralelo, cada um olhando uma parte do repo. O líder então combina os achados em um relatório único.
• Projetos de longa duração: um projeto de várias semanas acumula contexto que uma única sessão não consegue manter. As Agent Teams permitem quebrar o trabalho em checkpoints, com cada checkpoint sob responsabilidade de um colega que não precisa lembrar tudo que veio antes.

Existe um custo.

Cada colega é uma sessão completa do Claude Code com sua própria janela de contexto, então o uso de tokens escala linearmente com o tamanho do time. Um time de quatro pessoas usa aproximadamente quatro vezes os tokens de uma sessão única para a mesma quantidade de trabalho. Algumas estimativas colocam até mais. A troca é reduzir o tempo de relógio e aumentar a profundidade por tópico, o que normalmente compensa quando o trabalho não é realista para uma única sessão concluir.

Quanto maior o projeto, mais você ganha com Agent Teams. Mas não exagere — para um pequeno bugfix, uma sessão única é mais barata e tão eficaz quanto.

Agent Teams e Claude Tag

As equipes de agentes não são o único lugar onde a Anthropic está repensando como a IA se encaixa nos fluxos de trabalho de times.

Claude Tag é um recurso separado que leva o Claude ao Slack como um participante organizacional compartilhado. Você marca @Claude em um canal, e o Claude assume tarefas usando as ferramentas da sua organização e o contexto do canal. Ele lembra o que foi discutido, faz follow-up por conta própria e trabalha sob a identidade da sua organização.

Os dois recursos resolvem problemas de coordenação diferentes. As Agent Teams coordenam várias sessões do Claude Code na máquina de um desenvolvedor para uma tarefa focada. O Claude Tag coordena uma identidade do Claude com um time de pessoas no Slack ao longo de dias e semanas. Mas a direção é a mesma: a IA está deixando de ser uma ferramenta usada isoladamente por uma pessoa para se tornar um participante que opera dentro do fluxo de trabalho existente do time.

Isso muda o que a IA precisa saber fazer bem.

Um assistente solo precisa ser um generalista forte, mas um sistema coordenado precisa ser um especialista forte que sabe planejar, repassar, pedir ajuda e manter alinhamento com outros agentes e humanos. As Agent Teams fazem isso para os fluxos de trabalho do Claude Code, e o Claude Tag torna isso visível no fluxo de trabalho do Slack.

Boas práticas para montar Agent Teams

Um bom setup de equipe de agentes depende principalmente da preparação inicial. A equipe em si é rápida, mas o tempo que você pode perder está em tarefas mal definidas e funções ambíguas.

Aqui vão algumas melhores práticas:

• Defina claramente as funções: cada colega deve ter um foco e um conjunto de arquivos sob sua responsabilidade. Ao criar um colega, diga exatamente pelo que ele é responsável, pelo que não é e com quais arquivos ou módulos pode trabalhar. Funções vagas produzem sobreposição e sobreposição gera conflitos de merge.

• Decomponha as tarefas antes de paralelizar: planeje primeiro, paralelize depois. Faça uma passada de planejamento para dividir o trabalho em tarefas com entradas, saídas e dependências claras, depois entregue o plano para a equipe executar. Planejar custa alguns milhares de tokens, mas uma equipe indo na direção errada pode custar centenas de milhares.

• Compartilhe padrões via CLAUDE.md: todo colega lê o arquivo CLAUDE.md no diretório de trabalho ao iniciar, então coloque ali suas convenções compartilhadas, incluindo estilo de código, organização de arquivos, abordagem de testes e formato das mensagens de commit.

• Crie checkpoints de revisão: acompanhe o progresso dos colegas, redirecione quem sair da rota e revise a saída do líder antes de aceitar. Para tarefas arriscadas, exija aprovação do plano antes de qualquer colega fazer mudanças. Isso força o colega a mostrar o plano primeiro e esperar o aval do líder.

• Limite o tamanho do time: comece com três a cinco colegas para a maioria dos fluxos. A partir daí, a sobrecarga de coordenação cresce mais rápido que o ganho de paralelismo.

• Evite conflitos de arquivo: divida o trabalho por arquivo ou por módulo para separar claramente cada colega. Dois colegas editando o mesmo arquivo vão sobrescrever as mudanças um do outro. Se uma tarefa realmente exigir vários colegas no mesmo arquivo, faça em sequência em vez de paralelizar.

• Pré-aprove operações comuns: prompts de permissão dos colegas sobem para o líder, e um time com quatro colegas pode gerar quatro vezes mais prompts. Configure sua lista permissions.allow antes de iniciar a equipe para que operações rotineiras como ler arquivos ou rodar testes não interrompam o trabalho.

• Combine modelo com função: rode o líder em um modelo mais forte como o Opus, já que coordenação se beneficia de raciocínio mais profundo, e os colegas em Sonnet para execução.

E a versão curta é: crie um plano de trabalho detalhado, faça o briefing do time como você faria com um grupo de desenvolvedores juniores, dê escopos claros e padrões compartilhados e confira o trabalho no fim. Quanto mais seu setup se parecer com o funcionamento de um time de engenharia real, melhor a Agent Team vai performar.

Claude Code Agent Team na prática

Aqui está o fluxo completo, de ponta a ponta.

Vou apresentar um exemplo pequeno: uma REST API “hello world” em FastAPI que lê uma mensagem de um banco SQLite, mais uma página HTML simples que chama a API e mostra o resultado. O app tem uma rota de backend, uma camada de banco, um frontend estático e um README, o que o torna perfeito para um time de quatro pessoas.

Ativar Agent Teams

As Agent Teams são um recurso experimental e vêm desativadas por padrão. Você as ativa definindo uma variável de ambiente, seja no seu shell ou no arquivo de configurações do Claude Code.

O arquivo de configurações fica em ~/.claude/settings.json. Abra e adicione:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Se você preferir não editar o arquivo, pode definir a variável no shell antes de iniciar o Claude Code:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Ambas as abordagens funcionam. Depois que a variável estiver definida, o Claude Code vai reconhecer prompts relacionados a equipes e iniciar a camada de coordenação quando você pedir.

Inicie o Claude Code e faça o briefing do time

Crie um diretório vazio para o projeto e inicie o Claude Code dentro dele:

mkdir hello-api && cd hello-api
claude

Agora faça o briefing da equipe. O prompt é linguagem natural, mas quanto mais específico você for sobre funções e fronteiras, melhor o desempenho. Aqui está o prompt para a API hello world:

Create an agent team to build a small "hello world" REST API.

The project is a FastAPI service that returns a greeting from a SQLite
database, plus a tiny HTML page that calls the API and shows the result.
- One teammate on the database: create app/db.py with a sqlite3 connection
  to a greetings.db file. Define a get_greeting() function that returns
  the message column from the first row. On import, create the table if
  it doesn't exist and seed it with "Hello, World!" if empty.
- One teammate on the backend: build a FastAPI app in app/main.py with
  a GET /greeting endpoint that calls get_greeting() from app/db.py.
  Add permissive CORS and mount the static/ directory at the root so
  the HTML page is served from the same origin.
- One teammate on the frontend: build static/index.html as a single page
  that fetches /greeting on load, shows a spinner while loading, displays
  the greeting in a centered card on success, and shows an error message
  on failure. Inline the CSS and JavaScript.
- One teammate on docs: write README.md with installation, run, and
  open-in-browser steps, plus an API reference table. Also create
  requirements.txt with fastapi and uvicorn[standard].
Use Sonnet for each teammate. Require plan approval before any teammate
makes changes.

Três pontos merecem destaque nesse prompt. As fronteiras por arquivo (app/db.py, app/main.py, static/index.html, README.md, requirements.txt) evitam sobreposição. A escolha de modelo (Sonnet) mantém os custos de tokens sob controle. E a plan approval força cada colega a mostrar seu plano antes de escrever código, o que cria um checkpoint para redirecionar quem entendeu o briefing de forma errada.

Veja a equipe em ação

Após enviar o prompt, o líder divide o trabalho em tarefas e inicia os colegas. Você verá um painel de agentes na parte inferior do terminal com uma linha por colega.

Agentes criados

Cada linha mostra o nome do colega e o que ele está fazendo no momento. O líder preenche a lista de tarefas compartilhada e atribui ou libera tarefas com base nas dependências. O colega de backend aguarda a camada de banco porque importa get_greeting() dela. O colega de docs espera até o restante estar suficientemente adiantado para descrever com precisão.

Você também pode ver a lista de tarefas. Pressione Ctrl+T para alternar a visualização. A lista mostra cada tarefa, seu status (pendente, em andamento ou concluída) e qual colega é o responsável.

Mova-se entre os colegas

Cada colega é uma sessão completa do Claude Code, e você pode conversar com qualquer um deles.

No painel de agentes, use as setas para cima e para baixo para selecionar um colega e pressione Enter para abrir sua transcrição. Agora você está na sessão daquele colega, e tudo o que digitar irá para ele, não para o líder. É assim que você fornece contexto extra ou redireciona a abordagem de um colega específico sem envolver o resto do time.

Pressione Esc para voltar ao líder.

Redirecione um colega que saiu da rota

Às vezes um colega entende o briefing de forma errada ou se perde fazendo algo que não deveria. Você percebe isso ao checar o plano durante a aprovação ou ao notar uma deriva no painel de agentes.

Se estiver usando aprovação de plano, o colega pausa após planejar e mostra a proposta antes de escrever qualquer arquivo. Veja como isso aparece para o agente de banco de dados:

Aprovação do agente de banco de dados

Você pode ler o esquema proposto e a abordagem, então aprovar ou rejeitar com feedback. Se o plano estiver faltando algo, responda com algo como "Use SQLAlchemy em vez de sqlite3 puro" e o colega vai refazer o plano.

Se notar um problema depois que um colega já começou a trabalhar, selecione-o no painel de agentes, pressione Enter para abrir sua sessão e envie uma mensagem. Você também pode pressionar x em um colega selecionado para pará-lo, ou pedir ao líder para iniciar um substituto se o atual estiver totalmente travado.

Encerrar e revisar

Quando todos os colegas finalizam suas tarefas, o líder retorna com um breve resumo e os comandos necessários para rodar o projeto.

Instruções finais do líder

Neste ponto, você revisa o trabalho. Pode abrir os arquivos gerados no editor e ler os diffs.

O arquivo app/main.py gerado

Você também pode inspecionar o banco criado e populado pelo agente de banco de dados.

A tabela greetings

Depois, instale as dependências, rode uvicorn app.main:app --reload e abra http://localhost:8000 no navegador para confirmar que o stack completo funciona de ponta a ponta.

App final

Se quiser mudanças, diga ao líder o que ajustar — ele mesmo corrige ou inicia um novo colega para cuidar disso. Quando você estiver satisfeito com o resultado, pode pedir ao líder para fazer o commit das alterações. O líder encerra os colegas quando a sessão termina e a configuração da equipe é limpa.

É isso!

Conclusão

As Claude Code Agent Teams se resumem a duas coisas: especialização e coordenação. Cada colega tem sua parte do trabalho e sua própria janela de contexto. O líder mantém todos alinhados, a lista de tarefas mantém o time sincronizado e as mensagens diretas evitam que você precise repassar informações entre sessões.

No panorama geral, o desenvolvimento assistido por IA está saindo do modo solo para o coordenado. As Agent Teams são como essa mudança aparece no Claude Code hoje, e o mesmo padrão está surgindo no Claude Tag para Slack. Quem se acostumar com isso agora vai gastar menos tempo lidando com limites de contexto e mais tempo entregando features de verdade.

Quer tirar uma certificação em IA generativa? Confira as melhores certificações em IA generativa de 2026, com cursos indicados, dicas de preparação e perguntas frequentes.