Keeping a cache warm on purpose
The snooze ping: what one ping costs, what a cold prompt costs instead, when it cancels itself, and the probe that proved a read refreshes the system blocks.
Walk away for lunch and your next message pays to rewrite the whole conversation history. On a 100,000-token thread that is sixty cents of cache write before you have said a word. Token Stanza’s keep-warm feature holds the cache open on purpose, for about three cents an hour on that same thread. This post is about the arithmetic that says when the trade is worth it.
What a ping is
The cache entry behind a conversation lives for an hour after its last read, and nothing extends it except another read. The previous post is about keeping that read cheap. This one is about making sure it happens.
A snooze arms a window of one to twelve hours on a conversation. For as long as the window is open, the app reads the prefix on your behalf. Every five minutes a background service checks for armed conversations. Any conversation whose prefix was last warmed fifty or more minutes ago gets pinged. Each ping is the lightest request that counts as a read: the same cached prefix your last message used, reproduced exactly, plus a one-line instruction to say “ok”, capped at eight output tokens. The previous post called these replays. The read refreshes the entry’s one-hour timer.
What it costs, and what it avoids
A ping on a 100,000-token conversation is a cache read of 100,000 tokens plus a handful of output tokens. The alternative, one cold message, is a cache write of the same 100,000 tokens. On Sonnet 4.5’s list prices:
| Request | Tokens | List price per million | Cost |
|---|---|---|---|
| Ping, cache read | 100,000 | $0.30 | $0.03 |
| Ping, output | 8 | $15.00 | under $0.0002 |
| Cold message, cache write | 100,000 | $6.00 | $0.60 |
Twenty to one. A ping costs about 5% of the rewrite it avoids. Pings fire at fifty to fifty-five minutes, so a conversation held warm costs a little over three cents an hour. A full twelve-hour snooze, the longest the app allows, is fourteen or so pings and about forty cents. That is less than the single cold write it prevents. The break-even arrives with the first message. If you send one more message before the window closes, the snooze has paid for itself, and every hour of warmth beyond the first is cheaper than the last one was.
When snooze does not pay for itself
The arithmetic is less kind on a short conversation. A 5,000-token thread costs a fraction of a cent to ping and three cents to rewrite cold, so a twelve-hour snooze on it costs about what one cold write would. Break-even, not savings. That is why the feature is a setting rather than a default. The person who knows whether they are coming back is the one holding the mouse.
When it refuses, when it cancels itself, and when it runs out
Arming is refused when the prefix has already expired or was never cached. A snooze on a cold conversation would begin by paying the very write it exists to avoid. On screen that is the Keep warm button, offered only while the cache countdown next to it is still running.
A write-dominated ping, one that comes back with more cache-write tokens than cache-read tokens, cancels the snooze. In plain terms the ping did not find the prefix, usually because another region served the request, and every further ping could pay full price again. Auto keep warm, the standing preference that re-arms the window on each turn, pauses one re-arm rather than switching itself off. A cost heuristic that silently turned a setting off would look like a bug with no way back.
A window that runs out does so quietly. The last ping’s hour counts down like any other. The button under the composer goes back from the window’s remaining time to the one-hour countdown, and when that reaches zero the conversation is cold and Keep warm is greyed out. Nothing is sent and nothing pops up. The only visible difference: the next message you send will be cold. If it would replay more than 50,000 tokens at full price, the composer asks before sending. That dialog has a post of its own, next in the series.
Checking that a ping does what it should
The system prompt is sent as two cached blocks, and the ping reads at the message cache point after both. Whether that read also refreshes the system entries behind it was the assumption the whole feature rests on, and the documentation leaves room to doubt it. If a read at the message cache point did not also refresh the system entries in front of it, a ping would be refreshing only part of the prefix.
The small test program from the previous post settled it. Its decisive request goes out eight and a half minutes after the first write, with five-minute cache entries, long after an untouched entry would have expired, and reads back exactly both system blocks. The only thing that had touched them in between was two message-level reads, the way a real turn or a ping does. A control entry that was never read had expired, proving the refresh was real. The run takes nine minutes and about a cent and a half.
What snooze is for
Overnight, mostly, and across the gaps in a working day. The sessions that get snoozed are the long ones. A research thread that has been going for hours and has a hundred thousand tokens of history, where the next message is coming tomorrow morning, and the whole value of the conversation is that the model still has all of it in front of it.
The overnight case is the arithmetic at its clearest. Twelve hours of pings cost less than one cold write, and every subsequent message stays cheap. Leave a 100,000-token conversation cold at six in the evening and the first message the next morning pays sixty cents to rewrite the history. Snooze it for twelve hours and the fourteen or so pings come to about forty cents, and the morning message reads the history for three cents. The saving is modest in dollars and large in shape. A pinged conversation costs the same at the start of the day as it did at the end of the previous one. A cold one costs twenty times more for its first message than for its second. A two-hour gap at lunch is the same story at a smaller scale: two pings for six cents against a sixty-cent write.
The feature is deliberately not clever about any of this. It does not guess that you are coming back. The one-to-twelve-hour window is a statement from the person who knows, and auto-snooze is the same statement made once for a conversation they expect to live with for a while.