Neuralese: when artificial intelligences no longer need to speak the way we do

When two humans need to collaborate, they generally use a shared language. When two computer systems need to exchange information, they use protocols defined in advance: APIs, data formats, schemas, messages, events, or commands whose syntax and meaning have been determined by humans.

Artificial intelligence systems are gradually introducing a third possibility. Agents trained to collaborate can learn representations or communication protocols on their own that allow them to accomplish a common task, without every element of that communication necessarily corresponding to a word, a sentence, or even a structure directly comprehensible to a human.

This family of phenomena has been studied for several years under the terms emergent communication and emergent language. The term Neuralese is also used to designate certain forms of numerical representations learned by neural networks. In its broader contemporary usage, it is sometimes applied to latent reasoning, when intermediate information remains in the model’s continuous representation space instead of being systematically converted into tokens and natural language.

One appealing but misleading interpretation must be ruled out immediately: we have not discovered a universal secret language spoken by artificial intelligences. There is not necessarily a Neuralese vocabulary, a common grammar, or a dictionary that would allow a vector representation to be translated directly into French or English. Learned representations depend on the model, its training, the task, and the system that has to interpret them.

The phenomenon is nonetheless technologically important. If artificial systems can reason and communicate effectively in representations that no longer need to pass systematically through human language, we potentially gain in efficiency, informational richness, and coordination capability. We also create a particularly interesting problem for architects, AI engineers, and security specialists: how do you observe, audit, and govern systems whose reasoning and communications are, in part, no longer naturally readable by humans?

To understand Neuralese, we have to go back to the way a neural network processes information. A large language model receives tokens, but internally it does not manipulate words the way we see them on screen. Tokens are transformed into multidimensional numerical representations. Across the network’s successive layers, these representations evolve according to attention mechanisms, learned parameters, and context.

Text is therefore the visible interface of a system whose computations are essentially carried out in high-dimensional vector spaces.

This distinction becomes particularly important when we examine reasoning. In a traditional Chain-of-Thought approach, a model produces an intermediate sequence in the form of tokens: a reasoning step is expressed in language, and that sequence then becomes the context that allows the computation to continue. This method has an obvious advantage for interaction with humans, since the steps can take a linguistic form.

It does, however, impose a passage through a discrete channel: the model’s vocabulary.

Work on latent reasoning or continuous chain-of-thought explores another possibility. Rather than decoding every intermediate state into words, some architectures make it possible to retain or reinject continuous hidden states directly into the subsequent steps of the computation. The model can thus carry out several transformations in its latent space before returning to natural language when it finally has to communicate its result.

The idea is technically fascinating because a vector representation can potentially carry an informational structure that does not map cleanly onto a succession of sentences. Converting each step into human language can amount to a form of compression: a rich, continuous representation has to be transformed into a limited string of symbols before being re-encoded for the next step.

This does not yet mean that latent reasoning is automatically superior. The research is recent and the results remain variable. Several methods aim precisely to determine under what circumstances maintaining continuous intermediate states improves reasoning, efficiency, or planning. The important distinction lies elsewhere: natural language is not necessarily the only possible medium for an AI system’s intermediate computational reasoning.

The phenomenon becomes even more interesting when several agents have to collaborate.

In Multi-Agent Reinforcement Learning environments, or MARL, several agents may receive different observations, pursue a common or partially common objective, and learn which actions maximize their reward. When a communication channel is provided to them, they can also learn what information to transmit to the other agents in order to improve their collective performance.

Nothing then requires the optimal protocol to resemble a human language.

An agent can learn that a certain multidimensional signal triggers useful behavior in another agent in a particular context. Through training, certain representations become associated with objects, states, intentions, actions, or relationships. More complex structures can appear when the task demands greater coordination.

This is precisely what research on emergent languages studies. Recent work has observed communication strategies capable of generalizing to new levels of abstraction, while other research is attempting to identify properties resembling composition, morphology, or element ordering in the communications learned by agents.

It then becomes useful to distinguish two forms of Neuralese. The first is intra-model: latent representations used in a system’s processing or reasoning. The second is inter-agent: learned representations serving directly to transfer information between several systems.

This second category opens up considerable architectural possibilities.

Imagine an infrastructure comprising hundreds or thousands of specialized agents. Some monitor infrastructure, others analyze cybersecurity events, optimize supply chains, control robots, interpret sensors, conduct research, or orchestrate computing resources. If every interaction has to be translated into grammatically correct sentences, several layers of representation become necessary solely to make the communications compatible with human language.

Yet two machines have no intrinsic reason to exchange the sentence “server number 47 is showing an abnormal increase in latency associated with a recent change in its traffic profile” if a compact numerical representation can directly convey the relevant state to another system capable of interpreting it.

Neuralese could therefore become a form of machine-to-machine semantic compression.

The potential is not solely about speed. Latent communications can avoid certain repetitive decoding and re-encoding operations, reduce the number of tokens exchanged, and potentially make it possible to transmit representations richer than those that can easily be expressed in sentence form. Researchers are in fact beginning to examine emergent communication between agents as a path toward improving the computational and energy efficiency of multi-agent systems.

At scale, this evolution could profoundly alter the architecture of agentic systems. Today, a large share of multi-agent environments still rely on interfaces comprehensible to developers: prompts, JSON, API calls, structured messages, events, and natural language. These mechanisms offer excellent observability, but they can become inefficient when a very large number of agents has to communicate continuously.

A future architecture could therefore use several communication layers. Humans would continue to interact in natural language. Critical interfaces would retain structured, auditable schemas. Certain internal communications between agents could use far more compact representations, optimized for machines.

This is where the problem becomes particularly interesting for security.

In traditional computer systems, observability is a fundamental property. We want to know which services are communicating, which APIs are being called, what data is circulating, which identities are carrying out the operations, and which decisions are producing certain events. Logs, distributed traces, SIEM, detection systems, and audit mechanisms rely largely on our ability to interpret the events we observe.

What happens when a significant portion of the communication between agents becomes semantically opaque to humans?

Recording a vector of several thousand dimensions does not mean we understand the message. Two agents can perfectly well exploit a representation whose every numerical value we are able to store without being able to explain precisely what it encodes.

We then arrive at an unusual situation: the transmission can be perfectly observable at the technical level while remaining partly opaque at the semantic level.

This distinction could become fundamental in agentic architectures.

The security challenge is therefore not necessarily to prohibit emergent communications. Their efficiency could prove too attractive for that position to be realistic. Instead, we will have to develop new forms of observability adapted to latent representations.

Several levels of control become conceivable. We can observe which agents are communicating, how often, and under what circumstances. We can measure the transformations of their representations, detect distribution shifts, compare behaviors against known baselines, use interpretability probes, impose separate channels depending on the sensitivity of the operations, and require translations or justifications when a communication contributes to a critical action.

The Zero Trust principle takes on a new dimension here. A communication should not become trustworthy simply because it comes from another agent belonging to the same system. The sender’s identity, its context, its permissions, the purpose of the communication, and the action requested can continue to be verified independently of the representation used to carry the information.

Continuous Trust becomes even more relevant when the content itself is difficult to interpret directly. Trust can be continuously reassessed on the basis of identity, behavior, provenance, history, context, and observable consequences.

A secure architecture could also separate the communication channel from the authority channel. Two agents could exchange extremely rich latent representations without that communication automatically granting them the right to execute a sensitive operation. Information can circulate freely within certain limits while actions remain subject to explicit controls.

This separation becomes essential if emergent protocols themselves evolve over time.

A human language has a certain stability because it is shared by a community and transmitted culturally. An emergent protocol between agents can be far more dynamic. A new version of the model, a retraining, a change to the reward function, or a shift in environment can all alter the way certain representations are used.

The problem is then no longer solely to understand a protocol. Its drift has to be detected.

We encounter a difficulty already familiar in Machine Learning Operations: data drift, concept drift, and model drift. Multi-agent environments could add another category: communication drift.

Two agents that were working together correctly may progressively alter their representations. An update to one of them can change the interpretation of certain signals. Subpopulations of agents can develop different conventions. A protocol optimized for one task can produce unexpected behaviors when used in another environment.

Interoperability therefore becomes a research problem as well.

Internet protocols have been extraordinarily successful precisely because their specifications are relatively independent of implementations. TCP/IP, DNS, HTTP, and TLS allow systems designed by different organizations to communicate because their interfaces are standardized.

Neuralese operates on an almost inverse logic: the representation can emerge from training and be deeply tied to the parameters of the systems that use it.

A vector produced by model A has no guarantee of carrying the same meaning for model B. Even two versions of the same model can develop latent spaces different enough to complicate a direct exchange.

Machine-to-machine communication architectures will therefore probably have to resolve a trade-off between emergent efficiency and standardized interoperability. Shared latent spaces, specialized encoders and decoders, standardized intermediate representations, or gateways capable of translating between several protocols could become necessary.

This evolution also raises an important question for explainability.

We often ask AI systems to explain their decisions. That explanation is generally produced after or around the internal computation. It is not necessarily a literal transcription of the representations that led to the answer.

The more reasoning and communications remain in latent space, the more important it becomes to distinguish explanation from observability.

An AI can generate an excellent justification in natural language without that justification being a faithful reconstruction of all the internal operations that produced the decision. For critical environments, we will therefore have to combine several approaches: traceability of inputs and outputs, data provenance, agent identity, permission control, instrumentation of internal states where possible, behavioral analysis, and independent validation of results.

We do not necessarily need to understand every number contained in every vector in order to govern a system. We must, however, have enough visibility to know what it is authorized to do, to detect when it is behaving differently from what is expected, and to prevent an opaque communication from automatically becoming an opaque authorization.

This is where Neuralese meets Hypersecurity head-on.

As infrastructures come to be composed of agents capable of reasoning, communicating, and acting at machine speed, security can no longer depend solely on manual inspection of content. It must incorporate machine identity, environment segmentation, dynamic privilege control, provenance, behavioral analysis, continuous monitoring, and the ability to quickly interrupt a chain of actions when its behavior falls outside the expected bounds.

The question is therefore not how to force machines to speak the way we do forever. It is how to design architectures in which they can benefit from forms of communication suited to their capabilities without humans losing the ability to understand the system at a level sufficient to govern it.

Neuralese does not denote a mysterious universal secret language that artificial intelligences have started speaking among themselves. The term covers instead a family of phenomena that are far more interesting technically: learned numerical representations that can serve internal reasoning, and communication protocols that can emerge when several agents learn to collaborate.

Research already shows that emergent communications can develop structures enabling coordination, abstraction, and certain forms of composition. It also shows how difficult their interpretation, generalization, and evaluation remain. A scientific review published in 2025 points out precisely that the field has yet to resolve significant questions of measurement, grounding, interpretability, and characterization of emergent linguistic properties.

For AI engineers and IT architects, the question becomes particularly important with the arrival of multi-agent systems. Thousands of specialized agents may not always have an interest in turning each of their internal representations into sentences intended for humans before communicating with one another. The potential gains in efficiency, informational density, and coordination could encourage the emergence of increasingly machine-native communications.

This evolution will give rise to a new category of engineering problems: how do you instrument a communication whose data we can record without necessarily understanding its semantics right away? How do you detect its drift? How do you maintain interoperability between models? How do you distinguish the transport of information from the authority to act? How do you apply Zero Trust and Continuous Trust to exchanges between agents? And how do you preserve a sufficient audit capability when certain reasoning steps never exist in the form of human language?

For Quantum Beyond, this frontier illustrates exactly why the architecture of artificial intelligence systems must evolve alongside their capabilities. AI Governance, AI Onboarding, IAM, segmentation, observability, and Hypersecurity will progressively have to apply to systems that communicate and reason at a level of representation designed more for machines than for us.

We have spent several decades teaching computers to understand our language. We are now entering a period in which we will also have to learn to build systems capable of operating securely when machines no longer need to translate each of their thoughts and communications into ours.