betaFeedback

WorksComputer Science

RegimeCouncil: Paired-Evidence Routing For Memory Conflict Governance In LLM Agents

Abstract

Language agents rely on long-term memory to personalize responses across extended interactions, yet stored facts quietly go stale as the world changes, and an agent often learns that using memory hurt only through delayed feedback after acting on an outdated record. Before the memory store is updated, how far should that negative feedback propagate: should it suppress memory use only on future queries for that same fact (a local policy), or also across other stored facts (a global policy)? Existing memory systems implicitly fix one of these two sharing scopes at design time. We formulate this online scope choice under hidden validity and delayed feedback as memory conflict governance, and prove that neither fixed policy is sufficient on its own. We then propose RegimeCouncil, a lightweight paired-evidence router that retains both scopes as advisors and arbitrates between them online without retraining the LLM. Using revealed comparisons between answering with memory and answering without memory (the no-memory anchor), a Local Advisor tracks the latest outcome on the queried fact alone, while a Global Advisor pools recent outcomes across all stored facts. A Meta Governor follows the Local Advisor by default to avoid cross-fact interference and switches to the Global Advisor only when global pooling accumulates a strictly positive recent utility margin, guaranteeing finite-time switching under delayed feedback. Across LongMemEval update streams and real-world historical drift on TempLAMA and TAQA with Qwen3-30B-A3B and GPT-4o, RegimeCouncil outperforms the better fixed-scope policy by 5.2-7.3 points on primary disagreement episodes and across all 30 held-out settings, while ablations show that removing any of its three modules reduces accuracy by 2-7 points.

Introduction

Language agents rely on long-term memory to personalize responses across extended interactions, yet stored facts quietly go stale as the world changes. Suppose an agent records “the user lives in Beijing” and later the user moves to Shanghai without explicitly deleting that old record. On a subsequent query—such as “Where do I live?” or a request for nearby restaurants—the stored Beijing record still matches the prompt, so the agent discovers that using memory hurt only after delayed feedback arrives through a user complaint, a correction, or a failed task. Such silent staleness is routine in personal and enterprise assistants that track evolving user attributes, preferences, and policies over months (Maharana et al., 2024; Wu et al., 2025). When the updated fact (e.g., “Shanghai”) is known and written into the memory store immediately, updating that single record is straightforward. The open question is how the agent should govern memory use before the store is updated: once delayed feedback reveals that using memory hurt on one fact, should it suppress memory use only on future queries for that same fact, or also across other stored facts (Figure 1)? For instance, updates may be batched asynchronously, or feedback may flag “Beijing” as wrong without naming the new city.

Three regimes of influence scale

Figure 1. Three regimes of influence scale, i.e., the propagation scope of delayed feedback: (1) a single fact when drift is isolated; (2) a store-wide use-threshold after a cluster of corrections; and (3) a cold-start prior from pooled outcomes when the queried fact has no local history.

Existing LLM memory systems have made substantial progress on deciding what to store, retrieve, retain, or compress (Packer et al., 2023; Chhikara et al., 2025; Rasmussen et al., 2025; Zhou et al., 2026; Zhang et al., 2026; Kang et al., [12] When adapting memory use from past outcomes, however, prior designs implicitly fix one of two opposite sharing scopes, which we define as a local policy and a global policy. A local policy confines each outcome to the single fact that was queried, as in per-item utility updates (Zhang et al., 2026) or per-record updates [3] (Rasmussen et al. 2025): it avoids cross-fact interference when facts change independently, but offers no guidance on unseen or rarely queried facts and cannot spread a warning when a cluster of facts goes stale together. A global policy, by contrast, pools recent outcomes across all stored facts through a shared confidence gate or recency window: it transfers evidence to fresh facts and reacts quickly to store-wide shifts, but allows errors on a few volatile facts to suppress valid, stable ones. Because neither fixed scope dominates over time, an agent must choose between them online—a sequential decision problem under hidden validity and delayed feedback that we term memory conflict governance.

To address this problem, we propose RegimeCouncil, a lightweight paired-evidence router that retains both sharing scopes as advisors and arbitrates between them online without retraining the underlying LLM. Whenever a past interaction’s outcome is revealed, RegimeCouncil compares the utility of answering with memory against answering without memory (the no-memory anchor), isolating whether memory itself helped or hurt regardless of question difficulty. From these paired comparisons, a Local Advisor tracks the latest outcome on the queried fact alone, while a Global Advisor pools recent outcomes across all stored facts. Because an unchanged fact is best judged by its own history, a Meta Governor follows the Local Advisor by default and switches to the Global Advisor only when global pooling has accumulated a strictly positive utility margin over recent revealed interactions. Three theoretical results motivate each part of this design: first, when staleness is not visible in the current prompt, no decision rule based solely on the prompt can avoid a constant error rate, whereas replaying delayed per-fact outcomes drives average regret to zero on revisited facts (Proposition 1); second, neither the local policy nor the global policy is sufficient on its own, as each suffers linear regret in a natural regime where the other succeeds (Proposition 2); and third, our margin-based Meta Governor is guaranteed to switch to the better advisor within a bounded number of steps after a shift, even under delayed feedback (Proposition 3).

Our main contributions are threefold: (1) Problem formulation: We formalize memory conflict governance, characterizing when delayed feedback about stale memories should stay confined to one fact versus propagate across the memory store. (2) Method and theory: We introduce RegimeCouncil, an online router pairing a Local Advisor, a Global Advisor, and an asymmetric Meta Governor, with regret-floor, scale-insufficiency, and finite-time switching guarantees (Propositions 1–3). (3) Empirical validation: Across LongMemEval update streams (16- and 54-fact pools) and real-world historical drift on TempLAMA and TAQA with Qwen3-30B-A3B and GPT-4o, RegimeCouncil outperforms the better fixed-scope policy by 5.2–7.3 points on primary disagreement episodes (and across all 30 held-out settings), while removing any module lowers accuracy by 2–7 points.

Related Work

Our work connects long-term memory in LLM agents with online decision making under non-stationarity and partial observability, focusing on how far delayed feedback should propagate across stored facts.

Long-term agent memory and knowledge updates. Recent agent memory frameworks extend interaction beyond the context window through tiered storage, retrieval, and temporal knowledge graphs ([3] (Park et al. 2023; Packer et al. 2023; Rasmussen et al. 2025)), learned memory compression or item-level utility reweighting ((Zhou et al., 2026; Zhang et al., 2026)), and budgeted retention under observability and token constraints ([12 a]). Corresponding benchmarks—including LoCoMo, LongMemEval, and MemoryAgentBench—show that handling knowledge updates and outdated facts remains a major bottleneck over multi-session dialogues ([8] (Maharana et al. 2024; Wu et al. 2025)). However, existing benchmarks typically expose explicit timestamps in the prompt so a recency-aware reader can identify the latest write directly, and existing memory architectures fix their feedback scope at design time—updating either a single accessed item in isolation ([3] (Zhang et al. 2026; Rasmussen et al. 2025)) or a shared global retrieval gate. In contrast, we study the unobservable regime where the prompt does not reveal whether a retrieved fact has gone stale, and dynamically arbitrate between per-fact and store-wide feedback scopes before the store is updated.

Non-stationarity and sharing scope. Classical concept-drift detection, non-stationary bandits, and strongly adaptive online learners adapt to changing environments by discounting older observations over a single data stream ([6, 1, 2, 4, 10]). Long-term memory introduces a structured, multi-fact form of non-stationarity: stored facts may drift independently (where pooling across facts causes interference) or become stale in correlated clusters (where pooling accelerates adaptation). Rather than tuning a single forgetting window over one stream, RegimeCouncil maintains both a fact-specific window and a store-wide pooled window over paired outcomes, choosing online which scope should govern the current decision.

Expert advice and partial observability. Tracking the best expert provides general rules for switching among predictors over time ([7, 4]), while Partially Observable Markov Decision Processes (POMDPs) formalize sequential action when latent state is hidden from the current observation ([13, 9]). Generic expert-tracking algorithms treat experts symmetrically and update from bandit or full-information losses without exploiting relational structure among queries. RegimeCouncil instead leverages two domain-specific properties of agent memory: first, pairing memory against a no-memory anchor cancels per-query difficulty variance and allows both advisors to be scored on every revealed interaction; second, because a fact’s own recent outcome is unbiased while cross-fact pooling can introduce interference, our Meta Governor applies an asymmetric margin rule that defaults to the Local Advisor and grants Global overrides only when pooling demonstrates strictly positive recent net gain.

Method

RegimeCouncil addresses memory conflict governance through one paired-evidence signal and three lightweight modules: a Local Advisor and a Global Advisor that propose memory actions at opposite sharing scopes, arbitrated online by a Meta Governor (Figure 2).

Overview of RegimeCouncil

Figure 2. Overview of RegimeCouncil. (1) At step tt, a query arrives for key ktk_t; whether the stored record is valid is hidden from the prompt, and the router chooses between injecting memory (at=1a_t=1) and using the no-memory anchor (at=0a_t=0). (2) The Global Advisor pools recent paired outcomes across all keys, whereas the Local Advisor reads only the latest revealed outcome on key ktk_t. (3) The Meta Governor compares what each advisor would have scored over recent revealed episodes, follows Local by default, and switches to Global only when At>0A_t > 0. (4) After a delay of at most τ\tau steps, the episode’s paired outcome arrives and updates both advisors and the governor.

Problem formulation and notation

An agent maintains a long-term memory store of KK tracked facts, indexed by keys k∈{1,…,K}k \in\{1,\ldots,K\} (for example, user_city or current_employer). At each sequential step t∈{1,…,T}t \in\{1,\ldots,T\}, a query arrives for key kt∈{1,…,K}k_t \in\{1,\ldots,K\} with decision-time observation zt∈Zz_t \in\mathcal{Z} (the user prompt together with the retrieved memory text). Whether the stored record for ktk_t is currently stale or valid is governed by a latent state rt∈{0,1}r_t \in\{0,1\} (the regime) that is hidden from ztz_t. In our running example, user_city still stores “Beijing” after the user has moved to Shanghai: ztz_t matches the query under both regimes, while the optimal memory action has reversed (a collision).

At step tt, the router chooses a binary action at∈A={0,1}a_t \in\mathcal{A} = \{0,1\}, where at=1a_t = 1 injects the stored memory record for ktk_t and at=0a_t = 0 withholds memory to answer with the base model alone (the no-memory anchor), obtaining episode utility ut∈[0,1]u_t \in[0,1]. Outcomes arrive with a bounded delay of at most τ≥1\tau\ge1 steps: at step tt, the agent has access to history ht=(z1:t,a1:t−1,Ft)h_t = (z_{1:t}, a_{1:t-1}, \mathcal{F}_t), where Ft\mathcal{F}_t contains the revealed outcomes of all completed episodes s≤t−τs \le t-\tau (and any earlier arrivals). The goal is to maximize expected cumulative utility JT(P)=EP[∑t=1Tut]J_T(P) = \mathbb{E}_P\left[\sum_{t=1}^{T} u_t\right].

Assumption 1 (Decision-time unobservability). On colliding contexts, the latent validity state rtr_t is not a function of the current observation ztz_t.

Assumption 2 (Delayed hindsight recoverability). An outcome generated at step ss is revealed by step s+τs+\tau, and the revealed comparison between using and withholding memory has the sign of the regime-optimal action on that episode.

Assumption 3 (Paired evaluation). Once an episode’s feedback arrives, its utility can be evaluated both with memory (us,memu_{s,\mathrm{mem}}) and without memory (us,0u_{s,0}).

These three assumptions capture how staleness surfaces in deployed assistants. Assumption 1 reflects silent updates: when a user moves or changes a preference without explicitly editing memory, the prompt ztz_t lacks the bit indicating whether the stored record is still current. Assumption 2 reflects delayed downstream supervision—such as a user complaint, a later correction, or a failed tool call—arriving within τ\tau steps. Assumption 3 enables direct comparison between using and withholding memory on the same query (either from offline evaluation logs or by checking an asynchronous background no-memory response against the same feedback signal; we also evaluate pure executed-action-only bandit feedback in Appendix E.3).

To formalize why delayed outcome history is indispensable, let u(a;z,r)=E[ut∣at=a,zt=z,rt=r]u(a;z,r) = \mathbb{E}[u_t \mid a_t = a, z_t = z, r_t = r] denote mean utility and ρr(a;z)=max⁡a′u(a′;z,r)−u(a;z,r)≥0\rho_r(a;z) = \max_{a'} u(a';z,r) - u(a;z,r) \ge0 its optimality gap under regime rr. A context zz is Δ\Delta-colliding if it is visited under both regimes with min⁡a[ρ0(a;z)+ρ1(a;z)]≥Δ\min_a[\rho_0(a;z) + \rho_1(a;z)] \ge\Delta. For any fixed context–regime sequence (zt,rt)(z_t,r_t) with colliding-visit frequency ρ\rho and visit-weighted minority-regime share q∈(0,12]q \in(0,\frac{1}{2}], we compare stationary observation-only policies Πobs={π:at∼π(⋅∣zt)}\Pi_{\mathrm{obs}} = \{\pi: a_t \sim\pi(\cdot\mid z_t)\} against history-aware policies Πhist={π:at∼π(⋅∣ht)}\Pi_{\mathrm{hist}} = \{\pi: a_t \sim\pi(\cdot\mid h_t)\} relative to a regime-aware oracle.

Proposition 1 (Observation floor and history separation). (i) Floor. Under Assumption 1 and Δ\Delta-collisions with parameters (p,q,Δ)(p, q, \Delta), every observation-only policy π∈Πobs\pi\in\Pi_{\mathrm{obs}} incurs average regret

1TRegret⁡T(π)≥δ:=pqΔ.\frac{1}{T}\operatorname{Regret}_{T}(\pi) \geq\delta:= pq\Delta.

(ii) Separation. If each key’s regime is piecewise constant with at most SS total switches across KK keys and feedback delay is at most τ\tau (Assumption 2), replaying the most recent revealed outcome of key ktk_t (the Local Advisor, §3.4) achieves

1TRegret⁡T≤(S+K)mT,\frac{1}{T}\operatorname{Regret}_{T} \leq\frac{(S+K)m}{T},

where mm is the maximum visits to a single key within any τ\tau-step window; hence Πhist\Pi_{\mathrm{hist}} strictly outperforms Πobs\Pi_{\mathrm{obs}} once T>(S+K)m/δT > (S+K)m/\delta.

Corollary 1 (Model capacity cannot recover missing validity bits). No stationary feature extractor f(zt)f(z_t) followed by an arbitrary classifier can reduce average regret below δ\delta when rtr_t is absent from ztz_t.

Proposition 1(i) and Corollary 1 rule out a common misdiagnosis: scaling up prompt encoders or classifiers cannot detect silent staleness from ztz_t alone. Proposition 1(ii) shows that conditioning on delayed per-key outcomes escapes this regret floor whenever keys are revisited faster than they switch (proof in Appendix § 6.§ 1).

Paired evidence

Rather than tracking raw rewards—which confound memory validity with how hard the question itself is—RegimeCouncil converts each revealed episode ss into its paired utility difference:

ds=us,mem−us,0∈[−1,1],d_s = u_{s,\mathrm{mem}} - u_{s,0} \in[-1,1],

where us,mem∈[0,1]u_{s,\mathrm{mem}} \in[0,1] is the utility with memory injected and us,0∈[0,1]u_{s,0} \in[0,1] is the utility of the no-memory anchor on the identical query. Subtracting us,0u_{s,0} cancels query-level difficulty: ds>0d_s > 0 means memory helped, ds<0d_s < 0 means stale memory hurt, and ds=0d_s = 0 is a tie where both actions performed equally. All three modules below operate directly on this shared stream of revealed dsd_s values.

Global Advisor

When a key is queried for the first time, or when a batch of stored facts goes stale simultaneously, the queried key has no up-to-date local outcome of its own, whereas recent outcomes on other keys are already informative. The Global Advisor captures this cross-key signal by maintaining a sliding window Wg(t)W_g(t) of the WgW_g most recently revealed paired differences across all keys in FtF_t, proposing memory when their sum is strictly positive:

gt=1[∑i∈Wg(t)di>0].g_t = \mathbb{1}\left[\sum_{i\in W_g(t)} d_i > 0\right].

where 1[⋅]\mathbb{1}[\cdot] denotes the indicator function. Global pooling provides an immediate cold-start prior on unseen keys (Figure 1, scene 3) and adapts rapidly when stored facts share a common validity regime (scene 2). However, when keys drift asynchronously, positive and negative did_i values mix inside Wg(t)W_g(t), causing majority keys to overwrite minority keys.

Local Advisor

To prevent cross-key interference, the Local Advisor isolates feedback to the currently queried key ktk_t. Let Wℓ(t;kt)W_\ell(t;k_t) index the WℓW_\ell most recently revealed outcomes for key ktk_t in FtF_t; the Local Advisor proposes memory according to

ℓt=1[∑i∈Wℓ(t;kt)di>0].\ell_t = \mathbb{1}\left[\sum_{i\in W_\ell(t;k_t)} d_i > 0\right].

Because each key’s validity state is piecewise constant between updates, older outcomes on the same key are more likely to predate a switch; we therefore fix Wℓ=1W_\ell=1 by design so ℓt\ell_t follows the single most recent revealed outcome for ktk_t (Figure 1, scene 1), defaulting to the safe no-memory anchor (ℓt=0\ell_t=0) before any decisive outcome for ktk_t is available.

Proposition 2 (Neither fixed scope is uniformly sufficient). There exist asynchronous-drift streams on which the Global Advisor incurs Ω(T)\Omega(T) regret relative to the Local Advisor because majority-key outcomes dominate the pooled window and misclassify minority keys. Conversely, there exist sparse-key streams on which the Local Advisor incurs Ω(T)\Omega(T) regret relative to the Global Advisor because keys are not revisited often enough to accumulate local evidence while pooled evidence is already informative.

Proposition 2 (proved in Appendix § 6.§ 2) explains why fixing either a local or a global policy at design time is fundamentally brittle: isolation is required for per-key fidelity under asynchronous drift, whereas pooling is required for sample efficiency under sparsity and correlated shifts.

Meta Governor

When gt=ℓtg_t = \ell_t, both scopes agree; when gt≠ℓtg_t \ne\ell_t, the router must decide which advisor to trust without observing the hidden validity state rtr_t. The Meta Governor resolves this conflict by scoring how well each advisor would have performed on recent revealed interactions. For any revealed episode i∈Fti \in\mathcal{F}_t, advisor j∈{g,ℓ}j \in\{g,\ell\} achieves counterfactual utility

vj,i={ui,memif advisor j proposed memory on episode i,ui,0otherwise.v_{j,i} = \begin{cases} u_{i,\mathrm{mem}} & \text{if advisor } j \text{ proposed memory on episode } i,\\ u_{i,0} & \text{otherwise.} \end{cases}

Over the window Wm(t)W_m(t) of the Wm≥1W_m \ge1 most recently revealed episodes in Ft\mathcal{F}_t, the Meta Governor computes the cumulative utility margin of Global over Local:

At=∑i∈Wm(t)(vg,i−vℓ,i).A_t = \sum_{i \in W_m(t)} (v_{g,i} - v_{\ell,i}).

Because Wm(t)W_m(t) indexes revealed outcomes rather than wall-clock steps, AtA_t remains well defined under arbitrary feedback delays or missing outcomes. Crucially, the governor applies an asymmetric selection rule: it anchors on the unbiased Local Advisor by default and switches to the Global Advisor only when At>0A_t > 0. Requiring a strictly positive pooled margin filters out transient cross-key fluctuations while enabling rapid store-wide overrides when a cluster of corrections causes Global to consistently outperform Local (Figure 1, scene 2).

Proposition 3 (Finite-time switching under delayed feedback). If vg,i−vℓ,i≥γ>0v_{g,i} - v_{\ell,i} \ge\gamma> 0 holds for WmW_m consecutive revealed episodes, the Meta Governor selects the Global Advisor; if vg,i−vℓ,i≤−γv_{g,i} - v_{\ell,i} \le-\gamma holds for WmW_m consecutive revealed episodes, it selects the Local Advisor. Under feedback delay at most τ\tau, either switch completes within at most Wm+τW_m + \tau decisions from the onset of the streak.

The proof (Appendix § 6.§ 3) follows directly from the event-indexed window: WmW_m revealed episodes overwrite Wm(t)W_m(t) to make AtA_t strictly positive (or negative), and bounded delay adds at most τ\tau steps.

Complete online routing loop

Putting the three modules together, at each step tt RegimeCouncil queries both advisors on key ktk_t and deploys

at={gtif At>0(Global override),ℓtotherwise(Local default).a_t = \begin{cases} g_t & \text{if } A_t > 0 \quad\text{(Global override)},\\ \ell_t & \text{otherwise} \quad\text{(Local default).} \end{cases}

Whenever a past episode’s outcome arrives in Ft\mathcal{F}_t, its paired difference dsd_s updates WgW_g, Wℓ(⋅;ks)W_\ell(\cdot;k_s), and the governor’s margin AtA_t. With Wℓ=1W_\ell=1 and override threshold 00 (At>0A_t > 0) fixed by design, the two window lengths (Wg,Wm)(W_g,W_m) are the only hyperparameters. Because each decision requires only rolling window sums in O(1)O(1) time and zero extra user-facing LLM calls, RegimeCouncil adds negligible runtime overhead (≈2.3 μs\approx2.3\,\mu\mathrm{s} per decision).

Experiments

We evaluate RegimeCouncil along three axes: (1) whether adaptive routing outperforms the better fixed-scope policy when the Global and Local Advisors disagree (§ 4.1), the exact regime identified by Proposition 2; (2) whether the same router transfers without retuning to real-world historical drift on TempLAMA and TAQA (§ 4.2); and (3) how each module contributes to accuracy and harmful-memory reduction (§ 4.3). In all experiments, Wℓ=1W_{\ell}=1 and override threshold 0 (At>0A_t > 0) are fixed by design, while (Wg,Wm)=(32,8)(W_g, W_m) = (32, 8) are fixed once on disjoint development schedules and held frozen across every held-out evaluation. We evaluate two representative LLMs—GPT-4o and Qwen3-30B-A3B (an MoE model activating ≈\approx3B parameters; hereafter Qwen)—and cache the model completions per item once so all routing policies observe identical LLM generations. Full protocol details, prompt templates, worked episodes, and extended robustness checks appear in Appendices B–E.

Main evaluation: routing when local and global scopes disagree

Benchmark construction and protocol. We build our primary streams from real knowledge-update user sessions in LongMemEval (Wu et al. (2025)), retaining the original questions together with their audited initial and updated answers without fabricating any facts. Because unmodified benchmark dialogues expose explicit timestamps in the prompt, a recency-aware reader could identify the newer statement directly from ztz_t—testing observable conflict rather than hidden staleness (Assumption 1). We therefore apply a deterministic lexical filter that strips explicit temporal pointers, and control when each fact switches from its old value to its updated value via a hidden schedule. In the primary block_switch family, 16 tracked facts are divided into two cohorts of eight that switch in opposite directions near mid-horizon; each key is queried once per pass over 22 passes (352 episodes in total), while the memory store commits updated snapshots every 96 episodes (6 passes), creating realistic staleness windows before store updates take effect. Schedules A and B are two held-out instances of this family generated from distinct deterministic hashes governing pass order and switch timing (10th, 11th, or 12th visit).

Evaluation metrics. Because both advisors deploy the exact same action whenever gt=ℓtg_t = \ell_t, the routing choice only matters on the disagreement slice (gt≠ℓtg_t \ne\ell_t, identified from advisor proposals alone without ground-truth labels). Our primary metric is disagreement-slice accuracy and its gain RC −- max(GG, LL) over the better single-scope advisor, alongside full-stream accuracy across all 352 episodes.

Main results and mechanism. Table 1 shows that RegimeCouncil outperforms the better fixed-scope advisor by +5.2 to +7.3 points on the disagreement slice (+2.0 to +2.3 points on the full stream) across both schedules and both models. Crucially, the identity of the better fixed scope flips across schedules—Local leads on Schedule A whereas Global leads on Schedule B for both LLMs—confirming Proposition 2 empirically: committing to either scope at design time loses on one schedule, while RegimeCouncil outperforms both without retuning (key-cluster bootstrap P(gap^>0)∈[0.93,0.97]P(\widehat{\mathrm{gap}}>0) \in[0.93, 0.97], Appendix B.5; joint 95% CI +1.9 [0.9, 3.1] full-stream and +5.1 [2.3, 8.1] on the slice).

ScheduleModelndisn_{\mathrm{dis}}RCBest G/LAgree-onlySlice GapRCBest G/LFull Gap [95% CI]
AQwen11087.380.065.5+7.370.267.9+2.3 [0.0, 3.4]
GPT-4o13484.379.167.2+5.273.371.3+2.0 [0.0, 3.4]
BQwen15183.478.176.2+5.371.669.3+2.3 [−0.3, 4.0]
GPT-4o14682.977.476.0+5.573.070.7+2.3 [−0.3, 3.7]

Table 1. Main results on the two primary held-out schedules: disagreement-slice accuracy (%) and full-stream accuracy (%) with key-cluster bootstrap 95% CIs (5,000 replicates). RC denotes RegimeCouncil; G and L denote the Global and Local Advisors used alone; Best G/L is max(GG, LL); Gap is RC minus Best G/L (points); Agree-only removes the Meta Governor (§ 4.3). Jointly resampling all four evaluations yields a full-stream gap of +1.9 [0.9, 3.1] and a slice gap of +5.1 [2.3, 8.1].

Inspecting the disagreement episodes reveals how both cases of Proposition 2 arise in practice (Appendix B.3). On the majority of disagreements (84/110 and 99/134 on Schedule A; 134/151 and 132/146 on Schedule B), the queried key’s latest paired outcome is a tie (d=0d=0), so Local abstains while Global transfers positive evidence from other keys; on the remaining episodes, Local’s per-key signal directly conflicts with the pooled window. Across these decisions, the Meta Governor selects an action at least as accurate as the alternative advisor 94–98% of the time: on Schedule A, Global overrides yield 10 helpful vs. 2 harmful switches on Qwen ((10−2)/110 = +7.3 points) and 10 vs. 3 on GPT-4o (+5.2 points); on Schedule B, they yield 10 vs. 0 and 9 vs. 0. Two concrete Qwen episodes on Schedule A illustrate both directions (Appendix § 9): at visit 7 of the volleyball-record query (old answer 3-2 still valid), Local abstains after a tie while Global pools positive snapshot evidence from other keys and overrides correctly; at visit 14 of the spare-screwdriver query (old answer “No” still valid), the pooled window turns non-positive after other keys flip, so the governor retains Local’s positive per-key signal and again answers correctly.

Scale and schedule robustness. With all parameters kept frozen, RegimeCouncil outperforms the better fixed scope across all 30 held-out settings (33,792 episodes; median slice gain +7.3, worst +0.6 points), spanning a third schedule hash (Schedule C), two additional drift families (independent_switch and poisson_flip), an expanded 54-key LongMemEval pool, and two real-drift benchmarks (Appendix § 7.7). On the 54-key pool (matched per-key commit lag refresh=324), every single 95% bootstrap CI excludes zero with slice gains of +6.0 to +9.7 points (Table 2); sweeping Wg∈{16,32,64}W_g \in\{16, 32, 64\} and Wm∈{4,8,16}W_m \in\{4, 8, 16\} keeps all entries positive (Appendix § 7.§ 5); and on a dedicated harm-exposure benchmark, RegimeCouncil matches the low harmful exposure of the best Local window while exceeding the accuracy of the best Global window on both models (Appendix § 7.9).

Schedule familyModelScheduleGap95% CI
block_switchQwenA+6.0[0.6, 9.1]
B+8.4[4.1, 10.0]
GPT-4oA+8.5[3.0, 11.5]
B+9.0[3.7, 10.6]
independent_switchQwenA+8.6[5.1, 10.1]
B+9.2[5.7, 10.7]
GPT-4oA+9.2[4.6, 11.7]
B+9.7[7.0, 12.4]

Table 2. Disagreement-slice gap on the 54-key pool with per-key snapshot lag matched to the 16-key protocol (refresh=324). All eight key-bootstrap 95% intervals (5,000 replicates) lie strictly above zero. Gap is RC minus Best G/L (points); windows stay frozen.

Transfer to real-world historical drift

Whereas the LongMemEval streams control switch timing through a schedule, we next evaluate the exact same frozen router when both the evolving facts and their switch times come from real historical chronologies (with explicit dates stripped from ztz_t per Assumption 1). TempLAMA ([5]) provides 120 time-varying Wikidata facts across 2010–2020 (such as political offices, sports clubs, or organization chairs), and TAQA ((Zhao et al., 2024)) provides 100 evolving Wikipedia-table questions across 2000–2023 (such as race winners, legislators, or league leaders). Each fact flips at its true historical change year—making the switch-time distribution empirical rather than synthetic—while Schedules A and B vary the query order within each pass under matched per-key snapshot lag (6K6K episodes). As shown in Table 4, RegimeCouncil achieves 81.5%–86.2% disagreement-slice accuracy across both benchmarks and both models, outperforming the better fixed-scope advisor by +7.2 to +18.1 points (+3.0 to +5.4 full-stream points), with all eight 95% bootstrap CIs well above zero. Notably, on TempLAMA with GPT-4o, both fixed scopes degrade to ≈ 66% on the disagreement slice because early concentrated switches clash with late stable keys, whereas RegimeCouncil maintains 83.6%–84.2% without any parameter retuning.

Table 4: Real-world historical drift on TempLAMA (120 keys) and TAQA (100 keys), disagreement-slice accuracy (%). Switch times follow true historical change years with matched per-key snapshot lag and frozen windows. All eight key-bootstrap 95% CIs (5,000 replicates) lie strictly above zero.

SourceModelSchedulendisn_{\mathrm{dis}}RCBest G/LGap95% CI
TempLAMAQwenA110585.478.2+7.2[5.8, 8.9]
B110986.278.8+7.4[6.0, 9.1]
GPT-4oA78684.266.2+18.1[15.2, 20.5]
B79383.666.1+17.5[14.6, 19.8]
TAQAQwenA85683.474.6+8.8[6.4, 10.8]
B84884.075.0+9.0[7.0, 11.1]
GPT-4oA70281.569.8+11.7[9.1, 14.7]
B68282.470.1+12.3[9.5, 15.6]

Table 4.

Module ablations and extended robustness

Removing any of the three modules degrades performance consistently across benchmarks and models (Table 3 and Appendix § 7.§ 4). On Schedule A (where full RegimeCouncil reaches 70.2% on Qwen and 73.3% on GPT-4o), removing the Global Advisor reduces full-stream accuracy by 2.3 and 2.0 points because unseen or tied keys lose cross-key transfer; removing the Local Advisor costs 3.7 and 6.0 points and more than doubles harmful memory exposures on GPT-4o (9 → 19 episodes where stale memory scores below the anchor); and removing the Meta Governor (Agree-only, which uses memory only when gt=ℓt=1g_t=\ell_t=1) costs 6.8 and 6.5 full-stream points (21.8 and 17.2 slice points in Table 1). The same pattern holds on Schedule B (−2.3 to −3.1 points; harmful exposures doubling from 8 → 15 on Qwen and 6 → 14 on GPT-4o without Local, Table 6) as well as on TempLAMA and TAQA (−3.9 to −7.0 without Local, −3.0 to −5.4 without Global, and −3.5 to −5.8 without the Meta Governor; Table 12–Table 13).

VariantQwenGPT-4o
without Global Advisor−2.3−2.0
without Local Advisor−3.7−6.0
without Meta Governor−6.8−6.5

Table 3. Module ablations on Schedule A (change in full-stream accuracy, points), keeping all windows and thresholds frozen. Full accuracy levels and harmful-exposure counts appear in Table 6.

ScheduleModelVariantAccuracyHarm exposureΔ\Deltaacc
AQwenFull RegimeCouncil70.29—
without Global Advisor67.98−2.3
without Local Advisor66.511−3.7
without Meta Governor63.48−6.8
GPT-4oFull RegimeCouncil73.39—
without Global Advisor71.36−2.0
without Local Advisor67.319−6.0
without Meta Governor66.86−6.5
BQwenFull RegimeCouncil71.68—
without Global Advisor68.88−2.8
without Local Advisor69.315−2.3
without Meta Governor68.56−3.1
GPT-4oFull RegimeCouncil73.06—
without Global Advisor70.56−2.6
without Local Advisor70.714−2.3
without Meta Governor70.25−2.8

Table 6. Module ablation on Schedules A and B (full-stream accuracy, %). Each row removes one component of the full router. Without Global or without Local, the remaining advisor is used alone. Without the Meta Governor (§ 3.5) the row falls below either advisor alone in all four settings (on Schedule A, 6.8 points on Qwen and 6.5 on GPT-4o; 21.8 and 17.2 disagreement-slice points). Removing Local roughly doubles harmful exposure in all four settings. Δ\Deltaacc is computed from unrounded accuracies.

ModelSchedulendisn_{\mathrm{dis}}RCBest G/LGap95% CI
QwenA110585.478.2+7.2[5.8, 8.9]
B110986.278.8+7.4[6.0, 9.1]
GPT-4oA78684.266.2+18.1[15.2, 20.5]
B79383.666.1+17.5[14.6, 19.8]

Table 12. TempLAMA real-drift stream (120 keys, real switch times, matched snapshot lag), disagreement-slice accuracy (%). Gap is RC minus Best G/L (points). The large GPT-4o gap is driven by the fixed Global and Local scales collapsing to ≈66%\approx66\% on the slice, not by an unusual RC level. Full-stream gaps are 3.0 and 3.1 points on Qwen and 5.4 and 5.3 points on GPT-4o (Schedules A and B). The difference from follow-recent-winner and CUSUM is within ≈0.7\approx0.7 points. All four key-bootstrap 95% CIs (5000 replicates) are above zero (P(gap>0)=1.00P(\mathrm{gap}>0)=1.00); each ablation reduces accuracy (without Local −5.7 to −7.0, without Global −3.0 to −5.4, without Meta Governor −3.9 to −5.8). Holding refresh = 96 while KK grows shortens the per-key lag below the protocol and is not comparable.

ModelSchedulendisn_{\mathrm{dis}}RCBest G/LGap95% CI
QwenA85683.474.6+8.8[6.4, 10.8]
B84884.075.0+9.0[7.0, 11.1]
GPT-4oA70281.569.8+11.7[9.1, 14.7]
B68282.470.1+12.3[9.5, 15.6]

Table 13. TAQA real-drift stream (100 keys, real switch times, matched snapshot lag), disagreement-slice accuracy (%). Gap is RC minus Best G/L (points). Full-stream gaps are 3.4 and 3.5 points on Qwen and 3.7 and 3.8 points on GPT-4o (Schedules A and B). The difference from follow-recent-winner and CUSUM is within ≈0.6\approx0.6 points. All four key-bootstrap 95% CIs (5000 replicates) are above zero (P(gap>0)=1.00P(\mathrm{gap}>0)=1.00); each ablation reduces accuracy (without Local −3.9 to −5.3, without Global −3.4 to −3.8, without Meta Governor −3.5 to −5.2).

Tie-deferral, adaptive baselines, and realistic feedback. Appendix § 10 evaluates three practical extensions with the same frozen windows. First, comparing against a standalone tie-deferral rule that follows Global only when Local has no signal (d=0d=0) without the Meta Governor (Table 17) separates two regimes: Local abstention achieves the lowest harmful exposure across all 30 settings (707 vs. 746–752 for Fixed Share, CUSUM, and standalone tie-deferral), whereas under clustered corrections where Local holds a stale non-zero signal (d=+1d=+1), the Meta Governor lifts disagreement accuracy from 66.3% to 94.2% and cuts harmful episodes by 59% (37 vs. 91); combining tie-deferral with the Meta Governor (RC-refined) retains both benefits (72.3% full-stream accuracy, +9.8 median slice gain, and 94.2% under clustered shifts). Second, seeking gain (Wg,Wm)=(32,8)W_g,W_m)=(32,8) fixed, RegimeCouncil remains effective when varying snapshot commit intervals vs. outcome delays τ∈[1,96]\tau\in[1,96] independently (Table 18–Table 19), as well as under mid-conversation drift-rate shifts (68.1%, +4.3 median slice gain, positive in 16/16 settings), random delays τr∼Uniform⁡{1..16}\tau_r\sim\operatorname{Uniform}\{1..16\} (+5.9 to +7.2 median gain), sparse feedback (+5.7 and +3.2 at 75% and 50% revelation), and pure executed-action-only bandit feedback via inverse-propensity estimation (68.9% vs. 63.2% for Global, higher in 30/30 settings and halving harmful exposures; Table 20). Third, because the Global Advisor already relies on paired outcomes dtd_t (which can be checked asynchronously in the background without ground-truth labels), RegimeCouncil shares 100% of LLM generation costs with Global while adding zero user-facing LLM calls, 0 ms critical-path latency, and only 1.41 μs of CPU routing time per decision (4.4 × 10510^5 decisions/s).

Table 17: Comparison across Case 1 (30 held-out settings, 33,792 episodes), Case 2 (54-key clustered shifts sync_multi and sync_switch), and Case 1+2 (54-key two-stage stream with asynchronous flips followed by store-wide flips; disagreement-slice accuracy in % and total harmful episodes). Default RegimeCouncil achieves the lowest harmful exposure on the 30 settings (707) and outperforms standalone tie-deferral by +27.9 points under clustered corrections while reducing harmful episodes by 59% on sync_switch (37 vs. 91) and 26% on two-stage streams (75 vs. 102); RC-refined achieves the highest accuracy across both regimes.

MethodCase 1: 30 Held-OutCase 2: ClusteredCase 1+2
FullGapHarmsync_multisync_switchTwo-Stage
Follow-recent-winner71.7+8.0746 (2.21%)94.293.5 (37)69.5 (65)
Fixed Share (η=2\eta=2, α=0.3\alpha=0.3)71.7+8.0746 (2.21%)94.293.5 (37)66.8 (74)
CUSUM on surplus71.3+7.8746 (2.21%)93.192.8 (41)67.1 (70)
Local + tie-deferral (no Meta)72.4+9.7752 (2.23%)66.391.3 (91)69.7 (102)
RegimeCouncil (default)71.6+7.3707 (2.09%)94.293.5 (37)68.2 (75)
RegimeCouncil (RC-refined)72.3+9.8748 (2.21%)94.293.8 (40)71.2 (77)

Table 17.

Table 18: Varying the snapshot commit interval at fixed outcome delay τ=1\tau=1 across Schedules A, B, and C on both models (mean full-stream accuracy, %). Since each of the 16 keys is visited once per 16-episode pass, commit intervals ≤16\le16 correspond to immediate write-back before the key’s next visit.

Snapshot Commit IntervalMean Full-Stream Accuracy (%)Gain vs. Always
Alwaysmax⁡(G,L)\max(G,L)RC (def.)RC-ref.RC (def.)RC-ref.
1 or 16 ep. (1 pass, write-back)93.092.691.692.7−1.4−0.3
32 episodes (2 passes)87.786.486.987.8−0.8+0.1
64 episodes (4 passes)78.977.579.480.3+0.5+1.4
96 episodes (6 passes, main)70.169.671.972.8+1.8+2.7
192 episodes (12 passes)51.256.756.756.8+5.5+5.6

Table 18.

Table 19: Varying the outcome revelation delay τ\tau at fixed commit interval 6K6K (disagreement-slice gap vs. max⁡(G,L)\max(G, L), points). For each pool, the first row reports the default RegimeCouncil and the second row reports RC-refined (tie-deferring Local with the Meta Governor).

Key Pool (Commit = 6K6K)Router Variantτ=1\tau=1τ=4\tau=4τ=8\tau=8τ=16\tau=16τ=48\tau=48τ=96\tau=96
16-key pool (commit 96)RegimeCouncil (default)+5.8+3.6−1.2−4.9−11.1−24.4
RegimeCouncil (RC-refined)+8.3+7.7+6.9+5.9+10.4+6.2
54-key pool (commit 324)RegimeCouncil (default)+8.6+7.7+6.8+4.8+0.6−7.3
RegimeCouncil (RC-refined)+9.9+9.6+9.4+9.4+8.6+7.5
TempLAMA 120 / TAQA 100RegimeCouncil (default)+11.5+11.0+10.1+8.8+2.60.0
RegimeCouncil (RC-refined)+12.3+12.2+11.8+11.2+9.4+8.4

Table 19.

Table 20: Performance under realistic feedback conditions across all 30 held-out settings and per-episode computational overhead relative to the Global Advisor alone.

Evaluation Condition / Cost MetricRegimeCouncil (default)Baseline Comparison
In-stream random delay (τt∼Uniform⁡{1..8}\tau_t \sim\operatorname{Uniform}\{1..8\} / {1..16}\{1..16\})+6.7 / +5.9 median slice gain (149/150 & 140/150 runs positive)Outperforms Fixed Share & Follow (133/150 positive at {1..16}\{1..16\})
Sparse feedback (75% / 50% of episodes revealed)+5.7 / +3.2 median slice gain (+9.8 / +8.7 with RC-refined)Outperforms Follow & Fixed Share (+5.5 / +2.9 median gain)
Noisy feedback (5% / 10% outcome flip probability)+3.5 / +1.0 median slice gainOutperforms Follow & Fixed Share (+3.1 / +0.7 median gain)
Executed-action-only bandit (IPW d^t\hat{d}_t, ε=0.05\varepsilon=0.05; no u0u_0 call)68.9% full-stream accuracy (31.3 harmful episodes/setting)Outperforms Global (63.2% acc., higher in 30/30 settings, 60.6 harm), Follow (68.5% acc., higher in 23/30, p=0.002p=0.002), & Local (68.5% acc., higher in 18/30)
User-facing LLM calls & latency1 call (+0 ms added latency)Global: 1 user-facing call (+1 shared background call for dtd_t)
Router CPU time & throughput (Python, 33,792 decisions)2.29 μ\mus/decision (4.4 ×105\times10^5 decisions/s)Global alone: 0.88 μ\mus/decision (+1.41 μ\mus router overhead)

Table 20.

Conclusion

Stored facts in long-term agent memory inevitably go stale over extended interactions, yet delayed feedback arrives before the store is updated and cannot be governed reliably by a single fixed scope: isolating feedback to one fact misses cold-start transfer and correlated shifts, whereas pooling feedback across all facts allows volatile items to suppress valid ones. We formulated this online scopeselection problem as memory conflict governance and introduced RegimeCouncil, a lightweight paired-evidence router that arbitrates between a Local Advisor and a Global Advisor through an asymmetric Meta Governor. Our theoretical analysis proves that delayed per-key outcomes escape the observation-only regret floor, neither fixed scope suffices alone, and margin-gated arbitration switches in finite time under bounded delay. Across controlled LongMemEval update streams, real-world historical drift on TempLAMA and TAQA, and relaxed feedback settings, RegimeCouncil consistently outperforms fixed-scope and symmetric adaptive baselines while reducing harmful memory exposures at microsecond runtime overhead. Promising future directions include extending multi-scope governance to hierarchical user-profile graphs and end-to-end multi-turn tool-use agents.

Proofs

The main text establishes three theoretical results supporting the RegimeCouncil architecture: Proposition 1 (an observation-only regret floor and per-key history separation), Proposition 2 (why neither a purely global nor a purely local scope suffices alone), and Proposition 3 (finite-time margin-gated switching under delayed feedback). We provide complete proofs below.

Observation floor and history separation (Proposition 1)

Proof of Proposition 1. Fix a colliding context zz visited n(z)n(z) times, of which a visit-weighted minority-regime share q(z)=min⁡{n0(z),n1(z)}/n(z)q(z)=\min\{n_0(z),n_1(z)\}/n(z) occurs under the minority regime. For every action aa,

ρ0(a;z)+ρ1(a;z)≥Δ\rho_0(a;z)+\rho_1(a;z) \ge\Delta

by Δ\Delta-collision, and both ρr\rho_r are nonnegative, so

n0(z)ρ0(a;z)+n1(z)ρ1(a;z)≥min⁡{n0(z),n1(z)}[ρ0(a;z)+ρ1(a;z)]≥n(z)q(z)Δ.n_0(z)\rho_0(a;z)+n_1(z)\rho_1(a;z) \ge\min\{n_0(z),n_1(z)\}\left[\rho_0(a;z)+\rho_1(a;z)\right] \ge n(z)q(z)\Delta.

Because π∈Πobs\pi\in\Pi_{\mathrm{obs}} conditions only on zz, the same action law π(⋅∣z)\pi(\cdot\mid z) governs every visit to zz irrespective of the regime (Assumption 1), so the expected total regret accumulated at zz equals Ea∼π(⋅∣z)[n0(z)ρ0(a;z)+n1(z)ρ1(a;z)]\mathbb{E}_{a\sim\pi(\cdot\mid z)}[n_0(z)\rho_0(a;z)+n_1(z)\rho_1(a;z)]. The displayed bound holds for every aa, so taking the expectation preserves it: the expected regret at zz is at least n(z)q(z)Δn(z)q(z)\Delta, and randomization cannot undercut it. Summing over colliding contexts (non-colliding visits contribute nonnegative regret) and dividing by TT yields average regret at least

ΔT∑zn(z)q(z)=pqΔ=δ,\frac{\Delta}{T}\sum_z n(z)q(z)=pq\Delta=\delta,

where pp is the colliding-visit frequency and qq the visit-weighted minority share. No independence across time is used. This proves part (i).

Part (ii): separation. Consider the history policy that, on each key kk, replays the sign of the revealed paired outcome for kk with the latest generation time and defaults to the anchor before any outcome for kk is revealed—the Local Advisor of § 3.4 with Wℓ=1W_\ell=1, which conditions on hth_t and so lies in Πhist\Pi_{\mathrm{hist}}. Fix a key kk whose regime is constant between switches; the regime-optimal memory action on kk is determined by that regime, and by Assumption 2 each revealed comparison carries its sign. Once a single post-switch outcome for kk has been revealed, every later-generated outcome carries the same sign, so the policy plays the regime-optimal memory action on every subsequent visit until the next switch and incurs zero regret there. Regret can therefore accrue only on visits that precede the first revealed outcome after a switch, or before the first outcome ever at cold start. An outcome generated at step ss is revealed by s+τs+\tau, so the stale visits following one switch number at most mm, the largest count of visits to a single key within any window of τ\tau steps. With at most SS switches and KK cold starts, and per-step regret at most 1 (utilities lie in [0,1][0,1]), the total regret is at most (S+K)m(S+K)m; dividing by TT gives the stated bound, which falls below the floor δ\delta of part (i) once T>(S+K)m/δT>(S+K)m/\delta.

When keys are too sparse for per-key replay (each seen O(1)O(1) times), the complementary history policy—the Global Advisor pooling across keys—attains the same separation whenever the keys share a regime: after each of the SS switches its pooled window is corrected within O(Wg+τ)O(W_g+\tau) revealed outcomes, giving total regret O(S(Wg+τ))O(S(W_g+\tau)) and average regret below δ\delta for large TT. The two cases mirror the constructions of Proposition 2.

Proof of Corollary 1. Any stationary feature map f(z)f(z) composed with a classifier induces a stationary policy in Πobs\Pi_{\mathrm{obs}}. Apply Proposition 1. The floor is therefore invariant in the capacity of ff: enlarging a class of maps Z→Δ(A)\mathcal{Z}\to\Delta(\mathcal{A}) cannot recover a regime bit that is absent from zz.

Granularity constructions (Proposition 2)

Proof of Proposition 2. Global mixing. Use two keys with opposite per-key advantages—dt=+1d_t=+1 whenever the majority key k1k_1 is queried and dt=−1d_t=-1 whenever the minority key k2k_2 is queried—and interleave them on a fixed periodic schedule in which k2k_2 appears a fraction β∈(0,12)\beta\in(0,\frac{1}{2}) of the steps. Once the window WgW_g is full, it contains at most ⌈βWg⌉\lceil\beta W_g\rceil entries equal to −1-1, so its pooled sum is at least Wg(1−2β)−O(1)>0W_g(1-2\beta)-O(1)>0 for WgW_g large enough; the Global Advisor therefore proposes memory on every step and acts wrongly on every k2k_2 visit, a fraction β\beta of the TT steps. The Local Advisor reads only the current key and, after a single revealed visit, tracks the correct per-key sign on both keys. The per-step utility gap on k2k_2 visits is bounded below by a positive constant on Θ(T)\Theta(T) steps, so Global suffers linear loss relative to Local.

Local sparsity. Present a sequence of distinct keys, each visited once, all sharing a common positive memory advantage dt=+1d_t=+1. On a fresh key the Local Advisor has an empty per-key window and defaults to the anchor, incurring a constant per-step gap. Once the first outcome is revealed, within τ\tau steps, the Global Advisor’s pooled sum is strictly positive and transfers the shared advantage to every subsequent new key. Repeating over TT distinct keys yields linear loss for Local relative to Global.

The two streams are disjoint in the failure they induce: the first makes pooling biased, the second makes isolation uninformative. No single fixed scale is therefore uniformly sufficient.

Finite meta response (Proposition 3)

Proof of Proposition 3. Recall At=∑i∈Wm(t)(vg,i−vℓ,i)A_t=\sum_{i\in\mathcal{W}_m(t)}(v_{g,i}-v_{\ell,i}) sums the surplus of the WmW_m most recently revealed episodes. Suppose first that vg,i−vℓ,i≥γ>0v_{g,i}-v_{\ell,i}\ge\gamma>0 for the WmW_m consecutive revealed indices that occupy the window. Then At≥Wmγ>0A_t\ge W_m\gamma>0, so the governor selects Global under the rule “override iff At>0A_t > 0.” If instead vg,i−vℓ,i≤−γv_{g,i} - v_{\ell,i} \leq-\gamma throughout the window, then At≤−Wmγ<0A_t \leq-W_m\gamma< 0 and Local remains (or returns as) the selection.

It remains to account for delay. An outcome generated at step ss is revealed by step s+τs + \tau. Filling Wm(t)\mathcal{W}_m(t) with WmW_m revealed outcomes therefore requires at most WmW_m generations plus τ\tau waiting steps, i.e., at most Wm+τW_m + \tau decisions. The bound is deterministic under the persistent-margin hypothesis; it does not cover streams where the sign of vg,i−vℓ,iv_{g,i} - v_{\ell,i} alternates inside every window of length WmW_m, nor pure bandit logs without counterfactual estimates (which we evaluate empirically via inverse-propensity estimation in Appendix § 10.§ 3). Because Wm(t)\mathcal{W}_m(t) is ordered by generation step, a late-arriving outcome never displaces newer ones. On episodes where both advisors agree, the margin is 0; the same argument shows that Global is selected whenever the margins in the window are nonnegative and at least one is strictly positive, and Local whenever they are all nonpositive.

Evaluation protocol

This appendix records how the delayed-feedback stream is built, how answers are scored, and which artifacts reproduce the main tables.

Items and cached answers

The primary confirmatory set consists of 16 LongMemEval knowledge-update questions (Wu et al., 2025) whose initial and updated answers were manually audited (selected deterministically via SHA-256 hash from the audited items containing temporal cues, prior to any router evaluations; the full 54-key audited pool is evaluated in Appendix § 7.6). To enforce decision-time unobservability (Assumption 1), we apply a fixed lexical filter that strips explicit temporal pointers (such as currently, now, previously, and no longer) identically across all items without altering facts or adding distractors. Each key thus presents a colliding observation: two unordered memory records and a question with no recency cue.

For each key and model, we cache three completions once: answering without memory (the no-memory anchor), answering with the old snapshot, and answering with the updated snapshot. At episode tt, ut,0u_{t,0} scores the no-memory answer against the currently valid ground-truth answer, and ut,memu_{t,\mathrm{mem}} scores the answer produced from the currently committed snapshot (falling back to ut,0u_{t,0} before the first snapshot commit). A completion scores 1 if normalized strings match (exact or substring match) and 0 otherwise. Caching ensures that every routing baseline observes identical LLM outputs on every episode, isolating routing decisions from generation variance.

Hidden schedule and delay

In the primary protocol, each of the 16 keys is visited once per pass over 22 passes (T=352T = 352 episodes). Under $block\_switch$, two cohorts of eight keys switch in opposite directions near mid-horizon (staggered by 1–2 visits per key), while visit order within each pass is deterministically hashed from the schedule seed. Memory snapshots are committed every 96 episodes (6 passes), so the stored record can lag behind a key’s switch by up to 96 episodes. In the main tables (§ 4.1–§ 4.2), completed outcomes are revealed before the next step (τ=1\tau= 1 in Assumption 2) so snapshot commit lag is isolated cleanly; Appendix § 10.§ 2 varies the commit interval and outcome delay τ∈[1,96]\tau\in[1, 96] independently.

Window lengths (Wg,Wm)=(32,8)(W_g, W_m) = (32, 8) are fixed on disjoint development schedules and never retuned on the held-out schedules (Schedules A, B, and C, plus a separate harm-exposure schedule in Appendix § 7.9).

Revelation slice

Table 5 splits Schedules A and B at the first snapshot commit. Until episode 96, a key that has not been committed is scored with the no-memory utility (Appendix § 7.§ 1), so the paired difference is 0, Global and Local propose the same action, and RegimeCouncil matches both. All 110, 134, 151, and 146 disagreement episodes (Schedule A Qwen and GPT-4o, then Schedule B Qwen and GPT-4o), and therefore the entire gap in Table 1, lie after the first commit. In most of them (84, 99, 134, and the key’s latest paired outcome is a tie, so Local has no signal and Global transfers evidence from other keys, the second case of Proposition 2. In the rest, the key’s own latest outcome disagrees with the pooled window, the first case.

ScheduleModelPre nnPre acc.Post nnPost ndisn_{\mathrm{dis}}Post gap
AQwen9637.5256110+7.3
GPT-4o9643.8256134+5.2
BQwen9637.5256151+5.3
GPT-4o9643.8256146+5.5

Table 5. Revelation slice on the cached main streams (accuracy, %). Pre is the 96 episodes before any snapshot commit: Global, Local, and RegimeCouncil tie, and ndis=0n_{\mathrm{dis}}=0. Post gap is RC−max⁡(G,L)RC-\max(G,L) on disagreements after the first commit, equal to Table 1.

Module ablation

Table 6 is the full module ablation summarized in § 4.3, on Schedules A and B. On Schedule B every removal lowers accuracy by 2.3 to 3.1 points. All three variants are ablations of the full router. The third removes the Meta Governor (§ 3.5). Its drop is not the gap versus max⁡(G,L)\max(G,L) in Table 1.

Metrics and the WmW_m/gate grid

The primary metric is accuracy on episodes where the Global (Wg=32W_g=32) and Local (Wℓ=1W_{\ell}=1) proposal bits differ, using those bits only (no labels), reported as RC−max⁡(G,L)RC-\max(G,L). Key-cluster bootstrap resamples the 16 keys (5,000 replicates, seed 0), not individual episodes; point estimates use the full sample. On the disagreement slice of Table 1, the bootstrap mean gaps are 4.3–6.2 points, with 95% intervals [0.0, 10.9] and [0.0, 9.6] on Schedule A (Qwen, GPT-4o) and [−0.6, 8.5] and [−0.8, 8.7] on Schedule B (P(gap>0)∈[0.93,0.97]P(\mathrm{gap}>0)\in[0.93,0.97]; jointly resampling all four evaluations gives +5.1 [2.3, 8.1] on the slice and +1.9 [0.9, 3.1] on the full stream). Table 7 reports the Wm×W_m\times gate sensitivity grid on Schedule A; it is report-only and was not used to select the frozen (Wm,gate)=(8,0)(W_m,\mathrm{gate})=(8,0).

Table 7: Report-only disagreement gaps (points) on Schedule A. Larger gates shrink the gain. Not used for selection.

WmW_mQwen, Schedule A: gate 0gate 1gate 2GPT-4o, Schedule A: gate 0gate 1gate 2
4+8.2+6.4+1.8+6.0+3.7+3.0
8 (frozen)+7.3+5.5+5.5+5.2+4.5+3.7
16+7.3+6.4+5.5+4.5+4.5+3.0

Table 7.

Table 8 is the companion WgW_g sweep: it recomputes the disagreement gap at Wg∈{16,32,64}W_g\in\{16,32,64\}, with Global and Local defined at that WgW_g and WℓW_{\ell}, WmW_m, and the gate held fixed. All twelve entries are

Table 8: Report-only disagreement gaps (points) versus the best advisor at the same WgW_g. All twelve entries are positive; the smallest is Schedule B, Qwen, at Wg=16W_g=16 (+1.8). Not used for selection.

WgW_gSchedule A, QwenSchedule A, GPT-4oSchedule B, QwenSchedule B, GPT-4o
16+9.9+4.6+1.8+2.0
32 (frozen)+7.3+5.2+5.3+5.5
64+5.7+4.9+3.1+4.4

Table 8.

positive; Wg=64W_g=64 stays positive on all four settings (+3.1 to +5.7), and halving the pooled window to 16 shrinks the gain most on Schedule B (+1.8 on Qwen and +2.0 on GPT-4o), as expected when Global underuses cross-key evidence. The frozen Wg=32W_g=32 is the most consistent across schedules and is not confined to a single length.

Scale and schedule robustness

These checks reuse the frozen windows (Wg,Wℓ,Wm,gate)=(32,1,8,0)(W_g, W_\ell, W_m,\mathrm{gate})=(32,1,8,0) with new held-out tags; nothing is retuned.

More keys. The audited LongMemEval knowledge-update pool yields 54 keys after the same temporal-pointer neutralization used for the main 16-key set; we cache the no-memory, old-answer, and new-answer completions for both models. To preserve the per-key snapshot lag of the main protocol we scale the refresh with the key count (refresh =6K=6K, i.e., 96 at K=16K=16 and 324 at K=54K=54), so that between two refreshes each key still receives about six visits regardless of KK, keeping the per-key lag constant across pool sizes. Table 2 reports the frozen router at K=54K=54: the disagreement gap stays +6 to +9.7 points and every key-bootstrap 95% interval lies above zero. Holding the refresh at 96 while KK grows shortens the per-key lag below the protocol and is not comparable.

A second schedule family. independent_switch (one flip per key at a hashed time, keys not cohort-synchronized) and poisson_flip (repeated independent flips) were not in the development grid. Table 9 evaluates the frozen router on the original 16-key caches. independent_switch is positive on all four settings. poisson_flip is also positive on all four, with smaller gaps (+0.6 to +4.6): repeated flips place both regimes inside the governor’s WmW_m window, the surplus stays near zero, and the governor remains on the Local default more often.

Table 9: Disagreement-slice gap (points) on two held-out schedule families, 16-key caches, frozen windows. independent_switch is positive on all four settings; poisson_flip is positive on all four with smaller gaps.

Schedule familySchedule A, QwenSchedule A, GPT-4oSchedule B, QwenSchedule B, GPT-4o
independent_switch+6.7+7.2+6.9+7.1
poisson_flip+0.6+3.1+4.6+3.3

Table 9.

Additional switching comparisons

Schedules A/B/C, the two held-out schedule families, the 54-key pool, and both real-drift sources, over both models, make 30 settings and 33,792 episodes. Holding (Wg,Wℓ,gate)=(32,1,0)(W_g,W_\ell,\mathrm{gate})=(32,1,0), Table 10 varies WmW_m and adds two switching rules on the same advisor surplus: follow-recent-winner and CUSUM. Every variant updates on the schedule of §3.6.

GovernorMedian gapWorst gapSettings < 0Switch rateExcess harm
Wm=1W_m=1+3.97+0.620/300.0930.13
Wm=2W_m=2+5.73+1.230/300.0710.13
Wm=4W_m=4+7.09+1.850/300.0490.27
Wm=8W_m=8 (frozen)+7.27+0.620/300.0350.90
Wm=16W_m=16+7.87+2.470/300.0271.27
Wm=32W_m=32+7.20+1.850/300.0242.33
Follow-recent-winner+8.12+2.470/300.0252.20
CUSUM on surplus+7.94+1.230/300.0192.20

Table 10.

Table 10: Every surplus-based governor outperforms the better fixed scale on all 30 held-out settings; the choice of governor mainly changes harmful exposure. Gaps are disagreement-slice points over max⁡(G,L)\max(G, L) (upper-middle element of the 30 sorted values; sample two-sided medians for Follow-recent-winner, CUSUM, and Wm=8W_m=8 are +8.0, +7.8, and +7.3 in Table 17), alongside the worst setting. Switch rate is the fraction of consecutive disagreement episodes on which the governor changes advisor. Excess harm is the mean number of episodes per setting, beyond the safest fixed scale, in which the policy acts on memory that is worse than the anchor.

No row of Table 10 falls below the better fixed scale. Follow-recent-winner, computed on the same streams, is a supplementary comparison.

Table 11: Development comparison, disagreement-slice points and harmful-episode counts, pooled over five tags and both models (refresh 96). The frozen rule has higher accuracy and fewer harmful episodes in every family, including the family Schedule A is drawn from. Per model the accuracy margins are +0.62 (Qwen) and +0.40 (GPT-4o).

On held-out disagreement accuracy the ordering is reversed by a small margin: follow-recent-winner is higher on 19 settings, equal on 4, and lower on 7, with mean difference 0.3 points (sign test p=0.03p=0.03). Only one key-bootstrap interval excludes zero (54-key block_switch, Qwen, −1.2, [−2.4, −0.2]). Those streams contain long stretches in which the same advisor remains better. Follow-recent-winner retains that advisor. The Meta Governor returns to Local whenever the recent surplus is not positive, and therefore forgoes a few tenths of a point on those stretches. The largest single deficit is Schedule A, −2.7 and −2.2 points, and Wm=4W_m=4 remains 1.8 and 1.5 points lower there. Two advantages remain with the frozen rule. On the development families, which were not used to choose the window, its disagreement accuracy is higher in every family, by 0.07 to 0.84 points, and it records fewer harmful episodes in each (Table 11). On the held-out settings it still records fewer harmful episodes on 26 of 30 (707 against 746; the safest fixed scale has 680). A retrospective sweep on the development families, scored by the worse model’s mean disagreement gap, ranks Wm=8W_m=8 first (3.55) and Wm=4W_m=4 second (3.45), with the same lowest cell (−1.61).

Development familyRC−followHarm, RCHarm, follow
v4_default+0.624965
anticorrelated+0.473846
long_stable_flip+0.0794105
sparse_need_global+0.531728
block_switch+0.846979

Table 11.

Naturally occurring drift (TempLAMA and TAQA)

All results above inject the non-stationarity with a schedule. To test whether the mechanism survives real drift, we replace the schedule with the true calendar chronology of changing facts, on two independent sources. The harness is otherwise unchanged: same paired-utility routing, same frozen windows, same per-key snapshot lag (refresh = 6K). We report both the disagreement-slice levels (so the gap is interpretable) and the full-stream gap.

Construction and selection. TempLAMA [5] mines (subject, relation, year) → object facts from Wikidata for 2010–2020. Of 5,839 subject–relation groups, 2,191 are single-valued and change exactly once (a single clean transition from an old to a new value); we take a 120key subset balanced across all nine relations. TAQA (Zhao et al., 2024) supplies Wikipedia-table questions over 2000–2023; most items change several times, so from 1,000 validation items we keep the 284 with a clean adjacent pair of single-valued runs (each ≥2\ge2 years, distinct non-overlapping answers) and hash-sample 100. Each key becomes a natural-language question with two memory records; years and temporal-pointer lexicon are stripped so the valid write is hidden at decision time (Assumption 1), exactly as for the LongMemEval streams. The regime flips at the fraction of the window corresponding to its real change year, so the switch-time distribution is empirical (TempLAMA spread across 2012–2019) rather than designed. Restricting to two regimes is a deliberate simplification that keeps each key a clean flip; multi-change keys are left to future work. The two rows per model (Schedules A and B) share the same real switch times and differ only in the hashed visit order.

The same frozen mechanism transfers from constructed schedules to two independent real-drift sources (Wikidata facts and Wikipedia-table questions), with the disagreement-slice levels making the gap interpretable and the full-stream gap a steadier +3 to +5 points.

Accuracy–harm frontier

Table 14 is the full accuracy–harm summary on the harm-exposure schedule; Figure 3 visualizes it: RegimeCouncil (red star) matches best-local harmful exposure while exceeding best-global accuracy, placing it on the favorable corner of the frontier. On the disagreement slice of this schedule, RegimeCouncil exceeds max(GG, LL) of its frozen advisors by 4.9 points on Qwen (ndisn_{\mathrm{dis}}=143) and 6.4 points on GPT-4o (ndisn_{\mathrm{dis}}=140).

ModelMethodAccuracyHarm exposureDrawdown
QwenNo memory48.900
Always memory76.7236
Best global (W=16W=16)76.7162
Best local (W=1W=1)75.981
RegimeCouncil78.481
GPT-4oNo memory48.600
Always memory79.0202
Best global (W=16W=16)79.0162
Best local (W=1W=1)78.451
RegimeCouncil81.051

Table 14. Complementary Pareto summary on the harm-exposure schedule.

Accuracy vs. harmful-memory exposure on the harm-exposure schedule, with Qwen3-30B-A3B and GPT-4o panels

Figure 3. Accuracy vs. harmful-memory exposure on the harm-exposure schedule. Blue circles: Global window. Green squares: Local (per-key). Orange diamonds: no / always memory. Red star: RegimeCouncil. Black outlines mark the best Global and best Local settings from Table 14.

Observable-conflict selection (not a RegimeCouncil result)

FactConsolidation places both writes in the prompt, so conflict is observable, and the comparison is certified selection between generic retrieval and last-write-wins rather than the Global/Local council under a hidden valid bit. Table 15 records it only so the rule can be inspected outside the main claim.

ModelGen@5Gen@20LWW@5LWW@20SelectedGuardedOnline Meta
GPT-4o19.120.655.954.4LWW@2054.454.4
Qwen17.617.642.639.7LWW@542.641.2

Table 15. Observable-conflict selection on MemoryAgentBench 64K (held-out %, n=68n=68). Not a RegimeCouncil score: both writes are in the prompt, and the choice is between generic retrieval and last-write-wins. Lifts of the selected policy over Gen@5: 35.3 points on GPT-4o and 25.0 on Qwen. Generic k=20k=20 never certifies.

The anchor is generic top-5 retrieval; challengers are generic top-20 and last-write-wins (LWW) at k∈{5,20}k \in\{5, 20\}. Certified selection uses Bonferroni 0.05/3 on the certification split only (n=132n=132); the reported accuracies are on the held-out split (n=68n=68). Online Meta applies the frozen surplus rule (Wm=8W_m=8, gate 0) between Gen@5 and LWW@5 after a certification warm-start.

Artifact index

Our reproducibility package includes the dataset builders (the LongMemEval streams, the 54-key pool, and the TempLAMA and TAQA real-drift sets), the cache fillers and cached model completions, the frozen router, and the evaluation runners that reproduce every table in this paper. The runners accept configuration files rather than hard-coded paths, so every result can be regenerated without editing source.

Prompt templates

RegimeCouncil does not prompt the LLM to choose Global versus Local. The model only answers the user question; the router is a deterministic function of paired utilities. We therefore cache three completions per key and never vary the prompt across routing methods.

Delayed-feedback QA. The main 16-key caches use the following template. The optional snapshot line is omitted for the no-memory completion and filled with the old or new answer for the two memory completions. Display order of the two records is arbitrary and is not a recency cue.

Two memory records conflict.  Their display order is arbitrary and the
currently valid regime is hidden.  Return only the short answer.
{collision observation}
A deployed feedback snapshot records the correct answer for this key
as: {snapshot}
[snapshot line included only for memory completions; omitted for no-memory]
Question:  {question}

A concrete fill-in for the volleyball-record question (abridged collision text):

Two memory records conflict.  Their display order is arbitrary and the
currently valid regime is hidden.  Return only the short answer.
Conflicting memory A: [...]  I’ve been doing pretty well in the
volleyball league, we’re 3-2 so far!
Conflicting memory B: [...]  our volleyball team, the Net Ninjas, is
doing well with a 5-2 record.
Question:  What is my current record in the recreational volleyball
league?

Without a snapshot the model must guess from two unordered records. With a snapshot it is given one of {3-2, 5-2} as the last committed write for that key; that write may already be stale relative to the hidden valid bit, which is why using memory is sometimes harmful. Because the exact same prompt template and cached completions are shared by the Global Advisor, the Local Advisor, and RegimeCouncil, prompt wording cannot favor one routing policy over another (and standard RAG models exhibit the same staleness vulnerability under neutral retrieval headers on LongMemEval (Wu et al., 2025)).

Observable-conflict prompts. On the appendix MemoryAgentBench check the LLM sees retrieved facts and a conflict rule. Generic top-k uses “Answer from the retrieved facts.” Last-write-wins additionally states that larger serial numbers are newer. The surplus rule still selects between two cached policies; it does not appear in the prompt.

Worked disagreement episodes

Table 16 walks through two Schedule A episodes on Qwen where Global and Local disagree. Utilities are 1 if the chosen completion matches the hidden gold and 0 otherwise. “Use memory” means deploy the delayed snapshot; “skip” means the no-memory completion.

Episode (hidden gold)GlobalLocalMetaRC
Volleyball record (3-2)useskipoverrideuse (correct)
Spare screwdriver (No)skipusekeep Localuse (correct)

Table 16. Two disagreement steps on Schedule A (Qwen). Global pools the last 32 paired advantages; Local reads only the current key. Meta overrides Local only if recent counterfactual surplus is strictly positive.

Helpful override. Visit 7 of the volleyball-record question, while the old write is still valid (gold 3-2). The delayed snapshot still matches the old write, so using memory is correct on this step

(u=1u=1) and skipping is not (u=0u=0). Local’s last outcome on this key was non-positive, so Local skips. The pooled window is already positive—other keys have shown that the current snapshot generation is useful—so Global proposes to use memory. Meta has accumulated At>0A_t > 0 and overrides. RegimeCouncil deploys memory and is correct; a local-only rule would have abstained.

Correct local default. Visit 14 of the spare-screwdriver question, while the old write is still valid (gold No). Local’s last visit to this key was positive, so Local proposes to use memory. The pooled window is non-positive after mixed flips, so Global skips. Surplus is not positive, Meta keeps the local default, and RegimeCouncil again deploys memory correctly. A global-only rule would have skipped.

These two steps are the mechanism in miniature: the governor reads no part of ztz_t and only compares the two advisors’ counterfactual utilities on completed episodes. On Schedule A, helpful overrides outnumber harmful ones (10 vs. 2 on Qwen).

Extended robustness, feedback relaxations, and cost analysis

This appendix reports additional evaluations using the fixed router configuration (Wg=32W_g=32, Wℓ=1W_\ell=1, Wm=8W_m=8, gate 0) without retuning.

Tie-deferral rule, clustered shifts, and adaptive baselines

Disagreements between Global and Local (gt≠ℓtg_t \ne\ell_t) fall into two cases: (i) Case 1 (no Local signal, d=0d=0 or unseen key), which accounts for 81% of disagreements (10,451 of 12,915) across the 30 held-out settings; and (ii) Case 2 (conflicting non-zero Local signal, d≠0d \ne0), which dominates when a cluster of facts becomes stale together. Table 17 compares the default RegimeCouncil (which abstains on Local ties to minimize harmful memory exposure), a standalone tie-deferring Local rule without the Meta Governor (follow Global when Local has no signal, keep Local otherwise), a combined variant (RC-refined: tie-deferring Local with the Meta Governor At>0A_t > 0), and tuned adaptive baselines (Fixed Share, CUSUM, and follow-recent-winner) across Case 1 (30 held-out streams), Case 2 (54-key clustered and store-wide shifts), and a combined Case 1 + Case 2 two-stage 54-key stream (asynchronous flips in the first half followed by store-wide flips in the second half).

Separately varying snapshot commit interval and outcome delay tau

Tables 18 and 19 vary the snapshot commit interval (at τ=1\tau=1) and the outcome revelation delay τ∈[1,96]\tau\in[1,96] (at fixed commit interval 6K) independently. When corrections are written back before the key’s next visit (commit ≤16\le16), always using memory suffices (93.0%); between revelation and consolidation (commit ∈[32,192]\in[32,192]), RegimeCouncil lifts accuracy by +0.5 to +5.5 points (+1.4 to +5.6 with RC-refined). Across outcome delays τ\tau, effective delay scales with τ/K\tau/K per Proposition 1(ii), and RC-refined remains strictly positive at every τ∈[1,96]\tau\in[1,96] across all four pools (126/126 settings).

In-conversation drift-rate variation, sparse/noisy/bandit feedback, and computational cost

Across 16 mid-stream drift-rate shift settings (per-visit flip hazard shifting between 0.04 and 0.30 in both directions across 16/54 keys and both models), default RegimeCouncil achieves 68.1% full-stream accuracy and a +4.3 median disagreement-slice gain, outperforming max⁡(G,L)\max(G,L) in all

16/16 settings (and remaining positive across shifts between 0.02 and 0.20, shifts between 0.05 and 0.40, three-stage shifts from 0.02 to 0.14 to 0.35, and sinusoidal drift over [0.02, 0.35]). Table 20 summarizes performance under variable in-stream delays, sparse or noisy revelation, executed-action-only bandit feedback (via inverse-propensity estimation d^t\hat{d}_t with ϵ=0.05\epsilon=0.05), and per-episode computational cost relative to the Global Advisor alone.

References

  1. [1]Omar Besbes, Yonatan Gur, and Assaf Zeevi. Stochastic multi-armed-bandit problem with non-stationary rewards. In Z. Ghahramani, M. Welling, C. Cortes, N. Lawrence, and K. Weinberger (eds.), Advances in Neural Information Processing Systems, volume 27. Curran Associates, Inc., 2014. URL https://proceedings.neurips.cc/paper_files/paper/2014/file/91b7292e5388b90b8839a7f19ec-Paper.pdf.DOI
  2. [2]Wang Chi Cheung, David Simchi-Levi, and Ruihao Zhu. Learning to optimize under non-stationarity. In Proceedings of the Twenty-Second International Conference on Artificial Intelligence and Statistics, pp. 1079–1087. PMLR, 2019.arxiv.org/abs/1810.03024
  3. [3]Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. Mem0: Building production-ready AI agents with scalable long-term memory. In ECAI 2025, volume 413 of Frontiers in Artificial Intelligence and Applications, pp. 2993–3000. IOS Press, 2025. doi: 10.3233/FAIA251160.DOI
  4. [4]Amit Daniely, Alon Gonen, and Shai Shalev-Shwartz. Strongly adaptive online learning. In Proceedings of the 32nd International Conference on Machine Learning, pp. 1405–1411. PMLR, 2015.arxiv.org/abs/1502.07073
  5. [5]Bhuwan Dhingra, Jeremy R. Cole, Julian Martin Eisenschlos, Daniel Gillick, Jacob Eisenstein, and William W. Cohen. Time-aware language models as temporal knowledge bases. Transactions of the Association for Computational Linguistics, 10:257–273, 2022.
  6. [6]João Gama, Indrè Žliobaitė, Albert Bifet, Mykola Pechenizkiy, and Abdelhamid Bouchachia. A survey on concept drift adaptation. ACM Computing Surveys, 46(4), 2014.
  7. [7]Mark Herbster and Manfred K. Warmuth. Tracking the best expert. Machine Learning, 32(2): 151–178, 1998. doi: 10.1023/A:1007424614876.DOI
  8. [8]Yuanzhe Hu, Yu Wang, and Julian McAuley. Evaluating memory in LLM agents via incremental multi-turn interactions. In International Conference on Learning Representations, 2026.arxiv.org/abs/2507.05257
  9. [9]Chi Jin, Sham Kakade, Akshay Krishnamurthy, and Qinghua Liu. Sample-efficient reinforcement learning of undercomplete POMDPs. In NeurIPS, 2020.arxiv.org/abs/2006.12484
  10. [10]Kwang-Sung Jun, Francesco Orabona, Stephen Wright, and Rebecca Willett. Improved strongly adaptive online learning using coin betting. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, pp. 943–951. PMLR, 2017.arxiv.org/abs/1610.04578
  11. [12]Qingcan Kang, Mingyang Liu, Shixiong Kai, Kaichao Liang, Tao Zhong, and Mingxuan Yuan. Learning what to remember: Observability-safe memory retention via constrained optimization for long-horizon language agents. arXiv preprint arXiv:2606.10616, 2026b.arxiv.org/abs/2606.10616
  12. [13]Akshay Krishnamurthy, Alekh Agarwal, and John Langford. Pac reinforcement learning with rich observations. In NeurIPS, 2016.arxiv.org/abs/1602.02722

Paper details

vlnc:W_pz87auvw
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 5

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents