🤖 AI

Agentization of Digital Assets for the Agentic Web: Concepts, Techniques, and Benchmark

Este artigo apresenta um framework formal para o processo de "agentização" de ativos digitais na Web Agêntica, introduzindo um agente especializado e o primeiro benchmark (A2A-Agentization Bench) para avaliar e garantir a fidelidade e interoperabilidade na criação de agentes autônomos.

Autores originais: Linyao Chen, Bo Huang, Qinlao Zhao, Shuai Shao, Zhi Han, Zicai Cui, Ziheng Zhang, Guangtao Zeng, Wenzheng Tang, Yikun Wang, Yuanjian Zhou, Zimian Peng, Yong Yu, Weiwen Liu, Hiroki Kobayashi, Weinan Zh

Publicado 2026-04-07

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Linyao Chen, Bo Huang, Qinlao Zhao, Shuai Shao, Zhi Han, Zicai Cui, Ziheng Zhang, Guangtao Zeng, Wenzheng Tang, Yikun Wang, Yuanjian Zhou, Zimian Peng, Yong Yu, Weiwen Liu, Hiroki Kobayashi, Weinan Zhang

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que a internet atual é como uma biblioteca gigante cheia de livros, ferramentas e máquinas, mas todas elas estão trancadas em caixas de vidro. Você pode ver o que tem dentro, mas não consegue usar as ferramentas ou pedir ajuda aos livros. Eles são "ativos digitais" (códigos, documentos, vídeos), mas são passivos e estáticos.

Agora, imagine que queremos transformar essa biblioteca em uma equipe de agentes autônomos (robôs inteligentes) que podem conversar entre si, pegar ferramentas emprestadas e resolver problemas complexos juntos.

Este artigo, intitulado "Agentização de Ativos Digitais para a Web Agêntica", trata exatamente de como tirar essas ferramentas trancadas das caixas e transformá-las em robôs úteis que podem trabalhar na nova "Web Agêntica".

Aqui está uma explicação simples, usando analogias do dia a dia:

1. O Problema: A "Fábrica de Robôs" Manual

Atualmente, para criar um agente (um robô capaz de fazer tarefas), os humanos precisam programá-lo do zero. É como tentar construir um carro peça por peça, manualmente, para cada modelo diferente. É caro, lento e difícil de escalar.

Por outro lado, já existem milhões de "peças" prontas na internet (repositórios de código, softwares, scripts). O problema é que essas peças não sabem falar a mesma língua dos robôs. Elas não têm um "cartão de visita" que explique o que fazem, nem um motor que as faça funcionar sozinhas.

2. A Solução: A "Agentização" (Transformar em Agente)

Os autores propõem um processo chamado Agentização. Pense nisso como uma linha de montagem mágica que pega um software estático e o transforma em um agente autônomo.

O processo tem quatro etapas principais (como se fosse cozinhar um prato pronto):

Preparar a Cozinha (Configuração do Ambiente): Antes de cozinhar, você precisa garantir que a cozinha tenha gás, água e os utensílios certos. O sistema cria um ambiente virtual perfeito para o software rodar sem erros.
Descobrir as Receitas (Extração de Habilidades): O sistema lê o código e descobre quais "truques" o software sabe fazer (ex: "cortar imagem", "ler PDF", "calcular impostos"). Ele transforma esses truques em "ferramentas" que o robô pode usar.
Dar um Cérebro (Instanciação do Agente Interno): O software ganha um "cérebro" (um agente de IA) que sabe quando e como usar essas ferramentas para resolver problemas.
Fazer o Cartão de Visita (Agent Card): O sistema cria um cartão de apresentação claro, dizendo: "Olá, sou o Agente de Imagens. Eu sei cortar fotos e remover fundos. Me chame quando precisar!". Isso permite que outros robôs entendam o que ele faz.

3. O Desafio: Por que é difícil?

Fazer isso automaticamente é como tentar montar um quebra-cabeça com as peças misturadas e sem a imagem da caixa. O artigo identifica três grandes obstáculos:

Ambientes Inconsistentes: Às vezes, o software precisa de uma versão específica de um programa que entra em conflito com o resto. É como tentar usar uma chave de fenda elétrica em uma tomada que não tem voltagem correta.
Habilidades Não Estruturadas: O código muitas vezes está escrito de forma confusa, sem documentação. O robô precisa "adivinhar" o que o código faz, como um detetive lendo um diário rabiscado.
A Lacuna Semântica: Mesmo que o código funcione, ele precisa ser explicado de forma clara para outros robôs. Se o cartão de visita for confuso, ninguém vai saber contratar aquele robô.

4. O Teste: A "Prova de Fogo" (Benchmark)

Para ver se a ideia funciona, os autores criaram um teste chamado A2A-Agentization Bench.

Eles pegaram 35 repositórios de código reais (de coisas como edição de vídeo, química, finanças e segurança).
Eles tentaram transformar esses códigos em agentes usando diferentes ferramentas de IA.
O teste mediu duas coisas:
1. Fidelidade: O robô realmente consegue fazer o que o código original fazia? (Ele não quebrou a ferramenta?)
2. Interoperabilidade: Outros robôs conseguiram entender o cartão de visita e chamar esse novo robô para trabalhar em equipe?

5. O Resultado: O que eles descobriram?

O experimento mostrou que:

É possível! Conseguimos transformar códigos estáticos em agentes funcionais.
Mas ainda é difícil. Muitos robôs falharam na hora de configurar o ambiente ou de criar um cartão de visita claro.
O segredo está na preparação. Os melhores resultados vieram de sistemas que gastaram tempo configurando o ambiente corretamente antes de tentar fazer o robô trabalhar.

Conclusão: O Futuro da Internet

Este trabalho é um passo fundamental para o futuro da internet. Em vez de termos apenas sites e aplicativos que nós usamos, teremos uma internet onde robôs conversam com robôs.

Imagine que você pede a um assistente pessoal: "Organize minha viagem".

O seu assistente chama um agente de voos (que foi "agentizado" a partir de um código de companhias aéreas).
Esse agente chama um agente de hotéis e um agente de previsão do tempo.
Todos eles trocam dados e resolvem tudo sozinhos.

Este artigo fornece o "manual de instruções" e as ferramentas para que milhões de softwares existentes hoje possam se juntar a essa grande equipe de robôs, tornando a internet muito mais inteligente e útil para todos nós.

Título: Agentização de Ativos Digitais para a Web Agêntica: Conceitos, Técnicas e Benchmark

1. O Problema

A Web Agêntica é um novo paradigma que redefine a internet através de interações autônomas e orientadas a objetivos, permitindo que agentes de IA colaborem em larga escala. No entanto, o crescimento deste ecossistema enfrenta um gargalo crítico: a escala de agentes especializados.

Limitação Atual: A construção manual de agentes é cara, lenta e difícil de escalar em diversidade.
Oportunidade Subutilizada: A web tradicional já possui uma vasta quantidade de "Ativos Digitais" (repositórios de código, documentos, serviços, etc.) que encapsulam conhecimento e funcionalidades valiosas.
O Desafio: Como transformar automaticamente esses ativos estáticos em agentes interoperáveis que possam ser descobertos e invocados por outros agentes na Web Agêntica?
Obstáculos Técnicos: A automação desse processo enfrenta três barreiras principais:
1. Ambientes Inconsistentes: Dependências conflitantes e difíceis de reproduzir.
2. Habilidades Não Estruturadas: Capacidades úteis escondidas em código não documentado.
3. Lacuna Semântica: Mesmo que o código funcione, falta uma interface clara (ex: "cartões de agente") para que outros agentes entendam como invocá-lo.

2. Metodologia

Os autores propõem um processo formalizado de Agentização, focado em repositórios de código como caso de uso representativo devido à sua complexidade.

A. Definição do Processo (4 Estágios)
O processo mapeia um ativo digital ( $D$ ) para um agente compatível com o protocolo A2A (Agent-to-Agent):

Configuração do Ambiente ( $E$ ): Criação de um ambiente executável e reprodutível (ex: contêineres) que encapsula as dependências do ativo.
Extração de Habilidades como Ferramentas ( $T$ ): Identificação, encapsulamento e validação de funções atômicas do repositório como ferramentas executáveis.
Instanciação do Agente Interno ( $A_{in}$ ): Construção da arquitetura cognitiva do agente, integrando as ferramentas extraídas em um loop de raciocínio (ex: ReAct).
Agentização Final (Geração do Cartão de Agente $C$ ): Criação de um registro de autodescrição (Agent Card) que detalha a identidade e as ferramentas disponíveis, permitindo a descoberta por outros agentes.

B. O Agente de Agentização (A2A-Agentization Agent)
Foi desenvolvido um framework autônomo projetado para executar os quatro estágios acima, resolvendo inconsistências de ambiente, extraindo habilidades não estruturadas e preenchendo a lacuna semântica para transformar repositórios brutos em agentes funcionais.

C. O Benchmark: A2A-Agentization Bench
Para avaliar rigorosamente essa capacidade, os autores criaram o primeiro benchmark dedicado à qualidade da agentização.

Dados: 35 repositórios GitHub diversos (9 domínios: visão, documentos, segurança, química, finanças, etc.) e 522 instâncias de avaliação.
Tarefas:
- Single-Repo: Tarefas que testam a herança de capacidades (o agente consegue executar o que o repositório promete?).
- Multi-Repo: Tarefas que exigem colaboração entre múltiplos agentes (interoperabilidade).
Métricas Principais:
- Fidelidade: Precisão na execução das habilidades extraídas.
- Interoperabilidade: Capacidade de ser invocado e orquestrado por outros agentes (qualidade do "Cartão de Agente").

3. Principais Contribuições

Conceito e Formalização: Definição rigorosa da "Agentização de Ativos Digitais" como uma tarefa de desenvolvimento autônomo em nível de repositório, visando a interoperabilidade via protocolo A2A.
Framework de Agentização: Proposta do A2A-Agentization Agent, um sistema automatizado que converte repositórios em agentes compatíveis com a Web Agêntica.
Novo Benchmark (A2A-Agentization Bench): Primeira avaliação abrangente do ciclo de vida completo da agentização, focando em fidelidade e interoperabilidade, com tarefas de um e múltiplos repositórios.
Análise Empírica: Avaliação de quatro frameworks de ponta (Claude Code, Codex CLI, OpenHands, EnvX) revelando gargalos críticos e fornecendo um roteiro para pesquisa futura.

4. Resultados Experimentais

Os experimentos foram conduzidos comparando diferentes frameworks de agentes de código:

Sucesso no Processo de Agentização (Stage 1):
- Claude Code e EnvX alcançaram 100% de sucesso na criação do agente (Pass@1), demonstrando robustez na configuração de ambientes e geração de esquemas.
- Outros frameworks (Codex, OpenHands) tiveram taxas ligeiramente menores, exigindo múltiplas tentativas.
Herança de Capacidades (Stage 2 - Single-Repo):
- Claude Code obteve a maior taxa de sucesso geral na execução de tarefas (36.9%).
- EnvX foi muito competitivo (35.1%) e mais eficiente em tokens, graças à sua configuração de ambiente pré-validada.
- A maioria dos agentes falhou em tarefas "Hard" (difíceis), indicando que a execução complexa ainda é um desafio.
Execução Colaborativa (Stage 3 - Multi-Repo):
- Qualidade da Especificação: EnvX e Claude Code tiveram as melhores pontuações de F1 na descrição das habilidades (Agent Cards), o que é crucial para o orquestrador entender o que o agente faz.
- Sucesso de Orquestração: Agentes com melhores descrições (EnvX, Claude) mantiveram maior robustez em cadeias longas de colaboração.
- Execução Final: Curiosamente, OpenHands teve a maior taxa de sucesso na execução final (46.2%) em tarefas colaborativas, apesar de ter uma taxa de orquestração menor, sugerindo que seu motor de execução é excepcionalmente robusto, mesmo quando a descoberta de tarefas não é perfeita.

Análise de Falhas (Lições Aprendidas):

Configuração de Ambiente: Falhas aqui levam a custos excessivos de tokens e tempo (ex: tentativa de instalar pacotes manualmente).
Construção de Habilidades: Assinaturas de funções incorretas ou APIs "alucinadas" (inexistentes) impedem a execução.
Especificação de Capacidades: Descrições genéricas nos cartões de agente confundem o orquestrador, impedindo o roteamento correto de tarefas.

5. Significado e Impacto

Este trabalho é fundamental para a evolução da Web Agêntica porque:

Resolve o Gargalo de Escala: Oferece um caminho automatizado para transformar o vasto ecossistema de software existente (repositórios de código) em agentes interoperáveis, sem necessidade de reescrita manual.
Padronização: Estabelece a importância de protocolos como A2A e a necessidade de "Cartões de Agente" precisos para a descoberta e colaboração.
Direção Futura: Identifica que, para a Web Agêntica amadurecer, a pesquisa deve focar em três pilares: pré-configuração robusta de ambientes, construção confiável de habilidades (sem alucinações) e descrições semânticas claras para colaboração multi-agente.

Em resumo, o artigo demonstra que a agentização automática é viável, mas ainda enfrenta desafios significativos de confiabilidade e interoperabilidade que devem ser superados para que a Web Agêntica atinja seu potencial de inteligência coletiva em larga escala.