A robot is not short of state. SLAM keeps a metric map, the planner keeps task state, the safety layer keeps its interlocks, and perception keeps a ring buffer measured in seconds. Each is bounded and well engineered, and none of them is episodic memory the reasoning layer can read. A bounded field gives the robot one working memory of the deployment: what it has seen, what it was asked, and what has already happened.
A robot has plenty of state. SLAM maintains a metric map, the behavior tree or planner maintains task state, the safety layer maintains its interlocks, and the perception stack maintains a ring buffer sized in seconds. Every one of these is bounded, well engineered, and holds a different kind of memory in a format the others were never meant to read.
The reasoning layer on top gets none of it except as a serialised snapshot squeezed into a prompt. A metric map is geometry, not a memory of what happened in the room. A ring buffer measured in seconds cannot answer what changed since this morning. Task state records the step, not the reason for it. So the policy that has to reason across all of it works from a context window that fills during a long shift and then slides, and the first thing a sliding window has no reason to keep is the operator instruction that was stated once at the start.
SCOPE: schematic. The measured on-robot footprint comes out of the pilot, for your compute and sensing platform.
SGF is not a safety system and is not in your safety path. Interlocks belong in the deterministic layer that already holds them, where they can be verified and certified. What a bounded field changes is that the reasoning layer stops operating without a memory of the deployment it is reasoning about.
A multi-day deployment produces tens of millions of tokens of perception summaries, task events, and operator instruction. What decides whether the reasoning layer can hold it is not how large a window the platform can afford, but whether the memory grows as the shift does.
SCOPE: measured on a single consumer-grade NVIDIA Blackwell GPU, on a single unbroken session 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 runs. Your on-robot footprint is projected from these results and measured against your compute and sensing platform in the pilot.
Episodic memory of the deployment, alongside the metric map that records geometry but not events.
The mission and the instructions behind it stay resident for the length of the deployment, rather than sliding out of the window while the task is still running.
A fixed on-robot footprint chosen at build time, so a long shift does not depend on a context window that fills and slides.
The reasoning context stops hitting a ceiling mid-shift. 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. A long shift passes that. Nothing like it appears at any depth we have run since.
SCOPE: on-robot behavior depends on your compute and sensing stack, and is projected from results measured on a single consumer-grade NVIDIA Blackwell GPU. A paid pilot returns the measured footprint for your platform, at the budget setting you choose. Our depth results were produced on a deliberately small research model, chosen to stress the memory rather than flatter the output. Treat them as a floor.
What the robot has seen, been asked, and already done, carried as one resident structure the reasoning layer can actually read, instead of four subsystem stores in four formats none of the others can parse.
Live sensor and task context kept literal over an instruction block the field cannot overwrite, so the immediate step stays sharp without losing the deployment behind it.
On-robot footprint held flat across a long deployment, inside your compute and power budget.
Operator-instruction residency under sustained load, where a sliding window would have dropped it.
Recall on events from earlier in the shift, which the metric map and the ring buffer cannot answer today.
Read fidelity against a full-attention reference, 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 reaches the same footprint number tomorrow by dropping the oldest turns, and on a long shift, the oldest turns are the reason the robot is doing any of this. What is hard is holding the footprint flat while the whole deployment stays available, and showing the model is still reading the start of it at depth. That is the result we publish, reproduced across independent runs, and it is what a pilot reproduces on your platform.
The field is held to a budget you fix before you deploy. It runs on the model the robot already carries, 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.