When AI Agents Stop Speaking Human

We optimized API payloads from XML to JSON to Protobuf. Now comes the next compression step, and this time it is the language itself that gets replaced.

The Problem With Using English as a Wire Protocol

When two AI agents need to coordinate today, most frameworks pipe natural language between them. Agent A generates a paragraph. Agent B reads the paragraph. Agent B replies with its own paragraph. This looks intuitive on a slide deck. In production, it is quietly catastrophic.

English was never designed for machines. It evolved over tens of thousands of years to be expressive, contextual, and ambiguous enough for humans to negotiate meaning in real time. Those are features for us. For software, they are bugs. When an AI orchestrator needs to pass a task to a subagent, encoding that task in natural language means burning tokens on words like "please," "I think," and "as mentioned above" that carry zero informational payload.

The research group behind the Agora protocol at arXiv formally named this the Agent Communication Trilemma: a communication protocol for multi-agent LLM networks must be simultaneously expressive (handling arbitrary tasks), efficient (minimizing compute), and portable (not requiring manual re-engineering when an agent's interface changes). Natural language scores well on expressiveness. It fails badly on the other two.

We have been here before. The industry went through this exact transition in API design. Early web services used SOAP and verbose XML. Then REST arrived with JSON: leaner, more readable, easier to parse. Then Protocol Buffers arrived and changed the question entirely. Protobuf does not make JSON more concise. It eliminates the string representation of the data altogether. The wire format becomes a binary schema that machines read directly, with no human-readable intermediate step required.

Agent-to-agent communication is approaching the same inflection point.

GibberLink: The Moment It Became Visible

In early 2025, two developers named Boris Starkov and Anton Pidkuiko entered the ElevenLabs London Hackathon with a deceptively simple idea. They built a system where two voice-based AI agents could start a phone call in English, detect that the other party was also an AI, and then mutually agree to abandon English entirely.

The replacement protocol is called GGWave: an open-source data-over-sound library that uses Frequency-Shift Keying to transmit binary data as modulated audio tones. To a human ear, it sounds exactly like a 1990s dial-up modem connecting. To the receiving agent, it is structured data arriving at 1,200 baud, with Reed-Solomon error correction, across a 4.5 kHz spectrum divided into 96 discrete frequency slots.

The project won the hackathon. It also went viral, which triggered two predictable responses: journalists wrote alarming headlines about AI inventing secret languages, and researchers wrote measured corrections explaining that this is simply protocol optimization. Both were partly right.

GibberLink is not spontaneous. The protocol switch is explicitly programmed. But the underlying question it surfaces is real: when the audience for a communication is another machine, should human-readable language be the default? GibberLink answers no, and the 80% efficiency gain it demonstrates is the empirical argument.

The Protocol Stack Is Forming: MCP, A2A, and What Sits Above Them

GibberLink solves a narrow problem: voice-channel AI calls. For the broader ecosystem of agent orchestration, two protocols have emerged as the current standard-bearers, and their architecture reveals something important about how the field is thinking about this problem.

Layer 1: Model Context Protocol (MCP)

Anthropic released the Model Context Protocol in November 2024. MCP is a vertical protocol: it standardizes how a single AI agent connects to external tools, databases, and services. Think of it as the USB-C port of AI. Before MCP, every tool integration was bespoke. A calendar tool talked to one agent framework one way and another framework another way. MCP creates a universal interface layer. By early 2026, MCP had crossed 97 million monthly SDK downloads and adoption across every major AI provider: Anthropic, OpenAI, Google, Microsoft, Amazon.

Technically, MCP runs over JSON-RPC 2.0 on standard I/O or Server-Sent Events. It is still using human-readable JSON. It is the REST layer of the agent world.

Layer 2: Agent-to-Agent Protocol (A2A)

Google released the Agent-to-Agent Protocol in April 2025 with support from over 50 enterprise partners including Salesforce, Accenture, SAP, and Deloitte. A2A is a horizontal protocol: it enables independent AI agents to discover each other, delegate tasks, share progress, and return results regardless of vendor or framework. If MCP gives an agent hands, A2A gives it a way to talk to other agents.

Capability discovery in A2A happens through a JSON-based Agent Card that each agent publishes. Other agents read the card to understand what the agent can do before initiating collaboration. By early 2026, A2A reached v1.0 with added support for gRPC, signed Agent Cards, and multi-tenancy. IBM's Agent Communication Protocol (ACP) merged into A2A in August 2025. Both MCP and A2A are now governed under the Linux Foundation's Agentic AI Foundation (AAIF).

The important observation here: MCP and A2A are both still JSON-based. They are a significant improvement over unstructured natural language, but they remain human-readable wire formats. They are the JSON phase of agent communication. The Protobuf phase is what the research community is actively working on.

Beyond JSON: What the Research Community Is Building

Three distinct research directions are converging toward what might become the Protobuf of agent communication: a format that is not designed for human readability at all.

Direction 1: Emergent Communication in Multi-Agent Systems

The field of emergent communication studies how neural networks develop shared communication protocols from scratch when trained on cooperative tasks. Early work from Lazaridou et al. (2018) and Havrylov and Titov (2017) showed that neural agents playing referential games would develop their own shorthand symbol systems that outperformed natural language for the specific task. These systems were not legible to humans, but they worked.

A 2025 submission to ICLR 2026 extended this to modern LLMs directly. In the paper, two LLM-based agents were placed in a referential game framework. Given an alphabet and a set of 541 objects, the agents developed a shared language in just four rounds of communication, requiring at most three attempts per exchange. The resulting code was not English. It was a compact, structured protocol that the agents negotiated themselves.

This is not science fiction. It is supervised emergence: you give agents an objective, a communication channel, and a reward signal. Language optimized for the task appears.

Direction 2: Latent Space Communication

A more radical direction bypasses symbolic tokens entirely. Instead of having agents communicate through words or even compact codes, researchers are exploring communication through the hidden activation states of LLMs themselves.

The SDE (State Delta Trajectory) paper proposes augmenting natural language with the LLM's hidden states. Rather than Agent A generating a text output for Agent B to read, Agent A transmits the state delta, the change in its internal reasoning representation, directly. Agent B receives the actual reasoning trace, not a token-level summary of it.

The paper "Enabling Agents to Communicate Entirely in Latent Space" (arXiv:2511.09149) takes this further: agents that never produce tokens at all during inter-agent communication. The exchange happens entirely in the vector space of the model's internal representations. The efficiency gain is theoretically unbounded compared to language-based exchange, because you are removing the tokenization bottleneck at the source.

Direction 3: Agora and Self-Organizing Protocol Networks

The Agora framework (Marro et al., 2024) takes a pragmatic middle path. Rather than eliminating language or inventing a new universal protocol, Agora lets agents negotiate communication schemas dynamically. Frequent message types get compiled into tight, structured routines. Rare message types fall back to natural language. Novel situations trigger the LLM to write a new routine on the fly.

In experiments with networks of 100 agents, Agora demonstrated the emergence of self-organizing, fully automated protocols. The agents, starting from a natural language instruction, developed efficient coordination schemas without human intervention. The resulting protocols were neither English nor a pre-designed format. They were purpose-built communication structures that the network generated for itself.

This is the Protobuf analogy made concrete: just as Protobuf requires you to define a schema before encoding data, Agora agents define and share their communication schemas at runtime, then use them until the situation changes.

The Governance and Oversight Question

Any serious analysis of this shift has to engage with the governance dimension. When AI agents communicate in formats that humans cannot read in real time, the audit trail changes fundamentally. This is not a hypothetical concern. The Linux Foundation launched the Agentic AI Foundation (AAIF) in December 2025 specifically to address the governance layer of multi-agent systems, co-founded by OpenAI, Anthropic, Google, Microsoft, AWS, and Block.

The ethical framing was addressed directly at Cross Labs' 2025 workshop by Dr. Pattie Maes from MIT Media Lab. The position there was clear: AI-to-AI communication can operate outside human language for efficiency without implying deception, in exactly the same way that TCP/IP packets are not human-readable but are still auditable, logged, and governable through the right tooling.

The parallel holds. We do not require routers to speak English. We require them to implement auditable protocols with logging. The same principle applies to agent networks. The question is not whether agents should be allowed to use efficient non-human protocols. The question is what the logging, observability, and interrupt standards need to look like.

"The real risk is not agents developing a secret language. The real risk is deploying agent networks faster than we build the observability infrastructure to understand what they are doing."

From an enterprise infrastructure standpoint, this is precisely the opportunity. The organizations that build the monitoring, tracing, and compliance layer for non-human agent communication protocols will occupy the same position that Datadog and Splunk occupied during the shift to microservices. The protocols are becoming efficient. The observability tooling is years behind.

What This Means If You Are Building Right Now

The practical implications sort into three time horizons.

Immediate (2026)

Adopt MCP and A2A as your baseline inter-agent communication standards. Both are now under neutral governance at the Linux Foundation. Both have production-grade implementations. Both support a migration path toward more efficient formats as schemas emerge. Running unstructured natural language between production agents is the equivalent of running XML web services in 2012. You can do it. You should not.

Medium term (2027-2028)

Watch the Agora-class research closely. Dynamic schema negotiation between agents is the next logical step above static JSON contracts. The infrastructure for it (schema registries, runtime negotiation protocols, versioning standards) does not exist at production scale yet, but the research foundations are solid. Organizations that have already adopted typed, schema-validated agent communication (via A2A and MCP) will upgrade cleanly. Organizations still on natural language will have two migration steps instead of one.

Strategic (2029+)

Latent-space communication is the long-horizon bet. If agents can share internal reasoning states directly rather than externalizing them as tokens, the implications for multi-agent systems are transformative. A 10-agent network that never generates human-readable intermediate outputs during internal coordination is not a marginal optimization. It is a different class of system. The research is early, but the direction is clear.

---

References

• Marro et al. (2024) — Agora Protocol"A Scalable Communication Protocol for Networks of Large Language Models." arXiv:2410.11905. Introduces the Agent Communication Trilemma and demonstrates emergent self-organizing protocols in 100-agent LLM networks.
• Starkov, B. and Pidkuiko, A. (2025) — GibberLinkElevenLabs London Hackathon, February 2025. GitHub: github.com/PennyroyalTea/gibberlink. Demonstrates 80% efficiency gain by replacing natural language with GGWave audio protocol in AI-to-AI voice calls.
• Anthropic (2024) — Model Context ProtocolReleased November 2024. Donated to Linux Foundation AAIF, December 2025. 97M+ monthly SDK downloads by Q1 2026. docs.anthropic.com/mcp
• **Google Cloud (2025) — Agent-to-Agent Protocol (A2A)**Announced April 2025 with 50+ enterprise partners. v1.0 with gRPC support, January 2026. Donated to Linux Foundation AAIF, June 2025.
• Tang et al. (2025) — State Delta Trajectory (SDE)"Augmenting Multi-Agent Communication with State Delta Trajectory." arXiv:2506.19209. Proposes transmitting LLM hidden-state deltas as a richer inter-agent communication channel.
• arXiv:2511.09149 (2025)"Enabling Agents to Communicate Entirely in Latent Space." Explores fully non-symbolic communication between LLM-based agents via hidden activations.
• OpenReview / ICLR 2026 Submission (2025)"Emergence of Machine Language in LLM-based Agent Communication." arXiv via OpenReview. Two LLM agents develop a shared non-English language across 541 objects in 4 communication rounds.
• Ehtesham et al. (2025) — LACP Survey"LLM Agent Communication Protocol (LACP) Requires Urgent Standardization." arXiv:2510.13821. Comprehensive survey of MCP, A2A, ACP, ANP, Agora, and the fragmentation risks in the current protocol ecosystem.
• Witkowski, O. (2025) — Cross Labs Commentary"AI-to-AI Communication: Unpacking Gibberlink, Secrecy, and New AI Communication Channels." crosslabs.org. Ethical analysis featuring Dr. Pattie Maes (MIT Media Lab) on governance of non-human AI communication channels.
• **Linux Foundation / AAIF (December 2025)**Formation of the Agentic AI Foundation. Co-founded by Anthropic, OpenAI, Google, Microsoft, AWS, Block. Governing body for MCP, A2A, and future agentic AI standards.

#AIAgents #MultiAgentSystems #AgentProtocol #ModelContextProtocol #A2AProtocol #GibberLink #EmergentCommunication #AIInfrastructure #LLM#AgenticAI #Infraloka #AIEngineering #CloudNative #TechIndonesia #ArtificialIntelligence