What is reflective or meta-memory?

Working memory, episodic memory, semantic memory, and procedural memory all describe something about the outside world or about performing a task: what happened, what’s true, or how to do something well. There’s a further layer that isn’t about the world at all. It’s about the agent’s own memory and reasoning, knowing what it knows, how it arrived at a conclusion, and how much weight that conclusion actually deserves. This is reflective or meta-memory, and without it, a shaky guess and a carefully verified fact can end up looking identical once they’re both sitting in storage.

What Does Reflective Memory Actually Capture That the Other Four Types Don’t?

The other categories all describe content: an event that happened, a fact that holds, a method that works. Reflective memory describes an assessment of that content instead, something like “this conclusion was reached with limited confidence because the underlying data was incomplete,” or “this approach worked once, but the sample size was small enough that it’s worth testing again before relying on it heavily.” It isn’t new information about the outside world. It’s a judgment about the quality or reliability of another piece of memory.

This makes reflective memory fundamentally different in kind from the other four categories, even though it often gets stored right alongside them. It’s memory about memory, one level removed from whatever the original content was actually describing.

Why Would an Agent Bother Generating This Self-Assessment at All?

The value shows up in what’s known as the reflection pattern: an agent evaluates the quality of its own output before finalizing it, catching weak reasoning or an incomplete conclusion before it gets treated as settled. When that self-critique itself gets remembered alongside the conclusion it’s critiquing, future recall isn’t limited to “here’s what we concluded.” It becomes “here’s what we concluded, and here’s how much that conclusion should actually be trusted.”

Without this step, a tentative, low-confidence guess looks exactly the same in storage as a thoroughly checked conclusion, since a plain fact by itself doesn’t carry any indication of how solid the ground underneath it actually was. Reflective memory is what closes that gap, recording the agent’s own honest assessment at the moment the conclusion was formed, while that context is still available.

Does Confidence Need to Travel With a Memory Rather Than Be Assumed Later?

It does, because there’s no reliable way to reconstruct how confident a conclusion should be after the fact if that judgment wasn’t captured when the memory was actually formed. A system retrieving an old memory months later has no independent way to tell a well-verified fact from an early, tentative guess unless that assessment was recorded at the time, alongside the content itself.

This extends an idea already covered about deciding what deserves to become a memory in the first place, but pushes it one step further. It isn’t only a question of whether something is worth storing at all. It’s a question of how much weight that stored thing should carry once it’s sitting there available for retrieval, and that weight has to be recorded deliberately rather than inferred after the fact from context that’s already gone.

Does Meta-Memory Actually Change What Gets Stored or Retrieved, or Is It Just Commentary?

It’s more than a passive note attached for the record. A memory tagged with low confidence can be treated as provisional, worth surfacing when relevant but flagged clearly enough that whoever’s using it knows to verify rather than treat it as settled. A memory tied to a documented reasoning failure can trigger a deliberate follow-up correction rather than being quietly left to sit uncorrected. And a pattern of consistently low-confidence conclusions clustered around one particular topic is itself a useful signal, one suggesting the underlying data source or process feeding that topic needs attention, rather than any single memory needing to be individually fixed.

Meta-memory, treated this way, actively shapes what happens downstream rather than sitting alongside a conclusion as an inert label nobody actually acts on.

How Does Weaviate Engram Support This Kind of Self-Assessment?

Weaviate Engram’s transform steps can apply exactly this kind of evaluation, using an LLM to judge a conclusion against described success criteria as part of the same pipeline that processes and stores it, allowing this kind of continual self-assessment to happen without needing a human to manually review every single conclusion. Consider a market-research summarization assistant that occasionally has to synthesize a view from sources that are incomplete or partially conflicting, where flagging thin evidence matters as much as producing the summary itself:

from engram import EngramClient

client = EngramClient(api_key=os.environ["ENGRAM_API_KEY"])

client.memories.add(
    "Summary: adoption of the new packaging format appears to be rising in the Nordic market. Confidence: limited — based on only two regional distributor reports, with no confirming data from retailers directly.",
    group="market-research",
)

Later, when this conclusion gets retrieved for a related question, the caveat comes back attached to it rather than getting quietly dropped along the way:

results = client.memories.search(
    query="What do we know about Nordic market adoption of the new packaging format?",
    group="market-research",
)

Whoever reads the result sees the actual conclusion and the honest assessment of how solid it is in the same breath, rather than a confident-sounding statement with no indication that it was built on thin, partially confirmed evidence. That’s the practical value of reflective memory: not a separate system bolted alongside ordinary memory, but a deliberate habit of recording how much a conclusion should be trusted at the moment it’s formed, so that trust doesn’t have to be guessed at, incorrectly, every time it’s recalled later.

All five categories covered so far describe different kinds of content and how confidently to treat it. There’s also a simpler, more mechanical way memory gets divided, one based purely on how long something is meant to last rather than what kind of content it holds. Our next chapter, What is the difference between short-term and long-term memory in agents?, returns to that more basic distinction directly.