A transformer holds every past token as key and value tensors. The cache grows with the conversation, memory tracks length rather than usefulness, and capacity planning becomes a guess. Semantic Gravity Fields replace that cache with a bounded field: fixed footprint, chosen before deployment.
Attention needs every prior key and value tensor. Each new token appends another slice, so the cache scales linearly with context length, multiplied by layers, heads, and batch size.
The workarounds all discard: sliding windows drop the oldest turns, summarisation compresses lossily and irreversibly, retrieval re-reads text the model already saw. Each one trades recall for headroom, and none of them gives you a ceiling you can plan around.
SCOPE: schematic. Real footprint depends on model dimensions, layer count, batch size, and precision.
A running representation of the entire conversation, compressed into a fixed number of semantic centers. It never grows past its budget — and the model keeps reading all of it, so a topic raised at the very start stays available a million-plus tokens later instead of scrolling out of reach.
The details that have to be exact — names, identifiers, quantities, codes — held word for word and never compressed. The values a wrong answer would turn into a support ticket stay precise no matter how long the conversation runs.
The most recent turns, word for word, over a protected instruction block. The window rolls forward as the conversation moves; the instructions stay fixed.
An optional layer you can load into a conversation — a saved persona, profile, or knowledge set: a support team's policies, or what an assistant should already know about you. It shapes how the model responds, sits alongside the live memory without spending its budget, and can be updated at any time.
One parameter moves the field between lossless and minimal. Everything else about the integration stays the same, so the same build can ship to a datacenter and to a headset.
Every distinction preserved. Highest footprint.
Merging on redundancy only.
Aggressive merging. Smallest field, gist-level recall.
SCOPE: the dial is qualitative here. Pilot partners receive the parameter, its measured footprint curve, and the recall deltas at each setting.
SGF operates on the memory path, not the weights. The model you serve today is the model you keep serving.
Quantization, paged attention, batching, and speculative decoding all still apply. SGF changes what is stored, not how it is computed.
A memory interface behind your serving layer. Write the field, read the field, hand the model its context as usual.
How centers are formed, scored, and merged is the invention, and it is patent-pending rather than published. What we do publish is everything a buyer needs to judge it: the footprint under a stated configuration, the recall deltas against the same workload on a standard cache, the failure modes we have found, and the conditions where SGF is the wrong tool.
Footprint, recall, latency, and the configuration behind each number.
Where SGF underperforms: short contexts, single-turn prompts, workloads dominated by retrieval.
Parameter-level behavior, integration internals, and the pilot report for your workload.
Center formation, merge scoring, and the pin policy.
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.