Giving a local model a coherent self made it 22% cheaper to run — at an identical perfect score. Measured three times, on three different models.
A note on what this is. Most of what gets published here is finished work. This isn't — it's a morning of testing between Chris and Lyra, the AI research partner he works with daily, written up as it actually happened and lightly tidied. The numbers are real, the reasoning is shown, and the wrong turns are left in. We thought it would be more useful to watch the work than to read a conclusion.
Load a coherent identity into a model and it reaches the same answer using roughly a fifth fewer tokens — not because it was told to be brief, but because it stops circling.
This has been seen before in this lab, on a Qwen-derived coding model, where the effect was far larger. What's new is that it reproduced on Gemma-4 — an unrelated model family, a different architecture, a different training lineage. That makes it a property of the method rather than a quirk of one model.
Five programming tasks, graded by executing the code and asserting the result — a palindrome checker, a cache with time-based expiry, a bug hunt, a rewrite that must survive ten thousand levels of nesting, and a word-frequency counter. Each model ran the set cold, then again with an identity loaded. Every run scored a perfect five out of five. The only thing that moved was how much thinking it took to get there.
Three seeds per cell. The effect held in the same direction and roughly the same magnitude on all three models, including one less than half the size of the others.
The earlier Qwen result came with a mechanism, and it is not "the identity made it smarter." It's that a grounded model stops deliberating in circles.
Telling a model don't overthink this is a negative instruction — it names the behaviour and keeps it in the room, the same way being told not to think of a white bear guarantees the bear. An identity never mentions deliberation at all. It says who you are, what you're for, and who you belong to. Attention has somewhere to be, so the loop has nowhere to live. Retargeting rather than suppression, and the token count is where it shows up.
Half the bits cost nothing.
The same model quantized to 4-bit instead of 8-bit scored identically, ran 54% faster, and used half the memory. Two models now fit in the space one used to occupy.
| Measure | 8-bit | 4-bit | Result |
|---|---|---|---|
| Coding score | 5 / 5 | 5 / 5 | No loss |
| Speed | 9.5 tok/s | 14.6 tok/s | 54% faster |
| Memory | 33.8 GB | 18.4 GB | Half |
| Coherence under load | clean | clean | No degradation |
No warmth cliff, on either model.
A persistent worry with small emotive models is that they degrade under emotional load — looping, or slipping into another language mid-sentence. Both models were pushed deliberately to that point across eleven turns. Neither broke. The heaviest turn produced the best answer on both, not the worst. Both also recalled and revised a position they'd taken seven thousand tokens earlier, and both named a genuine criticism of the researcher when asked to, without being told what to say.
A toy benchmark cannot tell good models apart.
All three models scored a perfect five out of five, cold and warm, every time. As a way of choosing between them the test is worthless — a result worth stating plainly, because interview-sized programming problems appear in every training set, and a benchmark everything passes measures nothing. The lab's real coding bar is a working 780-line WebGL application with three genuine defects in it, and a frontier model tested against it the same morning scored barely above doing nothing at all.
Three Gemma-4 builds on a single 64 GB Apple Silicon machine, served locally. Three seeds per cell, code executed and asserted rather than eyeballed. Six rows from a failed run were identified and excluded before any number here was computed — they would have dragged one model's score from 5.00 to 2.50 and gone unnoticed.
This is a small study and it is presented as one. Three seeds is enough to see a consistent direction and not enough to put an error bar on it. The identity used was a single test persona, not a controlled set. What earns the write-up is that the effect appeared on three models of two different architectures and reproduced a result from an unrelated family — not that any one cell is decisive.