Bring Your Own Agent: Integrating External Agents into Solace Agent Mesh  

The adoption of AI by enterprises is accelerating, but many initiatives fail to move beyond pilots. While teams can build capable agents quickly, those agents often fail to integrate cleanly with real enterprise systems and other agents. The challenge is not intelligence — it is integration and orchestration.

Agents must be able to talk to and work with ticketing systems, documentation platforms, internal APIs, and operational workflows without compromising security, governance, or reliability. Systems that rely on synchronous calls and tightly coupled workflows may succeed in demos, but they introduce fragility, latency, and operational risk that doom them to failure in production.

What enterprise AI needs is a durable foundation for integration and orchestration — one that links distributed systems, facilitates long-running processes, and can carry on through failures of individual agents, applications, and network links.

Why Agent Mesh is the Right Foundation

Solace Agent Mesh is not a standalone AI framework. It is built on top of Solace Platform, which many of the world’s leading enterprises have used to build event meshes that make real-time data available across their mission‑critical distributed systems like factory floors, stock markets, supply chains, and trading systems.

Where many AI frameworks assume synchronous calls and tightly coupled workflows, Agent Mesh uses an asynchronous, decoupled foundation. This enables agents to reliably communicate across long‑running processes, partial failures, multiple environments, and strict governance boundaries.

By orchestrating agents on top of an event mesh, you gain:

• Asynchronous coordination without blocking
• Built-in buffering and backpressure
• Natural fan-out and intelligent routing
• Replay and auditability
• Location transparency across environments

This transforms agents from experimental tools into resilient enterprise services.

Enterprise adoption also depends on how agents are introduced and connected. Organizations already have existing agents, services, and domain specific AI components built using different technologies and deployed across multiple environments. Agent Mesh is designed to integrate these external agents into a shared orchestration layer rather than replace them.

This integration is achieved through two complementary methods:

• A2A, which allows external agents to participate directly in agent-to-agent workflows
• MCP, which provides a governed integration surface for invoking external services and capabilities

 

Agent Discovery and Integration over the Event Mesh

For agent orchestration to work at enterprise scale, agents must be discoverable, describable, and dynamically connectable without hard‑coding endpoints or relying on centralized registries.

Agent Cards are defined as part of the A2A interaction model and provide declarative descriptions of an agent’s identity, skills, interfaces, and security requirements. Solace Agent Mesh implements Agent Cards over the event mesh by publishing them as events through the broker, enabling orchestrators to subscribe to capability announcements and route requests dynamically.

How Agent Cards flow through the Event Mesh

Agent Cards are published as events, enabling dynamic discovery and loose coupling. Readers who are new to Solace topic hierarchies and publish subscribe semantics can refer to this overview for background.

A typical topic taxonomy includes:

• {namespace}/a2a/v1/discovery/agentcards — agent capability announcements
• {namespace}/a2a/v1/agent/request/{agent_name} — requests to an agent
• {namespace}/a2a/v1/agent/response/{agent_name}/{request_id} — asynchronous responses
• {namespace}/a2a/v1/agent/status/{agent_name} — health and lifecycle updates

Because all interactions are event‑driven, agents can be added, removed, or relocated without reconfiguration to the agent itself, as long as it integrates via A2A or MCP.

MCP Server: External Incident Resolver Agent Example

To make this concrete, consider an external custom agent: an Incident Resolver. The resolver analyzes incident context, retrieves relevant history and documentation, and produces an actionable status summary. It is integrated into Solace Agent Mesh via an MCP Server so it can be invoked asynchronously through publish/subscribe topics.

Integration Steps

To bring this external agent into Solace Agent Mesh:

1. Create an MCP Server that wraps your external agent and exposes its capabilities as MCP tools
2. Create a SAM Agent configured to connect to the MCP Server
3. Define the Agent Card describing the agent’s skills and tools
4. Deploy — SAM publishes the Agent Card and subscribes to the appropriate request/response topics

Agent Card

The Agent Card advertises the Incident Resolver’s capabilities to the mesh (skills and the MCP tools behind them), along with interface and security requirements. Orchestrators use these cards to select the right agent at runtime without hard‑coded endpoints.

Topic Taxonomy

Once deployed, SAM automatically generates topic subscriptions for the Incident Resolver agent. For the namespace incident-mgmt:

Topic-Pattern	Purpose
incident-mgmt/a2a/v1/discovery/agentcards	Agent Card announcements
incident-mgmt/a2a/v1/agent/request/incident_resolver	Requests TO the agent
incident-mgmt/a2a/v1/agent/response/incident_resolver	Responses FROM the agent
incident-mgmt/a2a/v1/agent/status/incident_resolver	Agent health/status updates
incident-mgmt/sam/events/session/>	Session management

All communication flows through the Solace broker using publish/subscribe semantics. Requests are published to the agent’s request topic; responses are published back on response topics correlated by request_id, enabling asynchronous and resilient workflows.

End-to-End Orchestration Flow

1. A user submits a request, for example: “What’s the status of INC-1234?”, which is published as an event to
   incident-mgmt/a2a/v1/agent/request/orchestrator.
2. The orchestrator (Agent Mesh agent) consumes the request event and evaluates available Agent Cards to determine the appropriate agent capability and required context.
3. The orchestrator publishes the request event to the selected agent’s request topic:
   incident-mgmt/a2a/v1/agent/request/incident_resolver.
   The Incident Resolver agent is subscribed to this topic and receives the event asynchronously.
4. The Incident Resolver agent processes the event and invokes an MCP tool, for example
   suggestResolution("INC-1234").
5. The MCP Server authenticates via OAuth2, invokes the external Incident Resolver agent or service, and returns the result to the Incident Resolver agent.
6. Incident Resolver agent publishes the result as an event to
   incident-mgmt/a2a/v1/agent/response/incident_resolver/{request_id}.

A2A Proxy Integration

While MCP integration wraps external agents behind an MCP Server, A2A integration provides a complementary path. The key architectural difference is the proxy layer.

With MCP, an Agent Mesh agent invokes an MCP Server that wraps the external agent. With the A2A Proxy, the external agent runs independently with its own A2A endpoint, while the proxy bridges between the event mesh and HTTP. This allows external agents to participate in Agent Mesh workflows without any Solace-specific dependencies.

The A2A Proxy discovers A2A-native agents, retrieves their Agent Cards, and publishes those cards into the event mesh so the orchestrator can route requests transparently. From the orchestrator’s perspective, proxied agents are indistinguishable from native SAM agents.

Use MCP when you want a governed wrapper around existing tools or services. Use A2A Proxy when agents already speak A2A and should remain independently deployable.

What This Gives You

You Control	Agent Mesh Provides
Agent logic, reasoning, and framework	Discovery via Agent Cards over event mesh
Where it runs (cloud, on-prem, edge)	Event-driven orchestration and routing
What tools, APIs, and data sources it uses	MCP and A2A Proxy for protocol bridging
MCP and A2A Proxy for protocol bridging	Governance, observability, and audit
Independent scaling and deployment	Resilient pub/sub delivery and replay

You keep full control over your agent’s logic, where it runs (cloud, on‑prem, edge), and the framework it uses internally—while Agent Mesh provides discovery (Agent Cards), event‑driven orchestration, governance, observability, and resilient pub/sub delivery.

Here is an example illustration of the observer agent execution with Agent Mesh:

Conclusion

Enterprise AI success depends on integrating agents with real systems safely and reliably. With MCP integration for wrapping external tools, A2A Proxy for connecting native A2A agents, and event‑driven discovery via Agent Cards, Agent Mesh lets you bring your own agents—built with any framework, running anywhere—into a governed orchestration layer.

Key takeaways:

• MCP provides the governed bridge between SAM and your external tools and agents
• A2A Proxy enables native A2A agents to participate in the mesh without wrappers or Solace-specific dependencies
• Agent Cards enable dynamic discovery and selection without hard‑coded endpoints
• Topic-based routing enables asynchronous, resilient communication at scale
• You keep control of your agent’s logic, location, and implementation

Bring your own agent. Let SAM orchestrate it.