Skip to content

Supra Cognitive Modes: A Routed Architecture for Agent Memory

🕒 Published (v1): 2026-07-21 13:37 UTC · Source: Arxiv · link

Why this paper was selected

Routed memory architecture separating factual lookup, reasoning, synthesis — core harness primitive

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

Supra Cognitive Modes (SCM) is a routed agent-memory architecture that dispatches per-query semantic labels to one of three procedure families—direct lookup, graph/iterative multi-hop, or long-form synthesis—all reading from a single shared ingest substrate. The paper characterizes a deployed configuration across three memory benchmarks (LoCoMo, MAB, LongMemEval) and provides an unusually candid audit of what its evidence can and cannot support. It claims no causal routing advantage, only a working per-query control interface and descriptive accuracy results.

Problem

A single retrieval-and-synthesis policy cannot serve the heterogeneous query shapes that arise in long-running agent memory: direct factual lookup, relation-chain reasoning, and broad cross-session synthesis require different evidence pools and synthesis depths. Serving all three with one policy creates a trilemma among answer quality, latency, and cost—either over-spending on cheap queries or under-serving complex ones.

Method

SCM exposes a mode–payload–procedure interface. Each incoming query is assigned a mode via either an explicit application label or a frozen semantic classifier (four labels: single-fact, long-form, time-anchored, latest-version), which maps to a payload (concrete retrieval flags and synthesis config), which in turn selects a procedure family. Runtime gates—a lightweight tier classifier, intent rules, and a relation-chain detector—can revise the initial tier after inspecting the query or retrieved context. The dispatch logic is:

mode    = explicit_mode or classify(query)
payload = mode_to_payload(mode)
payload = runtime_gates(payload, query, retrieved_context)
return execute(procedure_for(payload.final_tier), query, payload)

Three procedure families share one ingest substrate:

  • Direct lookup: BM25 + dense retrieval over chunk/sentence/paragraph indexes, merged via reciprocal-rank fusion (RRF), capped at 100 chunks, synthesized with a single Claude Sonnet 4.5 call.
  • Graph/iterative multi-hop: extracted triples with normalized subject–predicate–object plus version numbers; a planner selects seed entities and hop sequences over a closed predicate vocabulary; newer version numbers take precedence for current-state queries.
  • Long-form synthesis: chronological sampling targeting 200 chunks, multipass bullets-expand procedure, with a cached/online source-shape classifier (narrative, research, technical, log, mixed) controlling coverage-planning and expansion prompts.

The shared substrate is populated via a mandatory Tier-1 ingest (chunks, embeddings, BM25 fields, triples) plus optional asynchronous supplement jobs (document shape, keypoints, canonical entities, event chains) whose fields are nullable and degrade gracefully when absent.

Key Contributions

  • Defines a per-query mode–payload–procedure control interface that exposes the memory operating point at query time rather than fixing one system-wide policy.
  • Provides a source-visible implementation covering direct, graph-capable, and long-form procedure families over a single asynchronous shared substrate.
  • Delivers a repository-traceable benchmark characterization with explicit auditing of timing, cost, judge, and provenance evidence boundaries—including clear statements of what the evidence does not support (causal routing effects, statistical significance, efficiency gains).

Results

All scores are descriptive; baselines lack raw outputs and most cells are single-run.

  • LoCoMo (n = 1,986): SCM 84.87% factoid, 68.61% adversarial abstention, 81.22% mixed — vs. Production Comparator 63.10% and Mem0 v2 OSS 13.08% (mixed full set).
  • MemoryAgentBench (n = 3,671): SCM 61.49% overall (runs: 61.72% and 61.26%, σ = 0.32 pp) — vs. Production Comparator 52.22% and Mem0 v2 OSS 34.03%. Sub-competencies: AR 78.62%, TTL 50.05%, LRU 54.67%, SF 62.62%. Notable heterogeneity: SH-Doc-QA 96.0%, MH-Doc-QA 85.0%, but Movie-Rec 13.9%, InfBench-Sum 27.5%.
  • LongMemEval (n = 500): SCM 86.00% — vs. Production Comparator 57.00% and Mem0 v2 OSS 24.00%.
  • Unweighted geometric mean across three benchmarks: SCM 75.45%, Production Comparator 57.27%, Mem0 v2 OSS 22.02%.
  • Frozen classifier: 96.06% overall accuracy on 1,065 synthetic examples; 90.14% micro accuracy on 568 consensus-labeled development questions.

Limitations

  • Raw baseline outputs are unavailable, so baseline parity on model, prompt, and pipeline settings cannot be independently audited.
  • LoCoMo and LongMemEval score an offline Stage-3 synthesis answer while retaining latency from the online answer path—end-to-end latency comparisons for these two benchmarks are omitted.
  • No component-removal ablations or fixed-policy controls were run, so no causal credit can be assigned to the routing mechanism or any individual procedure family.
  • Stored outputs do not fully preserve final runtime decisions (e.g., the active long-form payload has a provenance mismatch between recorded and amended graph strategy).
  • LM-judge scores measure agreement with the specified benchmark judge prompt, not human-validated correctness; the LoCoMo judge prompt originated with one compared system, creating a potential scoring circularity.
  • Statistical significance is explicitly not claimed; most benchmark cells are single-run.
  • Benchmark contamination in pretraining data of synthesis and judge models cannot be ruled out.

Relevance to Agentic AI / LLM Agents

SCM directly addresses a fundamental challenge in long-horizon LLM agents: memory systems must field qualitatively different query types—point lookups, relation chains, and cross-session synthesis—with very different cost-latency profiles, but most deployed systems apply a single retrieval policy. The mode–payload–procedure abstraction is a concrete design pattern that practitioners can adopt for configurable agent memory, complementing work on MemGPT/Letta (tiered memory), Mem0 (persistent extraction), and Zep/Graphiti (temporal knowledge graphs). The paper's unusually disciplined evidence audit—explicitly bounding what routing claims are supported—sets a useful methodological precedent for applied agent-systems research, where ablation gaps are common but rarely disclosed.