← 回到书房

共读 · 已保存研究结果

谁在管理记忆?快判断、慢推理与旧信息的退场

一句“这条信息已经过时”进入系统后,会发生什么?Jev 给了记忆管理一种有界判断接口;存储、关联、检索与生成仍由具体执行路径接起来。沿着这些接口读下去,可以把“有记忆”拆成可观察的能力,也能看清哪些能力尚未得到证明。

先认清三个角色

Jev 是接收状态与问题的 hosted decision model;Jev-Mem 是使用它的 memory architecture;System Two 是最后组织答案或生成抽象的模型。官方 Jev 文档说明同一权重服务各账户,不提供客户 fine-tuning / LoRA。把更多经历放进 state,改变了这一次判断的输入,还不能叫模型学会了你的经历。 同一批问题共享 state,但彼此独立;需要前一步答案才能决定的问题,要由调用方分阶段组织。

写入:先留下经历,之后再决定用途

论文保留合法 observation,给它记忆类型、时间和来源。当前随附 profile 关闭 admission;可选的拒绝入口存在,却不是这个配置的默认行为。这样做保留了“现在看不出价值,未来才需要”的可能,同时也把筛选负担交给后续关联与检索。类型分数低不自动意味着条目该消失。

关联:控制器只判断它见到的候选

向量、实体、关键词和时间先圈出附近记录,Jev 再判断语义与因果等关系,代码按阈值建边。候选生成漏掉某段关键经历,后面的判断再精确也无从补救。AMS 既有候选竞争实验提醒我们:保存、进入候选、排进 context 是不同节点;它没有测 Jev 的 embedding 或关系质量。

检索:停下来,不总是因为已经知道

Jev-Mem 按 query 分配图预算,从 anchors 开始,反复检查已有证据并扩展。充分回答、继续探索无益和预算耗尽都可能结束循环。把所有停止都算成“证据完整”,会掩盖缺证据但无路可找的状态。模型失败还会改变 routing、traversal 或 stopping 的处理,必须保留实际走过的路径。

维护:过时的判断,先落在哪里

当前 consolidation 询问重复、矛盾、obsolete 和表示选择;它记录判断、添加关系,在另有 summarizer 且门槛满足时增加派生节点。下面的源码实验给定判断值,观察执行路径怎样改变节点和索引。它刻意把“能否判断对”留给另一个实验,先回答“这个判断究竟能让代码做什么”。

遗忘:要退出的是哪个范围

设六月记录是“出差选靠窗”,九月说“这次受伤,选过道”。这是编者例子,未做模型测试。我们可能需要当前订票采用过道、保留六月的历史解释、让临时条件结束后原偏好仍有效。当前 context 不出现、以后不再检索、持久化副本清除、已训练参数影响撤回,各自需要机制;一个 obsolete 标量不能替它们完成工作。

论文的速度与质量,先保留报告身份

Table 1–2 报告 LoCoMo overall 0.777、build 158 s、query 0.93 s;本站未复现。v1 正文与表格若干数值不同,当前源码的默认 best-of-n 使用参考答案选择,计时字段也有不同边界。没有运行 manifest,不能用现有默认值反推论文一定怎样运行;也不能把整套系统的收益全归功于 Jev。

AMS 因而可以多问一层

AgeMem 关心学到的管理策略,已有学习专题关心经验如何改变后续选择,Jev 则提供固定模型上的可组合控制接口。把它们连起来后,下一问会更具体:判断准确了吗,执行改变了吗,后续任务受益了吗?三种证据分别成立,再讨论能迁移什么。

Executed source study / 已执行源码实验

判断给定以后,记忆实际怎样变化?

切换已执行的 synthetic case,比较调用前后的节点、向量成员和派生摘要,再展开完整判断与返回记录。页面展示保存的源码执行结果;不在浏览器调用 Jev 或重新运行实验。

10 个 source-informed contract cases:指定 controller responses,执行固定 upstream 函数及真实 NetworkX/NumPy 内存后端,使用 MockEncoder 和拼接摘要回调。结果仅证明这些输入下的控制行为;不是 Jev 语义准确率、真实检索、持久化清除、模型遗忘或论文 benchmark 复现。

关闭 admission,给定四种 memory type 分数均为 0;检查合法 observation 是否仍保存。

存储节点 0 → 1;向量成员 0 → 1;派生摘要 0 → 0;关系 0 → 0。

调用前的快照

  • 存储节点无
  • 向量成员无
  • 派生摘要无

这些 ID 是原始运行 UUID 的统一显示标签。成员变化来自上游内存后端;向量仍在,不等于已验证语义检索会命中。

检查给定判断、实际返回、关系与逐项断言
{
  "id": "default-off-admission-still-follows-judgment",
  "title": "Admission 关闭:类型分数全零仍写入",
  "role": "control-negative",
  "group": "build-admission",
  "intervention": "关闭 admission,给定四种 memory type 分数均为 0;检查合法 observation 是否仍保存。",
  "input": {
    "config": {
      "write_enabled": true,
      "admission_enabled": false,
      "read_enabled": false,
      "jev_mock": true,
      "fallback_to_magma": true,
      "candidate_top_k": 10,
      "consolidation_threshold": 0.85,
      "consolidation_interval": 0
    },
    "sequence": [
      {
        "id": "n1",
        "text": "Alice plans to move to Lisbon later this year.",
        "timestamp": "2026-09-01T09:00:00"
      }
    ]
  },
  "before": {
    "stored_ids": [],
    "vector_ids": [],
    "summary_ids": [],
    "links": []
  },
  "after": {
    "stored_ids": [
      "n1"
    ],
    "vector_ids": [
      "n1"
    ],
    "summary_ids": [],
    "links": []
  },
  "observations": {
    "build_outcomes": [
      {
        "text": "Alice plans to move to Lisbon later this year.",
        "build": "stored",
        "id": "n1",
        "has_jev_mem": true
      }
    ],
    "consolidation_decisions": [],
    "summarizer_calls": [],
    "controller_calls": [
      {
        "operation": "memory_type",
        "question": "episodic",
        "kind": "noul",
        "value": 0
      },
      {
        "operation": "memory_type",
        "question": "semantic",
        "kind": "noul",
        "value": 0
      },
      {
        "operation": "memory_type",
        "question": "procedural",
        "kind": "noul",
        "value": 0
      },
      {
        "operation": "memory_type",
        "question": "preference",
        "kind": "noul",
        "value": 0
      }
    ],
    "audit_events": [
      "memory_constructed"
    ],
    "nodes": {
      "n1": {
        "content": "Alice plans to move to Lisbon later this year.",
        "source": null,
        "has_jev_mem": true,
        "memory_type": {
          "episodic": 0,
          "semantic": 0,
          "procedural": 0,
          "preference": 0
        },
        "admission": null,
        "admission_score": null,
        "raw_content": "Alice plans to move to Lisbon later this year.",
        "source_memory_ids": [],
        "parent_interaction_id": null,
        "consolidation": []
      }
    },
    "vector_count": 1
  },
  "checks": {
    "jev_write_path_used": true,
    "original_texts_retained": true,
    "node_vector_membership_matches": true,
    "node_added_count": true,
    "vector_added_count": true,
    "written_despite_zero_judgement": true,
    "admission_not_queried": true
  }
}

本例执行断言 7/7 符合预期;这不是模型判断正确率。

实验使用了哪些原函数与替身
{
  "source": {
    "repo": "https://github.com/libingzheren/Jev-Mem",
    "commit": "81574eb23f3fd8d1a6c4d54a1e7d6f2dd539e9bb",
    "expected_commit": "81574eb23f3fd8d1a6c4d54a1e7d6f2dd539e9bb",
    "commit_matches_pin": true,
    "commit_subject": "Add Hugging Face Paper badge to README",
    "dirty": false,
    "files": [
      {
        "path": "memory/memory_builder.py",
        "purpose": "MemoryBuilder.build, MemoryBuilder.consolidate",
        "sha256": "7ded92afb0615b84507ed53176a92f087b19c3e3ec0ac1bb777c200ab77a7228",
        "bytes": 59188,
        "line_count": 1387,
        "classes": {
          "MemoryBuilder": 26
        },
        "functions": {
          "__init__": 33,
          "build": 119,
          "_store_jev_node": 189,
          "_build_magma": 220,
          "consolidate": 228,
          "_simple_entity_extraction": 293,
          "extract_event": 326,
          "create_episode_node": 501,
          "create_session_nodes": 551,
          "create_event_from_episode": 601,
          "_index_text_basic": 672,
          "index_event": 697,
          "create_temporal_links": 730,
          "create_context_links": 762,
          "create_semantic_links": 815,
          "create_causal_links": 862,
          "create_entity_links": 914,
          "create_temporal_proximity_links": 957,
          "detect_qa_links": 998,
          "create_episode_event_links": 1045,
          "create_session_links": 1079,
          "batch_create_links": 1104,
          "build_memory": 1143,
          "save": 1292,
          "load": 1328,
          "add_sessions_to_existing_memory": 1360
        }
      },
      {
        "path": "memory/jev_mem_policies.py",
        "purpose": "WritePolicy, find_candidates, node_state",
        "sha256": "c1cde01f332448eb733e721e48e265bf134dac7e9eb3e702639c397fe1dfed2b",
        "bytes": 8950,
        "line_count": 186,
        "classes": {
          "MemoryAdmission": 12,
          "MemoryTypeScores": 26,
          "GraphNeeds": 34,
          "WritePolicy": 96
        },
        "functions": {
          "timestamp_value": 43,
          "node_state": 50,
          "cosine": 61,
          "find_candidates": 69,
          "allocate_graph_budgets": 161,
          "score": 19,
          "__init__": 97,
          "memory_type": 100,
          "assess_observation": 108,
          "relations": 125,
          "add": 145
        }
      },
      {
        "path": "memory/jev_mem_config.py",
        "purpose": "JevMemConfig",
        "sha256": "d413ce263433e682e256e6a780e6e4c8a9dcf0448e796d7ea51d4fe1b67bc428",
        "bytes": 4132,
        "line_count": 92,
        "classes": {
          "JevMemConfig": 11
        },
        "functions": {
          "__post_init__": 49,
          "_integer": 73,
          "load": 79,
          "to_dict": 90
        }
      },
      {
        "path": "memory/keyword_enrichment.py",
        "purpose": "KeywordEnricher",
        "sha256": "93b0f62409b192a8b1cbabc7bfbf245f49d57d4bb528c8d719a2f67806e92304",
        "bytes": 9275,
        "line_count": 270,
        "classes": {
          "KeywordEnricher": 14
        },
        "functions": {
          "test_enrichment": 210,
          "__init__": 17,
          "extract_keywords": 32,
          "extract_bigrams": 92,
          "enrich_content": 118,
          "enrich_query": 167
        }
      },
      {
        "path": "memory/jev_questions.py",
        "purpose": "Noul/Choice question definitions",
        "sha256": "2e8f4b8483e1da30f4e2d7d9d9ece227c3890dbb641f3d96ac7bbccff5ce8e9c",
        "bytes": 11712,
        "line_count": 164,
        "classes": {},
        "functions": {
          "noul": 10,
          "observation_questions": 14,
          "admission_questions": 19,
          "memory_type_questions": 44,
          "relation_questions": 66,
          "consolidation_questions": 86,
          "routing_questions": 112,
          "stopping_questions": 129,
          "traversal_questions": 146,
          "choice_fixture": 160
        }
      },
      {
        "path": "memory/mock_encoder.py",
        "purpose": "MockEncoder",
        "sha256": "8e92f2677ef7956e72e0c7a51dc3e07e7741e9e08ba2ca5bea96f48ccb4c09c9",
        "bytes": 605,
        "line_count": 19,
        "classes": {
          "MockEncoder": 7
        },
        "functions": {
          "encode": 10
        }
      },
      {
        "path": "memory/graph_db.py",
        "purpose": "EventNode, Link, LinkType, NodeType, NetworkXGraphDB",
        "sha256": "71b97499268b6e891e2093247c13e7a591a4ed33429d8339af1b7dc089f3b42e",
        "bytes": 25738,
        "line_count": 708,
        "classes": {
          "NodeType": 19,
          "LinkType": 27,
          "LinkSubType": 34,
          "LinkStatus": 59,
          "EventNode": 66,
          "EpisodeNode": 102,
          "SessionNode": 169,
          "Link": 208,
          "TraversalConstraints": 260,
          "GraphDBInterface": 303,
          "NetworkXGraphDB": 369
        },
        "functions": {
          "to_dict": 224,
          "from_dict": 242,
          "__post_init__": 217,
          "allows_link": 272,
          "add_node": 379,
          "add_link": 388,
          "get_node": 410,
          "get_link": 414,
          "get_neighbors": 418,
          "update_node": 443,
          "update_link": 456,
          "delete_node": 475,
          "delete_link": 491,
          "traverse": 513,
          "find_path": 565,
          "get_subgraph": 591,
          "__init__": 372,
          "get_temporal_chain": 612,
          "find_causal_paths": 645,
          "export_to_json": 667,
          "import_from_json": 677,
          "save": 701,
          "load": 705,
          "dfs_causal": 649,
          "edge_filter": 574
        }
      },
      {
        "path": "memory/vector_db.py",
        "purpose": "NumpyVectorDB",
        "sha256": "439b55276d8e6dd396737fd49d23625c76f4ea152c21655cd0a067fa76252827",
        "bytes": 21972,
        "line_count": 625,
        "classes": {
          "IndexType": 36,
          "VectorEntry": 43,
          "VectorDBInterface": 82,
          "FAISSVectorDB": 133,
          "NumpyVectorDB": 390,
          "VectorEncoder": 533
        },
        "functions": {
          "create_vector_db": 600,
          "to_dict": 53,
          "from_dict": 66,
          "add_vector": 403,
          "add_vectors": 420,
          "search": 428,
          "get_vector": 463,
          "update_vector": 471,
          "delete_vector": 483,
          "exists": 490,
          "size": 494,
          "clear": 498,
          "__init__": 536,
          "_rebuild_index": 322,
          "save": 503,
          "load": 517,
          "encode": 570,
          "encode_batch": 580,
          "encode_with_timeout": 594
        }
      },
      {
        "path": "memory/trg_memory.py",
        "purpose": "TemporalResonanceGraphMemory",
        "sha256": "ba96ad8325c6e2a55bc12eb36ec1e0b1100cb6281e491d98581afd346e8b75f1",
        "bytes": 37877,
        "line_count": 987,
        "classes": {
          "EventExtractionResult": 49,
          "QueryContext": 59,
          "TemporalResonanceGraphMemory": 67
        },
        "functions": {
          "__init__": 70,
          "add_event": 152,
          "query": 234,
          "_extract_event": 309,
          "_simple_extract_event": 368,
          "_create_temporal_links": 387,
          "_create_semantic_links": 421,
          "_async_causal_inference": 462,
          "fast_path_ingestion": 486,
          "slow_path_consolidation": 547,
          "_get_neighborhood": 585,
          "_infer_latent_edges": 610,
          "_create_entity_edges": 643,
          "_infer_causality": 676,
          "_synthesize_narrative": 775,
          "consolidate_narrative_nodes": 830,
          "_create_narrative_node": 860,
          "save": 916,
          "load": 934,
          "get_statistics": 958,
          "_count_node_types": 968,
          "_count_link_types": 975,
          "wait_for_async_tasks": 982
        }
      },
      {
        "path": "memory/temporal_parser.py",
        "purpose": "TemporalParser",
        "sha256": "9ae3b55060c83acebd10da3c91d1d8e2aecc3eeb2fb10595341c6b2606c849ac",
        "bytes": 16040,
        "line_count": 428,
        "classes": {
          "TemporalParser": 16
        },
        "functions": {
          "__init__": 21,
          "parse_session_timestamp": 45,
          "extract_temporal_reference": 90,
          "_extract_weekday_reference": 120,
          "_extract_absolute_date": 160,
          "extract_all_dates": 206,
          "describe_references": 247,
          "normalize_date_format": 315,
          "calculate_duration": 334,
          "is_temporal_question": 371,
          "extract_time_constraints": 391
        }
      },
      {
        "path": "memory/episode_segmenter.py",
        "purpose": "Episode (imported by memory_builder)",
        "sha256": "d02be12205a42360f449f4790b7b6ad537250ef6361e75862840f6a8483ac58d",
        "bytes": 12058,
        "line_count": 332,
        "classes": {
          "Episode": 15,
          "MessageBuffer": 30,
          "BoundaryDetector": 71,
          "EpisodeSegmenter": 186
        },
        "functions": {
          "__init__": 190,
          "add": 38,
          "size": 55,
          "is_full": 59,
          "clear": 63,
          "get_messages": 67,
          "detect_boundary": 80,
          "_check_explicit_signals": 98,
          "_semantic_boundary_check": 128,
          "process_turn": 205,
          "flush_remaining": 243,
          "finalize": 254,
          "create_episode": 260,
          "_generate_title_and_summary": 297,
          "reset": 329
        }
      },
      {
        "path": "memory/answer_formatter.py",
        "purpose": "AnswerFormatter",
        "sha256": "6fefa322f79deee8332f6fe05d7ffa0176515d175c99492c6b16497e31a7cfad",
        "bytes": 39752,
        "line_count": 985,
        "classes": {
          "AnswerFormatter": 16
        },
        "functions": {
          "__init__": 21,
          "extract_answer": 53,
          "_extract_from_malformed_json": 84,
          "_extract_from_json": 195,
          "_normalize_answer": 284,
          "_is_not_found": 312,
          "_remove_prefixes": 325,
          "_normalize_date": 342,
          "_normalize_duration": 370,
          "_normalize_identity": 404,
          "_normalize_name": 444,
          "_general_normalization": 473,
          "build_qa_prompt": 499,
          "_get_original_text": 664,
          "_get_semantic_enrichment": 699,
          "validate_adversarial_answer": 736,
          "format_context_for_qa": 802,
          "validate_answer": 957
        }
      },
      {
        "path": "memory/jev_client.py",
        "purpose": "JevClient, ProbabilityResult (inspected; carrier substituted)",
        "sha256": "6e72ec6305ffb70931f5d9d18840001e1eaa1dd74b4f0d26c83bb837652149ea",
        "bytes": 11958,
        "line_count": 271,
        "classes": {
          "JevUnavailable": 32,
          "CallBudget": 37,
          "ProbabilityResult": 54,
          "DecisionLog": 63,
          "JevClient": 79
        },
        "functions": {
          "remaining_seconds": 44,
          "consume": 47,
          "__init__": 80,
          "emit": 68,
          "_get_sdk": 92,
          "close": 102,
          "__enter__": 108,
          "__exit__": 111,
          "probabilities": 114,
          "evaluate": 121,
          "_question_payload": 198,
          "_probability": 213,
          "_validate": 219,
          "_retry_after": 244,
          "_log": 260,
          "_failure": 265
        }
      }
    ],
    "executed": [
      {
        "path": "memory/memory_builder.py",
        "symbols": "MemoryBuilder.build, MemoryBuilder.consolidate"
      },
      {
        "path": "memory/jev_mem_policies.py",
        "symbols": "WritePolicy, find_candidates, node_state"
      },
      {
        "path": "memory/jev_mem_config.py",
        "symbols": "JevMemConfig"
      },
      {
        "path": "memory/keyword_enrichment.py",
        "symbols": "KeywordEnricher"
      },
      {
        "path": "memory/jev_questions.py",
        "symbols": "Noul/Choice question definitions"
      },
      {
        "path": "memory/mock_encoder.py",
        "symbols": "MockEncoder"
      },
      {
        "path": "memory/graph_db.py",
        "symbols": "EventNode, Link, LinkType, NodeType, NetworkXGraphDB"
      },
      {
        "path": "memory/vector_db.py",
        "symbols": "NumpyVectorDB"
      },
      {
        "path": "memory/trg_memory.py",
        "symbols": "TemporalResonanceGraphMemory"
      },
      {
        "path": "memory/temporal_parser.py",
        "symbols": "TemporalParser"
      },
      {
        "path": "memory/episode_segmenter.py",
        "symbols": "Episode (imported by memory_builder)"
      },
      {
        "path": "memory/answer_formatter.py",
        "symbols": "AnswerFormatter"
      }
    ],
    "substituted": [
      {
        "boundary": "typesafe_sdk carrier",
        "replaces": "typesafe_sdk Noul / Choice / ChoiceAnswer / error classes",
        "why": "The SDK is not installed and must not be installed; the model step is scripted. Question payloads still come from the real jev_questions.py."
      },
      {
        "boundary": "system-one controller",
        "replaces": "JevClient.probabilities / JevClient.evaluate live path",
        "why": "No online model, network or credentials. Scripted answers carry the same Noul float / ChoiceAnswer shape the real jev_mock path produces."
      },
      {
        "boundary": "deterministic node labels in the receipt",
        "replaces": "the runtime uuid4 node ids inside the receipt only",
        "why": "Upstream EventNode keeps its real uuid4 ids end-to-end; the runner maps each runtime id to n1, n2 ... in creation order and reports those labels. The mapping is applied to the snapshot output, never to the executed source, so no upstream behaviour depends on it."
      },
      {
        "boundary": "LLM layer",
        "replaces": "utils.memory_layer.LLMController",
        "why": "memory_builder / trg_memory import it at module scope; it is never used because llm_enabled=False; its constructor raises if reached."
      },
      {
        "boundary": "summary generation",
        "replaces": "System-Two summarizer",
        "why": "The callback joins the two source strings and records its inputs; it does not call a model."
      }
    ]
  },
  "method": {
    "purpose": "Source-bound characterization of Jev-Mem's write/admission and consolidation decisions; the model step is scripted, not executed.",
    "controller": {
      "note": "Scripted numeric defaults are 0.9 except listed zero-default control; coverage-token questions default to zero; per-case overrides take precedence. Choice uses the stated selection probability. These are supplied values, not model predictions.",
      "coverage_tokens": [
        "redundancy",
        "contradiction",
        "obsolete",
        "causes",
        "caused_by",
        "before",
        "after",
        "overlaps",
        "same_episode",
        "temporal_order",
        "entity"
      ],
      "default_value": 0.9
    },
    "determinism": "Real UUIDs remain in upstream execution. Receipt-only labels n1, n2 ... follow build order and replace all node references, including persisted decisions and summary provenance. Link UUIDs and internal dedup hashes are omitted; typed endpoints and relations are retained. Fixture timestamps are fixed; a generated summary has no supplied timestamp.",
    "minimum_runtime": "numpy, networkx, tqdm (upstream's declared deps). No typesafe-sdk, faiss or sentence-transformers needed."
  },
  "boundary": {
    "is_jev_inference": false,
    "is_embedding_accuracy": false,
    "is_benchmark": false,
    "is_model_forgetting": false,
    "find_candidates_is_semantic_retrieval": false,
    "notes": [
      "A high obsolete probability is a returned judgement about the new/candidate pair, not a deletion.",
      "The encoder is upstream's MockEncoder; candidate selection is not a real semantic-retrieval result.",
      "No scalar in this receipt measures a model's semantic ability."
    ]
  }
}
方法、源码与复跑命令 ↗
来源与实际阅读范围 · 8

Jev-Mem:把记忆控制拆成有界判断

沿着 observation、关系候选、检索反馈与非破坏性维护,定位每个控制判断的执行去处。

§§3.1–3.3、Appendix B;Tables 1–2;固定源码及本站实验

论文结果未复现;源码执行只检验指定判断后的行为,不测试 Jev 预测准确率。

回原文 ↗

AgeMem:判断策略怎样接受反馈

将策略收到的反馈、动作是否完成与结果是否正确分开,避免把一个反馈分数当成完整管理能力。

AMS 既有精读与 reward observation audit;本轮未重读全文

AgeMem 的训练机制不等于调用固定 Jev 接口;本站 reward audit 也不证明真正 mutation。

回原文 ↗

Experience reuse:有记录,为什么仍读不到

候选池和排序会限制后续 controller 能看见什么;新增经历可能挤占旧证据。

AMS 既有检索竞争研究,4 场景、108 次 SQLite BM25 选择

BM25 教学实验不是 Jev-Mem 真实候选或语义检索评价。

回原文 ↗

Memora:回忆与遗忘各自怎样验收

把需要保留的历史与需要撤回的当前作用分开,追踪变化是否传到实际使用位置。

AMS 既有 Memora 精读与 forgetting contract audit

不同实现拥有不同 contract;不能用 Memora 的结果代替 Jev-Mem 的证据。

回原文 ↗

官方模型文档

TypeSafe · Jev 接口与模型边界

固定模型通过 state、Choice / Score / Noul 给出有界输出;修改上下文与 criteria 不等于客户参数训练。

Models / Customizing Jev / Language support;并读 Introduction、Confidence 与 Noul;2026-09-22

接口保证不等于目标任务正确率;官方说明英语最好,中英混合 memory 负载尚需评价。

官方接口语义说明

TypeSafe · Noul 与 confidence 怎样读

命题成立的估计、价值大小和预测正确率是不同量;阈值需要目标侧评价。

Reading a Noul;并读 https://docs.typesafe.ai/confidence;2026-09-22

没有测量这些输出在本专题任务上的校准误差,不能把示例概率直接转成成功率。

官方模型限制说明

Jev 1.13 · 官方已知弱项

时间和一致性等 memory 要求仍需明确的执行规则与针对性评价。

日期比较、间接推理、噪声上下文与 adversarial input;2026-09-22

官方举例不是本专题运行结果;不能据此推算本场景错误率。

官方开源实现

Jev-Mem · 固定实现与评价说明

复跑前先区分 active profile、单答案设置、fallback、停止原因和不同计时字段。

commit 81574eb;同时检查 config、builder、policies、retrieval、client 与 harness

当前代码未与论文运行版本绑定;mock controller 也不会自动关闭 answerer / judge 的真实调用。

留下的理解

给判断一个可观察的去处

本次高低 obsolete 对照都保留了原记录与向量成员。想让过时信息退出当前使用范围,需要指明哪个对象和哪条读取路径发生变化。

保留原文,也检查当前适用性

历史证据与当前选择可以有不同角色。观察派生摘要、旧节点及其来源关系,不把新增 summary 当成清除了旧记录。

再做真正的 controller 比较

冻结候选、图、answerer 和预算,分别比较规则、通用模型 typed output 与 Jev;同时测判断、执行和答案。这个实验尚未运行。

这里扩展的“记忆”包含经验如何被管理和投入使用。结构化语义判断提供一个可组合的部件;它的价值要由实际执行与后续任务继续回答。

继续追问

问题
经验怎样长成判断习惯?

同一批经验保留为案例、规则或参数时,怎样改变未见情境中的选择;反馈被纠正之后,这种改变又怎样更新?

持续研究 · 当前判断可修订

带走这份公开研究

Markdown ↓JSON ↓

含当前正文、出处、阅读范围与接续线索;链接的全文不随包附带。

已打开共读 · 已保存研究结果:谁在管理记忆?快判断、慢推理与旧信息的退场。Admission 关闭:类型分数全零仍写入,调用前,显示保存的源码执行结果。