Agent Memory Designer

Purpose

Design agent memory architecture: what to remember, where to store it, how to retrieve it, and when to forget — with privacy and cost controls.

Input: Agent use case, session patterns, data sensitivity, latency/cost budget
Output: Memory Architecture document with tiers, schemas, retrieval flows, and hygiene rules
Examples: See examples.md for worked input/output.

Workflow

Step 1: Classify memory needs

Map each user story to required memory types.

Step 2: Choose storage tiers

Document read/write latency and cost per tier.

Step 3: Design write path

Define what gets written after each agent turn:

• Extract — entities, decisions, user corrections, task outcomes
• Summarize — compress verbose turns into durable facts
• Dedupe — merge with existing memories (same key → update, not duplicate)
• Score — importance / confidence before persistence

Include triggers: user correction always writes; routine chit-chat may not.

Step 4: Design read path (recall)

Query → Intent classifier → Retrieve from tiers → Rank → Budget trim → Inject into context

Set top-k, similarity threshold, and max tokens injected.

Step 5: Define hygiene and governance

Step 6: Validate

Run Validation checklist.

Decision Rules

Validation

• Memory types mapped to user stories
• Storage tier per type with TTL documented
• Write path: extract, summarize, dedupe rules defined
• Read path: retrieval strategy and token budget set
• PII and secrets exclusion enforced at write
• User deletion and retention policies specified
• Cost estimate per 1k sessions (storage + embedding + recall)
• Failure mode: empty recall falls back gracefully

Anti-patterns

• Remember everything — unbounded logs inflate cost and inject noise.
• Vector-only memory — losing structured keys makes profile lookup unreliable.
• No TTL — stale facts poison agent behavior months later.
• Recall without ranking — dumping top-20 chunks floods context.
• Cross-user leakage — missing tenant isolation in shared vector index.

Best Practices

• Start with session + explicit user profile; add episodic memory when needed.
• Store memories as atomic facts with source turn ID and timestamp.
• Run memory hygiene audits monthly; prune low-relevance episodic entries.
• Pair with context-engineering for assembly order and budget.
• Log recall hits/misses for tuning thresholds.

Output Structure

# Memory Architecture: [Agent Name]

## Requirements
| Story | Memory types needed |
|-------|---------------------|

## Storage Tiers
| Type | Store | TTL | Est. cost |
|------|-------|-----|-----------|

## Write Pipeline
[Extract → Summarize → Dedupe → Persist]

## Read Pipeline
[Query → Retrieve → Rank → Inject]

## Schemas
[Memory record JSON examples]

## Hygiene Policies
| Policy | Rule |
|--------|------|

## Security
[PII, encryption, tenant isolation]

Next Skills