00:00:00O Opus 4.6 foi o único upgrade da Anthropic?
00:00:03Você já conhece os subagentes, onde cada agente opera como uma entidade individual com
00:00:07sua própria janela de contexto.
00:00:09Mas esses subagentes falhavam quando havia uma tarefa que exigia coordenação entre eles.
00:00:13Nesses casos, o orquestrador tinha que intervir, pegando as respostas de um agente e delegando-as
00:00:17a outro, ou os agentes tinham que confiar em notas na pasta do projeto.
00:00:21Devido a essa falha de comunicação, tarefas simples acabavam se tornando complicadas demais.
00:00:25Para resolver isso, a Anthropic lançou um novo upgrade para os subagentes e os chamou de Agent-Teams.
00:00:30Eles foram lançados junto com o Opus 4.6.
00:00:33Embora este ainda seja um recurso experimental, nós o implementamos em múltiplos fluxos de trabalho,
00:00:37e a maior melhoria foi que o tempo de execução dessas tarefas foi drasticamente reduzido.
00:00:41Mas é experimental por um motivo e ainda tem algumas arestas, e também encontramos pequenas
00:00:44correções para esses problemas.
00:00:47Agent-Teams é a ideia de ter múltiplas instâncias do ClodCode trabalhando juntas.
00:00:51Cada membro da equipe trabalha em tarefas isoladas e possui uma gestão centralizada controlada
00:00:55por um único agente.
00:00:56Agora, você pode pensar que isso soa muito parecido com os subagentes já existentes do Clod, porque
00:01:00ambos rodam em paralelo e dividem tarefas, mas eles não são a mesma coisa.
00:01:03Isso porque o Agent-Teams resolveu o principal problema da estrutura de subagentes.
00:01:08Os subagentes não conseguem se comunicar entre si e precisam depender do agente orquestrador
00:01:12para atuar como um meio de comunicação entre eles.
00:01:15Os membros da equipe, por outro lado, conseguem se comunicar uns com os outros.
00:01:18A ideia central do Agent-Teams é ter várias sessões do ClodCode colaborando.
00:01:22Uma sessão atua como líder da equipe, coordenando o trabalho, atribuindo tarefas e sintetizando resultados,
00:01:27enquanto os companheiros de equipe trabalham de forma independente em suas próprias janelas de contexto.
00:01:31Os subagentes têm sua própria janela de contexto e reportam o resultado de volta para quem os chamou.
00:01:34Mas para as equipes, funciona de forma diferente.
00:01:36Cada membro da equipe de agentes é uma sessão de terminal totalmente independente.
00:01:40Eles não são restritos ou coordenados por um orquestrador que apenas divide tarefas.
00:01:43Em vez disso, essas sessões de terminal são abertas e fechadas pelo líder principal da equipe.
00:01:47Eles são capazes de trabalhar em tarefas que exigem discussão e colaboração entre agentes
00:01:52devido à sua capacidade de comunicação.
00:01:54Portanto, uma equipe de agentes consiste essencialmente em um líder e companheiros de equipe.
00:01:57O líder da equipe é o agente principal que cria a equipe e coordena seu trabalho.
00:02:01Os companheiros de equipe são os trabalhadores que realmente executam as tarefas.
00:02:03Cada companheiro recebe uma lista de tarefas, que é uma lista compartilhada de itens.
00:02:07Cada membro identifica o que precisa fazer nessa lista e executa a tarefa.
00:02:10Para se comunicarem, eles também possuem uma caixa de correio compartilhada que permite o envio de mensagens.
00:02:15Agora, a questão era como isso realmente funciona se cada membro da equipe é independente.
00:02:19Como eles sabem o que os outros membros estão fazendo?
00:02:21Isso funciona porque toda a informação sobre a equipe, os membros e as tarefas em que cada um
00:02:26está trabalhando é armazenada localmente na pasta ".claud" e identificada pelo nome da tarefa.
00:02:30Este recurso ainda é experimental e vem desativado por padrão, então haverá alguns bugs
00:02:34no manuseio dos companheiros de equipe durante esta fase.
00:02:36Para testá-lo, tivemos que ativá-lo manualmente.
00:02:38Fizemos isso configurando a flag da CLI do claud code para equipes de agentes experimentais como 1.
00:02:43Com essa flag da CLI ativada, as equipes de agentes ficaram disponíveis para uso em futuras sessões.
00:02:47Com essa flag habilitada, pudemos acessar o recurso de equipes no claud code.
00:02:51Como é um recurso experimental, precisamos usar uma terminologia específica que diga ao
00:02:55claud que queremos usar uma equipe de agentes para determinado trabalho.
00:02:58Nossa equipe começou a usar esse recurso para paralelizar a revisão de código, permitindo que falhas
00:03:02fossem identificadas e corrigidas ao mesmo tempo.
00:03:04Para isso, pedimos ao claud para usar um membro da equipe para encontrar problemas no código e
00:03:08outro para corrigir os problemas identificados pelo primeiro membro.
00:03:11Tivemos que ser detalhados no prompt para fazê-lo seguir a direção correta.
00:03:15Se subagentes estivessem lidando com isso, eles estariam escrevendo um relatório em algum arquivo
00:03:19físico para que os outros agentes soubessem o que corrigir.
00:03:21Mas aqui, queríamos acelerar o processo de revisão permitindo que isso acontecesse sem o custo
00:03:26adicional de gravar em um arquivo local.
00:03:27Quando demos o prompt ao claud code, os membros da equipe surgiram, cada um controlado pelo
00:03:31líder da equipe.
00:03:32O agente líder deu o prompt para os agentes individuais, informando qual tarefa realizar.
00:03:36O primeiro agente de revisão começou a trabalhar e, após analisar a tarefa, compartilhou mensagens
00:03:40com o corretor de código, bug por bug.
00:03:42Este agente estava priorizando problemas críticos de segurança e, assim que o corretor de código recebeu as
00:03:47mensagens do revisor, começou a implementar as correções enquanto o revisor
00:03:51continuava procurando por mais problemas.
00:03:53Da mesma forma, eles continuaram conversando entre si e relatando as mudanças que eram implementadas.
00:03:57Assim que os problemas críticos foram concluídos, os dois agentes passaram para a correção
00:04:01dos problemas de prioridade média.
00:04:02A revisão e a correção do código aconteciam simultaneamente, o que poupou muito tempo.
00:04:06O bom disso é que você também pode atribuir ou modificar qualquer tarefa para um membro da equipe.
00:04:10Com isso ativado, você pode direcionar o trabalho daquele membro específico da equipe.
00:04:14Assim que os agentes terminavam o trabalho, o controle voltava para o agente principal, que é
00:04:18responsável por garantir que as mudanças necessárias foram feitas corretamente e por encerrar
00:04:22esses agentes de forma graciosa, garantindo que sua saída não cause erros futuros.
00:04:26Você provavelmente notou que construímos muita coisa nestes vídeos.
00:04:28Todos os prompts, o código, os templates, sabe, as coisas que você normalmente teria que
00:04:32pausar e copiar da tela, tudo está em nossa comunidade, neste vídeo e em todos os vídeos
00:04:36anteriores também.
00:04:37Links na descrição.
00:04:38Encontrar e corrigir falhas em escala é ótimo, mas há casos frequentes em que você tem problemas
00:04:43e simplesmente não consegue descobrir o que os está causando.
00:04:45Nesses casos, podemos usar uma equipe de agentes para testar múltiplas perspectivas do mesmo app
00:04:49e trabalhar progressivamente em direção ao bug.
00:04:51Dessa forma, os membros da equipe podem comunicar suas descobertas uns aos outros e avançar juntos.
00:04:55Pedimos ao Claude para encontrar um bug na base de código e especificamos o uso de vários membros,
00:04:59permitindo que abordassem o problema de diferentes perspectivas.
00:05:02Ele então gerou quatro subagentes, cada um focado em uma perspectiva diferente do mesmo app.
00:05:06Eles receberam prompts similares do líder da equipe e investigaram os erros baseados em
00:05:09seu aspecto específico da aplicação, enquanto o líder principal esperava que terminassem e
00:05:14depois analisava as descobertas de suas pesquisas.
00:05:16Sem as equipes, teríamos um único processo, o que teria levado muito mais tempo.
00:05:19Mas com esses agentes, o processo foi muito mais rápido.
00:05:22A investigação terminou rápido, e toda a pesquisa dos agentes foi feita em aproximadamente
00:05:272 a 3 minutos, o que é uma melhoria significativa comparada à verificação linear, que
00:05:31facilmente levaria de 5 a 10 minutos.
00:05:33Algo para ficar atento é que essa abordagem consome muitos tokens, pois cada agente tem
00:05:37sua própria janela de contexto, então precisamos ter cuidado com isso.
00:05:40Assim que os agentes retornaram seus resultados e foram encerrados, o líder da equipe também
00:05:45verificou os resultados fazendo sua própria checagem.
00:05:46Todos os quatro agentes convergiram para o mesmo bug e apontaram corretamente o problema com
00:05:50um "stale closure" no useEffect.
00:05:52Essa parte exata foi sinalizada por todos os quatro agentes.
00:05:54Além disso, se você está gostando do nosso conteúdo, considere apertar o botão de "hype", pois nos
00:05:59ajuda a criar mais conteúdos assim e a alcançar mais pessoas.
00:06:02Essa estrutura de agentes mudou a forma como trabalhamos em tarefas de longo prazo, pois com suas habilidades,
00:06:07os agentes não precisam depender apenas de documentar seu progresso.
00:06:10Com equipes de agentes, podemos lidar com diferentes aspectos de uma aplicação em paralelo e
00:06:14também ter um membro dedicado exclusivamente à pesquisa.
00:06:16Quando demos o prompt ao Claude, ele gerou 6 agentes.
00:06:19Dois estavam trabalhando em pesquisa e lançando as bases, enquanto o restante estava
00:06:23construindo as páginas.
00:06:24Os agentes construtores foram bloqueados pelo agente que lançava as bases, pois ele era responsável
00:06:28por instalar os pacotes necessários e preparar o ambiente com todas as dependências.
00:06:32Cada agente recebeu um prompt específico definindo seu trabalho.
00:06:35Os agentes bloqueados ficaram esperando pelo sinal de desbloqueio do líder da equipe.
00:06:38Uma vez que a pesquisa e as bases foram concluídas, os agentes restantes foram desbloqueados e
00:06:43começaram a implementar suas respectivas partes da aplicação lado a lado.
00:06:46Eles continuaram se comunicando entre si para garantir a consistência entre cada componente.
00:06:49O líder da equipe continuou coordenando com os agentes e, quando qualquer agente terminava, o líder
00:06:53enviava uma mensagem de encerramento, lidando com sua saída de forma graciosa.
00:06:57Todo esse processo consumiu cerca de 170 mil tokens da janela de contexto, mas no fim,
00:07:02conseguimos construir o app exatamente como queríamos, tudo a partir de um único prompt.
00:07:05Como mencionamos no vídeo, quando nossa equipe estava testando isso, descobrimos várias
00:07:09maneiras de fazer as equipes de agentes funcionarem melhor para nós, e essas práticas recomendadas
00:07:13estão disponíveis no AI Labs Pro para você mesmo testar.
00:07:16A primeira recomendação é geralmente aplicável a todos os agentes, não limitada apenas ao
00:07:20recurso de equipes de agentes.
00:07:21Você precisa especificar explicitamente o escopo onde o agente deve trabalhar.
00:07:25Você pode fazer isso definindo no prompt, especificando quais arquivos procurar
00:07:29para realizar a tarefa, ou criando documentos no projeto contendo as tarefas
00:07:33individuais, como fizemos em nosso fluxo de trabalho, onde preparamos um documento de tarefa
00:07:38adequado para cada atribuição para que o agente possa trabalhar de forma independente e no escopo certo.
00:07:41Outra coisa a se manter em mente é que cada um desses agentes deve trabalhar em tarefas
00:07:45independentes entre si, pois se editarem o mesmo arquivo ao mesmo tempo,
00:07:49criariam um conflito e poderiam acabar sobrescrevendo o conteúdo.
00:07:52Além disso, houve vezes em que o agente principal ficava impaciente
00:07:56se algum agente demorasse para concluir uma tarefa e começava a implementar a tarefa ele mesmo
00:08:00em vez de deixar os companheiros terminarem, então é importante lembrar o agente principal
00:08:04de esperar que os companheiros concluam antes de prosseguir.
00:08:06Você também precisa dimensionar as tarefas adequadamente.
00:08:08Se atribuir tarefas pequenas demais, isso cria um custo excessivo de coordenação.
00:08:11Se as tarefas forem grandes demais, aumenta o risco de esforço desperdiçado, então as tarefas
00:08:16precisam ser equilibradas e autocontidas.
00:08:17Finalmente, você precisa monitorar o trabalho dos agentes.
00:08:19Se algum agente não estiver rendendo o esperado, você pode interromper sua execução e dar
00:08:23novas instruções sobre o que ele deve fazer.
00:08:25Seguir essas práticas torna o uso desse recurso experimental muito mais eficaz.
00:08:29Isso nos traz ao fim deste vídeo.
00:08:31Se você quiser apoiar o canal e nos ajudar a continuar fazendo vídeos como este, você
00:08:35pode fazer isso usando o botão "Valeu demais" abaixo.
00:08:38Como sempre, obrigado por assistir e nos vemos no próximo.