Update, 28 October 2026: Synap is now #1 on LongMemEval at 95.6% on all 500 questions. Read the results.
Maximem Team | May 20, 2026
LangGraph gives an agent persistent memory through two layers. A checkpointer (InMemorySaver, SqliteSaver or PostgresSaver) saves graph state per thread_id, which covers one conversation. A Store (InMemoryStore in development, PostgresStore in production) holds JSON documents across threads under namespaces you define, with optional semantic search. What LangGraph leaves to you is the memory logic: your code decides what to write, how to key it per user, and what to do when a fact changes. Maximem Synap fits at the Store layer; SynapStore implements BaseStore, so nodes write what they learn and search it back from any thread under one user identity, while PostgresSaver stays as your checkpointer.
What LangGraph Already Does Well
LangGraph models an agent as a state machine in which the LLM is one node among many. You define nodes as functions, wire edges as transitions, add cycles for retries and insert interrupt points for human approval. This is not prompt engineering with extra steps. Persistence is built into that design: compile a graph with a checkpointer and you get conversation continuity, human-in-the-loop pauses, time travel and fault tolerance from one mechanism.
How LangGraph Memory Works Today
A checkpointer writes a snapshot of your graph's state at each super-step boundary, filed under the thread_id you pass in the run config. Think of it as a save-game file: the graph can pause, resume or rewind because every intermediate state was captured.
You choose the checkpointer when you compile the graph. InMemorySaver ships with LangGraph and keeps checkpoints in RAM, so threads are gone when the process restarts; the docs recommend it for experimentation. SqliteSaver writes to a SQLite database and suits local workflows. PostgresSaver stores checkpoints in PostgreSQL and is the option the docs call ideal for production: state survives restarts and every instance reads the same threads.
Checkpoints are scoped to a thread by design. Memory that crosses threads is the job of the Store, which keeps JSON documents under a namespace tuple such as (user_id, "memories") and a key. Any node can read and write it through runtime.store, and configuring it with an embedding model turns search into semantic search. InMemoryStore is meant for development and testing; PostgresStore is one of the persistent stores the docs list for production.
What the Store does not do is decide anything. LangGraph's own memory guide lays out the choices and leaves them to you: one profile document per user or a collection of small ones, writes in the hot path or from a background job, and how an old fact gets updated when a new one contradicts it. That extraction and update logic is a memory-layer problem.
What Synap Adds
Synap is agentic context management. It does not replace LangGraph's checkpointer. It takes the Store slot and does the memory logic on the server.
The maximem-synap-langgraph package ships two components that plug into LangGraph's native interfaces:
SynapStore implements BaseStore. Each put is ingested as a Synap memory with the namespace and key attached as metadata, and each search runs Synap's retrieval for the user the store was built for and returns ordinary SearchItem objects. A store is pinned to one user_id at construction, or to a customer-wide shared pool when you pass only a customer_id, so build one per user.
SynapCheckpointSaver implements BaseCheckpointSaver. Its reads are semantic rather than exact key-value lookups, so for production thread state keep PostgresSaver (or SqliteSaver for local work) as your checkpointer and use SynapCheckpointSaver for audit, observability and demo flows. Cross-thread memory is SynapStore's job.
Four helpers sit beside them: create_synap_node injects memory for the latest user message into state, synap_st_prompt and create_synap_st_node add Synap's compacted view of the current conversation, and SynapLangGraphCallbackHandler reports turns and tool calls back to Synap.
Three limits are worth knowing first. Search is the supported read path, because an exact get by key depends on metadata that some Synap instances strip during extraction; on those instances search still returns the user's memories but does not filter by namespace. Deletes through the store are logged no-ops in this release, and list_namespaces returns an empty list. Data that needs strict key-value semantics belongs in PostgresStore.
We built this because multi-agent graphs kept losing context that lived in a different thread last session. The result: 92% 95.6% on LongMemEval and 93.2% on LoCoMo on our open eval harness (LongMemEval: Gemini 3.8 Flash as answer model and gpt-4o as judge; LoCoMo: gpt-5-mini as answer model and judge), in-conversation reads at an asserted P75 under 15ms, and a memory layer that scales across threads.
For why context management is infrastructure and not a feature, read What Is Agentic Context Management? (/blog/what-is-agentic-context-management). For build-versus-buy numbers, see The Real Cost of DIY Agent Memory (/blog/real-cost-diy-agent-memory).
What Synap Adds to LangGraph

What Production Teams Gain
Cross-thread continuity. User starts in thread A, returns in thread B. Your PostgresSaver checkpointer resumes exact state inside each thread, and SynapStore makes what was learned in thread A searchable from thread B.
Accuracy that ships. Synap scores 92% 95.6% on LongMemEval (500 questions) and 93.2% on LoCoMo (1,540 questions), benchmarks that measure whether agents recall facts across long, multi-turn conversations, reproduced on our open eval harness with Gemini 3.8 Flash as answer model and gpt-4o as judge for LongMemEval, and gpt-5-mini as answer model and judge for LoCoMo.
Token efficiency. Synap's Agentic Compaction keeps the working context bounded: it triggers at 3,000 tokens, 10 messages or 5 minutes idle, compresses toward a 1,500-token target while keeping the last three conversation pairs verbatim, and returns a validation score and a preserved-facts count on every pass. Re-sending the full history grows token cost quadratically with conversation length; validated compaction keeps it close to linear.
Latency that does not block. In-conversation reads come from a cache Synap pre-fetches into your own process, at an asserted P75 under 15ms; a cold retrieval targets P95 450ms, and accurate mode adds reranking and entity expansion at a higher latency. SynapStore uses accurate mode unless you pass mode="fast".
Entity resolution. "My manager" in one thread and "Sarah" in another resolve to one person on the server, so your graph nodes do not have to.
Predictable failures. Store writes raise SynapIntegrationError, so a node knows persistence failed. Store reads return None or an empty list and log the error.
How to Get Started
Three steps.
Step 1: Install. Requires Python 3.11 or later and langgraph 1.0 or later.
pip install maximem-synap-langgraphStep 2: Initialize the SDK once, then compile your graph with a store.
import os from typing import Annotated, TypedDictfrom langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import END, START, StateGraph from langgraph.graph.message import add_messages from langgraph.runtime import Runtime from maximem_synap import MaximemSynapSDK from synap_langgraph import SynapStore
sdk = MaximemSynapSDK(api_key=os.getenv("SYNAP_API_KEY")) await sdk.initialize()
class State(TypedDict): messages: Annotated[list, add_messages] memory: str
async def recall(state: State, runtime: Runtime): question = state["messages"][-1].content hits = await runtime.store.asearch(("memories",), query=question, limit=5) return {"memory": "\n".join(str(hit.value) for hit in hits)}
async def remember(state: State, runtime: Runtime): await runtime.store.aput( ("memories",), "timezone", {"text": "Alice works in Asia/Tokyo."} ) return {}
builder = StateGraph(State) builder.add_node("recall", recall) builder.add_node("remember", remember) builder.add_edge(START, "recall") builder.add_edge("recall", "remember") builder.add_edge("remember", END)
store = SynapStore(sdk, user_id="alice") # add customer_id on a B2B instance graph = builder.compile(checkpointer=InMemorySaver(), store=store)
Put your LLM node between recall and remember and read state["memory"] when you build its prompt.
Step 3: Deploy. Synap handles cross-thread memory and retrieval, and your graph handles logic. For production thread state, compile with PostgresSaver as the checkpointer and pass SynapStore as the store; SynapCheckpointSaver is best-effort by design.
Full config, scoping, and error handling: https://docs.maximem.ai/integrations/langgraph. For the LangChain side (create_agent, checkpointers, stores and the Synap retriever, tools and callback handler), see How to Add Conversational Memory to a LangChain App.
Memory Is Infrastructure
LangGraph gave developers a standard for building stateful agents. The checkpointer saves and resumes state and the Store keeps documents across threads. Deciding what belongs in the Store, and keeping it true as users change their minds, is a different problem.
Teams either write that extraction and update logic on top of PostgresStore themselves, or they plug in a system built for it. Either way the payoff is customers who do not have to repeat themselves.
This is why memory is infrastructure, not a feature.
Start building LangGraph agents that remember across threads → (https://synap.maximem.ai)
Synap pricing is usage-based. You pay for memory operations: storage, retrieval, compaction. No per-seat or per-framework surcharge. Starter plan: $19/month at launch pricing (list $49). Every new account gets about $10 in free credits to test before committing. See full pricing at https://synap.maximem.ai/pricing.
Related Articles:
LangChain Long-Term Memory: Remembering Users Across Sessions
Why AI Forgets
The Real Cost of DIY Agent Memory



