Recall Router in MemoCue

Updated 7 July 2026

Recall Router is a strategy-guided framework that transforms user queries into cue-rich prompts to proactively activate personal memories.
It employs a two-stage process using a 5W Recall Map for classification and a hierarchical recall tree with MCTS for cue-query generation.
The framework integrates cognitive recall strategies with reinforcement learning to outperform conventional memory retrieval methods.

Recall Router denotes, in MemoCue, a framework for strategy-guided agent-assisted memory recall in which an agent does not merely retrieve information from an external memory module, but instead transforms an original user query into a cue-rich query intended to activate the person’s own relevant memory (Zhao et al., 31 Jul 2025). The framework addresses two explicit problems: choosing an appropriate recall strategy for diverse forgetting scenarios, and generating high-quality strategy responses from abstract strategy patterns. Its solution is a two-stage architecture consisting of a 5W Recall Map for scenario routing and a hierarchical recall tree combined with Monte Carlo Tree Search (MCTS) for strategy selection and cue-query generation, and it is used to construct the instruction-tuned system MemoCue (Zhao et al., 31 Jul 2025).

1. Concept and problem setting

Recall Router is introduced for the Strategy-Guided Recall (SGR) setting, where the agent is expected to help a person reconstruct incomplete or vague memories by asking better questions rather than only retrieving stored content. The motivating claim is that conventional memory agents are constrained by the limited size of their memory module, which hinders acquisition of complete memories and affects practical recall performance. MemoCue therefore treats memory assistance as a routing problem over recall strategies rather than as direct answer extraction alone (Zhao et al., 31 Jul 2025).

The framework formalizes two challenges. The first is strategy selection: queries such as “Where are my keys?”, “Who was that person?”, “When did I take my medication?”, and “Why did I choose this option?” require different forms of cueing. The second is response realization: the strategy inventory is grounded in memory theory, but the system must still translate abstract strategy descriptions into concrete, useful prompts. Recall Router addresses the first by classifying the query into one of five forgetting scenarios and the second by searching over strategy-conditioned cue queries with a hierarchical decision process (Zhao et al., 31 Jul 2025).

A recurring misconception is to treat the framework as a conventional retrieval pipeline. The paper explicitly distinguishes it from that view: the agent is designed to transform the original query into a cue-rich one, so that the person’s own memory can be proactively activated. This suggests that Recall Router is better characterized as a strategy router over memory cues than as a pure retriever (Zhao et al., 31 Jul 2025).

2. The 5W Recall Map

The first routing stage is the 5W Recall Map, inspired by Lasswell’s 5W communication model. It classifies a user query into five scenarios: Event (What), Person (Who), Location (Where), Temporal (When), and Decision (Why) (Zhao et al., 31 Jul 2025). The routing target is the type of forgetfulness rather than surface wording alone.

The paper states that the classification module is a fine-tuned RoBERTa model. For training, GPT-3.5-turbo is used with few-shot prompting to annotate 2,000 samples, these annotations are manually verified, and the resulting classifier is trained on an A100-80GB GPU for 500 epochs with batch size 32 (Zhao et al., 31 Jul 2025). The output of this classifier determines which strategy family the router may search over.

The five scenarios correspond to distinct cue sources. Event queries target forgotten actions or episodes; Person queries target identity, relation, or appearance; Location queries target spatial context; Temporal queries target timing, sequence, or routines; and Decision queries target motives, preferences, or decision logic (Zhao et al., 31 Jul 2025). This classification is the framework’s primary “routing” decision.

3. Strategy inventory and hierarchical recall tree

Recall Router defines 15 recall strategy patterns, grouped three per scenario. These strategies are explicitly described as cognitively grounded cueing patterns rather than generic prompt templates (Zhao et al., 31 Jul 2025).

Scenario	Strategies	Primary cue basis
Event (What)	Scenario Reconstruction; Interpersonal Interaction; Sensory Activation	Context, social context, sensory traces
Person (Who)	Appearance Clues; Role Connection; Emotion Trigger	Appearance, relation, emotional association
Location (Where)	Multiple Associations; Immersive Recall; Spatial Cues	Associations, scene/path, spatial layout
Temporal (When)	Timeline Rewind; Key Milestones; Routine Pattern	Sequence, anchor times, habits
Decision (Why)	Background Motivation; Option Comparison; Experience Support	Motives, trade-offs, prior experience

The framework models strategy use as a hierarchical Markov Decision Process with a hierarchical recall tree (Zhao et al., 31 Jul 2025). At the high level, the state is

$s_t^h = (Q_u, H_t, M_t),$

where $Q_u$ is the original user query, $H_t$ is dialogue history, and $M_t$ is retrieved relevant memory from the memory bank up to turn $t$ . The high-level action space is the 15-strategy pool, and the selected action is a strategy pattern.

At the low level, the state becomes

$s_t^l = (s_t^h, a_t^h),$

and the action is a concrete cue query $Q_c$ . The paper writes the low-level generation rule as

$a_t^l \sim \mathcal{P}(a \mid s_t^l), \qquad \mathcal{P}(a \mid s_t^l) = \operatorname{LM}(Q_c \mid s_t^l),$

with best-response selection

$a_t^l = \arg\max_{Q_c \in \mathcal{A}^l} \mathcal{P}(Q_c \mid s_t^l).$

This separates which strategy to use from how to phrase the cue (Zhao et al., 31 Jul 2025).

The transformation objective is summarized in the paper as

$Q_c = \mathcal{T}(Q_u, S),$

where the cue query is derived from the original query and the chosen strategy. In effect, the tree stores strategy-conditioned dialogue states, previous cueing attempts, and memory evidence, making strategy search adaptive across turns rather than static (Zhao et al., 31 Jul 2025).

4. SGR-MCTS optimization

The search procedure is SGR-MCTS, which applies selection, expansion, simulation, and backpropagation to the hierarchical recall tree (Zhao et al., 31 Jul 2025). The root node is the original user query, and each rollout searches for a high-reward strategy-response path.

During selection, child nodes are chosen by UCT:

$Q_u$ 0

where $Q_u$ 1 is the average reward of node $Q_u$ 2, $Q_u$ 3 is the parent visit count, $Q_u$ 4 is the node visit count, and $Q_u$ 5 is the exploration constant (Zhao et al., 31 Jul 2025). Expansion then uses the LLM to generate a cue query

$Q_u$ 6

followed by a simulated user response and state update.

The rollout stops when either sufficient response quality is reached or the dialogue-turn limit is exceeded:

$Q_u$ 7

Here $Q_u$ 8 is a BERTScore-based similarity measure and $Q_u$ 9 is the true answer (Zhao et al., 31 Jul 2025).

The reward is decomposed into three parts. Recall Accuracy $H_t$ 0 is measured by BERTScore similarity between simulated response and true answer. Recall Focus uses Jaccard similarity,

$H_t$ 1

and Recall Depth counts recovered memory-element types,

$H_t$ 2

where the element set includes Event, Person, Location, Temporal, and Decision (Zhao et al., 31 Jul 2025). The paper states that Recall Depth is evaluated using Qwen2.5-32B-Instruct.

To avoid local optima, simulation uses an $H_t$ 3-greedy exploration factor, initialized at 1 and decreased by 0.05 during simulation (Zhao et al., 31 Jul 2025). After reaching a terminal state, backpropagation updates node value and visit count:

$H_t$ 4

$H_t$ 5

The search budget is reported as $H_t$ 6 iterations, and the system retains the top- $H_t$ 7 paths with $H_t$ 8 for downstream dataset construction (Zhao et al., 31 Jul 2025).

5. MemoStrategy dataset and MemoCue

The outputs of Recall Router are used to build the instruction-tuning dataset MemoStrategy (Zhao et al., 31 Jul 2025). Each sample contains the original user query $H_t$ 9, a selected recall strategy $M_t$ 0, and a cue query $M_t$ 1. The instruction-tuning format has three fields: Instruction, which includes task description and brief strategy definitions; Input, containing the original query; and Output, containing the recommended strategy and cue-query response.

Dataset construction follows the router’s search pipeline: analyze the user query, classify the forgetting scenario, select candidate strategies, generate cue queries, simulate user responses, and keep only effective samples. The paper also specifies quality filtering rules: invalid samples are removed when the response is unclear, fails to reveal valid recalled information, or lacks key details such as people or dates (Zhao et al., 31 Jul 2025).

The paper contains an explicit inconsistency in dataset size. One description reports 5805 samples split into 5200 train / 605 test, while another reports 4805 samples split into 4500 train / 305 test (Zhao et al., 31 Jul 2025). Both descriptions refer to the same MemoStrategy construction pipeline.

MemoCue is then obtained by fine-tuning multiple open-source LLMs on MemoStrategy, including Qwen2.5-14B-Instruct, Qwen2.5-7B-Instruct, Llama-3-8B-Instruct, Mistral-7B-Instruct, and Yi-9B (Zhao et al., 31 Jul 2025). The reported training configuration uses LoRA, batch size 8 per GPU, learning rate $M_t$ 2, 5 epochs, and 8 Nvidia Tesla A100-80GB GPUs. The resulting agent is designed to produce strategy-aware and cue-rich responses rather than generic prompts.

MemoCue is evaluated on PerLTQA, LoCoMo, and MemoryBank (Zhao et al., 31 Jul 2025). The paper describes PerLTQA as containing 141 user memory banks, 8,593 QA pairs, and 35,179 memory streams; LoCoMo as containing 50 ultra-long conversations of around 300 turns and 9,000 tokens each; and MemoryBank as containing 15 virtual users over 10 days with 194 probing questions. Baselines include multiple prompting variants of open-source models, as well as gpt-3.5-turbo, gpt-4, gpt-4o, and o1-preview (Zhao et al., 31 Jul 2025).

The central automatic metric is Balance of Recall Score (BRS),

$M_t$ 3

with $M_t$ 4 (Zhao et al., 31 Jul 2025). The numerator rewards accurate recall through BERTScore, while the denominator penalizes cue queries that remain too similar to the original query. This metric encodes the framework’s central trade-off: the cue query should remain relevant, but it should not merely restate the user’s input.

The main experimental claim is that MemoCue surpasses LLM-based methods by 17.74% in recall inspiration (Zhao et al., 31 Jul 2025). The strongest reported MemoCue configuration, based on Qwen2.5-14B-Instruct, achieves 78.15 on PerLTQA, 77.89 on LoCoMo, 72.42 on MemoryBank, and 76.15 on average (Zhao et al., 31 Jul 2025). Human evaluation further reports win rates of 83% against GPT-4, 85% against GPT-4o, and 78% against o1-preview on dimensions including recall inspiration, response intelligence, and cue consistency (Zhao et al., 31 Jul 2025).

In the broader literature, the Recall Router of MemoCue occupies one position within a larger family of recall-oriented routing systems. SelRoute routes memory-retrieval queries among lexical, semantic, hybrid, and vocabulary-enriched pipelines, achieving Recall@5 of 0.800 on LongMemEval_M with bge-base-en-v1.5 and a zero-ML SQLite FTS5 baseline with NDCG@5 of 0.692 (McKee, 2 Apr 2026). MemRouter instead routes write-side memory admission in long-term conversational agents, training only ~12M trainable parameters and reporting overall F1 52.0 vs 45.6 against an LLM-based memory manager under a matched LoCoMo harness (Hu et al., 1 May 2026). These systems do not define Recall Router in the MemoCue sense, but they show that contemporary routing research treats recall not as a single operation, but as a sequence of routing decisions over memory access, admission, and retrieval.