If your agent loses its conversation the moment you restart it, the history was almost certainly held only in the memory of the running process. The fix is to write each conversation to durable storage, give that conversation a stable identifier, and load it again on the next run. Prompt wording will not solve this.
Why the history disappears
Many agent setups keep the message list in a Python list, a JavaScript array, or an in-memory saver object. That data lives only as long as the process does. When you stop and restart the app, the new process starts with an empty history and the model has nothing to continue from.
As an Amazon Associate I earn from qualifying purchases.
Continuity therefore requires two things. First, the messages or graph state for a conversation must be written to storage that survives a restart. Second, the next run must load that stored state before it calls the model. A session ID or thread ID is only a lookup key. It points to the history; it does not contain the history, and it does nothing if the storage behind it is gone.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Check the failure before changing code
Work through these checks in order. Most cases are resolved by the first three.
#1 Best Overall
- Confirm that history is written after each run and that the write finishes before the process exits. A run that is interrupted mid-write can leave nothing behind.
- Confirm the backend is durable. An in-memory object, a temporary directory, or an ephemeral container filesystem will not survive a restart, even if the code looks correct.
- Confirm the restarted process points to the same database file or service, and uses the same session or thread identifier for that user’s conversation. A new random ID on each start produces a fresh, empty conversation every time.
- Confirm the framework’s session or checkpointer integration is actually enabled, and that the run path loads stored items before the model call.
- Decide what you need. Continuity within one conversation is handled by session or thread persistence. Facts that must carry across separate conversations need a separate store, covered below.
OpenAI Agents SDK for Python
The SDK’s session feature retrieves the session’s stored items before each run and saves the new input and output after the run. The official Sessions documentation describes SQLiteSession and says that a persistent file path can be supplied. Create the session with a fixed ID and a database file path that lives on disk outside any temporary location.
After a restart, reuse the same session ID and open the same database file. The conversation then comes from the stored session rather than from a list that existed only in the previous process. The documentation describes this as the way to avoid calling .to_input_list() manually between turns.
Do not combine this with the run-level conversation_id, previous_response_id, or auto_previous_response_id options on the same run. The Running agents documentation treats sessions as client-managed and the other options as OpenAI-managed, and it states that session persistence cannot be combined with those server-managed continuation settings. Pick one strategy per conversation.
OpenAI Agents SDK for JavaScript
The JavaScript SDK exposes a Session interface that you can back with your own storage. The built-in in-memory session is meant for local development. For production, plug in a backend that stores session data and reloads it on later runs, and reuse the same session identity and backing store every time. If the in-memory session is what your app currently uses, a restart will reproduce your symptom exactly.
LangGraph
In LangGraph, two things must be in place. The graph needs a checkpointer attached, and each invocation needs a stable thread_id in the configurable run settings, for example {"configurable": {"thread_id": "customer-42"}}. LangGraph uses that identifier to save and retrieve the thread’s checkpoints.
The checkpointer must be durable. An in-memory saver lasts only for the life of the process, so it will reproduce the restart problem. Use a database-backed checkpointer and point it at storage that the restarted app can reach. Reusing a different thread ID after restart starts a new thread, so keep the ID tied to the user or conversation in your own data model.
LangGraph’s Persistence documentation describes two complementary systems. Checkpointers hold thread-scoped state, and stores hold long-term data shared across threads. The Checkpointers documentation confirms that thread_id is the key used to store and retrieve checkpoints.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteThread history and cross-conversation memory are different jobs
A common mistake is expecting a restored thread to know facts learned in a different conversation. Those are separate persistence problems, and each needs its own mechanism.
| Requirement | What to store | How it is retrieved | Typical mechanism |
|---|---|---|---|
| Continue one conversation after restart | Full message history or graph state for that conversation | Same session ID or thread_id |
SDK session with persistent storage, or LangGraph checkpointer |
| Remember selected facts across conversations | Chosen preferences, profile facts, or knowledge | Keys and queries defined by your application | A separate store, such as LangGraph’s store abstraction |
A checkpoint for one thread does not make its contents visible to another thread. If a user’s preferences must be available in every new conversation, write them to the separate store deliberately.
Multiple workers and containers
If your app runs several workers or containers, the session or thread identifier must resolve to durable storage that every worker can reach. If a follow-up request lands on a worker whose local file is empty or unreachable, the conversation will look reset even though the code is correct. The documentation requires the same session or store on later runs; the shared-storage implication for multi-worker deployments follows from that requirement and should be verified in your own environment.
Bottom line
Store each conversation in a durable session or checkpoint backend, reuse its stable identifier after every restart, and keep it on storage the restarted process can reach. Use a separate store for facts that must persist across conversations. The documentation pages checked in October 2026 describe this behaviour, but they carry no publication dates, so confirm the current API names against the versions you have installed.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The Bottom Line
Store each conversation in a durable session or checkpoint backend, reuse its stable identifier after every restart, and keep it on storage the restarted process can reach. Use a separate store for facts that must persist across conversations.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
