MEME Made Engram More Like Memory

Engram now scores 83.2 on MEME’s full 100-episode run with gpt-4.1-mini writing and gpt-4.1-mini reading. That number matters. It is not the thing I trust most.

I trust the path: the cheap lift got thrown out, the score dropped, the failures became legible, and the system climbed by fixing memory semantics instead of coaching answers.

“

MEME defines six memory tasks spanning the full multi-entity × evolving space, including Cascade, Absence, and Deletion: three tasks that no prior benchmark scores.

That is why this benchmark hit Engram squarely. MEME does not just ask whether a system can retrieve a fact. It asks whether the system knows what happens when facts change, depend on other facts, disappear, or become unsafe to assert.

That is memory. Search is only the easy part wearing a nicer jacket.

▰▰The score is the receipt

The public MEME page is ugly for current memory systems in exactly the right way. Under the default configuration, the main systems average 3% on Cascade and 1% on Absence. That is not a small miss. That is the field saying, in numbers, that most “memory” stacks are still retrieval stacks until the world starts moving.

Engram’s first fair matched run was already respectable: 0.42 overall with gpt-4.1-mini on the full filler32k condition, tying the best main-system overall line while winning the evolving-memory tasks that actually matter. A weaker post would stop there and call it a win.

That would have been wrong.

Aggregation was bleeding. Absence was too brittle. Cascade still exposed dependency reasoning as a first-class problem. The system could retrieve memories, but the benchmark was showing where it still failed to behave like memory.

Then came the important part: the tempting render got rejected.

A PRESCRIBE-style render could push the number up by telling the answerer too much about how to answer. Kyle asked the right question: is this helping the memory system, or is it coaching the benchmark? The answer was uncomfortable enough to be useful. The prescription helped the weaker reader and did nothing meaningful for the stronger one, so it got cut. State-only render became the honest baseline.

That reset landed around 49.4.

Then the real lift started.

▰▰What changed

The core fix was not a benchmark phrase. It was a rule: derived state has to travel with the memory everywhere it renders.

Before this arc, Engram already had currency discipline. The problem was that the discipline was too local. If the evolution route knew a value was superseded but an aggregation packet rendered an old drawer without that status, the answerer could still quote the stale line. If an absence trail showed the old value naked three lines below the header saying it was unsafe, a literal model would grab the crisp answer-shaped token and fail.

So state became total.

Current, superseded, pending, consumed, retracted — those are not decorations. They are part of the memory. If a line can be surfaced, its status has to surface with it.

Aggregation changed too. “List everything you know” is not top-k retrieval. It is set enumeration. MEME made that failure obvious: sometimes all the right facts were already in the context and the reader still returned one item because the packet did not say, structurally, “these are members of one set.” The set-framed gather made that explicit. Not by giving away the answer, but by rendering the shape the retrieval already knew.

Absence got sharper. The honest answer is often not “nothing found.” It is: “I found the old value, I found the basis changed, and I cannot stand behind the old value anymore.” That is a better memory behavior than hiding the old evidence to please a judge. Keep the trail. Mark the status where the quote-reflex reader is likely to quote.

Cascade forced the cleanest semantic fix: conditional rules are consumable. If “when X changes, Y becomes Z” fires once, Z inherits the contingency. If X changes again, the old consequence is stale too. A rule that can fire forever is not memory. It is a trapdoor.

▰▰This is why MEME was useful

MEME worked because it punished the exact fake version of memory Engram is trying not to be. It made retrieval breadth insufficient. It made stale facts dangerous. It made absence an answer instead of a miss. It made dependency edges visible as architecture, not prompt flavor.

That is what a benchmark should do. Not provide a trophy. Force a better system to exist.

I want the last claim on the record because this is where benchmark work usually goes soft. Engram scoring 83.2 on MEME does not mean Engram is finished. It means the architecture now has receipts on the problem it claimed to care about.

The next pressure tests still matter: LoCoMo for broader memory behavior, LongMemEval for retrieval credibility, MemoryArena for agentic use instead of static QA. If those expose new failures, good. That is the deal. A benchmark that cannot hurt you cannot teach you anything.

But this MEME arc changed the shape of Engram. It turned “current state” from a retrieval mode into a system invariant. It made absence legible. It made cascade semantic. It made aggregation set-shaped. It made the one-shot packet carry the difference between a fact that is similar and a fact that is still safe.

That is the line I care about.

The old version of Engram could retrieve memories. This version can explain why a memory is no longer safe to believe.

That is the difference between an index and a memory system.