The Protocol Layer
Three protocols are defining how agents discover, communicate, and share context. Together they form the coordination fabric of the agentic enterprise.
The Big Picture
Each protocol solves a different coordination problem. You need all three.
MCP is the agent's toolbox
It standardizes how agents connect to databases, APIs, file systems, and services. Without MCP, every integration is a snowflake.
A2A is the agent's LinkedIn
It lets agents discover each other, advertise capabilities, and coordinate tasks across organizational boundaries. Without A2A, agents are isolated.
Agents SDK is the agent's operating system
It provides the runtime, lifecycle management, and orchestration primitives. Without the SDK, you're building an OS from scratch.
Protocol 01
Model Context Protocol (MCP)
Created by Anthropic, now the universal standard for connecting AI models to the outside world. Backed by OpenAI, Google, Microsoft, Amazon, and Block.
What MCP Does
MCP standardizes how AI models connect to external tools, data sources, and services. Think of it as the USB-C of the AI world — one protocol, universal compatibility. Before MCP, every model-tool integration required custom glue code. With MCP, you write the integration once and it works with any compliant model.
Core Concepts
Servers
Expose capabilities — tools, resources, and prompts — through a standardized interface. A Postgres MCP server exposes queries. A GitHub server exposes repo operations. Each server is a capability boundary.
Clients
Connect AI models to servers. The client manages the session, discovers available tools, routes model requests, and handles authentication. Claude Desktop, Cursor, and VS Code all ship MCP clients.
Transport
The communication layer between client and server. Today: stdio (local) and SSE over HTTP (remote). Tomorrow: Streamable HTTP for stateless, horizontally scalable deployments.
The MCP Context Object
MCP doesn't just connect tools — it carries rich context alongside every interaction. The context object is the protocol's secret weapon for enterprise deployments.
Prompt History
Full conversation context travels with the request
Agent Identity
Authenticated agent credentials and permissions
Access Scope
Fine-grained authorization for tool capabilities
Linked Memory
References to persistent memory stores and embeddings
Decision Logs
Chain-of-thought reasoning for audit trails
Audit Traces
Immutable records of every tool invocation and result
2026 Roadmap
Four working groups are driving the next evolution of MCP.
Transport Evolution
Streamable HTTP replacing SSE for stateless horizontal scaling. Enables serverless MCP deployments and CDN-level caching of tool responses.
Agent-to-Agent Communication
Direct agent delegation through MCP without a central orchestrator. Agents can invoke other agents as tools, enabling recursive multi-agent composition.
Metadata Discovery
.well-known endpoints for automatic server capability discovery. Agents can crawl a domain and understand every available tool without manual configuration.
Agent Lifecycle
Retry semantics, expiry policies for transient tasks, and health-check protocols. Enterprise-grade reliability for mission-critical agent deployments.
Enterprise Deployment
Cloudflare Reference Architecture
Cloudflare's production MCP deployment has become the de facto reference architecture for enterprise teams. Key components:
- Remote MCP Servers — Deployed on Workers, auto-scaling, zero cold start. Each server is a capability boundary with independent auth.
- Code Mode — Reduces token costs by 30-50% by generating executable code instead of sequential tool calls. The agent writes a script, the server executes it.
- Shadow MCP Detection — Monitors for unauthorized MCP servers connecting to your models. The enterprise equivalent of shadow IT, but for agent tooling.
Security Considerations
Supply Chain Attacks
Malicious MCP servers injecting poisoned tool responses. Compromised community servers are the #1 vector for agent exploitation.
Prompt Injection via Tools
Tool responses containing adversarial instructions that hijack agent behavior. Every tool response is an untrusted input surface.
Context Isolation Failures
Sensitive context leaking between sessions or across organizational boundaries. MCP context objects must be scoped and encrypted.
Reduction in development time vs traditional API integrations
Maintenance cost savings from standardized tool interfaces
Protocol 02
Agent-to-Agent Protocol (A2A)
Launched by Google in April 2025, now with 150+ enterprise partners including Atlassian, Salesforce, SAP, ServiceNow, Accenture, Deloitte, and McKinsey.
What A2A Does
A2A enables agents to discover each other's capabilities and coordinate tasks across organizational boundaries. Where MCP connects an agent to tools, A2A connects an agent to other agents. It's the protocol that turns isolated AI assistants into a collaborative workforce.
Core Concepts
Agent Cards
JSON metadata served at /.well-known/agent.json describing an agent's capabilities, skills, authentication requirements, and endpoint URLs. The DNS of the agentic web — any agent can discover any other agent.
Task Lifecycle
Every task moves through a defined state machine: submitted → working → input-required → completed / failed / canceled. Both agents always know the state. No ambiguity.
Parts & Artifacts
Structured message exchange between agents. Parts are individual message components (text, files, data). Artifacts are the final outputs of completed tasks. Strong typing prevents the "JSON soup" problem.
Built on Existing Standards
HTTP, SSE, and JSON-RPC — no exotic dependencies. Enterprise teams can deploy A2A alongside existing API infrastructure. Load balancers, API gateways, and service meshes all work out of the box.
v0.3 Highlights
- gRPC support for high-throughput inter-agent communication
- Enhanced security model with mutual TLS and signed Agent Cards
- Streaming improvements for long-running collaborative tasks
- Push notification support for async task completion
Enterprise Case Study: Tyson Foods
Tyson Foods uses A2A for supply chain automation across their network of suppliers, logistics partners, and distribution centers. Procurement agents discover supplier agents via Agent Cards, negotiate pricing through structured task exchanges, and coordinate delivery schedules — all without human intermediaries for routine orders.
MCP vs A2A — They're Complementary
This is the most common point of confusion. Here's the distinction:
MCP = Agent → Tool
"I need to query a database" — MCP provides the connection.
A2A = Agent → Agent
"I need a specialist to handle this" — A2A finds the right agent and delegates.
Protocol 03
OpenAI Agents SDK (Agents SDK)
Replaces the Assistants API (sunsetting August 2026). Built on the Responses API — a unified, stateful interface for building production agent systems.
Five Primitives
Agents
LLMs configured with instructions, tools, and system prompts. Each agent is a specialized unit of work with clear boundaries.
Tools
Function calling, web search, file search, and Computer-Using Agent (CUA). Agents interact with the world through typed tool interfaces.
Handoffs
Structured delegation between agents. A triage agent routes to specialists. Each handoff carries full context — no information loss.
Guardrails
Input/output validation hooks that run before and after every agent turn. Enforce schemas, block PII leakage, and validate tool outputs.
Tracing
Automatic observability piped to the OpenAI dashboard. Every tool call, handoff, and guardrail check is logged with latency and token counts.
Computer-Using Agent (CUA)
Agents that can see and interact with screen UIs — clicking buttons, filling forms, navigating apps. 87% accuracy on WebVoyager benchmark. The bridge between agent workflows and legacy software with no API.
Enterprise Adopters
Stripe
Automated invoicing & dispute resolution
Coinbase
Wallet agents for transaction management
Box
Enterprise data analysis & summarization
Navan
Travel booking & expense management
Hebbia
Deep research across financial documents
Key Strength
The Agents SDK offers the tightest integration with OpenAI models and the simplest path for OpenAI-native shops. If your organization is already on GPT-4o or o3, the SDK gives you agents, handoffs, guardrails, and tracing out of the box — with minimal abstraction layers between your code and the model.
Protocol Comparison
How the three protocols differ across key dimensions.
| Dimension | MCP | A2A | Agents SDK |
|---|---|---|---|
| Purpose | Agent-to-tool connection | Agent-to-agent coordination | Agent runtime & orchestration |
| Scope | Context & tool access | Discovery & task delegation | Full agent lifecycle |
| Backed By | Anthropic, OpenAI, Google, Microsoft, Amazon | Google, 150+ enterprise partners | OpenAI |
| Adoption | 97M monthly SDK downloads | 150+ enterprise partners | Replacing Assistants API (Aug 2026) |
| Best For | Connecting models to external data & tools | Cross-org agent collaboration | OpenAI-native agent development |
| Works With | Any LLM, any framework | Any agent runtime | OpenAI models (GPT-4o, o3, etc.) |
How They Work Together
A real enterprise deployment uses all three protocols in concert. Here's how a user request flows through the stack.
User Request
A user submits a complex request: "Analyze Q3 sales data, compare against industry benchmarks, and draft an executive summary."
Agents SDK Runtime
The supervisor agent (built on Agents SDK) decomposes the task into subtasks using its instructions and guardrails. It decides which specialized agents to invoke via handoffs.
MCP Tool Access
The data analyst agent uses MCP to connect to the Salesforce server (pull Q3 data), the Postgres server (query internal metrics), and the file system server (retrieve report templates). Each connection carries full context.
A2A Agent Discovery & Delegation
For industry benchmarks, the agent discovers an external research agent via its Agent Card at the market data provider's domain. It delegates the benchmark comparison task via A2A, receiving structured artifacts back.
Results Flow Back
All results converge at the supervisor agent. Tracing captures every step. Guardrails validate the final output. The executive summary is delivered with full provenance — every data point is traceable to its source.
Protocols are the foundation. What you build on them matters.
Understanding MCP, A2A, and the Agents SDK is step one. Next: learn how to orchestrate agents at scale and secure the communication layer.