---
schema_version: "1"
id: 53df9fbee3e971fc742d4f9f865381b8b394f279c046006052f8eab310287b14
title: Arquitetura da empresa agente com o MuleSoft
collection: architect
version: current
locale: pt-br
portal_url: https://docs.salesforce.com/architect/current/pt-br/fundamentals/guides/mulesoft-architecting-agentic-enterprise.md
canonical_url: https://architect.salesforce.com/docs/architect/pt-br/fundamentals/guide/mulesoft-architecting-agentic-enterprise.html
source_site: architect.salesforce.com
content_type: documentation
content_hash: f83ec26fd07c56f6e7f7fd1361301426c9b5e6d931d92cc0b9b9e638e9609606
products:
- Fundamentos
- Architect Site Content Repo
updated_at: 2025-10-01T00:00:00Z
---
# Da integração composta para uma empresa governada por agentes
A transição para a Enterprise do agente representa a mudança arquitetônica mais significativa desde o nascimento da nuvem. Ela promete níveis sem precedentes de produtividade e automação, mas também apresenta desafios profundos relacionados à governança, à segurança e à complexidade operacional. Usar uma abordagem fragmentar – implantar agentes em silos sem uma estratégia unificadora – é um caminho direto para dívida técnica e caos organizacional.
Implantar agentes sem um plano de gerenciamento central cria um risco operacional significativo, incluindo vulnerabilidades de segurança de acesso direto ao sistema, falta de observabilidade nas interações e ações do agente e altos custos devido a integrações redundantes de ponto a ponto. Essa estratégia de implementação isolada resulta em um ambiente vulnerável que é difícil de gerenciar em escala. Um modelo sustentável requer uma plataforma unificada para integração e governança de agentes.
A _MuleSoft_ fornece uma plataforma aberta, unificada e abrangente para orientar com confiança as empresas em toda a sua jornada. Ele aproveita o panorama de API existente da empresa como a base para ações de agentes e acelera a criação de novos ativos prontos para agentes por meio de um ciclo de vida de desenvolvimento baseado em IA confiável. Por meio do suporte de nível corporativo para padrões abertos, como protocolos de Protocolo de contexto de modelo (MCP) e Agent2Agent (A2A), ele torna esses ativos acionáveis para comandos simples e colaboração complexa de vários agentes, independentemente de como o panorama da IA evolui. O [_MuleSoft Agent Fabric_](https://docs.mulesoft.com/agent-fabric/) fornece uma solução para descobrir, orquestrar, controlar e observar todo o ecossistema do agente. Através dessa abordagem integrada, a _MuleSoft Agent Fabric_ fornece uma base comprovada para escalar uma rede de agentes de IA confiáveis, que transforma a promessa da IA em resultados de negócios tangíveis e automatizados e realiza todo o potencial da empresa inteligente.
## **A base composta para IA acionável**
A abordagem de três camadas estabelecida da conectividade conduzida por API (APIs de sistema, processo e experiência) fornece uma estrutura eficiente para estruturar a capacidade de ação do agente.
- As **APIs do sistema** oferecem uma interface consistente, segura e abstrata para os sistemas de registro subjacentes. Eles desconectam os agentes da complexidade de protocolos de back-end e modelos de dados, o que garante que todas as ações do agente sejam realizadas em pontos de extremidade governados e confiáveis.
- As **APIs de processo** encapsulam lógica de negócios complexa e de várias etapas. Os agentes não precisam entender a orquestração complexa por trás da criação de pedidos de vendas, da verificação de inventário ou do início de envios. Eles podem usar as APIs de processo (por exemplo, "Ordem do processo") sem precisar lidar com as complexidades subjacentes. As APIs de processo fornecem um mecanismo seguro, transacional e auditável para os agentes executarem processos de negócios, o que reduz drasticamente o raciocínio necessário do agente e garante que as regras de negócios sejam aplicadas de maneira consistente.
- **As APIs de experiência** foram tradicionalmente projetadas para servir aplicativos específicos da IU (por exemplo, o Aplicativo de gerenciamento de pedidos); no entanto, elas também podem ser reutilizadas como ações repletas de contexto para agentes. Isso fornece aos agentes informações essenciais para realizar uma determinada tarefa sem exigir várias chamadas a sistemas downstream.
## 1\. Criação generativa: Acelerar o desenvolvimento de ativos prontos para o agente
Para atender à crescente demanda por ferramentas e recursos prontos para agentes, as empresas devem acelerar o desenvolvimento das APIs e integrações que formam a base composta. A _MuleSoft_ lida com esse desafio integrando a IA generativa diretamente no ciclo de vida do desenvolvimento, o que cria um ciclo virtuoso que usa a IA para criar os ativos de alta qualidade que outros agentes consomem.
### **1.1 MuleSoft Vibes**
Para os desenvolvedores, a [MuleSoft Vibes](https://www.mulesoft.com/platform/api/anypoint-code-builder/announcing-mulesoft-vibes) atua como um parceiro inteligente automatizando os aspectos mais repetitivos do desenvolvimento de integração e fornecendo uma interface unificada e agente para todo o ciclo de vida do desenvolvimento de software. Por meio do MuleSoft Vibes no [Anypoint Code Builder](https://docs.mulesoft.com/anypoint-code-builder/), os desenvolvedores interagem com recursos generativos que são alimentados pelos [confiáveis Pipelines _Einstein AI_](https://blogs.mulesoft.com/automation/how-mulesoft-turns-generative-output-into-value/), o que torna o processo de desenvolvimento assistido por IA suave e eficiente. Este pipeline - o _Service de Execução de Gráfico de Inferência (IGES)_ \- é um processo de várias etapas usado para obter resultados de alta qualidade. Ele consiste em fundamentação, validação, correção de erros e avaliação rigorosa.
- A funcionalidade de Fluxos [**gerativos**](https://blogs.mulesoft.com/dev-guides/einstein-for-acb/) no _MuleSoft Vibes_ é baseada na estrutura de IA _Agentforce_. Ele transforma a lógica de negócios de linguagem natural (Avisos do usuário) em aplicativos do Mule funcionais. O _Pipeline IGES_ consiste nas seguintes etapas:
- **Resumo do histórico da conversa:** O LLM analisa o aviso atual e as mensagens anteriores do usuário para criar um aviso resumido que captura a intenção do usuário e o histórico da conversa. Esse aviso consolidado melhora a precisão das etapas subsequentes de recuperação e geração de dados.
- **Recuperação semântica do fluxo de um banco de dados vetorial:** O sistema pega o aviso resumido da etapa anterior e realiza uma pesquisa semântica em um banco de dados vetorial que contém mais de 200 conectores, mais de 7.000 operações de conector e mais de 7.000 snippets de código de amostra. Ele recupera os conectores, operações e exemplos de código mais relevantes para fundamentar o processo de geração usando dados precisos e garante que as saídas estejam alinhadas ao extenso ecossistema do conector da MuleSoft. Como o MuleSoft é o padrão do setor para conectores e operações, essa fundamentação fornece ao modelo uma rigorosa precisão de contexto e domínio que os LLMs genéricos não têm.
- **Aumento:** O conteúdo recuperado e as mensagens do histórico da conversa então são combinadas com o aviso resumido. Esse aviso aumentado conduz o LLM para reduzir alucinações. Ele também inclui instruções para evitar a geração de conteúdo tóxico.
- **Geração de fluxo:** Esta etapa utiliza o modelo _Einstein AI LLM_ para gerar código XML bruto baseado no contexto e exemplos fornecidos. Esta é a etapa principal do pipeline de geração.
- **Pós-processamento e validação:** O pós-processador e o validador verificam o código para garantir a sintaxe correta e o uso de operações válidas do conector enquanto uma verificação de toxicidade separada sinaliza conteúdo prejudicial.
- **Corrigência de erro de várias etapas:** Se todas as gerações iniciais forem inválidas, o mecanismo de correção de erro automatizado analisará as mensagens de erro para detectar padrões. Em seguida, ele reenvia o aviso para o LLM junto com mensagens de erro aprimoradas e metadados corretivos.
- **Geração de arquivo de configuração:** Esta etapa extrai metadados do conector relevantes, aumenta o aviso e os envia ao LLM para gerar configurações de conector precisas. Por fim, todos os namespaces POM e XML são gerados de modo determinístico usando a versão mais recente de cada dependência, o que elimina alucinações e garante consistência.
- A geração de transformação [**DataWeave**](https://blogs.mulesoft.com/dev-guides/dataweave-generative-transformation/)**:** A transformação de dados é frequentemente a parte mais demorada do desenvolvimento de integração. A _MuleSoft Vibes_ lida com esse processo usando a abordagem de várias etapas semelhante à geração do _Mule Flow XML_.
- **Reasoning of Intention:** O LLM analisa amostras de dados de entrada e saída do usuário para inferir e articular a lógica de transformação de alto nível em linguagem natural. Essa etapa separa a meta do usuário dos valores de dados literais que podem ter sido fornecidos no aviso.
- **Recuperação semântica do DataWeave:** Para localizar a documentação da função DataWeave mais relevante semanticamente e os exemplos de transformação concluídos, o sistema usa o aviso gerado da etapa anterior como uma consulta para o banco de dados do vetor. Isso baseia o processo de geração em informações verificadas de alta qualidade.
- **Aumento:** As funções e exemplos recuperados são combinados com o aviso do usuário original para criar um conjunto de instruções sensível ao contexto para a chamada de LLM subsequente, o que influencia o comportamento do LLM para reduzir alucinações.
- **Geração de DataWeave:** Esta etapa utiliza o modelo de LLM para gerar um script de transformação do DataWeave e uma explicação que acompanha baseada no contexto e nos exemplos fornecidos. Esta é a etapa principal do pipeline de geração.
- **Pós-processamento e validação** O script gerado é avaliado com base em duas métricas específicas: validade e correção. O script deve ser compilado sem erros de sintaxe (validade) e produzir a saída esperada quando for executado usando a entrada de amostra (correcção).
- **Corrigência de erro de várias etapas:** Se a validação inicial falhar, esse plugin identificará as categorias de erro e corrigirá os problemas no script gerado. Esse refinamento ajuda a melhorar a taxa de sucesso geral e a precisão do sistema.
- **Processamento e validação finais** O script corrigido do módulo de correção de erros passa por um processo de nova validação para garantir que seja sintaxicamente válido e funcionalmente correto. Esse gate de qualidade final garante que a saída seja precisa e confiável antes de enviá-la de volta ao usuário.
- Os desenvolvedores de [**especificação de API**](https://docs.mulesoft.com/anypoint-code-builder/api-ai-create-spec) **e geração de [documentação](https://docs.mulesoft.com/exchange/generating-documentation-with-ai):** podem gerar especificações _OpenAPI (OAS)_ ou _RAML_ totalmente validadas descrevendo a API desejada em linguagem natural. O _MuleSoft Vibes_ ingere o aviso (que inclui detalhes sobre recursos, métodos, esquemas de segurança e parâmetros) e produz uma definição de API válida e sintaxicamente correta. Após a geração, ele pode criar documentação para a API no _Anypoint Exchange_, que cobre tudo, desde autenticação até detalhes do ponto de extremidade e tratamento de erros, liberando os desenvolvedores desses tipos de tarefas tediosas.
- **Geração de MUnit assistida por IA:** A garantia de qualidade é fundamental para ativos consumidos por agentes autônomos. A _MuleSoft Vibes_ ajuda a gerar casos de teste do MUnit diretamente do Código de fluxo do Mule. Isso ajuda a simular dependências e declarações externas e identificar lacunas de teste comuns, o que reduz drasticamente o esforço manual necessário para alcançar uma alta cobertura de teste e garantir a confiabilidade da lógica de integração.
### **1.2 MuleSoft do seu jeito**
Os desenvolvedores prosperam em seus ambientes preferidos. É por isso que a _MuleSoft_ encontra desenvolvedores onde estão, o que lhes permite criar integrações em seu IDE de IA preferido. O [Model Context Protocol (MCP) Server da MuleSoft](https://www.npmjs.com/package/@mulesoft/mcp-server) expõe recursos de desenvolvimento, implantação e gerenciamento como ferramentas MCP que qualquer IDE nativa de IA baseada em VS Code (por exemplo, Cursor, Windsurf ou Trae) pode consumir para interagir com a _Plataforma Anypoint_ usando linguagem natural.
Ao empacotar sua funcionalidade IDE principal em uma [extensão padrão do VS Code](https://marketplace.visualstudio.com/items?itemName=salesforce.mule-dx-extension-pack), a _MuleSoft_ desacopla suas ferramentas de um shell IDE de marca, o que permite que as ferramentas de desenvolvimento sejam agnósticas ao IDE. Em vez de competir com a rápida evolução dos IDEs, essa escolha de arquitetura permite que as ferramentas de desenvolvimento da MuleSoft permaneçam compatíveis e acessíveis em todo o ecossistema crescente de IDEs modernos baseados em IA.
## 2\. Habilitar capacidade de ação: Transformar APIs em ferramentas para agentes
Em uma empresa agente, ter uma base robusta de APIs composíveis é necessário, mas insuficiente. A próxima etapa crítica é garantir que esses ativos sejam descobríveis, compreensíveis e invocáveis pelos agentes de IA. Isso exige uma "camada de capacidade de ação" criada com base em padrões abertos projetados especificamente para comunicação agente. A _MuleSoft_ fornece ferramentas de nível empresarial para os dois protocolos emergentes dominantes:
- **MCP** para interações entre agentes
- **A2A** para interações entre agentes
### **2.1 Protocolo de contexto modelo (MCP)**
O _MCP_ rapidamente surgiu como o padrão da indústria para comunicação entre agentes, o que é análogo ao que o _REST_ se tornou para serviços da Web. O _MCP_ permite que os agentes de IA descubram dinamicamente as capacidades de um sistema, entendam suas entradas e saídas e o invocem para executar uma ação, tudo sem exigir lógica pré-programada ou codificada.
O [MuleSoft MCP Connector](https://docs.mulesoft.com/mcp-connector/latest/) permite que qualquer API implementada como um aplicativo Mule seja publicada como um servidor MCP. Como a _MuleSoft_ fornece centenas de conectores predefinidos para praticamente todos os principais sistemas empresariais (por exemplo, SaaS, legados e bancos de dados), isso transforma instantaneamente as APIs e aplicativos de uma organização em um conjunto de ferramentas prontas para agentes. Uma API projetada para verificar o inventário no SAP, um fluxo que processa um novo lead no Salesforce ou um aplicativo personalizado conectado por meio do _MuleSoft_ podem ser disponibilizados aos agentes de IA como ferramentas gerenciadas atômicas usando o _Conector MCP_.
### **2.2 Protocolo entre agentes (A2A)**
Embora o _MCP_ seja excelente em interações hierárquicas entre agentes e ferramentas, processos de negócios complexos geralmente exigem a colaboração entre vários agentes especializados. O protocolo _agente a agente (A2A)_ é o padrão aberto emergente projetado para facilitar a comunicação entre pares que permite fluxos de trabalho sofisticados de vários agentes.
O suporte da MuleSoft para A2A permite que as empresas projetem e criem sistemas avançados com o mesmo nível de governança e confiabilidade que esperam para suas APIs. O [MuleSoft A2A Connector](https://docs.mulesoft.com/a2a-connector/latest/) permite que os desenvolvedores exponham facilmente qualquer agente como um servidor A2A ou invoquem qualquer agente em conformidade com A2A de um aplicativo Mule. Por exemplo, um processo de solicitação de hipoteca pode ser orquestrado em um "Agente de verificação de crédito", um "Agente de assinatura de documento" e um "Agente de conformidade regulatória", com cada agente a descobrir e invocar as capacidades dos outros (conforme necessário) para promover o progresso da solicitação.
Ao fornecer ferramentas robustas de nível corporativo para MCP e A2A, o MuleSoft dá suporte à criação de um ecossistema flexível que consiste em interações diretas entre agentes (por meio de ferramentas de MCP) e interações entre agentes (A2A). Independentemente de como a paisagem da IA evolui, essa abordagem coloca a _MuleSoft_ como a base subjacente que conecta todas as formas de comunicação agente.
## 3\. Tecido do agente do MuleSoft: O sistema nervoso central da empresa agente
Conforme as empresas adotam a IA agente, elas inevitavelmente enfrentam o desafio da disseminação de agentes. Para evitar que isso devolva em caos, é necessária uma camada de orquestração dedicada. O [MuleSoft Agent Fabric](https://docs.mulesoft.com/agent-fabric/) ([demo](https://www.youtube.com/watch?v=GAqwPie16ic)) é uma solução de arquitetura abrangente concebida para enfrentar este desafio. Ele fornece um plano de gerenciamento central para descobrir, governar, orquestrar e observar toda a rede de agentes de IA, independentemente de onde eles são criados ou como operam. Funcionando como o "controle de tráfego aéreo" para a força de trabalho digital da empresa, o _MuleSoft Agent Fabric_ transforma uma coleção de agentes fragmentados e isolados em uma rede de inteligência coesa, segura e de alto desempenho.
O _MuleSoft Agent Fabric_ é baseado em quatro pilares integrados que abrangem o gerenciamento completo do ciclo de vida dos agentes como ativos empresariais de primeira classe.
### **3.1 Registro do agente (descobrir)**
A base de qualquer ecossistema gerenciado é a capacidade de descoberta. O _registro de agentes_ serve como o catálogo universal e centralizado para cada ativo agente dentro da empresa. Isso inclui agentes criados personalizados, agentes integrados a aplicativos SaaS, servidores MCP que expõem sistemas legados e pontos de extremidade A2A para colaboração entre agentes. Ao fornecer uma única fonte de verdade, o _Registro do agente_ resolve o problema de descoberta crítica impedindo que as equipes criem recursos redundantes e permitindo que desenvolvedores humanos e outros agentes de IA encontrem e reutilizem ativos existentes dinamicamente em escala.
O _Registro de agentes_ é criado com base em _Anypoint Exchange,_ e adiciona três novos tipos de ativos: Agentes, servidores MCP e LLMs. Ele captura informações sobre esses ativos, incluindo ferramentas de MCP, protocolos de transporte e cartões do agente, bem como as dependências entre os agentes e os servidores e ferramentas de MCP que eles consomem. Os desenvolvedores podem criar e gerenciar ativos diretamente no registro. Eles também podem programaticamente descobrir e reutilizar ativos existentes no MuleSoft Vibes (por meio da ferramenta search_asset do _MuleSoft MCP Server_) ao criar novas orquestrações. Isso fornece aos desenvolvedores todas as informações necessárias para entender e consumir esses ativos.
### **3.2 Agente Broker (Orquestração)**
Quando os ativos são descobríveis, eles devem ser orquestrados para realizar um trabalho útil. O _Agent Broker_ é um serviço de orquestração que executa processos de negócios em várias etapas. Ele usa um LLM configurável para interpretar tarefas de alto nível e gerar fluxos de trabalho correspondentes. O _Agent Broker_ descobre, sequencia e chama dinamicamente os agentes e ferramentas necessários para concluir esses processos.
A conectividade é gerenciada por meio do _MCP_ para ferramentas e um protocolo _A2A_ para agentes. Isso permite que o sistema organize os agentes em domínios específicos da empresa (por exemplo, Cadeia de abastecimento ou Finanças) e encaminhe tarefas em todos eles. Um único aviso em linguagem natural (por exemplo, "Integrar um funcionário") é dividido em uma sequência de ações distintas executadas por diferentes agentes ou ferramentas em vários sistemas de back-end. A Orquestração do agente de corretagem inclui:
- **Padrão de orquestração dinâmica:** Esse é um padrão de Agente-Loop que determina as subtarefas e as orquestra nos agentes e ferramentas mais adequados para atingir a meta geral. Ao aproveitar esse padrão, podem ser criados [agentes colaborativos](/docs/architect/pt-br/fundamentals/guide/agentic-patterns#15-agentes-colaborativos-mutirões-de-agentes) para resolver casos de uso complexos (por exemplo, [tratamento de escalonamento de serviço complexo](/docs/architect/pt-br/fundamentals/guide/agentic-patterns#35-caso-de-uso-do-agente-colaborativo-escalonamento-de-serviço-complexo)).
- **Reasoning desenvolvido com LLM:** Usa um LLM para interpretar metas de linguagem natural e gerar planos de execução, o que elimina a necessidade de lógica de fluxo de trabalho rígida embutida em código.
- **Modelo de LLM configurável:** Permite que os desenvolvedores especifiquem qual modelo de LLM usar, o que fornece controle sobre custo, desempenho e recursos.
- **Desenvolvimento da Língua Natural:** A lógica do _Agent Broker_ pode ser definida usando linguagem natural por meio de _MuleSoft Vibes_.
- **Observabilidade:** O _Monitoramento de qualquer ponto_ fornece registro e rastreamento após a implantação para ajudar os usuários a entender e depurar o raciocínio e as interações do agente corretor com ferramentas _MCP_ e agentes _A2A_.
- **Implantação gerenciada:** O _Agent Broker_ é um aplicativo containerizado que é suportado pelo _Mule Runtime_, que gerencia a disponibilidade e a escalabilidade da implantação.
### **3.3 Gateway flexível para MCP e A2A (Govern)**
O _Anypoint Flex Gateway_ é o mecanismo através do qual determinadas políticas são tecnicamente aplicadas. A _MuleSoft Agent Fabric_ utiliza o _Anypoint Flex Gateway_ para [segurar, inspecionar e gerenciar todas as interações agentes](https://docs.mulesoft.com/gateway/latest/flex-agent-secure) que ocorrem por meio dos protocolos _MCP_ e _A2A_. Isso permite que as organizações apliquem um rico [conjunto de políticas de nível corporativo](https://docs.mulesoft.com/gateway/latest/flex-agent-policies) a todo o tráfego de agentes para garantir que cada ação seja segura, em conformidade e auditável antes de sua execução. Para escalar a adoção de IA de modo seguro e responsável, essas proteções são essenciais.
| Nome da política | Protocolo(s) | Descrição |
| :----------------------------------------------------- | :---------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Política de validação do JWT/Política de imposição do ID do cliente** | A2A, MCP | A **Política de validação/Política de imposição de ID do cliente** protege agentes _A2A_ e servidores _MCP_ restringindo o acesso apenas a chamadores autenticados. |
| **Validação de esquema** | A2A, MCP | A **validação de esquema** garante que as solicitações de agente recebidas estejam de acordo com a especificação _A2A_ ou _MCP_, o que evita o tráfego malformado. |
| **Detector de PII A2A** | A2A | O **detector de PII A2A** identifica _informações de identificação pessoal (PII)_ em solicitações e respostas e habilita o registro ou o bloqueio para atender aos requisitos de conformidade. |
| **Decorador de prompts A2A** | A2A | O **A2A Prompt Decorator** insere contexto personalizado ou instruções em avisos enviados aos agentes para orientar seu comportamento e impor proteções. |
| **Controle de acesso baseado em atributo do MCP** | MCP | **O Controle de acesso baseado em atributo do MCP** regula o acesso a ferramentas e recursos específicos expostos por um servidor _MCP_ com base em atributos do usuário (por exemplo, reivindicações de Níveis, IP ou JWT). |
| **Registro de SSE** | A2A, MCP | O registro **SSE** registra o conteúdo dos fluxos de _eventos enviados pelo servidor (SSE)_ que são usados por protocolos de agência para auditoria abrangente e rastreabilidade. |
| **Limitação de taxa e controle de spike** | A2A, MCP | A **Limitação de taxa e o Spike Control** protegem agentes e sistemas de back-end contra surtos de tráfego e ataques de denegação de serviço aplicando limites de solicitação. |
| **Cartão do agente A2A** | A2A | O **Cartão do agente A2A** reescreve o URL do cartão do agente para garantir que todo o tráfego seja provisionado corretamente por meio da instância de Gateway flexível gerenciada. |
**Políticas de governança corporativa para protocolos agentes**
Além de reger solicitações de entrada, o _Anypoint Flex Gateway_ também gerencia todas as conexões de saída e solicitações de um agente para serviços externos (por exemplo, Servidores e ferramentas _MCP_ ou outros agentes). Isso inclui:
- **Registro:** Fornece um ponto de observabilidade centralizado para monitorar e registrar todas as solicitações de agente de saída para auditoria e solução de problemas.
- **Segurança:** Evita vazamento de dados confidenciais inspecionando o tráfego de saída.
- **Autenticação:** Gerencia as credenciais para sistemas externos aplicando mecanismos de autenticação de saída, incluindo Chaves de API, OAuth e ClientId/ClientSecret de um único ponto.
O [**Kit de desenvolvimento de políticas (PDK**)](https://docs.mulesoft.com/pdk/latest/policies-pdk-overview) do _Anypoint Flex Gateway_ permite que os usuários criem políticas personalizadas quando as políticas prontas para uso não atendem a requisitos específicos. Usando o _PDK_, os desenvolvedores podem escrever lógica de política na linguagem de programação _Rust_ e compilá-la em um módulo _WebAssembly (WASM)_. O módulo independente é carregado no _Anypoint Flex Gateway_ para aplicar regras de segurança exclusivas, transformações de dados personalizadas ou lógica de integração especializada diretamente na borda da API. Isso fornece uma maneira eficiente e de alto desempenho de estender a funcionalidade do gateway para casos de uso exclusivos ou complexos.
Estes são os quatro componentes-chave do _PDK_:
- **Anypoint CLI PDK Plugin:** Esse plugin cria o projeto _PDK_ e carrega a política compilada para o _Exchange_. Ele também gera um _Makefile_ que simplifica o processo de desenvolvimento fornecendo um conjunto claro de comandos para criar e gerenciar a política.
- **Modelo de política:** Quando um novo projeto é criado, o _PDK_ gera um quadro ou modelo básico. Essa estrutura inclui todos os arquivos e ajustes necessários para compilar com sucesso a política, o que dá aos desenvolvedores um ponto de partida para a lógica personalizada.
- **Estruturas de construção de SDK:** Essas ferramentas resumem a arquitetura complexa e orientada por evento do proxy _Envoy_ subjacente. Usando padrões de reator e executor, o _SDK_ fornece um método de codificação linear e simples. Isso ajuda a reduzir a complexidade, melhorar a depuração e diminuir a curva de aprendizado para desenvolvedores.
- **Gestão de políticas:** O [Servidor MCP MuleSoft](https://docs.mulesoft.com/mulesoft-mcp-server/reference-mcp-tools) fornece ferramentas de _MCP_ para ajudar os usuários a gerenciar o ciclo de vida da política personalizada. Exemplos dessas ferramentas incluem:
- get_flex_gateway_policy_example
- manage_api_instance_policy
- manage_flex_gateway_policy_project
### **3.4 Visualizador do agente (Observe)**
O _Agent Visualizer_ fornece um mapa dinâmico em tempo real de toda a rede de agentes, transformando o que poderia ser uma "caixa negra" de interações de IA em um sistema totalmente observável. Os arquitetos e as equipes de operações podem usar o _Visualizador do agente_ para revisar como os agentes estão conectados, rastrear seus fluxos de decisão, monitorar sua saúde e desempenho e identificar dependências. Esse nível de visibilidade é crucial para otimizar o desempenho, solucionar falhas de modo eficiente, detectar gargalos e aumentar a confiança nos agentes implantados.
## **4\. Unificação da Salesforce Platform**
### **4.1 Catálogo da API e Centro de tópicos**
O _Catálogo da API MuleSoft_ e o _Tema Center_ são projetados para melhorar a forma como as APIs são descobertas, usadas e gerenciadas, particularmente em conjunto com a _Agentforce_.
Todas as APIs da _MuleSoft_ projetadas e publicadas podem ser descobertas e consumidas por meio do [Catálogo de APIs](https://help.salesforce.com/s/articleView?id=platform.api_catalog.htm&type=5) na _Plataforma Salesforce_. O _Catálogo de API_ serve como o repositório centralizado e unifica todas as APIs de uma organização, desde _MuleSoft_, _Salesforce_, _Heroku_ e outras nuvens, em uma única visualização. Isso facilita a descoberta, a compreensão e a reutilização de APIs existentes para desenvolvedores e administradores, permitindo que elas sejam usadas em automações (por exemplo, _Agentforce_, _Flow_ e _Apex_).
O [MuleSoft para Agentforce: O Centro de tópicos](https://blogs.mulesoft.com/news/mulesoft-for-agentforce-topic-center/) permite que os desenvolvedores estruturem suas APIs em torno de casos de uso de negócios específicos definindo os metadados Agentforce **Tópicos** e **Ações** no momento do projeto. Isso inclui:
- **Ações**, que são as tarefas que um agente pode realizar
- **Instruções**, que orientam o agente sobre como aplicar determinadas ações
Ao [adicionar essa camada semântica](https://docs.mulesoft.com/anypoint-code-builder/ai-enabling-api-project-topic-center), o _Topic Center_ torna as APIs compreensíveis e consumíveis pela _Agentforce_, o que garante que ela possa interagir com sistemas empresariais de maneira eficaz.
### **4.2 Agentforce Gateway**
O _Agentforce Gateway_ é uma camada de governança centralizada projetada para gerenciar e proteger interações dentro do ecossistema em expansão _Agentforce_. À medida que a _Agentforce_ se integra a APIs e ferramentas adicionais de terceiros por meio de protocolos como o _MCP_, a principal função do _Agentforce Gateway_ é aplicar políticas (por exemplo, limites de taxa e restrições de ferramentas) a todo o tráfego de saída iniciado pela _Agentforce_ e auditar todas as solicitações de saída.
O _Agentforce Gateway_ utiliza o mecanismo de políticas de governança da API _MuleSoft_ existente, que é integrado nativamente à _Plataforma Salesforce_. Esse mecanismo de política baseado em _Envoy_ intercepta o tráfego do agente, aplica políticas configuradas (por exemplo, controle de acesso baseado em atributo e limites de cotação) e gerencia a autenticação e autorização, tudo sem exigir que os clientes instalem infraestrutura de gateway adicional.
### **4.3 Inteligência de integração**
Implantar uma rede governada de agentes é uma realização marcante. No entanto, ele introduz novos desafios operacionais "dia 2". É necessário um nível aprimorado de inteligência operacional para monitorar, medir e solucionar problemas de um sistema dinâmico distribuído de atores autônomos. A visão arquitetônica final é um sistema em que a IA não é usada apenas para executar processos de negócios, mas também para monitorar, gerenciar e curar a própria infraestrutura em que ela é executada.
A visão de integração da _MuleSoft_ aproveita o poder do ecossistema mais amplo da _Salesforce_ para fornecer percepções profundas e personalizáveis sobre o desempenho do tecido de integração e da rede de agentes. Ao capturar e armazenar dados em conformidade com a [OpenTelemetry (OTEL)](https://opentelemetry.io/) \- o padrão emergente de observabilidade - no **Salesforce Data 360**, as organizações podem criar um repositório unificado para logs, métricas e rastreamentos em todo o seu panorama. Esses dados podem ser visualizados no **Tableau** por meio de painéis predefinidos e visualizações personalizadas para obter percepções detalhadas sobre o desempenho da API, os padrões de interação do agente e a integridade geral do sistema.
Esse sistema tem três componentes principais:
1. **Ingestão:** O serviço de ingestão é o ponto de entrada centralizado para coletar e processar dados de telemetria de vários aplicativos _Mule_, _Agent Brokers_ e _Flex Gateways_. Ele realiza validação de esquema, normalização de dados e filtragem para manter a qualidade e a consistência dos dados em vários aplicativos. Além disso, ele impõe controles (por exemplo, autenticação, criptografia, equidade do locatário e limitação de taxa) no pipeline de ingestão.
2. **Armazenamento:** Um trabalho de streaming de alto rendimento é executado no _Data 360_ que lê dados de tópicos de vários locatários _Kafka_ e os transforma no formato _OTEL_. Os dados OTEL então são vinculados ao _Data 360_ do locatário nos DMOs _TelemetryTraceSpan_, _TelemetryLogs_ e _TelemetryMetrics_ no _Lakehouse_.
3. **Visualização/Consumo:** Com os dados de telemetria disponíveis no _Data 360_, os clientes podem revisar a integridade do sistema e obter percepções usando painéis predefinidos ou personalizados por meio do _Tableau Next_. Os clientes também podem aproveitar o [Tableau Concierge](https://help.salesforce.com/s/articleView?id=analytics.tua_metric_questions.htm&type=5), uma habilidade de análise agente pré-construída no _Tableau Next_, que permite aos usuários fazer perguntas sobre dados de telemetria em linguagem natural e receber respostas confiáveis e acionáveis com visualizações. Os clientes também podem exportar os dados para sistemas existentes de _Gerenciamento de desempenho de aplicativo (APM)_ (por exemplo, _DynaTrace_, _Datadog_, _Splunk_ e assim por diante).
## **Conclusão**
A transição para uma Enterprise do agente não é apenas uma atualização de TI; é um ponto de inflexão arquitetônica fundamental. Uma implantação fragmentada e isolada de agentes de IA é um caminho direto para caos operacional, TI sombra e débito técnico não gerenciável. O único caminho sustentável é por uma arquitetura unificada e composível. Com base na base comprovada de conectividade conduzida por API, o _MuleSoft Agent Fabric_ fornece o "sistema nervoso central" necessário para gerenciar esta nova força de trabalho digital. Ele fornece os recursos essenciais para descoberta, orquestração, governança de nível corporativo e observabilidade completa. É assim que ultrapassamos a experimentação de IA e começamos a arquitetar uma empresa verdadeiramente inteligente, automatizada e segura, transformando potencial autônomo em resultados de negócios controlados e tangíveis.
## **Guia Técnico e Referências**
- [Introdução ao Anypoint Code Builder](https://docs.mulesoft.com/anypoint-code-builder/start-acb)
- Guia [técnico do Einstein para Anypoint Code Builder: Fluxos generativos](https://blogs.mulesoft.com/dev-guides/einstein-for-acb/)
- Mergulho profundo de transformação generativa [DataWeave: Inovação de IA para transformação rápida de dados](https://blogs.mulesoft.com/dev-guides/dataweave-generative-transformation/)
- [Criando especificações de API com o MuleSoft Dev Agent](https://docs.mulesoft.com/anypoint-code-builder/api-ai-create-spec)
- [Gerar documentação da API com a IA generativa do Einstein](https://docs.mulesoft.com/exchange/generating-documentation-with-ai)
- [Visão geral do servidor MCP da MuleSoft](https://docs.mulesoft.com/mulesoft-mcp-server/)
- [MuleSoft Ferramentas do servidor MCP](https://docs.mulesoft.com/mulesoft-mcp-server/reference-mcp-tools)
- [Conector MCP](https://docs.mulesoft.com/mcp-connector/latest/)
- [Conector A2A](https://docs.mulesoft.com/a2a-connector/latest/)
- [Introdução ao Agent Fabric](https://docs.mulesoft.com/agent-fabric/learning-map-agent-fabric)
- [Protegendo interações do agente com o Flex Gateway](https://docs.mulesoft.com/gateway/latest/flex-agent-secure)
- [Políticas de agente de gateway flexível](https://docs.mulesoft.com/gateway/latest/flex-agent-policies)
- [Kit de desenvolvimento de política de gateway flexível (PDK) Visão geral](https://docs.mulesoft.com/pdk/latest/policies-pdk-overview)
- [Catálogo da API do MuleSoft para Salesforce](https://help.salesforce.com/s/articleView?id=platform.api_catalog.htm&type=5)
- [Habilitar um projeto de API para tópicos e ações do agente](https://docs.mulesoft.com/anypoint-code-builder/ai-enabling-api-project-topic-center)
- [Trabalhar com o Tableau Next](https://help.salesforce.com/s/articleView?id=analytics.tua_consume.htm&type=5)
- [OpenTelemetry](https://opentelemetry.io/)
- [Protocolo de contexto do modelo](https://modelcontextprotocol.io/docs/getting-started/intro)
- [Protocolo Agent2Agent (A2A)](https://a2a-protocol.org/latest/)
## Sobre o autor
Nikhil Aggarwal é um arquiteto principal na Salesforce, onde ele lidera a arquitetura para MuleSoft e Salesforce Automation Clouds. Nikhil traz mais de 18 anos de experiência em entregar produtos em grande escala e tem paixão pela arquitetura escalonável, experiências intuitivas do desenvolvedor e a criação de equipes de alto desempenho. Antes da Salesforce, ele liderava várias iniciativas no Microsoft Power Platform, no Dataverse e no Office 365 do conceito ao lançamento. Seu trabalho continua a moldar como as empresas modernas conectam sistemas, automatizam fluxos de trabalho e liberam valor comercial na era da IA.