memory-architecture

Define layered agent memory responsibilities and cross-layer query routing flows.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/thistleknot/skills --skill memory-architecture-thistleknot
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-architecture
Source: https://github.com/thistleknot/skills/tree/main/memory-architecture
Command: npx skills add https://github.com/thistleknot/skills --skill memory-architecture-thistleknot

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Memory-augmented agents often fail because memory is treated as a single component rather than a layered system; this reference clarifies what each layer should store, how it updates, and how layers connect so the overall architecture has no gaps.

Core Features & Use Cases

  • Canonical layered architecture: Defines a unified stack across implicit, explicit (semantic), agentic episodic, procedural, and working memory layers.
  • Design templates for real scenarios: Provides ready-to-use composition patterns (e.g., RAG-lite, personal assistant memory, procedural autonomous agents, research synthesis pipelines).
  • Cross-layer integration points: Specifies entity anchor flow (semantic ↔ episodic ↔ procedural) and procedure discovery flow (episodic traces → procedural DAGs), plus query routing guidance via cognitive taxonomy.
  • Anti-pattern diagnostics: Highlights common failure modes like vector-only memory, episodic dumps, missing entity anchors, working memory overflow, and lack of decay policies.

Quick Start

Use memory-architecture to choose the correct set of memory layers for your agent, then map which existing skills will implement each layer and connection.

Frequently Asked Questions about memory-architecture

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

FAQPage Schema
Why does my agent memory architecture fail when using a single vector store for retrieval?

Vector-only memory fails because it treats memory as a single component rather than a layered system. A coherent agent memory stack requires distinct semantic, episodic, procedural, and working memory layers with defined cross-layer interfaces to avoid architectural gaps and missing entity anchors.

What is the best way to design a layered memory architecture for a memory-augmented agent?

Designing a layered agent memory architecture involves defining implicit, semantic, episodic, procedural, and working memory responsibilities. You must establish clear cross-layer flows for entity anchoring, procedure discovery, and working-memory routing to connect retrieval and reasoning paths without architectural gaps.

How do I route queries to the correct memory layer in an agentic reasoning system?

Route queries by applying a cognitive taxonomy to map retrieval requests to the correct memory layer. This working-memory routing directs traffic to appropriate semantic, episodic, or procedural paths, ensuring the agentic reasoning system retrieves context from the correct memory architecture layer.

What are common anti-patterns when building a semantic and procedural memory stack?

Common memory architecture anti-patterns include using vector-only storage, performing episodic dumps without entity anchors, causing working memory overflow, and lacking decay policies. These failure modes disrupt cross-layer integration and prevent proper procedure discovery from episodic traces to procedural DAGs.

Do I need separate memory layers for a personal assistant versus an autonomous agent?

Different agent types require different layer compositions. The memory architecture provides design templates for scenarios like personal assistants and procedural autonomous agents, allowing you to select the correct combination of semantic, episodic, procedural, and working memory layers for your specific use case.

How does procedural memory connect to episodic memory traces in an agent architecture?

Procedural memory connects to episodic memory through the procedure discovery flow. This cross-layer integration converts episodic traces into procedural DAGs, allowing the memory-augmented agent to anchor entities and discover repeatable procedures within its memory architecture.