The Various Protocols Used in AI

If you've been building with AI in the last year, you've probably noticed something: everyone's talking about protocols. Not HTTP, not gRPC — the new protocols. The ones that let an AI agent use a calculator, call another agent, or orchestrate a multi-step workflow without everything collapsing into spaghetti.

I've spent the last few months deep in this space, and here's my attempt to make sense of it. There are five major players right now: MCP (Model Context Protocol), A2A (Agent-to-Agent), ACP (Agent Communication Protocol), AG2/AutoGen, and LangGraph. Each solves a different slice of the "how do AI agents actually do things" problem. Let me break them down.

MCP — Model Context Protocol

Created by: Anthropic (open-sourced in late 2024)

The problem it solves: Before MCP, every AI integration was custom. Want Claude to read your Google Drive? Custom integration. Want it to query your database? Custom integration. Every tool connection was a one-off engineering effort, and none of them talked to each other.

How it works: MCP is a client-server protocol. You have an MCP host (like Claude Desktop, an IDE plugin, or your own app), an MCP client that manages connections, and MCP servers that expose specific tools — file systems, databases, APIs, whatever. The protocol defines a standard JSON-RPC 2.0 message format for listing tools, calling them, and getting results back. It also handles capability negotiation: a server announces what it can do, and the client adapts.

Think of it as USB-C for AI. One standard connector, many devices.

Current adoption: This is moving fast. Claude Desktop ships with MCP support. Cursor, Windsurf, and VS Code have integrated it. There are thousands of community MCP servers. Stripe, Notion, GitHub — all building official ones. It's quickly becoming the default way to give an LLM access to external tools.

A2A — Agent-to-Agent Protocol

Created by: Google (announced April 2025, open-sourced)

The problem it solves: MCP handles agent-to-tool communication. But what about agent-to-agent? If I have a hiring pipeline where one agent screens resumes, another schedules interviews, and a third makes offers, they need a standard way to discover each other, delegate tasks, and exchange results — even if they're built on different frameworks.

How it works: A2A defines a role-based model: a client agent and a remote agent. Each agent publishes an "Agent Card" (a JSON descriptor at /.well-known/agent.json) containing its name, capabilities, supported input/output formats, and authentication requirements. Communication happens through structured tasks with lifecycle states (submitted → working → input-required → completed / failed / canceled). Messages carry typed parts (text, files, structured JSON), and agents can produce artifacts as output.

It's essentially a task-oriented protocol for agent delegation, with built-in support for long-running operations and multi-turn interactions.

Current adoption: Still early. Google announced it at Cloud Next 2025, and the spec is open-source. Some early integrations exist (LangChain has experimental support, AutoGen 0.4+ integrates with it), but production deployments are rare. The spec itself is still evolving. It's one to watch, not one to bet your architecture on today.

ACP — Agent Communication Protocol

Created by: IBM Research / the BeeAI project (now part of the Linux Foundation's agentic AI ecosystem)

The problem it solves: Similar to A2A — agents need to communicate — but ACP takes a different philosophical approach. Where A2A is task-oriented and structured, ACP is more about flexible, conversational communication between agents in a decentralized network.

How it works: ACP treats communication as structured conversations. Agents exchange messages with typed content blocks, maintain shared conversation state, and can discover each other dynamically. It supports both synchronous request-response and asynchronous message-passing patterns. Agents can form ad-hoc "acquaintances" — they discover peers, establish communication channels, and negotiate interaction patterns at runtime.

The protocol separates the communication layer from the agent logic, so you can plug ACP into any agent framework. It also supports multi-modal content natively in messages.

Current adoption: ACP is the quiet one in the room. It has solid academic backing and IBM's engineering behind it, but it hasn't gotten the same hype cycle as MCP or A2A. It's part of the broader push toward open agent ecosystems, and I expect it to gain traction in enterprise settings where IBM has influence. For now, it's more reference implementation than production standard.

AG2 / AutoGen

Created by: Microsoft Research (original AutoGen), now maintained by the AG2 community

The problem it solves: The other protocols here are about communication standards. AutoGen is different — it's a full framework for building multi-agent systems. The problem: how do you get multiple AI agents to collaborate on a complex task, with each agent having its own role, memory, and reasoning capability?

How it works: AutoGen (now rebranded as AG2 for the community-driven fork) provides abstractions for conversable agents. You define agents with specific system messages, capabilities, and behavior patterns. The framework handles the orchestration — who talks to whom, in what order, with what context. Built-in patterns include:

TwoAgentChat: Simple back-and-forth between agents
GroupChat: Multiple agents in a shared conversation with a speaker selection mechanism
RoundRobinGroupChat: Agents take turns in a fixed order
SelectorGroupChat: An LLM decides who speaks next based on context

AG2 adds features like tracking agent costs, custom agent teams, and integrations with external protocols (including A2A and MCP). The original AutoGen 0.4 release was a major rewrite with better async support and a more modular architecture.

Current adoption: AutoGen has the most GitHub stars of anything in this post (~40k+). It's widely used in research and has a strong community. AG2 is the actively maintained fork moving forward. It's production-viable for research-heavy and internal tooling use cases, though it's more framework than protocol — it doesn't try to be a universal standard.

LangGraph

Created by: LangChain (Harrison Chase, late 2023)

The problem it solves: LLMs are stateless. Real workflows aren't. How do you build an AI application that has branching logic, cycles, persistent state, retries, and human-in-the-loop checkpoints — without losing your mind?

How it works: LangGraph is a graph-based orchestration framework built on top of LangChain. You define your application as a graph: nodes are functions (LLM calls, tool invocations, arbitrary Python), edges define the flow between them, and a shared state object persists across the graph. The key insight is that graphs support cycles — so you can loop back, retry, or iterate until a condition is met.

Core primitives: - StateGraph: The main abstraction — define nodes, edges, and a state schema - Nodes: Functions that read and write to shared state - Edges: Conditional or static transitions between nodes - Checkpoints: Persist state at every step for debugging, replay, and human-in-the-loop - Supervisor pattern: A "router" LLM decides which specialized agent to invoke next

LangGraph doesn't try to be a communication protocol. It's an orchestration engine. You use it to build the inside of a single agent or a tightly-coupled multi-agent system.

Current adoption: LangGraph is arguably the most production-deployed tool on this list. LangChain's ecosystem is massive, and LangGraph is the go-to for complex agent workflows. Companies are running it in production for customer support, research synthesis, code generation, and more. It has strong documentation, a large community, and first-class support for streaming, debugging, and deployment.

Comparison

Protocol/Framework	Type	Creator	Primary Problem	Maturity	Ecosystem Size
MCP	Communication protocol	Anthropic	Agent ↔ Tool connectivity	Early production	Very large, fast-growing
A2A	Communication protocol	Google	Agent ↔ Agent delegation	Spec stage / early integrations	Small, growing
ACP	Communication protocol	IBM Research	Decentralized agent communication	Research / reference	Small
AG2/AutoGen	Multi-agent framework	Microsoft Research	Agent team orchestration	Mature (research), growing (production)	Large
LangGraph	Orchestration framework	LangChain	Stateful agent workflows	Production-ready	Very large

Where This Is All Going

Here's my honest take: we're in the "TCP/IP moment" of AI agents. Multiple protocols, competing philosophies, no clear winner yet. But I think three things will happen in the next 12-18 months:

MCP wins the tool layer. It's simple, it works, and the ecosystem momentum is undeniable. Expect it to become the default way agents connect to external systems — the way REST became the default for web APIs.
A2A and ACP converge or one dies. The agent-to-agent space is too small for two competing standards long-term. Google's weight gives A2A an edge, but IBM's enterprise relationships and ACP's technical flexibility could keep it alive. My bet: A2A becomes the practical standard, ACP influences the design.
Frameworks absorb protocols. LangGraph will speak MCP and A2A. AG2 will too. The distinction between "framework" and "protocol" will blur — frameworks will implement protocols natively, and protocols will ship with reference framework implementations.

The winning architecture in 2027 will probably look like this: MCP for tool connectivity, A2A for agent-to-agent delegation, and LangGraph (or its successor) for internal orchestration. The protocols are complementary, not competitive.

If you're building today: start with MCP for tool integration, use LangGraph for complex workflows, keep an eye on A2A for when you need cross-agent delegation. And don't sleep on AG2 if you're doing research-heavy multi-agent work.

The space is moving fast. The best time to learn these was six months ago. The second best time is now.