12 - Agentes de fator Como chegamos até aqui: uma breve história do software

Versão detalhada: como chegamos a esse ponto

Você não precisa me ouvir.

Quer você seja um novato em inteligências ou um veterano rabugento como eu, vou tentar convencê-lo a abandonar a maioria de suas visões pré-existentes sobre inteligências de IA, dar um passo atrás e repensá-las a partir dos primeiros princípios. (Caso você não tenha visto o lançamento dos recursos da API da OpenAI há algumas semanas, aqui está o spoiler: empurrar uma lógica corporal mais inteligente para trás da API não é a direção certa)

Corpos inteligentes como software e uma breve história deles

Vamos falar sobre como chegamos até aqui.

60 anos atrás

Falaremos muito sobre gráficos direcionados (DGs) e seus amigos acíclicos, os gráficos acíclicos direcionados (DAGs). A primeira coisa que quero destacar é que ...... bem ...... software é um gráfico direcionado. Há um motivo pelo qual costumávamos usar fluxogramas para representar programas.

20 anos atrás

Há cerca de 20 anos, começamos a ver a popularização dos orquestradores de DAG. Estamos falando de coisas como Fluxo de arePrefeito Essas ferramentas clássicas, bem como alguns predecessores e algumas ferramentas mais recentes, como (dagstereinggestemoinho de vento). Eles seguem o mesmo padrão de gráfico com os benefícios adicionais de observabilidade, modularidade, novas tentativas e gerenciamento.

10-15 anos atrás

Começamos a ver modelos de aprendizado de máquina espalhados em DAGs quando eles começaram a se tornar bons o suficiente para serem usados. Você pode pensar em etapas como "resumir o texto desta coluna em uma nova coluna" ou "classificar perguntas de suporte por gravidade ou sentimento".

Mas, no final das contas, ainda é essencialmente o mesmo software determinístico de sempre.

Perspectivas futuras para corpos inteligentes

Não sou o primeiro, mas a maior coisa que aprendi quando comecei a aprender sobre inteligências é que você pode abandonar o DAG. Os engenheiros de software não precisam mais escrever código para cada etapa e caso extremo, você pode dar às inteligências um objetivo e um conjunto de transições:

Em seguida, deixe o modelo de linguagem grande tomar decisões em tempo real para descobrir o caminho.

A perspectiva aqui é que você escreva menos software e simplesmente forneça "bordas" ao gráfico do Big Language Model e deixe que ele encontre "nós" por conta própria. Você pode se recuperar de bugs, pode escrever menos código e pode descobrir que o modelo de linguagem grande encontra novas soluções para os problemas.

Inteligência como um ciclo

Em outras palavras, você tem um ciclo de três etapas:

1. O Big Language Model determina a próxima etapa do fluxo de trabalho, gerando JSON estruturado ("chamadas de ferramenta")
2. Chamadas de ferramentas de execução de código determinístico
3. O resultado é anexado à janela de contexto
4. Repita esse processo até que a próxima etapa seja identificada como "Finish" (Concluir).

initial_event = {"message": "..."}
context = [initial_event]
while True:
next_step = await llm.determine_next_step(context)
context.append(next_step)
if (next_step.intent === "done"):
return next_step.final_answer
result = await execute_step(next_step)
context.append(result)

Nosso contexto inicial é apenas o evento de inicialização (talvez uma mensagem do usuário, um acionador de tarefa cron, um webhook etc.) e, em seguida, deixamos o modelo de linguagem grande escolher a próxima etapa (a ferramenta) ou determinar se a tarefa está concluída.

Este é um exemplo de várias etapas:

O DAG "materializado" resultante seria algo parecido com isto:

Problemas com esse modelo "24 horas por dia"

O maior problema com esse modelo é:

• Quando a janela de contexto se torna muito longa, as inteligências se perdem - elas continuam tentando os mesmos métodos fracassados repetidamente.
• Na verdade, é apenas um problema, mas é o suficiente para fazer com que esse método avance rapidamente.

Mesmo que você não tenha criado inteligências manualmente, provavelmente já viu esse problema de contexto longo ao usar uma ferramenta de codificação de corpos inteligentes. Eles se perdem durante o uso e você precisa abrir um novo bate-papo.

Gostaria até de fazer uma observação que já ouvi muito e que talvez você também tenha percebido intuitivamente:

Mesmo que o modelo ofereça suporte a janelas de contexto cada vez mais longas, você sempre obterá melhores resultados com prompts e contextos curtos e focados

A maioria dos desenvolvedores com quem conversei, quando perceberam que, depois de mais de 10 a 20 rodadas de diálogo, as coisas ficavam confusas e o modelo de linguagem grande não conseguia se recuperar disso, disseramDeixei de lado a ideia do "loop de chamada de ferramenta".Mesmo que o tempo do corpo inteligente 90% esteja correto, isso ainda está longe de ser "bom o suficiente para o cliente". Mesmo que um corpo inteligente acerte 90% das vezes, isso ainda está longe de ser "bom o suficiente para ser entregue ao cliente". Você consegue imaginar um aplicativo da Web com 10% de páginas que travam ao serem carregadas?

Atualização de 2025-06-09 - Eu gosto muito. @swyx dessa declaração:

O que realmente funciona - microinteligência

Uma abordagem que vejo com frequência em aplicações práticas é adotar e pontuar o modelo de corpo inteligente em um DAG mais amplo e determinístico.

Você pode se perguntar: "Por que usar a intelligentsia nesse caso?". -- Falaremos disso mais tarde, mas, basicamente, o fato de um modelo de linguagem gerenciar conjuntos de tarefas bem dimensionadas facilita a integração do feedback em tempo real de pessoas reais e sua tradução em etapas do fluxo de trabalho sem ficar preso em um loop de erros contextuais. (Elemento 1eElemento 3eElementos 7).

Permitir que os modelos de linguagem gerenciem conjuntos de tarefas com escopo explícito facilita a integração do feedback em tempo real de pessoas reais ...... sem ficar preso em ciclos de erros contextuais

Um exemplo real de uma microinteligência

Esse é um exemplo de como o código determinístico pode executar uma microinteligência que lida com a etapa "man in the loop" do processo de implantação.

• humanidade Fazer o merge do PR no branch principal do GitHub
• Código determinístico Implementação em um ambiente de preparação
• Código determinístico Executar testes de ponta a ponta (e2e) em ambientes de pré-lançamento
• Código determinístico Atribua a tarefa ao Intelligence para a implantação do ambiente de produção com o contexto inicial "Deploy SHA 4af9ec0 to production environment" (Implantar SHA 4af9ec0 no ambiente de produção)
• corpo inteligente invocações deploy_frontend_to_prod(4af9ec0)
• Código determinístico Solicitação de aprovação humana para essa operação
• humanidade Rejeite a operação com o feedback: "Posso implantar o backend primeiro?"
• corpo inteligente invocações deploy_backend_to_prod(4af9ec0)
• Código determinístico Solicitação de aprovação humana para essa operação
• humanidade Aprovar a operação
• Código determinístico Realizar a implementação de back-end
• corpo inteligente invocações deploy_frontend_to_prod(4af9ec0)
• Código determinístico Solicitação de aprovação humana para essa operação
• humanidade Aprovar a operação
• Código determinístico Realizar a implantação de front-end
• corpo inteligente Avalie a conclusão bem-sucedida da tarefa e encerre-a!
• Código determinístico Executar testes de ponta a ponta em ambientes de produção
• Código determinístico Conclusão da tarefa ou transmissão da tarefa para o Rollback Intelligence para analisar a falha e, possivelmente, fazer a reversão

Este exemplo é baseado em um exemplo que nós da Humanlayer lançamos para gerenciar nossas implementações. Inteligência real de código aberto -- Aqui está um diálogo real que tive com ele na semana passada:

Não demos a essa inteligência um grande número de ferramentas ou tarefas. O principal valor do Big Language Model está em analisar o feedback de texto simples de humanos e sugerir cursos de ação atualizados. Isolamos as tarefas e o contexto o máximo possível para manter o Big Language Model concentrado em um fluxo de trabalho pequeno, de 5 a 10 etapas.

Aqui está outra. Uma demonstração mais clássica de suporte/chatbot.

Então, o que exatamente é um corpo inteligente?

• Prompt (prompt) - Informa ao modelo de linguagem grande como agir e quais "ferramentas" estão disponíveis para ele. A saída da dica é um objeto JSON que descreve a próxima etapa do fluxo de trabalho ("chamada de ferramenta" ou "chamada de função"). (Elemento 2)
• declaração de troca - Com base no JSON retornado pelo Big Language Model, decida o que fazer com ele. ( Parte do elemento 8)
• Contexto cumulativo - Armazena uma lista de etapas que ocorreram e seus resultados. (Elemento 3)
• loop for - Antes de o Modelo da Grande Linguagem emitir algum tipo de chamada de ferramenta "terminate" (ou resposta de texto simples), adicione o resultado da instrução switch à janela de contexto e peça ao Modelo da Grande Linguagem para escolher o que fazer em seguida. (Elemento 8)

No exemplo do "deploybot", obtivemos vários benefícios ao dominar o fluxo de controle e o acúmulo de contexto:

• em nossa declaração de troca responder cantando loop for em que podemos sequestrar o fluxo de controle para fazer uma pausa à espera de entrada humana ou à espera da conclusão de uma tarefa de longa duração.
• Podemos facilmente serializar Contexto (textual) para pausa e retomada.
• em nossa Prompt (prompt) Nesse caso, podemos tentar otimizar a maneira pela qual as instruções e "o que aconteceu até agora" são entregues ao modelo de linguagem grande.

Parte II comandante-em-chefe (militar) Formalização desses padrõesEles podem ser usados em qualquer projeto de software para adicionar uma impressionante funcionalidade de IA sem precisar adotar a implementação/definição tradicional de um "corpo de inteligência de IA" em sua totalidade.