Does Dust Remember Between Conversations? Agent Memory, Honestly Explained

Your team runs Dust. Assistants answer questions over company knowledge, the global agent drafts the weekly update, a custom agent triages support threads. Then Dust announced Agent Memory, and the pitch sounds like the end of re-briefing. The honest question is narrower: what does it actually keep, and what still starts blank?

What Dust's Agent Memory actually is

Before Agent Memory, Dust agents reset between conversations. That was Dust's own framing: agents did not remember yesterday's correction or learn preferences, and every interaction existed in a vacuum. Agent Memory changed that, and the design is deliberately simple.

Memory arrives as a tool you add to an agent, not a default behavior. When it is on, the agent builds a persistent understanding of each user's work patterns, preferences, and ongoing projects. Storage is user-scoped: each person's interactions create their own knowledge graph. Everything stored is inspectable in the agent details drawer, and the Dust global agent now uses memory for its own conversations too.

So the direct answer to the search question is yes, with the modifier that matters: Dust remembers you across conversations with that agent, once the memory tool is switched on.

The three honest limits

First, it is opt-in. Memory is added as a tool, not enabled by default. Every Dust agent you already run has no memory until someone turns it on, and Dust made that choice deliberately: memory changes agent behavior, so teams decide where persistent context earns its place.

Second, it is user-scoped. Each person's interactions create their own knowledge graph. That is the right privacy shape for a company assistant, but it cuts the other way for operations: what the agent learns about your workflow from working with you does not pool into a shared operational record. Teammate A correcting the report format does not teach the agent for teammate B.

Third, it is conversational memory, not run state. Dust's docs still recommend starting a new conversation for each distinct topic so long sessions do not overflow the model's context window. Memory stores preferences, patterns, and ongoing projects for the person. It does not store a ledger of what happened on last night's run, what is pending, or what must not be repeated.

That third limit is the one that bites automation operators.

The amnesia that schedules expose

Imagine the nightly lead-triage workflow: a Dust agent reads the day's new leads against your qualification criteria, drafts outreach, and logs outcomes. Tuesday's run needs Monday's verdicts: which leads were already qualified, which were parked until next quarter, which ones asked never to be contacted again. Dust's Agent Memory remembers that you prefer outreach emails short. It does not keep the verdict ledger, because the ledger is not a preference and it is not yours. It belongs to the run.

Or the support-triage agent that runs every hour. The 2pm run escalates a thread to engineering with a promise of a reply by end of day. The 3pm run needs to know that promise exists so it does not escalate the same thread again or contradict the timeline. Conversational memory has nothing to say about this. It remembers the user, not the operation.

Or the weekly report agent. It needs to know what last week's report already covered so this week's edition reports only what changed. The per-user knowledge graph holds your preference for bullet points. The already-covered list lives nowhere.

None of this is Dust failing at its job. Dust built memory for people talking to agents. Scheduled work needs memory for agents doing work: decisions, promises, dedup guards, pending items. Different shape, different consumer.

The pattern that fixes it: one memory under every run

The fix is a shared memory layer that sits underneath every run and that every surface reads before acting and writes after acting. Before a scheduled run starts, it checks: what happened last time, what is pending, what must not be repeated. After the run, it records what it decided, what it promised, what changed. That memory outlives any single conversation and is shared across every run, every agent, every tool.

Dust's side of this is already friendly to the idea. Dust agents connect to tools over open protocols, and a memory service that speaks MCP plugs in the same way a data source does. The agent asks, the memory answers, and nothing about the Dust build has to change.

Where a hosted memory service fits

This is the workload Vilix AI was built for. It is cloud-hosted, so there is no infrastructure to stand up: no database, no embedding pipeline, no vector store to tune. One account, and the memory is there.

Because it is served over MCP, the same memory follows the work everywhere: the Dust agent, the workflow that scheduled the run, the phone app where you review the outcome. Every surface reads and writes the same state.

It keeps full conversation history rather than just distilled facts, which matters when an agent needs to know what was actually promised in a thread, not someone's summary of it. The free plan is free forever, a Pro trial runs seven days with no credit card required, and the data is portable: export the whole thing or delete it at any time. Get started at vilix.ai.

The takeaway

Dust remembers you. The memory tool is real, inspectable, and a genuine upgrade for anyone who chats with the same agent every day. But the moment you schedule the work, the agent's memory needs change shape: from knowing the person to knowing the operation. The nightly triage, the hourly escalation check, the weekly report all need a past they can read and a future they can write.

Give them one shared memory and the amnesia between runs stops. The agent that was sharp inside the conversation stays sharp between them too.