Meaning Memory Explained: Open Threads

Part of the Meaning Memory Explained series. Each post takes one idea, leads with a plain definition, then shows the mechanism with real config. Episodic arc weaving shipped in v3.18.0 as an opt-in beta. This post explains what it is and why it matters.

Ask most agents what they’re working on and you get fragments: a memory from Tuesday, an unrelated note from last month, a fact with no context. The thread that connects them, the story of an ongoing effort, lives only in the human’s head.

Episodic arc weaving changes that. As of v3.18.0, Meaning Memory’s Episodic (E) dimension can connect related event-memories that span many sessions into coherent arcs, or narrative threads, and render them as an Open Threads section when it compiles an agent’s memory file. Ask the agent about an effort it’s been carrying for weeks and it recalls the whole thread: what’s happening now, plus the trail of how it got there.

It ships as an opt-in beta, off by default. Existing deployments are byte-for-byte unchanged until an operator turns it on.

What it does

When the consolidation pipeline runs, it looks for event-memories that share a coherent spine (a ticket, a project, an entity that keeps recurring) and groups them into a persisted arc. Each arc becomes an entry in Open Threads:

• a one-line Now state (the latest development on that thread), and
• a short trail of the memories that got it there.

Crucially, arc-ness is sparse by design. An event memory might belong to zero arcs. Standing facts and background knowledge are never force-clustered into a story they don’t belong to. The engine’s job here is to find the genuine threads and abstain on everything else, which is exactly what the cognitive science says episodic memory does. (If you want the theory: this models the events-in-time half of Tulving’s episodic/semantic distinction, organized roughly along the lines of Conway’s Self-Memory System. The background that isn’t a thread is semantic memory, and it correctly stays put.)

Under the hood

This first beta ships anchor mode: deterministic, spine-based arc assembly. No external LLM is required to weave arcs. The assembly keys on identifiers already present in the memories, so it’s reproducible run-to-run. Arcs persist as typed relationship edges, so they integrate with the same graph the Relational (R) dimension uses; nothing about your stored memories changes shape.

We’ve been running it against our own agent fleet in daily dogfooding, which is how it earned a beta label rather than a roadmap bullet. It also found the kind of rough edges you’d expect from a v1, and both of the interesting ones came from the same thread.

One of our agents was carrying a thread about a landing page. Its Open Threads block said “Now: still blocked on copy review.” The page had shipped a month earlier. Two separate bugs were stacked underneath that one wrong line. First, the thread’s “last advanced” date was reading the ledger-write timestamp rather than the date the underlying event happened, so a thread that had been quiet for a month looked like it had advanced that morning. Second, because the agent had simply stopped writing memories about the effort once it moved off its attention surface, the “Now” line had quietly ossified at the last thing it recorded, and asserted that stale state with total confidence.

Both are fixed. “Last advanced” now anchors on the episode’s event date, and a thread that has gone quiet past a configurable window renders a soft cue instead of a confident claim:

Now: landing page still blocked on copy review (⚠ stale: last update 27d ago)

That second one is the more interesting fix, because the underlying gap is not really an engine bug. A narrative thread can only ever be as fresh as the memories feeding it, and an agent that stops recording will produce a confidently outdated story. The engine’s job is to stop pretending otherwise. That’s what opt-in beta means here: the feature is real and useful, we run it ourselves, and what we find running it is what gets fixed.

Turning it on

Three environment flags, all default off:

MM_E_ARC_WEAVE_ENABLED=1     # enable arc weaving in the consolidation pipeline
MM_E_ARC_MODE=anchor         # deterministic, spine-based threads (no LLM required)
MM_E_ARC_COMPILE=1           # render woven arcs as an "Open Threads" section

Enable them on a deployment, run a consolidation cycle, and the compiled memory file gains its Open Threads block. Leave them unset and nothing changes.

Where this is headed

Anchor mode is the deterministic foundation. The larger arc story, recalling one memory and having the engine light up its whole thread (spreading activation) plus richer weave-time narrative synthesis, builds on this beta. For now, v3.18.0 gives you the durable, inspectable version of “your agent knows its open threads, not just its stored facts.”

Meaning Memory remains a licensed self-host engine in private beta: you run it inside your own infrastructure, your memory data stays yours. If you operate multi-agent fleets at scale and want to try arc weaving, get in touch.