← Back to Blog

6 Memory Types Your AI Agent Needs (And How to Use Each)

March 24, 2026 < 10 min read

Not all memories are created equal. When a user tells your AI agent "I'm a Python developer in Austin who has a meeting with Sarah at 3pm and prefers dark mode," that single sentence contains four completely different types of information — each with different storage needs, retrieval patterns, and expiration rules.

Most agent memory systems treat everything as flat text. Store it, embed it, retrieve by similarity. This works for simple use cases, but it falls apart at scale. A meeting time from last Tuesday shouldn't have the same retrieval weight as a core language preference. A relationship between two people shouldn't be stored the same way as a step-by-step workflow.

After working with hundreds of developers building AI agents, we've identified six distinct memory types that cover virtually every use case. Understanding them — and using the right type for the right information — is the difference between an agent that kinda remembers and one that truly understands.

The Six Memory Types

Storing Each Type: Code Examples

Here's how to store each memory type using the 0Latency API, with type-specific metadata that optimizes retrieval.

Facts

# Python — Storing a fact
import requests

HEADERS = {"X-API-Key": your_api_key, "Content-Type": "application/json"}

requests.post("https://api.0latency.ai/memories/extract", headers=HEADERS, json={
    "agent_id": "assistant",
    "content": "User is a senior Python developer with 8 years of experience",
    "metadata": {
        "type": "fact",
        "confidence": 0.95,     # Explicitly stated by user
        "category": "professional",
        "entities": ["user", "Python"]
    }
})

Preferences

// JavaScript — Storing a preference
await fetch('https://api.0latency.ai/memories/extract', {
  method: 'POST',
  headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    agent_id: 'assistant',
    content: 'User prefers TypeScript over JavaScript for new projects',
    metadata: {
      type: 'preference',
      category: 'language',
      strength: 'strong',         // strong | mild | inferred
      supersedes: 'JavaScript'    // What this preference replaces
    }
  })
});

Events

# Python — Storing an event
requests.post("https://api.0latency.ai/memories/extract", headers=HEADERS, json={
    "agent_id": "assistant",
    "content": "Team standup meeting every Monday and Wednesday at 10am PST",
    "metadata": {
        "type": "event",
        "recurring": True,
        "schedule": "Mon,Wed 10:00 PST",
        "participants": ["user", "Sarah", "Alex"],
        "expires": None  # Recurring — no expiration
    }
})

Relationships

// JavaScript — Storing a relationship
await fetch('https://api.0latency.ai/memories/extract', {
  method: 'POST',
  headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    agent_id: 'assistant',
    content: 'Sarah is the engineering team lead and manages Alex and Jordan',
    metadata: {
      type: 'relationship',
      entities: ['Sarah', 'Alex', 'Jordan'],
      relationships: [
        { from: 'Sarah', to: 'Alex', relation: 'manages' },
        { from: 'Sarah', to: 'Jordan', relation: 'manages' },
        { from: 'Sarah', to: 'engineering', relation: 'leads' }
      ]
    }
  })
});

Procedures

# Python — Storing a procedure
requests.post("https://api.0latency.ai/memories/extract", headers=HEADERS, json={
    "agent_id": "assistant",
    "content": "Deployment process: 1) Push to main branch, 2) Wait for CI green, 3) Create release tag, 4) Approve staging deploy, 5) Run smoke tests, 6) Promote to production",
    "metadata": {
        "type": "procedure",
        "name": "production_deployment",
        "steps": 6,
        "category": "devops",
        "retrieve_as": "complete"  # Always return full sequence
    }
})

Emotional Context

// JavaScript — Storing emotional context
await fetch('https://api.0latency.ai/memories/extract', {
  method: 'POST',
  headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    agent_id: 'assistant',
    content: 'User expressed frustration about repeated CI failures on the billing service',
    metadata: {
      type: 'emotional',
      sentiment: 'frustrated',
      intensity: 0.7,           // 0-1 scale
      topic: 'CI/billing',
      decay: 'fast'             // Emotional context fades quickly
    }
  })
});

Retrieval Optimizations by Type

Storing with types is only half the benefit. The real power comes from type-aware retrieval:

• Facts: Retrieved by entity match and semantic similarity. Highest confidence wins.
• Preferences: Retrieved by category, weighted by recency. Most recent preference for a given category always surfaces first.
• Events: Retrieved by temporal proximity. "What's happening today?" only surfaces events within the relevant time window.
• Relationships: Retrieved by graph traversal. "Who works with Sarah?" follows relationship edges, not just text similarity.
• Procedures: Retrieved as complete units. You never want step 3 of 6 without the rest.
• Emotional: Retrieved with decay weighting. Last week's frustration is less relevant than today's excitement.

# Python — Type-filtered recall
response = requests.post("https://api.0latency.ai/recall", headers=HEADERS, json={
    "query": "What does the user prefer for new projects?",
    "agent_id": "assistant",
    "filters": {
        "types": ["preference", "fact"],  # Only retrieve preferences and facts
        "recency_weight": 0.8             # Heavily weight recent memories
    }
})

for mem in response.json()["memories"]:
    print(f"[{mem['metadata']['type']}] {mem['content']} (score: {mem['score']:.2f})")

Why Typing Matters at Scale

With 100 memories, flat storage works fine. With 100,000, it becomes a problem. Here's why:

• Retrieval noise drops dramatically. A query about user preferences doesn't need to search through events and procedures. Type filtering reduces the search space by 60-80% in typical workloads.
• Expiration becomes automatic. Events from last month can be archived. Emotional context from last week can decay. Facts persist. Each type has natural lifecycle rules.
• Contradiction detection improves. Two facts can contradict each other. A fact and an event can't. Type awareness eliminates false-positive contradiction alerts.
• Context windows stay clean. When building prompts, you can pull the right mix: current preferences, relevant facts, recent events — without wasting tokens on low-relevance memories.

0Latency supports all six memory types natively. Our entity extraction engine can automatically classify memories by type when you don't specify one, and our retrieval system uses type-aware scoring to surface the most relevant memories for any query. See our pricing page for plan details — the Free tier includes 10,000 memories with full type support.

Getting Started

You don't need to implement all six types at once. Start with the most impactful ones for your use case:

1. Customer support agents: Start with Facts + Preferences + Emotional Context.
2. Coding assistants: Start with Facts + Preferences + Procedures.
3. Personal assistants: Start with Events + Relationships + Preferences.
4. Multi-agent systems: Start with Facts + Relationships + Procedures.

Add more types as your agent matures. The beauty of a typed memory system is that it grows with your application — each new type adds a dimension of understanding without disrupting what's already working.