Keep the cache warm.

The fix is a keep-alive. Just before the cache expires, resend the thread's last request byte for byte, with max_tokens: 0. No answer comes back. The provider reads the cached prefix, and that read resets the expiry clock. A read costs a small fraction of a write.

The orange line jumps once the cache expires. The blue staircase climbs by one cheap read per ping. Until the blue line catches the orange, keeping the cache warm is cheaper.

When it stops paying

Context size cancels out. Break-even depends only on how much cheaper a read is than a write, and how often you ping.

On a 1-hour cache, Fable 5.1 reads are one eightieth the price of a write. That buys three days of pings. A 5-minute cache needs a ping every few minutes, so it runs out much sooner.

The catch: you don't always come back

That blue staircase is also what a finished thread costs. A keep-alive can't tell a lunch break from a closed task, so it keeps paying for threads you've abandoned. Most breaks that matter are short: lunch, a meeting, a review. Overnight gaps are where abandoned threads pile up.

So set a cutoff. A few hours catches the breaks worth catching, and stops paying for the rest. Skip small contexts too, where a rewrite costs pennies anyway.

What pings can't fix

A ping keeps the old prefix alive. It can't help once the prefix changes, whether from compaction, an edited system prompt, a model switch, or new tool definitions. Those misses need fixing in how the context is built.

Building it

• Save the exact bytes of each idle thread's last request.
• Replay them just before expiry, asking for zero output.
• Stop after a few hours, and skip small contexts and subagents.
• Keep pings out of thread history. They're cache traffic, not turns.
• Log each miss as expiry or invalidation, so you tune the right thing.