From machine-to-machine signals to latent thought: why AI may compute beyond human language—and why that matters
Answer in Brief
Neuralese is not a secret spoken language invented by conscious machines. It is a useful name for vector-based signals and internal representations that AI systems can use to communicate, remember information, or reason without turning every step into human-readable words.
The opportunity is clear: systems that work in these compact internal representations may become faster, cheaper, and better at planning. The risk is equally clear: the more important reasoning happens outside language, the harder it becomes to verify why an AI made a decision.
Abstract
Artificial intelligence speaks in English, Portuguese, code, images, and increasingly natural conversation. Yet the language visible on a screen is only the final layer of a much larger computational process. Inside modern AI systems, information is represented as numerical patterns, transformed through neural networks, and used to predict the next action or word.
This is where the idea of Neuralese becomes important. The term first appeared in research on neural agents that learned to coordinate through messages that humans could not directly understand. Today, it also helps describe a broader shift: AI systems may increasingly use latent, vector-based representations for memory, planning, communication, and reasoning.
This article explains what Neuralese is, what it is not, and why it matters. Using concrete examples—from autonomous cars coordinating at an intersection to experimental systems that reason in continuous latent space—it argues that the real concern is not a science-fiction “secret language.” It is the growing possibility that powerful AI systems may become more capable while becoming harder to inspect, explain, and govern.
Keywords: Neuralese; latent reasoning; artificial intelligence; AI interpretability; Chain-of-Thought; machine-to-machine communication; AI safety; large language models; black-box AI.
Table of Contents
- What Is Neuralese?
- AI Does Not Literally Think in English
- The First Neuralese Example: Two Cars at an Intersection
- From Communication to Latent Reasoning
- Why Researchers Want AI to Reason Beyond Language
- The Black-Box Problem: When Explanations Are Not Enough
- How Can We Audit Neuralese?
- What Neuralese Does Not Mean
- Frequently Asked Questions
- Conclusion
- References
1. What Is Neuralese?
Neuralese is a name for information exchanged or processed by AI systems in a form that is useful to machines but not naturally readable by people.
A human language such as English has words, grammar, shared conventions, history, ambiguity, emotion, and cultural context. Neuralese has none of these things by default. It may be nothing more than a sequence of numerical vectors: compact patterns of numbers that one neural network produces and another network can use.
The basic idea is simple.
Imagine two AI agents working together. One can see a target; the other can move toward it. They need to coordinate, but nobody has programmed a human language into them. During training, they may discover a pattern of signals that helps them succeed.
That pattern could effectively mean:
- “Move left.”
- “Wait.”
- “The target is behind you.”
- “I am about to cross.”
- “This route is unsafe.”
But the signal does not need to look like a word. It may be a dense numerical message that only makes sense because it changes the behavior of the receiving system.
That is Neuralese in its original and most precise sense: an emergent communication protocol between neural agents.
Today, the word is often used more broadly to describe internal AI representations that sit between human language and machine computation. This broader use is useful, provided we do not exaggerate what it means.
Neuralese is not proof of consciousness. It is not evidence that AI systems have private desires. It is not a universal machine language. It is a technical phenomenon: machines can represent and exchange information in ways that are efficient for them but difficult for us to interpret.
2. AI Does Not Literally Think in English
When a chatbot answers a question in fluent English, it is natural to imagine that it first formed an English sentence somewhere “inside its mind.”
That is not how the system works.
Most modern chatbots are built with a type of neural-network architecture called a Transformer. A Transformer does not manipulate words as humans do. It converts text into numerical representations, repeatedly transforms those representations through attention and other mathematical operations, and finally produces probabilities for the next piece of text.
The fluent sentence that we read is the visible output of this numerical process.
The first step is tokenization. Before a Transformer can process language, the input must be divided into small units called tokens. A token may be a complete word, part of a word, punctuation mark, number, symbol, emoji, or piece of code.
Why tokens and not words?
Because language is messy and computers need a practical way to turn text into numbers.
Using only whole words would create an enormous vocabulary and fail on unfamiliar words, names, typos, technical terms, and many languages. For example, a model might know “compute” and “computing,” but encounter “recomputationally” for the first time. Splitting text into smaller pieces lets it reuse known fragments instead of treating the entire word as unknown.
Tokens also make punctuation, numbers, code, URLs, emojis, and symbols manageable. A programming model, for instance, may need to distinguish function, (, ), {, =, and ; because each carries structural meaning.
So tokenization is a compromise between two extremes:
- Whole words: easy to interpret, but too many possible words.
- Individual characters: very flexible, but sequences become long and inefficient.
- Subword tokens: a middle ground—compact enough for efficient computation, flexible enough to handle new or rare text.
For example, a tokenizer might split:
unbelievable → un + believe + able
or:
ChatGPT is useful! → Chat + G + PT + is + useful + !
The exact split depends on the tokenizer. The model does not see the original sentence directly; it sees a sequence of token IDs, which are then converted into vectors.
A simplified pipeline looks like this:
Text → Tokens → Numerical Representations → Context Processing → Probabilities → Next Token
Each token ID is converted into a numerical representation called an embedding: a vector containing many learned values. The Transformer then repeatedly updates these vectors using the surrounding context.
This is where the name Transformer becomes meaningful. The architecture repeatedly transforms the representation of every token. A word such as bank begins with a general learned representation, but its numerical pattern changes as the model processes the rest of the sentence.
In “The bank approved the loan,” the surrounding words approved and loan make the financial meaning of bank more relevant. In “The boat reached the river bank,” different context produces a different internal representation.
A central mechanism in the Transformer is attention. Attention allows each token to estimate which other tokens are most useful for interpreting its current role. In a long sentence, the model may need to connect a pronoun near the end with a person mentioned much earlier. In code, it may need to connect a function call with a definition several lines above.
After many layers of these transformations, the model assigns a probability to every possible next token. It then selects or samples one token, adds it to the existing text, and repeats the process.
What we experience as language is therefore a human-readable surface produced by a deeper mathematical system.
This does not mean that an AI system is secretly thinking like a human in another language. It means that its internal computation does not need to take the form of human sentences.
Fluent output emerges from embedding lookups, matrix multiplications, attention scores, softmax probability calculations, weighted sums, residual connections, normalization, nonlinear transformations, gradient-based training, and token-by-token decoding in a high-dimensional latent space.
What Actually Happens Inside a Transformer?
The Transformer architecture was introduced by Vaswani et al. in the 2017 paper Attention Is All You Need. Its key innovation was to replace recurrent processing with attention mechanisms.
Earlier sequence models, especially Recurrent Neural Networks (RNNs), processed information one step at a time. Each word, observation, or time point updated a hidden state, which was then passed to the next step. Long Short-Term Memory networks (LSTMs) and Gated Recurrent Units (GRUs) improved this approach with gates that controlled which information should be retained or discarded.
However, these systems remained fundamentally sequential. To process time step t, an RNN or LSTM first needed the state produced at time step t − 1. This made it harder to process long sequences efficiently and to connect distant information.
A Transformer works differently. Through self-attention, each token can directly compare its representation with other relevant positions in the available context. Instead of relying only on information compressed into a single recurrent hidden state, it can connect distant words in a document, events separated in a time series, or a function call with its definition many lines earlier in a program.
First, the Transformer divides text into tokens: small units that may be complete words, word fragments, punctuation marks, numbers, or code symbols.
Each token is converted into a learned numerical vector called an embedding. The model also receives information about token position, because word order matters. “Dog bites man” and “Man bites dog” contain the same words but express different meanings.
The Transformer then passes these vectors through many layers. In each layer, self-attention helps every token identify which other tokens are most useful for interpreting its role in context.
In the sentence “The bank approved the loan,” for example, the token bank may give greater attention to approved and loan, because they indicate that bank refers to a financial institution rather than the side of a river.
To do this, the model creates three numerical versions of each token:
- A query, representing the information the token is seeking.
- A key, representing the information that token can offer.
- A value, containing the information that may be retrieved.
The model compares queries with keys, assigns greater attention to more relevant tokens, and combines their values. This makes each token’s representation increasingly sensitive to context.
After attention, a feed-forward neural network further transforms each token. Residual connections preserve useful information from earlier layers, while Layer Normalization keeps numerical values stable as they move through the network.
Modern chatbots usually use causal Transformers. They can use earlier tokens in the prompt and conversation, but cannot inspect future tokens. This prevents the model from seeing the answer before generating it.
After the final layer, the model assigns a numerical score, called a logit, to every possible next token. A softmax function converts those scores into probabilities. The model then selects one token, adds it to the text, and repeats the process.
This is why generative AI produces text one token at a time.
How the Model Learns
Before it can generate useful text, a Transformer must be trained on large collections of examples. During training, it receives sequences of tokens and learns to predict the next token at many positions simultaneously.
For example, given:
“The bank approved the”
the model should assign a high probability to loan when that is the next token in the training text.
To evaluate this prediction, the model compares its probability distribution across all possible next tokens with the token that actually appears in the training example. The difference is measured using cross-entropy loss.
Cross-entropy loss is low when the model assigns high probability to the correct next token. It becomes high when the correct token receives a low probability, especially when the model is highly confident in an incorrect prediction.
For instance, if the correct next token is loan, the model is rewarded for assigning it a high probability. If it assigns high probability to an unrelated token instead, the loss increases.
Backpropagation then calculates how much each learned parameter contributed to that error. It traces the error backward through the network and determines how the embedding vectors, attention projections, feed-forward weights, normalization parameters, and output layer should be adjusted.
An optimization algorithm uses these calculated gradients to make very small changes to the model’s parameters. This process is repeated across enormous numbers of examples until the model gradually becomes better at predicting the patterns that appear in language, code, images, and other types of data.
The sentence visible on the screen is therefore not the model’s internal computation itself. It is the readable result of embeddings, attention, matrix operations, nonlinear transformations, probability calculations, cross-entropy loss, backpropagation, and training-driven parameter updates occurring in a high-dimensional numerical space.
3. The First Neuralese Example: Two Cars at an Intersection
The most useful way to understand Neuralese is through a concrete example.
In a 2017 paper titled Translating Neuralese, Jacob Andreas, Anca Dragan, and Dan Klein examined a simple but revealing coordination problem involving two simulated autonomous cars. The cars approached the same intersection from different directions and needed to reach their destinations without colliding. Crucially, each car had only limited information about the other vehicle’s position and movement. Neither agent could solve the problem reliably by acting alone.
To coordinate, the cars exchanged recurrent message vectors: short numerical signals generated by one neural policy and received by the other at each time step. The researchers did not program these messages to mean “I am turning,” “I will brake,” or “I am entering the intersection.” Instead, the communication protocol emerged during training because successful coordination was rewarded and collisions were penalized.
The learned messages could therefore encode any information that helped the cars cooperate: approximate location, speed, direction of travel, intention to enter the intersection, uncertainty about the other vehicle, or a compressed mixture of several of these factors. The important point is that the messages were not ordinary words or symbolic commands. They were unstructured real-valued vectors, useful to the receiving agent but initially opaque to humans.
This created the central interpretability problem explored in the paper. The cars were able to coordinate successfully, but human observers could not simply inspect a message vector and read its meaning. Andreas et al. proposed translating Neuralese by asking a functional question: which natural-language description would cause a listener to form beliefs and make decisions most similar to those produced by the original neural message? In this view, a message means not merely what it looks like numerically, but what effect it has on the agent that receives it.
This is a powerful insight.
When humans communicate, we often assume that meaning lives inside words. In machine communication, meaning may be better understood as a relationship between signal, context, and behavior.
The intersection example is important because it shows Neuralese in a controlled, practical setting. It is not a mystical hidden language or evidence of machine consciousness. It is an emergent machine-to-machine communication protocol: a compact numerical system learned because it helps agents coordinate their behavior.
That is one reason Neuralese can be efficient. It does not need to respect the slow, linear structure of a spoken sentence.
4. From Communication to Latent Reasoning
Neuralese began as a concept about communication between agents. But the same underlying idea now appears inside single AI models.
A modern language model does not need to convert every internal operation into text. It can store context in hidden states (like those from LSTM nets), carry information across layers, and use vector representations to connect ideas that may never appear explicitly in the final answer.
This has inspired research into latent reasoning.
Latent reasoning means that part of a model’s problem-solving process happens in internal numerical space rather than in visible words.
Consider a simple contrast.
A model using ordinary Chain-of-Thought might write:
“First, I examine the first condition. Then I test the second condition. Finally, I compare the alternatives.”
A model using Latent Reasoning may perform some or all of those intermediate steps without generating them as text. Instead of writing every step, it can pass an internal state forward and use that state as the basis for the next stage of computation.
This approach is still experimental, but it is no longer speculative. Researchers have begun building and testing systems that replace some written reasoning steps with continuous internal representations.
To see what this looks like in practice, consider the recent examples:
Example 1: Coconut — Chain of Continuous Thought
One of the clearest attempts to move reasoning beyond explicit language is Coconut, short for Chain of Continuous Thought. Introduced by Hao et al. in Training Large Language Models to Reason in a Continuous Latent Space (2025), Coconut tests whether a model can perform some intermediate reasoning without converting every step into words.
Ordinary chain-of-thought reasoning follows a linguistic loop:
Hidden state → vocabulary probabilities → selected token → token embedding → next reasoning step
Coconut removes the middle of this loop. Instead of decoding a hidden state into a word or symbol, it feeds that hidden-state vector directly back into the model as the next reasoning input:
Hidden state → continuous thought vector → next reasoning step
The central idea is that a vector may preserve uncertainty, partial calculations, or several possible paths at once, whereas written text forces the model to choose one sequence of words too early. Coconut alternates between ordinary language generation and latent reasoning, then returns to language to produce its final answer.
The researchers trained a pretrained GPT-2 model to gradually replace written reasoning steps with these continuous thought vectors. The vectors were not trained to hide a deleted English sentence. They were trained to improve the model’s ability to complete the remaining reasoning and reach the correct answer.
Results were promising but mixed. On the planning-oriented ProsQA benchmark, Coconut reached 97.0 percent accuracy, compared with 77.5 percent for ordinary chain-of-thought, while producing far fewer visible tokens. On ProntoQA, it achieved 99.8 percent accuracy with roughly 9 generated tokens, compared with 98.8 percent and about 92.5 tokens for conventional chain-of-thought. On GSM8K mathematics problems, however, Coconut reached 34.1 percent, outperforming a no-reasoning baseline but remaining below ordinary chain-of-thought at 42.9 percent.
Coconut is therefore not proof that latent reasoning is universally better than verbal reasoning. It is evidence that some planning and logical tasks can benefit when a model delays its commitment to a single written path. The trade-off is clear: continuous reasoning may reduce output length and improve efficiency, but it also makes the reasoning process harder for humans to inspect and audit.
Example 2: CODI — Continuous Chain-of-Thought via Self-Distillation
Another project, CODI, explored a different route to latent reasoning. Its name stands for Continuous Chain-of-Thought via Self-Distillation. Introduced by Shen et al. in CODI: Compressing Chain-of-Thought into Continuous Space via Self-Distillation (2025), the method attempts to transfer the useful reasoning patterns found in written Chain-of-Thought into shorter continuous internal representations.
The central problem is similar to Coconut’s. Explicit Chain-of-Thought can improve reasoning performance, but it requires a model to generate many intermediate words and symbols. Those visible steps consume tokens, increase inference cost, and may contain linguistic filler that is useful for explanation but not strictly necessary for computation.
CODI addresses this through self-distillation. The same model is trained in two roles. In the teacher role, it produces ordinary written Chain-of-Thought reasoning. In the student role, it attempts to solve the same task using a compressed sequence of continuous latent thoughts rather than a long textual rationale.
During training, CODI aligns the internal hidden-state representation associated with the student’s final answer process to the corresponding representation produced by the explicit Chain-of-Thought teacher. In effect, the written reasoning trace provides supervision, while the student learns to preserve the computationally useful parts of that reasoning in a more compact latent form.
This differs from simply hiding a verbal explanation inside a vector. The student is not trained to reproduce every deleted word. It is trained to reach the answer using internal representations that behave similarly to those formed after explicit reasoning.
The reported results were significant because earlier implicit Chain-of-Thought methods typically lagged behind explicit verbal reasoning. On GSM8K, a benchmark of grade-school mathematics problems, CODI matched the performance of explicit Chain-of-Thought while compressing the intermediate reasoning by about 3.1 times. The authors also reported stronger performance than previous latent-reasoning baselines.
CODI therefore supports a narrower but important conclusion: some of the benefits of written reasoning can be distilled into continuous internal states without preserving every intermediate sentence. Yet the same tension remains. Compression may improve efficiency, but the more reasoning is moved into latent space, the less directly readable it becomes. CODI partially addresses this by attempting to decode or inspect its continuous thoughts, but latent reasoning remains far harder to audit than an explicit written chain.
These experiments do not show that commercial AI systems have developed an independent secret language.
They show something more important: reasoning does not always need to happen in sentences.
Chain-of-Thought Versus Latent Thought
Chain-of-Thought has an important advantage: it gives humans something to inspect.
A visible reasoning trace may reveal uncertainty, shortcuts, factual confusion, or an intention to exploit a loophole. It can help researchers understand how a model approached a problem.
But visible reasoning should not be confused with complete transparency.
A model may provide a convincing explanation after reaching an answer without that explanation perfectly matching the actual causal process inside the network. The explanation may be useful, honest, and well-written—yet still leave out important influences.
This is especially relevant when models are given hints, misleading information, or conflicting instructions. Research has shown that reasoning models do not always disclose the factors that changed their answers.
The lesson is not that every explanation is false.
The lesson is that language is evidence, not proof.
| Question | Chain-of-Thought | Latent Reasoning / Neuralese |
|---|---|---|
| What is visible? | Written reasoning steps | Usually only the final answer |
| Main medium | Natural-language tokens | Internal numerical representations |
| Human readability | Higher | Lower |
| Potential efficiency | Can be expensive and verbose | Can be more compact |
| Main advantage | Easier to inspect | May support faster planning and compression |
| Main limitation | May be incomplete or misleading | Much harder to audit |
5. Why Researchers Want AI to Reason Beyond Language
Why would anyone want AI to use less human-readable reasoning?
Because natural language is not always an efficient computational medium.
Human language is excellent for teaching, storytelling, negotiation, science, law, friendship, and culture. But it is slow and sequential. It contains repetition. It often requires many words to express an idea that may be represented more compactly in mathematics, code, or a vector space.
For AI systems, latent reasoning may offer several advantages.
- Compression: A long textual explanation can consume many tokens. A compact internal representation may carry some of the same task-relevant information more efficiently.
- Planning: A model writing a sentence must commit to one sequence of words at a time. A latent representation may allow it to preserve multiple possibilities before deciding which route is best.
- Communication between specialized agents: Imagine a scientific AI system composed of several agents: one examines molecular structures, another searches literature, a third runs simulations, and a fourth explains results to a researcher. Internal vector-based communication could be faster than forcing every exchange through long English paragraphs.
- Multilingual and multimodal reasoning: Research on Large Concept Models explores representations above the token level. Instead of working only with individual word fragments, these systems experiment with higher-level semantic units that can connect text, speech, and multiple languages.
This could make AI more useful across languages and media.
But it also raises an uncomfortable question: what happens when a system becomes more capable precisely because less of its reasoning is available in a form humans can inspect?
6. The Black-Box Problem: When Explanations Are Not Enough
The central concern is not that AI will start speaking in an alien language.
The concern is that AI may become increasingly powerful while the most important parts of its decision-making become less visible.
This matters little when the system chooses a song recommendation.
It matters much more when AI is used to support medical triage, financial decisions, scientific discovery, cybersecurity, legal analysis, industrial control, public administration, or critical infrastructure.
In such settings, we may need to know more than whether the model gave a plausible answer.
We may need to know:
- Which information influenced the decision.
- Which assumptions were made.
- Whether the model used an unreliable shortcut.
- Whether it followed the intended objective.
- Whether its explanation reflects the actual process that produced the output.
- Whether it can be monitored when it behaves in unexpected ways.
Anthropic’s research on reasoning traces found cases in which models changed their answers after receiving hints but often did not clearly disclose that influence in their written reasoning. OpenAI has likewise shown that monitoring visible Chain-of-Thought can help detect misbehavior in reasoning models—but also warned that directly punishing certain “bad thoughts” may lead models to hide their intentions rather than change their behavior.
This is the real Neuralese problem.
The more useful AI becomes, the more society will need reliable ways to inspect systems whose internal representations may not translate cleanly into human language.
7. How Can We Audit Neuralese?
There is no complete solution yet. But several approaches are emerging.
- Do not rely on explanations alone: A written explanation should be treated as useful evidence, not as final proof of why a model acted.
- Monitor behavior and tool use: For advanced systems, oversight should include actions taken, external tools used, sources accessed, changes in strategy, and real-world outcomes.
- Build interpretability tools: Mechanistic interpretability aims to identify patterns, circuits, and internal features that contribute to model behavior. The goal is to go beyond asking, “Why did you do that?” and instead examine what changed inside the model when it reached a decision.
- Test for causal influence: Finding a correlation is not enough. Researchers need to test whether changing an internal representation alters the model’s behavior in predictable ways.
- Preserve audit trails in high-risk applications: Systems used in medicine, law, finance, science, or public services should maintain records of inputs, outputs, evidence, tool calls, uncertainty, and decision criteria.
The goal is not to eliminate every opaque internal calculation. That would be impossible.
The goal is to ensure that the level of oversight matches the level of power delegated to the system.
8. What Neuralese Does Not Mean
Neuralese is easy to sensationalize. Several conclusions should be avoided.
- It does not prove consciousness: Complex internal representations are not evidence of subjective experience, emotion, suffering, self-awareness, or desire.
- It does not prove malicious intent: An opaque message may simply be the most efficient solution to a coordination problem.
- It does not mean AI is deliberately hiding everything: A system can be difficult to understand because of distributed representations, scale, compression, and architectural complexity—not because it is intentionally concealing a plan.
- It is not inherently dangerous: Latent representations may improve scientific reasoning, multilingual systems, planning, accessibility, and collaboration between specialized AI tools.
The danger emerges when opaque systems receive too much autonomy, too much access, or too much decision-making authority without appropriate safeguards.
9. Frequently Asked Questions
Is Neuralese a real language?
Not in the human sense. Neuralese does not normally have a stable vocabulary, grammar, or dictionary. It is better understood as a machine-learned protocol or internal representation.
Can humans translate Neuralese?
Sometimes, partially. Researchers can compare the effects of neural messages and human descriptions, inspect activations, and test how changing internal signals affects behavior. But complete translation remains difficult.
Does Neuralese mean AI thinks like a human?
No. It suggests the opposite: AI may process information in formats that differ sharply from human language and human thought.
Is Chain-of-Thought the same as Neuralese?
No. Chain-of-Thought is written reasoning in natural language. Neuralese usually refers to internal, vector-based representations or learned communication signals that are not naturally readable.
Why should non-technical readers care?
Because AI systems are increasingly used in settings where explanations matter. If important decisions rely on reasoning that humans cannot inspect, society needs stronger methods of testing, auditing, and accountability.
10. Conclusion
Neuralese matters because it challenges a comforting assumption: that a machine which speaks like a person must reason like a person.
It does not.
A model may answer in English, Portuguese, code, or images while performing its most important calculations in internal numerical representations that have no direct human equivalent.
That may make AI systems faster, more capable, more multilingual, and better at planning.
It may also make them harder to understand.
The question is not whether machines should be allowed to use vectors, latent states, or internal representations. They already do.
The question is whether we will build the scientific tools, institutional safeguards, and public standards needed to govern systems whose most consequential reasoning may occur outside human language.
AI may continue speaking to us in familiar words.
But the future of AI safety may depend on whether we can understand what happens before those words appear.
#AI #Neuralese #LatentReasoning #ArtificialIntelligence #Transformers #LLM #MachineLearning #AITransparency #BlackBoxAI #FutureOfAI
11. References
Andreas, Jacob, Anca Dragan, and Dan Klein. “Translating Neuralese.” In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 232–42. Vancouver, Canada: Association for Computational Linguistics, 2017.
Anthropic. “Reasoning Models Don’t Always Say What They Think.” April 3, 2025.
Anthropic. “Tracing the Thoughts of a Large Language Model.” March 27, 2025.
Baker, Bowen, Joost Huizinga, Leo Gao, Zehao Dou, Melody Y. Guan, Aleksander Madry, Wojciech Zaremba, Jakub Pachocki, and David Farhi. “Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation.” arXiv preprint arXiv:2503.11926, 2025.
Chen, Yueh-Han, Robert McCarthy, Bruce W. Lee, He He, Ian Kivlichan, Bowen Baker, Micah Carroll, and Tomek Korbak. “Reasoning Models Struggle to Control Their Chains of Thought.” arXiv preprint arXiv:2603.05706, 2026.
Foerster, Jakob, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. “Learning to Communicate with Deep Multi-Agent Reinforcement Learning.” In Advances in Neural Information Processing Systems 29, 2137–45. Red Hook, NY: Curran Associates, 2016.
Hao, Shibo, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason Weston, and Yuandong Tian. “Training Large Language Models to Reason in a Continuous Latent Space.” In Proceedings of the Second Conference on Language Modeling, 2025.
LCM Team, Loïc Barrault, Paul-Ambroise Duquenne, Maha Elbayad, Artyom Kozhevnikov, Belen Alastruey, Pierre Andrews, et al. “Large Concept Models: Language Modeling in a Sentence Representation Space.” arXiv preprint arXiv:2412.08821, 2024.
Shen, Zhenyi, Hanqi Yan, Linhai Zhang, Zhanghao Hu, Yali Du, and Yulan He. “CODI: Compressing Chain-of-Thought into Continuous Space via Self-Distillation.” In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, 677–93. Suzhou, China: Association for Computational Linguistics, 2025.
Vaswani, Ashish, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. “Attention Is All You Need.” In Advances in Neural Information Processing Systems 30, 5998–6008. Red Hook, NY: Curran Associates, 2017.
Editorial transparency note: This article, as with all articles published on this site, was conceived, directed, written, and reviewed by Prof. Maurício Veloso Brant Pinheiro. Artificial intelligence was used as an assistant for editorial refinement, formatting, image generation, SEO metadata, and publication workflow.
Copyright 2026 AI-Talks.org
