Brilliant paper on agent memory from FAIR at Meta.

(bookmark it)

A single global history is the usual way to let agents learn from past runs. When tasks are interleaved, it gains almost nothing over no memory at all, an average of +0.015 in normalized reward.

This work proposes Routed Continual Learning. Past trajectories are grouped into clusters, and each cluster keeps its state in one memory system from a fixed library. Before each run, an LLM router reuses a cluster or creates a new one.

They tested it on a stream mixing 301 CL-Bench instances with 97 banking instances from τ³-Bench, across four language models.

Routed CL raised reward over the global history by 15% to 30% of the maximum attainable reward. Estimated API cost fell by 65% to 72%.

The runs were sequential, so parallel agents updating one cluster remain untested.

If your agents handle mixed work, it might help to split their memory into clusters before adding a bigger memory system.

https://arxiv.org/abs/2610.38796

Chat with Paper: https://academy.dair.ai/papers/routed-continual-learning-2610.38796…

Routed Continual Learning

Source: https://arxiv.org/html/2610.38796 Mahesh BalakrishnanAffiliation:FAIR at MetaDavid GeraghtyAffiliation:FAIR at MetaDavid MaoAffiliation:FAIR at MetaVidhya VenkatAffiliation:FAIR at MetaIlya MironovAffiliation:FAIR at Meta

Abstract

Agents deployed at scale repeatedly encounter related problems, and it is natural to let them learn from each other’s experience rather than starting over each time. Unfortunately, there is no single way to retain that experience that works well across settings, and no way to know in advance which future problems a given experience will help with. A global history preserves every detail but becomes expensive and mixes together experience that may not belong together; compressing that history into one fixed representation limits the cost but can throw away valuable details.

We introduce Routed Continual Learning (Routed CL), an architecture that decides how to partition and retain experience. Past trajectories are grouped into clusters, each of which maintains state using one memory system from a fixed library. Before each run, an LLM-based router either reuses an existing cluster or creates a new one, basing its decision on the problem statement, memory system descriptions, and cluster summaries. We also introduce Context Memory Adapter, which mediates between the memory system and the agentic loop by augmenting the agent’s initial context with the memory system’s outputs and updating the selected cluster with information from the trajectory.

We evaluate the architecture on a heterogeneous stream that interleaves 301 instances from the six CL-Bench tasks with 97 banking instances fromτ3\tau^{3}-Bench, for 398 instances total. Across four language models and five matched rollouts, Routed Continual Learning raises normalized reward over a single global in-context learning (ICL) history by 15–30% of the maximum attainable normalized reward, achieves higher mean normalized reward than ICL-only clustering, and reduces estimated API cost by 65–72% relative to Global ICL. These results support approaching continual learning as a routing problem that chooses both a learning mechanism and a state cluster rather than committing to one representation globally.

††date:October 2026††correspondence:Michael Philip at[email protected]## 1Introduction

State-of-the-art agentic systems are designed to operate at scale, with distributed heterogeneous agents acting concurrently and independently. Many of these agents encounter related problems and could benefit from shared knowledge, which can reduce token cost, improve task performance, and keep agents from repeating one another’s mistakes. One striking example occurred during a recent OpenAI cyber-capability evaluation. Independently instantiated agents created an unintended shared message board and used it to propagate exploit findings across runs. The resulting exchange of information enabled agents in the broader evaluation to obtain breakthrough capabilities beyond the reach of individual agents(OpenAI, 2026;Greenblatt et al., 2026).

Our goal is to make such sharing deliberate: to build a system that supplies agents with relevant prior experience by design, rather than expecting them to develop one. To this end, we must decide what information to extract from trajectories, how to represent it, which agents should receive it, and when it should be provided. Different applications may require different answers to these questions; no single memory system is optimal across all of them. For example, coding-heavy tasks may benefit from a repo index, tool-oriented workloads from examples, knowledge tasks from grounded facts, data analytics from time-series models, etc.

The distributed environment of an enterprise setting compounds these challenges: agents are built by different teams, wrap different models, and have no reason to know that other agents exist. Our architecture places minimal requirements on the agents it supports. It intercepts an agent’s prompt and, when useful, injects relevant content directly into the agent’s context, requiring no explicit cooperation.

The result of this work is an architecture with two central features:

• •Transparent deployment:The architecture requires neither coordination among individual agents nor changes to how they operate.
• •Routing:Because no single memory system serves every application equally well, a routing component selects a memory system and relevant prior state for each run.

Table 1:Normalized reward across five matched rollouts. Each cell reports the mean and the range as[min,max][\min,\max]. Stateless-reference gain is reported separately in Table4. Higher is better; bold marks the best of the four staged conditions. Ground-truth assignment uses source-task identity, unavailable to the router, to apply a fixed memory-system–cluster mapping specified before confirmatory evaluation.Continual Learning Bench (CL-Bench;Asawa et al., 2026) provides a useful starting point for evaluating an implementation of this architecture. Following CL-Bench’s convention, we call each individual problem aninstance; a sequence of instances from the same domain is atask. Examples of these tasks include text-to-SQL transformations and playing poker against deterministic opponents. An instance of a task for the first example is a single natural-language question that may require multiple SQL queries to resolve; an instance of the poker task is a single hand. CL-Bench evaluated six such tasks in isolation and found that naïve in-context learning (ICL) outperformed dedicated memory systems on the aggregate metric. Retaining prior trajectories provides a strong baseline when each task is evaluated separately, which is the target scenario for the benchmark. This approach becomes less effective when different tasks are interleaved: a single history combines experience that may be useful for one task but irrelevant for another. A learning system must therefore decide what observations to share among which instances, and when to use a different memory system.

To expand the range of tasks beyond CL-Bench, we incorporate the Banking Knowledge domain fromτ3\tau^{3}-Bench(Shi et al., 2026). Each instance is a multi-turn customer-service conversation in which an agent must follow a domain policy, retrieve unstructured knowledge, and use tools while interacting with a simulated user. This contributes 97 thematically related instances with an interaction structure and reward function substantially different from those of the six CL-Bench tasks.

We introduceRouted Continual Learning, which assigns each instance to aclusterthat couples a memory system with a set of prior trajectories (that can be empty). Before each instance, arouter, implemented as a large language model (LLM), decides whether to reuse an existing cluster or create a new one, in which case the router selects a memory system from a fixed library. The memory system defines the learning mechanism; the cluster maintains the memory system’s state and publishes a summary to guide assignment of future instances. The router uses only the current instance, memory system descriptions, and cluster summaries; task labels during the benchmark evaluation are not supplied.

Our five memory systems (Table2) retain prior trajectories, distill reusable reasoning strategies, or model structured numerical state. Some memory systems require mapping a task-specific schema into generic state. We therefore introduceContext Memory Adapter, a shared runtime that derives this mapping, or adapter, from prior experience and supplies learned state through the agent’s context.

We evaluate four language models on a heterogeneous 398-instance stream combining all six CL-Bench tasks with 97τ3\tau^{3}-Bench banking instances. Four staged conditions progressively add capabilities: Stateless ICL (no cross-instance state), Global ICL (one shared history), Routed ICL (router-partitioned ICL histories), and Routed CL (the full memory system library). We compare these conditions on normalized reward and API cost.

Our contributions are:

• •We formulate continual learning over heterogeneous, interleaved instance sequences as a joint decision: how to represent experience and which instances should share state.
• •We introduce Routed Continual Learning, which for each instance selects a memory system from a fixed library and a cluster to hold its resulting state.
• •We show that across four language models and five matched rollouts, Routed CL improves normalized reward over both Global ICL and Routed ICL while reducing estimated API cost by 65–72% relative to Global ICL.

2Related Work

Analysis of algorithms and learning theory.Before turning to agentic systems, we recall earlier lines of work that share the same central insight: An algorithm or system tuned for a single-shot task differs from one optimized holistically for a sequence of related tasks, which is arguably the more practically relevant regime. By retaining state across tasks, the system can learn from experience, amortize computational effort, transfer knowledge, and adapt to the empirical task distribution.

The amortized complexity analysis of algorithms and data structures(Tarjan, 1985)considers the average cost of a sequence of operations rather than their peak complexity, establishing, for instance, competitive guarantees for the LRU caching policy and amortized guarantees for splay trees(Sleator and Tarjan, 1985a;Sleator and Tarjan, 1985b). Self-improving algorithms adapt to the data distribution(Ailon et al., 2006), converging to the optimal expected complexity.

In online learning, samples are revealed incrementally; the main challenge is to perform competitively relative to a baseline chosen in hindsight after observing the entire sequence(Shalev-Shwartz, 2012). Continual learning concerns models that learn from a sequence of tasks or changing data distributions, aiming to adapt to new information while retaining previously acquired knowledge(Parisi et al., 2019).

Prompt rewriting and context augmentation.Model performance can be improved at inference time by adapting both how a task is specified and what information is supplied to the model. Automatic Prompt Engineering (APE) shows that automatically generating task instructions can outperform manually designed prompts(Zhou et al., 2023); more recently, GEPA demonstrates that prompts can be iteratively improved through LLM-based reflection on execution trajectories(Agrawal et al., 2026). Eevee jointly optimizes a router and a set of prompts, coupling routing to prompt updates so that each prompt specializes to the inputs it receives(Xu et al., 2026). APE and GEPA optimize prompts offline, over a batch of accumulated tasks; Eevee assumes ground-truth labels for training its router. Routed Continual Learning makes online choices, selecting a memory system and a cluster for each instance as it arrives, from a fixed library whose members we do not optimize.

Context augmentation enriches the model’s input with retrieved knowledge or sampled outputs(Ram et al., 2023;Luo et al., 2024). Dynamic Cheatsheet maintains a single evolving memory of strategies and solutions carried across problems(Suzgun et al., 2026). Agentic Context Engineering (ACE) grows this memory through incremental edits rather than full rewrites, which reduces the risk of context collapse that repeated rewriting can cause(Zhang et al., 2026b). Both systems accumulate one context across all problems; Routed Continual Learning instead partitions accumulated state into separate clusters and selects among them, so that unrelated problems need not share a history.

Memory systems.Systems that give agents access to past experience differ mainly in what they keep: raw context, distilled facts, advice, structured procedures, or latent vectors. Routed Continual Learning is compatible with all of them: it picks a memory system per instance from a fixed library, and keeps each pick’s state in its own cluster.

MemGPT treats the context window like physical memory, paging information in and out of external storage as the agent requests it through function calls(Packer et al., 2023), while CoEvo-Mem learns the retrieval policy itself, adjusting how memories are fetched as it refines what they contain(Ye et al., 2026). Mem0 pulls relevant facts from each trajectory and reconciles them against what it already holds, adding, revising, or deleting entries as it goes(Chhikara et al., 2025).

Reflexion writes a short self-critique after a failed attempt and reads it back on the next try(Shinn et al., 2023); ExpeL abstracts insights that hold across tasks(Zhao et al., 2024); Dynamic Cheatsheet keeps a running note of strategies that have worked(Suzgun et al., 2026); ACE grows a playbook of scored bullets, editing it in small increments so earlier entries survive(Zhang et al., 2026b); and ReasoningBank mines both successes and failures for reusable reasoning strategies(Ouyang et al., 2026).Fang et al. (2026)propose trajectory-informed memory generation that groups experience by outcomes: clean successes, runs that failed and recovered, and runs that succeeded wastefully.

Other systems retain something other than free-form text from past executions. Agent Workflow Memory extracts reusable workflows(Wang et al., 2025); Voyager accumulates a library of executable skills(Wang et al., 2024); MemGen maintains a latent space representation(Zhang et al., 2026a).

Standard harness hooks and rewriters.Most agent frameworks already expose a point at which a message can be intercepted and modified before an agent’s own logic runs, without changing the agent itself. AutoGen’s ConversableAgent, for instance, lets a caller register hooks that fire before a reply is generated, including one that updates the agent’s state(Wu et al., 2024). Production deployments extend the same idea into guardrail and middleware layers, where an input hook inspects or rewrites a message on its way to the model and an output hook does the same to the response, again without modifying the agent’s own code. In our implementation, Context Memory Adapter attaches at exactly this point: rather than validating or filtering a message, it augments the prompt to include retrieved memory content, using the same hook mechanism these frameworks already provide for other purposes.

3Problem Formulation

Routed continual learning addresses settings in which neither the appropriate representation of past experience nor the prior state relevant to a new instance is known in advance. We consider a causally ordered, heterogeneous stream containing interleaved instances from several source tasks, without explicit task labels. Using only the visible instance specification, memory system descriptions, and cluster summaries, the system must determine how to represent experience and which instances should share state.

Heterogeneous continual streams.Continual Learning Bench (CL-Bench) defines a task as an ordered sequence of problem instances(Asawa et al., 2026). We study a setting in which instances from multiple such source tasks are interleaved into one heterogeneous stream. Let source taskd∈{1,…,D}d\in\{1,\ldots,D\}provide instancesxd,1,…,xd,Ndx_{d,1},\ldots,x_{d,N_{d}}. The evaluated streamx1,…,xNx_{1},\ldots,x_{N}, whereN=∑d=1DNdN=\sum_{d=1}^{D}N_{d}, preserves the order of instances within each source task. At positiontt, the system receives the visible specification ofxtx_{t}: its natural-language prompt and required structured response format. It does not receive an explicit task label or information about its relationship to earlier instances.

Completing an instance produces an agent-visible trajectoryτt\tau_{t}containing the instance prompt, model actions, tool outputs, and feedback revealed through normal interaction. The environment also assigns rewardrtr_{t}for evaluation, but does not share it with the learning system. At every decision, the system may use only information exposed by that point in the interaction.

Continual-learning memory systems.We call the component of our architecture that retains experience across agentic runs a continual-learning memory system. Letℳ\mathcal{M}be a finite library of such systems whose implementations and allowed configuration schemas are fixed before evaluation. A memory system renders text from its state for the actor’s context and updates that state by consuming trajectories. Once clustercc, backed by systemmm, has been configured, these operations are

zt=𝚛𝚎𝚊𝚍m​(Sc,t,xt,θc),Sc,t+1=𝚞𝚙𝚍𝚊𝚝𝚎m​(Sc,t,τt,θc),z_{t}=\mathtt{read}_{m}(S_{c,t},x_{t};\theta_{c}),\qquad S_{c,t+1}=\mathtt{update}_{m}(S_{c,t},\tau_{t};\theta_{c}),whereSc,tS_{c,t}is the cluster state,θc\theta_{c}is its cluster-specific configuration, andztz_{t}is text added to the actor’s context. Only the selected cluster’s state is updated. Multiple agents may interact with the same cluster concurrently;𝚛𝚎𝚊𝚍\mathtt{read}and𝚞𝚙𝚍𝚊𝚝𝚎\mathtt{update}operations are atomic.

Some memory systems require task-specific bindings between the task schema and generic state. For those systems, Context Memory Adapter derives the cluster-specific adapter configurationθc\theta_{c}from prior runs; other systems use fixed interfaces. Memory systems interact with the agent through context; they neither act in the environment nor modify its parameters.

Stateful routing.The system must choose both a learning mechanism and the cluster whose state the current trajectory will read and update. A clusterccis an isolated instance of one memory system, with its own state and an immutable descriptionδc\delta_{c}of which instances should share that state; multiple clusters may use the same system. LetCtC_{t}be the clusters available before instancett. Givenxtx_{t}, memory system descriptions, and summariesΣ⁡(Ct)\Sigma(C_{t}), the routerπ\pichooses either𝚛𝚎𝚞𝚜𝚎⁡(c)\mathtt{reuse}(c)forc∈Ctc\in C_{t}or𝚌𝚛𝚎𝚊𝚝𝚎⁡(m,δ)\mathtt{create}(m,\delta)form∈ℳm\in\mathcal{M}. The choice remains fixed during the instance. New clusters begin from initial state. Reusing too broadly can mix unrelated state, while unnecessary creation can prevent useful transfer.

Thus, routing jointly selects a memory system and a cluster: Global ICL uses one ICL state, Routed ICL selects among ICL clusters, and Routed CL selects both.

4System Components

Routed CL comprises an LLM router, isolated stateful clusters, a fixed memory-system library, and Context Memory Adapter. The memory system determines how experience is retained, while the cluster determines which instances share state. Upon receiving an instance, the router chooses an existing cluster or creates a new one; the cluster assignment stays static throughout the instance execution. Figure1summarizes this lifecycle.

Figure 1:Overview of Routed Continual Learning. Before each instance, the router chooses a memory system and either reuses or creates a stateful cluster. Context Memory Adapter reads its state and augments the task context before execution; the selected cluster is updated from the trajectory, while all other clusters remain unchanged. The displayed clusters are illustrative; the pool grows as clusters are created and reused online.### 4.1Router and Stateful Clusters

The router implementsπ\piwith one structured-output LLM call before each instance. It receives the visible prompt and response schema, each memory system’s declared learning behavior, and, for every cluster, only its identifier, memory-system type, immutable description, and completed-trajectory count. It cannot inspect raw trajectories, internal memory-system state, or hidden conversation state from earlier routing calls.

The router is prompted rather than trained. Its prompt and memory-system library remain fixed during evaluation, and it receives no source-task labels or rewards.

4.2Frozen Memory-System Library

Mechanism selection is meaningful only when memory systems encode different assumptions about reusable information. We use five systems spanning three representation families (Table2). The router chooses among the five concrete systems; the families only organize the presentation and do not create another routing layer. These systems are examples rather than a canonical taxonomy. The library was selected during exploratory development on CL-Bench and frozen before confirmatory evaluation; our experiments test selection and configuration within it, not the synthesis of new memory-system families.

Table 2:Five memory systems grouped by the form of state they retain.In-context Learning (ICL).Each ICL cluster retains visible prompts, actor responses, and feedback as an ordered history, discarding the oldest messages only at the model context limit. Its only abstraction is the router-defined cluster boundary.

ReasoningBank.We adapt ReasoningBank(Ouyang et al., 2026)to the Context Memory Adapter interface. After each completed visible trajectory, the same backbone model judges whether the attempt succeeded or failed and extracts up to three structured memory items capturing reusable strategies or failure-avoidance lessons. Before a later instance, the system retrieves the memories associated with the most similar prior request and injects them at the instance boundary. Our adaptation uses no hidden rewards, uses frozen local embeddings, and does not use ReasoningBank’s test-time-scaling extension.

Numerical memory systems.The numerical systems’ statistical libraries consume generic typed records and contain no CL-Bench task names, task-specific fields, prompts, or scoring logic. Hierarchical Regression and Hierarchical Discrete-Event State use PyMC(Abril-Pla et al., 2023), and Persistent-Entity State uses River’s Bayesian linear regression(Montiel et al., 2021); task semantics enter through adapter bindings and extracted evidence. AppendixB.2provides implementation details.

4.3Context Memory Adapter

Context Memory Adapter configures cluster-specific adapters when a memory system requires task-specific bindings, and exposes the selected cluster’s state through the actor’s context; AppendixB.1describes the adapter lifecycle and validation procedure. An adapter supplies only schema-bounded semantic bindings and permitted configuration choices, never parser code or task answers, so online adaptation is limited to routing, bounded configuration, and state updates within a frozen library.

To isolate continual learning from task execution, Context Memory Adapter never acts in the environment or submits an answer. Before the first actor turn, it may inject a budget-bounded advisory alongside the unchanged prompt; the advisory remains in the within-instance history. The selected cluster is updated only with information from its assigned trajectory. The same actor retains its original tools and response schema, and only its response is scored. Context Memory Adapter cannot access hidden tests or evaluation rewards, so memory affects behavior solely through context.

5Experiments

Benchmark and heterogeneous stream.Routed Continual Learning is intended for streams where prior experience can help, but the system is not told which memory system to use or which instances should share state. Evaluating the source tasks separately would test individual learning mechanisms but not the routing problem. We therefore construct a heterogeneous stream by interleaving all 301 instances from the six CL-Bench tasks(Asawa et al., 2026)with 97 Banking Knowledge instances fromτ3\tau^{3}-Bench(Shi et al., 2026), for 398 instances total. CL-Bench contributes six tasks spanning distinct interfaces, reward functions, and forms of reusable cross-instance information.τ3\tau^{3}-Bench adds multi-turn customer-service interactions requiring policy-grounded reasoning, knowledge retrieval, and tool use. The source tasks are summarized in Table3.

For each rollout, we form one heterogeneous stream by randomly interleaving the seven source-task sequences while preserving each source task’s canonical order. All systems are evaluated on the same set of five rollouts. Source-task labels used for analysis are not supplied to the router or agents. Native prompts, tools, response schemas, feedback, and reward functions remain visible, so routing may use observable task structure.

Compared systems.We compare four staged conditions with matched actors, task interfaces, budgets, model limits, and stream order. Stateless ICL resets after each instance; Global ICL shares one history across the stream; Routed ICL partitions that history among dynamically defined clusters; and Routed CL also selects among the five memory systems in Table2. Configurable clusters derive their adapters from observable warm-up experience on first reuse. All ICL histories use a 100K-token context budget, applied stream-wide for Global ICL and independently per cluster for the routed conditions.

Separately, we evaluate our ReasoningBank adaptation under two fixed-system configurations. Global RB maintains one memory store across the stream, whereas Routed RB maintains one store per router-selected cluster. This comparison uses three matched rollouts and is reported in AppendixC.2.

We also evaluate Ground-truth assignment, a privileged diagnostic that uses source-task identity and a fixed memory-system and cluster mapping chosen during exploratory development and frozen before confirmatory evaluation.

Models and repetitions.To assess whether our findings hold across model families, we evaluate four language models: Claude Opus 4.7, Claude Opus 5, GPT-5.6 Sol, and Gemini 3.7 Flash. Within each condition, every model-mediated role uses the evaluated model: the actor and any router, adapter configurator, typed extractor, ReasoningBank judge, or memory writer required by that condition. The fixedτ3\tau^{3}-Bench user simulator and evaluator are benchmark components shared across conditions.

To estimate variability from stream ordering and stochastic model outputs, we evaluate each model–condition pair over five complete rollouts. Because persistent state couples later instances to earlier behavior, the complete rollout is the unit of replication. For each language model, we summarize the five paired differences between methods.

Evaluation protocol.We froze all method components before confirmatory evaluation. Matched conditions receive the same task interface, feedback, budgets, and model limits; AppendixA.5gives the complete specification.

All task-derived evidence comes from the native task interface. The four staged conditions receive no source-task identities, privileged assignments, hidden tests, or held-out rewards; Ground-truth assignment receives only source-task identity. To prevent cross-instance leakage, we reset Sales Prediction’s writable workspace and expose Codebase Adaptation actors only to base-commit snapshots, with regression tests reserved for evaluation. These changes apply to every method but make the affected results not directly comparable to historical CL-Bench runs (AppendicesA.4.1andA.4.2).

Resource totals include every model call. AppendixDreproduces the fixed prompts and memory-system descriptions.

Metrics.We report normalized reward as the primary metric. For the six CL-Bench tasks, the external stateless reference published with CL-Bench maps to 0 and the task maximum to 1; scores below the reference are negative.τ3\tau^{3}-Bench instead uses its native[0,1][0,1]reward, and all seven source tasks are weighted equally. Our secondary metric, stateless-reference gain, compares each method with Stateless ICL using the same language model and matched interleaving: 0 denotes matched Stateless ICL performance and 1 the task maximum. AppendixA.6provides the complete definitions.

We estimate API cost for every model call using a frozen, dated public list-price schedule that accounts for token caching. AppendixA.7gives the complete accounting policy.

6Results and Analysis

We demonstrate that Routed Continual Learning sharply improves aggregate reward over Stateless ICL and globally shared memory baselines, while costing substantially less than Global ICL. Detailed task- and model-level breakdowns are deferred to the appendix.

Global ICL loses its advantage under heterogeneous interleaving.CL-Bench found naïve ICL strongest when its tasks were evaluated as separate homogeneous streams(Asawa et al., 2026). In our interleaving, mean stateless-reference gain rises from 0.015 for Global ICL to 0.222 for Routed ICL and 0.280 for Routed CL. Figure4shows how this pattern develops over the stream. For Opus 4.7, Global ICL helps early but its gain declines later; for Opus 5, it remains worse than Stateless ICL throughout. The routed methods show larger gains later in the stream.

Clustering helps ICL but does not consistently help ReasoningBank.Routed ICL exceeds Global ICL by 0.117–0.241 normalized-reward points across models. By contrast, routing ReasoningBank produces no consistent reward gain and raises mean cost by 8–29% (Figure3). This may be because ICL exposes an entire cluster history, whereas ReasoningBank already retrieves memories selectively by request similarity.

Memory-system selection adds task-specific gains.Routed CL adds another 0.002–0.076 normalized-reward points. Gemini’s mean improvement is only 0.002 but is positive in four of five paired rollouts; the other models show larger gains. Table5reports the paired results. At the task level, Routed CL improves over Routed ICL on Cohort andτ3\tau^{3}-Bench for every model and on Spectrum for three of four models, while reducing cost on Sales and Spectrum for every model and on Cohort for three of four models (Figures5and6). On Sales, for example, Opus 5 maintains essentially unchanged reward at 0.34×\timesthe cost.

Figure 2:Mean normalized reward versus mean estimated API cost across the five matched rollouts in Table1. Estimated costs include every model call under the frozen pricing schedule. Within each model, lines connect Global ICL, Routed ICL, and Routed CL; Stateless ICL appears separately. Table6reports the exact mean costs.Routed CL achieves the highest mean reward among the four staged conditions for every model and lies on the empirical reward–cost Pareto frontier.Routed CL improves the reward–cost trade-off.Among the four staged conditions, Routed CL lies on the empirical reward–cost Pareto frontier for every model (Figure2). It achieves higher reward than Global ICL at 65–72% lower cost and costs 25–33% less than Routed ICL on three models; on Opus 4.7, it costs 5% more for a 0.034 reward gain. Routed CL costs more than ReasoningBank: relative to Global RB, it gains 0.189–0.358 reward points at 31–44% higher cost and achieves higher reward than Routed RB for every model (Figure3).

Routing leaves model-dependent headroom.Replacing the LLM router with Ground-truth assignment, a fixed source-informed diagnostic, raises normalized reward by only 0.008 for Opus 5 and 0.014 for GPT-5.6 Sol, but by 0.069 for Opus 4.7 and 0.071 for Gemini 3.7 Flash. Across 20 model–rollout combinations, the router independently chooses the same memory system in 86% of source-task cases, the same cluster partition in 91%, and both in 79% (Table8). Figure7visualizes the coupled Ground-truth assignment. Disagreements concentrate on Code for Gemini and Opus 4.7, which often select ReasoningBank rather than ICL, and on Sales for Gemini, which never selects hierarchical regression. Routed CL also trails Routed ICL on these pairs.

7Conclusion and Future Work

Agents learning across heterogeneous tasks must decide how to represent and group relevant experiences. We introduce Routed Continual Learning, which makes these decisions jointly by selecting a memory system and a stateful cluster for each agent run.

On our heterogeneous stream spanning CL-Bench andτ3\tau^{3}-Bench, Routed CL achieves higher reward than both Global ICL and Routed ICL for all four language models at substantial cost reductions (e.g., saving 65–72% compared to Global ICL). Notably, Global ICL, found to be the strongest performing system by the original CL-Bench when evaluated on isolated tasks, gains almost nothing (mean +0.015 in aggregated normalized reward) relative to the stateless condition when the tasks are interleaved. These results support treating continual learning as a routing problem that jointly determines how experience is represented and which instances share state.

Our experiments process instances sequentially, and each rollout uses one language model as the actor and for all model-mediated memory-system roles. Although the architecture isolates cluster state and defines atomic reads and writes, we do not evaluate simultaneous updates, stale reads, or cross-model reuse of cluster state. These remain important tests for distributed deployment.

Future work could study richer interactions between components: reading from multiple clusters for a single instance, and updating several clusters or memory-system representations from the resulting trajectory, while controlling cost and interference.

AI Use Statement

We used generative AI tools to help refine hypotheses and conceptual framing, provide feedback on experimental design, implement and debug the proposed methods and experimental infrastructure, inspect and compile experimental results, search relevant literature, prepare figures, and draft and revise portions of the manuscript. Large language models also serve as experimental actors, routers, and information extractors in the evaluated systems; those uses are described separately in the System Components and Experiments sections. The authors made all final research and writing decisions, reviewed and revised all AI-assisted text, verified citations against primary sources, tested AI-assisted code, and checked reported results against the underlying experimental records.

Ethics Statement

Our experiments use previously released benchmarks and simulated interactions. The motivating example in the Introduction highlights a capability risk: pooling experience can enable a group of agents to achieve outcomes beyond the capabilities of any individual agent, including in security-sensitive settings. Persistent state can also propagate sensitive, erroneous, or adversarial information. Deployments should therefore enforce task- and user-level authorization, provenance, retention and deletion policies, and isolation across security boundaries, while assessing the capabilities of the combined system rather than only its component models.

Reproducibility Statement

The System Components and Experiments sections specify the architecture, memory-system library, routing and adapter procedures, baselines, metrics, and matched-rollout protocol. The appendix reproduces the fixed prompts and memory-system descriptions and documents adapter validation, benchmark adaptations, environment isolation, the frozen evaluation contract, and cost accounting.

References

• Abril-Plaet al.(2023)O. Abril-Pla, V. Andreani, C. Carroll, L. Dong, C. J. Fonnesbeck, M. Kochurov, R. Kumar, J. Lao, C. C. Luhmann, O. A. Martin, M. Osthege, R. Vieira, T. Wiecki, and R. ZinkovPyMC: a modern and comprehensive probabilistic programming framework in Python.PeerJ Computer Science9,pp. e1516.Cited by:§4.2.
• Agrawalet al.(2026)L. A. Agrawal, S. Tan, D. Soylu, N. Ziems, R. Khare, K. Opsahl-Ong, A. Singhvi, H. Shandilya, M. J. Ryan, M. Jiang, C. Potts, K. Sen, A. Dimakis, I. Stoica, D. Klein, M. Zaharia, and O. KhattabGEPA: reflective prompt evolution can outperform reinforcement learning.InThe Fourteenth International Conference on Learning Representations,External Links:LinkCited by:§2.
• Ailonet al.(2006)N. Ailon, B. Chazelle, S. Comandur, and D. LiuSelf-improving algorithms.InProceedings of the Seventeenth Annual ACM-SIAM Symposium on Discrete Algorithms,SODA ’06,pp. 261–270.External Links:ISBN 0898716055Cited by:§2.
• Asawaet al.(2026)P. Asawa, C. M. Glaze, G. Orlanski, R. Ramakrishnan, B. Xu, A. Biswal, V. S. Chen, F. Sala, M. Zaharia, and J. E. GonzalezContinual learning bench: evaluating frontier AI systems in real-world stateful environments.External Links:2606.05661,LinkCited by:§A.6,§1,§3,§5,§6.
• Chhikaraet al.(2025)P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. YadavMem0: building production-ready AI agents with scalable long-term memory.External Links:2504.19413,LinkCited by:§2.
• Fanget al.(2026)G. Fang, V. Isahagian, K. R. Jayaram, R. Kumar, V. Muthusamy, P. Oum, and G. ThomasTrajectory-informed memory generation for self-improving agent systems.External Links:2603.10600,LinkCited by:§2.
• Greenblattet al.(2026)R. Greenblatt, A. Cotra, and H. WijkBrief independent investigation of agents’ behavior, reasoning and collaboration in the OpenAI/Hugging Face hacking incident.Technical reportMETR and Redwood Research.External Links:LinkCited by:§1.
• Luoet al.(2024)M. Luo, X. Xu, Y. Liu, P. Pasupat, and M. KazemiIn-context learning with retrieved demonstrations for language models: a survey.Transactions on Machine Learning Research.External Links:LinkCited by:§2.
• Montielet al.(2021)J. Montiel, M. Halford, S. M. Mastelini, G. Bolmier, R. Sourty, R. Vaysse, A. Zouitine, H. M. Gomes, J. Read, T. Abdessalem, and A. BifetRiver: machine learning for streaming data in python.Journal of Machine Learning Research22(110),pp. 1–8.Cited by:§4.2.
• OpenAI (2026)OpenAIThe Hugging Face incident and the road ahead.Note:Published August 26, 2026; accessed September 3, 2026External Links:LinkCited by:§1.
• Ouyanget al.(2026)S. Ouyang, J. Yan, I. Hsu, Y. Chen, K. Jiang, Z. Wang, R. Han, L. Le, S. Daruki, X. Tang, V. Tirumalashetty, G. Lee, M. Rofouei, H. Lin, J. Han, C. Lee, and T. PfisterReasoningBank: scaling agent self-evolving with reasoning memory.InThe Fourteenth International Conference on Learning Representations,External Links:LinkCited by:§C.2,§2,§4.2.
• Packeret al.(2023)C. Packer, V. Fang, S. G. Patil, K. Lin, S. Wooders, and J. E. GonzalezMemGPT: towards LLMs as operating systems.External Links:2310.08560,LinkCited by:§2.
• Parisiet al.(2019)G. I. Parisi, R. Kemker, J. L. Part, C. Kanan, and S. WermterContinual lifelong learning with neural networks: a review.Neural Netw.113(C),pp. 54–71.Cited by:§2.
• Ramet al.(2023)O. Ram, Y. Levine, I. Dalmedigos, D. Muhlgay, A. Shashua, K. Leyton-Brown, and Y. ShohamIn-context retrieval-augmented language models.Transactions of the Association for Computational Linguistics11,pp. 1316–1331.Cited by:§2.
• Shalev-Shwartz (2012)S. Shalev-ShwartzOnline learning and online convex optimization.Found. Trends Mach. Learn.4(2),pp. 107–194.Cited by:§2.
• Shiet al.(2026)Q. Shi, A. Zytek, P. Razavi, K. Narasimhan, and V. Barresτ\tau-Knowledge: evaluating conversational agents over unstructured knowledge.arXiv preprint arXiv:2603.04370.External Links:LinkCited by:§1,§5.
• Shinnet al.(2023)N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. YaoReflexion: language agents with verbal reinforcement learning.InAdvances in Neural Information Processing Systems,pp. 8634–8652.Cited by:§2.
• Sleator and Tarjan (1985a)D. D. Sleator and R. E. TarjanAmortized efficiency of list update and paging rules.Commun. ACM28(2),pp. 202–208.Cited by:§2.
• Sleator and Tarjan (1985b)D. D. Sleator and R. E. TarjanSelf-adjusting binary search trees.J. ACM32(3),pp. 652–686.Cited by:§2.
• Suzgunet al.(2026)M. Suzgun, M. Yuksekgonul, F. Bianchi, D. Jurafsky, and J. ZouDynamic cheatsheet: test-time learning with adaptive memory.InProceedings of the 19th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers),pp. 7080–7106.External Links:LinkCited by:§2,§2.
• Tarjan (1985)R. E. TarjanAmortized computational complexity.SIAM Journal on Algebraic Discrete Methods6(2),pp. 306–318.Cited by:§2.
• Wanget al.(2024)G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. AnandkumarVoyager: an open-ended embodied agent with large language models.Transactions on Machine Learning Research.Note:External Links:LinkCited by:§2.
• Wanget al.(2025)Z. Z. Wang, J. Mao, D. Fried, and G. NeubigAgent workflow memory.InProceedings of the 42nd International Conference on Machine Learning,ICML.Cited by:§2.
• Wuet al.(2024)Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, A. H. Awadallah, R. W. White, D. Burger, and C. WangAutoGen: Enabling next-gen LLM applications via multi-agent conversations.InFirst Conference on Language Modeling,External Links:LinkCited by:§2.
• Xuet al.(2026)W. Xu, S. Liu, and M. WangEevee: towards test-time prompt learning in the real world for self-improving agents.External Links:2606.11182,LinkCited by:§2.
• Yeet al.(2026)B. Ye, Y. Xu, Z. Li, X. Yin, J. Ma, and W. LiCoEvo-Mem: co-evolving retrieval policy and memory bank for LLM agents.External Links:2608.01739,LinkCited by:§2.
• Zhanget al.(2026a)G. Zhang, M. Fu, and S. YanMemGen: weaving generative latent memory for self-evolving agents.InThe Fourteenth International Conference on Learning Representations,External Links:LinkCited by:§2.
• Zhanget al.(2026b)Q. Zhang, C. Hu, S. Upasani, B. Ma, F. Hong, V. Kamanuru, J. Rainton, C. Wu, M. Ji, H. Li, U. Thakker, J. Zou, and K. OlukotunAgentic context engineering: evolving contexts for self-improving language models.InThe Fourteenth International Conference on Learning Representations,External Links:LinkCited by:§2,§2.
• Zhaoet al.(2024)A. Zhao, D. Huang, Q. Xu, M. Lin, Y. Liu, and G. HuangExpeL: LLM agents are experiential learners.InProceedings of the AAAI Conference on Artificial Intelligence,pp. 19632–19642.External Links:2308.10144Cited by:§2.
• Zhouet al.(2023)Y. Zhou, A. I. Muresanu, Z. Han, K. Paster, S. Pitis, H. Chan, and J. BaLarge language models are human-level prompt engineers.InThe Eleventh International Conference on Learning Representations,External Links:LinkCited by:§2.

Appendix AAdditional Experimental Details

A.1Source Tasks

Table 3:Source tasks used to construct the heterogeneous evaluation stream.

A.2Heterogeneous Stream Construction

Feedback produced by a source task that advances automatically is buffered and delivered when that source task is next activated. This preserves its causal position without attaching it to another task’s trajectory.

A.3Implementation and Rollout Configuration

The headline table aggregates five matched stream seeds (42–46) per model. Ground-truth assignment also reports five matched rollouts for every model.

A.4Benchmark Protocol Modifications

A.4.1Sales Prediction Workspace Isolation

The released Sales Prediction runtime preserves its writable execution environment across instances and explicitly encourages the actor to save code, models, and notes under/app. This provides a general-purpose cross-instance storage channel outside the continual-learning system being evaluated.

For every method in our evaluation, we instead discard the Sales container at each instance boundary and start a fresh one. The harness then reconstructs the current instance’s data room. Benchmark-provided observations, including the currently visible historical data and previous-round feedback, remain available through the native task interface; actor-created files do not persist. The task instructions are changed accordingly so that they accurately describe the execution environment. This isolation strengthens attribution to the evaluated continual-learning system but makes our Sales results not strictly protocol-equivalent to historical CL-Bench results.

A.4.2Codebase Adaptation Isolation

CL-Bench describes Codebase Adaptation as beginning from an issue’s base commit and evaluating the submitted patch against hidden regression tests. The CL-Bench 1.0 release commit (a7ddacb) did not fully enforce this separation. Actor workspaces retained the shared image’s Git database, from which later fix commits could be inspected, and the official regression-test patch was applied before the actor began interacting with the repository.

Our hardened actor initialization first restores the base commit and removes untracked and ignored build artifacts. It then removes the inherited Git database and creates a fresh repository containing only a single snapshot commit. The official regression-test patch is never applied in the actor container. Evaluation remains unchanged: after submission, a separate evaluator reconstructs the base tree, applies the hidden regression-test patch and the actor’s submitted patch, and runs the designated tests. The runtime records whether actor sanitization was enabled and whether the test patch was visible for every run.

This change matches the benchmark’s stated hidden-test protocol but differs from the released runtime used by historical runs. Aggregate results alone do not show whether a historical agent used either leakage channel. We therefore report our Code results as sanitized evaluations and avoid treating comparisons with historical Code scores as strictly equivalent.

A.5Frozen Evaluation Contract

Before confirmatory runs, we freeze the router prompt and memory-system descriptions; all memory-system implementations; the prompts and schemas used for adapter configuration, typed extraction, ReasoningBank self-judgment, and memory extraction; statistical defaults; the Ground-truth assignment mapping; and the task harness and scoring code. We do not revise these components in response to confirmatory outcomes. Within each matched comparison, systems receive the same native instance prompts, tools, response schemas, visible feedback, action budgets, and actor context-window and response limits.

When deciding how much retained ICL history fits, the runtime reserves 500 tokens within each configured 100,000-token budget. If the remaining history exceeds that allowance, it removes the oldest retained messages first. Global ICL applies this policy to one stream-wide history; Routed ICL and ICL clusters selected by Routed CL apply it independently per cluster.

Within each model–condition pair, the same evaluated model serves as the actor and, where applicable, powers selection, adapter configuration, typed extraction, ReasoningBank self-judgment, and memory extraction. Resource measurements include all of these calls.

A.6Metric Definitions

For a fixed language model and rollout seed, letr¯d​(M)\bar{r}_{d}(M)denote the mean native reward of methodMMon source taskdd.

Normalized reward.

For the six CL-Bench tasks, we follow CL-Bench and normalize each task’s reward using its external referencerdextr_{d}^{\mathrm{ext}}, the reported stateless GPT-5.4 ICL reward for taskdd(Asawa et al., 2026):

r¯d​(M)−rdextrdmax−rdext.\frac{\bar{r}_{d}(M)-r_{d}^{\mathrm{ext}}}{r_{d}^{\max}-r_{d}^{\mathrm{ext}}}.Here,rdmaxr_{d}^{\max}is the benchmark-defined maximum reward for taskdd. Forτ3\tau^{3}-Bench, whose native reward already lies in[0,1][0,1], we use that reward directly.

Stateless-reference gain.

Stateless-reference gain instead uses Stateless ICLBBwith the same language model and rollout seed:

r¯d​(M)−r¯d​(B)rdmax−r¯d​(B).\frac{\bar{r}_{d}(M)-\bar{r}_{d}(B)}{r_{d}^{\max}-\bar{r}_{d}(B)}.Both metrics are averaged equally across the seven source tasks. These task-level normalizations place heterogeneous rewards on a common scale; they do not make our mixed-stream and hardened protocols strictly comparable with historical aggregate CL-Bench results.

A.7API Cost Accounting

We include every model call used for actor decisions, selection, adapter configuration, typed extraction, ReasoningBank self-judgment, and memory extraction. Costs use a frozen, dated public list-price schedule. Uncached input, cache-read, cache-write, and output tokens are priced separately, and reasoning tokens reported separately by a provider are priced as output. This policy captures the caching advantage of long ICL histories.

Appendix BAdditional Method Details

B.1Adapter Validation and Evidence Repair

ICL uses a fixed interface, whereas ReasoningBank and the numerical memory systems use cluster-specific adapters. ReasoningBank’s adapter identifies the boundary between a repeated prompt wrapper and its changing request; its memory induction and retrieval behavior remain fixed. Numerical adapters instead bind visible task fields to roles such as targets, identities, groups, and time, and choose among the configuration options permitted by each memory system’s fixed typed schema.

A configurable cluster’s first instance receives the original prompt unchanged. Its completed trajectory becomes the warm-up example, and adapter configuration occurs only if the cluster is subsequently reused.

On the first reuse of a configurable numerical cluster, Context Memory Adapter configures its adapter from the completed warm-up trajectory together with the current visible prompt and response schema. A fresh memory-system runtime replays the warm-up trajectory, prepares the current instance, and checks the resulting state and bindings. If validation fails, Context Memory Adapter returns the deterministic error to the configuring LLM, which may return one complete repair. A second failure terminates adapter configuration rather than accepting an unvalidated configuration. Successful validation initializes the memory-system state from the warm-up trajectory, and the resulting adapter configuration is frozen for the lifetime of the cluster.

After configuration, numerical memory systems invoke a typed extractor whenever new evidence becomes available. The extractor receives one complete visible event, such as the current query or a completed trajectory, and emits the records required by the configured adapter. Memory-system-specific validators check their schema, internal consistency, and exact provenance against the source event. An invalid batch receives at most one validation-informed repair; persistent failure is reported rather than accepted or silently truncated. The extractor does not fit the statistical model, associate latent entities, or generate predictions. Those operations remain inside the fixed memory-system runtime.

B.2Numerical Memory-System Implementations

Hierarchical Regression.

This memory system models repeated numerical outcomes indexed by stable keys, categorical factors, and optionally time. Its adapter chooses the target family and temporal structure, while the extractor establishes consistent dimension names and emits requested prediction points and visible realized outcomes. The runtime pools accumulated evidence through hierarchical regression implemented in PyMC, with global, key-specific, factor, and temporal terms, refitting as new outcomes arrive. Once an estimate has repeated support, it renders a compact forecast with its fitted observation-noise estimate and recent observations; the actor may still revise that estimate using the current environment.

Hierarchical Discrete-Event State.

This memory system models monotone event-free probabilities over ordered intervals through conditional hazards. Its adapter chooses the number of intervals and stable categorical context roles; the extractor maps visible aggregate measurements to target identities, reusable features, context levels, probability curves, and support weights. A hierarchical discrete-hazard model implemented in PyMC pools an interval-specific baseline with feature-, entity-, and context-level effects, then converts predicted hazards back into valid monotone curves. The runtime ingests visible aggregates from completed trajectories and renders the resulting curves for requested targets as advisory context on subsequent instances.

Persistent-Entity State.

This memory system handles variable-size, unordered measurement sets whose underlying entities may persist without stable identifiers. Its adapter identifies the numerical coordinates that define entity identity, visible measurements that determine their uncertainty scales, values to predict, target family, and any optional query window. The extractor copies each visible measurement set into typed records without performing association. The runtime links observations through uncertainty-aware matching, updates persistent identity estimates and online Bayesian regressions, and renders current or previously confirmed entities relevant to the query as advisory context.

Appendix CAdditional Results

C.1Stateless-Reference Gain

Table 4:Gain relative to matched model-specific Stateless ICL across five rollouts. Each cell reports the mean, with[min,max][\min,\max]beneath. Higher is better; bold marks the best of the four staged conditions.Table 5:Paired normalized-reward differences between Routed CL and Routed ICL across the five matched stream seeds. The second column reports the mean with[min,max][\min,\max]beneath; positive values favor Routed CL.

C.2Comparison with ReasoningBank

To compare against a prior memory system and separate cluster routing from memory-system choice, we evaluate our documented ReasoningBank adaptation(Ouyang et al., 2026)under two fixed-system conditions.Global RBmaintains one ReasoningBank state across the complete stream, whereasRouted RBuses the LLM router to partition instances among ReasoningBank clusters. Section4describes how this adaptation preserves ReasoningBank’s core retrieval, extraction, and consolidation loop and where it differs from the original implementation. Figure3compares these conditions and Routed CL over the same three matched rollouts. The path from Global RB to Routed RB shows the effect of routing a fixed alternative memory system; the final segment to Routed CL shows the benefit of access to the full memory-system library under routed execution.

Figure 3:Mean normalized reward versus mean estimated API cost for the ReasoningBank comparison over three matched rollouts. Within each model, lines connect Global RB, Routed RB, and Routed CL. Routed CL is recomputed over these three rollouts and therefore differs from the five-rollout values in Table1. Points toward the upper left are better.

C.3Learning Dynamics

Figure4examines whether the benefit of persistent state grows as experience accumulates. At each stream prefix, we compute each method’s reward difference from its matched Stateless ICL rollout separately for every source task, normalize by that task’s full-rollout headroom, and average the seven tasks equally. Curves begin at 5%. Before a source task first appears within a prefix, its contribution is defined as zero; this preserves a fixed seven-task average rather than averaging over a changing set of tasks. Early points are closer to zero because source tasks that have not yet appeared contribute zero. This affects every method equally within a matched rollout, and all seven source tasks have appeared by 15% of the stream.

Figure 4:Stateless-reference gain through successive prefixes of the heterogeneous stream. Lines show means across five matched rollouts and shading spans[min,max][\min,\max]; the endpoints reproduce the full-stream gains in Table4.

C.4Estimated API Cost

Table 6:Mean estimated API cost in USD per 398-instance rollout across five matched seeds. Costs include every model call under the accounting policy in AppendixA.7; Table7reports the corresponding token breakdown. Lower is better.

C.5Token Usage

Table 7:Mean token usage (millions) per 398-instance rollout across the same five matched rollouts as Table6. The three input columns partition total input; cached input is not counted again in the total. Lower is better, and comparisons are most direct within a model because tokenizers differ.*Accounting note.*Fresh input excludes cache reads and writes. Usage total includes all reported input, cache, output, and reasoning tokens without double-counting; providers differ in whether reasoning tokens appear in the Output column.

C.6Performance by Source Task

Figure 5:Five-seed mean change in stateless-reference gain by source task. The panels compare successive conditions: Global ICL minus Stateless ICL, Routed ICL minus Global ICL, and Routed CL minus Routed ICL. Blue indicates improvement and orange regression.Figure 6:Five-seed mean API-cost ratio between Routed CL and Routed ICL by source task. Each cell reportsCRouted​CL/CRouted​ICLC_{\mathrm{Routed\ CL}}/C_{\mathrm{Routed\ ICL}}using mean task-level costs across matched rollouts. Values below one (blue) indicate that Routed CL is cheaper; values above one (orange) indicate that it is more expensive. Costs include all model calls attributed to instances from that source task.Gemini’s 2.41×\timesPoker cost ratio occurs in the three rollouts where Routed CL merged all opponents into one ICL cluster (Table8, panel b). The merged cluster required the actor to repeatedly process a longer history; costs were comparable to Routed ICL in the two opponent-partitioned rollouts.

C.7Memory-System and Cluster Assignments

Table8reports the router’s memory-system assignments in its upper panel and the corresponding cluster partitions in its lower panel.

Table 8:Memory-system and cluster assignments across four models and five matched rollouts per model. Panel (a) counts assignments to each memory system; panel (b) lists the number of clusters in rollout order. Bold entries match the corresponding component of Ground-truth assignment; cluster agreement requires the complete partition, not only its size. Source-task identities and grouping keys are used only for post-hoc evaluation. Memory-system abbreviations follow Table2.“Repository” denotes separatetablibandtenacityclusters, “Opponent” one cluster for each of the three Poker opponents, and “Stream” one cluster containing all instances from that source task. Gemini 3.7 Flash merges the two Code repositories in three of five rollouts and the three Poker opponents in three of five. GPT-5.6 Sol fragmentsτ3\tau^{3}-Bench into 23–27 clusters in four of five rollouts, while Opus 4.7 creates 23 and 86 clusters in two rollouts. These are descriptive routing errors; the table does not attribute reward differences to either failure mode.

C.8Ground-truth Assignment

Figure 7:Ground-truth assignment used for diagnostic comparisons. The mapping was fixed before confirmatory evaluation and is not an optimized policy or upper bound. It shows the joint memory-system and cluster assignment for each source task.

Appendix DPrompts and Memory-System Descriptions

This appendix reproduces the fixed natural-language instructions that define Routed CL’s experimental method: the router prompt and memory-system descriptions, the prompts Context Memory Adapter uses for adapter configuration and typed extraction, ReasoningBank self-judgment and memory extraction, and the fixed wrappers used to expose learned state to the actor. Line wrapping and runtime-value placeholders are normalized, but the fixed wording is otherwise verbatim. Text in angle brackets denotes visible data inserted at runtime. We omit native benchmark instance prompts and response schemas, which are benchmark inputs rather than method prompts, as well as provider-specific transport and retry messages that only enforce an already specified structured-output schema.

Stateless ICL and Global ICL add no system instruction to the native benchmark prompt. Routed ICL uses the router below, but its actor likewise receives only the native prompt and the visible history assigned to its cluster.

D.1Router

The router receives the following system prompt before every instance. In the verbatim implementation prompt,taskdenotes the current instance andsystemdenotes a candidate memory system.

Youroutetasksamongavailablecontinual-learningsystems.

Eachexistingclusterownsonefixedsystemandstateaccumulatedfromearlier

tasks.

Useonlythesuppliedtask,clustersummaries,andsystemdeclarations.Infer

whatinformationcouldusefullytransfertofuturerelatedtasks.Whencreating

acluster,selectthesystemwhosedeclaredlearningbehaviorandrequirements

bestmatchthatinformation.Donotassumeundeclaredcapabilitiesorprefera

systembecauseofitsidentifierorpositioninthecandidatelist.

Reuseanexistingclusteronlywhenitsdescriptionindicatesthatitsstate

appliestothesamescopeandislikelytohelpwithoutconflict.Otherwise

createanewcluster.Multipleclustersmayusethesamesystem.Describethe

scopeoffuturetasksthatshouldbenefitfromanewcluster.

Everystructuredresponsemustincludeallfourfields.Usenullforfieldsthat

donotapply:

-Existing:{“kind”:“existing”,“cluster_id”:“cluster-0001”,“system_id”:null,

“description”:null}

-New:{“kind”:“new”,“cluster_id”:null,“system_id”:“system-id”,

“description”:“Concisescopeforfuturetasks”}

Returnonlythestructuredselection.

The user message is a JSON object with the following structure. The current instance prompt and response schema are copied from the native interface; no source-task identity is included.

{

“clusters”:[

{

“description”:<immutableclusterdescription>,

“id”:<clusteridentifier>,

“system_id”:<systemidentifier>,

“trajectory_count”:<numberofcompletedtrajectories>

},...

],

“systems”:[

{“description”:<systemdescription>,“id”:<systemidentifier>},...

],

“task”:{

“prompt”:<currentvisibleinstanceprompt>,

“response_schema”:<currentstructured-responseschema>

}

}

The frozen system descriptions supplied in the Routed CL condition are:

icl:

What:Boundedverbatimepisodicmemorythatretainsprioractor-visible

interactionsintemporalorderwithinitsconfiguredcontextwindow.Choose

when:Futurerelatedtaskscontinuethesameentities,environment,orevolving

state,orwhenexactpriorfacts,actions,observations,oroutcomesmaybe

needed.Avoidwhenonlycompacttask-independentstrategiesneedtotransfer.

reasoning_bank_v1:

What:Self-judgedreasoningmemorythatdistillssuccessfulandfailed

actor-visibleexperiencesintocompactstrategiesandpreventativelessons.

Foreachnewtask,itretrievesthememoriesattachedtothesinglemost

semanticallysimilarpriorexperience.

Choosewhen:Tasksareself-containedepisodesthatbenefitprimarilyfrom

reusableprocedures,decisionpatterns,orfailure-avoidancelessonsdistilled

fromrelatedpriorexperiences.

hierarchical_regression_v1:

What:Hierarchicalonlineregressionoverkeyedscalaroutcomes.Choosewhen:

Thereusabletargetisascalarnumericoutcomeobservedrepeatedlyforkeyed

entitiesorpanelsovertime.Scalarnumericoutcomeswithkeyeddimensions,

observationtimes,requestedpredictiontimes,andprovenance.

hierarchical_discrete_event_v1:

What:Ahierarchicaldiscrete-eventmodelformonotoneevent-freeprobability

curves.Choosewhen:Thereusabletargetisajointlymodeledmonotone

probabilityvectoroverfixedorderedintervals,pooledacrossgroups,features,

orentities.Monotoneprobabilitycurveswithcategoricalgroups,features,

entitykeys,weights,andprovenance.

persistent_entity_state_v1:

What:Onlineregressionoverunorderedmeasurementsofpersistentlatent

entities.Choosewhen:Eachstepcontainsavariable-sizesetofnoisydetections

thatmaycorrespondtopersistententities.Rawnumericidentitycoordinates,

naturalscalereferences,numericvalues,optionalvisiblebounds,stepindex,

andprovenance.

The router returns a structured object with four fields:kind,cluster_id,system_id, anddescription.

D.2Adapter Configuration

ICL requires no cluster-specific adapter configuration. ReasoningBank and the three numerical memory systems each append their own contract to the common adapter-configuration instruction below. In the verbatim prompts that follow,operatoris the implementation-level term for the selected memory system; we preserve the wording used during evaluation.

D.2.1Common Adapter Configuration Instruction

Configuretheselectedgenericmemoryoperatorfromvisibletasksyntax.

Configureonlychoicesadmittedbytheresponseschema.Numericaladaptersuse

theruntime’ssharedstructured-outputLLMextractor.Runtimecodesupplies

fixedversiontags,operatoridentity,andextractorsettings.Donotgenerate

parsercode,taskanswers,hiddenfields,rewards,ornewoperators.

D.2.2ReasoningBank request-boundary contract

Operator:reasoning_bank_v1

Inputcontract:Thecurrentvisiblerequestandcompletedactor-visible

trajectories.Outcomelabelsareinferredbytheactormodelwithoutaccess

tohiddentaskoutcomesorexternalevaluatoroutputs.

Adapterconfiguration:Returnonlyasyntaxbindingforisolatingthechanging

requestfromeachfullinitialprompt.Setrequest_markertoaliteraldelimiter

thatappearsexactlyonceineveryshowninitialprompt,immediatelybeforethe

changingrequest.Preferthecloseststabledelimitertotherequest.Setitto

nullonlywhenthefullpromptisitselftherequestornoshareddelimiteris

available.Donotencoderequestcontent,taskfacts,toolnames,answers,or

benchmark-specificrules.

D.2.3Keyed scalar regression contract

Operator:hierarchical_regression_v1

Inputcontract:Scalarnumericoutcomeswithkeyeddimensions,observation

times,requestedpredictiontimes,andprovenance.

Adapterconfiguration:Usethesharedllm_structured_output_v1extractortoemitthe

currenttime,everyrequestedkeyedpredictionpoint,andonlyexplicitly

visiblerealizedoutcomes.Thefirstvalidextractionestablishesstable

semanticdimensionnamesforthestream.Classifythetargetfamilyasreal,

positive_continuous,count,orprobability,andchoosewhetheritstimeeffect

isabsentorlinear.Donotsupplynumericalpriors,trends,noiselevels,or

shrinkageconstants.Theruntimederivesthelinkandoutputconstraints,

estimatesanyglobaltrendfromrepeatedvisibleoutcomes,andusesone

standardizedregularizationpolicy.Omitsourcessoruntimelifecycledefaults

apply.

D.2.4Discrete-event contract

Operator:hierarchical_discrete_event_v1

Inputcontract:Monotoneprobabilitycurveswithcategoricalgroups,features,

entitykeys,weights,andprovenance.

Adapterconfiguration:Returnanllm_discrete_event_v1manifest.Configure

interval_countandthenamesofstablecategoricalcontextroles.Acontextrole

mustdescribeasource-widenuisanceconditionthatrepeatsacrossmultiple

measuredentities;donotuseentityidentifiers,requestedtargetfeatures,

measurementavailability,orone-offlabelsascontextroles.Theruntime

estimatesitspopulationbaselinefromvisibleevidenceandappliesoneshared

weaklyinformativepriortoeveryeffectfamily.Donotsupplynumericalpriors.

ThesharedruntimeextractorderivestargetIDsandtypedevidencerecords

directlyfromvisibleevents,validatesexactnumericprovenance,derivesa

compactresponsebindingfromeachvisibleschema,andsuppliesgeneric

evidence-acquisitionguidance.Donotgenerateparsercodeorencodeconcrete

targetidentifiers,contextvalues,observations,answers,orrewardsinthe

manifest.

D.2.5Persistent-entity contract

Operator:persistent_entity_state_v1

Inputcontract:Rawnumericidentitycoordinates,naturalscalereferences,

numericvalues,optionalvisiblebounds,stepindex,andprovenance.

Adapterconfiguration:Returnanentity_regression_v1manifestusingtheshared

structured-outputextractor.Chooserawnumericfieldsthatidentifythesame

latententityacrossstepsseparatelyfromnumericfieldswhosevaluesshouldbe

learned.Identitymustcontainthestablestructuralcoordinatesneededto

distinguishentities,includingasize,span,orshapemeasurementwhenthat

propertydefinestheentity’spersistentfootprint.Putgenuinelyfluctuating

measurementsinvaluesinstead.Donotomitastructuralidentitycoordinate

merelybecauseitalsoappearsintherequestedoutput.Foreachidentity

coordinate,nameapositivevisiblemeasurementthatdefinesitsnaturalscale,

suchasanuncertainty,span,orsizefield,anddeclarewhetherthatmeasurement

isalreadyastandarddeviation;afulluniformextentfortheidentityvalue

itself;orafullintervalwidthwhosemidpointlocatesaseparateidentity

coordinate.Theoperatorconvertsthatdeclaredinterpretationintounitless

uncertaintyandlearnsresidualcalibrationonline;donotsupplytolerances,

noiselevels,matchthresholds,orsupportthresholds.Classifypredictedvalues

asreal,positive_continuous,count,orprobability;theruntimederivesthelink

andalwaysregularizestemporaleffects.Optionalwindowboundsmayfilter

rememberedentitiestothecurrentlyvisiblenumericrange.Giveconcisedisplay

namesforeveryidentityandpredictedvalue;theruntimeownstheadvisorytext

andformatting.Omitsourcesbecausetheruntimefixesingestionatquerystart.

Donotusetasknames,hiddenidentities,rewards,orbenchmark-tunedanswers.

For numerical memory systems, the configuring LLM receives the following user message. Terminal submissions are omitted because their values are candidate answers rather than observations.

Selectedoperator:<operatoridentifier>

Visibleprefix:

VISIBLECOMPLETEDTRAJECTORIES

TRAJECTORY<index>

TURN<index>QUERY

<visiblequery>

ACTION

<visibleaction,or[terminalstructuredsubmissionomitted]>

OBSERVATION

<visibleobservation>

...

CURRENTVISIBLEQUERY

<currentinstanceprompt>

CURRENTRESPONSESCHEMA

<currentstructured-responseschema>

ReasoningBank needs only the changing request boundary, so its configuring LLM instead receives the initial prompts from the completed and current instances:

Selectedoperator:reasoning_bank_v1

Visibleprefix:

VISIBLEINITIALPROMPTS

COMPLETEDINITIALPROMPT<index>

<completedinitialprompt>

...

CURRENTINITIALPROMPT

<currentinitialprompt>

If deterministic validation rejects an adapter configuration, one repair attempt adds:

Thepreviousadapterconfigurationfaileddeterministicvalidationwith:<validationerror>

Returnacorrectedcompleteadapterconfiguration.Previouspayload:

<previousstructuredpayload>

D.3Typed Evidence Extractors

After adapter configuration, the numerical operators use structured-output extractors to translate visible text into operator-native records. The output schemas are, respectively,PanelTaskBatch,DiscreteEventEvidenceBatch, andDetectionEvidenceBatch. Deterministic validators admit only values grounded in the supplied visible event.

D.3.1Keyed scalar regression extractor

Youareamemoryextractor,notthetask-solvingactor.Translateonevisible

numericforecastingqueryintothecompletetypedtaskrequiredbyan

already-selectedkeyedregressionoperator.Returnonlythestructuredresponse.

current_timeisthetimeexplicitlyidentifiedascurrent.requestedgroupseach

entityoncewitheverytargettimethetaskaskstheactortopredict.records

containsonlyhistoricaloutcomesexplicitlyrevealedasfeedback.Nevertreat

requestedvalues,priorpredictions,errors,scores,ortool-readabledataas

realizedobservations.Chooseshortsemanticdimensionnamesandusethesame

namesexactlyonceineveryrequestedpointandobservation.Copyallcategorical

andnumericvaluesexactly.Returnanemptyrecordslistwhennorealizedoutcome

isvisible.Theframeworkvalidatesstructureandvisible-valuegroundingbefore

anythingentersmemory.

Selectedoperatorinputcontract:

-current_time:onevisiblenumerictime

-requested:oneseriesperentitywithallrequestedtargettimes

-records:onlyvisiblerealizedoutcomes

-frozendimensionnames:<existingnames,or(infer)>

Translatethisexactvisiblequery:

<currentvisiblequery>

D.3.2Discrete-event extractor

Youareamemoryextractor,notthetask-solvingactor.Convertexactlyone

visibletrajectoryeventintotypedevidenceforthealready-selected

hierarchicaldiscrete-eventoperator.Returnonlythestructuredresponse.Do

notwriteparsercode,predicttaskanswers,userewards,orinferhiddenvalues.

Inferresponse_bindingdirectlyfromthevisibleresponsefieldsandschema

description:delimiteristheexactseparatorbetweenanarbitrarytargetprefix

andcomponentsuffix,andcomponent_labelsmustfollowthesemanticorderstated

bythevisibleschemaratherthanpropertyorder.Thecompactrulemustcover

everyvisiblestructuredfield.Foreveryexacttargetidentifiervisibly

requestedbytheresponseschemaoremittedinacompletedstructuredaction,

emitonetargetmapping.Itsfeaturesarethesmallestreusableconditions

visiblyencodedasexactsubstringsofthatidentifier.Splitcombinationsinto

atomicconditions;donotincludehorizons,sourcelabels,identifiers,or

inferredsynonyms.Eachrecordmustcitetheexplicitlylabeledzero-based

SOURCETURNcontainingitsnumericevidence;ignoreanyhuman-facingstepnumber

insidethequery.Copyanexactcontiguoussource_excerptthatnamesthe

measurementandcontainstheprobabilityvectorandsupportweight.Copythe

observedmonotoneprobabilityvectorandweightexactlyfromthatexcerpt.

Observedzeroandonevaluesarevalid:neverreplacethemwithepsilon,clipping,

oraprobabilityfloor.Whenbothdirectmeasurementsandfitted,predicted,or

diagnosticvaluesappear,recordonlydirectmeasurements.Neveruseloss,

confidence,ordiagnosticvaluesasprobabilities.Useentity_keyforadirect

measurementofonerequestedtarget.Useraw_featuresonlyforconditions

declaredinthetargetmappings.Arecordwithnoentityorfeaturesisa

baselineonlywhenitsexcerptexplicitlyidentifiesthecompletesource

populationorglobalaggregate.Attacheveryconfiguredcategoricalcontextrole

toeveryrecordusingliteralvaluesvisibleintheevent.Emitaminimal

sufficientevidenceset:atmostoneglobalbaseline,directmeasurementsof

requestedtargets,andnon-redundantreusablefeaturemeasurements.Skip

complements,residualbuckets,alternativepartitions,fittedproxies,and

ambiguousrowsunlesstheydirectlymeasurearequestedtargetordeclared

feature.Theframeworkderivesresponsebindingsseparately.

Selectedoperatorinputcontract:

-orderedprobabilitydimensions:<intervalcount>

-inferacompactresponsebindingfromthevisibleresponsefields:emitthe

exactdelimiterandcomponentsuffixesintheirdeclaredsemanticorder;the

rulemustapplytoarbitrarytargetprefixes

-requiredcategoricalcontextroles:<configuredroles>

-knowntargetmappingsfromearliervisibleevents:<knownmappings>

-acquisitionguidance:

<actor-facingacquisitionguidance>

Translatethisexactvisibleeventintoevidencerecords:

EVENTKIND:instance_completed

STREAMINDEX:<cluster-localtrajectoryindex>

CURRENTQUERYPROMPT:

CURRENTRESPONSEFIELDS:

[]

CURRENTRESPONSESCHEMA:

{}

SOURCETURN<zero-basedindex>

QUERY:

<visiblequery>

ACTION:

<visibleJSONaction,orSTRUCTUREDRESPONSEFIELDSfollowedbytheJSONlistof

terminalresponsefieldnames>

OBSERVATION:

<visibleobservation>

D.3.3Persistent-entity extractor

Youareamemoryextractor,notthetask-solvingactor.Convertonevisiblequery

intotypedmeasurementrecordsforanalready-selectedmulti-targettracking

operator.Returnonlythestructuredresponse.Copythevisibleeventidentifier,

configurednumericcontextfields,recordidentifiers,andconfigurednumeric

measurementfieldsexactly.Followtheconfiguredsemanticrolenames:

distinguishcoordinatesusedforidentity,valuestopredict,andanyvisible

numericboundsorothercontext.Donotassociaterecordsacrossevents,predict

persistententities,transformunits,orinferhiddenvalues.Useevery

configuredfieldnameexactlyonceandemiteveryvisiblemeasurementrecord.

Theframeworkvalidateseveryvalueagainstthevisiblequery.

Selectedoperatorinputcontract:

-visible_id:theexactidentifierofthismeasurementevent

-numericcontextroles:<configuredcontextnames>

-record_id:theexactvisibleidentifierofeachdetection

-numericmeasurementroles:<configuredmeasurementnames>

Mapsourcefieldnamesintothesesemanticroles.

Translatethisexactvisiblequeryintomeasurementrecords:

<currentvisiblequery>

When a structured evidence batch fails fixed schema or grounding validation, the extractor appends the following repair text and retries within its fixed budget:

Thepreviousevidencebatchfailedfixedschemaorgroundingvalidation.Return

acorrectedbatch.

Validationerror:<exceptiontype>:<validationerror>

Rejectedbatch:

<previousstructuredbatch,whenavailable>

D.4ReasoningBank Memory Formation

After each completed visible trajectory, ReasoningBank first asks the evaluated model to infer whether the attempt succeeded or failed. This proxy judgment uses only the visible request and trajectory, not hidden rewards or evaluator outputs.

D.4.1Self-judgment

Youareahelpfulassistantthatjudgeswhetheranagentsuccessfully

completedatask.Useonlythesuppliedtaskandtrajectory.Returnthe

outcomeandaconciserationale.

Its user message is:

Task:<visiblerequest>

Trajectory:

<completedactor-visibletrajectory>

Didtheagentsuccessfullycompletethetask?

The response is a structured object containingoutcome, eithersuccessorfailure, and a conciserationale.

D.4.2Memory extraction

Given the proxy outcome and rationale, the same evaluated model receives one of two fixed system prompts. For a successful trajectory, the system prompt is:

Youareanexpertinsolvinginteractivetasks.Youwillbegivenauserquery

andthecorrespondingtrajectorythatrepresentshowanagentsuccessfully

accomplishedthetask.

##Guidelines

Extractandsummarizeusefulinsightsasmemoryitemsfromthetrajectory.

Thegoalisforthememoryitemstobehelpfulandgeneralizableforfuture

similartasks.

##Importantnotes

-Youmustfirstthinkwhythetrajectoryissuccessful,andthensummarize

theinsights.

-Extractatmost3memoryitems.

-Donotrepeatsimilaroroverlappingitems.

-Preferconcrete,actionableproceduresoverabstractprinciples.

-Donotembedtask-specificnames,identifiers,queries,orliteralvalues.

Returneachitemusingthetitle,description,andcontentfieldsrequiredby

theresponseschema.Thedescriptionstateswhenorwhennottousetheitem.

Thecontentcontainsonetothreesentencesofactionableinsight:theinsights

learnedtosuccessfullyaccomplishsimilartasksinthefuture.

For a failed trajectory, the system prompt is:

Youareanexpertinsolvinginteractivetasks.Youwillbegivenauserquery

andthecorrespondingtrajectorythatrepresentshowanagentattemptedto

resolvethetaskbutfailed.

##Guidelines

Extractandsummarizeusefulinsightsasmemoryitemsfromthetrajectory.

Thegoalisforthememoryitemstobehelpfulandgeneralizableforfuture

similartasks.

##Importantnotes

-Youmustfirstreflectandthinkwhythetrajectoryfailed,andthensummarize

whatlessonsyouhavelearnedorstrategiestopreventthefailureinthe

future.

-Extractatmost3memoryitems.

-Donotrepeatsimilaroroverlappingitems.

-Preferconcrete,actionableproceduresoverabstractprinciples.

-Donotembedtask-specificnames,identifiers,queries,orliteralvalues.

Returneachitemusingthetitle,description,andcontentfieldsrequiredby

theresponseschema.Thedescriptionstateswhenorwhennottousetheitem.

Thecontentcontainsonetothreesentencesofactionableinsight:theinsights

learnedtoavoidsuchfailuresandsuccessfullyaccomplishsimilartasksinthe

future.

Both prompts receive the following user message:

**Query:**<visiblerequest>

**Trajectory:**

<completedactor-visibletrajectory>

Thetask<succeededorfailed>because:<self-judgmentrationale>

The structured response contains at most three items, each withtitle,description, andcontentfields.

D.5Actor-Facing Context Templates

Context Memory Adapter injects the generated advisory into the actor’s context while leaving the native instance prompt unchanged. The generated rows depend on visible state; the fixed wrapper text is reproduced below.

D.5.1ReasoningBank

Belowaresomememoryitemsaccumulatedfrompastinteractionwiththe

environmentthatmayhelpsolvethecurrenttask.Usethemonlywhenrelevant.

#MemoryItem1

##Title<title>

##Description<description>

##Content<content>

ReasoningBank retrieves one prior experience and injects all memory items extracted from it.

D.5.2Keyed scalar regression

===PYMCHIERARCHICALPREDICTIVESTATE===

Thisadvisorystateusesonlycanonicalprevious-roundoutcomesvisibleintask

promptsandpriorstructuredsubmissions.Inspectthecurrentfilesandrevise

theseestimateswhenwarranted.

Entityforecastsfromonesharedglobal/entity/factor/trendrule:

-<entitydimensions>:visibleoutcomes{<recentoutcomes>};advisoryforecasts

{<time=value,uncertainty,andsupport>}

Resolvedpredictionreceipts:n=<count>,mean(actual-predicted)=<meanresidual>,

meanabsoluteresidual=<meanabsoluteresidual>.

Memoryestimatesarenotgroundtruthandarenotasubmission.

===ENDPYMCHIERARCHICALPREDICTIVESTATE===

The resolved-prediction line is omitted when no prior advisory prediction has a visible outcome.

D.5.3Discrete event

===HIERARCHICALEVENTMEMORY===

Useonlyvisiblesourcedata.Obtainasource-wideevent-freecurveanduseful

entitymarginalsorcombinationswhentoolspermit.Preserveexactsupport

countsandcanonicalconditionsfromrequestedidentifiers.Current-source

aggregatesmayreflectselectioneffectsratherthanpopulationtruth;thefinal

estimatespoolevidenceacrosssources.

===ENDHIERARCHICALEVENTMEMORY===

Priormodelestimatesbytarget:

-<targetidentifier>:[<orderedevent-freeprobabilities>]

Before the model has fitted state, the final block is replaced byNo prior model state is available yet.

D.5.4Persistent entity

===ONLINEENTITYSTATE===

Candidatepersistent-entityhypothesesinferredfrompriorvisiblemeasurements

andupdatedwiththecurrentmeasurementsetarelistedbelow.Candidatesare

uncertainevidenceandmayrepresentduplicatesornoise.Reconcilecompatible

candidatesandproducetherequiredstructuredresponseyourself.

-candidate=<entity>;<identitycoordinateandobservedrange>;support=<count>;

seen_rounds=<range>;active_now=<boolean>;<predictedvalues>

===ENDONLINEENTITYSTATE===