Tool-Genesis: A Task-Driven Tool Creation Benchmark for Self-Evolving Language Agent

O artigo apresenta o Tool-Genesis, um benchmark diagnóstico que avalia a capacidade de agentes de linguagem de criar e utilizar ferramentas a partir de requisitos abstratos, revelando que falhas iniciais em modelos de ponta se amplificam e degradam o desempenho em tarefas downstream.

O essencial

Imagine que você tem um assistente de IA super inteligente, capaz de conversar, escrever textos e resolver problemas complexos. Mas, para fazer coisas do mundo real — como comprar uma passagem de trem, analisar dados financeiros ou controlar a iluminação da sua casa —, ele precisa de "ferramentas" (como aplicativos ou APIs).

Até agora, a maioria dos testes de IA assumia que essas ferramentas já estavam prontas, com manuais perfeitos e botões bem definidos. Era como pedir para um cozinheiro fazer um bolo, mas já entregar a receita escrita, os ingredientes medidos e o forno pré-aquecido. O cozinheiro só precisava seguir as instruções.

O problema: No mundo real, não temos manuais perfeitos. Às vezes, a ferramenta nem existe, ou o manual está incompleto, cheio de erros ou escrito em uma linguagem confusa. Se o cozinheiro tiver que criar a receita e o próprio forno do zero, baseado apenas em uma ideia vaga ("faça um bolo de chocolate"), ele provavelmente vai falhar.

É aqui que entra o Tool-Genesis (Gênese de Ferramentas), o novo estudo apresentado neste artigo.

A Ideia Principal: O "Teste de Criação"

Os autores criaram um novo tipo de teste para ver se as IAs conseguem criar suas próprias ferramentas a partir do nada, apenas ouvindo o que você precisa.

Em vez de perguntar: "Você consegue usar esta ferramenta de busca?", o Tool-Genesis pergunta: "Você precisa encontrar voos de X para Y. Crie a ferramenta de busca que faça isso."

As Analogias do Papel

Para entender melhor, vamos usar algumas metáforas:

1. O "Caixa de Ferramentas" vs. "Pedaço de Papel Descartável":

   • O jeito antigo (Ad-hoc): A IA cria um "rascunho" rápido para resolver aquele único problema. É como escrever uma nota num guardanapo para calcular uma conta. Funciona uma vez, mas se você tentar usar de novo, o guardanapo pode estar sujo ou rasgado.
   • O jeito Tool-Genesis: A IA deve criar uma "ferramenta durável". É como se ela construísse uma máquina de lavar roupa nova, com botões claros e um manual de instruções, para que você possa usá-la hoje, amanhã e daqui a 10 anos. O teste exige que a ferramenta seja robusta e reutilizável.

2. O "Efeito Dominó" dos Erros:

   • O estudo descobriu algo assustador: se a IA errar um detalhe pequeno no início (como escrever o nome de um botão errado ou esquecer um parâmetro), esse erro pequeno se transforma em um desastre gigante no final.
   • Analogia: Imagine que a IA constrói uma ponte. Se ela errar a medida de um único parafuso na fundação (o erro inicial), a ponte inteira pode desabar quando um carro passar por cima (o erro final na tarefa). O Tool-Genesis mostra que mesmo as IAs mais inteligentes falham em colocar o "primeiro parafuso" corretamente.

3. A "Caixa Preta" vs. O "Raio-X":

   • Antes (Caixa Preta): Os testes antigos diziam apenas: "A IA acertou ou errou a resposta final?". Se ela errou, ninguém sabia se foi porque a ferramenta era ruim, porque a IA não soube usá-la ou porque a ferramenta tinha um bug. Era como ver um carro quebrar e não saber se foi o motor, o pneu ou o motorista.
   • Tool-Genesis (Raio-X): O novo teste faz um "raio-x" em cada etapa. Ele verifica:
     1. A ferramenta foi construída no formato certo? (Compliance)
     2. O manual de instruções (o código) faz sentido? (Fidelidade do Esquema)
     3. A ferramenta funciona de verdade quando você tenta usá-la? (Testes Unitários)
     4. Ela resolveu o problema do usuário? (Utilidade Final)
   • Isso permite dizer exatamente onde a IA falhou: "Ela errou na construção da ferramenta, não na estratégia de uso."

O Que o Estudo Descobriu?

Os pesquisadores testaram as IAs mais modernas do mundo (como GPT-4, Claude, Gemini e modelos chineses) e descobriram:

• Elas são ótimas em seguir instruções, mas péssimas em criar do zero: Quando a IA recebe uma ferramenta pronta, ela é incrível. Mas quando tem que inventar a ferramenta sozinha, ela tropeça muito.
• O "Loop de Reparo" ajuda: Se você permite que a IA tente, veja onde errou, e tente consertar (como um programador que testa e corrige bugs), o desempenho melhora muito. É como se a IA aprendesse com seus próprios erros em tempo real.
• Tamanho importa (mas não é tudo): Modelos maiores geralmente criam ferramentas melhores, mas mesmo os gigantes ainda cometem erros básicos que quebram tudo.

Por Que Isso é Importante?

O Tool-Genesis não é apenas mais um teste de nota. É um guia para o futuro. Ele nos diz que, para ter IAs que realmente evoluem e ajudam nas tarefas do dia a dia, não basta apenas treinar elas para responder perguntas. Precisamos ensiná-las a construir, consertar e manter suas próprias ferramentas.

Se queremos que a IA seja um verdadeiro "funcionário" que resolve problemas complexos, ela precisa saber criar o próprio "kit de ferramentas" para a tarefa, e não apenas usar o que já está na estante.

Em resumo: O Tool-Genesis é o teste que diz: "Não me diga apenas que você sabe usar o martelo. Me mostre que você consegue forjar um martelo novo, com o cabo certo e a cabeça firme, apenas ouvindo que eu preciso pregar um prego." E, até agora, as IAs ainda estão aprendendo a forjar martelos que não quebram na primeira pancada.

Resumo técnico

1. Problema e Motivação

A pesquisa atual sobre agentes de linguagem autoevolutivos foca na capacidade de criar, adaptar e manter ferramentas a partir de requisitos de tarefas. No entanto, os benchmarks existentes apresentam três lacunas críticas que limitam o progresso real:

1. Dependência de Especificações Pré-definidas: A maioria dos benchmarks assume que as interfaces ou esquemas das ferramentas já estão disponíveis e corretas. Isso ignora a capacidade do agente de inferir contratos de interface a partir de requisitos abstratos e gerar esquemas verificáveis.
2. Foco em Escala vs. Utilidade de Cenário: Muitas avaliações medem apenas a diversidade ou o número de ferramentas geradas, sem verificar se o conjunto de ferramentas (toolbox) é coeso, reutilizável e capaz de cobrir um cenário do mundo real de ponta a ponta.
3. Avaliação "Caixa Preta": As métricas atuais baseiam-se frequentemente em respostas finais ou verificações de chamadas superficiais. Isso cria um "dilema da caixa preta", onde é difícil discernir se uma falha ocorreu devido à construção defeituosa da ferramenta (bugs de lógica, esquemas inválidos) ou a uma estratégia de uso subótima.

O objetivo do Tool-Genesis é preencher essas lacunas, avaliando a capacidade dos agentes de criar ferramentas persistentes e reutilizáveis a partir de requisitos abstratos, sem especificações prévias.

---

2. Metodologia

O Tool-Genesis formaliza a criação de ferramentas como um problema de geração condicional sobre interfaces do Model Context Protocol (MCP). O processo é decomposto em duas fases acopladas:

1. Predição de Interface (Tool Interface Prediction): O modelo deve inferir um esquema de interface estruturado (JSON Schema) a partir de uma descrição natural da tarefa.
2. Materialização da Ferramenta (Tool Materialization): Com base no esquema (previsto ou ground truth), o modelo deve gerar uma implementação executável do servidor (código Python/Server) que satisfaça critérios de reutilização.

Construção do Dataset

O dataset foi construído através de um pipeline rigoroso (Figura 2 do artigo):

• Coleta: Crawler de servidores MCP de fontes como GitHub, HuggingFace e agregadores (Smithery, GLMA).
• Filtragem: Validação de estrutura, executabilidade em sandbox, deduplicação e validação semântica via LLM para garantir segurança e ausência de dependências externas críticas.
• Geração de Tarefas e Trajetórias: Uso de LLMs para sintetizar tarefas realistas e gerar trajetórias de execução em sandbox, garantindo que as interações com as ferramentas sejam baseadas em feedback real e não em alucinações.
• Geração de Testes Unitários: Extração e síntese de testes unitários (incluindo casos negativos e de fronteira) para validar a funcionalidade das ferramentas geradas.
• Inspeção Manual: Revisão humana para garantir consistência, solvabilidade e aderência aos requisitos.

O dataset final contém 86 servidores MCP executáveis, 508 ferramentas, 2.150 tarefas e 9.441 testes unitários, cobrindo 24 classes de domínio.

Protocolo de Avaliação (4 Níveis)

O benchmark introduz um protocolo de ciclo de vida completo para desvendar a causa das falhas:

• Nível 1 (Conformidade de Superfície): Taxa de conformidade com o padrão MCP e taxa de execução do servidor (inicialização e resposta).
• Nível 2 (Fidelidade da Interface Semântica): Schema-F1, que mede a correspondência entre os esquemas de parâmetros previstos e os de referência (usando correspondência bipartida e similaridade de embeddings).
• Nível 3 (Correção Funcional): UTsoft e UThard, que medem a porcentagem de ferramentas que passam em testes unitários padrão e estritos (incluindo casos de fronteira e negativos).
• Nível 4 (Utilidade da Tarefa Downstream): Taxa de Sucesso (SR) normalizada por um oráculo. Um agente fixo tenta resolver tarefas usando as ferramentas geradas. O resultado é comparado com o desempenho usando ferramentas de referência (ground truth) para quantificar a "lacuna de utilidade".

---

3. Principais Contribuições

1. Tool-Genesis Benchmark: O primeiro benchmark diagnóstico projetado para avaliar a criação de ferramentas sob a ausência de especificações, focando na inferência de contratos e na geração de ativos reutilizáveis.
2. Protocolo de Avaliação Diagnóstica: Um sistema de métricas de 4 níveis que permite atribuir falhas especificamente à qualidade da ferramenta (esquema, lógica) ou à estratégia de uso, resolvendo o problema da "caixa preta".
3. Lacuna de Utilidade Normalizada por Oráculo: Uma métrica que quantifica a diferença de desempenho entre ferramentas geradas e ferramentas de referência, oferecendo uma medida clara do potencial de autoevolução.
4. Descoberta de Gargalos Críticos: A evidência de que falhas menores na fase inicial (interface/esquema) são amplificadas ao longo do pipeline, causando quedas precipitadas no desempenho final.

---

4. Resultados Experimentais

Os experimentos foram realizados em uma ampla gama de modelos (OpenAI GPT-4o/4.1/5.1, Claude, Gemini, Qwen3, DeepSeek, Kimi) usando duas estratégias: Direto (geração única) e Code-Agent (loop ReAct com execução e correção).

• Desempenho Geral: Mesmo os modelos mais avançados (SOTA) lutam para criar interfaces precisas e lógica executável em uma única tentativa (one-shot). As métricas de Nível 1 e 2 são frequentemente altas, mas não garantem sucesso no Nível 4.
• Impacto do Loop Fechado (Code-Agent): A estratégia de "Code-Agent" (que permite execução e correção iterativa) trouxe ganhos significativos.
  • Exemplo: O Gemini-3-Flash viu sua taxa de execução (Exec.) saltar de 0.140 para 0.977 e a taxa de sucesso (SR) de 0.103 para 0.581.
  • Isso demonstra que o feedback de execução é crucial para transformar esquemas plausíveis em ferramentas funcionais.
• Amplificação de Falhas: O estudo mostra que a fidelidade do esquema (Nível 2) é um preditor fraco do sucesso da tarefa (Nível 4) sem feedback de execução. Pequenos erros na interface inicial levam a falhas catastróficas downstream.
• Escala e Fine-tuning:
  • Modelos maiores geralmente performam melhor, mas a hierarquia pode mudar dependendo da estratégia (ex: Qwen3-32B vs 235B).
  • Fine-tuning no dataset Tool-Genesis melhorou consistentemente todos os níveis de avaliação, indicando que o benchmark serve não apenas para avaliação, mas também como um sinal de treinamento eficaz para internalizar a criação de ferramentas.

---

5. Significado e Impacto

O Tool-Genesis representa uma mudança de paradigma na avaliação de agentes de linguagem:

• Do "Script Descartável" para "Ativo Persistente": Move o foco da geração de scripts únicos para a criação de conjuntos de ferramentas (toolsets) robustos, verificáveis e mantíveis.
• Diagnóstico Preciso: Permite que pesquisadores identifiquem exatamente onde o processo de criação falha (ex: o modelo entende a tarefa, mas falha na definição do esquema JSON, ou o esquema está correto, mas a lógica de implementação tem bugs).
• Direcionamento Futuro: O trabalho sugere que o progresso futuro deve focar em mecanismos de reparo guiado por execução e internalização de padrões de interface via treinamento, em vez de apenas depender de prompts estáticos.

Em resumo, o Tool-Genesis estabelece um novo padrão para avaliar a verdadeira capacidade de autoevolução de agentes, provando que a criação de ferramentas é um desafio complexo que exige mais do que apenas a seleção de APIs; exige a engenharia de software autônoma e verificável.