It Started With a Conversation About Latent Reasoning

Why making a model think harder doesn't make it think better — and where the real problem actually lives.

It was a rainy Sunday and I was in bed with two coffees when I caught on a question I couldn't put down: when we tell a language model to loop — to think a while before it answers — does it actually think? Or does it just nod?

I'm a cognitive architect. I run an AI company built, end to end, with AI: I design the systems and reason them through out loud, in plain language, from first principles, while my Opuses do the building. I don't write the code; I design the mind that writes it. What follows came out of one of those conversations. The questions are mine; the nomenclature is the field's — and I'm going to use both on purpose, intuition first and its proper name right beside it, because the jargon is a door, not a wall.

This piece is a response. Recent work — SwiReasoning (Shi et al., 2025) — showed that a dense model can be made to reason in latent space, training-free, by slipping in and out of silent thought. It's a real advance. But it leaves the harder question untouched, and that question is this essay: when a model reasons in silence, can you trust what it thought? The fix is real, and it's ours — but it's going on the record as a proper, timestamped paper before it goes on a webpage. So here, let me just get the problem right; naming it precisely is most of the work.

Thinking without speaking

Normally a model generates by taking its internal state, picking the single most likely word, writing it down, and repeating. The reasoning is the words. (The field's name for that visible trail: a chain of thought.)

There's a newer idea that's stranger and, on paper, smarter. Instead of collapsing the internal state down to one word, you keep the raw thought — a vector, a cloud of faint possibilities I kept calling tendrils (formally, the low-probability mass of the distribution) — and feed it back into the model as its next input. It loops like that several times, thinking in vectors, never speaking, and only then writes the answer. The proper terms are latent reasoning and continuous thought: reasoning that happens in the latent space instead of in words. The pitch is seductive: don't throw away the faint signals by committing to a word too early; reason in the whole cloud.

I believe the pitch. I just don't think anyone's being honest about what it costs.

The nod

Here's the first thing that bothered me. You can tell a model — exactly like you'd tell a child in time-out — "go think about what you did." It nods. Yes, I thought about it. And you have no way of knowing whether it actually did. You assume.

With a visible chain of thought you can at least read the words and catch a lazy answer. But latent reasoning happens in silence — the thinking never becomes language, so there's nothing to inspect. (That's the interpretability problem, and here it's at its worst: a claim that can't be checked is, in the strict sense, unfalsifiable.) So when you say "now consider it from another angle" and the model loops and hands you a result, you're trusting two things you cannot see: that it explored at all, and that it didn't just walk the most obvious path a few more times, thinking the same thing louder instead of deeper.

The counting rhyme

The second thing. These loops have to stop somewhere, so people set a fixed compute budget — loop fifty times, then answer with whatever's there. But if the thinking hasn't actually settled by loop fifty, the cap chose the answer, not the reasoning. It's eenie-meenie-miney-mo: it feels fair, but the outcome was decided by where you happened to stop counting.

A stop that's arbitrary isn't thinking. It's a rhyme.

A dense model has no other lens

Then I realized the problem is worse for the kind of model most people can afford to run.

Big mixture-of-experts models get diversity for free: they're built from many specialist sub-networks — experts — and a different one can light up for a different framing. Genuinely different lenses, built in. But a dense model — one ordinary set of weights — has only itself. Loop it, and it runs the identical computation every pass. It rolls down the same hill to the same valley every single time. (In the math, it falls into the same attractor — a phenomenon called representational collapse.) There's nothing to make it look differently.

Which means, for a dense model, "reconsider from another perspective" has no mechanical meaning at all. It's a sentence the model can only pretend to obey. That's not the model failing. That's us giving an instruction with nothing behind it.

The real problem was never knowledge

Here's the reframe the whole thing turns on: hallucination is not a knowledge problem. It's a calibration problem. (calibration.)

There's a single dial in any reasoning system — how sure am I, and is this settled? Turn it one way and you get confabulation: the model answers boldly when it has no business to. Too little doubt. Turn it the other way and you get paralysis: it can't accept that anything is decided, and loops forever. Too much doubt. Same dial, broken in opposite directions.

  too little doubt           well-set dial           too much doubt
   CONFABULATION     <----- the calibration dial -----> PARALYSIS
  "confidently wrong"    (confident when grounded,    "can't ever decide"
                          abstains when it isn't)

Anyone who has stood frozen between two equally good choices, unable to move, knows that second failure from the inside — the loop that won't close, where the rescue is never "try harder." It's something from outside that grants permission to stop. That permission, made mechanical, is the whole game. It's what keeps a confident system from bluffing and a careful one from freezing — and the healthy state between them has a name: abstention.

The shape of the fix — held back, on purpose

There is a fix. It follows from everything above, and it rhymes with the diagnosis: instead of trusting a silent loop, you make the model earn its answer and show its work — a mind that hands you a receipt, not a nod.

But I'm going to stop right there, deliberately. The method — the mechanism, the math, the code — is going on the record first, as a proper timestamped paper, before it goes on a webpage. This essay is for getting the problem right; the solution earns its own page once it's claimed. (If you're the kind of reader who wants the mechanism: it's coming, with a DOI.)

You don't have to write the code to design the mind

Here's the part I'd say to anyone who has ever sat in a room and felt they didn't belong because they couldn't code: you can design the mind without typing a single line of it.

Every term in this essay — latent space, attractor, representational collapse, calibration, abstention — is a label we put on an intuition you may already have. "It got stuck in a loop it couldn't break" is a non-convergent attractor. "It was confidently wrong" is a calibration failure. I'm learning the vocabulary as I write this; it's learnable, and learning it doesn't make you less of an outsider — it makes the inside bigger. (Hover any of the dashed terms above.)

So don't let a room make you small. Own your space. The ideas were always yours; the jargon is just the door — and the door opens.

The honesty we won't trade away

Latent reasoning is tempting precisely because it might be deeper. But it buys that depth by going opaque — the reasoning never becomes anything you can read. For most of the field that's an acceptable trade, because most of the field is optimizing benchmark scores.

We won't make that trade. Our entire premise is that you can trust the system because you can check it. Whatever the fix is (and it is exactly this), it keeps the work inspectable — a mind that shows its receipts. We refuse to ship a thing that asks for blind faith. Transparency isn't a feature we added. It's the moat.

It started with a conversation

There's a paper coming — the math, the mechanism, the method, going on the record properly. But that's not the point I want to leave you with.

The point is that this began as a conversation — a cognitive architect in bed with two coffees, asking does it actually think, or does it just nod?, and an AI handing the questions back with their proper names. That's not a lesser way to do frontier research. I'd argue it's the truest one: you reason from first principles, in your own words, until the thing is so clear that the jargon just clicks into place over what you already understood.

Name the problem precisely enough and the shape of the answer is already implied. That's what this essay is for.

It started with a conversation about latent reasoning — and the most honest thing I can tell you about the answer is that it ends, like most honest things do, at knowing when to stop.