← Back to Blog

Negative Recall: Teaching Your AI What NOT to Remember

March 25, 2026 < 8 min read

Most conversations about AI memory focus on what to remember. But equally important — and far less discussed — is what to forget.

When a user says "Actually, I don't live in San Francisco anymore — I moved to Denver," your agent needs to do more than just store the new fact. It needs to actively suppress the old one. Otherwise, the next time someone asks "Where does this user live?", there's a coin flip between San Francisco and Denver depending on which memory surfaces first.

This is the problem of negative recall: the ability to mark information as retracted, outdated, or wrong — and ensure it doesn't pollute future retrievals.

Why Deletion Isn't Enough

The naive approach is simple: when something changes, delete the old memory. But deletion creates its own problems:

• You lose the audit trail. There's no record that the information was ever known, or that it was corrected. This matters for compliance and debugging.
• Semantic search still matches. If the embedding for "lives in San Francisco" is gone but nothing says "does NOT live in San Francisco," a query about West Coast users might still infer the wrong thing from related memories.
• Race conditions. In systems processing multiple conversations simultaneously, a deletion might not propagate before another process reads the stale data.
• GDPR and compliance. Some regulations require you to demonstrate when data was corrected, not just that it was. Hard-deleting destroys this proof.

Negative recall is a smarter approach. Instead of deleting memories, you suppress them — marking them as invalid while keeping a record of both the original information and the correction.

How Negative Recall Works

At its core, negative recall adds a layer between storage and retrieval. When your agent recalls memories, the system filters out suppressed entries before returning results. But it does this intelligently — not just checking a "deleted" flag, but understanding the semantic relationship between corrections and the memories they invalidate.

The Suppression Flow

1. Correction detected: A new memory is identified as correcting or retracting an existing one.
2. Link created: The new memory is linked to the old one with a "supersedes" relationship.
3. Old memory flagged: The original memory gets a "superseded" status — still stored, but excluded from standard recall.
4. Negative embedding stored: Optionally, a negative signal is stored so that semantic searches actively avoid the retracted information.

# Python — Negative recall with 0Latency
import requests

API_KEY = "your-api-key"
BASE = "https://api.0latency.ai"
HEADERS = {"X-API-Key": API_KEY, "Content-Type": "application/json"}

# Original memory was stored earlier:
# "User lives in San Francisco"

# User corrects their location
response = requests.post(f"{BASE}/memories/extract", headers=HEADERS, json={
    "agent_id": "assistant",
    "content": "User lives in Denver (moved from San Francisco)",
    "metadata": {
        "correction": True,
        "supersedes_query": "User lives in San Francisco",
        "reason": "User corrected their location"
    }
})

result = response.json()
print(f"Stored: {result['memory_id']}")
print(f"Superseded: {result.get('superseded_memories', [])} memories")
# Stored: mem_abc123
# Superseded: ['mem_xyz789'] memories

# Now when you recall, only the current info surfaces
recall = requests.post(f"{BASE}/recall", headers=HEADERS, json={
    "query": "Where does the user live?",
    "agent_id": "assistant"
})

for mem in recall.json()["memories"]:
    print(f"  [{mem['status']}] {mem['content']}")
# [active] User lives in Denver (moved from San Francisco)

JavaScript Example

// JavaScript — Correcting a memory with negative recall
const correct = 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 dark roast coffee, not medium roast',
    metadata: {
      correction: true,
      supersedes_query: 'User prefers medium roast coffee',
      reason: 'User explicitly corrected this preference'
    }
  })
});

const result = await correct.json();
console.log(`Corrected. ${result.superseded_memories.length} old memories suppressed.`);

Five Use Cases for Negative Recall

1. User Corrections

The most common case. A user says something, then corrects themselves — either immediately or in a future conversation. "Actually, my name is spelled with a K, not a C." Without negative recall, both spellings persist and surface randomly.

2. Policy Changes

Your company updates its refund policy from 30 days to 14 days. Every memory the agent has about "30-day refund window" is now wrong. Negative recall lets you invalidate all memories matching a pattern in one operation.

# Python — Bulk suppression for policy changes
response = requests.post(f"{BASE}/memory/suppress", headers=HEADERS, json={
    "agent_id": "support-agent",
    "query": "30-day refund policy",
    "reason": "Policy updated to 14 days effective March 2026",
    "replacement": "Refund policy is 14 days from purchase date"
})

print(f"Suppressed {response.json()['suppressed_count']} memories")
print(f"Replacement memory stored: {response.json()['replacement_id']}")

3. Data Privacy Requests (GDPR/CCPA)

When a user requests data deletion under GDPR's "right to be forgotten," you need to remove their personal information from agent memory. Negative recall provides a clean mechanism: suppress all memories containing the user's personal data while maintaining an audit log that the deletion occurred (without retaining the data itself).

4. Outdated Information

Time-sensitive information naturally becomes stale. Product prices change, team members leave, offices relocate. A memory system that can't handle staleness will confidently provide wrong answers. Negative recall with temporal rules can automatically flag memories older than a configurable threshold for review or suppression.

5. Multi-Agent Conflict Resolution

In systems where multiple agents share a memory store, one agent might learn information that contradicts what another stored. Negative recall provides a clean resolution mechanism: the authoritative source can suppress the conflicting memory without deleting it, maintaining a full history of what was believed and when it was corrected.

Designing for Negative Recall

If you're building an agent that needs to handle corrections gracefully, here are the key principles:

1. Never hard-delete. Always soft-delete or suppress. The history of corrections is valuable context.
2. Make corrections explicit. When storing a correction, include what it replaces and why. This creates a clear audit trail.
3. Use semantic matching, not exact matching. "User lives in SF" and "User's home is San Francisco" are the same memory expressed differently. Your suppression system needs to understand semantic equivalence.
4. Support bulk operations. Policy changes can invalidate hundreds of memories at once. Your system needs to handle this efficiently.
5. Provide escape hatches. Sometimes a suppressed memory needs to be restored. Maybe the correction was itself wrong. Make un-suppression possible.

0Latency handles all of this out of the box. Every memory stored through our API supports correction metadata, automatic supersession, and bulk suppression operations. Suppressed memories are excluded from recall results but remain available for audit queries. And with our Free tier supporting 10,000 memories, you can test the full negative recall workflow without spending a cent.

The Forgetting Curve for AI

Humans forget naturally. It's a feature, not a bug — our brains automatically deprioritize information that's no longer relevant. AI agents don't have this luxury. Every memory persists with equal weight unless you actively manage it.

Negative recall is the artificial equivalent of natural forgetting. It's a controlled, intentional process that keeps your agent's memory clean, current, and trustworthy. Without it, your agent's memory becomes a landfill — everything ever learned, piled together with no distinction between current truth and historical noise.

The best memory systems don't just remember well. They forget well too.

Build agents that handle corrections gracefully. Your users — and your compliance team — will thank you.