The mental model we'll instrument

DeepAgents adds two things on top of these two primitives: a virtual filesystem (context offloading) and sub-agents (context isolation) — not a third persistence system.

Environment — versions to pin

# requirements.txt (see also docs/code/requirements.txt)
langgraph>=1.2,<2.0
langchain>=1.4,<2.0
langmem>=0.0.30
deepagents>=0.7,<0.8
python>=3.11,<4.0

State, Graph, compile

from langgraph.graph import StateGraph, MessagesState, START

def call_model(state: MessagesState):
    response = my_llm.invoke(state["messages"])
    return {"messages": [response]}

graph = StateGraph(MessagesState)
graph.add_node("call_model", call_model)
graph.add_edge(START, "call_model")
app = graph.compile()   # <- no memory yet at this point

Without a checkpointer, every invoke() starts from scratch: no working memory survives between two calls.

The checkpointer: short-term memory, per thread

from langgraph.checkpoint.memory import InMemorySaver
# (canonical name in recent versions; "MemorySaver" remains an alias)

checkpointer = InMemorySaver()               # dev — swap for PostgresSaver in prod
app = graph.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "user-42-session-1"}}
app.invoke({"messages": [("user", "Hi, I'm Alex")]}, config=config)
app.invoke({"messages": [("user", "What's my name?")]}, config=config)
# -> remembers, because it's the same thread_id

• A different thread_id = a completely isolated conversation.
• In prod: PostgresSaver / AsyncPostgresSaver — scalable, survives restarts.

Time travel, human-in-the-loop, fault tolerance

state_now = app.get_state(config)                     # latest checkpoint
state_then = app.get_state({                          # a specific earlier checkpoint
    **config,
    "configurable": {**config["configurable"], "checkpoint_id": some_id},
})
app.update_state(config, {"messages": [...]})          # writes a new checkpoint
                                                        # ("fork" — history isn't destroyed)

• The graph can pause (interrupt) at a node, persist its state, wait for a human, then resume exactly where it left off.
• Replaying from an old checkpoint re-executes the nodes (new LLM/tool calls) — it's not just a replay of cached output.
• Crash / restart: the thread resumes from its last durable checkpoint.

Trimming & rolling summary

The checkpointer solves persistence, not the token budget: a growing history eventually saturates the context.

• trim_messages (langchain_core.messages): trims a copy of the messages to a token/message budget before the LLM call — doesn't modify the persisted state.
• A more robust pattern: a rolling summary of older turns (injected as a system message) + the last k messages verbatim. Full fidelity on recent turns, compressed gist for the rest.

The Store: namespaced key/value + semantic search

from langgraph.store.memory import InMemoryStore
import uuid

store = InMemoryStore(index={"embed": embed_fn, "dims": 1536})

user_id = "user-42"
namespace = (user_id, "memories")            # scoped by user/organization

store.put(namespace, str(uuid.uuid4()), {"fact": "Prefers concise answers, code first"})
store.put(namespace, str(uuid.uuid4()), {"fact": "Data engineering team, uses Airflow"})

hits = store.search(namespace, query="how should I format my answers for this user?")
# -> ranked by embedding similarity, strictly within this namespace

Namespaces are plain tuples — you can nest them arbitrarily: (org_id, user_id, "preferences").

The Store, injected automatically

from langgraph.store.base import BaseStore

def personalize_node(state, *, store: BaseStore):
    memories = store.search(
        (state["user_id"], "memories"),
        query=state["messages"][-1].content,
    )
    # -> inject `memories` into the prompt/system message
    # before the LLM call
    ...

LangGraph's dependency-injection system supplies the store to the node via the type annotation — without it being a visible parameter of the graph.

Just like the checkpointer, this only works if the graph was compiled with a store: app = graph.compile(checkpointer=checkpointer, store=store) — forgetting store= is a common source of a confusing runtime error.

langmem: memory as a tool

from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    "anthropic:claude-haiku-4-5-20251001",
    tools=[
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
    store=store,
)
# -> the agent decides ON ITS OWN, mid-conversation,
#    when to write to or search memory

create_react_agent forwards store/checkpointer kwargs into its internal .compile() automatically — if you build a custom graph with StateGraph instead (as in the earlier slides), that passthrough is NOT automatic and you must call .compile(store=..., checkpointer=...) yourself.

Background processing (don't do it all in the hot path)

• create_memory_manager: extracts/consolidates the notable facts from a conversation (semantic memory), without blocking the current turn.
• create_memory_store_manager + ReflectionExecutor: runs this asynchronously/deferred rather than after every message — avoids redundant burst work, decisions on incomplete context, and wasted tokens.

LangGraph memory — reference table

DeepAgents: on top of LangGraph, not alongside it

• deepagents (GitHub langchain-ai/deepagents): "the batteries-included agent harness", explicitly inspired by Claude Code.
• Built on LangChain's create_agent (so, on LangGraph): the same building blocks, but with filesystem, sub-agents, context management and skills provided by default.
• Three principles the project advertises: opinionated (good defaults for long/multi-step work), extensible (no need to fork), model-agnostic.

Planning: the todo-list

from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    middleware=[TodoListMiddleware()],   # opt-in since deepagents 0.7 (no longer provided by default)
)

The agent explicitly writes and updates a structured checklist of subtasks (with per-task status), rather than keeping the plan implicitly in its reasoning — modeled directly on Claude Code's behavior.

Sub-agents: context quarantine

research_subagent = {
    "name": "web-researcher",
    "description": "Conducts in-depth web research on a specific question "
                   "and returns a condensed summary.",
    "system_prompt": "You are a focused research assistant. Investigate "
                      "thoroughly, then report only your conclusions.",
    "tools": [web_search_tool],
}

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    subagents=[research_subagent],   # + a "general-purpose" sub-agent is always available
)

The sub-agent runs in its own context window; only its condensed final report returns into the parent agent's context — no noise from intermediate tool calls leaks through.

Virtual filesystem: context offloading

• Tools ls, read_file, write_file, edit_file, glob, grep — a file surface manipulated through tool calls, which does not touch the real disk by default.
• A large tool result (a big web search, a long file, a query result) is written to a virtual file instead of being dumped into the message history — the agent then only re-reads the useful portion.

Backends: the junction point with LangGraph

• If a route's backend can't support an operation (e.g. delete on a read-only route), DeepAgents either surfaces an error or simply hides that tool from the model — check which, per backend, before assuming delete always works.

This is the single most important point of the whole talk: DeepAgents' filesystem is not a 3rd persistence mechanism — it's a façade over the LangGraph Store.

Routing: what should survive, and what shouldn't

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

backend = lambda rt: CompositeBackend(
    default=StateBackend(rt),                 # ephemeral draft, thread-scoped
    routes={"/memories/": StoreBackend(rt)},   # everything under /memories/ survives across sessions
)

agent = create_deep_agent(model="anthropic:claude-sonnet-5", backend=backend, store=store)

agent.invoke({"messages": [(
    "user",
    "Research LangGraph's memory model and write your findings "
    "to /memories/langgraph_notes.md",
)]})

Verifying cross-session persistence

1. Invoke the agent with thread_id="A", have it write /memories/notes.md.
2. Invoke with thread_id="B" (same store): ask it to read_file("/memories/notes.md") → it works.
3. Repeat the test with a file outside /memories/ (so on StateBackend) → it's gone in thread B.

Skills: on-demand loading

• SkillsMiddleware (extended in DeepAgents 0.6): reusable behaviors, loaded on demand.
• Only a piece of metadata (name + short description) stays permanently in the system prompt; the full content is loaded only if the agent judges the skill relevant to the current task.
• This is a context-management technique in its own right: you only pay the token cost of a capability if it's actually used this turn.

What changes between prototype and prod

• Persistent backends: PostgresSaver / PostgresStore rather than the InMemory* variants — necessary as soon as a process restarts or you scale horizontally.
• Observability: trace sub-agent calls (LangSmith or equivalent) to check what does — and doesn't — come back into the parent context — otherwise context isolation becomes a black box to debug.
• Security: FilesystemBackend has a "virtual" mode that blocks path traversal (../, ~/) — never expose real disk access without this safeguard in a server context.

What to choose, for which need

Companion notebook outline

docs/code/agent_memory_langgraph_deepagents.ipynb

1. Cosine similarity "from scratch" (numpy) — no framework, just the intuition.
2. Generative Agents-style retrieval score (recency + importance + relevance) on toy memories.
3. LangGraph — checkpointer, isolated threads, time travel.
4. LangGraph — Store, namespaces, semantic search, agent-driven memory (langmem).
5. DeepAgents — a research sub-agent, virtual filesystem, cross-session persistence via StoreBackend.

Suggested exercises (after the session)

• Replace InMemoryStore with a PostgresStore on a local database, and verify that memory survives a kernel restart.
• Add a second, specialized DeepAgents sub-agent (e.g. a "SQL analyst") and observe, via traces, what does — or doesn't — come back into the parent context.
• On a real use case from the team (e.g. a reporting agent), identify which type of memory (short-term / long-term / both) would solve the current problem.

One mental map to keep

Terms not already in Part 1's glossary

Full vocabulary (Framework, Harness, Opinionated, Token, Embedding, RAG, Checkpointer, Store, Grounding, Context engineering...): see Part 1's glossary.