# Agent Memory Corruption

## The Problem

Agent's conversational memory becomes corrupted or inconsistent, causing it to forget context, hallucinate past interactions, or contradict itself.

### Symptoms

* ❌ Agent forgets previous conversation
* ❌ Refers to things never discussed
* ❌ Contradicts earlier statements
* ❌ Context window overflow corrupts memory
* ❌ Memory persists incorrectly across sessions

### Real-World Example

```
Turn 1:
User: "I'm working on Project Phoenix"
Agent: "Great! Project Phoenix is your team's OAuth integration."

Turn 2 (5 turns later):
User: "What was I working on?"
Agent: "I don't have information about your current project."

Memory lost - Agent forgot "Project Phoenix"

Or worse:
Agent: "You mentioned Project Apollo earlier"
→ Hallucination - user never mentioned Apollo
→ Memory corruption
```

***

## Deep Technical Analysis

### Memory Storage Issues

**Context Window Overflow:**

```
8K context window:
→ Conversation history: 6,000 tokens (growing)
→ System prompt: 500 tokens
→ Current query + response: 2,000 tokens
→ Total: 8,500 tokens → Overflow!

Result:
→ Oldest turns truncated
→ Agent loses early context
→ Forgets user's initial question
```

**No Explicit Memory:**

```
Stateless API calls:
→ Each request independent
→ No persistent memory

Application must:
→ Track conversation history
→ Pass to each API call
→ Manage truncation

If not implemented:
→ Agent has amnesia
```

### Memory Retrieval Failures

**Semantic Memory Lookup:**

```
Instead of full conversation history:
→ Embed past turns
→ Retrieve relevant past context

Query: "What project am I on?"
→ Retrieve: Turn 1 ("Project Phoenix")
→ Answer: "Project Phoenix"

But if retrieval fails:
→ Relevant turn not retrieved
→ Agent can't answer
```

**Memory Priority:**

```
Recent turns more important:
→ Last 3 turns: Always include
→ Older turns: Retrieve if relevant

Balance:
→ Recency (what just discussed)
→ Relevance (related past context)
```

### Hallucinated Memory

**LLM Confabulation:**

```
User: "What did I say earlier about authentication?"
Agent searches memory: No mention of authentication

But LLM generates:
"You mentioned using OAuth for authentication"
→ Hallucinated memory
→ User never said this

Dangerous: Fabricates past conversation
```

**Cross-Session Leakage:**

```
User A session: Discussed Project Phoenix
User B session: Different user

Agent in User B session:
"As we discussed, Project Phoenix uses OAuth..."
→ Leaked User A's context to User B

Memory isolation failure
```

### Memory Compression

**Summarization:**

```
Long conversation (50 turns):
→ Raw: 15,000 tokens (too large)

Compress:
→ Summarize early turns
→ "User asked about API authentication. Agent explained OAuth flow."
→ Compressed: 30 tokens

Trade-off:
+ Fits in context window
- Loses detail
```

**Selective Retention:**

```
Identify important turns:
→ User provides key info (name, project, role)
→ Agent makes commitments
→ Errors/corrections

Retain these verbatim:
→ Less important turns: Summarize or drop
```

### Memory Validation

**Fact-Checking Memory:**

```
Agent recalls: "You said your rate limit is 500/hour"

Validate:
→ Check conversation history
→ User actually said: "1000/hour"
→ Mismatch detected

Correct:
→ "Apologies, I misremembered. You said 1000/hour."
```

**Memory Consistency:**

```
Track facts mentioned:
→ User's name: Alice
→ User's team: Engineering
→ User's project: Phoenix

If agent later says:
→ "Your project, Apollo..."
→ Contradiction: Phoenix != Apollo
→ Flag: Memory corruption
```

***

## How to Solve

**Implement explicit memory storage (database or vector DB for past turns) + use semantic retrieval for relevant past context + compress old turns via summarization + always include recent 3-5 turns + validate memory recalls against stored history + isolate memory by session/user (no cross-session leakage) + detect memory hallucination (check if recalled info actually exists) + monitor memory consistency (no contradictions) + expire memory after session timeout.** See [Memory Management](/rag-scenarios-and-solutions/agent/memory-corruption.md).


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://help.twig.so/rag-scenarios-and-solutions/agent/memory-corruption.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.