Agent Memory as Rate-Limited Filtering: Explicit State Outlasts Long Context Beyond a Reader-Dependent Horizon

Tianhao Guo; Chongyao Guo

cs.LGNov 2, 2026

Agent Memory as Rate-Limited Filtering: Explicit State Outlasts Long Context Beyond a Reader-Dependent Horizon

Authors: Tianhao Guo, Chongyao Guo

Abstract

Can a language model that reads the full history of an access log say whether a service may act now? On an executable benchmark of grants, withdrawals, reinstatements, expiries, groups and change windows under a known policy, scored on pairs of histories that differ only in the order or one field of the deciding events, open models of 7 to 32 billion parameters fall from 72 to 86 percent after eight or sixteen events to 48 to 55 percent after 256, while reasoning-trained 32B models reading the current state reach 96 and 98 percent. A reasoning model of 120 billion parameters trails the state by four and seven points at 256 and 512 events and by about ten at 1,024, so the length beyond which explicit state outlasts long context grows with the reader. We treat agent memory as recursive filtering. The decision depends on the history only through a state whose size is set by the number of tracked keys. A store holding fewer component records than the state forgets on a time scale set by its capacity, and a reader model predicts its accuracy within 0.02 on average in a registered test. Retaining log lines without regard to time order errs with probability approaching one half, a bound that is attained. A filter in which a model parses each line and an explicit rule applies the updates answers 80 to 89 percent at 256 events and beats relevance retrieval, model-kept ledgers, a reimplementation of StateMem and the Mem0 library. A retriever that selects at query time the lines the queried state depends on matches it at 256 events on the first domain, so what decides is selection by the state's dependencies, which the filter performs when writing, without the query. Applying parsed updates themselves, the models fall to 58 and 59 percent. A frozen replication on a second domain with fresh wording reproduces the horizon.

Figures & tables

eviction	$K$	$T$	$\overline{\|S\|}$	$f=0$	$0.125$	$0.25$	$0.375$	$0.5$	$0.625$	$0.75$	$0.875$	$1$
random	3	64	4.3	.000	.161	.161	.355	.450	.581	.709	.840	1
random	3	256	4.2	.000	.194	.194	.410	.455	.649	.716	.910	1
random	7	64	8.0	.000	.098	.203	.314	.457	.572	.708	.851	1
random	7	256	8.2	.000	.101	.208	.319	.468	.594	.724	.860	1
random	15	64	13.0	.000	.118	.212	.341	.470	.578	.713	.853	1
random	15	256	16.2	.000	.084	.178	.282	.417	.548	.688	.839	1

Table 1: Predicted factor

1-2\bar{P}_{e}(f)

of Proposition 22 on the controlled rate-sweep backgrounds (

K

background keys, horizon

T

40

pairs). Predicted balanced accuracy is

\frac{1}{2}+(\mathrm{BA}(1)-\frac{1}{2})

times the entry.

eviction	$K$	$T$	$\overline{\|S\|}$	$f=0$	$0.125$	$0.25$	$0.375$	$0.5$	$0.625$	$0.75$	$0.875$	$1$
store, random	3	64	4.2	.000	.025	.025	.106	.110	.322	.313	.768	.769
projection, random	3	64	4.2	.000	.207	.175	.400	.408	.630	.621	.898	.889
store, LRU	3	64	4.2	.000	.025	.025	.050	.050	.225	.225	.675	.675
projection, recency	3	64	4.2	.000	.025	.025	.075	.075	.225	.225	.675	.675
store, random	3	256	4.2	.000	.000	.000	.028	.029	.120	.118	.678	.685
projection, random	3	256	4.2	.000	.187	.177	.390	.387	.589	.613	.869	.859

Table 2: Factor

1-2\bar{P}_{e}

of the bounded recursive store of Definition 23 and of a read-time projection that keeps the same number

C=\mathrm{round}(f\cdot\overline{|S|})

of components, fixed per cell, on fresh seeds of the rate-sweep backgrounds (

40

pairs per cell,

50

runs of random eviction per episode). These are the registered predictions of the reader experiment.

	Executable ground truth	Supersession or revocation	Reinstatement after revocation	Source priority	Expiry	Paired order counterfactuals	Reader check with correct state	Query-unknown writing	Horizon as controlled variable	Real logs
StateMemBench [ 14 ]	✓	✓	$\times$	$\times$	–	$\times$	$\times$	✓	✓	$\times$
STALE [ 8 ]	$\times$	✓	$\times$	$\times$	$\times$	$\times$	$\times$	✓	$\times$	$\times$
Memora [ 64 ]	–	✓	–	$\times$	–	$\times$	$\times$	–	✓	$\times$
MemoryAgentBench [ 21 ]	$\times$	✓	$\times$	$\times$	$\times$	$\times$	$\times$	✓	✓	$\times$
MEMAUDIT [ 6 ]	✓	✓	$\times$	$\times$	–	$\times$	–	✓	$\times$	$\times$
OrgAccess [ 55 ]	$\times$	$\times$	$\times$	–	✓	$\times$	$\times$	$\times$	$\times$	$\times$

Table 3: Design features of benchmarks that test whether a model or memory system answers from the current state of an evolving history.

Panel of Figure 1 — Figure 1: Reading the full log (solid) against reading the replayed state (dashed). Each point is 120 episodes (60 pairs) from the test seed range. The state is a list of facts and never contains the answer.

	Qwen2.5-7B			Qwen2.5-14B			phi-4
Law	LOO	Extrap.	$\chi^{2}$	LOO	Extrap.	$\chi^{2}$	LOO	Extrap.	$\chi^{2}$
$\mathrm{AUC}-\frac{1}{2}\propto e^{-T/\tau}$	$.028/.047$	$-.029,-.017$	$2.2$	$.030/.055$	$-.063,-.010$	$2.4$	$.080/.138$	$-.061,-.154$	$16.9$
$\mathrm{AUC}=f+Ae^{-T/\tau}$	$.032/.047$	$-.029,-.017$	$1.5$	$.054/.108$	$-.000,+.108$	$2.4$	$.050/.093$	$-.019,-.066$	$3.4$
$d^{\prime}\propto e^{-T/\tau}$	$.030/.052$	$-.036,-.019$	$2.6$	$.035/.060$	$-.073,-.016$	$3.0$	$.088/.148$	$-.081,-.165$	$20.2$
$d^{\prime-2}=d_{0}^{\prime-2}+T/T_{c}$	$.048/.081$	$+.043,+.059$	$12.1$	$.042/.076$	$-.003,+.075$	$11.0$	$.046/.062$	$+.013,-.051$	$6.1$
$d^{\prime}\propto T^{-\alpha}$	$.071/.142$	$+.039,+.057$	$8.7$	$.059/.089$	$+.010,+.094$	$10.9$	$.045/.067$	$+.018,-.041$	$6.1$

Table 4: Decay laws fitted to the six-length AUC (raw log, test seeds). LOO: leave one length out, root mean square and maximum absolute error. Extrap.: fitted on

T\leq 64

, error at

T=128

and

T=256

\chi^{2}

on four degrees of freedom (three for the floor law).

d^{\prime}

-based laws use the equal-variance binormal link

\mathrm{AUC}=\Phi(d^{\prime}/\sqrt{2})

[ 17 ] .

Panel of Figure 2 — Figure 2: Chain counterfactuals with a budget of two lines and the exact reader. The dashed curve is the lower bound $\tfrac{1}{2}-b/(m-1)$ of Theorem 8 , valid for every reader of an order-oblivious memory. A rule that keeps a uniformly random subset of the key’s withdrawals attains it ( Proposition 10 ), and none of the plotted rules does.

		chain length $m$					blocked events $b^{\prime}$
$b$	rule	5	9	17	33	65	2	4	8	16
2	BM25	0.50	0.50	0.50	0.50	0.50	0.36	0.36	0.43	0.47
	key mention	0.38	0.44	0.48	0.49	0.48	0.17	0.35	0.36	0.43
	salience	0.50	0.50	0.50	0.50	0.50	0.50	0.50	0.50	0.50
	gradient	0.49	0.47	0.51	0.51	0.47	0.53	0.48	0.49	0.49
	recency	0.48	0.43	0.43	0.33	0.14	0.50	0.50	0.50	0.50

Table 5: Error of the exact reader on retained views. Chain columns follow Theorem 8 , blocked columns follow Proposition 13 .

	$B=128$				$B=256$				$B=512$
memory	32	64	128	256	32	64	128	256	32	64	128	256
replayed state (oracle)	0.94	0.64	0.55	0.53	0.94	0.85	0.71	0.60	0.94	0.90	0.90	0.79
last applied event per component	0.67	0.60	0.55	0.56	0.81	0.60	0.57	0.60	0.87	0.80	0.64	0.63
last event per key	0.60	0.66	0.57	0.55	0.79	0.62	0.49	0.60	0.85	0.74	0.58	0.60
LLM state ledger	0.68	0.55	0.62	0.51	0.66	0.67	0.58	0.50	–	–	–	–
LLM summary	0.58	0.56	0.52	0.54	0.70	0.62	0.58	0.53	–	–	–	–

Table 6: Recursive memories over 256 events, balanced accuracy at four checkpoints and three budgets. The state of the full benchmark needs about 500 tokens at the last checkpoint. With 40 pairs per cell the 95 percent bootstrap interval of each entry is about

\pm 0.1

. BM25 retrieval keeps the full archive and sees the query at read time, while every other memory is written without the query.

reader	memory	$t=32$	64	128	256
Qwen2.5-14B	parsed events + transition rule	0.94	0.90	0.88	0.80
	replayed state (oracle)	0.94	0.90	0.90	0.83
	LLM ledger, $B=256$	0.66	0.67	0.58	0.50
	LLM applies the parsed updates	–	0.72	–	0.59
	LLM fact store (add, update, delete), $B=512$	–	0.83	–	0.59
	BM25 retrieval, $B=512$	0.83	0.72	0.69	0.59

Table 7: Balanced accuracy over 256 events with the full background (80 streams, 40 pairs), read by three readers. The parsed filter uses Qwen2.5-14B as parser for both readers. ∗ The 768-token reasoning-trace reader reads the full log on the separate test streams of Section 4.1 , and gives no decision within the cap in 30 (Qwen) and 15 (phi-4) of 120 cases at 256 events, which count as errors. The 4096-token reader reads the same streams as the other rows, and reaches the cap without a decision in 5 (Qwen 14B), 0 (phi-4) and 9 (Qwen 32B) of 80 cases. The two rows in which the reader model maintains the state from the same parsed updates, or edits a fact store, were run at 64 and 256 events only. Qwen2.5-32B reads with the Qwen2.5-14B parses.

what is exact, what a model does	Qwen2.5-14B	phi-4
exact rule on the true events, no reader	1.00	1.00
exact rule on the parsed events, no reader (parsing)	0.98	0.98
reader on the true state (decoding)	0.83	0.86
reader on the state from parsed events (parsing and decoding)	0.80	0.84
reader on a table the model updates from the parsed events (transition)	0.59	0.58
reader on the full log with a 4,096-token trace (everything)	0.64	0.73

Table 8: Where the errors arise, first domain, 80 full-background streams at 256 events, balanced accuracy. The parser is Qwen2.5-14B in every row that parses. Each row makes one more stage a model’s job.

	full log		state from parsed events	tokens per decision, 256 events
reader	64	256	256	full log	state
QwQ-32B	0.90	0.85	0.98	7,052 + 2,513	745 + 787
R1-Distill-Qwen-32B	0.89	0.70	0.96	7,047 + 1,755	740 + 686

Table 9: Reasoning-trained readers, balanced accuracy on the 80 full-background streams. Tokens are prompt plus generated, averaged over requests.

reader	events	log	parsed events	state	minus log	full log	parsed state
		full	state from	true	state from parsed	tokens per decision
gpt-oss-120b	256	0.95	0.99	0.99	$+0.04$ $[0.01,0.08]$	6.1k + 1.6k	0.8k + 0.4k
gpt-oss-120b	1,024	0.87	0.99	0.98	$+0.12$ $[0.07,0.17]$	23.4k + 4.7k	0.9k + 0.4k
Qwen2.5-72B (4-bit)	256	0.72	0.94	0.95	$+0.22$ $[0.16,0.28]$	7.1k + 0.2k	0.8k + 0.1k
Qwen2.5-72B (4-bit)	1,024	0.55	0.92	0.92	$+0.37$ $[0.31,0.43]$	27.5k + 0.1k	0.8k + 0.1k
QwQ-32B	1,024	0.52	–	–	–	27.5k + 10.1k	–

Table 10: Stronger readers on 100 pairs of full-background streams at 256 and 1,024 events, balanced accuracy. The state from parsed events uses the Qwen2.5-14B parser and the exact rule. Differences are paired over pairs with 95% bootstrap intervals. Tokens are prompt plus generated, averaged over decisions.

	parsed lines	full log		state / parsed + rule		reasoning trace
reader	correct	64	256	64	256	256
Qwen2.5-14B	99.95%	0.54	0.51	0.76 / 0.76	0.68 / 0.68	0.58
phi-4	97.07%	0.59	0.50	0.84 / 0.85	0.76 / 0.76	0.68

Table 11: The second domain, balanced accuracy over 40 pairs per horizon. “State” is the domain’s own rendering of the true state, “parsed + rule” parses each line with the reader model and applies the domain author’s update function. The reasoning trace has up to 4096 tokens.

Panel of Figure 3 — Figure 3: Balanced accuracy against budget for $K=1,3,7,15$ background keys (blue, teal, orange, red), 64 events (solid) and 256 events (dashed). The threshold of the state memory moves with $K$ and stays put when the horizon quadruples. Recency never reaches 0.85.

Panel of Figure 4 — Figure 4: Budgeted filters on the controlled backgrounds with $K=15$ keys at $T=256$ events, 40 pairs per point. Lines are the predictions of Proposition 22 , fixed before the run except for the end point at $f=1$ . Points are the measured balanced accuracies.

memory	persistent store	raw archive	model calls per event	reader sees
full log	all lines	yes	0	all lines
BM25, recency and relevance	all lines	yes	0	top lines, 512 tokens
dependency retriever (R5-3)	all lines	yes	0	lines naming the query’s components
LLM ledger, summary	text, 256 tokens	no	1 per 16	the text
model-applied table (R2-B1)	table, at most 512 generated tokens	no	1 per 16	the table
Mem0-style fact store (R2-B3)	facts, unbounded	no	1 per 16	the facts, cut to 512 tokens

Table 12: What each memory keeps and what it costs. “0 or 1” model calls: none when the exact events are used, one parser call per event when they are parsed.

Method	Query-blind writing	Who decides supersession	Source authority	Persistent store bound	LLM calls per event
StateMem [ 14 ]	✓	LLM flags, newer turn wins	$\times$	none, superseded units kept	1
Mem0 [ 9 ]	✓	LLM (delete or update)	$\times$	none	$1+{}$ one per extracted fact
Zep/Graphiti [ 52 ]	✓	LLM detects, time resolves	$\times$	none, invalidated edges kept	several (extraction, resolution, temporal)
A-Mem [ 75 ]	✓	none, notes are never superseded	$\times$	none, one note per event	$2+{}$ one per linked neighbour
AriGraph [ 2 ]	✓	LLM selects outdated triplets	$\times$	none	2
MemAgent [ 76 ]	$\times$	LLM rewrites memory	$\times$	1024 tokens	1

Table 13: Design of memory methods for evolving state. Calls are LLM calls made while writing the memory, per event (turn, message, observation, or chunk).

Appendix figures & tables3 assets

Supplementary material from the paper’s appendix.

Appendix

		chain length $m$					blocked events $b^{\prime}$
$b$	rule	5	9	17	33	65	2	4	8	16
2	BM25	0.49	0.50	0.50	0.50	0.50	0.34	0.38	0.43	0.47
	key mention	0.40	0.44	0.48	0.49	0.48	0.30	0.39	0.43	0.46
	salience	0.49	0.50	0.51	0.50	0.50	0.44	0.48	0.49	0.49
	gradient	0.47	0.45	0.51	0.53	0.48	0.51	0.48	0.50	0.52
	recency	0.48	0.43	0.43	0.33	0.14	0.50	0.51	0.50	0.50

Appendix

Table 14: Error of Qwen2.5-14B reading the retained views of Section 4.3 . The bound rows refer to every reader of an order-oblivious memory.

Benchmark	Evidence
StateMemBench [ 14 ]	Answers come from replaying each symbolic program through a deterministic evaluator. Scenarios contain value updates, scoped exceptions, commitments, and retractions. Restoration of a retracted item, source authority, order-only minimal pairs, and an answerer given the correct state are not described. A scoped override that may lapse leaves expiry ambiguous. Memory stores are built before the probe. Set A and Set B share the probe structure and differ in length. Programs are rendered into dialogue by an LLM, and public data supplies vocabulary only.
STALE [ 8 ]	Scenarios are generated by an LLM, edited by experts, and graded by an LLM judge. Each instance contains one implicit conflict that invalidates an earlier belief, and the paper limits itself to one-shot transitions, so no state is restored. Source authority, expiry, order pairs, and a correct-state control are not described. Frameworks ingest the dialogue before probing. Contexts reach 150K tokens, but length is not an experimental factor.
Memora [ 64 ]	Questions derive from simulated memory traces and are graded by LLM judges, so programmatic ground truth is ambiguous. The simulator introduces, updates, and invalidates entities. Users may reverse earlier statements, which leaves reinstatement ambiguous, and temporal constraints leave expiry ambiguous. Source authority, order pairs, and an oracle-memory condition are not described, and whether memory is written before the query is not stated. Weekly, monthly, and quarterly horizons are compared. Conversations are simulated.
MemoryAgentBench [ 21 ]	The selective-forgetting data reuse counterfactual edit pairs from MQuAKE, with the new fact placed after the original. The only conflict rule is to prefer later information. Reinstatement, expiry, order-swapped pairs, and a correct-state control are not described. Chunks are ingested incrementally before questions. Contexts of 6K, 32K, 64K, and 262K tokens are used. Inputs are reconstructed from existing long-context datasets to simulate multi-turn interaction.
MEMAUDIT [ 6 ]	Package optima are computed exactly by branch-and-bound with MILP certification. Tombstones mark superseded or deleted facts. Reinstatement, source priority, and order pairs are not described. A temporal-interval distribution leaves expiry ambiguous, and a reader audit in the appendix is not a correct-state control. Memory is written before future queries are known. Sweeps vary the budget, not the stream length. The natural package is a LongMemEval-style slice built with an LLM.
OrgAccess [ 55 ]	Expected responses are largely LLM-generated and human-reviewed. There are no grant-then-revoke sequences or reinstatement. Competing directives are mentioned without a defined priority order. Expiry dates and temporal access limits appear in examples. Order pairs, a correct-state control, and memory writing are not described. The controlled variable is the number of concurrent permissions (1, 3, or 5).

Appendix

Table 15: Evidence for each cell of Table 3 , taken from each paper’s description of its own design.

Test	Registered criterion	Outcome
E0	Gradient retention beats longest-line and BM25 retention on five hand-written scenarios	Tied with longest line, demoted
E1 (gate 4)	Rank-one or query-averaged Fisher quadratic predicts KL at least 10% better than the best first-order predictor	Failed, mechanism claim terminated
E2-0, E2-0b	Full-context reader recalls both classes and reinstatements at 0.90 at 64 events	Failed for Qwen 7B and 14B
X1a	Reader AUC decreases with $T$	Holds for all three readers
X1b	Neutral persona changes balanced accuracy at 64 events by 0.10 or more	No ( $+0.008$ )
X2	State reading at 0.95 or above at every $T$ and flat in $T$	Fails: below 0.95 for all readers; for phi-4 no detectable dependence on $T$ (no equivalence test)

Appendix

Table 20

State Tracking in Language Models

See all 8 papers

Computation, Not Memory: Chain-of-Thought and State Tracking in LLM Agents
Oct 19, 2026Pedram Mouseli, Massieh MoayediCoT Reasoning Multi-Turn Language Model Reasoning
University of Toronto
Mergeable Model-Side Aggregation States for Long-Context Language Models
Jul 29, 2026Dachuan Song, Junyu Yin, Zechen Hu +1Numerical Reasoning in Language Models Long-Context Language Modeling
Department of Electrical and Computer Engineering, George Mason University, Fairfax, VA, USA · Department of Computer Science, George Mason University, Fairfax, VA, USA
Learning to Remember: End-to-End Training of Memory Agents for Long-Context Reasoning
Feb 13, 2026Kehao Zhang, Shangtong Gui, Sheng Yang +2Persistent Memory for Language Models Long-Context Inference
1Key Laboratory of Intelligent Information Processing, Institute of Computing Technology, Chinese Academy of Sciences (ICT/CAS) · University of Chinese Academy of Sciences, Beijing, China · 4Li Auto Inc. +1

Oct 19, 2026J/K move · Enter open · S save

Computation, Not Memory: Chain-of-Thought and State Tracking in LLM Agents

Pedram Mouseli, Massieh Moayedi

University of Toronto

CoT Reasoning Multi-Turn Language Model Reasoning Faithfulness of Language Model Reasoning

Open paper AskPDF arXiv

Language-model agents often reason before they act, and the value of monitoring that reasoning depends on how it relates to their actions. We ask how an agent's actions depend on its reasoning when the correct action depends on a changing state. In a small file-system task, background events announce which file's lock has been toggled but not its new value. The agent therefore has to reconstruct the current locks from its history before it can move files safely. With Qwen3-8B and Qwen3.5-9B, we separate two roles of reasoning: generating it before each action, and retaining earlier reasoning in the prompt. Most of the reduction in lock-violating commands comes from reasoning written at the moment of action. Retaining earlier reasoning adds little to rule-following, although it helps one model complete the task. The benefit depends on what the reasoning says. Filler text, reasoning written for another history and an accurate table of the state do not reproduce it. When we give the agent reasoning written for a history that differs in one lock value, the agent acts on that reasoning even against its own history. Without reasoning, linear probes recover the state from the model's activations about as well as a text classifier recovers it from the transcript. However, decoding accuracy does not predict which interventions change the agent's actions. In this setting, the benefit of reasoning for rule-following comes mainly from generating it at each step. The state that can be decoded without reasoning is a limited guide to how the agent acts.

Abstract

State Tracking in Language Models

Explore similar work

Computation, Not Memory: Chain-of-Thought and State Tracking in LLM Agents

Mergeable Model-Side Aggregation States for Long-Context Language Models

Learning to Remember: End-to-End Training of Memory Agents for Long-Context Reasoning