Uma barreira fundamental (e comum) para o sucesso de agentes de Inteligência Artificial (IA) em grandes empresas são as APIs legado. Frágil e temperamental, essa infraestrutura mais antiga permanecerá como coração do universo do TI corporativo por um bom tempo. 

Para aproveitar todo o potencial da era dos agentes, as organizações precisam tornar sua infraestrutura e funcionalidades legado acessíveis aos LLMs.

Qual é a melhor maneira de fazer isso? Eliminar a ambiguidade das APIs ao empacota-las em pipelines determinísticos, expostos como ferramentas do Protocolo de Contexto do Modelo (MCP).

Nenhuma outra solução atualmente disponível (por mais engenhosa que seja) pode fazer esse trabalho com segurança.

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

Recentemente, a Anthropic e a Cloudflare exploraram os benefícios de construir sistemas LLM que escrevem códigos para realizar tarefas. Nessa abordagem, o modelo codifica uma solução usando trechos de código fornecidos por um sistema de arquivos, juntamente com a descrição da tarefa. Um ambiente sandbox executa o script e retorna as saídas para o LLM, que continua seu fluxo de trabalho.

Esse caminho atende a tarefas mais simples que usam sistemas modernos com abstrações bem documentadas e importáveis. Ele aborda problemas reais do MCP relacionados ao desempenho e uso de contexto, mas negligencia as restrições significativas impostas pelas APIs corporativas.

Como qualquer engenheiro de integração sabe, essas interfaces, frequentemente personalizadas e ligadas a sistemas críticos, não serão substituídas da noite para o dia.

Para que os agentes de IA entreguem um impacto significativo a curto prazo, eles devem criar uma ponte entre os ecossistemas modernos e eficientes em código (habilitados por MCP e execução de código) e o cenário persistente de sistemas legados que impulsionam as operações globais.

Porque as APIs legado não vão a lugar nenhum

Empresas estabelecidas dependem de tecnologias como SOAP, XML-RPC, SDKs personalizados ou interfaces proprietárias que não foram projetadas para a automação por agentes. Esses sistemas mantêm registros, movimentam remessas, processam sinistros e roteiam os pagamentos que mantêm as operações globais em funcionamento.

Esses sistemas irão resistir: eles representam bilhões de dólares em investimento em infraestrutura e obrigações de compliance. Cada chamada de API incorpora conhecimento institucional, lógica de negócios e dependências operacionais que não podem ser simplesmente “modernizadas” por decreto.

Portanto, os agentes apoiados por LLMs precisarão trabalhar com eles. No entanto, ao usar APIs legado diretamente, os LLMs frequentemente improvisam de forma inadequada ou recuperam a string errada durante interações não controladas, causando um erro e interrompendo o fluxo de trabalho. A mediação dessas interações por meio de codificação em tempo real faz pouco para mitigar os modos de falha.

O risco da autonomia em nível de API

A autonomia em nível de API permite que LLMs ou agentes interajam diretamente com as APIs. Eles raciocinam sobre o esquema ou documentação, decidem quais chamadas fazer, montam parâmetros, sequenciam as interações e interpretam as respostas. Tudo dinamicamente durante a execução.

Em tese, isso permite que os agentes se adaptem a documentação incompleta e interfaces legado, mas na realidade, a autonomia em nível de API é arriscada por três motivos principais:

• APIs “tagarelas”: APIs baseadas na web ligadas a processos de negócios esperam um sequenciamento cuidadoso, autenticação repetida e trocas passo a passo. Cada etapa aumenta o potencial do LLM interpretar mal os requisitos, fornecer valores de parâmetro incorretos ou esquecer contextos anteriores. Um único erro pode inviabilizar todo o processo.
  
• Sensibilidade dos dados: APIs legado frequentemente expõem informações de identificação pessoal (PII). Sem controles rígidos, dados sensíveis podem entrar no contexto de trabalho do modelo ou nos logs da ferramenta, criando riscos significativos de compliance e confidencialidade.
  
• Processos sensíveis: Um agente que falha em uma simples extração de registro read-only cria uma pequena frustração. Um agente que falha no meio de uma tarefa de criação de conta pode causar um grande problema para o time de suporte.

Pesquisadores encontraram resultados insatisfatórios ao permitir que agentes interagissem livremente com APIs HTTP. Um estudo de 2024 descobriu que um agente apoiado pelo GPT-4o alcançou o resultado correto usando APIs em apenas 29% das vezes.

A codificação por agentes não é a solução

Anthropic e Cloudflare recentemente delinearam uma abordagem para LLMs escreverem código TypeScript em tempo real para realizar tarefas simples. Os LLMs unem abstrações bem documentadas devido ao seu amplo treinamento em dados de codificação com grande acurácia.

Isso não funcionará para APIs corporativas legado que carecem de camadas de abstração ou SDKs importáveis. Os modelos poderiam codificar interações de API diretamente, mas isso introduz ruído; as APIs corporativas não seguem comportamentos uniformes, deixando o LLM a adivinhar a abordagem apropriada.

Adicionando complexidade, os processos de negócios muitas vezes exigem uma ordenação rígida das tarefas.

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

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

Se processar o pagamento antes da reserva do assento, o cliente pode pagar por um assento que não recebe. Se reservar o assento antes do pagamento, o cliente pode conseguir o assento gratuitamente.

A iteração amplifica esses custos potenciais. Mesmo com a documentação completa da API no momento da inferência, os LLMs podem exigir várias tentativas para escrever um código que seja executado com sucesso de ponta a ponta. No exemplo acima, um LLM que requer duas tentativas para completar o fluxo de trabalho poderia cobrar o cliente duas vezes.

Agravando essas questões, as tentativas de codificação iterativa aumentariam as janelas de contexto e aumentariam a latência. Elas também poderiam impedir o registro adequado se o negócio precisar de logs em nível de código, além dos logs das interações de API.

A solução: Pipelines MCP encapsulados para APIs legado

Em vez de expor cada solicitação e resposta de baixo nível, os agentes devem interagir com os sistemas legados por meio de pipelines predefinidos e governados por código que impõem processos de negócios e absorvem a complexidade operacional em nome deles.

Cada pipeline funciona como um ambiente de execução controlado, gerenciando a autenticação, a recuperação de erros e a 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 sequênciais.
• Impõe processos de negócios.
• Melhora a eficiência do contexto.
• Protege a privacidade dos dados.

Os desenvolvedores podem codificar esses pipelines diretamente ou construí-los por meio de uma plataforma de integração low-code. Com a Digibee, os usuários constroem abstrações em nível de endpoint para APIs de negócios e as encadeiam em uma interface drag-and-drop. Eles podem até incluir blocos de tratamento de erros para modos de falha comuns e implantar a ferramenta em um servidor MCP com apenas alguns cliques. A partir daí, qualquer agente pode usá-la, seja ele construído na Digibee ou não.

Ao envolver a funcionalidade da API, o pipeline minimiza a interação direta do agente. O agente fornece os parâmetros necessários e recebe apenas a informação final exigida. Todas as trocas intermediárias (e dados sensíveis) permanecem fora da memória de trabalho do modelo.

Essa abordagem fundamenta a execução de código do LLM na realidade complexa de sistemas corporativos arcaicos que talvez nunca sejam modernizados. Os pipelines encapsulados fornecem o tecido conjuntivo que permite aos agentes de IA agirem de forma inteligente em ambientes modernos e legados.

Exemplo: Conectando ecossistemas modernos e legados

Vamos a um exemplo prático: Uma pessoa vai viajar e pergunta a um chatbot de suporte sobre quais de seus próximos voos ela pode fazer upgrade para a primeira classe.

Em seguida, o que acontece é uma orquestração inteligente:

1. O agente de IA invoca uma tool de pipeline MCP (como as criadas na Digibee): get_upgrade_opportunities(customer_id).
2. Dentro do pipeline (invisível para o agente):
   • Autenticação na API legado da companhia aérea.
   • Recuperação de todas as reservas futuras da cliente.
   • Cruzamento de dados de disponibilidade de assentos entre os voos.
   • Filtro para voos que têm assentos disponíveis na primeira classe e onde a cliente está na classe econômica coach.
   • Transformação dos 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 a informação ao cliente.

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

Este pipeline lidaria internamente com todo o processo de múltiplas etapas (bloquear o assento, processar o pagamento, confirmar a reserva e enviar a confirmação) como um único workflow determinístico.

O que isso significa?

• O agente nunca toca nas APIs legado diretamente, nunca escreve código de filtragem e jamais gerencia o sequenciamento complexo.
• Ele simplesmente orquestra pipelines MCP pré-construídos e auditáveis que encapsulam processos de negócio conhecidos.

Essa abordagem equilibrada entrega tanto a confiabilidade de workflows determinísticos quanto a flexibilidade do raciocínio agentivo da IA.

O caminho prático para agentes de IA prontos para o ambiente corporativo

A promessa dos agentes de IA é enorme. Cumprir essa promessa exige mais do que avanços em raciocínio ou arquitetura de modelos. Exige uma infraestrutura que permita aos agentes operar tanto sistemas modernos quanto aqueles de décadas atrás.

A execução de código resolve uma parte desse problema: permitindo eficiência, escalabilidade e controle para integrações modernas. Mas sem suporte equivalente para interfaces legado, até os agentes mais capazes terão dificuldades em entregar resultados onde eles mais importam.

Com a Digibee, os desenvolvedores podem resolver esse problema. Ao encapsular as interações de API legado dentro de pipelines seguros e que podem ser compostos, a Digibee oferece aos agentes de IA uma interface consistente e governada por código para cada sistema que eles tocam, seja ele cloud-native ou rodando em um data center construído vinte anos atrás.

À medida que as organizações exploram como implantar agentes de forma responsável e em escala, a Digibee fornece a fundação que faltava. Não é apenas uma ponte entre sistemas antigos e novos, é a camada de orquestração que torna possível a verdadeira automação híbrida.