Originally published at Trida AI.
Ask an operations agent a plain question late in a long job — who owns this incident right now — and you can watch a particular failure arrive. The history is all there. Every handover, every status change, every correction sits in the context, in order. The agent has, in the literal sense, read everything. It answers with an owner from three changes ago, fluently and without hedging.
The usual response is to reach for a bigger window, or to summarise harder. Both treat the problem as a storage problem. It isn't one. The model was never short of information. It was asked to recompute the present from the past, on every turn, by scanning a pile of changes and working out which ones still stand. That recomputation is the weak step, and it gets weaker the more changes pile up.
A benchmark for exactly that weak step
State tracking sounds like a bookkeeping chore, and that is why it is a good test: either the final value is right or it isn't. StateBench benchmark from Petty, Merrill and Sabharwal feeds a model a long sequence of assignments and asks for the final state. The tasks come in four tiers. The easy ones set a value once, or replace it outright. The hard ones build on current values: in one, a variable updates from its own current value; in the hardest, a variable takes another variable's current value, or two variables swap.
Production work lives in the hard tiers. Owners swap shifts. A price is set as "the previous quote plus the surcharge." An approver is whoever the last approver delegated to. On the easy tiers the frontier models tested do well. On the soluble and general tiers, the paper reports, accuracy falls to at-chance levels once the sequences reach between 10,000 and 64,000 tokens, and its abstract is blunt about the overall result: none of the pretrained models tested robustly solves even the soluble tier. A working session with chatty tool output reaches 10,000 tokens quickly. The history an agent carries into an afternoon question is already in the range where re-deriving state from it stops being reliable.
Two cautions belong with that result, and we will keep them. StateBench is synthetic: fixed variable sets, pure assignment sequences, no retrieval or tools to check against. A real agent can sometimes look a value up instead of remembering it. What the benchmark isolates is the default most systems actually ship: the transcript is the memory, and the model is the bookkeeper. That default is what fails.
Keep the record somewhere else
The fix is older than language models. Databases learned long ago to separate the log from the current state: the log records every change, and a table holds what is true now, maintained as each change lands. An agent's memory wants the same split.
Concretely: every change to something the agent tracks, an owner, a status, a date, an amount, is applied to a state ledger by ordinary code at the moment it happens. The code resolves the swap, the override and the delegation when the update arrives, while the update is unambiguous and its source is known. The ledger stores one current record per thing: the value, when it last changed, and where the change came from. The full log stays in storage, available for audit and for the occasional deep look, but it does not ride along in the prompt.
What the model receives on each turn is the task, the current ledger record, and the latest change if one just landed. That is a small, stable input. The question "who owns this now" becomes a read, not a reconstruction.
What the model sees on each turn, and what stays outside the window: the log and the ledger are kept by code, and the assembler copies current values in.
This is not summarisation wearing a new hat. A summary is prose a model wrote about the past, and it inherits the model's errors at the moment it was written; a wrong owner, once summarised in, is very hard to evict. A ledger update is a field assignment made by code that either applied the change or did not. The two fail differently, and the ledger's failure is the one you can test: replay the log, compare the record, find the update that landed wrong.
There is supporting evidence that the model loses little by working this way. A November preprint from Belcak and colleagues, You don't need long context, compacted agent histories aggressively across long-horizon and long-input tasks and found that frontier models sacrificed little to no accuracy at short contexts — in its most extreme setting, on long-horizon software tasks, one action per fresh context, carrying only a written state forward. It also prices the alternative: on the frontier open-weight models it measured, generating later tokens cost up to seven times more than generating early ones. A long transcript is not a free insurance policy. You pay for it on every turn, in money and in the attention it dilutes. Anthropic's guidance on effective context engineering makes the same point from the design side: context is a finite resource, and the aim is the smallest set of high-signal tokens that does the job. A current record is about as high-signal as tokens get.
One incident, worked through
Take an example incident record an agent is helping to run. Six changes land over a morning. Two are plain replacements. One is a swap, the shape StateBench's hard tiers are built from: at 10:40 the owners of this incident and a neighbouring one are exchanged, so the correct owner afterwards is a name that appears nowhere in this incident's own early history as an owner at all.
One incident, six changes, and the current record the ledger holds at the end. The example is illustrative; the swap at 10:40 is the change a transcript reader has to resolve at question time.
With a ledger, the 11:15 question about ownership reads the record: owner, status, severity, customer notified, each with the time it last changed. With a transcript, the same question asks the model to replay six changes, notice that change five reassigns ownership by reference to another incident, and discard the two earlier owners. That is precisely the operation the benchmark shows degrading. It degrades silently, because the discarded owner still reads like a plausible answer.
Where the ledger earns nothing
Honesty about the limits, because there are real ones. Some questions are about the past, not the present: why did the severity change, who approved the workaround, what did we tell the customer the first time. A ledger of current values cannot answer those, and should not pretend to. It needs the log beside it, and the agent needs a way to go and read the log selectively when a question is historical. The design rule is about the default, not a ban: current-state questions get the record; history questions get a targeted look at the log, not the whole log by reflex.
The ledger also moves the failure rather than deleting it. If the code that applies updates has a bug, a swap applied in the wrong direction, a delegation rule misread, the record is wrong in a way the model will repeat with total confidence, because now the wrong value arrives labelled as current. A transcript at least contains the evidence to catch it. So the ledger needs the boring machinery any system of record needs: replay tests against the log, a provenance field on every value so a human can check one field without trusting the rest, and a way to rebuild the record from the log when something smells off. Skip those, and you have built a faster way to be wrong.
And some work has no stable state worth keeping: a one-shot drafting task, a short research run, anything that ends before its facts start changing. A ledger there is ceremony. The pattern pays when a job lives long enough for its facts to be revised — which, in deployment work, is most jobs that matter.
Work with us
If your agents answer present-tense questions from an ever-growing transcript, the failure will not announce itself as a memory problem; it will show up as confident, stale answers. Send us the workflow through Trida AI's intake and we will look first at where its state actually lives.


Top comments (0)