Skip to Content
BlogAgent Memory with LangMem and LangChain Best Practices

Agent Memory with LangMem and LangChain Best Practices

Memory for agents

Agent memory is one of those ideas that sounds simple until you try to ship it.

Most teams start with “let’s save important things.” But useful memory is not about saving everything. It is about deciding:

  • what kind of memory matters,
  • when it should be written,
  • where it should live,
  • and how it should be recalled later without polluting every prompt.

That is where LangMem becomes interesting. It gives you a practical set of memory primitives and tools for LangGraph-style agents, while LangChain’s broader guidance adds the storage and operational discipline that keeps long-term memory from turning into long-term mess.

Why agent memory matters

Without durable memory, an agent is often limited to the current thread. It may keep conversation state for one run, but lose user preferences, successful patterns, and cross-session context as soon as the thread ends.

Good memory changes that.

It lets an agent:

  • remember user preferences across conversations,
  • retrieve relevant facts at the right moment,
  • learn from successful interactions,
  • and gradually improve behavior instead of starting from zero every time.

The important nuance is that not all memory is the same.

The three memory types worth separating

LangMem’s conceptual model makes an important distinction between semantic, episodic, and procedural memory.

Semantic memory

This is the fact layer.

Examples:

  • user preferences,
  • project facts,
  • organization context,
  • recurring domain knowledge.

This is often the first memory teams want, because it directly supports personalization and retrieval.

Episodic memory

This is the experience layer.

Instead of only storing facts, episodic memory captures situations that worked well before: a successful troubleshooting flow, a useful reasoning pattern, or a strong example interaction that can guide future behavior.

This is especially useful when memory should behave like learned few-shot experience rather than like a preference database.

Procedural memory

This is the behavior layer.

Procedural memory is about how the agent should act: style rules, response habits, instruction refinements, and system behavior that improves over time.

In practice, this often shows up as evolving prompt rules or carefully managed instruction files rather than simple semantic facts.

LangMem’s real question: what, when, and where?

One of the most useful ideas in LangMem is that memory design is application-specific.

Before adding memory, ask:

  1. What should the agent learn?
  2. When should those memories be formed?
  3. Where should they be stored so recall actually works?

That framing is better than treating memory as a generic “save note” feature, because it forces you to connect memory design to the actual agent workflow.

Profiles vs collections

LangMem draws a helpful line between profiles and collections.

Profiles

Profiles are best when you want the current state in a structured form.

Examples:

  • preferred name,
  • response style,
  • role,
  • settings,
  • active goals.

Profiles are ideal when the latest state matters more than historical accumulation. They are easier to validate, easier to edit, and easier to present back to users.

Collections

Collections are better when memory should grow over time.

Examples:

  • facts gathered over many sessions,
  • accumulated context about a project,
  • episodic examples,
  • notes that should be searched only when relevant.

The trade-off is that collections need stronger consolidation rules. If you over-extract, recall quality drops. If you under-extract, useful context never comes back.

That is why LangMem’s memory-management approach is not only about insertion. It is also about updating, consolidating, and invalidating stale memories.

Hot-path memory vs background memory

This is probably the most practical LangMem distinction.

Hot-path memory

Hot-path memory is the “conscious” path.

The agent actively decides to use memory tools such as create_manage_memory_tool and create_search_memory_tool during the conversation itself.

Use this when:

  • a fact is immediately important,
  • the agent should decide what to save,
  • retrieval needs to happen during the current task,
  • and a little extra latency is acceptable.

This pattern is direct and easy to reason about, but it adds decision overhead during the live interaction.

Background memory

Background memory is the “subconscious” path.

Here, memory extraction happens after or between interactions using patterns like create_memory_store_manager. The agent keeps responding normally while a separate memory process reflects on the conversation, extracts useful information, and consolidates it later.

Use this when:

  • recall quality matters more than immediate write speed,
  • you want better consolidation,
  • you do not want memory writes to slow the main response path,
  • and you expect repeated interactions where delayed learning is acceptable.

In practice, this is a strong default for many systems: use hot-path writes for high-value facts, and background processing for broader pattern extraction.

Do not confuse thread state with long-term memory

This is one of the easiest architecture mistakes to make.

LangMem’s docs and LangGraph patterns make a useful distinction:

  • the checkpointer keeps short-term thread state and conversation continuity,
  • the store handles long-term, cross-thread memory.

Those are related, but they are not the same thing.

If you only checkpoint state, your agent remembers one conversation.

If you add a real store with namespaces and retrieval, your agent can remember across conversations, users, and workflows.

Namespaces are not a detail

If there is one memory design habit worth adopting early, it is namespacing.

LangMem’s tools make it easy to scope memory hierarchically, for example by:

  • user,
  • assistant,
  • organization,
  • or memory type.

That matters because shared, flat memory becomes noisy fast.

A simple pattern like:

  • ("memories", "{user_id}") for user-specific facts,
  • ("memories", "{organization_id}", "{user_id}") for org-aware recall,
  • or separate lanes for profiles and searchable notes

can dramatically improve retrieval quality and reduce accidental leakage across contexts.

LangChain’s storage best practices are the missing operational layer

LangChain’s long-term memory guidance for Deep Agents adds an important production perspective.

The idea is simple and powerful:

  • keep some files transient,
  • keep others persistent,
  • and route them intentionally.

With CompositeBackend, StateBackend, and StoreBackend, you can separate:

  • short-term working files that disappear with the thread,
  • from long-term files under paths like /memories/ that survive across threads and restarts.

That leads to several practical best practices:

  • use descriptive memory paths,
  • document the memory layout in the system prompt,
  • prune old data so persistent storage stays useful,
  • and use persistent stores in production instead of in-memory development defaults.

This is a strong pattern because it makes memory explicit. The agent knows where preferences live, where research notes live, and which files are safe to treat as durable context.

A practical default memory architecture

If I were designing an agent memory stack today, I would usually start here:

  1. Use a checkpointer for thread continuity.
  2. Use a persistent store for long-term memory.
  3. Keep a structured profile for current user preferences.
  4. Keep a searchable collection for episodic and semantic recall.
  5. Use hot-path memory tools only for high-signal facts.
  6. Use background reflection to consolidate broader patterns.
  7. Treat procedural memory changes carefully, because changing behavior is more sensitive than storing facts.

This avoids the two common extremes:

  • memory that is too weak to be useful,
  • or memory that is so aggressive it becomes noisy, slow, and hard to trust.

The core lesson

LangMem gives you the mechanisms:

  • memory managers,
  • memory tools,
  • store managers,
  • and prompt-optimization utilities.

LangChain’s broader guidance gives you the operating discipline:

  • separate transient from persistent memory,
  • keep storage organized,
  • make recall intentional,
  • and choose production-ready persistence when durability matters.

So the real best practice is not “add memory.”

It is this:

Design memory as an architecture decision.

Choose the right memory type. Write it at the right time. Store it in the right place. Retrieve it with the right scope.

That is how agent memory becomes genuinely helpful instead of merely accumulative.

Primary references:

Last updated on
What Is AutoResearch?Powerful Tools for AI Agents