What are the different types of agent memory (short-term, long-term, episodic)?

In this question, we will learn the different types of agent memory: short-term, episodic, and long-term, how they interact, and when to pick one or another for agent behavior.

We will cover the following:

• The intuition
• How it actually works
• Design patterns and architectures
• When to use each
• Tradeoffs and failure modes

Direct answer: Short-term memory holds immediate working state for the current conversation or task, episodic memory logs discrete past experiences with rich context for later retrieval, and long-term memory stores consolidated, compact facts or skills for repeated use. These three play complementary roles: short-term is fast and volatile, episodic is detailed and indexed, and long-term is compact and optimized for frequent reads.

The intuition (an analogy that makes it click)

Think of the agent as a person at a desk. Short-term memory is the open notebook on the desk that contains what you are actively working on. Episodic memory is the photo album with dated stories and context. Long-term memory is the filing cabinet of distilled notes and rules you consult often.

When you need an immediate fact you glance at the notebook. When you need to recall a past event you flip through the album using dates or tags. When you want a general principle you consult the filing cabinet.

How it actually works (the real mechanics, with one concrete worked example)

Short-term memory is implemented as in-session context vectors, working variables, or a short cache. It is optimized for low latency and frequent updates. A simple mathematical model for exponential decay of a short-term trace is:

where $m_t$ is the memory state at time $t$, $x_t$ is the new observation, and $0<\alpha<1$ controls retention.

Episodic memory stores time-stamped structured records such as (state, action, observation, reward, metadata). Retrieval uses indexing and similarity search, for example nearest neighbor on embeddings. Long-term memory holds condensed representations, knowledge graphs, or model parameters learned by continual training.

Concrete example: a customer support agent.

• Short-term: the open ticket text and variables like 'current issue' and 'customer mood'.
• Episodic: a log entry "2026-03-01: billing dispute resolved, refund issued" stored with embedding and tags.
• Long-term: distilled rules such as "refunds under 30 days approved automatically" stored as a rule or a knowledge-base entry.

Comparison table for typical properties:

Design patterns and architectures

There are common patterns to combine memories safely and effectively.

1. Working-context plus episodic recall: keep a compact short-term context and query episodic memory when you detect a retrieval need. For example, on a repeated issue, issue embeddings trigger fetching the matching past ticket.

2. Consolidation pipeline: periodically aggregate short-term traces or repeated episodic entries into long-term summaries. This can run offline using clustering or distillation.

3. Hybrid retrieval: use a two-stage retrieval where a fast approximate lookup yields candidates and a slower re-ranking step returns the best episodic matches.

When designing embeddings or indexes remember to include metadata such as timestamps, user id, and task tags. Retrieval often uses cosine similarity on embeddings or term-based search depending on the content.

When to use each

• Use short-term memory when the agent needs to maintain conversational state, local variables, or ephemeral planning steps within a session.
• Use episodic memory when you want to retain full contextual events for personalized behavior, auditing, or learning from rare events.
• Use long-term memory when you need compact, frequently used facts or models that are inexpensive to query and high-value to store permanently.

A practical rule: if you expect to reuse an experience across sessions and it matters which exact event it was, store it as episodic. If you expect to extract a rule or pattern from many episodes, move it to long-term.

Tradeoffs and failure modes

Memory design forces choices among recall speed, storage cost, and relevance. Short-term memory can be fast but forgetful. Episodic memory can be large and noisy. Long-term memory needs consolidation and can become stale.

Common failure modes:

• Catastrophic forgetting when consolidation overwrites important but infrequent episodes.
• Over-reliance on stale long-term facts leading to incorrect behavior.
• Retrieval-induced hallucination when the agent draws incorrect inferences from loosely related episodic matches.

Questions the interviewer might ask:

Some follow-up questions you might get:

How would you index episodic memory for fast retrieval? Use dense embeddings computed by a trained encoder and an approximate nearest neighbor library like FAISS for speed, combined with metadata filters for time and user.

How do you prevent privacy leaks from memory? Apply redaction and access controls, encrypt memory storage, and limit what is written to episodic memory. Consider differential privacy or summarization before persistence.

When should you consolidate episodes into long-term memory? Consolidate when patterns emerge across many episodes or when a human curator marks an episode as important. Use periodic batch processes to create distilled knowledge.

How do you handle contradictory episodic memories? Keep provenance and timestamps, surface conflicts to the policy that prioritizes more recent or higher-confidence events, or flag for human review.

What retrieval metrics matter? Precision at top-k, recall for relevant episodes, latency, and freshness. Balance precision and recall according to the task.

Some things to note:

• Always include metadata and provenance for episodic entries.
• Design retrieval filters to reduce false positives.

What the interviewer is really testing

They want to see that you understand the roles and tradeoffs between fast volatile state, rich event logs, and consolidated knowledge. They also want practical choices: indexing strategies, consolidation pipelines, and safety controls. Demonstrate you can map requirements to a hybrid memory design that balances latency, capacity, and privacy.