Nobody ships a naive cache to a handset. The stack already has KV quantization, paged attention, sliding-window attention, and eviction heuristics, and every one of them buys a constant factor while leaving the curve pointing up. SGF changes the shape instead: a resident footprint that sums to a ceiling you state before you ship, and that does not move as the session runs long.
On-device stacks are not naive about memory. KV entries are quantized to eight or four bits, paged attention keeps allocation from fragmenting, sliding-window and local attention cap what each layer has to attend to, and eviction heuristics drop the tokens that scored low on attention. This is good engineering and it works.
What none of it does is change the shape of the curve. Quantized memory still tracks conversation length, paging still allocates more pages, and a sliding window buys its headroom by discarding the beginning, which is where the instructions were. So the budget still has to be sized for the worst session a user might have, and in practice that means maintaining a second cut-down build for the handset with its own bugs and its own test surface.
SCOPE: schematic. The footprint at each budget setting comes out of the pilot, for your target device.
Device-class behavior below is projected from measured datacenter results and confirmed against your target in a pilot.
A constant factor moves the line down. It does not change where the line is pointing. What we publish is a resident memory that does not grow with the session at all.
SCOPE: measured on a single consumer-grade NVIDIA Blackwell GPU, a single unbroken conversation of 1,900,000 tokens across 9,359 turns, 14.5× the base model's trained context, with the resident memory flat from 50,000 tokens through to the final turn and total footprint ~1,370× at 1.9M tokens under a standard cache. The ratio grows with length and is only meaningful at a stated depth. Reproduced on 3 independent conversations. Your device-class footprint at each setting comes out of the pilot.
A ceiling that is a number in the spec, not a worst-case guess sized around the longest session anyone might have.
One budget setting moves the same build between a rack and a handset, so the second cut-down code path goes away.
No retraining and no recalibration. It runs on the model you already ship, unmodified.
The ceiling moves, not just the slope. Before we bounded the read, our own runs died at roughly 285,000 tokens: output collapsed to about a dozen tokens a turn and stopped, with the memory still flat. Nothing like that ceiling appears at any depth we have run since.
SCOPE: this page states direction. Published depth and footprint results were measured on a single consumer-grade NVIDIA Blackwell GPU; device-class numbers are projected from them. A paid pilot returns the measured footprint and the recall deltas at each setting, against your current quantized and windowed configuration.
A number chosen before you ship, stated in the spec, and true for every unit. Not a worst-case guess sized around the longest session anyone might have.
A sliding window reaches the same footprint number tomorrow by dropping the oldest tokens, which is where the instructions were, and where the session started. The whole history stays available here, and we can show the model still reading it at depth.
Recall measured at each setting you choose, against your current configuration, so the trade is a decision you make with numbers rather than an eviction policy you inherit.
Footprint at each budget setting, down to the minimum your target allows, against your current quantized configuration.
One-build parity: the same integration measured on a rack and on a handset.
Recall deltas at each setting, so the trade is a decision you make with numbers rather than a heuristic you inherit.
Read fidelity against a full-attention reference at each setting, so you can see what the compression costs before you choose where to sit.
SCOPE: this page states direction, not magnitude. Measured numbers for your workload come out of the pilot, with the configuration that produced them.
Bounded memory on its own is not hard. A sliding window gets the same footprint number tomorrow by discarding the beginning of the session. What is hard is holding the footprint flat while the whole session stays available, and showing the model is still reading the start of it at depth. That is the result we publish, reproduced across independent conversations, and it is what a pilot reproduces against your target.
The field is held to a budget you fix before you deploy. It runs on the model you already ship, with no retraining and no recalibration. Patent pending; the implementation stays private.
A scoped four-week pilot: you bring one workload and a memory budget, we return a measured comparison against your current cache: footprint, recall, and the configuration that produced both.