Watch a language model think, layer by layer
Most models can only be studied from the outside, you feed them something and read what comes back. Ours can be read from the inside while they answer. Every layer, every neuron, every word it looked back at, live in a browser with nothing to install.
Everything it does is readable
A model is a long chain of arithmetic, every number it works with exists in memory while the answer is being built. Most engines throw those numbers away as fast as they can, because holding on to them costs time.
Veritate keeps the taps open. Tracing costs nothing while it is off, which is the part that matters, interpretability that slows a model down is interpretability that gets switched off before it reaches anything real.
So you can ask about one specific answer. Not what the model usually does, what it did here, on this word, at this layer.
- What each layer carriesThe residual stream, layer by layer, for every position in what you wrote
- Which neurons firedThe feed-forward activations on this word, and how hard each one pushed
- What it looked back atThe attention scores, showing which earlier words each head is reading from
- What it would have said earlyThe logit lens, the answer it was holding at layer four instead of layer twenty-four
- What decided the answerDirect logit attribution, how much each part of the model pushed the word it chose
You can see what it looked back at
As it writes each word, it reaches back to the words that matter and leaves the rest alone. The dashboard draws those connections while they happen, so a wrong answer stops being a mystery, you can see what it was reading when it went wrong.
The same view shows what it nearly said. Stop the model halfway up the stack and it already has a word in mind, watching that word change from layer to layer is the closest thing there is to watching a thought settle.
Why this matters
A clinic, a bank, or anyone facing an audit has to be able to say why a system produced what it produced. A model you can open is a model you can defend, the reasons are in the trace and the trace belongs to you.
When a training run drifts, being able to look inside turns a week of guessing into an afternoon of reading. We build the models this way because it is how they get better, and the same view ships with them.
Where this goes
Every model people rely on should be readable by the people relying on it. That is easy to say about a model with a few hundred million parameters and hard to say about one with a few hundred billion, which is one more reason we build small.
A model small enough to sit on your machine, open enough to read while it runs, and honest enough to show you what it nearly said instead. That is what we are building toward, and it is already running in a browser.
Watch one think
Send it a sentence and read the attention, the neurons, and the answer forming as it goes.