A short writeup of the STOHLE project. Paper, code, one-command reproduction, and DOI: github.com/jannallenberger/stohle (DOI 10.5281/zenodo.21002196).

I spent a while on a simple question: can you steer a frozen language model toward a topic at inference time, without retraining, and can a couple of new tricks beat the plain version? I had an idea I liked, the "Ghost Room," for recycling the good drafts a best-of-N search would normally throw away. Most of it didn't work. The part worth your time is what happened when I changed how I graded the outputs.

The grader changed the answer

I graded the same experiments two ways. First with a cheap LLM-as-judge (a same-family model scoring text 0 to 100), which is how a lot of steering work gets evaluated. Then with a stricter, independent judge: a natural-language-inference model scoring how strongly a text is about the target topic versus competing topics, with a matched writing-quality budget so on-topic gibberish cannot win.

Three results flipped. Best-of-many versus generating once went from a clear win (+15.6 on the cheap judge) to nothing. An internal reader I had reported as appearing only in larger models turned out to work even in the smallest one, so I retracted the size-dependence story. And the Ghost Room went from significantly hurts to no effect. Every disagreement ran the same direction: the cheap grader was always the more optimistic one.

I want to be careful here. I did not check either grader against human labels, so I am not saying the cheap one is wrong and the strict one right in any absolute sense. They disagree, and that is enough to flip the conclusion of the paper. I default to the NLI judge because it is independent of the model being graded and built as a contrast rather than an absolute score. The narrower, more useful takeaway: if your only judge is a weak automatic one, your steering wins deserve suspicion until a human spot-check backs them up. Mine included.

What actually held up

Two things survived, and both are basically known results done carefully. Steering works: rotating the hidden state toward a concept direction, keeping its length fixed (which behaves far better than just adding a vector), moves text on-topic on held-out topics, +0.42 on the adherence margin, p < 0.001. And the concept signal is readable from the internals: a list-free projection reader picks the most on-topic draft from a batch about as well as a hand-written keyword list, which fits what the probing literature already shows.

What did not

The Ghost Room, and both variants I built of the same idea (a persistent council of viewpoints, and a text-level version that keeps rejected drafts in the prompt), all came out equivalent to doing nothing. On the held-out test the Ghost Room scored -0.095 against the no-recycling baseline, inside the pre-registered equivalence band, no better than injecting random vectors or just steering harder. It even cost a little writing quality.

The deeper pattern surprised me. You can read how on-topic a draft is from the activations, but that did not translate into producing a better draft: generating once scored the same as generating eight and keeping the best. So the readable signal is real, and turning it into better writing, by recycling or by selection, just did not pay off in anything I tried. I also caught myself about to claim a roughly 21% compute saving from an adaptive budget; under the strict grader that fell apart too, because best-of-many is not beating generate-once in the first place, so there is nothing to economize.

Why post a pile of negative results

Because they are clean, and the methods are the point. Everything ran on one 8 GB consumer GPU. The plan was pre-registered and frozen before I touched the test set, the test set was used once, and every headline number regenerates from committed data with a single script and no GPU. The honest one-liner: you can steer a frozen model, and you can read the concept signal out of it, but turning that signal into better writing did not survive careful testing. The open question I could not answer is whether that gap closes at larger full-precision model sizes my 8 GB card cannot run.

Paper, data, and reproduce.py: github.com/jannallenberger/stohle

Disclosure: the implementation and analysis were done by Claude Opus 4.8 in Claude Code under my direction. I am noting it openly, since the post is partly about not trusting automated output you have not checked.