memory-systems

Implements layered memory with temporal knowledge graphs for cross-session entity tracking.

Updated Jan 19, 2026
One-click install
npx skills add https://github.com/illogical/InstructionLibrary --skill memory-systems-illogical
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-systems
Source: https://github.com/illogical/InstructionLibrary/tree/main/skills/memory-systems
Command: npx skills add https://github.com/illogical/InstructionLibrary --skill memory-systems-illogical

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires numpy, and includes scripts (resource) and references (resource) components.

What problem does it solve?

Memory systems provide persistence across sessions and enable reasoning over accumulated knowledge by combining layered memory, graph structures, and time-aware storage. This solves the problem of losing state and inconsistent entity data when agents reset or across conversations.

Core Features & Use Cases

  • Layered memory architecture (working memory, short-term memory, long-term memory) and knowledge graphs for scalable continuity.
  • Temporal memory with validity periods to track changes over time using temporal knowledge graphs.
  • Knowledge graphs and vector stores for structured reasoning and fast retrieval.
  • Entity tracking and cross-session persistence for consistent user experiences.
  • Memory consolidation and privacy-aware retention to control growth and data exposure.
  • Use Case: An AI assistant remembers user preferences across sessions and reasons about past interactions to tailor responses.

Quick Start

Initialize a memory session, store a fact about an entity (e.g., "Customer123 last_seen: 2026-02-08"), then retrieve memories for that entity in the current session.

Frequently Asked Questions about memory-systems

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I persist agent memory across sessions?

To persist agent memory across sessions, you use a layered memory architecture combining working, short-term, and long-term memory layers. This enables entity tracking and continuity by storing facts in vector-based and graph-based stores for later retrieval.

What is temporal memory in a knowledge graph and when do I need it?

Temporal memory in a knowledge graph tracks entity changes over time using validity periods. You need it when agents must reason about past interactions and time-aware knowledge, rather than just storing static facts across conversations.

How do I store and retrieve memories using a knowledge graph for entity tracking?

You store and retrieve memories for specific entities by initializing a session, recording facts like an entity's last seen state, and querying the graph-based store. This ensures consistent entity data and cross-session persistence for tailored responses.

Can I use numpy for vector-based memory stores in an AI assistant?

Yes, you can use numpy to support vector-based memory stores for fast retrieval. The architecture combines these vector stores with knowledge graphs to enable structured reasoning over accumulated knowledge for your AI assistant.

What is the best way to manage memory consolidation and data exposure in agents?

The best way to manage memory consolidation is using privacy-aware retention policies that control data growth and exposure. This prevents unbounded memory expansion while maintaining necessary continuity across conversations.

Why does my agent lose state and have inconsistent entity data across conversations?

Agents lose state and produce inconsistent entity data across conversations when they lack temporal memory and cross-session persistence. Implementing a layered memory architecture with knowledge graphs resolves this by retaining facts and tracking changes over time.