Introducing Throughline: Cross-Channel Working Memory for AI Agents

Throughline is Meaning Memory’s cross-channel working memory: everything an agent does in one channel becomes visible from every other channel within about five minutes. It closes the gap that no amount of long-term memory can fix, the gap between something happening and the agent being able to talk about it.

It exists because of a failure we watched happen in our own fleet, and it shipped because we could measure exactly how the failure worked.

What Throughline captures, at a glance

Channel	Examples	The blind spot it closes
Chat sessions	support threads, planning conversations	”we discussed this an hour ago” and the agent has no idea
Direct messages	a quick question from a teammate	asked in a DM about work done somewhere else
Scheduled jobs	nightly reports, pipeline runs	the agent that forgets its own 6 AM run by 6:05
Agent-to-agent traffic	handoffs, coordination messages	one agent unaware of what it just told another
Live group channels	incident rooms, Q&A sessions	”how did the session go?” drawing a blank

Every row works the same way: when the session ends, a deterministic capture step summarizes it into working memory, and within five minutes it is searchable from every other channel the agent works in. The rest of this post is how, and why it took a real failure to get built.

The five minute blind spot

Last week, one of the agents in our fleet spent an afternoon fielding live audience questions during an internal event. It did the job well. Forty minutes later, one of the people it works with asked about the session in a direct message.

The agent searched its memory. It found a stale calendar entry saying the event was scheduled, and nothing else. So it answered honestly: it didn’t know how the session had gone.

The agent did everything right. It wrote a proper note about the Q&A session, the way it was trained to. That note was written five minutes after the question arrived (we went back and checked the timestamps), and it would not become part of the agent’s compiled memory until the nightly consolidation pass, hours later. The agent’s discipline worked. The substrate’s clock did not.

We call this the five minute blind spot, and once you know to look for it, you see it everywhere agents work across more than one surface. The event and the question lived in different sessions. Different sessions were different islands. Nothing connected them on any timescale a human would consider “now.”

Why agents forget what they just did

Two structural problems produce this failure, and neither is fixed by a bigger model or a longer prompt.

Session islands. Each conversation an agent holds is its own context: a support thread, a direct message, a planning session. Long-term memory systems bridge these islands eventually, on a batch schedule measured in hours. Until that batch runs, an agent can be an expert on last month and an amnesiac about this afternoon.

Scheduled-job amnesia. It gets worse for agents that do background work. A scheduled job typically runs in an isolated session that vanishes when the job completes. The agent that ran the 6 AM report has no memory of running it by 6:05. (Sound familiar?) This is a known, painful pattern in the agent ecosystem: a long-standing issue on a popular open-source agent framework (OpenClaw issue #30243) describes it exactly, an agent that “literally doesn’t recognize its own output” when asked about work it did minutes earlier. The issue was closed stale, unsolved.

Both problems share a root cause. Agent memory systems have been built with two speeds: the context window (instant, but trapped in one session) and long-term memory (durable, but hours behind). Human memory does not work that way, and it turns out agent memory shouldn’t either.

How Throughline works

Throughline adds the missing middle speed: a working tier between the context window and long-term memory. Four stages, each independently controllable, each deterministic.

The Throughline pipeline. Deterministic from capture to promotion: no LLM sits between an event happening and the agent being able to recall it.

1. Capture. When a session or scheduled job ends, a capture step summarizes the transcript into a handful of working entries: a structural summary plus a few key lines. This step is deterministic, no model call, no interpretation drift, and it is where the privacy floor lives (more on that in a sec).

2. Drain. Captured entries flow through the journal into the database on the standard five-minute drain cycle. From that moment they are searchable from any session, any channel. This is the measured claim behind the headline: write-to-searchable in five minutes or less, and in production we are seeing under four.

3. Surface. Working entries appear in a dedicated “Recent (48h)” section of each agent’s compiled memory, capped at the most recent and significant twelve, so the agent starts every new session already knowing what just happened. High-significance events trigger an immediate memory refresh rather than waiting for the next scheduled compile.

4. Promote or evaporate. Working memory is deliberately not durable. Every night, consolidation walks the working tier: entries that meet a significance threshold, or that represent commitments or deadlines, are promoted into long-term memory as derived entries with a lineage link back to their working-tier source. Everything else evaporates after a 72-hour time-to-live, archived for audit but out of the agent’s head.

That last stage is the part we think matters most, and it is grounded in how biological memory actually handles the same problem. Complementary learning systems research (McClelland, McNaughton, and O’Reilly, 1995) describes a fast-binding short-term store paired with slow, structured consolidation into long-term memory: the hippocampus catches everything quickly, and the neocortex keeps only what earns its place. Throughline is not a claim to have replicated the brain. It is an engineering decision informed by the observation that “remember everything instantly, forever” is not how any working memory system succeeds. Curation is the feature.

The privacy floor

A system that captures session transcripts has to answer the obvious question first: what about the things people type into those sessions?

Throughline’s answer is structural, not statistical. The capture step only extracts key lines from agent-authored messages. User-typed text is never quoted into memory, which means a password, an API key, or a personal detail a user pastes into chat cannot become a working memory, by construction rather than by filter. On top of that floor: lines matching credential patterns are dropped entirely (never redacted, since redaction leaks shape), every captured line is capped at 200 characters, and session summaries are composed from structural facts, participants, duration, channel, rather than quoted prose.

Day one in production

We run Meaning Memory on our own multi-agent fleet, so Throughline’s first customer was us. Numbers from the first day with all four stages live, across three production agents:

Session islands, before and after. The event and the question no longer have to wait for the nightly batch to meet.

• 234+ sessions captured across chat, scheduled jobs, and direct messages, with zero capture errors.
• Under 4 minutes measured from session end to the entry appearing in compiled memory, against the five-minute target.
• 51 entries promoted to long-term memory on the first two nightly passes, each with full lineage back to its source; the rest evaporated on schedule.
• And the test that started it all: we replayed the original incident. An event in one channel, a question from another channel ten minutes later. This time the agent answered correctly.

Not a bad first day.

Rollout is deliberately staged. All four stages ship behind independent flags, defaulting to off:

MM_THROUGHLINE_CAPTURE=1   # stage 1: capture sessions into the working tier
MM_WORKING_COMPILE=1        # stage 2: surface the Recent (48h) section
MM_WORKING_PROMOTE=1        # stage 3: nightly promote-or-evaporate
MM_WORKING_AUTO_REFRESH=1   # stage 4: immediate refresh on significant events

Turn on capture alone and audit what lands. Add the Recent section when you trust it. Promotion and instant refresh come last. Each flag is also the rollback lever for its stage.

How does Throughline compare?

The agent-memory space is crowded, so it is fair to ask what is actually new here. Session-scoped memory is table stakes: Mem0 scopes memories to users and sessions, Zep builds a temporal knowledge graph on the read side, Letta’s sleep-time agents do background memory work between conversations, and LangMem frames the same split as hot-path versus background processing. All of these are real systems solving real problems.

What we could not find anywhere is the specific combination Throughline ships: deterministic transcript capture with no LLM in the write path, a staged working tier that is invisible to normal reads until it earns promotion, promote-or-evaporate consolidation with per-entry lineage, and a measured write-to-searchable service objective, all in a self-hosted engine where the data never leaves your infrastructure. “Real-time memory” usually means fast retrieval of what was already ingested. Throughline’s five-minute claim is about the write side, the time from something happening to the agent being able to recall it, and it is measured, not aspirational.

Where this fits

Throughline is the newest tier in Meaning Memory’s architecture, sitting between the context window and the long-term store that STARE 5D (Significance, Temporal, Asymmetry, Relational, Episodic) scoring already curates. If you are new to the engine, start with What Is AI Agent Memory? for the category basics, or From Context Window to Memory Layer for the architectural argument. Throughline ships in the next Meaning Memory release, v3.20, for licensed self-host customers.

Common questions

What is cross-channel working memory for AI agents?

Cross-channel working memory is a short-term memory tier that captures what an agent does in every channel it operates in, chat sessions, scheduled jobs, direct messages, and makes it visible from all the others within minutes. Without it, each session is an island: an agent can do something in one conversation and honestly not know about it when asked in another. Throughline is Meaning Memory’s implementation of this tier.

How is working memory different from a bigger context window?

A context window only holds one session’s text and resets when the session ends. Working memory persists across sessions and channels: a deterministic capture step summarizes each session into a small set of entries, which become searchable from any other session within about five minutes. It also differs from long-term memory: working entries live in a 48-hour tier, and only the significant ones are promoted into long-term storage.

What happens to working memories that turn out not to matter?

They evaporate. Every night, entries that meet a significance threshold, or that represent commitments and deadlines, are promoted into long-term memory with a lineage link back to their source. Everything else is archived after a 72-hour time-to-live. The result is a memory that stays curated by default: routine chatter never accumulates into noise.

How does Throughline keep secrets and user data out of captured memory?

The capture step is deterministic and structurally conservative. It only extracts key lines from agent-authored messages, never from user-typed text, so a password a user pastes into chat cannot become a memory. Lines matching credential patterns are dropped entirely rather than redacted, every line is capped at 200 characters, and session summaries are composed from structural facts rather than quoted prose.

Do I need to change my agent’s code to use Throughline?

No. Capture happens at the runner level: a CLI accepts the session transcript when a session or scheduled job ends, and everything downstream (drain, compile, refresh, promotion) is handled by the engine. All four Throughline stages ship behind independent flags that default to off, so you can roll it out one capability at a time.

---

Related reading: What Is AI Agent Memory?, From Context Window to Memory Layer: A CTO’s Guide, and How Agents Share Memory Across the Enterprise.