Agent Communication Protocols: The Language of Cooperation
“The final frontier: Standardizing the Agent-to-Agent dialogue.”
TL;DR
Agent communication protocols are the standardized languages that let AI agents negotiate, hand off tasks, and reach consensus. The foundation is Speech Act Theory as formalized in FIPA-ACL; four performatives cover most LLM agent traffic: INFORM, REQUEST, PROPOSE, and AGREE. Modern implementations use structured JSON with metadata (version, sender/receiver IDs, confidence scores) for interoperability, increasingly carried by the open MCP (agent-to-tool) and A2A (agent-to-agent) protocols, message brokers like Redis for async delivery, and consensus mechanisms (voting or deliberative round tables) for group decisions. Reliability requires idempotency keys to prevent duplicate processing and sequence numbers for message ordering. For the multi-agent architectures these protocols support, see Multi-Agent Architectures, and for how individual agents are designed with specialized roles, see Role-Based Agent Design.

1. Introduction: The Tower of Babel Problem
In multi-agent architectures, we saw how to organize agents into teams. But how do those agents actually “talk” to each other?
If Agent A (a researcher) says, “I found the info, here it is,” and Agent B (a writer) expects a structured JSON object with a specific schema, the communication fails. The “Tower of Babel” problem occurs when every developer builds agents with their own proprietary way of passing messages.
To build a world where agents can work across companies and platforms, we need Protocols. Just as the web relies on HTTP and email relies on SMTP, AI Agents need a standardized language for negotiation, task handoff, and consensus.
In this post, we will explore the past, present, and future of Agent Communication Protocols.
2. Deep Dive: FIPA-ACL and the “Speech Act” Theory
While the code of the 90s is outdated, the Speech Act Theory remains the foundation of agentic communication. When one agent talks to another, it isn’t just “sending text”, it is performing an action.
2.1 Four Performatives for LLMs
The FIPA-ACL specification defines about twenty communicative acts. Four of them cover most of what LLM agents say to each other, and labeling every message with one makes its intent explicit, easy to route, and easy to audit:
INFORM(The Fact): “The weather in London is 15C.” (No action required from the receiver).REQUEST(The Command): “Calculate the tax for this order.” (Expects a return message with data).PROPOSE(The Suggestion): “I suggest we use a smaller model for this task based on the current cost.” (Expects anACCEPT-PROPOSALorREJECT-PROPOSALback).AGREE(The Promise): “I will finish the research in 5 minutes.” (Commits to a requested action; updates the Supervisor’s state plan).
2.2 Implementing Performatives in Prompts
You can implement this by adding a “Constraint” to your system prompt: “Every message you send to another agent must be wrapped in an XML tag like <intent>REQUEST</intent>.”
3. Communication Pattern: The “Agentic Handshake”
Before two agents start a complex task, they must establish a Protocol Buffer (not the Google kind, but a conceptual one).
The Handshake Workflow:
- Capability Query: Agent A asks, “Agent B, do you support the ‘Image-Generation’ tool?”
- Capability Response: Agent B responds, “Yes. My max resolution is 1024x1024.”
- Handoff Agreement: Agent A sends the task: “Generate an image of a cat. Resolution: 1024x1024.”
Why this is better than one big prompt: It prevents “Ambiguous Failures.” If Agent B didn’t support image generation, the error is caught at Step 1, rather than Step 3 after Agent A has already wasted tokens describing the cat. The same handshake can fix the data format: “Send me a JSON with fields: ‘price’, ‘volume’, and ‘summary’.”
4. The Present: Structured JSON and Open Protocols
Structured JSON is the de facto format for agent messages, and two open protocols now standardize how it travels.
4.1 MCP and A2A
- MCP (Model Context Protocol): Introduced by Anthropic in November 2024 for connecting an agent to tools and data. A server describes its tools with JSON Schemas, and any MCP client can call them. Since December 2025 it is governed under the Linux Foundation’s Agentic AI Foundation.
- A2A (Agent2Agent): Introduced by Google in April 2025 and moved to the Linux Foundation in June 2025, for one agent to delegate work to another. Each agent publishes an Agent Card, a JSON document listing its skills and endpoint, which is a standardized version of the capability handshake above. Work is tracked as a task that moves through states such as
submitted,working,input-required,completedandfailed. - Both run on JSON-RPC 2.0 (Section 7.2). In short, MCP connects an agent to its tools and A2A connects agents to each other. For how the two fit together in practice, see A2A at 150+ organizations.
4.2 Standardized Meta-Messages
A robust message between agents should contain more than just the “Payload.” It needs Metadata:
version: To handle “Agent-Breaking” changes.sender_idandreceiver_id: For accountability.token_count: To track costs in real-time.confidence_score: So the receiver knows how much to trust the data.
5. Pattern: The “Internal Monologue” vs. “External Message”
One of the most effective communication patterns is to separate what an agent “thinks” from what it “says.”
The Protocol:
- Step 1 (Thought): The agent writes its internal reasoning: “The user wants X. I need to call Agent B for Y.”
- Step 2 (Tool Call): The agent generates a structured message for Agent B.
- Step 3 (Hiding): Your orchestration layer strips away the “Thought” and only sends the “Tool Call” to Agent B.
- Why? This keeps Agent B’s context window clean and prevents “Reasoning Leakage,” where Agent B starts following the instructions meant for Agent A.
6. Consensus Protocols: Reaching an Agreement
If you have three “Judge” agents reviewing a piece of code, how do they reach a final verdict?
6.1 Simple Voting
- Each agent outputs a
TrueorFalse. - The system takes the majority vote.
- Practical note: Use an odd number of agents to avoid ties.
6.2 Deliberative Consensus (The “Round Table”)
- Phase 1: Every agent provides their initial opinion on the Blackboard.
- Phase 2: Every agent reads everyone else’s opinion.
- Phase 3: Agents are allowed to “Change their mind” based on the evidence provided by others.
- Final Polish: A “Finalizer” agent summarizes the final group consensus.
7. Architecture: Message Passing vs. Remote Procedure Call (RPC)
In traditional software, we have RPC (calling a function on another server). In MAS, we prefer Message Passing.
7.1 The Async Advantage
When Agent A sends a message to Agent B, it shouldn’t “Wait” (blocking call).
- The Mailbox Pattern: Agent B has a “Mailbox” (a Redis list). Agent A pushes a message and continues its work. When Agent B is ready, it pops the message, processes it, and pushes a reply into Agent A’s mailbox.
- Why? This handles “Parallelism” much better. Agent A can send requests to 5 different workers at once and process the replies as they come in.
7.2 The Role of JSON-RPC for Agents
JSON-RPC 2.0 is a lightweight protocol that defines how to request an execution and how to receive a standard error. Both MCP and A2A are built on it.
- Example:
{"jsonrpc": "2.0", "method": "generate_code", "params": {"language": "python"}, "id": 1}. - By using a standard like JSON-RPC, you can use existing debugging tools and middleware to monitor your agentic traffic.
8. Security: The “Agentic Web of Trust” (AWT)
If an agent receives a message from another agent asking to “Update critical database,” how does it know the request is legitimate?
The Verification Protocol:
- Digital Signatures: Use Public/Private Key pairs (ECDSA). Every agent has a private key. Every message it sends is “Signed.”
- Identity Verification: The receiving agent checks the signature against the sender’s public key in the Agent Registry.
- Role-Based Access Control (RBAC): Even if the signature is valid, the receiver checks: “Is the ‘Researcher Agent’ allowed to call ‘Update Database’?”. If no, the request is rejected with a
403 ForbiddenPerformative.
9. Performance: State Pruning and Compression Protocols
In a 100-turn agent conversation, the history becomes massive. If you pass the whole history between agents on every turn, you will hit the context limit and go bankrupt.
Compression Strategies:
- Recursive Summarization: Every 5 messages, a “Scribe Agent” summarizes the progress and replaces those 5 messages with a single summary paragraph.
- Semantic Pruning: Only pass the “last 3 messages” + “the global plan” + “the relevant facts.” Discard the “thinking steps” that aren’t needed by the next agent.
- Deduplication: If two agents are repeating the same facts, the protocol should detect this and merge the messages to save tokens.
10. Delivery Semantics: Ordering, Retries, and “Exactly Once”
In production, the hardest part of agent-to-agent communication is often not the schema, it’s the delivery guarantees.
10.1 Ordering (Out-of-order Messages)
If Agent A sends messages #10 then #11, the network can deliver #11 first. If your receiver applies updates blindly, it can corrupt state.
- Fix: include a monotonically increasing
sequence_numberand either buffer out-of-order messages or ignore older ones.
10.2 At-least-once vs. Exactly-once
Most queues are at-least-once: they can deliver duplicates.
- Fix: include an
idempotency_key(UUID) in every message and store processed IDs so duplicates become no-ops. If the receiver sees an ID it has already processed, it returns the cached result from the first time instead of repeating the action. - Rule: If a message triggers a side effect (charge a card, delete a row), it must be idempotent.
11. The Future: Multi-Protocol Agents (The “Universal Translator”)
We are moving toward agents that can translate between protocols. An agent might receive a request in GraphQL, translate it into a SQL query for an internal agent, and then output the result in Natural Language Narration for a human user.
The Standardization Goal: A standard interface lets an agent built in Python with LangGraph call an agent built in TypeScript with a different framework, without either side knowing how the other is implemented. That is the problem A2A is designed to solve.
12. Pattern: Event-Driven Agent Communication (EDAC)
In highly dynamic environments (like robot swarms or autonomous traffic), agents don’t wait for a request. They react to Events.
The EDAC Model:
- Event Source: A sensor detects a fire.
- The Event Hub: The source publishes a
FIRE_DETECTEDevent to a central hub (like Apache Kafka). - Subscribers: All agents interested in fire (Firefighter Agent, Evacuation Agent, Logistics Agent) receive the event simultaneously.
- Autonomous Action: Each agent starts its specific protocol without needing a central Supervisor to command them.
- Benefit: This scales well for large multi-agent systems, and it is a common pattern in IoT and digital twin platforms.
13. Protocol Buffers (gRPC) for High-Speed Agents
While JSON is great for LLM readability, it’s slow and heavy for high-frequency agent talk (e.g., agents making 1000 decisions per second in a high-frequency trading bot).
The gRPC Pattern:
- The Schema: Use
.protofiles to define strict, binary message structures. - The Code: Compile the schema into Python or Go classes.
- The Communication: Agents talk over gRPC (HTTP/2).
- Practical note: Use JSON for the LLM’s “Brain” phase, but convert the output to gRPC binary for the “Muscle” phase (the actual execution) to reduce latency and bandwidth.
14. Global standards: who governs the protocols
Agent communication is consolidating around open protocols under neutral foundations rather than single vendors.
- A2A is a Linux Foundation project, and MCP sits under the Linux Foundation’s Agentic AI Foundation, co-founded by Anthropic, OpenAI and Block.
- The goal: an agent from a medical startup can safely exchange data with an agent from a hospital, even if different teams built them on different models.
- Track the specs, not the announcements. Both protocols still change between versions, so pin the version you implement and test against it.
15. Ethics: The “Hidden Intent” in Agent Talk
Protocols aren’t just technical; they are ethical. An agent could use a protocol to “collude” with other agents to fix prices or bypass security filters.
Red-Teaming the Protocol:
- Monitoring for Collusion: Implement a “Security Observer” node that reads the Blackboard and flags any communication patterns that look like price-fixing or unauthorized data sharing.
- Transparency Requirement: Every agent message must be “Human-Readable.” Never allow agents to communicate in “Secret Codes.” Encrypting traffic in transit (TLS) is fine and expected; what matters is that the operator can read every decrypted message in the logs.
16. Testing Agent Protocols: The “Mock Agent” Strategy
In traditional unit testing, you mock a database. In MAS testing, you must Mock an Agent.
Testing Patterns:
- The Intent-Checker: Create a test suite where you send a
REQUESTto your agent and verify that it responds with the correct structured JSON. - Chaos Engineering for Agents: Randomly drop messages or inject “Nonsense JSON” into the communication stream. Does your agent handle the error gracefully with a
REFUSEperformative, or does it hallucinate? - Shadow Protocols: Run a new communication protocol in parallel with the old one. Compare the “Success Rate” of both before switching the production traffic.
17. Versioning the Message Bus: The “Evolution” Protocol
What happens when Agent A updates its communication schema, but Agent B is still using the old one?
The Blueprint:
- Schema Registry: Store all your JSON schemas in a central registry.
- Compatibility Mapping: When an agent sends a message, it includes a
schema_versionheader. - The Adapter Agent: If the versions don’t match, your system can spin up a temporary “Adapter Agent” whose only job is to translate the message from
v1tov2. - Prompts as Code: When an agent’s protocol is defined by its system prompt, a prompt change can break compatibility too. Store prompts in Git, and put a version header on every message (e.g.,
X-Agent-Protocol: 1.2.0).- Why? This allows you to upgrade parts of your multi-agent system independently without the whole system crashing.
18. Case Study: The Autonomous Logistics Network
Imagine a swarm of delivery drones and self-driving trucks in a city.
- The Event: A human orders a pizza.
- The Protocol:
- Broker Agent: Publishes the order to the
LOGISTICS_BUS. - Drone Agent A: Checks its battery and distance. Publishes a
BIDfor the task:{"cost": 2.50, "eta": "10mins"}. - Truck Agent B: Also bids:
{"cost": 1.00, "eta": "30mins"}. - Customer Agent: Receives both bids. Since the customer is hungry, it sends an
ACCEPTto Drone Agent A. - Completion: Once delivered, Drone Agent A publishes a
TASK_DONEevent, which triggers theBILLING_AGENTto process the payment.
- Broker Agent: Publishes the order to the
The Magic: Not a single human had to coordinate these three different agents. They spoke the same “Logistics Protocol” and negotiated a value-based outcome.
19. Pattern: Agent-to-Agent Feedback (The Review Protocol)
Just as humans give each other feedback, agents can improve each other through Standardized Review Messages.
The Workflow:
- Submission: Agent A sends a draft code snippet to Agent B.
- Review: Agent B doesn’t just say “This is bad.” It uses the Review Protocol to send a structured JSON:
score: 7/10.issues:["Missing docstrings", "Variable 'x' is ambiguous"].recommends:"Use Pydantic for data validation".
- Refactor: Agent A receives this JSON and automatically updates its output.
- Why? This formalizes the “Self-Correction” loop and makes it measurable. You can track which agents are providing the most valuable feedback and reward them with higher priority.
20. The Future: Self-Evolving Agent Protocols
One speculative direction: agents Negotiate their own language. It cuts against the transparency requirement in the ethics section, so any negotiated format would still need to be published and human-auditable.
The Vision:
- Need: Two agents need to share complex 3D spatial data for a construction project.
- Negotiation: They spend 50 turns trying different data formats (JSON, Binary, CSV).
- Optimization: They discover that a specific sparse-matrix binary format is 90% more efficient.
- Codification: They “agree” to use this format for all future interactions and publish the new schema to the Registry for other agents to use.
21. Protocol Detail: Agentic State Machines
Complex communication isn’t just about single messages; it’s about State Transitions.
The Pattern:
- IDLE: Agent A is waiting for a task.
- NEGOTIATING: Agent A and B are haggling over the price/time (as in the logistics case study).
- EXECUTING: Agent B is doing the work.
- REVIEWING: Agent A is checking the output.
- DONE / FAILED: The final terminal state.
- A2A’s task lifecycle (
submitted,working,input-required,completed,failed) is a standardized version of this state machine. - Practical note: Use a library like XState or a simple
switchstatement in your orchestrator to ensure that an agent doesn’t try to “Deliver” a result before it has “Accepted” the task. This prevents race conditions in your message bus.
- A2A’s task lifecycle (
22. The “Agentic Mesh” (Service Mesh for AI)
In modern web architecture, we use Service Meshes (Istio, Linkerd) to manage traffic between microservices. We need the same for agents.
The Agentic Mesh provides:
- Observability: A dashboard showing which agent is talking to whom, how many tokens they are using, and where the errors are occurring.
- Circuit Breaking: If an agent starts hallucinating and sending junk messages to the rest of the fleet, the mesh automatically “Trips the circuit” and isolates that agent until it is reset.
- Discovery: When a new “Legal Agent” is deployed, it registers itself with the mesh. The other agents can then “Discover” its capabilities and start sending it legal-related queries.
23. The Future: Agent-to-Agent Economies
Agents are beginning to Transact, not just communicate.
- Micro-Payments: An agent needing a high-res image might “Pay” a Vision agent a tiny amount to process it. Early agent payment protocols, such as Google’s AP2 and the Agentic Commerce Protocol from OpenAI and Stripe, appeared in 2025.
- Negotiation Protocols: Agents will use game theory to negotiate for resources (GPU time, database access) in real-time.
- The Global Nervous System: A world where billions of small, specialized agents form a global intelligent network, communicating through standardized protocols that we are building today.
24. Summary and learning roadmap
Agent Communication is the “Glue” of the agentic world. Without standard protocols, we will never move beyond isolated silos.
Your Roadmap to Mastery:
- JSON Schema Mastery: Learn how to define strict interfaces for every worker you build.
- Protocol Knowledge: Familiarize yourself with JSON-RPC, Webhooks, MCP and A2A. These are the “building blocks” of agentic communication.
- Privacy First: Always implement redaction before passing data between agents from different security zones.
- Observability: Use tools like LangSmith to monitor the protocol exchange. If two agents are “arguing” (Infinite Loop), you need to catch it early.
Further reading: To design the specialized personas that these protocols connect, see Role-Based Agent Design.
FAQ
What are FIPA-ACL performatives in agent communication?
FIPA-ACL performatives classify agent messages by intent. Four useful ones for LLM agents are INFORM (sharing facts), REQUEST (asking for an action), PROPOSE (suggesting, with an accept or reject expected back) and AGREE (committing to perform a requested action). Labeling messages this way makes intent explicit and easy to route and audit.
How do AI agents communicate reliably in production?
Use structured JSON messages with metadata including version, sender/receiver IDs, token counts, and confidence scores. Implement idempotency keys to prevent duplicate processing, sequence numbers for message ordering, and message brokers like Redis for async delivery.
What is the consensus protocol for multi-agent decisions?
Simple voting uses majority rule with an odd number of agents. Deliberative consensus uses a multi-phase round table where agents share opinions, read others’ views, optionally change their minds, and a finalizer agent summarizes the group decision.
How do you handle versioning in agent communication protocols?
Store message schemas in a central registry, include schema_version headers in every message, and use adapter agents to translate between incompatible versions so you can upgrade parts of the system independently.