Se o seu agente segue o mesmo roteiro toda vez, compile o roteiro

A maior parte dos agentes em produção é um modelo de linguagem lendo um procedimento e improvisando os passos. Alguém escreveu um documento explicando como tratar um reembolso, triar um ticket ou conciliar uma fatura, e o modelo lê isso em tempo de execução e decide o que fazer em cada bifurcação.
Um paper chamado ReTrace faz a pergunta óbvia que vem depois. Se o procedimento não muda entre execuções, por que um modelo decide os passos toda vez?
A tese
Os números reportados são específicos o bastante para dar margem a discussão, e isso é um bom sinal. Em 79 procedimentos de produção, os fluxos gerados pelo ReTrace concluíram 93.8% das tarefas. Os agentes originais concluíam 96.8%. Os fluxos compilados custam 24% menos por tarefa.
Em outro benchmark a diferença de tempo é bem maior: 1.3 segundo contra 170 segundos do agente equivalente.
Lidos juntos, esses números mostram o formato da troca. Você abre mão de três pontos de conclusão e ganha uma tarefa que custa um quarto menos e termina em cerca de 1% do tempo real. Para um fluxo que roda 10,000 vezes por dia, isso muda para que serve o fluxo.
Como compila
O mecanismo está mais perto de extrair um programa do que de escrever prompts melhores.
O sistema observa um agente seguir um procedimento e extrai o raciocínio por trás de cada chamada de ferramenta. Esses motivos não são guardados como prosa. Condições que se repetem entre execuções são fundidas em um documento de regras compacto, e esse documento é compilado em um fluxo executável: um grafo de etapas, ramos e chamadas de ferramenta que roda sem modelo no caminho de decisão.
O resultado é que o julgamento do modelo é capturado uma vez, na fase de build, e reaproveitado. Em tempo de execução só roda código derivado desse julgamento.
Se isso soa como o argumento da compilação antecipada contra a interpretação, é porque é. Um interpretador é flexível e paga pela flexibilidade em cada execução. Um compilador paga uma vez e depois roda rápido, e quebra quando a entrada deixa de corresponder àquilo contra o que foi compilado.
Onde vão os três pontos
A pergunta honesta é qual 3% das tarefas o fluxo compilado deixa de fora, e a forma como o paper apresenta o resultado sugere que são os casos incomuns.
Um documento de procedimento cobre o caminho normal e menciona as exceções de passagem. Um agente que o lê consegue improvisar quando um caso não encaixa: fazer uma pergunta de esclarecimento, tentar outra ferramenta, notar que a conta do cliente tem uma marcação que muda tudo. Um fluxo compilado faz exatamente aquilo para o que foi compilado, e quando um caso cai fora do documento de regras ele falha ou faz a coisa errada com muita confiança.
É por isso que a economia de 24% é interessante e o 93.8% é o número que decide a adoção. Em um fluxo onde uma tarefa que falhou é repetida por uma pessoa a $10 o caso, economizar 24% de processamento criando 3% mais escalações pode ser prejuízo. Em um fluxo onde a tarefa que falhou é pega por um validador adiante e repetida automaticamente, os mesmos números são dinheiro de graça.
O paper não parece detalhar as falhas por tipo, pelo menos não no que está disponível. Esse detalhamento é justamente o que um time precisa antes de levar um procedimento para produção.
O que isso diz sobre a stack de agentes
A visão que dominou os últimos dois anos é que agentes melhoram quando os modelos melhoram. O ReTrace aponta para outro eixo. Parte do trabalho dos agentes é genuinamente aberta e precisa de um modelo no loop a cada passo. Outra parte é um procedimento com árvore de decisão fixa, e rodar um modelo ali é desperdício de tokens, do mesmo jeito que chamar um modelo de linguagem para interpretar uma data.
O interessante é que a divisão pode ser descoberta em vez de declarada. Você não precisa decidir antes quais dos seus fluxos são procedimentais. Roda o agente, observa o que ele faz e deixa a etapa de extração dizer se o padrão de decisão é estável o bastante para compilar.
Isso tem uma consequência organizacional. O fluxo compilado é um artefato legível. Alguém pode abrir e ver as regras de verdade, incluindo as que ninguém documentou, como "se o reembolso passar de quinhentos, encaminhar para uma pessoa", que só existe porque o agente a inferiu dos exemplos. É uma trilha de auditoria melhor do que uma transcrição, e é o tipo de coisa que um time de compliance consegue aprovar.
O problema de manutenção que ninguém resolveu
Fluxos compilados têm um modo de falha que agentes não têm: deriva. Mude a política de reembolso e o grafo compilado continua executando a antiga até alguém recompilar. Mude o schema da ferramenta e o fluxo chama uma função que não aceita mais aqueles argumentos.
Um agente que lê um documento de procedimento tem o mesmo problema em forma mais branda. Ele lê o documento atual, então uma mudança de política se propaga na execução seguinte. Também lê o schema atual, então um parâmetro renomeado é tratado. Você paga por essa adaptabilidade em cada chamada, e todo o argumento do ReTrace é que você está pagando demais.
A correção é óbvia e sem glamour: recompilar quando algo muda e tratar o documento de regras como um artefato versionado, no mesmo processo de revisão do código. Se as ferramentas tornam isso fácil é a diferença entre um resultado de pesquisa e um produto.
Vale a pena testar?
Se você roda em volume qualquer coisa que siga um procedimento escrito, a conta vale a pena com os seus próprios dados. Pegue um fluxo, registre algumas centenas de execuções e veja com que frequência o agente tomou um caminho que não estava no documento. Se a resposta for quase nunca, você está pagando um modelo para fazer papel de switch.
Se a resposta for com frequência, seu procedimento é menos procedimento do que você pensava, e compilar vai produzir um fluxo que falha nos casos que o seu negócio realmente considera importantes.
Talvez a contribuição mais útil do paper seja tornar isso mensurável. Por dois anos a discussão sobre agentes foi sobre capacidade, e capacidade é difícil de precificar. O ReTrace precifica uma decisão específica: quanto vale o julgamento de um modelo por passo, em dólares e em segundos. Em 79 procedimentos a resposta veio em 24% menos processamento e 99% menos latência, por três pontos de conclusão. É um número com o qual um time de finanças consegue trabalhar.
O paper completo está no arXiv, e a cobertura disponível até agora é fraca em detalhes de implementação, então trate os números como uma tese e não como uma receita. Mas a pergunta que ele faz é a certa, e todo time que roda agentes em escala vai ouvi-la em breve de alguém segurando uma fatura.
Artigos relacionados
Uma planilha comunitária de toques que desliga os anúncios dos Android chineses
Não mexe no sistema, não desbloqueia nada, não faz flash de nada. Só vira os botões que os fabricantes já deixaram à mostra. O preço é uma lista que alguém precisa continuar escrevendo.
GPT Image 2.6 manteve o preço por token e elevou a fatura
O GPT Image 2.6 mantém cada tarifa por token do 2.5 e mesmo assim custa mais por imagem, porque boa parte do trabalho acontece agora nos tokens de saída. Onze dias após o lançamento, a estrutura de preços diz mais que o ranking.
Alguém reconstruiu o IDM por fora e anotou o que não tocou
Uma reimplementação em Rust do Internet Download Manager promete 5 vezes a velocidade e 86 idiomas. O documento mais interessante é o parágrafo que explica como ela foi feita sem copiar nada.
Rune é um framework de UI em Rust feito para que um agente possa verificar o próprio trabalho
Rune renderiza sem interface, despeja sua árvore de elementos e aceita entrada roteirizada, o que dá a um agente de código um sinal diffável que um screenshot nunca oferece. O framework está em pré-lançamento e não aceita pull requests.