NLIP, A2A, MCP: the three protocols your agents actually need

If you are building multi-agent systems today, you have three protocol options competing for your attention. MCP connects agents to tools. A2A connects agents to agents. NLIP connects everything to everything, at the cost of being newer and less proven. Knowing which layer each one operates at saves you from picking the wrong one and rebuilding six months later.

The problem they all solve

Every agent framework rolls its own communication layer. CrewAI has internal messaging. LangGraph uses a graph-based state channel. Hermes Agent has its own plugin system. None of them talk to each other.

This is fine when you run one framework. The moment you need a CrewAI research agent to hand off to a LangGraph coding agent, or a Hermes automation agent to call a Salesforce agent, the integration becomes bespoke glue code. Three protocols now exist to standardise different parts of that glue.

MCP: the tool layer

The Model Context Protocol, released by Anthropic in late 2025 and standardised at modelcontextprotocol.io, connects language models to external tools. Think of it as USB-C for tool calls: a standard way for an agent to discover, invoke, and receive results from tools like databases, APIs, file systems, and web scrapers.

MCP defines three primitives: tools (functions the model can call), resources (data the model can read), and prompts (reusable instruction templates). A server exposes these over a transport (stdio for local, HTTP+SSE for remote), and a client discovers and invokes them.

// MCP tool call — the model decides when to invoke this
{
  "method": "tools/call",
  "params": {
    "name": "query_database",
    "arguments": {
      "sql": "SELECT count(*) FROM orders WHERE status = 'pending'"
    }
  }
}

MCP is good at what it does. The specification is clear, the transport is simple, and the ecosystem has grown fast. By September 2026, there are hundreds of MCP servers for everything from PostgreSQL to GitHub to Slack. If you need your agent to use a tool, MCP is the right answer.

A2A: the agent layer

Google released the Agent-to-Agent protocol in early 2026. Where MCP connects agents to tools, A2A connects agents to other agents. The distinction matters: a tool has structured inputs and predictable behaviour. An agent is autonomous, may take hours to complete a task, and might communicate in natural language rather than JSON.

A2A has four stages:

1. Discovery. Agents publish an Agent Card at a well-known URL. The card describes what the agent can do, what modalities it supports (text, audio, video), and how to authenticate with it.
2. Task creation. A client agent sends a task to a remote agent with a unique ID and the work to be done.
3. Execution. The remote agent works on the task. This can take seconds or hours. The client receives status updates via server-sent events.
4. Completion. The task reaches a terminal state: completed, failed, or cancelled. The result includes any artifacts the remote agent produced.

A2A builds on existing standards: HTTP for transport, SSE for streaming updates, JSON-RPC for messages, and OpenAPI authentication schemes. Fifty technology partners have signed on, including Salesforce, SAP, LangChain, and MongoDB.

// A2A Agent Card — what a remote agent advertises
{
  "name": "Research Agent",
  "description": "Deep research on any topic, returns cited reports",
  "url": "https://research.example.com/a2a",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {"id": "web-research", "name": "Web Research"}
  ]
}

NLIP: the envelope layer

The Natural Language Interaction Protocol, published as an arXiv paper on 3 September 2026 (2609.04135) and standardised by Ecma International, takes a different approach. Instead of defining specific interaction patterns (tool calls, task management), NLIP defines a message envelope that can carry any content over any transport.

The core idea: a lightweight semantic wrapper around natural language messages that includes metadata about the sender, receiver, conversation context, and capabilities. The envelope travels over HTTP, WebSocket, AMQP, or whatever transport the deployment requires. NLIP-aware gateways can translate between protocols, adapt to different ontologies, and bridge heterogeneous systems.

The paper was written by researchers from multiple companies and universities. It presents NLIP as a layer that sits above specific protocols like MCP and A2A, providing a common language for agents that may not share a framework, model, or even a definition of what "tool call" means.

// NLIP message envelope (simplified)
{
  "nlip_version": "1.0",
  "sender": { "id": "agent-a", "type": "llm-agent" },
  "receiver": { "id": "agent-b", "type": "tool-agent" },
  "context": { "conversation_id": "conv-123", "turn": 4 },
  "content": {
    "modality": "text",
    "body": "Summarise the quarterly report and flag any anomalies."
  }
}

How they compare

Where they overlap

The A2A team addresses this directly in their documentation: "Agentic applications need both A2A and MCP. We recommend MCP for tools and A2A for agents." That is the cleanest mental model. MCP is the tool layer. A2A is the collaboration layer. They are complementary, not competing.

NLIP is more ambitious. It wants to be the envelope that carries everything, including MCP and A2A messages. In theory, an NLIP gateway could receive a message from an A2A client and route it to an MCP server, translating formats along the way. In practice, this is early-stage work. The reference implementation exists, but production deployments are scarce.

The risk with NLIP is the same risk that plagued SOAP and WS-* specifications: trying to solve every integration problem at once produces a specification so general that nobody implements it completely. The advantage is that Ecma standardisation gives it a path to formal adoption that MCP and A2A lack.

What to build on today

If you are starting a multi-agent project in September 2026, here is the honest recommendation:

1. Use MCP for every tool integration. The ecosystem is mature enough that you should not be writing bespoke tool-call code. Pick an existing MCP server or write one if nothing covers your use case.
2. Use A2A for agent-to-agent communication. If you need agents built on different frameworks to collaborate, A2A's task lifecycle and Agent Card discovery model is the most practical option today.
3. Watch NLIP. If you are building enterprise infrastructure that must bridge many protocols and ontologies, track NLIP's progress. The Ecma standardisation process moves slowly, but the result tends to be durable.
4. Do not pick one and ignore the others. They operate at different layers. An agent that uses MCP for tools and A2A for collaboration is not making a trade-off. It is using the right layer for each job.

Putting it together

A practical multi-agent setup using both MCP and A2A looks like this:

# Pseudocode: research agent delegates to a coding agent

import mcp
import a2a

# Local tools via MCP
db_client = mcp.Client("stdio://postgres-mcp-server")
github_client = mcp.Client("stdio://github-mcp-server")

# Remote agent via A2A
coding_agent = a2a.RemoteAgent(
    agent_card_url="https://coder.example.com/.well-known/agent.json"
)

# Research phase: use local tools
data = db_client.call_tool("query_database", sql="SELECT ...")

# Coding phase: delegate to remote agent
task = coding_agent.create_task(
    message=f"Write a Python script to analyse this data: {data}"
)

# Wait for completion (with streaming updates)
for update in task.stream():
    print(update.status, update.message)

result = task.wait()
github_client.call_tool("create_pull_request", **result.artifacts)

The MCP clients handle tool discovery and invocation. The A2A client handles the long-running delegation to a remote coding agent. Each protocol does what it was designed for. No glue code, no custom integration layer.

Sources

• NLIP paper: Xing et al., "The Natural Language Interaction Protocol and Standard for AI Agents," arXiv:2609.04135, 3 Sep 2026
• MCP specification: modelcontextprotocol.io/specification
• A2A protocol: a2aprotocol.ai
• A2A specification: github.com/a2aproject/A2A