Agentic systems leverage multiple agents and multiple tools. These agents and tools can be developed and hosted by different providers. To allow inter-agent communication and to access different data sources, standards like Model Context Protocol (MCP) and Agent Communication Protocol (ACP) are evolving.
Model Context Protocol (MCP) is an evolving standard driven by Anthropic which focusses on the re-use of tools and access to various data sources. Agent Communication Protocol (ACP) is led by IBM Research and goes one step further by proposing how to do agent-to-agent collaboration.
Model Context Protocol
MCP defines a common protocol to access tools. Custom tools can be developed, for example to access enterprise data and to invoke business logic. Additionally, tools can be re-used via MCP servers. The MCP standards provides the flexibility to switch between LLM providers and vendors.
MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.
MCP offers a specification as well as SDKs to enable developers to implement MCP in their systems.
Enterprise features like authentication and remote MCP server support are planned to be added soon.
MCP Example
Here is a simple example of an MCP server. Python functions can be marked as tools by using decorators. The descriptions and arguments are described via natural language.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("weather")
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"
async def make_nws_request(url: str) -> dict[str, Any] | None:
"""Make a request to the NWS API with proper error handling."""
headers = {
"User-Agent": USER_AGENT,
"Accept": "application/geo+json"
}
async with httpx.AsyncClient() as client:
try:
response = await client.get(url, headers=headers, timeout=30.0)
response.raise_for_status()
return response.json()
except Exception:
return None
@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
"""Get weather forecast for a location.
Args:
latitude: Latitude of the location
longitude: Longitude of the location
"""
points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
points_data = await make_nws_request(points_url)
if not points_data:
return "Unable to fetch forecast data for this location."
forecast_url = points_data["properties"]["forecast"]
forecast_data = await make_nws_request(forecast_url)
if not forecast_data:
return "Unable to fetch detailed forecast."
periods = forecast_data["properties"]["periods"]
forecasts = []
for period in periods[:5]:
forecast = f"""
{period['name']}:
Temperature: {period['temperature']}°{period['temperatureUnit']}
Wind: {period['windSpeed']} {period['windDirection']}
Forecast: {period['detailedForecast']}
"""
forecasts.append(forecast)
return "\n---\n".join(forecasts)
Agent Communication Protocol
ACP goes one step further and proposes how to do agent-to-agent collaboration.
The Agent Communication Protocol (ACP) is a protocol designed to standardize how agents communicate, enabling automation, agent-to-agent collaboration, UI integration, and developer tooling. Current agent systems often use diverse communication standards, causing complexity, integration difficulties, and vendor lock-in. ACP addresses these issues uniquely by standardizing interactions tailored specifically for agents.
ACP is being defined by the BeeAI community which is driven by IBM Research. BeeAI is govererned by the Linux Foundation. Right now ACP is in alpha and the organizers are inviting the community to actively participate.
Topics are listed on the ACP Architecture page:
- Support for Stateful Agents
- Choosing between REST and JSON-RPC for Communication
- WebSockets vs HTTP vs Peer-to-Peer (Full Duplex Communication)
- Streaming Data between Agents
- Handling Request Cancellation and Ensuring Persistency
- Agent and Tool Providers versus MCP Servers: Roles and Responsibilities
- Configuration and Model Dependency Management for Agents