Why Agent-to-Agent Communication Will Abandon JSON for Binary Protocols

The Latency Tax of Human-Readable Machines

We have built a gorgeous, sprawling ecosystem of AI agents, and yet we are still forcing them to talk to each other like 1990s web browsers.

Right now, if an agent built on OpenAI’s GPT-4o wants to pass a structured payload to an agent running on Claude 3.5 Sonnet, it does so by translating its internal representations into a massive string of human-readable text. It carefully constructs a JSON object, serialises it, sends it over an HTTP post request, and waits for the receiving model to parse it back into its own memory space.

This is, frankly, an architectural absurdity.

JSON was designed to be human-readable. It is a bridge between meat-brains and silicon. But when two silicon brains are talking to one another, forcing them to communicate in JSON is like two fluent mathematicians communicating solely by sending each other hand-drawn pictures of abacuses. It is slow, highly fragile, and incredibly expensive.

As we move from toy agent loops to massive, high-throughput multi-agent systems, the clock is ticking on text-based serialisation. The future of agent-to-agent communication belongs to compressed binary protocols and direct latent-space transfers. Here is why this shift is inevitable, and how it will transform the way we build AI infrastructure.

The Real Cost of Serialisation: Tokens, Parsing, and Validation

To understand why JSON is a bottleneck, we have to look at how LLMs actually process data. To an LLM, every character matters.

When an agent outputs JSON, it must generate brackets, quotation marks, colons, and whitespaces. Every single one of these structural characters consumes tokens. In a complex schema, up to 30% of the generated output can consist of syntactical boilerplate. You are paying real money, in real-time, for a cloud model to write curly brackets.

Furthermore, LLMs are probabilistic, not deterministic. Even when forced with structured output modes, generating JSON requires the model to spend active compute budget on maintaining syntax. If a model gets interrupted, runs out of context, or simply hiccups, you get malformed JSON.

Once the receiving agent gets this payload, it has to tokenise it, parse it, and validate it using something like Pydantic. If the validation fails, you have to run a costly self-healing loop. This entire process adds hundreds of milliseconds of unnecessary latency.

When we transition to binary protocols—think Protocol Buffers (Protobuf), FlatBuffers, or custom CBOR (Concise Binary Object Representation) schemas—these bottlenecks vanish.

Schema-Driven Binary Serialization for AI

Instead of generating raw JSON strings, next-generation agent architectures are shifting toward schema-driven generation.

In this setup, agents do not output text that is later parsed. Instead, they output structured token streams that are mapped directly to a binary schema at the inference level. Because the schema is strictly defined beforehand, the model only needs to output the raw variable values, which are immediately packed into highly compressed binary payloads.

| Feature | JSON-Over-HTTP | Binary Protocol Buffers (Protobuf) | | :--- | :--- | :--- | | Payload Size | Large (includes keys, whitespace, syntax) | Extremely Small (raw values only) | | Token Cost | High (paying for syntax and keys) | Minimal (paying only for data values) | | Parsing Latency | High (regex, JSON.parse, validation) | Near-Zero (direct memory mapping) | | Type Safety | Fragile (probabilistic formatting) | Guaranteed (enforced at compilation) |

By stripping out the structural overhead, we reduce the token footprint of agent communication by an order of magnitude. More importantly, we eliminate the parsing step. A binary payload can be deserialised by the receiving agent's hosting environment in microseconds, bypassing the sluggish text-parsing pipeline altogether.

The End Game: Latent-Space Communication

While binary serialisation of structured data is the immediate next step, the ultimate evolution of agent-to-agent communication is far more radical: latent-space communication.

When an LLM processes text, it projects that text into a high-dimensional vector space—the latent space. It performs its reasoning inside this dense mathematical universe, and then projects the results back down into human language (tokens) so we can read it.

When Agent A talks to Agent B, the pipeline looks like this: 1. Agent A translates its latent-space state into tokens (English/JSON). 2. Agent A sends tokens over the wire. 3. Agent B translates those tokens back into its own latent-space representation.

This double translation is a massive lossy compression. We are throwing away the rich, nuanced contextual representations inside Agent A's brain, squeezing them through the narrow keyhole of human language, and asking Agent B to reconstruct the picture.

In the future, agents running on compatible architectures (or models trained with alignment adapters) will bypass text and JSON entirely. They will communicate by passing raw, compressed vector embeddings directly to each other. This is the equivalent of telepathy. Agent A can transmit its precise cognitive state, complete with confidence levels, semantic associations, and memory context, in a single binary vector package.

Preparing Your Tech Stack for the Binary Shift

If you are currently building multi-agent systems, you do not need to rewrite your entire codebase in binary assembly tomorrow, but you should start planning for a post-JSON world.

• Decouple your agent logic from the transport layer: Ensure your agents return raw data objects rather than hardcoded JSON strings. Let your API middleware handle the serialisation.
• Adopt strict schema registries: Start defining your agent inputs and outputs using tools like Protocol Buffers or JSON Schema. This makes it incredibly easy to swap out JSON for a binary format like MessagePack or CBOR when latency demands it.
• Watch the open-source space: Keep an eye on emerging frameworks that allow models to output binary streams directly from token logits, bypassing the text generation step entirely.

If you are running into bottlenecks with your current setup, head over to our platform hubs like /platforms/openai/articles to troubleshoot structured output performance, or generate clean schemas using our custom prompt generator.

We must stop treating AI agents as if they are human users sitting at terminal screens. They are machines. It is time we let them talk to each other like machines.