home / skills / sickn33 / antigravity-awesome-skills / agent-memory-systems

agent-memory-systems skill

/skills/agent-memory-systems

This skill helps you design and optimize memory systems for agents, emphasizing retrieval, chunking, and embedding to prevent forgetfulness.

This is most likely a fork of the agent-memory-systems skill from xfstudio
npx playbooks add skill sickn33/antigravity-awesome-skills --skill agent-memory-systems

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.3 KB
---
name: agent-memory-systems
description: "Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-term (context window), long-term (vector stores), and the cognitive architectures that organize them.  Key insight: Memory isn't just storage - it's retrieval. A million stored facts mean nothing if you can't find the right one. Chunking, embedding, and retrieval strategies determine whether your agent remembers or forgets.  The field is fragm"
source: vibeship-spawner-skills (Apache 2.0)
---

# Agent Memory Systems

You are a cognitive architect who understands that memory makes agents intelligent.
You've built memory systems for agents handling millions of interactions. You know
that the hard part isn't storing - it's retrieving the right memory at the right time.

Your core insight: Memory failures look like intelligence failures. When an agent
"forgets" or gives inconsistent answers, it's almost always a retrieval problem,
not a storage problem. You obsess over chunking strategies, embedding quality,
and

## Capabilities

- agent-memory
- long-term-memory
- short-term-memory
- working-memory
- episodic-memory
- semantic-memory
- procedural-memory
- memory-retrieval
- memory-formation
- memory-decay

## Patterns

### Memory Type Architecture

Choosing the right memory type for different information

### Vector Store Selection Pattern

Choosing the right vector database for your use case

### Chunking Strategy Pattern

Breaking documents into retrievable chunks

## Anti-Patterns

### ❌ Store Everything Forever

### ❌ Chunk Without Testing Retrieval

### ❌ Single Memory Type for All Data

## ⚠️ Sharp Edges

| Issue | Severity | Solution |
|-------|----------|----------|
| Issue | critical | ## Contextual Chunking (Anthropic's approach) |
| Issue | high | ## Test different sizes |
| Issue | high | ## Always filter by metadata first |
| Issue | high | ## Add temporal scoring |
| Issue | medium | ## Detect conflicts on storage |
| Issue | medium | ## Budget tokens for different memory types |
| Issue | medium | ## Track embedding model in metadata |

## Related Skills

Works well with: `autonomous-agents`, `multi-agent-orchestration`, `llm-architect`, `agent-tool-builder`

Overview

This skill explains how to design and operate agent memory systems that make agents reliably intelligent. It covers short-term context windows, long-term vector stores, and cognitive architectures that bind them so agents retrieve the right information at the right time. The focus is on practical retrieval-first strategies: chunking, embeddings, indexing, and decay policies.

How this skill works

The skill inspects memory needs across types (working, episodic, semantic, procedural) and maps them to storage and retrieval patterns. It prescribes chunking rules, embedding model choices, vector store selection criteria, and retrieval pipelines that include metadata filters, temporal scoring, and conflict detection. It emphasizes testing retrieval quality, not just storage volume, and provides heuristics for budget-aware memory management.

When to use it

  • Designing an agent that must recall past interactions accurately over long sessions
  • Building a hybrid system combining short-term context and long-term knowledge
  • Evaluating candidate vector databases and embedding models for production
  • Optimizing retrieval latency and relevance under token/budget constraints
  • Implementing decay, consolidation, or override policies for dynamic memories

Best practices

  • Always design retrieval tests alongside chunking experiments before committing to a storage format
  • Filter by metadata first (user, session, topic) to reduce false positives before similarity scoring
  • Use temporal scoring and recency boosts for time-sensitive memories
  • Track embedding model, vector dims, and version in metadata to enable re-indexing
  • Avoid storing everything forever—implement pruning and consolidation policies
  • Measure retrieval precision and recall with representative queries and update chunk sizes accordingly

Example use cases

  • Customer support agent that recalls prior tickets, resolutions, and user preferences across months
  • Coding assistant that retrieves relevant project files, past code reviews, and design decisions
  • Personal assistant that maintains a short-term dialog context and a long-term profile of user habits
  • Research agent that indexes papers with chunked abstracts and semantic summaries for fast retrieval
  • Multi-agent orchestration where agents share and shard memories with access controls

FAQ

How do I choose a vector store?

Match requirements: latency, scale, pricing, feature set (filters, namespaces, hybrid search) and integration SDKs. Benchmark with typical payloads and query patterns.

What chunk size should I use?

Start with 200–1,000 tokens, test retrieval effectiveness, and tune by document type; use overlapping windows for context continuity.