AGENTPERF04-BP02 Implement efficient protocol-based agent communications
Standardized protocols such as the Model Context Protocol (MCP) and agent-to-agent (A2A) give agents a consistent way to communicate with tools and each other, reducing per-interaction overhead and enabling interoperability. Different protocols have different performance profiles, connection establishment, serialization, streaming, multiplexing, which makes protocol selection a meaningful performance decision for high-frequency agent communication.
Desired outcome:
-
You use MCP for tool integration, A2A for agent-to-agent coordination, and streaming protocols for real-time agent-user interactions.
-
You have protocol overhead minimized through connection reuse and efficient serialization.
-
You have documented protocol selection guidelines for the organization.
Common anti-patterns:
-
Using HTTP or REST APIs with JSON serialization for all agent communications regardless of interaction pattern, paying connection establishment and verbose serialization overhead for high-frequency internal communications.
-
Implementing custom communication protocols instead of adopting standards like MCP and A2A, creating maintenance burden and blocking interoperability with the broader agent ecosystem.
-
Establishing new connections for every agent interaction rather than pooling and reusing them, adding unnecessary handshake latency.
Benefits of establishing this best practice:
-
Protocol-appropriate connection management reduces per-interaction overhead.
-
Standard protocols open interoperability with the broader agent ecosystem.
Level of risk exposed if this best practice is not established: Medium
Implementation guidance
Adopt MCP as the standard protocol for agent-to-tool communication. Amazon Bedrock AgentCore Gateway exposes tools as MCP-compatible endpoints that agents discover and invoke through a consistent interface. For agent-to-agent communication, the A2A protocol supported by AgentCore Runtime provides structured inter-agent coordination with agent card discovery, task delegation, and result collection. Frameworks such as Strands Agents and LangGraph provide MCP and A2A support.
For real-time agent-user interactions that need streaming,
WebSocket connections through
Amazon API Gateway
Authentication overhead is part of the protocol performance profile. In complex multi-agent workflows, token validation, credential issuance, and policy evaluation accumulate into a measurable latency contributor. AgentCore Identity provides agent authentication with token caching, and AWS IAM roles for service-to-service authentication remove explicit credential exchange from the critical path.
Implementation steps
-
Adopt MCP for agent-to-tool communications through AgentCore Gateway: Expose tools as MCP-compatible endpoints through Amazon Bedrock AgentCore Gateway so agents discover and invoke tools through a consistent interface.
-
Use A2A protocol through AgentCore Runtime for agent-to-agent coordination: Use the A2A protocol supported by AgentCore Runtime for agent-to-agent coordination, with agent card discovery, task delegation, and result collection.
-
Implement WebSocket connections through API Gateway for real-time streaming agent-user interactions: Use WebSocket connections through Amazon API Gateway
for real-time streaming so the channel stays open rather than reestablishing on each turn. -
Enable connection pooling and protocol-level compression for all communications: Pool connections on every protocol path and enable compression once payloads exceed a few kilobytes.
-
Budget for authentication overhead and implement token caching through AgentCore Identity: Use AgentCore Identity with token caching for agent authentication, and use AWS IAM roles for service-to-service calls so credential exchange isn't on the critical path.
Resources
Related best practices:
Related documents:
Related videos:
Related examples:
Related tools:
Related services:
