Uma barreira importante, e comum, para o sucesso dos agentes de IA em escala corporativa são as APIs legadas. Instável e frágil, essa infraestrutura antiga continuará no centro da TI corporativa por muitos anos.

Para aproveitar tudo o que a era agêntica tem a oferecer, as empresas precisam disponibilizar sua infraestrutura e suas funcionalidades legadas para os Large Language Models (LLMs).

A melhor maneira de fazer isso? Eliminar a ambiguidade das APIs ao encapsulá-las em pipelines determinísticos expostos como ferramentas MCP.

Nenhuma outra solução disponível atualmente, por mais sofisticada que seja, consegue realizar esse trabalho com segurança.

O contexto da execução de código baseada em agentes

Falando em soluções sofisticadas, Anthropic e Cloudflare exploraram recentemente os benefícios de construir sistemas de LLMs que escrevem código para executar tarefas. Nessa abordagem, o modelo cria uma solução utilizando trechos de código fornecidos por meio de um sistema de arquivos, junto com a descrição da tarefa. Um ambiente sandbox executa o script e retorna os resultados ao LLM, que continua seu workflow.

Essa abordagem funciona para tarefas mais simples que utilizam sistemas modernos, com abstrações bem documentadas e que podem ser importadas. Ela resolve problemas reais do Model Context Protocol (MCP) relacionados a desempenho e uso de contexto, mas ignora limitações importantes impostas pelas APIs corporativas legadas.

Como qualquer engenheiro de integração que trabalha em ambientes corporativos sabe, essas interfaces, muitas vezes customizadas, verbosas e fortemente vinculadas a sistemas críticos, não serão substituídas da noite para o dia.

Para que agentes de IA gerem impacto relevante no curto prazo, eles precisam conectar ecossistemas modernos e eficientes em código, viabilizados por MCP e execução de código, ao cenário persistente de sistemas legados que sustentam operações globais.

APIs legadas não vão desaparecer

Empresas com décadas de operação dependem de SOAP, XML-RPC, SDKs customizados ou interfaces proprietárias que não foram projetadas para automação agêntica. Esses sistemas mantêm registros contábeis, movimentam cargas, processam sinistros e direcionam os pagamentos que mantêm operações globais funcionando.

Esses sistemas continuarão existindo: representam bilhões de dólares em investimentos em infraestrutura e obrigações de compliance e confidencialidade. Cada chamada de API incorpora conhecimento institucional, lógica de negócio e dependências operacionais que não podem simplesmente ser "modernizados" por determinação.

Portanto, agentes baseados em LLMs precisarão trabalhar com eles. Mas, ao utilizar APIs legadas diretamente, LLMs muitas vezes improvisam de maneira inadequada ou recuperam a string errada durante interações sem restrições, provocando erros e interrompendo o workflow. Mediar essas interações por meio de código escrito em tempo real pouco ajuda a reduzir esses modos de falha.

O problema da autonomia no nível das APIs

A autonomia no nível das APIs permite que LLMs ou agentes interajam diretamente com APIs. Eles raciocinam sobre o schema ou a documentação, decidem quais chamadas realizar, montam parâmetros, determinam a sequência das interações e interpretam as respostas, tudo dinamicamente durante a execução.

Em teoria, isso permite que os agentes se adaptem a documentações incompletas e interfaces legadas. Na prática corporativa, porém, a autonomia no nível das APIs apresenta riscos por três motivos principais:

• APIs com muitas interações: APIs web vinculadas a processos de negócio exigem sequenciamento cuidadoso, autenticações repetidas e trocas passo a passo. Cada etapa aumenta a possibilidade de o LLM interpretar requisitos incorretamente, fornecer valores errados aos parâmetros ou esquecer informações anteriores. Um único erro pode comprometer todo o processo.
• Sensibilidade dos dados: APIs legadas frequentemente expõem informações de identificação pessoal (PII). Sem controles rigorosos, dados sensíveis podem entrar no contexto de trabalho do modelo ou nos logs das ferramentas, criando riscos significativos de compliance e confidencialidade.
• Processos sensíveis: um agente que falha ao consultar um registro em modo read-only gera um pequeno inconveniente. Um agente que falha no meio de uma tarefa de criação de conta pode obrigar as equipes de suporte a correr para resolver o problema.

Pesquisadores encontraram resultados pouco expressivos ao permitir que agentes interajam livremente com APIs HTTP. Um estudo de 2024 constatou que um agente baseado no GPT-4o chegou ao resultado correto utilizando APIs em apenas 29% das tentativas.

Programação agêntica não é a resposta

Na abordagem apresentada pela Anthropic e pela Cloudflare, LLMs escrevem código TypeScript em tempo real para realizar tarefas relativamente simples. Os modelos conseguem combinar abstrações bem documentadas com facilidade graças à grande quantidade de dados de programação presentes em seu treinamento.

Isso não funciona da mesma forma para APIs corporativas legadas que não possuem camadas de abstração ou SDKs que possam ser importados. Os modelos poderiam escrever diretamente as interações com as APIs, mas isso adicionaria ruído: APIs corporativas não seguem comportamentos uniformes, deixando o LLM responsável por inferir a abordagem adequada.

Para aumentar a complexidade, processos de negócio frequentemente exigem uma ordem rígida de execução das tarefas.

Em uma interface de reserva de passagens aéreas, por exemplo, o sistema precisa:

• Reservar temporariamente o assento escolhido pelo cliente.
• Processar o pagamento do cliente.
• Confirmar a reserva do assento.
• Enviar uma mensagem de confirmação.

Processe o pagamento antes de reservar temporariamente o assento e o cliente pode pagar por um lugar que não receberá. Confirme o assento antes do pagamento e o cliente pode ficar com ele sem pagar.

A necessidade de novas tentativas amplia esses possíveis custos. Mesmo com toda a documentação da API disponível durante a inferência, LLMs podem precisar de várias tentativas para escrever um código que execute corretamente o processo de ponta a ponta. No exemplo acima, um LLM que precise de duas tentativas para concluir o workflow pode cobrar o cliente duas vezes.

Além disso, tentativas iterativas de programação aumentariam significativamente as janelas de contexto e a latência. Elas também poderiam dificultar a manutenção adequada de registros caso a empresa precise de logs no nível do código, além dos logs das interações com as APIs.

A resposta: pipelines MCP encapsulados para APIs legadas

Em vez de expor cada requisição e resposta de baixo nível, os agentes deveriam interagir com sistemas legados por meio de pipelines predefinidos e governados por código, que garantem a execução dos processos de negócio e absorvem a complexidade operacional em nome dos agentes.

Cada pipeline funciona como um ambiente controlado de execução, gerenciando autenticação, recuperação de erros e transformação de dados antes que qualquer resultado chegue à janela de contexto do agente.

Essa arquitetura:

• Minimiza o uso de tokens.
• Reduz o risco de falhas em cascata.
• Garante a execução dos processos de negócio.
• Melhora a eficiência do contexto.
• Protege a privacidade dos dados.

Os desenvolvedores podem programar esses pipelines diretamente ou construí-los por meio de uma plataforma de integração low-code. Com a Digibee, os usuários criam abstrações no nível dos endpoints para APIs de negócio e as conectam em uma interface drag-and-drop. Também podem incluir blocos de tratamento de erros para modos de falha comuns e disponibilizar a ferramenta em um servidor MCP com poucos cliques. A partir daí, qualquer agente pode utilizá-la, tenha sido ele construído na Digibee ou não.

Ao encapsular as funcionalidades das APIs, o pipeline minimiza a interação direta do agente. O agente fornece os parâmetros necessários e recebe apenas as informações finais de que precisa. Todas as interações intermediárias, incluindo dados sensíveis, permanecem fora da memória de trabalho do modelo.

Essa abordagem conecta a execução de código por LLMs à realidade complexa dos sistemas corporativos antigos que talvez nunca sejam modernizados. Os pipelines encapsulados fornecem a camada de conexão que permite que agentes de IA atuem de forma inteligente tanto em ambientes modernos quanto legados.

Exemplo: conectando ecossistemas modernos e legados

Vamos a um exemplo. Uma pessoa em viagem de negócios pergunta a um chatbot de atendimento ao cliente quais de seus próximos voos podem receber um upgrade para a primeira classe.

Então, acontece o seguinte:

1. O agente aciona a ferramenta: get_upgrade_opportunities(customer_id).
2. Dentro do pipeline, de forma invisível para o agente:
   • Autentica na API legada da companhia aérea.
   • Recupera todas as próximas reservas do cliente.
   • Cruza as reservas com a disponibilidade de assentos de cada voo.
   • Filtra os voos em que há assentos disponíveis na primeira classe e o cliente está na classe econômica.
   • Transforma os dados em um formato limpo e estruturado.
3. O pipeline retorna apenas as oportunidades de upgrade relevantes para o contexto do agente.
4. O agente apresenta as informações ao cliente.

Caso o cliente decida fazer o upgrade, o agente executaria a solicitação por meio de outro pipeline MCP: process_seat_upgrade(booking_id, new_seat_class).

Esse pipeline cuidaria internamente de todo o processo em múltiplas etapas, reservando temporariamente o assento, processando o pagamento, confirmando a reserva e enviando a confirmação, tudo como um único workflow determinístico.

O que isso significa?

• O agente nunca interage diretamente com as APIs legadas, nunca escreve código de filtragem e nunca precisa gerenciar o sequenciamento complexo.
• Ele simplesmente orquestra pipelines MCP pré-construídos e auditáveis que encapsulam processos de negócio conhecidos.

Essa abordagem equilibrada combina a confiabilidade dos workflows determinísticos com a flexibilidade do raciocínio agêntico.

O caminho prático para agentes de IA prontos para ambientes corporativos

O potencial dos agentes de IA é enorme. Transformar esse potencial em realidade exige mais do que avanços em raciocínio ou na arquitetura dos modelos. É necessária uma infraestrutura que permita aos agentes operar tanto sistemas modernos quanto aqueles construídos há décadas.

A execução de código resolve parte desse problema ao oferecer eficiência, escalabilidade e controle para integrações modernas. Mas, sem um suporte equivalente para interfaces legadas, até os agentes mais capazes terão dificuldade para gerar resultados onde eles mais importam.

Com a Digibee, os desenvolvedores podem fechar essa lacuna. Ao encapsular interações com APIs legadas em pipelines seguros e combináveis, a Digibee oferece aos agentes de IA uma interface consistente e governada por código para todos os sistemas com os quais interagem, seja um ambiente cloud-native ou um data center construído há vinte anos.

À medida que as empresas exploram formas de implementar agentes com responsabilidade e em escala, a Digibee fornece a infraestrutura necessária. Mais do que uma ponte entre sistemas antigos e novos, ela funciona como a camada de orquestração que torna possível uma verdadeira automação híbrida.

‍