diff --git a/modules/ROOT/assets/images/agent-fabric-pillars.png b/modules/ROOT/assets/images/agent-fabric-pillars.png index e6bfc5614..f28ffdf67 100644 Binary files a/modules/ROOT/assets/images/agent-fabric-pillars.png and b/modules/ROOT/assets/images/agent-fabric-pillars.png differ diff --git a/modules/ROOT/nav.adoc b/modules/ROOT/nav.adoc index 99a3964c1..8dcad6bb8 100644 --- a/modules/ROOT/nav.adoc +++ b/modules/ROOT/nav.adoc @@ -1,7 +1,8 @@ .xref:index.adoc[Anypoint Platform] * xref:index.adoc[Documentation] * xref:learning-map-mulesoft-ai.adoc[] -* xref:learning-map-agent-fabric.adoc[Agent Fabric] +* xref:agent-fabric-overview.adoc[Agent Fabric] + ** xref:learning-map-agent-fabric.adoc[Get Started with Agent Fabric] ** xref:agent-fabric-release-notes.adoc[] ** xref:agent-networks-get-started.adoc[] * xref:learning-map-api-management.adoc[API Management] diff --git a/modules/ROOT/pages/agent-fabric-overview.adoc b/modules/ROOT/pages/agent-fabric-overview.adoc new file mode 100644 index 000000000..0b3f3d984 --- /dev/null +++ b/modules/ROOT/pages/agent-fabric-overview.adoc @@ -0,0 +1,342 @@ += MuleSoft Agent Fabric Overview + + +MuleSoft Agent Fabric helps you turn agent sprawl into a governed, coordinated, intelligent network. Regardless of the platform where your AI agents were built or are running, Agent Fabric provides the infrastructure to discover, orchestrate, govern, and observe agents across your enterprise. Agent Fabric enables you to build intelligent agent networks where multiple agents work together, access enterprise systems securely, and operate under consistent governance and observability. + +[[how-agent-fabric-works]] +== How MuleSoft Agent Fabric Works + +Every organization has systems, agents, LLMs, and data sources scattered across platforms and teams. Left unmanaged, this creates agent sprawl: siloed agents that can't work together, inconsistent experiences, security gaps, and costs that are difficult to control. Agent Fabric solves this by providing a unified control plane for the agentic era. + +Agent Fabric starts with enterprise actionability, bridging the gap between your existing enterprise stack and the agentic world. It makes every system, agent, LLM, and data source directly usable in agentic workflows without rebuilding them, giving the entire fabric a foundation to build on. + +MuleSoft supports two complementary products that can be used together for agentic enterprises. Each serves a distinct role in building and managing your organization's AI agent strategy: + +* Agentforce ++ +Build and deploy Salesforce-native agents for use within the Salesforce ecosystem. +* Agent Fabric ++ +The agent control plane for managing and governing agents across any platform, including Salesforce Agentforce, Amazon Bedrock, Google Vertex AI, Microsoft Copilot Studio, and others. Use Agent Fabric when you need to discover, catalog, and govern agents built anywhere, orchestrate multi-vendor workflows where agents from different platforms must work together, or apply consistent security, compliance, and cost controls across your entire agent ecosystem. + +Agentforce and Agent Fabric are core components of Salesforce's Agentic Enterprise Architecture, a four-layer platform model designed for the era of AI agents and headless operations. This architecture separates the data foundation, business logic, orchestration, and experience layers. + +Agent Fabric operates in the orchestration layer, providing the control plane for multi-vendor agent coordination. + +image::agent-fabric-pillars.png[Agent Fabric pillars, discover, govern, orchestrate, and observe] + +As the agent control plane for your enterprise, Agent Fabric delivers four core capabilities that work together, whether you're managing Agentforce agents, third-party agents, or both: + +* <> ++ +A central registry, supported with automated discovery, where every agent and MCP server — regardless of where it's built — can be cataloged, discovered, and reused. This eliminates duplication and makes it easy to compose solutions from existing assets. +* <> ++ +Enterprise-grade guardrails ensuring every agent, MCP server, and LLM interaction is secure, compliant, and cost-controlled, so teams can innovate with confidence. +* <> ++ +The ability to coordinate agents and tools across ecosystems with guided determinism, so multi-step processes run smoothly and every agent works together to deliver reliable business outcomes. +* <> ++ +End-to-end visibility into how agents make decisions and perform, turning black-box AI into transparent, accountable systems. + +Together, these capabilities transform disconnected agents and MCP servers into a unified, trusted, high-performing digital workforce. + +[[enterprise-actionability]] +== Enterprise Actionability + +Before agents can orchestrate across your enterprise, your existing systems need to be accessible to them. Enterprise actionability bridges the gap between what you have today, including APIs, data sources, LLMs, and existing services, and the agentic world, without requiring you to rebuild anything. MuleSoft provides a set of tools to make any asset directly actionable inside agentic workflows. + +=== MCP Bridge + +* What it is: MCP Bridge enables you to create MCP servers from your existing API instances, exposing their operations as MCP tools that agents can discover and call, without modifying the underlying API. + +* Role in Agent Fabric: MCP Bridge is one of the most important and accessible entry points into Agent Fabric. APIs your organization has already built and governed can become immediately available to any agent in your network through simple configuration, with no rewriting required. + +* What you can do: +** Convert any existing API instance into an agent-ready MCP server through simple configuration +** Select which API operations to expose as discrete MCP tools +** Apply governance policies to the resulting MCP server from the same portfolio + +* When you need it: Use MCP Bridge when you want agents to call your existing APIs without needing API-specific details, or when you want to make a large API surface agent-ready quickly without custom development. + +* Learn more: xref:exp-services-create-mcp-server.adoc[Create an MCP Server] + +=== MCP Connector + +* What it is: Anypoint Connector for MCP (MCP Connector) lets you build Mule applications that act as MCP servers and clients, giving you full programmatic control over what tools and resources you expose to agents and enabling Mule apps to connect to external MCP servers. + +* Role in Agent Fabric: MCP Bridge converts existing APIs automatically through configuration. MCP Connector is for teams that need to build custom MCP server logic, compose multiple systems, apply transformation, orchestrate interactions with external MCP services, or expose capabilities that don’t map directly to a single existing API. + +* What you can do: +** Build Mule applications that expose tools and resources to MCP clients +** Connect Mule applications to external MCP servers +** Compose multiple backend systems into a single MCP server +** Define custom logic for how agent requests are handled +** Orchestrate workflows that incorporate AI agents and external MCP services +* When you need it: Use MCP Connector when you need to expose capabilities to agents that require custom logic, multi-system composition, orchestration with external MCP services, or transformation that configuration-based tools like MCP Bridge don’t cover. +* Learn more: xref:connectors::mcp::index.adoc[MCP Connector] + +=== A2A Connector + +* What it is: Use Anypoint Connector for A2A (A2A Connector) to add A2A protocol support to Mule applications so they can act as both A2A servers and A2A clients. You can also use A2A Connector to make agents built on other platforms A2A-compliant. + +* Role in Agent Fabric: A2A Connector brings existing Mule applications into the orchestrated agent world without rebuilding them as native agents. It standardizes agent communication so that any application can become a first-class participant in multi-agent workflows, capable of receiving tasks from a broker and delegating to other agents. + +* What you can do: +** Make any Mule applications A2A-compliant +** Enable Mule applications to receive and delegate tasks within an agent network +** Participate in broker-orchestrated workflows without rebuilding existing applications + +* When you need it: Use A2A Connector when you have existing Mule applications that need to participate in agent networks as A2A-compliant agents. + +* Learn more: xref:connectors::a2a::index.adoc[A2A Connector] + +=== Other AI Connectors + +* What it is: AI Connectors provide pre-built integrations to LLMs and vector databases, making them directly accessible inside Mule-based agentic workflows + +* Role in Agent Fabric: AI Connectors ensure that the LLMs and knowledge stores your organization already uses are available to agents without custom integration work. They connect your agentic workflows to the models and data that power agent reasoning and context. + +* What you can do: +** Connect LLMs and vector databases to agentic workflows without custom integration +** Unlock existing AI infrastructure for use inside agent networks +** Enrich agent reasoning with organizational knowledge stores + +* When you need it: Use AI Connectors when your agents need to reason with LLMs or retrieve context from vector databases your organization already operates. + +* Learn more: +** xref:connectors::agentforce::index.adoc[Agentforce Connector] +** xref:connectors::amazon-bedrock::index.adoc[Amazon Bedrock Connector] +** xref:connectors::einstein-ai::index.adoc[Einstein AI Connector] +** xref:connectors::mulesoft-ai-chain::index.adoc[MuleSoft AI Chain Connector] +** xref:connectors::mulesoft-inference::index.adoc[MuleSoft Inference Connector] +** xref:connectors::mulesoft-vectors::index.adoc[MuleSoft Vectors Connector] + + +=== B2B (Partner Manager) + +* What it is: Anypoint Partner Manager enables bidirectional Business-to-Business message exchanges with external trading partner ecosystems through configuration-driven integration. Partner Manager handles technical partner onboarding, message flow orchestration, and transaction monitoring across multiple transport protocols (AS2, SFTP, HTTP/S, FTP) and message formats (X12, EDIFACT, CSV, JSON, XML). + +* Role in Agent Fabric: Partner Manager makes B2B trading partner networks directly actionable for agents without requiring them to understand complex EDI standards or protocol-specific integration patterns. Agents can initiate B2B transactions, query partner message flows, monitor transmission status, and respond to partner interactions as part of multi-step workflows, turning manual B2B operations into automated, agent-driven processes. +* What you can do: +** Enable agents to send and receive B2B transactions with trading partners +** Query message flow status, transmission tracking, and acknowledgment statuses +** Access partner profile information and endpoint configurations +** Monitor B2B transaction activity and custom message attributes +** Integrate B2B workflows into broader agentic orchestration patterns + +* When you need it: Use Partner Manager when agents need to participate in B2B ecosystems for use cases like order to cash, procure to pay, logistics planning, warehouse management, or transportation execution where automated B2B message exchange with external partners is required. +* Learn more: + +=== IDP (Intelligent Document Processing) + +* What it is: MuleSoft Intelligent Document Processing (IDP) uses multimodal large language models to extract structured data from unstructured or semi-structured documents like invoices, purchase orders, receipts, and custom document types. IDP creates document actions—configurable schemas with AI-powered extraction instructions—that are published as APIs for consumption by agents, RPA, and Mule applications. + +* Role in Agent Fabric: IDP makes document data directly actionable for agents by transforming locked information in PDFs, images, and paper documents into structured, queryable data that agents can reason over and act upon. Instead of requiring manual document review or rigid OCR templates, agents can process documents intelligently, extract key fields with confidence scoring, and route documents for human review when needed, seamlessly blending AI extraction with agent-driven workflows. + +* What you can do: +** Enable agents to extract structured data from invoices, purchase orders, and custom document types +** Configure document actions with pre-built or custom schemas using natural language prompts +** Leverage Einstein for complex document analysis that requires reasoning beyond simple field extraction +** Apply confidence thresholds and human-in-the-loop review workflows for quality assurance +** Integrate document processing results into agent workflows through published APIs + +* When you need it: Use IDP when agents need to extract and act on data trapped in documents as part of procurement, accounts payable, order processing, or any workflow where unstructured document data must become structured, actionable information within your agent network. + +* Learn more: + + +[[discover]] +== Discover + +Agent Fabric provides a central registry and automated discovery tools that surface every agent in your organization, regardless of platform. Before you can govern, orchestrate, or observe agents, you need a complete picture of what exists. Discovery gives you that foundation and enables coordinated control across your entire agent ecosystem. + +=== Agent Registry + +* What it is: The agent registry is the central catalog for all agentic assets across your organization. In the enhanced MuleSoft experience, your Portfolio serves as the registry, organized into catalogs for Agents, MCP Servers, LLM Proxies, APIs, and Gateways. Each catalog holds the services your organization has registered or discovered, so you can govern, monitor, and manage them from one place, regardless of which platform or provider built them. MuleSoft also provides access to a curated set of public MCP servers from the Official MCP Registry and Informatica, giving teams a starting point for common integrations without building from scratch. +* Role in Agent Fabric: The agent registry is where Agent Fabric makes every agent, tool, and model visible and reusable. The registry gives teams a trusted source of truth for all agentic assets, so they can reuse what already exists instead of duplicating work. The registry forms the foundation of discovery. +* What you can do: +** Browse and search registered agents, MCP servers, LLM proxies, APIs, and gateways +** View service details, conformance status, and instance health at a glance +** Manage lifecycle, governance, and monitoring for each asset from its catalog page +** Register assets manually or through automated provider discovery +** Publish agent networks and MCP servers for organizational reuse + +* When you need it: Whenever you are starting a new agentic project and want to find existing assets before building from scratch, or when you want to share what your team built with the rest of the organization. +* Learn more: xref:exp-portfolio-overview.adoc[View Your Portfolio Overview] + +=== Scanners + +* What it is: A scanner connects the enhanced MuleSoft experience to a supported cloud provider. When a scanner runs, it discovers services on that platform, such as agents, APIs, and MCP servers, and registers them automatically in the matching portfolio catalog. +* Role in Agent Fabric: Scanners enable continuous, automated discovery across a multi-provider landscape. Teams configure scanners once, and the scanners keep the registry current as services are added, changed, or retired on external platforms. A scanner monitors connected platforms for new and updated agents and pulls them automatically into the agent registry, providing a real-time, single source of truth for every agent across your enterprise. +* What you can do: +** Connect cloud providers as scanner sources +** Automatically discover and register agents, MCP servers, and APIs across ecosystems +** Schedule scans to run continuously or trigger them on demand +** View scanner status, last-run results, and the number of assets discovered +** Manage scanners from Platform > Providers in the enhanced MuleSoft experience + +* When you need it: When your organization has agents built across multiple platforms and you need a continuous, automated way to keep your registry current without manually registering every asset. +* Learn more: xref:exp-scanners-add-from-providers.adoc[Adding Scanners from Providers] + +[[govern]] +== Govern + +Without governance, orchestration turns to chaos. Agent Fabric provides enterprise-grade guardrails that ensure every agent, MCP server, and LLM interaction is secure, compliant, and cost-controlled, so teams can innovate with confidence. + +=== Omni Gateway + +* What it is: Omni Gateway is the runtime governance layer that sits between agents and the systems they call, applying security, compliance, and cost controls to every interaction across APIs, agents, MCP servers, and LLMs. +* Role in Agent Fabric: Omni Gateway makes governance real at runtime. Defining policies in a governance strategy sets the intent. Omni Gateway enforces that intent on live traffic. It ensures that no agent interaction bypasses security controls, regardless of which platform the agent was built on or which system it is calling. Omni Gateway serves as the enterprise policy framework for your agent network, ensuring agents act responsibly, securely, and in alignment with business objectives. +* What you can do: +** Apply rate limiting, authentication, and authorization to all agent, API, and MCP server requests +** Enforce runtime policies for data privacy, compliance, and cost +** Control agent access to specific tools and APIs +** Log and audit agent traffic for security and compliance purposes + +* When you need it: Use Omni Gateway for any production deployment where agents handle sensitive data, call external APIs, or need consistent security and compliance enforcement across your organization. +* Learn more: xref:exp-governance-create-strategy.adoc[Create Governance Strategies] + +=== Governance Strategies + +* What it is: Governance strategies bundle design-time rules and runtime policies into a coherent governance posture applied across targeted services. In the enhanced MuleSoft experience, governance strategies are managed under *Governance > Governance Strategies*. +* Role in Agent Fabric: Governance strategies turn compliance intent into systematic enforcement across your portfolio. A governance strategy lets you define rules once, spanning access and security, data privacy, performance and cost, and compliance, and apply them consistently across every agent, MCP server, API, and LLM proxy in scope. +* What you can do: +** Create strategies spanning access and security, data privacy, performance and cost, and compliance and observability domains +** Apply policies at the service or instance level so runtime traffic reflects the defined strategy +** Review conformance scores, violations, and warnings via Conformance Reports on each service +** Monitor governance coverage to identify which services lack active strategies +** Block or flag non-compliant actions at design time or runtime +* When you need it: Use governance strategies when your organization needs consistent, auditable enforcement of security, compliance, or cost rules across a portfolio of agents and services. +* Learn more: xref:exp-governance-work-with-strategies.adoc[Working with Governance Strategies] + +=== Cost Management + +* What it is: Cost Management surfaces token usage, daily spend signals, and cost optimization controls across your portfolio. +* Role in Agent Fabric: As LLMs become central to agentic workflows, token consumption becomes a significant operational cost. Cost Management gives organizations the visibility and controls to keep that cost predictable. It connects governance directly to economics. The same governance strategy framework that enforces security and compliance can also reduce unnecessary token spend through tool mapping and tool sanitization controls. +* What you can do: +** Monitor token usage and spend trends across LLM proxies and agents +** Apply tool mapping to restrict which tools an LLM or agent can invoke, reducing unnecessary token consumption +** Apply tool sanitization to filter inputs and outputs before they reach a model +** Identify high-cost services and tune them through governance controls +** Keep every agent action authenticated and attributable to the user who initiated it +** Maintain a complete audit trail of agent actions tied to real user authorization +* When you need it: Use Cost Management when LLM token consumption is a significant operational concern, or when you need to enforce spending limits and audit agent interactions across your organization. +* Learn more: xref:exp-governance-view-cost-and-token-usage.adoc[Viewing Cost and Token Usage] and xref:exp-governance-create-strategy.adoc[Create Governance Strategies] + +=== Trusted Agent Identity + +* What it is: Trusted Agent Identity is a set of identity and authorization policies that ensure agents act with a specific user's identity and proper authentication on every interaction, so access follows the calling user's permissions rather than granting blanket agent access. +* Role in Agent Fabric: Without identity controls, agents can become a governance gap, calling systems with elevated or opaque permissions that bypass the controls applied to human users. Trusted Agent Identity closes that gap, ensuring every agent interaction is authenticated, attributable, and auditable. This is what makes agent governance meaningful in regulated environments. +* What you can do: +** Ensure agents act under a specific user's identity rather than with generic or elevated agent-level access +** Keep every agent action authenticated and attributable to the user who initiated it +** Maintain a complete audit trail of agent actions tied to real user authorization + +* When you need it: Use Trusted Agent Identity any time agents call APIs or services on behalf of users, or when compliance requires knowing not just that an agent made a call, but who authorized it. +* Learn more: + + + +[[orchestrate]] +== Orchestrate +Coordinate agents and tools across ecosystems with guided determinism, so multi-step processes run smoothly and every agent works together to deliver reliable business outcomes. + +=== Agent Broker + +* What it is: An intelligent routing service that coordinates task delegation across A2A-compliant agents in your agent network. Brokers originate from MuleSoft and are defined in your agent network YAML alongside the agents and MCP servers they can leverage to accomplish tasks. +* Role in Agent Fabric: The broker is the orchestration intelligence in your agent network. When a request arrives, the broker determines which agent or other broker is best suited to handle it and delegates accordingly, generating a contextId and taskId to track task state across the interaction. +* By dynamically matching tasks with other agents and enabling seamless collaboration across ecosystems, balancing fixed rules and LLM reasoning, the broker transforms scattered agents into a coordinated workforce. Brokers appear in your portfolio and can be discovered and reused by other brokers across your organization. +* What you can do: +** Build hierarchical orchestration by delegating tasks to specialized A2A-compliant agents or other brokers +** Publish brokers to your portfolio for discovery and reuse across your organization +** Define brokers in your agent network YAML configuration +** Configure the broker's routing logic and orchestration patterns +** Deploy the full agent network (including the broker) to CloudHub 2.0 or Runtime Fabric +** Monitor broker routing decisions and performance using Agent Visualizer + +* When you need it: when your agent network includes multiple agents with different specializations and you need a component to intelligently route work to the right agent based on context. Add a broker when routing logic needs to go beyond a single agent. + +* Learn more: xref:anypoint-code-builder::af-define-your-agent-network-specification.adoc[] + +=== Agent Network + +* What it is: An agent network is a coordinated group of agents, brokers, LLMs, and MCP servers that acts as a central hub for defining, validating, and running agentic processes across your enterprise. You configure an agent network in a human-readable YAML file that details the required structure and properties that define your project's assets, connections, and policies. +* Role in Agent Fabric: The agent network is the configuration and infrastructure layer that brings all the components of your agentic solution together. It defines the composition of your network, specifying which agents are available, which brokers orchestrate them, which LLMs provide reasoning, and which MCP servers connect agents to backend systems. Without an agent network, agents operate in isolation. With one, they become a coordinated system capable of handling complex, multi-step workflows. +* What you can do: +** Define the composition of a multi-agent system in a single YAML configuration +** Connect agents to backend systems and data sources via MCP servers +** Use LLMs for reasoning and planning across the network +** Deploy the full agent network, including agents, brokers, and MCP servers +** After publishing, network assets are registered in your portfolio for discovery and reuse + +* When you need it: Use an agent network any time you are building an agentic solution that involves multiple agents, LLMs, or MCP servers working together. Agent networks do not require a broker. You can start with just agents and MCP servers and add a broker when you need intelligent routing across specialized agents. + +* Learn more: xref:anypoint-code-builder::af-agent-networks.adoc[] + +[[observe]] +== Observe + +Agent Visualizer provides a detailed visual graph of your agent network so you can see, understand, and interact with your enterprise’s evolving network of agents, Model Context Protocol (MCP) servers, and large language models (LLMs), including agents created in external platforms. + +=== Agent Visualizer + +* What it is: Agent Visualizer is a visualization and monitoring tool that displays agent network structure, real-time request flows, and performance metrics. +* Role in Agent Fabric: Agent Visualizer makes the agent network legible, both during development, where you need to verify that routing logic and agent connections are configured correctly, and in production, where you need to identify bottlenecks, trace failures, and optimize performance. It turns multi-agent interactions into clear, interactive maps so you can trace decisions, monitor real-time health, and detect issues before they impact outcomes. Without this visibility, multi-agent systems are opaque and difficult to operate with confidence. +* Key capabilities: +** Visual network topology showing agents, brokers, MCP servers, and their connections +** Performance metrics including latency, throughput, and error rates +** Historical analysis for identifying patterns over time + +* When you need it: Use Agent Visualizer during development to verify your network is wired correctly, at deployment to confirm traffic is routing as expected, and in production to troubleshoot. + +* Learn more: xref:agent-visualizer::index.adoc[Agent Visualizer Overview] + +=== Monitor + +* What it is: In the enhanced MuleSoft experience, monitoring is available at both the service level and the organization level. At the service level, each agent, API, MCP server, LLM proxy, and gateway has a Monitoring tab showing runtime health signals and detailed time-series breakdowns, depending on your gateway, runtime path, and platform connections. At the organization level, Observability aggregates dashboards, reports, and alerts when your administrator has connected the observability backend for your business group. +* Role in Agent Fabric: Monitoring closes the loop between governance and operations. Governance strategies define what should happen; monitoring tells you whether it is happening. It surfaces latency, error rates, request volume, and other runtime signals so you can catch regressions early, triage incidents quickly, and make informed decisions about policy changes and capacity. +* What you can do: +** View runtime health metrics such as latency, error rates, and request volume, including detailed time series and dimensions per service on its Monitoring tab +** Compare signals across instances or environments to attribute changes to deployments or policy updates, allowing you to baseline behavior after changes. +** Configure alert notifications to route API and runtime alerts to Slack, email, or other channels your team monitors +** Access organization-wide dashboards and reports through Observability, using filters to narrow your investigation down to a specific service, environment, or route. + +* When you need it: Use monitoring during development for performance validation, and continuously in production to ensure reliability, meet SLAs, and catch issues before they affect users. + +* Learn more: xref:exp-services-monitoring.adoc[Monitoring Your Services] + +[[supporting-tools]] +== Supporting Tools + +=== Anypoint Code Builder + +* What it is: Anypoint Code Builder is the development environment for building agent networks, configuring agent interactions, and developing custom MCP servers. +* Role in Agent Fabric: Anypoint Code Builder is where agent networks come to life. It provides the visual editor canvas and tooling to define an agent network YAML and develop custom MCP servers, all before deploying to production. +* Key capabilities: +** Design and configure agent network structures with visual editors +** Define routing logic and agent interactions in YAML +** Build and test agent workflows locally before deploying +** Develop custom MCP servers for specific integration needs +** Use MuleSoft Vibes to generate and validate network configurations from natural language +* Learn more: xref:anypoint-code-builder::index.adoc[Anypoint Code Builder Overview] + +=== MuleSoft Vibes + +* What it is: MuleSoft Vibes is the AI assistant built into Anypoint Code Builder, trained on industry best practices for graph-based agent architecture. +* Role in Agent Fabric: Vibes accelerates the process of building agent networks by letting you describe what you want in natural language and generating robust broker and network configurations from those descriptions. Vibes validates that the resulting architecture is sound and aligned with best practices before you deploy. +* What you can do: +** Describe your desired agent network in natural language and generate YAML configurations +** Validate network structure and routing logic against architecture best practices +** Accelerate development from initial design through testing and refinement +* When you need it: Use MuleSoft Vibes throughout the development lifecycle, from initial network design through iterating on routing logic and agent configurations. +* Learn more: xref:anypoint-code-builder::vibes-get-started.adoc[Get Started with MuleSoft Vibes] + +== What's Next + +* Get started with the xref:learning-map-agent-fabric.adoc[Agent Fabric Learning Map] for a guided path through discovering assets, building your first agent network, and deploying it with governance and monitoring. + +* Explore the https://www.mulesoft.com/lp/ebook/mulesoft-agent-fabric-technical-overview[MuleSoft Agent Fabric Technical Overview] for a comprehensive guide to the technical foundations, capability pillars, and architectural best practices that power enterprise agentic transformation. + +* Learn about the technical foundations, capability pillars, and architectural details https://architect.salesforce.com/docs/architect/fundamentals/guide/mulesoft-agent-fabric-deep-dive.html#Agent_Orchestration_Design_Patterns[MuleSoft Agent Fabric Deep Dive]. diff --git a/modules/ROOT/pages/learning-map-agent-fabric.adoc b/modules/ROOT/pages/learning-map-agent-fabric.adoc index 8b657bf31..13a3cc379 100644 --- a/modules/ROOT/pages/learning-map-agent-fabric.adoc +++ b/modules/ROOT/pages/learning-map-agent-fabric.adoc @@ -11,8 +11,6 @@ MuleSoft Agent Fabric helps you turn your agent sprawl into a governed and highl + View metrics, logs, and traces in Anypoint Monitoring. -image::agent-fabric-pillars.png[] - The end-to-end journey for Agent Fabric consists of various tasks, each with links to relevant content to assist you in completing them. [.lm-table, cols="1a,1a,1a", grid="none"] @@ -82,6 +80,7 @@ Visualize your agent network and monitor performance and behavior. [discrete] == See Also +* xref:agent-fabric-overview.adoc[Agent Fabric Overview] * xref:anypoint-code-builder::index.adoc[Anypoint Code Builder] * xref:exchange::index.adoc[Anypoint Exchange] * xref:monitoring::index.adoc[Anypoint Monitoring]