SuperLocalMemory V3: Information-Geometric Foundations for Zero-LLM Enterprise Agent Memory

Paper: arXiv:2603.14588 Code: qualixar/superlocalmemory Code reference: main @ 308404ba (2026-05-24)

1. Motivation (研究动机)

当前 agent memory 的三个结构性短板

这篇论文的核心问题不是“再做一个记忆库”，而是指出当前 agent memory 的底层机制过于工程化：检索几乎统一依赖 embedding cosine similarity，记忆衰减依赖固定 TTL、指数衰减或访问次数阈值，跨项目/跨会话的矛盾检测通常没有形式化机制。作者认为这会在企业场景里变成可靠性瓶颈：一个长期运行的 agent 会积累大量 facts、用户、项目和上下文，如果相似度、生命周期和一致性都靠 heuristic，系统规模变大时无法说明它为什么还应该正确。

第一类问题是 uncertainty-blind retrieval。Cosine similarity 把每个 embedding 维度当成同等可信，但实际表示空间的不同维度有不同统计稳定性：有的维度承载稳定语义，有的维度接近噪声或分布尾部。论文希望用 Fisher information / Fisher-Rao metric 把“维度可信度”纳入检索分数，让低方差、高置信的语义维度对排名贡献更大。

第二类问题是 unprincipled lifecycle dynamics。现有 memory 系统通常把“遗忘”写成固定衰减函数，例如距离上次访问多久、访问次数多少、TTL 是否过期。论文认为这类规则不能随 memory manifold 的统计结构自适应，也没有稳定分布或收敛保证。作者因此把 memory lifecycle 建模为 Poincaré ball 上的 Riemannian Langevin dynamics，让活跃、高重要性的记忆靠近原点，长期未用的记忆自然漂向边界。

第三类问题是 cross-context contradiction。企业 agent 会跨项目、跨会话、跨用户记录事实，例如同一个 API 在一个项目里被记为 REST，在另一个上下文里被记为 GraphQL。单纯向量检索很难判断“两个相关事实是否不能同时成立”。论文把 memory context graph 视为 sheaf，使用 coboundary norm / first cohomology 的语言识别不可调和的局部不一致，并在存储阶段写入 supersedes 等图边。

论文要解决的具体目标

SLM-V3 的目标是在 zero-LLM / local-first 约束下，为 agent memory 建立一套可以解释、可扩展、可合规的数学基础：检索用信息几何替代单一 cosine，生命周期用随机动力学替代手写衰减，一致性用 sheaf cohomology 替代临时字符串/LLM 判定。这个目标特别面向企业 agent：数据不能随便出本地或租户边界，记忆需要跨长时间尺度运行，系统还要能解释为什么某条旧记忆被保留、降权或替换。

为什么值得研究

一旦 agent memory 有形式化检索和一致性基础，系统可以更自然地支持百万级 memories、多租户 profile isolation、合规审计和长期任务连续性。论文强调 Mode A 的 zero-cloud 设计在架构上满足 EU AI Act / data sovereignty 的方向：检索、重排、存储、矛盾检测都在本地 CPU 上完成；Mode B/C 只把 LLM 作为 answer synthesis / sufficiency verification 的增强，而不是检索本身的必要条件。

2. Idea (核心思想)

核心 insight：agent memory 不是普通向量数据库，而是带不确定性、生命周期和上下文一致性约束的统计-拓扑对象。因此，检索分数应该来自统计 manifold 上的 precision-weighted distance，记忆保留/遗忘应该来自带平稳分布的动力学过程，矛盾检测应该来自 context graph 上局部 sections 是否能拼成全局一致 section。

关键创新可以压缩成三层：第一，给每条 memory 的 embedding 附加 per-dimension variance，把 memory 表示为 diagonal Gaussian $(μ_{i}, σ_{i})$ ，再用 Fisher-information-weighted score 替代纯 cosine；第二，把记忆状态 $ξ (t)$ 放在 Poincaré ball 内，用 Riemannian Langevin SDE 生成 lifecycle weight；第三，把上下文图建成 sheaf，用 coboundary norm $κ$ 在 store time 找 contradictions 并写入图结构。

与 Mem0、Zep、MemGPT 一类系统的根本差异在于：那些系统通常把 LLM summarization、embedding retrieval、heuristic decay 和 prompt engineering 组合起来；SLM-V3 把 cloud LLM 从检索核心里移出去，试图让“该召回什么、该保留什么、该替换什么”由本地可复现的数学层决定。它并不声称 Mode A 的最终回答质量超过 cloud-heavy 系统，而是声称检索质量与合规边界可以在 zero-LLM 条件下显著逼近主流系统。

3. Method (方法)

3.1 Overall framework：本地化 ingest + 多通道 retrieve + 三个数学层

Figure 1 解读：左侧是 store / ingestion pipeline：内容先被 embedding 成 $μ$ ，再抽取 metadata、entities、semantic facts、emotions / beliefs，并构造 entity graph；随后 sheaf consistency checker 在图边上检测矛盾，必要时创建 supersedes edges；最后通过 entropy gate 过滤低信息内容并持久化到 SQLite。中间是 retrieval pipeline：query 先分类，再进入 Fisher semantic、BM25、entity graph、temporal reasoning 等信号源，之后用 WRRF 融合并重排。右侧是三层数学贡献：Fisher-Rao retrieval、sheaf consistency、Riemannian Langevin lifecycle。底部的 Mode A/B/C 说明系统从 fully local zero-LLM 到 cloud-augmented 的隐私-能力梯度。

论文中的 memory tuple 是： $m = (μ \in R^{d}, σ \in R_{> 0}^{d}, content, entities, facts, t_{created}, t_{accessed}, n_{access}) .$ 直觉上， $μ$ 是“记忆在哪里”， $σ$ 是“这个位置在每个维度上有多可靠”，entities/facts 是可结构化检索和图传播的锚点，timestamps / access counts 则喂给 lifecycle dynamics。它不是把所有内容塞进一个 embedding，而是把一条 memory 拆成向量、图节点、时间事件、置信度和生命周期状态。

3.2 Ingestion pipeline：从原始文本到可检索 facts

论文描述的 store pipeline 有 11 步：embedding、metadata extraction、named entity extraction、semantic fact extraction、emotion/belief detection、entity graph construction、sheaf consistency checking、foresight prediction、observation construction、entropy gating、SQLite persistence。Released code 中 src/superlocalmemory/core/store_pipeline.py 的 run_store / enrich_fact 与这个设计基本对应：enrich_fact 先调用 embedder 得到 embedding，再计算 Fisher parameters，解析 canonical entities 和 temporal metadata，初始化 8 维 Langevin position，并把 fact 写成 AtomicFact；随后 run_store 做 consolidation、ANN/vector-store upsert、context generation、graph edges、AutoLinker、sheaf check 和 temporal validation。

如果去掉 ingestion 的结构化步骤，后续检索会退化成普通 vector search：BM25 没有 token table，entity graph 没有边，sheaf 没有可检查的上下文连接，temporal channel 也只能从原始文本临时猜日期。这也是论文强调 SQLite schema / profile isolation 的原因：记忆系统的“可检索性”很大一部分是在写入时预计算出来的。

def store_memory(content, profile_id, db, embedder, extractors, graph, sheaf_checker):
    record = make_memory_record(content, profile_id)
    facts = extractors.fact_extractor.extract(content)
    if not facts:
        facts = [fallback_semantic_fact(content)]
 
    stored_ids = []
    for fact in facts:
        embedding = embedder.embed(fact.content)
        fisher_mean, fisher_variance = embedder.compute_fisher_params(embedding)
        canonical_entities = extractors.entity_resolver.resolve(fact.entities, profile_id)
        temporal = extractors.temporal_parser.extract_dates_from_text(fact.content)
        langevin_position = init_langevin_position(dim=8, radius=0.05)
 
        atomic = AtomicFact(
            content=fact.content,
            embedding=embedding,
            fisher_mean=fisher_mean,
            fisher_variance=fisher_variance,
            canonical_entities=list(canonical_entities.values()),
            referenced_date=temporal.get("referenced_date"),
            langevin_position=langevin_position,
        )
        db.store_fact(atomic)
        graph.build_edges(atomic, profile_id)
 
        if sheaf_checker and atomic.embedding and atomic.canonical_entities:
            for contradiction in sheaf_checker.check_consistency(atomic, profile_id):
                if contradiction.severity > 0.45:
                    db.store_edge(GraphEdge(
                        source_id=atomic.fact_id,
                        target_id=contradiction.fact_id_b,
                        edge_type="supersedes",
                        weight=contradiction.severity,
                    ))
        stored_ids.append(atomic.fact_id)
    return stored_ids

3.3 Information-geometric retrieval：用 variance-weighted score 替代纯 cosine

论文把每条 memory 的 embedding 扩展成 diagonal Gaussian。给定 embedding $e_{i}$ ，先归一化 $\overset{e}{^}_{i} = e_{i} /∥ e_{i} ∥$ ，再用维度信号强度估计方差： $μ_{i} = e_{i}, σ_{i, k}^{2} = σ_{m a x}^{2} - (σ_{m a x}^{2} - σ_{m i n}^{2}) \cdot \frac{∣ e ^ _{i, k} ∣}{m a x _{j} ∣ e ^ _{i, j} ∣} + ϵ .$ 然后为了避免新写入 memory 的 variance 估计太不稳定，系统在前 10 次 access 内从 cosine 平滑过渡到 Fisher score： $α_{i} = min (n_{access, i} /10, 1), s_{eff} (q, m_{i}) = (1 - α_{i}) s_{c o s} (q, m_{i}) + α_{i} s_{FR} (q, m_{i}) .$ 核心检索分数是： $s_{FR} (q, m_{i}) = exp (- \frac{1}{T} \sum_{k = 1}^{d} \frac{( μ _{q, k} - μ _{i, k} ) ^{2}}{σ _{i, k}^{2}}) .$ 直觉：如果两个 memory 与 query 的 cosine 一样近，但其中一个在关键维度上方差更小，Fisher score 会更偏向它，因为它代表更“确定”的语义证据。这样做在 $O (d)$ 复杂度下保留了向量检索的效率，却把局部统计精度纳入了排序。

def fisher_semantic_score(query_embedding, fact_embedding, fact_variance, temperature=15.0):
    # Mirrors released default: simplified Mahalanobis-like Fisher-Rao scoring.
    q = torch.tensor(query_embedding, dtype=torch.float32)
    f = torch.tensor(fact_embedding, dtype=torch.float32)
    var = torch.clamp(torch.tensor(fact_variance, dtype=torch.float32), min=1e-6)
    distance = torch.sum((q - f) ** 2 / var)
    return torch.exp(-distance / temperature).item()
 
 
def compute_fisher_params(embedding):
    e = torch.tensor(embedding, dtype=torch.float64)
    norm = torch.linalg.vector_norm(e)
    if norm < 1e-10:
        return torch.zeros_like(e), torch.ones_like(e)
    mean = e / norm
    signal = torch.abs(mean) / (torch.max(torch.abs(mean)) + 1e-10)
    variance = VAR_MAX - (VAR_MAX - VAR_MIN) * signal
    return mean, torch.clamp(variance, VAR_MIN, VAR_MAX)

论文公式与 released code 实现差异：论文写 $μ_{i} = e_{i}$ ，但 src/superlocalmemory/core/embeddings.py::compute_fisher_params 返回的是 normalized mean；论文呈现的是 Fisher-information-weighted score，released code 的默认 fisher_mode="simplified" 在 src/superlocalmemory/retrieval/semantic_channel.py::_compute_fisher_sim 使用 fact variance 的 Mahalanobis-like score，完整 Atkinson-Mitchell geodesic 只在 fisher_mode="full" 且 query/fact variance 都存在时启用。

3.4 Four/six-channel retrieval and WRRF fusion

论文主体把检索写成四个核心通道：Fisher semantic、BM25 keyword、entity graph、temporal reasoning；另外有 profile lookup、scene expansion、bridge discovery 三个补充 stage。WRRF 公式为： $WRRF (m) = \sum_{i = 1}^{4} \frac{w _{i}}{k + r _{i} ( m )}, k = 60.$ 其中 $r_{i} (m)$ 是 memory 在第 $i$ 个通道里的 rank，不出现则贡献 0。Query strategy classifier 会按 single-hop、multi-hop、temporal、aggregation/open-domain 调整 channel weights；multi-hop 更偏 entity graph，temporal query 更偏 temporal channel。

Released code 中 src/superlocalmemory/retrieval/engine.py::recall 的实际流程是：query classification → profile shortcut → active channels → weighted_rrf → multi-hop cross-channel intersection boost → bridge discovery → scene expansion → entity graph post-RRF boost → cross-encoder rerank → load top facts。BM25 使用 rank_bm25.BM25Plus(k1=1.2, b=0.75) 并给 exact phrase 1.5× bonus；temporal channel 同时做 entity-temporal search 和 date proximity；entity graph 在新版本中既保留 standalone search，又在 engine 中以 score_candidates 形式作为 post-RRF booster。

def recall(query, profile_id, strategy, channels, config, db, reranker=None):
    # Released implementation: strategy -> channels -> RRF -> expansion/boost -> rerank.
    weights = strategy.classify(query).weights
    channel_results = {}
 
    query_embedding = embed_once_if_needed(query)
    if "semantic" not in config.disabled_channels:
        channel_results["semantic"] = channels.semantic.search(query_embedding, profile_id, top_k=50)
    if "bm25" not in config.disabled_channels:
        channel_results["bm25"] = channels.bm25.search(query, profile_id, top_k=50)
    if "temporal" not in config.disabled_channels:
        channel_results["temporal"] = channels.temporal.search(query, profile_id, top_k=50)
    if channels.hopfield is not None:
        channel_results["hopfield"] = channels.hopfield.search(query_embedding, profile_id)
    if channels.spreading_activation is not None:
        channel_results["spreading_activation"] = channels.spreading_activation.search(query_embedding, profile_id)
 
    fused = weighted_rrf(channel_results, weights, k=config.rrf_k)
    fused = bridge_discover_and_scene_expand(fused, db, profile_id)
 
    candidate_ids = [x.fact_id for x in fused[:100]]
    graph_scores = channels.entity_graph.score_candidates(query, candidate_ids, profile_id)
    fused = boost_by_entity_graph(fused, graph_scores, weight=weights.get("entity_graph", 1.0))
 
    if reranker is not None:
        fused = reranker.blend_cross_encoder_and_rrf(query, fused, alpha=strategy.alpha)
    return load_top_facts(fused, db, limit=config.top_k)

论文公式与 released code 实现差异：论文叙述是 four-channel retrieval 且 WRRF $k = 60$ ；released code 的 src/superlocalmemory/core/engine_wiring.py::init_retrieval 会注册 semantic、BM25、entity_graph、temporal，并可加入 spreading_activation 和 hopfield 作为第 5/6 通道；src/superlocalmemory/retrieval/engine.py::_run_channels 还注释说明 entity graph 现在主要作为 post-RRF signal enhancer，而不是独立通道；src/superlocalmemory/core/config.py::RetrievalConfig 默认 rrf_k=15，不是论文中的 60。

3.5 Sheaf-theoretic consistency：在 store time 检测跨上下文矛盾

Memory sheaf 把 context graph $G = (V, E)$ 中的每个顶点 $v$ 视为一个上下文，每个 stalk $F (v) = R^{d}$ 是该上下文内 memory embeddings 的空间；边 $(u, v)$ 上的 restriction map $ρ_{u \to v}$ 表示从一个上下文到另一个上下文时共享事实应如何投影。Coboundary operator 是： $(δ f) (u, v) = ρ_{u \to v} (f (u)) - f (v) .$ 如果 $δ f = 0$ ，说明局部 facts 能拼成全局一致 section；如果 discrepancy 很大，则表示存在跨上下文冲突。论文进一步把 contradiction score 写成： $H^{1} (G, F) = ker (δ_{1}) / im (δ_{0}), κ = \frac{∥ δ f ∥ ^{2}}{∥ f ∥ ^{2} + ϵ} .$ Released code 的 src/superlocalmemory/math/sheaf.py::check_consistency 实际在新增 fact 的图边邻居上计算 edge-type-specific restriction map 和 coboundary norm；若 severity 超过 threshold，就返回 contradiction，并在 store_pipeline.py 中写入 EdgeType.SUPERSEDES。因此它不是 retrieval-time LLM judge，而是写入阶段的图一致性维护。

def check_sheaf_consistency(new_fact, db, threshold=0.45):
    if new_fact.embedding is None or not new_fact.canonical_entities:
        return []
    contradictions = []
    x = torch.tensor(new_fact.embedding, dtype=torch.float64)
 
    for edge in db.get_edges_for_node(new_fact.fact_id, new_fact.profile_id):
        if edge.edge_type in {"contradiction", "supersedes"}:
            continue
        other = db.get_fact_embedding(edge.other_endpoint(new_fact.fact_id))
        if other is None:
            continue
        y = torch.tensor(other, dtype=torch.float64)
        restriction = restriction_for_edge_type(edge.edge_type, x, y)
        severity = torch.linalg.vector_norm(restriction @ x - y).pow(2) / (torch.linalg.vector_norm(x).pow(2) + 1e-8)
        if severity.item() > threshold:
            contradictions.append((edge.other_endpoint(new_fact.fact_id), min(severity.item(), 1.0)))
    return contradictions

3.6 Riemannian Langevin lifecycle：用几何位置生成 retrieval weight

SLM-V3 把每条 memory 的生命周期状态放在 Poincaré ball $D^{d} = {ξ \in R^{d} : ∥ ξ ∥ < 1}$ 中。论文的连续动力学是： $ d\xi = -\lambda_{\xi}^{-2}\nabla_E U(\xi)dt

\sqrt{2T}\lambda_{\xi}^{-1}dW
\frac{1}{2}T(d-2)\lambda_{\xi}^{-1}\xi dt, \quad \lambda_\xi=\frac{2}{1-|\xi|^2}. $P o t e n t ia l f u n c t i o n 编码 rece n cy / f re q u e n cy / co n t e x t u a l re l e v an ce ：$ U(\xi)=\alpha|\xi|^2-\beta\cdot n_{\text{access}}(\xi)-\gamma\cdot r(\xi,c). $离散实现使用 E u l er - M a r u y ama u p d a t e ：$ \xi_{t+1}=\xi_t-\lambda_{\xi_t}^{-2}\nabla_EU(\xi_t)\Delta t +\frac{1}{2}T(d-2)\lambda_{\xi_t}^{-1}\xi_t\Delta t +\sqrt{2T\Delta t}\lambda_{\xi_t}^{-1}\eta_t. $ Released code 的 src/superlocalmemory/math/langevin.py 还额外加入 Ebbinghaus-style outward forgetting drift：access 和 importance 越高，memory strength 越高，向边界漂移越弱；最终 retrieval weight 按 radius 从原点到边界线性衰减。生命周期状态阈值为 Active <0.3、Warm <0.55、Cold <0.8、Archived >=0.8。

def langevin_step(position, access_count, age_days, importance, dt=0.005, temperature=0.3):
    xi = torch.tensor(position, dtype=torch.float64)
    radius_sq = torch.clamp(torch.dot(xi, xi), max=0.99 ** 2)
    lam = 2.0 / (1.0 - radius_sq + 1e-8)
    lam_inv = 1.0 / lam
 
    grad_u = potential_gradient(xi, access_count, age_days, importance)
    drift = -(lam_inv ** 2) * grad_u * dt
 
    strength = max(0.5, 0.3 * math.log1p(access_count) + 0.4 * importance)
    forget_rate = 1.0 / strength
    outward = xi / (torch.linalg.vector_norm(xi) + 1e-8)
    forgetting_drift = forget_rate * outward * dt * 0.1
 
    correction = 0.5 * temperature * (len(xi) - 2) * lam_inv * xi * dt
    diffusion = math.sqrt(2.0 * temperature * dt) * lam_inv * torch.randn_like(xi)
    new_xi = project_to_open_unit_ball(xi + drift + forgetting_drift + correction + diffusion)
    weight = 1.0 - torch.linalg.vector_norm(new_xi).item() / 0.99
    return new_xi.tolist(), max(0.0, min(1.0, weight))

3.7 Code-to-paper mapping

Code reference: main @ 308404ba (2026-05-24) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
Store / ingestion pipeline	`src/superlocalmemory/core/store_pipeline.py`	`run_store`, `enrich_fact`
Fisher parameter construction	`src/superlocalmemory/core/embeddings.py`	`compute_fisher_params`
Fisher semantic retrieval	`src/superlocalmemory/retrieval/semantic_channel.py`	`SemanticChannel.search`, `_compute_fisher_sim`
BM25 channel	`src/superlocalmemory/retrieval/bm25_channel.py`	`BM25Channel.search`
Entity graph retrieval / booster	`src/superlocalmemory/retrieval/entity_channel.py`	`EntityGraphChannel.search`, `score_candidates`
Temporal retrieval	`src/superlocalmemory/retrieval/temporal_channel.py`	`TemporalChannel.search`
WRRF fusion	`src/superlocalmemory/retrieval/fusion.py`	`weighted_rrf`
Retrieval orchestration	`src/superlocalmemory/retrieval/engine.py`	`RetrievalEngine.recall`, `_run_channels`, `_apply_reranker`
Channel wiring and reranker config	`src/superlocalmemory/core/engine_wiring.py`	`init_retrieval`
Sheaf contradiction detection	`src/superlocalmemory/math/sheaf.py`	`SheafConsistencyChecker.check_consistency`
Langevin lifecycle dynamics	`src/superlocalmemory/math/langevin.py`	`LangevinDynamics.step`, `compute_lifecycle_weight`
Runtime config / ablation knobs	`src/superlocalmemory/core/config.py`	`RetrievalConfig`, `MathConfig`, mode factory

4. Experimental Setup (实验设置)

Dataset and scale

主要数据集是 LoCoMo conversational memory benchmark。论文说明 LoCoMo 包含 10 个 multi-session conversations，总计 1,986 个问题，覆盖 single-hop、multi-hop、temporal、open-domain 四类。实际报告里有多种 scoring subset：Mode A Raw appendix 表给出 10 个 conversations 中 1,276 个已评分问题；Fisher-vs-cosine 数学贡献实验覆盖 6 个 conversations、832 个问题；Mode C 详细结果只在 conv-30 的 81 个问题上报告。

Baselines

主表比较了 EverMemOS、Hindsight、Zep v3、MemOS v2、Mem0，以及 SLM-V3 的 Mode A Raw、Mode A Retrieval、Mode C。这里的对比要注意部署形态：EverMemOS / Hindsight / Zep / MemOS / Mem0 多依赖 cloud LLM 或 cloud embedding；SLM-V3 Mode A Raw 是 zero-LLM answer construction，Mode A Retrieval 用外部 LLM 只做 answer synthesis 以隔离 retrieval quality，Mode C 则使用 cloud embedding 和 cloud LLM。

Metrics

论文采用 LLM-as-Judge scoring：judge model 是 gpt-4.1-mini，每个回答按 1–5 Likert scale 评分，rating $\geq 4$ 记为 correct，再转成 accuracy。主表按 single/multi/temporal/open-domain 分类别报告 accuracy，并给 aggregate。Ablation 还报告相对 full system 的 percentage-point delta；统计分析中对 conv-30 full system 用 1,000 次 bootstrap 给出 95% CI [53.4, 74.0]。

Implementation / training config

这不是传统训练论文，主要是系统配置和评测配置。论文实验在 Azure Container Instances 上运行：每个 container 分配 2 vCPUs / 4 GB RAM，Python 3.12 + PyTorch 2.10 CPU-only，本地 SQLite 数据库；111 个 containers 分布在 3 个 Azure subscriptions、eastus2 和 swedencentral，每个处理一个 (conversation, configuration) pair；完整评测包含 10 个 LoCoMo conversations 和 8 个 ablation configurations；总估算成本 $9–15 USD。

论文配置：Mode A Raw 使用 nomic-embed-text-v1.5 768-d embedding 和 bge-reranker-v2-m3 cross-encoder，所有模型 baked into container；Mode A Retrieval 检索同 Mode A Raw，但用 gpt-4.1-mini 生成答案；Mode C 使用 text-embedding-3-large 3072-d embeddings，并用 gpt-4.1-mini 做 answer generation 和 judge。代码配置需要单独记录：src/superlocalmemory/core/config.py 当前 default RetrievalConfig.rrf_k=15、semantic_top_k=50、bm25_top_k=50、use_cross_encoder=True、cross_encoder_model="cross-encoder/ms-marco-MiniLM-L-12-v2"；MathConfig 当前 default fisher_temperature=15.0、langevin_dt=0.005、langevin_temperature=0.3、Mode A sheaf threshold 0.45、Mode C sheaf threshold 0.65。这些数字来自 released code config，而不是论文表格的默认叙述。

5. Experimental Results (实验结果)

Main LoCoMo results

System	Single	Multi	Temporal	Open	Aggregate
EverMemOS	96.1	91.1	89.7	70.8	92.3
Hindsight	86.2	70.8	95.1	83.8	89.6
Zep v3	90.8	81.9	77.3	75.0	85.2
SLM-V3 Mode C	64.0	100.0	—	86.0	87.7
MemOS v2	85.4	79.4	75.1	64.6	80.8
SLM-V3 Mode A Retrieval	72.0	70.3	80.0	85.0	74.8
Mem0	69.0	61.7	58.3	50.0	64.2
SLM-V3 Mode A Raw	57.5	43.0	63.0	72.0	60.4

这个表的关键信息是：SLM-V3 Mode A Raw 的最终回答准确率不如 LLM-heavy 系统，但 Mode A Retrieval 的 74.8% 说明本地多通道检索已经能召回相当多可用证据；Mode A Retrieval 在 open-domain 上达到 85.0%，是表中最高值。Mode C 在 conv-30 的 81 个问题上 aggregate 87.7%，接近 Zep v3 的 85.2% 和 Hindsight 的 89.6%，但它不是完整 10 conversations 的同规模结果。

Figure 2 解读：这张图把 LoCoMo accuracy 和 cloud dependency 放在一起看。SLM-V3 的定位不是绝对最高分，而是用 local-first / zero-LLM retrieval 换取合规和可复现；Mode C 则展示如果允许 cloud embedding + LLM answer generation，SLM-V3 可以靠近主流 cloud-dependent memory systems。

Ablation results

Configuration	LoCoMo (%)	Δ (pp)
SLM-V3 full system	60.4	—
− Fisher metric (`fisher_off`)	49.6	−10.8
− Sheaf consistency (`sheaf_off`)	58.7	−1.7
− All math layers (`all_math_off`)	52.8	−7.6
− BM25 channel (`bm25_off`)	53.9	−6.5
− Entity graph (`entity_off`)	59.4	−1.0
− Temporal channel (`temporal_off`)	60.2	−0.2
− Cross-encoder (`cross_encoder_off`)	29.7	−30.7

Figure 5 解读：最大贡献来自 cross-encoder reranking，移除后下降 30.7 pp（Δ = -30.7 pp）；数学层中 Fisher metric 的单项贡献最大，下降 10.8 pp；BM25 下降 6.5 pp，说明 exact lexical evidence 仍是 agent memory 中不可替代的信号。Sheaf、entity、temporal 在 conv-30 单 conversation 上 delta 较小，论文也承认这些较小差异的置信区间可能重叠。

Figure 4 解读：分类型 ablation 显示 multi-hop 最敏感：cross-encoder removal 让 multi-hop 从 50% 掉到 15%，BM25 removal 掉到 23%，all-math-off 掉到 38%。这支持论文对多通道融合的解释：multi-hop 问题需要 entity graph、lexical anchor、semantic similarity 和 reranker 同时工作；open-domain 相对鲁棒，说明 broad semantic/BM25 证据足以覆盖一部分问题。

Fisher-Rao vs cosine / math layer contribution

Conversation	With Math (%)	Without Math (%)	Δ (pp)
conv-26	78.5	71.2	+7.3
conv-30	77.5	66.7	+10.8
conv-42	60.8	47.3	+13.5
conv-43	64.3	58.3	+6.0
conv-44	64.2	44.3	+19.9
conv-49	84.7	65.9	+18.8
Average	71.7	58.9	+12.7

Figure 3 解读：数学层平均带来 +12.7 pp，且在更难的 conversations 上收益更大，例如 conv-44 +19.9 pp、conv-49 +18.8 pp。论文把这解释为 sparse / dense mixed memory population 下 cosine neighborhood 更容易被噪声污染，而 Fisher-Rao 用 variance profile 打破 cosine tie，更能区分低方差、高置信的记忆。

Mode C and cross-encoder caveat

Mode C 在 conv-30 的 per-category 结果为：single-hop 64.0、multi-hop 100.0、open-domain 86.0、aggregate 87.7。附录还报告了一个反直觉现象：在 Mode C 中关闭 cross-encoder 后 aggregate 反而是 90.1（single-hop 55.0、multi-hop 100.0、open-domain 93.0），比开启时高 +2.4 pp。论文解释是 cloud embedding text-embedding-3-large 在该 conversation 上已经足够强，cross-encoder 有时会把 broad open-domain evidence 降权到较窄匹配后面。

Limitations

作者明确承认三点限制。第一，评测集中在 LoCoMo，两人长期对话不能完全代表企业 memory 的 multi-user / multi-project 场景；LongMemEval 和 MemoryAgentBench 仍是未来工作。第二，zero-LLM Mode A Raw 约 60% 的答案准确率低于 LLM-dependent systems，本文更强的结论是“数学检索缩小了 gap”，不是“无 LLM 已经全面超过 cloud system”。第三，sheaf consistency 在 LoCoMo 上贡献较小，因为 LoCoMo 没有高密度 cross-context contradictions；这层的价值更可能在企业知识库和长期 agent deployment 中显现。

Paper Notes

探索

SuperLocalMemory V3: Information-Geometric Foundations for Zero-LLM Enterprise Agent Memory

SuperLocalMemory V3: Information-Geometric Foundations for Zero-LLM Enterprise Agent Memory

1. Motivation (研究动机)

当前 agent memory 的三个结构性短板

论文要解决的具体目标

为什么值得研究

2. Idea (核心思想)

3. Method (方法)

3.1 Overall framework：本地化 ingest + 多通道 retrieve + 三个数学层

3.2 Ingestion pipeline：从原始文本到可检索 facts

3.3 Information-geometric retrieval：用 variance-weighted score 替代纯 cosine

3.4 Four/six-channel retrieval and WRRF fusion

3.5 Sheaf-theoretic consistency：在 store time 检测跨上下文矛盾

3.6 Riemannian Langevin lifecycle：用几何位置生成 retrieval weight

3.7 Code-to-paper mapping

4. Experimental Setup (实验设置)

Dataset and scale

Baselines

Metrics

Implementation / training config

5. Experimental Results (实验结果)

Main LoCoMo results

Ablation results

Fisher-Rao vs cosine / math layer contribution

Mode C and cross-encoder caveat

Limitations

目录