Dev & Engineering semantic-memorytemporal-knowledge-graphvector-retrievalentity-trackingmemory-consolidationbenchmark-evaluation

Persistent Semantic Memory Design

Design durable, retrievable agent memory that scales from simple files to temporal knowledge graphs.

FollowSkills review · FSRS-2.0
Not recommended
53/ 100 5-point scale 2.7 / 5
Trust16 / 25 · 3.2/5

The skill explicitly recommends privacy consideration, retention policies, deletion rights, session scoping, and non-blocking storage-failure handling. However, it does not define least privilege, user confirmation, sensitive-data classes, encryption, access control, data-flow disclosure, or rollback for persisted data, so 9 points are deducted. No malicious behavior or obvious overreach is shown.

Reliability6 / 20 · 1.5/5

The document is internally organized and covers empty retrieval, stale results, conflicting facts, and storage failures, with an accompanying implementation script. However, consolidation is unimplemented, dependencies are not pinned, hash-based pseudo-embeddings are not stable across processes, and the script's text-field behavior differs from some examples and reference code. Because this is static review with no skill-specific tests, the score is conservatively capped at 6, deducting for reproducibility and incomplete failure diagnostics.

Adaptability11 / 15 · 3.7/5

Activation scenarios, intended use, and boundaries with filesystem-context, context-compression, and context-optimization are clearly stated, covering file, vector, graph, and temporal memory. It lacks sufficiently explicit non-fit ranges, input/output contracts, platform requirements, Chinese-language support, and mainland-China network reachability, so 4 points are deducted.

Convention10 / 15 · 3.3/5

The skill uses progressive structure with frontmatter, activation criteria, layered concepts, practical guidance, examples, error recovery, integration notes, and references. The repository supplies an MIT license, version, creation/update dates, and author information. It lacks a clear maintenance owner, update procedure, changelog, dependency-installation guidance, FAQ, and a fully demonstrated path for validating internal references, so 5 points are deducted.

Effectiveness6 / 15 · 2.0/5

The skill provides directly usable architecture-selection, retrieval, temporal-modeling, and recovery guidance, plus Python examples and an integration script, so it plausibly completes the core design task. However, the examples use pseudo-embeddings, consolidation is a no-op in the integrated implementation, several components are explicitly demonstrative, and representative outputs or comparative benefits are not verified. Under the static cap, it receives 6, with deductions for limited production readiness and evidence.

Verifiability4 / 10 · 2.0/5

The repository includes reference lists, claimed benchmarks, router regression materials, and CI, but the supplied CI primarily validates researcher tooling and other examples rather than the memory-systems key paths. Benchmark figures and external papers are not supplied with reproducible result artifacts in this material. This supports limited auditability but not independent reproduction, so 4 points are awarded with deductions for thin cross-validation and skill-level test coverage.

Evidence confidence:Low Reviewed Jul 20, 2026 Reviewed revision c578e85e40fe
Before you use it
  • Do not treat scripts/memory_store.py as production persistence: it uses pseudo-embeddings and in-memory structures, leaves consolidate() empty, and provides no deletion, access control, encryption, or rollback mechanism.
  • Treat benchmark figures and framework capabilities as leads requiring revalidation; the supplied material lacks independent results for this skill's key paths.
  • Before persisting user memories, add consent, data classification, tenant isolation, retention, deletion-rights, and conflict-audit policies.
  • Pin Python and third-party dependency versions before deployment, and verify the frameworks' actual APIs, cloud restrictions, and mainland-China reachability.
See the full review method →

What does this skill do, and when should you use it?

This skill is for agent systems that must retain knowledge across sessions, track entities, and reason over accumulated information. It guides teams from filesystem-backed memory toward vector stores, graph memory, and temporal knowledge graphs based on retrieval needs. It covers framework selection, retrieval strategies, consolidation, stale or conflicting facts, and benchmark choice. It is an architectural guide with examples, not a standalone memory runtime.

Compares Mem0, Zep/Graphiti, Letta, Cognee, LangMem, and filesystem memory by retrieval pattern and trade-off; maps working, short-term, long-term, entity, and temporal-KG layers to implementation choices; explains semantic, entity-based, temporal, and hybrid retrieval; recommends consolidation and recovery handling for empty, stale, conflicting, or failed memory operations; identifies LoCoMo, LongMemEval, and DMR as evaluation options; and provides Python examples for Mem0, temporal queries, and Cognee ingestion and search.

  1. An agent engineer is building cross-session memory for user preferences, domain knowledge, or entity identity.
  2. A production team needs to decide when to move from files to vector or graph-backed memory.
  3. A system must represent changing facts, validity intervals, or historical states.
  4. An architecture team is comparing Mem0, Zep/Graphiti, Letta, Cognee, and LangMem.
  5. An evaluation team needs to measure long-conversation retention and retrieval quality with published benchmarks.

What are this skill's strengths and limitations?

Pros
  • Offers a clear escalation path from filesystem memory to temporal knowledge graphs.
  • Covers selection, retrieval, consolidation, conflict handling, and failure recovery.
  • Treats benchmark results as dated, source-specific signals rather than absolute rankings.
  • Includes concrete Mem0, temporal-query, and Cognee examples.
Limitations
  • Does not provide a standalone executable implementation or complete installation guide.
  • Framework and benchmark claims should be rechecked before product decisions.
  • No skill-specific test suite or platform validation is shown.
  • Graph and advanced memory frameworks add infrastructure and operational complexity.

How do you install this skill?

Copy the complete skills/memory-systems directory into the host's Agent Skills directory. For a Codex project, for example: mkdir -p .codex/skills && cp -R skills/memory-systems .codex/skills/. Preserve the directory layout rather than flattening SKILL.md; the repository also documents installation as a Claude Code plugin marketplace containing the collection.

How do you use this skill?

Use it in an Agent Skills-compatible host with a request such as: “Design cross-session memory for an agent that tracks changing user preferences, and compare filesystem memory, Mem0, and Zep/Graphiti.” It is intended to activate for persistent semantic memory, entity tracking, temporal validity, retrieval design, consolidation, and memory benchmarking. Complete runtime integration and dependency-installation instructions are not provided by this skill.

How does this skill compare with similar options?

The skill explicitly compares Mem0, Zep/Graphiti, Letta, Cognee, LangMem, and filesystem memory. Its central recommendation is to start with the shallowest viable layer and add structure only when retrieval quality or reasoning requirements justify it: filesystem memory for simple agents and prototypes, Mem0 for fast production adoption, Zep/Graphiti for temporal and relationship modeling, Letta for deep introspection, and Cognee for dense customizable semantic graphs.

FAQ

Does this skill automatically store or retrieve memories?
No. It provides architecture guidance, framework comparisons, recovery patterns, and examples; it is not a memory service by itself.
Should every new agent start with a temporal knowledge graph?
No. The guidance recommends timestamped filesystem memory first, then escalation when retrieval quality, relationship traversal, temporal validity, or multi-hop reasoning requires it.
How should stale or conflicting facts be handled?
Track validity periods, prefer the most recently valid fact, consolidate periodically, preserve history for temporal queries, and surface low-confidence contradictions.

More skills from this repository

All from muratcankoylan/Agent-Skills-for-Context-Engineering

Dev & Engineering

Context Compression Strategies

Compress long-running agent sessions while preserving files, decisions, risks, and next actions.

Dev & Engineering

Context Engineering for Production Agents

A structured guide to designing, optimizing, and evaluating production agent systems with reliable context management.

Productivity & Collaboration

Digital Brain Personal OS

Manage content, relationships, knowledge, and goals through structured files and AI.

Dev & Engineering

Long-Horizon Prompting

Designs auditable launch briefs for autonomous agents and parallel multi-agent work on difficult, long-running tasks.

Dev & Engineering

Advanced LLM Evaluation

Build auditable, calibrated LLM-output evaluations with explicit rubrics, confidence scoring, and bias controls.

Dev & Engineering

Context Degradation Diagnosis

Identify and mitigate lost attention, poisoning, distraction, confusion, and conflict in long agent contexts.

Dev & Engineering

Agent Tool Design Guide

Design tool interfaces agents can route, call, and recover from reliably.

Dev & Engineering

Autonomous Agent Harness

Designs autonomous agent loops that remain controlled, recoverable, and auditable.

Dev & Engineering

Agent Evaluation Methods

Build repeatable evaluation, regression detection, and quality gates for agent pipelines.

Dev & Engineering

Filesystem Context Engineering

Move large, durable, or shared agent context into files and retrieve it selectively when needed.

Dev & Engineering

Context Efficiency Optimizer

Reduce context cost with caching, masking, compaction, and partitioning while preserving answer quality.

Dev & Engineering

Self-Improvement Loops

Evolve agent harnesses, workflows, and context mechanisms under bounded, evidence-based evaluation.

Dev & Engineering

Context Engineering Fundamentals

Understand and shape reliable agent context through attention budgets, context-window mechanics, and signal-density principles.

Dev & Engineering

Latent Briefing

Share task-relevant orchestrator state with workers through task-guided KV-cache compaction when the inference runtime is controllable.

Dev & Engineering

Multi-Agent Architecture Patterns

Design multi-agent systems with context isolation, explicit handoffs, coordinated execution, and controlled failure handling.

Dev & Engineering

Project Development Methodology

Decide whether an LLM fits the job, then design a staged agent pipeline with predictable parsing, iteration, and cost control.

Dev & Engineering

BDI Mental State Modeling

Turn RDF context into explainable belief, desire, and intention chains.

Dev & Engineering

Rigorous Research Agent

A validation, recovery, and source-tracking protocol for multi-step research.

Dev & Engineering

Agent Skill Blueprint

A reusable structure for authoring well-scoped context-engineering skills.

Dev & Engineering

Reasoning Trace Optimizer

Diagnose context, tool, and instruction failures by analyzing agent traces and iteratively improving prompts.

Related skills