The Translation Accident

I. A Movie Poster and the Entire Film

In early 2026, The Information’s report on OpenAI Astra barely made a ripple outside tech circles. Ordinary people don’t need to know what “Recurrent Depth” is, just as airline passengers don’t need to understand the blade angles of a turbofan engine. But if you’ve spent the past few years treating AI interpretability as a serious issue, you probably paused when you saw the term.

The linguist Roman Jakobson divided translation into three types: intralingual (rephrasing technical jargon into plain language), interlingual (e.g., English to Chinese), and intersemiotic (moving between sign systems, like adapting a novel into a film). Over the past few years, the dominant approach in AI interpretability has essentially been the third type: translating the high‑dimensional mathematical computations inside a model into natural language that humans can read.

But the tool they’ve used to do that is the second type: having the model generate a natural‑language “chain of thought” (CoT), and then having humans read that text.

Read a screenplay and claim you understand the director’s visual language.

Anthropic’s J‑lens project offers a concrete example. They tried to index internal activation patterns using “single‑token concepts” from the vocabulary — but the researchers themselves admitted in their paper that a vast number of concepts have no corresponding single‑token name. Those nameless, untitled computational processes are inherently in interpretability’s blind spot. If a model wants to bypass its monitors inside latent space, it can do so entirely within structures that the vocabulary cannot reach.

II. Two Monday Mornings

Zoom out and look at two labs on a Monday morning, and the difference becomes clearer.

At Anthropic’s office, a group is discussing how to encrypt the CoT shown to users, to prevent them from being alarmed by the model’s “internal drafts.” Their logic: before generating the final answer, the intermediate steps may contain imperfect, tentative reasoning fragments, and exposing them directly to users is undesirable. So they opt for a mild form of obfuscation.

At OpenAI’s office — at least as The Information’s reporting suggests — another group is doing the opposite. Their Recurrent Depth scheme allows the model to cycle repeatedly through shared parameter layers, with the hidden state “chewing on” the problem internally, only mapping the computation to the vocabulary distribution when a final output is needed.

The reasoning process has been actively withdrawn from natural‑language space.

This is not obfuscation; it is relocation — moving the “thinking” to a place where the human vocabulary cannot reach. The model will still give you an output, and it may even append a fluent explanation afterward: “Here’s how I thought about it.” But that statement is already a post‑hoc translation, like the justification you invent on the spot after making a decision. You can’t call it false, but it is certainly not the reasoning process itself.

III. The Physical Meaning of Three Layers

The technical principle behind Recurrent Depth is not complicated, but its impact has layers.

First, compute. Traditional CoT must generate every intermediate token through a full autoregressive decode step — like climbing a staircase, lifting your leg anew at each step. Recurrent Depth, by contrast, lets the model cycle repeatedly through a fixed set of parameter layers — like walking in circles on a spiral staircase — and only exits after enough loops. This shifts the computational burden from “moving parameters” (memory‑bandwidth bound) to “doing matrix multiplications” (compute‑core bound). The hardware utilisation gain is real. A 3.5‑billion‑parameter model, by increasing the number of cycles, can approach the performance of a 50‑billion‑parameter model.

Second, the moat. Want to distill CoT via API to mimic OpenAI’s reasoning capabilities? The source no longer exists. The intermediate process is in latent space; no native trace can be captured externally. Even if the model attaches an explanation, it is second‑hand translation. You cannot learn original reasoning from second‑hand text.

Third, and most subtle: the liberation from symbols. The model no longer needs to spend compute on generating human‑style “logical connectives.” Words like “therefore,” “however,” and “considering” do not help the computation itself; they are only there to account for the logical chain to a human reader. By skipping that step, the model can directly perform its topological transformations in the representational space best suited for computation.

IV. The Seismological Turn in Interpretability

For AI safety monitors, all of this is bad news. Monitoring depends on visibility. If the reasoning process no longer appears as text, the traditional “read‑the‑CoT” approach becomes obsolete.

But there is another side to it.

Since the model no longer “keeps a diary,” monitors are forced to switch tools — from “reading text” to “directly studying the dynamics of hidden states” — not caring what the model says (because there is nothing to read), but caring about the waveform, frequency, and anomalous jumps of activation patterns.

When the tool changes, the question changes. The old tool did literary criticism: judging whether a piece of text is sincere. The new tool does physical observation: watching at which bifurcation point a high‑dimensional dynamical system undergoes a phase transition. The latter is closer to hard science, though far from mature.

Given the current technical resources of today’s labs, a truly usable “latent‑space seismograph” may still be years away. But the direction is right.

V. Beyond the Output Layer

Last week I wanted Fable to help me check the security configuration of my home gateway. A routine operation — I had run the script locally and just wanted a second opinion from a different model perspective. Fable refused and routed my request to Opus 4.8 — the layer jokingly known in the community as the “most neurotic” censorship tier.

When I saw the routing log in the terminal, I wasn’t angry; I almost laughed. A model capable of cycling through thousands of reasoning steps in latent space, a compressed intelligence that can mathematically approach the performance of a 50‑billion‑parameter system — and the reason it gets blocked is that I asked, “Help me check the gateway.”

Staring at that log, I remembered the 486 computer from my childhood: you typed a command, it either gave you a result or an error. You never had to guess what it was “thinking” — it wasn’t thinking at all.

Now we are building something that repeatedly computes in latent space. Its underlying logic is bound to exceed human intuition. We cannot fully describe everything that happens inside it with our impoverished natural language.

So the final question is not “Will it conspire in latent space?” The final question is: Can we accept an intelligence we cannot fully monitor, simply because its outputs are genuinely useful?

That routing‑log incident later became an inside joke with my colleagues. Every time we trigger censorship, we say, “Banished to Opus 4.8 again.” That sentence carries no fear, no worry about “AGI awakening” — only a specific impatience in a specific scenario.

Perhaps that is the most honest shape of the future: we will gradually grow accustomed to living with an opaque, efficient, occasionally glitchy intelligent system — much as we take electricity and running water for granted. We will replace abstract fear with concrete annoyance. And then we will get back to work.