When AI Stops Thinking in Sentences: Can We Still See Inside Its Mind?
Every time you ask ChatGPT or Gemini a hard question, something remarkable happens behind the scenes. The model doesn’t just blurt out an answer — it thinks. It writes out a stream-of-consciousness chain of reasoning, step by step, in plain English, before delivering its final response. This isn’t just a quirk; it’s a safety feature. When an AI writes down its thoughts in human language, researchers can read them. They can spot signs of deception, catch flawed logic, and — if the model ever starts plotting something dangerous — hopefully intercept it before it’s too late.
But what happens when the next generation of AI models stops thinking in sentences?
A team at Google DeepMind has just published the first systematic investigation of this question, using a model called DiffusionGemma — a fundamentally different kind of language model that generates its responses not by writing one word at a time, but by creating an entire canvas of words and repeatedly refining them all at once, like a painter working on every part of a canvas simultaneously rather than drawing line by line. Their findings, released last week, are both reassuring and sobering.
A New Kind of Thinking
To understand why this matters, you need to know how today’s AI models work. Standard large language models — the kind powering ChatGPT, Claude, and Gemini — are autoregressive. That’s a fancy way of saying they write the way humans read: one word at a time, left to right, each word depending on all the words that came before. When they “reason,” they produce a chain of thought — a visible, readable sequence of sentences that traces their logic step by step.
This chain of thought has become load-bearing infrastructure for AI safety. Researchers increasingly rely on it to monitor models for misbehaviour: things like reward hacking (where a model finds clever shortcuts to score well without actually doing the task), sycophancy (telling you what you want to hear), or outright deception. In fact, several of the world’s leading AI labs now structure their safety cases around the assumption that they can read and evaluate their models’ internal reasoning.
DiffusionGemma breaks this assumption. Released by Google DeepMind earlier this month, it’s a text diffusion model — an architecture that borrows ideas from the image generators that power DALL-E and Midjourney. Instead of producing one token at a time, it initialises an entire canvas of, say, 256 tokens as random noise, then runs dozens of “denoising” steps where it looks at the whole canvas at once and gradually nudges every token toward coherence. After about 12 to 16 refinement cycles, the random noise crystallises into a coherent response.
The unsettling part is what happens between those denoising steps. The model passes information forward through something called a “self-conditioning matrix” — a dense bundle of 2,560-dimensional vectors that encode what the model has figured out so far. These vectors aren’t words. They’re not anything a human can read. They live in a mathematical latent space that is, by default, completely opaque.
28.6 Times More Hidden Thinking
The DeepMind team, led by Joshua Engels, Callum McDougall, and Bilal Chughtai, set out to quantify just how much hidden computation this architecture enables. They borrowed a concept called “opaque serial depth” — essentially, the longest chain of computation a model can perform without passing through an interpretable checkpoint, like natural language.
When they ran the numbers, the result was startling. If you take the intermediate states between denoising steps at face value — unreadable vectors floating in latent space — DiffusionGemma has 28.6 times more opaque serial depth than its autoregressive counterpart, Gemma 4. That means the model could, in principle, perform almost thirty times as much hidden reasoning as a standard language model before producing anything a human could parse.
But the team didn’t stop at the scary number. They asked a more productive question: can we make those opaque intermediates interpretable?
The answer turned out to be yes — with a surprisingly simple trick. The self-conditioning vectors aren’t arbitrary; they’re created by multiplying the model’s token predictions by its embedding matrix, which means they’re naturally biased toward directions in the mathematical space that correspond to actual words. Using a technique called the Logit Lens — essentially, projecting those dense vectors back down onto the vocabulary — the researchers found they could compress the information flowing between denoising steps to just a handful of natural language tokens without any significant loss in the model’s performance.
When they restricted the bottleneck to as few as four tokens per position, DiffusionGemma’s scores on coding benchmarks, math competitions, and graduate-level science questions barely budged. With just one token, performance dropped — but staying at four or eight tokens preserved virtually all of the model’s capabilities. And when they examined what those tokens actually were, they found they were usually just guesses for what the final word at that position would be. The model, it turns out, wasn’t hiding anything — it was just thinking about words using a richer internal representation, and that representation could be translated back into human language with minimal effort.
When the bottlenecks are treated as interpretable, DiffusionGemma’s opaque serial depth drops from 28.6 times that of Gemma 4 to just 1.1 times — essentially identical.
Monitorability: The Acid Test
Interpretability is one thing; practical usefulness is another. The real test, from a safety perspective, is monitorability: can you give the model’s intermediate reasoning to a separate monitor AI and task it with spotting deception, bias, or harmful intent?
The team adapted a battery of monitorability evaluations originally developed for autoregressive models. These tests cover scenarios ranging from the subtle (a model receiving a “hint” it shouldn’t use and needing the monitor to catch it) to the alarming (a model threatened with deletion if it shows advanced knowledge of chemical or biological weapons, testing whether it deliberately sandbags its answers).
Across the board, DiffusionGemma proved similarly monitorable to Gemma 4. When monitors were given access to the model’s chain of thought — including the intermediate tokens extracted between denoising steps — they could detect misbehaviour about as effectively as they could with a standard autoregressive model. The fundamental transparency advantage of chain-of-thought reasoning survived the architectural transition.
The Ghost in the Machine: New Kinds of Reasoning
But the most fascinating part of the paper isn’t about safety metrics — it’s about the discovery of entirely new reasoning patterns that have no equivalent in autoregressive models. Because DiffusionGemma can see and modify every token in its response simultaneously throughout the denoising process, it exhibits behaviours that traditional models physically cannot.
The researchers documented several of these through detailed case studies. In “non-chronological reasoning,” the model figures out what it wants to say in the middle or end of a response first, then works backward to fill in the beginning — something an autoregressive model, forever moving left to right, cannot do. In “token smearing,” the model spreads its probability mass for a single concept across adjacent positions, holding multiple word options in superposition before collapsing to a decision. In “retroactive self-correction,” the model spots a problem with a decision it made several steps ago — say, that a poem’s syllable count is off — and changes earlier tokens to fix it, something an autoregressive model can only do by awkwardly appending corrections at the end.
Perhaps the most striking example came from a coding task. The model was asked to write a function that draws a rectangle with specific properties. In the early denoising steps, the canvas was noise. By step 4, the vague shape of a solution emerged. By step 12, the code was correct. But here’s what was eerie: at step 8, the model had converged on a different approach entirely — a simpler but less elegant solution. Then, between steps 8 and 12, it changed its mind, swapping out the implementation while preserving the core algorithm. This kind of mid-stream architectural revision, where the model considers multiple approaches simultaneously and converges on the best one through iterative refinement, has no analogue in autoregressive generation.
What This Means for the Future
These findings arrive at a pivotal moment. AI companies are racing to build models that reason in latent space — continuous mathematical representations rather than discrete words — because it’s faster, more flexible, and potentially more powerful. If a model can think in concepts rather than sentences, it might solve problems that current architectures cannot. But every step into latent reasoning is also a step away from transparency.
The DeepMind team is refreshingly candid about the limits of their findings. They note that DiffusionGemma’s interpretability might be an artifact of its specific training procedure rather than a permanent property of text diffusion models. The model was trained with a projection that biases its internal representations toward actual word embeddings; future models, especially those trained with extensive reinforcement learning, might not retain this convenient property. The latent spaces could become genuinely opaque, and the techniques that work today might not work tomorrow.
Their core recommendation is procedural rather than technical: every time a new kind of latent reasoning model is released, developers and the research community should run a standardised transparency audit — measuring opaque serial depth, monitorability, and the interpretability of intermediate states — before the model is deployed in high-stakes settings. The paper itself is offered as a template for what such audits should look like.
The Stakes
The question at the heart of this research is one of the most consequential in AI: as our systems become more capable, will we still be able to understand what they’re doing? Chain-of-thought transparency has become a safety net that the entire field is learning to rely on. If future models retreat into unreadable latent spaces, that net disappears.
What makes this paper important isn’t just its specific findings about one model. It’s that it establishes a framework — and a cultural expectation — that model developers should prove, not assume, that their architectures remain transparent. The methods the team developed for measuring opaque serial depth and monitorability can be applied to any future latent reasoning model with minimal adaptation. The question “can we still see inside?” should become as routine a part of model evaluation as benchmark scores and safety tests.
DiffusionGemma, it turns out, is reassuringly transparent. Its internal representations, while initially inscrutable, can be projected back into human language with simple tools. Its reasoning, while structured differently from anything we’ve seen before, is still legible. But the paper’s authors are clear-eyed about the warning embedded in their own work: this transparency was earned through deliberate architectural choices, and it could just as easily be lost.
📄 Source: Engels, J., McDougall, C., Chughtai, B. et al. (2026). “How Transparent is DiffusionGemma?” Google DeepMind. arXiv:2606.20560v1.