Supra Cognitive Modes: A Routed Architecture for Agent Memory

Title: Supra Cognitive Modes: A Routed Architecture for Agent Memory
Authors: Joshua Tobkin* and David Yang (*Corresponding author: j.tobkin@supra.com)
Venue: Supra Research / arXiv
Year: 2026
Code URL: No public code URL is explicitly provided in the paper; the evaluation is backed by an internal reproduction artifact (repository-traceable but not publicly distributed)
Pages: 27 pages (including appendices)

1. 研究摘要

Agent-memory workloads present a fundamental tension in the design of long-lived language-model agents. Unlike static question-answering corpora, an agent's memory layer must simultaneously answer direct factual lookups, trace relation chains across scattered records, and synthesize broad summaries over hundreds or thousands of interaction turns. A single retrieval and synthesis policy cannot serve all three shapes equally well: a factoid question needs precision and low latency, a multi-hop relation query needs graph traversal, and a broad synthesis request needs stratified, multi-pass summarization. Pushing all queries through the heaviest path would waste computation on simple questions; forcing everything through the cheapest path would degrade complex ones. The central problem addressed by this paper is therefore how to expose the memory operating point as a per-query control rather than fixing one policy for an entire deployment.

The paper proposes Supra Cognitive Modes (SCM), a routed architecture that maps explicit or automatically selected semantic labels—called modes—to retrieval and synthesis payloads over one shared ingest substrate. The intellectual contribution is not a new retrieval primitive, but a compositional control interface: modes (semantic labels) are separated from payloads (concrete retrieval and synthesis configurations), which are in turn separated from procedures (execution families). This separation allows several semantic labels to map to the same initial payload, and it allows runtime gates to revise the payload before execution. The result is a flexible routing layer that dispatches among direct fused lookup, graph or iterative multi-hop handling, and long-form synthesis, all reading from the same underlying store of embeddings, extracted triples, and versioned facts.

The three main contributions are correspondingly bounded but clearly stated. First, the paper defines the mode–payload–procedure interface and argues that per-query control is the right abstraction for heterogeneous agent-memory workloads. Second, it describes a source-visible implementation of that interface over a shared asynchronous substrate, including direct, graph-capable, and long-form procedure families. Third, it provides a repository-traceable characterization of the deployed configuration across three benchmarks—LoCoMo, MemoryAgentBench, and LongMemEval—together with an unusually explicit audit of the timing, cost, judge, and provenance evidence that is and is not available.

The key reported results are aggregate accuracy scores for the deployed SCM configuration: 84.87% on LoCoMo factoid categories and 68.61% on adversarial abstention, 61.49% on MemoryAgentBench averaged across two repetitions, and 86.00% on LongMemEval. These figures exceed the reported Mem0 v2 OSS and production-comparator baselines on the same benchmarks, but the authors repeatedly caution that the comparisons are configuration-level and not causal attributions to routing itself. The paper's most distinctive empirical move is not the headline table, but its diagnostic layer: by preserving semantic-mode labels and retrieval traces, the authors expose task- and mode-conditioned failure strata that can guide future engineering.

Why should readers care about this work? It reframes the memory problem from "build a better retrieval index" to "build a controllable memory operating system." The shared substrate design means that the cost of construction is paid once, while the per-query routing allows latency and synthesis depth to be matched to the question shape. The paper also models a valuable style of honest evaluation: it separates implementation claims from causal claims, reports what is missing from the artifact, and offers concrete next steps rather than overreaching conclusions. For practitioners, the immediate takeaway is that a small frozen classifier plus runtime gates can make heterogeneous memory workloads more tunable; for researchers, the paper opens a design space for routing-aware memory systems where the operating point is exposed rather than buried in a fixed pipeline.

2. 理论框架

The intellectual lineage of SCM lies at the intersection of three recent movements in agent design: long-term memory systems, adaptive retrieval and routing, and retrieval-augmented generation with structured knowledge. Foundational agent architectures such as Generative Agents (Park et al., 2023) and CoALA (Sumers et al., 2023) showed that stored experience can shape planning, while MemoryBank (Zhong et al., 2024) and MemGPT/Letta (Packer et al., 2023) introduced explicit memory tiers. More recent systems have moved construction and organization into the memory layer itself: Mem0 (Chhikara et al., 2025) extracts persistent user memories at ingest; Zep/Graphiti (Rasmussen et al., 2025) builds a temporal knowledge graph with provenance; A-Mem (Xu et al., 2025) organizes memories as dynamically linked notes; and MIRIX (Wang and Chen, 2025) uses several typed stores under a controller. SCM inherits the idea that memory quality depends on where construction, organization, and synthesis costs are paid, but it reframes the problem as a control problem over a single substrate rather than as a choice among separate stores.

The routing perspective also has deep roots. Adaptive-RAG (Jeong et al., 2024) classifies questions into no-retrieval, single-step, and multi-step tiers; Self-RAG (Asai et al., 2024) learns when to retrieve and critique evidence; IRCoT (Trivedi et al., 2023) interleaves retrieval with multi-hop reasoning; and FLARE (Jiang et al., 2023) retrieves when generation becomes uncertain. FrugalGPT (Chen et al., 2023) and RouteLLM (Ong et al., 2024) apply analogous routing to model selection. SCM differs primarily in the routed unit: instead of exposing only retrieval depth or model choice, it maps a per-query semantic label to a payload that can select retrieval strategy, substrate reads, prompt family, and synthesis procedure. The result is a richer control surface that sits one level above the underlying retrieval and generation primitives.

The core concepts of SCM are mode, payload, and procedure. A mode is a semantic label describing the query shape, such as single-fact lookup, long-form synthesis, time-anchored lookup, or latest-version resolution. A payload is the concrete configuration derived from that label, specifying retrieval depth, fusion strategy, synthesizer model, prompt family, and whether graph or multi-hop handling is enabled. A procedure is the execution family that actually answers the query: direct lookup, graph or iterative multi-hop handling, or long-form synthesis. The crucial theoretical move is that modes and procedures are not one-to-one. Several labels may map to the same initial payload, and runtime gates can change the executed procedure based on query or retrieved-context signals. This decoupling is what makes the architecture an interface rather than a fixed taxonomy.

The dispatch logic can be written as

The first equation selects the semantic label, either from the application or from a frozen classifier. The second maps that label to a concrete configuration. The third allows runtime signals to revise the configuration, for example forcing a multi-hop tier when relation markers are detected. The final equation selects the execution family. The meaning of each variable is intuitive: mode is the semantic intention, payload is the operational plan, and final_tier is the resolved execution path. The value of this formulation is that it makes the memory operating point explicit and mutable on a per-query basis, while still allowing shared construction of the underlying substrate.

The shared substrate itself is a theoretical commitment. Rather than building separate stores for each procedure, SCM puts chunks, embeddings, lexical indexes, extracted triples, and fact-version metadata in one place. Optional asynchronous supplements add higher-level signals such as document shape, anticipated keypoints, canonical entities, event chains, and question patterns. These supplemental fields are nullable, meaning procedures read them only when enabled and otherwise degrade gracefully. This design encodes a specific assumption about cost placement: mandatory ingest creates a minimal queryable layer, while richer signals can be computed lazily without blocking query readiness. The theoretical boundary is that the substrate must support all three procedure families at acceptable quality, even before the optional supplements are complete.

The assumptions and scope of the framework are discussed with unusual candor. The paper assumes that query shape can be predicted well enough to route usefully, that the shared substrate is rich enough to support the routed procedures, and that language-model judges provide a reasonable but not human-validated signal. It does not assume that routing is optimal, that it causally explains the benchmark results, or that the evaluated configuration establishes a universal accuracy–latency–cost frontier. These boundaries are important: the theoretical framework is a design vocabulary and control interface, not a claim that any particular routing policy is superior to every fixed policy.

3. 技术架构

The technical architecture of SCM is organized around four design concepts: the mode source, the payload map, runtime gates, and the procedure families. Together they form a unified system in which the memory operating point is selected per query but the underlying storage and construction costs are shared. The system overview is simple in spirit but rich in detail: a query enters the router, receives an explicit or inferred mode, is converted to a payload, may be revised by runtime gates, and is finally executed by one of the procedure families against the shared substrate.

The mode source is either an application-selected label or the output of a frozen semantic classifier. The frozen classifier in the evaluated configuration emits one of four labels: single-fact lookup, long-form synthesis, time-anchored lookup, and latest-version resolution. It was selected from five candidate prompts on a synthetic off-test calibration set of 1,065 question-shape examples and then checked on a consensus-labeled development slice of 568 questions. The classifier uses Claude Haiku 4.5 with temperature 0, and unparseable outputs default to single-fact lookup. The payload map then turns the semantic label into concrete retrieval and synthesis flags. For example, single-fact, time-anchored, and latest-version labels all map to the same forced-simple retrieval configuration called h40-temporal-synth, with top_k = 100 and a Sonnet synthesizer. Only the long-form label maps to a different payload, h17-narrative, which enables graph-capable retrieval and a multipass synthesis procedure. There is also a special runtime route for in-context-learning corpora called ICL_BROAD_CONTEXT, which uses the same simple payload as the lookup labels. This mapping is summarized in a compact table in the paper, showing that the semantic label set is deliberately larger than the initial payload action set.

Runtime gates can revise the initial payload using query shape or retrieved-context signals. The system includes a lightweight tier classifier, intent rules, and a relation-chain detector. Multiple-choice questions can be forced to the simple tier, summary requests to the summary tier, and queries with several relation markers to multi-hop handling. Retrieval-shape detection can also reroute in-context-learning corpora after inspecting returned chunks. Empty-retrieval fallbacks can retry an ICL route or switch to summary-tier retrieval to recover chunks. These gates explain why the recorded classified_mode distribution can contain five values even though the frozen classifier has only four modes. The gates are not a fixed pipeline; they are a dynamic control layer that can override or refine the classifier's initial decision.

The three procedure families form the execution layer. Direct lookup embeds the query, optionally adds two lightweight paraphrases, and runs retrievers in parallel. The active configurations combine Okapi BM25 with dense retrieval over chunk, sentence, and paragraph indexes, then merge candidates with reciprocal-rank fusion (RRF). The final depth is capped at 100 chunks. A single Sonnet call synthesizes the answer, and the prompt instructs the model to emit "No information available" when the queried entity is unsupported. This abstention behavior is prompt-directed, not a deterministic post-retrieval filter. Graph and iterative multi-hop handling targets relation chains and current-state questions. Extracted triples store normalized subject, predicate, and object fields along with source memory, confidence, version number, active status, and optional temporal fields. A planner can select a seed entity and hop sequence over a closed predicate vocabulary; a grounded walker then chooses among actual incoming and outgoing edges. Candidate triples are ordered by descending version number, giving newer values precedence for ordinary current-state retrieval while retaining older evidence for provenance. Failed graph planning can fall back to iterative dense retrieval or standard fused retrieval. Long-form synthesis samples the corpus chronologically, targeting 200 chunks, and applies a multipass bullets-expand procedure. A cached or online source-shape classifier distinguishes narrative, research, technical, log, and mixed corpora; the selected shape controls a coverage-planning prompt and an expansion prompt. The active payload enables shape-aware wrapping, broad research prompts, narrative name fidelity, and soft keypoint hints, while leaving some other reranking features disabled.

The data flow through the system is therefore not uniform. A simple lookup moves quickly through embedding, lexical retrieval, fusion, and a single synthesis call. A multi-hop query may traverse the graph planner, the grounded walker, and fallback mechanisms. A long-form synthesis request executes a stratified, multi-pass procedure over a larger sample of the corpus. What unifies these paths is the shared substrate: all procedures read from the same chunks, embeddings, triples, and version metadata. The substrate lifecycle has a mandatory Tier-1 path that creates chunks, optional sentence and paragraph segments, embeddings, lexical-index fields, and extracted triples. Once that path completes, fused lookup is available immediately; graph quality depends on the retained triples; and long-form synthesis can operate directly from stratified chunks. Optional supplement jobs then cache higher-level signals such as document shape, keypoints, canonical entities, event chains, question patterns, structural importance, and entity types. These fields are nullable, so missing enrichments degrade to online detection or omission rather than blocking query readiness.

Key implementation details are pinned in the artifact. Embeddings use OpenAI text-embedding-3-large at 1,024 dimensions. BM25 uses k1 = 1.5 and b = 0.75. RRF uses k_constant = 30. The final retrieval depth is top_k = 100. Synthesis uses Claude Sonnet 4.5 at temperature 0. Judges use gpt-4o-mini and gpt-4o variants depending on the benchmark. These choices are not arbitrary: fixed temperature and deterministic prompt settings are intended to reduce variance in a multi-model, multi-benchmark evaluation. The paper also notes some non-invariants, such as the use of ChromaDB for Mem0 but pgvector for SCM and the production comparator, which means vector-store choice remains part of the complete-configuration comparison rather than being controlled.

4. 实验评估

The experimental design is driven by the recognition that agent-memory workloads are heterogeneous, so a single benchmark cannot capture the full surface. The authors therefore choose three complementary suites. LoCoMo (Long-term Conversational Memory) studies very long conversations, with 1,986 questions covering four factoid categories and one adversarial abstention category. MemoryAgentBench (MAB) covers accurate retrieval, test-time learning, long-range understanding, and selective forgetting across 3,671 questions. LongMemEval (Longitudinal Personal Memory Evaluation) covers extraction, multi-session reasoning, temporal reasoning, knowledge updates, and abstention across 500 questions. Together these suites exercise direct lookup, relation-chain reasoning, long-form synthesis, and current-state resolution in different proportions.

The evaluation strategy is explicitly descriptive rather than causal. The authors report three complete configurations: SCM in its deployed mode-routed configuration, a production comparator, and Mem0 v2 OSS with its language-model reranker. The headline results are shown in the table below.

SCM records the largest displayed aggregate on all three benchmarks, as well as the largest observed minimum score. However, the authors immediately qualify these numbers. Raw baseline outputs are unavailable, so prompt parity, row-level corrections, and paired uncertainty cannot be independently audited. Most cells are single-run, and the MAB reference consists of two repetitions scoring 61.72% and 61.26%, with an arithmetic mean of 61.49% and a sample standard deviation of 0.32 percentage points. The paper does not report p-values, confidence intervals, or formal effect sizes, and it describes terms like "higher" and "lower" as observations on the retained outputs only.

The MAB competency breakdown reveals substantial heterogeneity beneath the aggregate. Accurate retrieval (AR) averages 78.62%, with strong performance on SH-Doc-QA (96.0%), MH-Doc-QA (85.0%), and EventQA (86.3%), but weaker performance on LME-S* (45.7%). Test-time learning (TTL) averages 50.05%, buoyed by the MCC group (86.40%) but dragged down by Movie-Rec (13.9%). Long-range understanding (LRU) averages 54.67%, with InfBench-Sum at 27.5% and Detective-QA at 80.3%. Selective forgetting (SF) averages 62.62%, with FC-SH at 82.7% but FC-MH at 42.8%. This pattern shows that the aggregate score is not uniform: the system is strong on direct factoid questions and detective-style reasoning, but weak on movie recommendations, long-range summarization, and multi-hop conflict resolution. The authors use these strata as engineering hypotheses, not as causal attributions to individual procedures.

LongMemEval shows the largest SCM–comparator differences by task type. SCM reaches 95.71% on single-session-user, 94.64% on single-session-assistant, 83.33% on single-session-preference, 78.95% on multi-session, 83.46% on temporal-reasoning, and 88.46% on knowledge-revision. The comparator scores are lower across the board, especially on temporal reasoning (31.58%) and single-session-preference (53.33%). The local reproduction trace records mode labels for these questions: temporal questions are distributed mainly across time-anchored, long-form, and single-fact labels, while knowledge-update questions are mostly labeled single-fact. Because no removal ablations were run, the task scores cannot be assigned to a unique procedure.

A notable methodological correction is made in the LoCoMo scoring. A question-text join duplicated one question across the factoid and adversarial categories, displacing it into the adversarial cut. The authors reclassify that existing row by fixture identity, which raises the factoid score from 81.17% to 84.87% and the mixed full-set score to 81.22%. This correction is transparently documented, and the authors caution that the mixed score combines two different metrics and should not be interpreted as a homogeneous accuracy measure. The factoid cut (84.87%) and the abstention cut (68.61%) are reported separately as the more meaningful numbers.

The statistical scope is intentionally limited. The MAB reference has two repetitions; other cells are single-run. Language-model judges may be prompt-, verbosity-, and contamination-sensitive, and no additional human-agreement study was performed. The authors treat reported percentages as descriptive benchmark-metric agreement rather than independently validated correctness. This is a careful, conservative stance that strengthens the paper's credibility even as it narrows the conclusions that can be drawn.

5. 案例研究

Although the paper does not present a single named protagonist scenario, it provides enough diagnostic detail to illuminate how the method behaves in practice. The most instructive cases are the failure strata from the completed local reproduction, which reveal the strengths and weaknesses of the routed architecture under real workload shapes.

Consider the LongMemEval temporal-reasoning category. In the local reproduction, 25 of 133 questions failed, with the largest recorded mode being long-form synthesis (14 failures) followed by time-anchored lookup (9 failures). The retrieval trace records hit_at_k = true for all 25 failures, meaning the relevant chunks were retrieved but the final answer was still judged incorrect. Representative rows show evidence-use errors: incomplete counting despite several relevant mentions, generic advice instead of a stored preference, incorrect ordering of retrieved events, and abstention when both current and prior facts were present. This pattern suggests that the bottleneck for temporal reasoning is not retrieval but synthesis: the substrate contains the needed facts, but the procedure does not always assemble them into the correct temporal order or resolve the conflict between old and new values.

The LongMemEval knowledge-update category provides a complementary case. Here 10 of 78 questions failed, and the dominant recorded mode was single-fact lookup (5 failures), with smaller groups in long-form synthesis and time-anchored lookup. The fact that most knowledge-update questions were labeled single-fact is interesting: it suggests the classifier treated them as direct lookups rather than as version-resolution tasks. Yet the failures occurred even though hit_at_k was true, indicating that the retrieved chunk contained the updated fact but the synthesizer either missed the update or failed to prefer the latest version. This case illustrates the gap between retrieving a relevant chunk and correctly resolving a versioned current-state answer.

A very different failure pattern appears in the MemoryAgentBench Movie-Rec task. All 179 failures out of 200 questions were recorded with classified_mode = SINGLE_FACT_LOOKUP. Recommendation questions are not factoid lookups; they require aggregating preferences across the corpus and producing a ranked list. The fact that the router assigned them to the simplest lookup mode points to a semantic mismatch: the frozen classifier's four-mode vocabulary may not have a label that captures recommendation-style reasoning, so these questions fall into the default lookup path. This case reveals a genuine weakness of the current routing vocabulary and suggests that expanding the mode set or adding a recommendation-specific gate could improve results.

The MAB FC-MH (multi-hop fact consolidation) failures show yet another pattern. Of 229 failures out of 400 questions, 214 were recorded with LONG_FORM_SYNTHESIS. Unlike Movie-Rec, these questions did receive the most powerful synthesis procedure, but the procedure still failed to resolve conflicts across multiple hops. This suggests that the graph or iterative strategy within the long-form tier is not yet strong enough for compositional conflict resolution, or that the fallback path between graph and iterative handling is not well calibrated. The active payload has a provenance mismatch here: its JSON field records graph_routed while an amendment note records a change to graph_then_iterative, and stored outputs do not retain the final graph strategy. This ambiguity prevents the authors from assigning the FC-MH failures to either graph or iterative execution.

Finally, the LoCoMo adversarial abstention failures show how a prompt-directed behavior can become a measurable strength when configured correctly. With entity-grounded abstention enabled, SCM scores 68.61% on the corrected adversarial cut, compared to a reported 2.46% with abstention disabled. The prompt instructs the synthesizer to identify the question's main entity and answer "No information available" when that entity is unsupported. The fact that this behavior is model-directed rather than filter-based is important: it relies on the model's ability to judge entity support, which can produce both correct abstentions and false refusals. The 139 residual failures in the local reproduction include many near-miss refusals or semantically reasonable corrections that fail the lexical target, reinforcing the authors' decision to report factoid and abstention metrics separately.

6. 综合价值与局限

The theoretical significance of SCM is that it provides a conceptual vocabulary for thinking about memory as a per-query operating point rather than a static architecture. The mode–payload–procedure separation gives designers a way to expose control without rebuilding the store for each new query shape. This is a useful conceptual tool because it clarifies where the memory trilemma—accuracy, latency, and cost placement—can be negotiated. Instead of choosing one point on the frontier for the whole system, the designer can choose a different point for each query, while still sharing the construction and indexing costs.

Practically, the work matters for anyone building long-lived agents that must answer heterogeneous questions. Customer support assistants, personal companions, and research agents all mix factoid recall, summarization, and temporal reasoning in the same conversation stream. SCM suggests that the right abstraction is not "a better vector store" or "a better graph index" but a controllable layer that can dispatch among retrieval and synthesis strategies as the query demands. Deployment would require maintaining the frozen classifier, calibrating the runtime gates, and deciding which optional supplements are worth their asynchronous cost. The paper makes clear that these engineering decisions are not trivial and that the current configuration is one point in a larger design space.

The strengths of the paper are its architectural clarity, its diagnostic transparency, and its methodological honesty. The architecture is explained with clean diagrams and a precise separation of concerns. The diagnostic layer preserves semantic-mode labels and retrieved chunks so that failure inspection can be done without re-running the model. The evaluation section is unusually explicit about what is missing: raw baseline outputs, aligned timing for LoCoMo and LongMem, complete token ledgers, and component-removal controls. This honesty makes the paper more credible than a conventional benchmark paper that would treat headline numbers as self-evident wins.

The limitations are equally important. The evaluation is configuration-level, not causal. Because baseline rows and many runtime decisions are unavailable, the paper cannot isolate the effect of routing itself. The frozen classifier is validated on synthetic and small real-dev slices, but there is no held-out procedure-level gold assignment or confusion matrix. The active graph strategy has a provenance mismatch between the JSON config and the amendment note. The LoCoMo and LongMem scored answers come from an offline Stage-3 synthesis path whose latency and token usage were not persisted, so the paper cannot make aligned end-to-end latency or cost comparisons. Language-model judges are known to be sensitive to prompt wording, position, and verbosity, and no human-agreement study was performed. Contamination of the public benchmarks in the pretraining data of synthesis and judge models is also acknowledged as a threat.

Broader implications connect this work to the trend toward memory as an operating-system resource rather than a passive database. Systems like MemOS and LightMem are making similar moves: memory is becoming a managed resource with explicit construction, consolidation, and retrieval policies. SCM contributes to this trend by adding a routing layer that exposes the operating point to the application. It does not close the research direction; rather, it opens questions about optimal router design, learned payload selection, and the trade-off between richer mode vocabularies and classifier accuracy. The paper's own list of next steps is the best summary of what remains to be done: persist complete routing provenance, align scored answers with timing and usage, compare routed and fixed policies on identical corpus snapshots, and audit a stratified judge sample.

7. 延伸阅读与思考

SCM builds on several important prior lines of work. In agent memory, Generative Agents established the value of stored observations and synthesized reflections; MemoryBank added long-term updating and forgetting; and MemGPT/Letta made memory an explicit resource with tiered access. These systems showed that memory is not just retrieval but also construction and organization. In adaptive retrieval, Adaptive-RAG, Self-RAG, IRCoT, and FLARE demonstrated that retrieval depth and timing can be adapted to question complexity. SCM extends these ideas by routing not just retrieval but the entire retrieval-plus-synthesis pipeline. In structured knowledge, GraphRAG and RAPTOR showed how graph and hierarchy can support synthesis over large collections; temporal knowledge graphs showed how to preserve changing relations. SCM organizes these primitives into procedure-owned paths over one shared substrate.

Alternative approaches for the same problem can be compared in philosophy as well as performance. Mem0 v2 OSS uses a language-model reranker and explicit extraction at ingest; it is simpler but scored lower on all three benchmarks in this study. The production comparator is a more competitive baseline but is not fully inspectable. Zep/Graphiti and A-Mem use temporal knowledge graphs and agentic linking as the central organizing principle, whereas SCM uses routing as the central principle and keeps the graph as one of several procedure options. MIRIX uses multiple typed stores under a controller, which is closer in spirit to SCM but does not emphasize the mode–payload–procedure separation.

Future directions are numerous. The most immediate is to validate whether automatic routing is actually better than a fixed policy on identical corpus snapshots. This would require holding the substrate constant and comparing the routed configuration against each procedure family run in isolation. Another direction is to learn the payload map rather than hand-engineering it, perhaps using offline bandit or reinforcement-learning methods. A richer mode vocabulary could address the current blind spots, such as recommendation and multi-hop conflict resolution. The optional supplement jobs could be selectively scheduled based on expected query patterns or predicted value. Finally, a human-agreement study for the language-model judges would strengthen the interpretability of the reported scores.

The deepest open problems in this area are not purely technical. They include how to represent the evolving self of a long-lived agent, how to balance forgetting and retention, how to attribute answers to sources when the chain of reasoning spans thousands of turns, and how to judge correctness when human evaluators themselves disagree. SCM's routing perspective does not solve these problems, but it provides a clearer control surface for exploring them. By separating the question of "what kind of memory operation is needed" from the question of "how is the memory stored," the architecture makes it easier to experiment with different procedures without rebuilding the substrate each time.

What is most surprising and thought-provoking about this work is the authors' willingness to publish a paper whose headline results are explicitly bracketed by limitations. Rather than claiming a routing breakthrough, they claim a routing interface and a carefully bounded characterization. In a field where benchmark tables are often treated as definitive, this epistemic discipline is refreshing. It also raises a question worth exploring further: how should the community evaluate systems whose value lies in controllability and composition rather than in a single accuracy number? SCM is a step toward an answer, but the question remains open.