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

Dreaming is magical.

TLDR: 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.

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. https://supermemory.ai