A coding agent already manages context: embedding search over the repository, compaction when the transcript nears the window limit, and re-reading files when either one falls short. Compaction is where the plan dies, because the constraint given in the first minute is exactly what a summariser judges redundant an hour later. A bounded field holds the plan for the length of the run and pins every identifier verbatim.
A coding agent today manages context with three mechanisms. Embedding search over the repository pulls in the chunks that look similar to the current query. Compaction summarises the transcript once it approaches the window limit, replacing the run so far with a shorter account of it. And when either falls short, the agent re-reads the file, paying for the same tokens a second time.
Each of them loses precisely what a long run depends on. Embedding search is good at finding a function by description and bad at the cross-file relationship that made the change necessary in the first place. Compaction is where the plan dies: the constraint stated in the first minute is exactly the kind of detail a summariser judges redundant an hour later. Re-reading is not recall, it is repurchase, and it still leaves the agent reasoning about a file it no longer remembers deciding anything about.
So the run drifts rather than fails. The agent re-derives a choice it already made, quietly violates a constraint it was given at the start, and misremembers a symbol it read a thousand tokens ago. Nothing raises an error. The output just stops matching the task.
SCOPE: schematic. Measured footprint and recall over a long run come out of the pilot, against your own workloads.
A multi-hour run over a large repository generates tens of millions of tokens of transcript and file content. What decides whether an agent can hold it is not how large a window you buy, but whether the memory grows as the run does.
SCOPE: measured on a single unbroken session of 1,900,000 tokens across 9,359 turns, 14.5× the base model's trained context, carried with no compaction pass, 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. No degradation trend was observed at that depth, across 3 independent runs. Your reachable context and the configuration that produced it come out of the pilot.
The plan and the constraints held for the length of the run, instead of being summarised away when the transcript hits the window limit.
Every file path, symbol, and identifier pinned verbatim, so the agent stops re-reading files it has already paid for.
A fixed ceiling on memory, so a multi-hour run has planned capacity rather than a compaction loop and an open bill.
The run stops hitting a ceiling mid-flight. 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 multi-hour run over a large repository passes that inside the first stretch. Nothing like it appears at any depth we have run since.
SCOPE: behavior on long runs depends on your task shape and field budget. A paid pilot returns footprint and recall measured against your current retrieval and compaction configuration. Our published depth results were produced on a deliberately small research model, chosen to stress the memory rather than flatter the output. A larger model abuses it less. Treat them as a floor.
The plan, the constraints, and everything the agent has already read carried as one resident structure rather than replaced by a shorter account of itself. An hour in, it is working from decisions rather than re-deriving them.
The immediate work kept literal over an instruction block the field cannot overwrite, so the step in front of the agent stays sharp without a compaction pass evicting the plan behind it.
Identifier recall on file paths and symbols deep into a long run, against your current retrieval and compaction setup.
Constraint adherence at the end of a multi-hour run, where compaction would have summarised the original instruction away.
Footprint held to a fixed ceiling across the run, next to the tokens your current stack spends on compaction and re-reads.
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 gets the same footprint number tomorrow by dropping the oldest turns, and in a long run, the oldest turns are the plan. What is hard is holding the footprint flat while the whole run 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 workload.
The field is held to a budget you fix before you deploy. It runs on the model the agent already uses, 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.