Same model, same book, wildly different output. Four reasons, and two of them are yours

The complaint arrives in nearly the same words every time: “same model, same book — yesterday it nailed the chapter, today it wrote mush.” “It feels like pulling a slot machine.” “Did I break my prompt?” Inside those three sentences hide four unrelated sources of variance. Two of them you can actually turn. The other two — knowing they exist is most of the cure.

One boundary line first. There is a different disease where AI continuation gets steadily worse the longer it runs — a one-way slide with three documented failure shapes that we mapped across 360 rounds. This piece is about the other thing: the same spot in the story, the same button, and a different result each press. Drift is a slope. Variance is a wobble.

Source one: sampling temperature — every word is a raffle

Before writing each word, the model holds a probability table: “he” 40%, “sword” 20%, “suddenly” 0.5%. Temperature decides how loose its hand is when drawing from that table. At 0 it always grabs the top entry; higher, and long shots get their turn. Fiction is precisely where vendors tell you to keep the hand loose: DeepSeek’s parameter docs recommend 1.5 for creative writing — the highest value in their table, against 0.0 for code and math (checked 2026-07-18). The dial ships in the slot-machine position on purpose, because the fully tightened position produces the safest, flattest next sentence every time.

Which corrects a common instinct along the way: the reroll button is not a repair tool. It is a second draw from the same probability table. Drawing something worse is exactly as legitimate an outcome as drawing something better. The model didn’t break, and neither did you.

This is your first controllable. Turn the temperature down if the swings bother you, or pick a model that swings less by nature — in our nine-model blind-judged benchmark, “steady” and “good” turned out to be independent axes. One model was consistently competent and consistently unlike the original; another kept its brilliance and its breakdowns within arm’s reach of each other.

Source two: the “same request” whose contents quietly changed

The context you send is a fixed-size window; the book keeps growing. Once the window fills, every new passage shoves the oldest material out. Worse, the mix shifts: by round fifteen, most of the window can be the model’s own earlier output, so the “original” it imitates is increasingly itself. We measured that curve — bare-prompt chains dropped from a sentence-length variation of 0.64 to 0.52 over 20 rounds, and labeling which passages were original prose versus AI continuation pulled the same metric back to 0.64. Press continue today and again ten segments later, and the operation is identical while the material is not. You didn’t change. The window did.

Second controllable, and the fix is structural feeding: lore injected on demand instead of raw text squatting in the window, source labels switched on. There is also a free detector hiding in the billing response: the cache-hit field (OpenAI calls it cached_tokens) suddenly falling from 90% to zero means your request prefix changed since last time. We wrote up a billing investigation around that one field; the culprit that time was a timestamp that changed every minute. A subtler variant of the same failure: lore entries re-sorted by relevance on every turn. Not a word of content changed, but a different order is, to the model, a different context.

Source three: you touched nothing — the server moved

Set temperature to 0, freeze the context byte for byte, send the identical request a thousand times. Same output? No. Thinking Machines published the test in September 2025: temperature 0, one prompt, 1,000 runs, 80 distinct completions — identical through the first 102 tokens, diverging at token 103. No mysticism in the root cause: inference servers batch incoming requests by current load, common GPU kernels are not batch-invariant, and a one-word numeric difference cascades into a different paragraph.

Not yours to control, and switching providers won’t dodge it — the effect exists on CPUs and TPUs too. As for the folklore that vendors quietly swap in quantized models at peak hours: we have no verifiable evidence and won’t vouch for it. What the experiment nails down is narrower and still useful: one bad generation is not a verdict on a model. It may have shared a batch with the wrong strangers. The practical reading cuts both ways, by the way — the take that blew you away during a quiet 6 a.m. session was drawn from the same lottery. Don’t subscribe annually over it any more than you’d rage-quit over its evil twin.

Source four: the reader moved

Nobody wants to claim this one. In our blind benchmark, two reviewers — unaware of each other, diligent enough to keep per-round notes — agreed perfectly on first and last place across two randomized mappings, then deadlocked on ranks four and five and flagged their own calls low-confidence. The argument was whether “consistently okay” beats “brilliant middle, corrupted ending”. That is taste weighting, and professionals don’t have a standard answer either — which is exactly why the benchmark reports those places as ranges instead of forcing a number. The passage that gave you chills at 2 a.m. reads flat after lunch; what changed in between was not a model version. You slept.

Shortest source on the list. Checking your own state costs nothing; a reroll doesn’t.

Which source is biting you right now? A three-step triage

You can run the autopsy live, mid-frustration. Step one: fire the identical prompt three times in a row. If the three results scatter wildly, sampling and server batching are doing the shaking — tune temperature or make peace with it. If all three are consistently bad, that is not a slot machine; go audit the context. Step two: ask whether the slump arrived after many consecutive continuations. If yes, the window’s composition has probably drifted — switch the source labels on, or restart from a clean branch. Step three: if it only reads badly at night, sleep first and judge tomorrow. The ordering is deliberate: cheap checks go first, and blaming yourself goes last.

Turning the two knobs, setting down the two rocks

Yours: sampling — tune temperature per genre, and if you have low tolerance for swings, pick from the benchmark’s steady tier. Context — keyed lore entries, source labels on, so the window’s composition stops shifting under you. Not yours: server batching and your own state, with one shared policy — never judge on a single run.

Which brings back the slot machine. The real problem with rerolling was never the randomness; it is that each pull destroys the last one, so nothing can be compared. Since some variance is unremovable, catch it instead: at important beats, have the model produce three directions, read them side by side, keep the one that earns it — the losers stay put in case you change your mind. That is branching, and it is how we write now: temperature untouched, candidates always on, and the model itself swappable per paragraph — a steady model for connective tissue, a swingier one where the scene needs a wilder draw. The slot-machine feeling went away on its own, because no pull is ever the last one.