Resumo Técnico: Compilação JIT de Agentes para Planejamento e Agendamento de Agentes Web Otimizados para Latência

Declaração do Problema

Agentes de uso de computador (CUAs) automatizam tarefas baseadas na web especificadas em linguagem natural (por exemplo, "pedir o item mais barato do Taco Bell") gerando sequências de chamadas de ferramentas, como clicar, digitar e rolar. As implementações atuais geralmente seguem um loop sequencial de buscar-tirar-screenshot-executar, onde cada iteração requer uma chamada a um Modelo de Linguagem de Grande Escala (LLM). Essa arquitetura sofre de duas limitações primárias:

1. Alta Latência e Custo: A necessidade de uma chamada a um LLM a cada passo cria atrasos significativos na execução e altos custos de inferência.
2. Precisão e Taxas de Erro: A aplicação ingênua de LLMs de ponta leva a erros frequentes, muitas vezes decorrentes de sequências incorretas de uso de ferramentas (por exemplo, clicar no elemento errado ou digitar no campo errado) e da falta de otimização no agendamento da execução.

Tentativas existentes de melhorar o desempenho, como filtragem agressiva de DOM ou aprendizado por reforço de modelos menores, ainda dependem de conjuntos de ferramentas estáticos e execução sequencial, falhando em explorar todo o espaço de agendamentos de execução (incluindo paralelismo e proteção contra falhas de requisição) ou em eliminar chamadas de LLM não determinísticas entre invocações de ferramentas.

Metodologia: Compilação JIT de Agentes

Os autores propõem a Compilação Just-In-Time (JIT) de Agentes, um sistema que traduz instruções de alto nível em linguagem natural em código executável otimizado no momento da síntese do plano. Diferentemente de agentes padrão que executam um loop de "observar-pensar-agir", este sistema compila uma tarefa em um grafo de código estático que orquestra chamadas de ferramentas e inferência, selecionando a tradução com o menor custo estimado. A arquitetura consiste em três componentes principais:

1. Protocolo de Ferramentas com Garantia de Invariantes

Para garantir a correção dos planos de código gerados, o sistema introduz um protocolo onde cada ferramenta especifica pré-condições e pós-condições (invariantes de estado).

• Estrutura: As ferramentas definem estados esperados antes da execução (pre), estados garantidos após a execução (post) e predicados opcionais de tempo de execução (pre_check, post_check) para depuração.
• Verificação: Isso permite verificação composicional no momento da compilação. Uma chamada de ferramenta é válida apenas se o estado atual satisfizer sua pré-condição. Essa verificação estática elimina uma grande classe de erros causados por sequências de ações incorretas (por exemplo, tentar pedir um item antes de navegar para a página de detalhes).
• Benefício: O protocolo desloca a fronteira de Pareto de latência-precisão, aumentando significativamente a taxa de geração de planos válidos.

2. Planejador Otimizador de Custos (JIT-Planner)

O planejador gera múltiplos planos de código candidatos em paralelo, valida-os contra o protocolo de ferramentas e seleciona o candidato de menor custo.

• Geração Paralela: Múltiplos trabalhadores amostram planos de código de um LLM simultaneamente.
• Validação Baseada em CFG: Cada plano é convertido em um Grafo de Fluxo de Controle (CFG). O sistema percorre o grafo para verificar o fluxo de estado (garantindo que o post do passo $i$ satisfaça o pre do passo $i+1$) e estimar o custo.
• Modelo de Custo: Os custos são acumulados com base em chamadas de ferramentas e chamadas de avaliação de IA (ai_eval). Uma penalidade de aninhamento ($\gamma$) é aplicada para desencorajar loops aninhados envolvendo chamadas caras de LLM.
• Resultado: O planejador seleciona o plano válido com o menor custo estimado, frequentemente substituindo chamadas de LLM desnecessárias por lógica de código puro (por exemplo, calcular o preço mínimo no código em vez de pedir ao LLM).

3. Agendador Consciente de Custos (JIT-Scheduler)

O agendador determina a estratégia de execução ótima para um plano dado com base em distribuições de latência aprendidas. Ele avalia três estratégias:

• Série: Execução sequencial.
• Paralela: Paralelismo de tarefas entre $n$ trabalhadores.
• Proteção (Hedge): Execução paralela especulativa onde $n$ trabalhadores redundantes executam a mesma tarefa, e o primeiro resultado válido é retornado.
• Mecanismo: Usando estimativa de custo Monte Carlo, o agendador amostra a partir de distribuições de latência aprendidas de elementos específicos de DOM (coletadas offline). Ele prevê quais elementos um plano interage e estima a latência esperada para cada estratégia, selecionando aquela com a latência média mínima.

Cache Offline

O sistema depende de um processo offline para popular dois caches:

1. Cache do Planejador: Mapeia ações de alto nível para código de ferramenta reutilizável e compatível com o protocolo (sintetizado a partir de traços de execução).
2. Cache do Agendador: Mapeia elementos de esquema de página para distribuições de latência (ajustadas a partir de traços de execução históricos).

Contribuições Principais

1. Protocolo de Ferramentas com Garantia de Invariantes: Estende interfaces de ferramentas padrão para incluir invariantes de estado, permitindo verificação estática de sequências de ferramentas e reduzindo erros de geração.
2. Planejamento Otimizador de Custos: Introduz um planejador que gera candidatos paralelos, valida-os através de travessia de CFG e seleciona o caminho de execução de menor custo, eliminando efetivamente chamadas redundantes de LLM.
3. Agendamento Consciente de Custos: Implementa um agendador que seleciona dinamicamente entre estratégias de série, paralela e de proteção com base em simulações Monte Carlo de distribuições de latência aprendidas.
4. Sistema End-to-End: Integra esses componentes em um compilador JIT que traduz tarefas em linguagem natural em código executável otimizado, indo além do loop padrão de agente.

Resultados

O sistema foi avaliado em 37 tarefas em cinco aplicações web (Dashdish, GitLab, Gomail, Omnizon, Reddit) usando vários LLMs de ponta.

• Desempenho do JIT-Planner:

  • Alcançou um aceleração de 10,4× sobre a linha de base padrão Browser-Use.
  • Melhorou a precisão em +28% sobre o Browser-Use.
  • Demonstrou que a estimativa de custo classifica efetivamente os planos: a diferença entre os candidatos de melhor custo e pior custo foi uma variância de 5,3× na latência.
  • O protocolo de invariantes reduziu a taxa de falha na geração de planos de 80% para 43% e deslocou o modo de falha dominante de violações de ordenação de ferramentas para outros tipos.

• Desempenho do JIT-Scheduler:

  • Alcançou uma aceleração de 2,4× e uma melhoria de +9% na precisão sobre o CUA da OpenAI.
  • Superou estratégias de agendamento fixas (Série, Paralela, Proteção) ao selecionar adaptativamente a estratégia ótima por tarefa. Por exemplo, identificou corretamente que tarefas com elementos de UI de alta variância (por exemplo, encontrar um botão específico) se beneficiam de proteção, enquanto consultas simples se beneficiam de execução em série.

• Análise de Complexidade:

  • As acelerações foram consistentes em toda a cardinalidade da tarefa (baixa, média, alta) e comprimento, indicando que os benefícios derivam principalmente da eliminação da inferência de LLM por passo, em vez de heurísticas específicas da tarefa.
  • Aplicações com padrões de navegação complexos (por exemplo, Reddit) apresentaram as maiores acelerações (até 18,9×), enquanto aquelas com fluxos mais simples apresentaram ganhos menores, mas ainda significativos.

Significado e Alegações

O artigo alega que a Compilação JIT de Agentes apresenta uma direção promissora para melhorar a eficiência e a confiabilidade de agentes de uso de computador. Ao tratar o planejamento de agentes como um problema de compilação, o sistema:

1. Desacopla Planejamento de Execução: Permite a otimização de todo o grafo de execução antes do tempo de execução, em vez de tomar decisões ganancias passo a passo.
2. Reduz Não Determinismo: Ao impor invariantes de estado e compilar tarefas em código, reduz a dependência de chamadas de LLM não determinísticas durante a execução, levando a maior precisão.
3. Otimiza o Uso de Recursos: Através de agendamento consciente de custos, adapta-se às características específicas de latência das interações web, equilibrando o trade-off entre latência e precisão mais efetivamente do que estratégias estáticas.

Os autores observam que a abordagem é mais adequada para aplicações que um agente lidará repetidamente, pois requer um custo de configuração offline (síntese de ferramentas e coleta de traços) para construir os caches necessários. Eles reconhecem limitações relacionadas a alterações na interface do usuário (que podem quebrar ferramentas em cache) e ambientes altamente estocásticos (por exemplo, CAPTCHAs), mas afirmam que o protocolo de invariantes fornece um mecanismo para detecção em tempo de execução e fallback.