Skills and Memory persistance across threads

OSS Product Help Deep Agents
1

I was testing deepagents I integrated /remember functionality in my custom ui now when i say /remember then skill name it saves the skill then when i switch thread and ask the agent to list threads it has not context.
is this behaviour appropriate or no

2

hi @chinu0609

This is expected with the default deepagents setup.
Threads are isolated by design - thread is a separate LangGraph conversation state. If you start a new thread (new thread_id), you should expect no chat context/history from prior threads unless you explicitly persist and reload it.

Deepagents default store is thread-scoped - it uses StateBackend, which stores files in the agent’s thread and explicitly notes that files persist within a conversation thread but not across threads. Therefore anything you /remember as a file (skills or memory file) will disappear when you switch to a different thread unless you are using a persistent backend across threads.

To persist remembered skills or memory across threads, use a persistent backend:

  • FilesystemBackend if you are running locally and are ok with disk persistance (be mindful of the security implications of giving the agent filesystem access)
  • StoreBackend + LangGraph BaseStore for a production-safe, cross-thread persistence layer. StoreBackend is designed for persistent , cross-conversation storage and persists across all threads.

About “list threads” specifically - is this a misspelling? Or is this an incorrectly phrased question?
Deepagents doesn’t automatically give the model awareness of other thread ids. Listing threads is usually a UI/server concern (your app can show threads - the agent won’t magically know them).

If you want global memory/skills across many threads, store memory/skills in a persistent backend (StoreBackend / FilesystemBackend) and ensure all threads point at the same memory/skills paths and the same logical namespace (e.g., consistent assistant_id/user scoping).

example (python)

from deepagents import create_deep_agent
from deepagents.backends.filesystem import FilesystemBackend

agent = create_deep_agent(
    memory=["~/.deepagents/AGENTS.md"],
    skills=["/skills/user/"],
    backend=FilesystemBackend(root_dir="/", virtual_mode=True),
)

example (Python): StoreBackend + PostgresStore (+ optional PostgresSaver)

from deepagents import create_deep_agent
from deepagents.backends import StoreBackend

from langgraph.store.postgres import PostgresStore

from langgraph.checkpoint.postgres import PostgresSaver

DB_URI = "postgresql://postgres:postgres@localhost:5442/postgres?sslmode=disable"

with (
    PostgresStore.from_conn_string(DB_URI) as store,
    PostgresSaver.from_conn_string(DB_URI) as checkpointer,
):
    store.setup()
    checkpointer.setup()

    agent = create_deep_agent(
        backend=lambda rt: StoreBackend(rt),
        store=store,
        checkpointer=checkpointer,
        skills=["/skills/user/"],
        memory=["/memory/AGENTS.md"],
    )

    config = {
        "configurable": {"thread_id": "thread-1"},
        "metadata": {"assistant_id": "my-assistant"},
    }

    agent.invoke(
        {"messages": [{"role": "user", "content": "Remember: prefer short answers."}]},
        config,
    )

    config2 = {
        "configurable": {"thread_id": "thread-2"},
        "metadata": {"assistant_id": "my-assistant"},
    }
    agent.invoke(
        {"messages": [{"role": "user", "content": "What do you remember about my preferences?"}]},
        config2,
    )
3

Hey @chinu0609 ,

Yeah — that behavior is actually expected.

In DeepAgents (and most agent frameworks), memory is usually thread-scoped by default. So when you use /remember, it saves the skill in the current thread’s memory.

When you switch threads, you’re basically moving to a new conversation context — so the agent won’t see the previous memory unless you’ve implemented shared/global memory across threads.

So nothing is broken :slightly_smiling_face:
It just means your memory layer is tied to the thread, not global.

If you want it to persist across threads, you’ll need to store it in something like:

  • A shared database

  • Long-term memory store

  • Or a global user-level memory layer

In Short: Yes, this is normal behavior.