Transcript
00:00:00Existe um novo termo circulando e você talvez já tenha ouvido falar. Chama-se loop engineering
00:00:04e, como todo termo da moda, todos estão falando como se fosse algo novo. Não é,
00:00:09mas quando você o combina com um agente sempre ativo como o Hermes, deixa de ser hype. A maioria das pessoas
00:00:13que tenta configurar isso acerta no loop, mas esquece o que realmente
00:00:17faz funcionar. Se você já sabe que existem dois tipos de loops, há uma configuração específica dentro
00:00:22de um deles que quase ninguém está fazendo. Quando você vê, a forma como pensa em criar com agentes
00:00:27muda completamente. Ao final deste vídeo, você entenderá exatamente o que é e terá isso
00:00:31rodando no Hermes e até no Claude Code sem precisar intervir.
00:00:36Com o loop engineering, a ideia central é simples. Você deixa de ser a pessoa que escreve o prompt que conduz o agente
00:00:41e, em vez disso, deixa o agente se conduzir. Mas, para ver por que é uma mudança de paradigma,
00:00:46você precisa comparar com o que veio antes. A habilidade que importava era o prompt engineering,
00:00:51onde todo o foco ia para escrever a série certa de instruções para guiar o agente de código adequadamente, mas o loop engineering
00:00:56inverte isso. Em vez de escrever o prompt você mesmo, você projeta o sistema que faz o
00:01:01prompt engineering para você e conduz o agente sozinho; então o foco se desloca da criação de
00:01:05instruções para o design de sistemas que rodam sozinhos. Tudo isso começou quando o criador
00:01:10do OpenClaw disse que você não deveria mais fazer prompts para seus agentes de código e que deveria focar
00:01:15em projetar loops que façam prompts para você, e ele não é o único. Boris, que é o criador do
00:01:20Claude Code, também fez a mesma afirmação na conferência anual de desenvolvedores da Anthropic, onde disse que
00:01:25ele não faz mais prompts para o Claude. Ele tem loops rodando que fazem os prompts para o Claude, e ele descobre sozinho
00:01:30o que precisa ser feito. Então, a questão é: como você começa com eles? Tudo se resume a
00:01:34quão bem você consegue configurar os sistemas onde você não precisa se preocupar em fazer prompts para o agente.
00:01:39Você define o que precisa e o agente faz o resto. É exatamente para onde o desenvolvimento com IA está
00:01:45indo. Antes de entrarmos em como construí-los, você precisa entender claramente o que é um loop. Um loop é
00:01:50basicamente um processo onde você define o objetivo final e o agente descobre os passos para alcançá-lo por conta
00:01:56própria. Ele se corrige ao longo do caminho e contorna problemas até atingir o objetivo que você definiu.
00:02:01Alguns meses atrás, antes dos modelos serem capazes o suficiente para sustentar tarefas longas, isso não era possível. Se você
00:02:06precisasse criar um aplicativo, você faria um prompt para o agente, monitoraria o que ele estava fazendo, verificaria a saída você mesmo,
00:02:11encontraria os problemas e faria um novo prompt para corrigi-los. Você era o loop. Você era a parte que fazia a
00:02:16verificação de erros e a correção de rumo entre cada passo. É assim que o desenvolvimento ainda parece para a maioria
00:02:20das pessoas, e é exatamente isso que o loop engineering está prestes a tirar das suas mãos. Agora, isso pode
00:02:25parecer um conceito novo, mas loops já existem há um tempo. Cron jobs são
00:02:30um bom exemplo de um loop que você provavelmente já viu. São apenas tarefas agendadas para rodar repetidamente
00:02:35e automaticamente, sem você precisar acioná-las a cada vez. A única diferença real é que um
00:02:39cron job roda em um horário fixo. Então, com loops, o trabalho deixa de ser sobre escrever o prompt.
00:02:44O desempenho do seu agente em uma tarefa se resume a quão bem você define o objetivo final. Para alguns de vocês,
00:02:49esse processo soará muito como aprendizado por reforço. Se você nunca ouviu falar, aprendizado por reforço
00:02:54é basicamente uma forma de treinar um modelo onde você não mostra as respostas certas. Em vez disso, você apenas diz
00:02:59a ele quando ele foi bem e quando não foi, e ele gradualmente descobre como melhorar sozinho.
00:03:04O modelo encontra o caminho certo tentando coisas diferentes. Ele recebe um sinal positivo quando se move na
00:03:09direção certa e um negativo quando não. A mesma ideia se aplica aqui, exceto que o modelo em si
00:03:14não é o que está sendo treinado. Em vez disso, o agente está trabalhando para concluir a tarefa que você deseja,
00:03:19iterando nela da mesma forma que um modelo melhoraria durante o treinamento. Se falhar, o loop que você
00:03:23colocou no agente não marca a tarefa como concluída. Ele tenta novamente, continua e se corrige até
00:03:28atingir o objetivo que você definiu. Agora, depois de ouvir tudo isso, você pode se perguntar o que sobra
00:03:33para você fazer se tudo está se tornando autônomo. Mas seu papel não diminui, ele se torna mais importante.
00:03:38Porque é seu conhecimento de domínio e experiência que definem o objetivo final em primeiro lugar,
00:03:43e isso acaba aparecendo em tudo o que você cria e entrega. É exatamente por isso que o movimento em direção a loops autônomos
00:03:48está apenas acelerando, e isso aparece em cada novo recurso que é lançado agora. O Fable 5 é o
00:03:54exemplo mais claro até agora. A Anthropic o lançou, embora estivessem pedindo uma desaceleração no desenvolvimento
00:03:59da IA, porque os modelos estão se tornando capazes em um ritmo difícil de acompanhar. E após
00:04:03liberá-lo por um tempo, eles até o removeram. Eles o construíram para tarefas longas e complexas,
00:04:08e ele funciona melhor quanto mais longa e complexa a tarefa se torna, o que é basicamente o oposto de como os modelos
00:04:13costumavam funcionar. Essa mudança realmente começou com o Opus 4.5. Quando ele foi lançado, tarefas de longa duração ficaram
00:04:19dramaticamente melhores. E você não precisava mais configurar agentes com arreios cuidadosamente guiados,
00:04:23basicamente configurações estruturadas que guiam o agente passo a passo. O foco mudou para
00:04:28preparar o projeto para rodar a longo prazo porque os modelos agora são capazes o suficiente para
00:04:33lidar com as coisas por conta própria sem muito manejo passo a passo. Mas o loop não é a única coisa que
00:04:38importa. Você também precisa estruturar seu projeto de uma maneira que permita ao agente trabalhar sozinho por um
00:04:43longo tempo sem que você precise intervir. Por isso, muitas pessoas têm criado e disponibilizado sistemas de código aberto
00:04:48exatamente para esse tipo de configuração. O loop RALF foi um dos primeiros. Ele funcionava definindo o objetivo final
00:04:53e garantindo que o agente não se desviasse dele. Isso era feito por meio de ganchos, que são basicamente
00:04:57scripts que rodam automaticamente quando algo específico acontece. Então, este script evita estritamente que o agente marque
00:05:03uma tarefa como concluída a menos que ela tenha realmente cumprido a condição. Mas ganchos são rígidos, então o Claude introduziu seu próprio comando de objetivo,
00:05:09que faz a mesma coisa, mas com mais flexibilidade. Em vez de uma verificação codificada, ele permite que
00:05:14outro modelo decida se a tarefa foi realmente concluída. Cobrimos o Goal Buddy 2, que construiu sobre
00:05:19isso fazendo com que o agente rastreasse seu progresso em arquivos locais e definisse exatamente o que “concluído” parece
00:05:24antes mesmo de começar, para que ele sempre saiba em que está trabalhando. O agente Hermes e o OpenClaw foram ambos
00:05:29construídos sobre a mesma filosofia. Eles retiram você da cena inteiramente e permitem que o agente cuide de tudo
00:05:35por conta própria. Agora, se você quiser construir esses loops, temos um sistema simples de cinco etapas para você e, como
00:05:40existem dois tipos de loops, algumas dessas etapas funcionam um pouco diferente, mas vamos entrar nos dois tipos
00:05:45mais tarde. Por enquanto, começaremos no Claude Code e, mais adiante no vídeo, veremos como fazer o mesmo
00:05:49no agente Hermes. O primeiro passo é verificar em que estado o projeto está. A partir disso, o modelo
00:05:54decide qual deve ser a próxima ação. Então ele age sobre essa decisão, e é aqui que o trabalho real
00:05:59acontece. O agente chama ferramentas, escreve em arquivos e roda comandos para concluir a tarefa. Uma vez que
00:06:04isso termina, ele reúne feedback para ver o que realmente aconteceu e, com base nisso, decide se a
00:06:09tarefa está concluída ou não. É aqui também que a diferença entre o prompt engineering e o loop engineering se torna
00:06:14óbvia. Com o prompt engineering, você está controlando apenas a etapa de decisão, enquanto o loop engineering
00:06:19cuida de todas as cinco juntas. Construir um loop que funcione bem significa acertar algumas coisas e
00:06:24cada uma está lá por causa de um problema específico que resolve. O primeiro é o gerenciamento de contexto. Você presta
00:06:29atenção ao que entra no contexto em cada turno, porque é isso que determina o que o agente
00:06:34realmente sabe a qualquer momento. Você não pode depender apenas do contexto do chat, mesmo com janelas de contexto
00:06:39tão grandes quanto um milhão de tokens, basicamente o quanto o agente pode manter na memória de uma vez, porque conforme a
00:06:44conversa cresce, seu prompt de sistema e instruções ficam enterrados sob as saídas recentes das ferramentas. A atenção do agente
00:06:50naturalmente é atraída para o que é mais recente, então as coisas importantes se perdem. É por isso que
00:06:55gerenciar o contexto importa tanto. A próxima coisa a acertar é a qualidade do feedback. O feedback é o que diz
00:07:00ao agente como ele se saiu, e é um dos sinais mais importantes em todo o sistema. Ele pode assumir muitas
00:07:05formas, como o resultado de um teste ou uma captura de tela da interface que ele acabou de construir, e qualquer forma que assuma,
00:07:11é isso que o agente lê para descobrir seu próximo movimento. Os portões de verificação são o que transformam esse feedback
00:07:16em um veredito claro. Eles são os pontos de checagem que dizem ao agente se uma tarefa está realmente concluída ou
00:07:21não. Você também precisa de uma condição de término, basicamente uma regra que diz ao loop quando parar, e esta
00:07:26tem que ser definida explicitamente, caso contrário, o agente desiste cedo demais ou continua sem fazer progresso
00:07:31real. O que as pessoas mais ignoram é o tratamento de erros. Você tem que soletrar o que o modelo
00:07:36deve fazer quando uma chamada de ferramenta falha, para que o sistema lide com isso de forma limpa, em vez de deixar as coisas
00:07:41em um estado quebrado que só cria mais problemas. E, finalmente, você precisa gerenciar o estado entre os turnos,
00:07:46basicamente acompanhar onde a tarefa está à medida que a conversa cresce. A janela de contexto não pode manter
00:07:51tudo para sempre, então você se apoia em arquivos externos que rastreiam informações para o agente e permitem que ele continue
00:07:57trabalhando sem perder o fio da meada. Uma coisa a ter em mente, no entanto, já que você está entregando o trabalho de
00:08:01descobrir o caminho para o modelo em vez de fazê-lo você mesmo, loops ficam caros em tokens,
00:08:06então você precisa ser deliberado sobre quando realmente usá-los. Quanto mais tokens um loop pode
00:08:11trabalhar, melhor ele tende a lidar com a tarefa. Mas antes de avançarmos, vamos ter uma palavra do
00:08:15nosso patrocinador, Scrimba. A maioria dos cursos de Python são apenas alguém falando sobre slides. O Scrimba é diferente,
00:08:21o player de vídeo deles é o editor de código, então você pode pausar a qualquer momento, editar o código do instrutor diretamente,
00:08:26e ver o que acontece. Sem troca de abas, sem copiar e colar, apenas código prático desde o início.
00:08:31O novo curso de “Aprenda Python” deles chamou minha atenção porque, em vez de exercícios aleatórios, você realmente
00:08:37constrói algo real. Desde o primeiro dia, você está criando o “PayUp”, um aplicativo de divisão de despesas totalmente funcional,
00:08:42e cada conceito é aplicado imediatamente. Você começa do zero absoluto, sem necessidade de conhecimento prévio de Python,
00:08:47e trabalha com variáveis, strings, captura de entrada do usuário, operadores aritméticos, conversão de tipo,
00:08:53limpeza de dados e formatação de números, tudo construindo recursos para o aplicativo. Ao final,
00:08:57você construiu um projeto funcional do zero que prova que você realmente sabe Python. Esta é apenas parte
00:09:02de várias que estarão disponíveis nas próximas semanas, e atualmente, é totalmente gratuito para
00:09:07acessar. Comece hoje com os cursos gratuitos deles, e nossos usuários receberão um desconto extra de 20% nos planos
00:09:12pro. Então, clique no link no comentário fixado, ou escaneie o código QR, e comece a construir hoje.
00:09:18Como mencionamos, existem dois tipos de loops. O primeiro chama-se loop determinístico. Você o usa
00:09:23para tarefas que têm uma definição clara do que “concluído” realmente parece, isso pode ser testes passando,
00:09:28código compilando com sucesso, ou qualquer coisa assim. Esses loops são bastante diretos para trabalhar
00:09:33em direção, porque o objetivo final é claro, então o modelo sabe exatamente o que precisa fazer antes de poder chamar
00:09:38a tarefa de concluída. Como o Hermes está sempre rodando, é um agente muito bom para implementar esse loop. Nós
00:09:43criamos vários fluxos de trabalho nele antes, e mostramos em nosso vídeo anterior como ele lida com muito do nosso trabalho
00:09:49por conta própria. O núcleo de um loop determinístico é a definição clara do objetivo final, e para os aplicativos
00:09:54que você hospedou, essa definição são seus casos de teste. Então você pode apontar o agente Hermes para qualquer aplicativo que você
00:09:59implantou com casos de teste e tê-lo monitorando para você. Agora, se uma mudança ou um commit acabar quebrando
00:10:04a produção, você pode configurar uma automação no Hermes para capturá-la. A razão pela qual funciona melhor aqui é que ele
00:10:09vem com o recurso de habilidades auto-evolutivas, então ele cria e evolui automaticamente habilidades com base no
00:10:14fluxo de trabalho, o que mantém a saúde do aplicativo em dia. Depois de configurar essa automação de monitoramento, você
00:10:18pode pedir a ele para iniciar o Claude Code em modo não interativo, basicamente rodando-o sozinho sem você
00:10:23ter que guiá-lo e fazê-lo corrigir problemas em um loop até que todos os casos de teste passem. O que ele faz
00:10:28a partir daí é configurar o fluxo de trabalho de automação e carregar habilidades como a habilidade de desenvolvimento orientado a sub-agentes
00:10:34e a habilidade de fluxo de trabalho de PR do GitHub, que lhe dizem como gerenciar o aplicativo no GitHub. Ele primeiro identifica os
00:10:39problemas que estavam quebrando a produção, então inicia o Claude Code em modo não interativo, que assume
00:10:44os testes e faz o commit das alterações assim que todos passam. Depois de ter executado cada teste e corrigido o que
00:10:50estava causando falha na produção, ele usa a CLI do GitHub para fazer o commit das alterações. O aplicativo acaba rodando
00:10:55sem falhas porque ele confirmou que todas as verificações para uma implantação bem-sucedida estão no lugar.
00:11:00Se você gosta dessas análises, inscreva-se no canal, clique no sino de notificação e aperte o botão de hype
00:11:05também. No canal, postamos conteúdo que ajuda você a aprender novas maneiras de otimizar diferentes
00:11:10processos em diferentes negócios com IA. Seu apoio, seja se inscrevendo, o sino de notificação
00:11:15ou o botão de hype, ajuda-nos a criar mais conteúdo como este e alcançar mais pessoas. Significa muito para nós.
00:11:21Agora, o segundo tipo é o loop não determinístico, e estas são tarefas onde você não pode simplesmente definir uma regra clara
00:11:26para verificar se o trabalho está feito da maneira que você pode com loops determinísticos. Por causa disso,
00:11:31não há uma maneira limpa de verificar o resultado. Estas são as coisas que nós, como humanos, podemos olhar
00:11:36e julgar por nós mesmos, como construir uma interface ou implementar um recurso que precisa de uma decisão.
00:11:41Então, quando você está trabalhando com um loop não determinístico, o fluxo de trabalho é diferente. Se você está aplicando
00:11:46IA para interface, você já sabe que ela tende a cair nos mesmos padrões o tempo todo. É por isso que nós
00:11:51criamos uma habilidade chamada “Detetor de Slop de IA”, que mantém todas as instruções sobre como evitar o “slop” de IA e lista
00:11:57os padrões que realmente o revelam. E a razão pela qual estamos usando o Hermes novamente são as habilidades
00:12:02auto-evolutivas. Se ainda encontrarmos slop de IA na interface após rodar a habilidade, a habilidade pode se atualizar para
00:12:07incorporar esse feedback diretamente, e é exatamente por isso que configuramos esse fluxo de trabalho no Hermes. Então, pedimos ao
00:12:13Hermes para usar a habilidade e verificar se a interface tem algum desses padrões. Se tiver, ele os corrige
00:12:18e inicia o Claude Code em modo não interativo para rodar a habilidade e continuar corrigindo o que encontrar até
00:12:23que não reste nada para corrigir. Outro benefício que obtemos do Hermes é que o modelo revisando o trabalho é
00:12:28diferente daquele que o está construindo. Estávamos usando os modelos GPT, que são conhecidos por estarem entre os melhores para
00:12:33revisão de código, então os modelos Claude se tornam o construtor e o outro agente se torna o verificador. É isso que
00:12:38completa o loop adversarial onde os dois verificam o trabalho um do outro. Uma vez que esse loop rodou, ele gerou uma
00:12:43interface muito melhor do que a saída genérica que os modelos Opus estão produzindo hoje em dia. E se você ainda notar algum sinal de slop de IA
00:12:49na interface após o término do loop do agente, você pode simplesmente mencionar e ele atualizará a habilidade para
00:12:54você, fortalecendo o verificador que você já tem. Nós aprimoramos essa habilidade para corresponder a múltiplos padrões de slop de IA
00:12:59que nós e o Hermes identificamos coletivamente. Se você quiser usar essa habilidade, pode obtê-la em nossa
00:13:04comunidade AI Labs Pro. O link estará na descrição. Isso nos leva ao final deste vídeo.
00:13:09Se você gostaria de apoiar o canal e nos ajudar a continuar fazendo vídeos como este, você pode fazê-lo usando o
00:13:14botão de “super thanks” abaixo. Como sempre, obrigado por assistir e vejo você no próximo.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video