How is Dynamic Dreaming different from Claude Code's context summarization?

Claude Code runs a single summarization pass when its context window fills up — whatever the summarizer decided mattered at that moment is kept, everything else is gone. Dynamic Dreaming runs in the background on its own schedule, revisits old memories in light of new information, and resolves contradictions that the original write never caught — including facts that arrived weeks apart.

Can Dynamic Dreaming fix a memory that was written incorrectly mid-conversation?

Yes — this is exactly the failure mode it targets. If a user debated two options and landed on option B in the final message, but the system recorded "prefers option A" from the middle of the discussion, a dream cycle will reweight that memory against the full conversation and correct the record. Contradictions get caught and resolved rather than silently persisting.

What is a memory inference, and how does Supermemory generate one?

An inference (also called a derivation) is a new connection the system draws between existing memories that were never written together — for example, linking a user's background, career moves, and stated goals into a single coherent narrative. Supermemory generates these during dream cycles by traversing the memory graph and finding relationships across fragments that arrived at different times, always grounding every inference back to its source memories so nothing is invented.

How long does it take for a dreamt memory to be available after a session ends?

Supermemory's hybrid retrieval keeps unprocessed content queryable the moment it arrives, so there is no gap in recall. The dreamt, enriched version of that same content catches up in the background within at most fifteen minutes, at which point the agent gets a richer, consolidated view of the same information.

Does Supermemory invent inferences it cannot trace back to source memories?

No — every inference the system generates must be traceable to the source memories it was built from. If the system cannot show its work, it does not produce the inference. This grounding constraint is a deliberate architectural choice to prevent the memory layer from hallucinating connections.

What is the dreaming parameter in the Supermemory API, and when should I use instant processing versus dynamic grouping?

The optional `dreaming` parameter on `POST /v3/documents` and `POST /v3/documents/batch` controls how memory formation runs: omitting it uses dynamic grouping (groups related documents together for semantic cohesion and lower cost), while setting `dreaming: 'instant'` processes each document individually so it is available in memory right away. Use instant processing for real-time chat or personalization use cases; use dynamic grouping for batch ingestion pipelines where immediate recall is less critical.

How does Supermemory's memory graph differ from a standard vector database for storing knowledge over time?

A vector database stores embeddings and returns similarity scores — it has no concept of relationships between pieces of knowledge, no contradiction handling, and no sense of time. Supermemory's memory graph uses ontology-aware edges to track how facts relate, supports an `extends` relation type for modeling hierarchies, handles knowledge updates and contradictions, and applies temporal filtering — so it can reason about what a user knew then versus what they know now.

How do I know which memories in Supermemory have been processed by a dream cycle?

Memories that are queued for or have been processed by a dream cycle are marked with a Dreaming symbol in the Supermemory console. You do not need to poll or check manually — the interface surfaces this state automatically.

What is Supermemory's recall latency for retrieval, and does dreaming slow that down?

Retrieval latency stays under 300ms regardless of dreaming state — dreaming runs in the background and does not block queries. Unprocessed memories are immediately queryable via hybrid retrieval, so response time is unaffected whether or not a dream cycle has touched a given memory yet.

Why do most memory systems write facts once and never revisit them, and what goes wrong because of that?

Most systems treat ingestion as final: a fact lands, gets written, and sits frozen while everything around it changes. The problem is that context evolves — users change their minds, conversations finish after the key decision is already stored wrong, and facts written in isolation miss relationships that only become visible later. The result is quietly corrupted user profiles and agents that confidently act on stale information, with no signal that anything is wrong.

Introducing Dynamic Dreaming in Supermemory

Dreaming is magical.

TL;DR
We're launching Dynamic Dreaming in supermemory today, which automatically works if you're using supermemory in any way - API, OpenClaw, Hermes agent, etc.

We (humans) dream to condense and reflect on our thoughts, not only things that happened today, but a weird blend of everything that has ever happened. It's how we connect dots that don't have obvious wires between them.

A conversation you had three weeks ago clicks with something you read this morning, and you wake up with an idea that wasn't there the night before.

Most memory systems don't do this. They learn instantly, the moment data flows in, and then never look at it again. A fact gets written and it just sits there - a frozen snapshot of one moment, oblivious to everything that has shifted around it since.

Some systems take a smarter swing at this. Claude Code, for example, condenses its context when the window fills up, summarizing what's been said and packing it down. Better, but still a single pass. Whatever the summarizer thought mattered at that one moment is what gets kept. Everything else is gone.

We think both of these approaches have their own caveats - What if the conversation was only half done when you learnt something? Or what if the user asks about the last conversation in this one?

A user spends twenty minutes debating two architectures and lands on option B in the very last message, but the system already wrote down "prefers option A" from the middle of the discussion. Every future session is now quietly poisoned. Or what about the user who comes back tomorrow and asks about yesterday's conversation, only to find that the only thing left of it is a three-line summary that decided, prematurely and forever, what mattered?

Dynamic Dreaming

Memory shouldn't be a transcript. It shouldn't be a snapshot.

It DEFINITELY shouldn't be a hash table you write once and read forever (like other memory providers). It should think about what it knows, on its own, in the background, and get better at remembering you the longer it lives.

So we built dynamic dreaming.

Best part? If you're already a user of supermemory, this will just work. Use it in your OpenClaw, or Hermes Agent. Just ask your agents to use supermemory. No additional configuration is required on your end. You'll be able to see a "Dreaming" symbol next to memories that will be dreamt on.

It just works

When you go quiet, or when enough new context has piled up, Supermemory will now enter a dream cycle on its own.

No cron job, no fixed timer. The system decides when, and it decides how deep to go based on what the heuristics tell it. A quick reflection for a short session. A longer dive when the day's worth of context warrants it.

During a dream, Supermemory does what brains do at night. It reconsolidates what it already knows. It merges fragments that belong together. It generates new abstractions over the raw material.

And the part that matters most: it reweights old facts in light of everything that's come in since they were written.
Memories that were too confident get tempered.
Memories that contradicted each other get resolved.
Memories that were just sitting there, isolated, suddenly find their neighbors.

The output isn't a summary.
It's three things at once: new memories, a graph of inferences (we also call them derivations) that weave between them, and a weighted, evolving picture of who the user actually is. Not a static profile, but a thought-out view that updates as the evidence changes.

Supermemory chat suggestion card titled "From Mumbai to CEO" asking how self-taught origins shaped problem-solving

The card above is a real inference. None of those facts were written together. The Mumbai jailbreak, the O1 visa, the two acquisitions, the GitHub stars. They came in over months, across dozens of separate conversations, in no particular order. Dreaming is what stitched them into a single thought. The narrative emerged on its own.

This is the thing we're most excited about: dynamic dreaming connects dots that, frankly, we thought were uncatchable.

It is the closest thing I've seen to a context window that never expires.

Still real-time

This part took us the longest to get right. If dreaming takes time, what happens when a user asks about the conversation that just ended thirty seconds ago, before any dream has touched it?

Nothing breaks. Supermemory's hybrid retrieval keeps unprocessed content queryable the moment it arrives, falling back to conversation search for memories that haven't been dreamt yet. New context is available instantly. The dreamt state catches up in the background, at most fifteen minutes, and when it does, the agent gets a richer version of the same truth.

And every inference stays grounded. We don't let the system invent things it can't trace back to source memories. If it can't show its work, it doesn't get to claim the thought.

What changes

Agents stop forgetting the things that matter. Contradictions get caught and reconciled instead of silently rotting in the index. User profiles stop being a brittle list of attributes and start being something closer to understanding. And the longer you use Supermemory, the better it gets. Not because it's accumulating more data, but because it's actually thinking about the data it has.

We've been building memory infrastructure for a year. This is the first feature that makes memory feel less like a database and more like a mind.

Dream away.

Use supermemory today. supermemory.ai

Introducing Dynamic Dreaming: supermemory now connects the dots, for you.

Dynamic Dreaming

It just works

Still real-time

What changes

Other posts.