What 70 Days of Cross-Channel Agent Memory Taught Us

This is a follow-up to Introducing Throughline: Cross-Channel Working Memory for AI Agents, published July 7, 2026. That post covered the architecture. This one covers what we learned after turning it on.

Building Meaning Memory has made 2026 one of the most challenging years of my career, and easily the most rewarding. For about eight months I have been in it continuously: designing the architecture, setting the logic goals, working through implementation details, and reviewing the code myself. A small team of AI coding agents works alongside me, which is its own kind of education. Some days that means watching a feature land exactly as designed. Other days it means reading a transcript where one of our own agents insists it never did something it did that same morning. (If you have ever had a coworker swear they never got the email you are both looking at, you know the feeling.)

This post is about the second kind of day, and what we did about it. When things break in production, you learn fast.

Where We Started: Static Agent Memory

Our agents run on OpenClaw, and like most agent frameworks it gives each agent a static memory file: a document loaded into the agent’s context at the start of every session. In our setup, Meaning Memory compiled that file each night from the long-term store. It is a sensible design, and for a single agent talking to a single person it works well.

It breaks down once an agent works across several channels at the same time. Each conversation starts from the same snapshot, and nothing an agent does in one conversation reaches the others until the next nightly compile. We built Throughline to close that gap: a working memory tier between the context window and long-term memory that any session can search within minutes.

What we missed in July was just how many static-model assumptions we had dragged into version one of Throughline. Over the next 70 days, real production traffic exposed three of them, one by one.

Discovery 1: Memory Recorded the Conversation, Not the Action

Found: July 11, four days after launch · Status: Fixed

Late that morning, someone on the team asked an agent to pass its assessment of a customer escalation to a peer agent. The agent did the legwork, dispatched the message, and confirmed it was done. That evening came the follow-up: did you pass that along? The first attempt at an answer failed on a rate limit. When the agent did answer, a little over an hour later on a smaller local fallback model, it said no, and asked which escalation they meant. Not our finest moment.

Root cause. The morning session had been captured about twenty minutes after it ended, so a record existed for hours before the question arrived. The problem was its content. The capture step pulled key lines from the agent’s messages, but it was tuned to find promises, decisions, and notes-to-self. A completed action (“Done, I sent it over”) matched none of those patterns and was dropped, and the tool call that delivered the message was not captured at all. That is the core flaw of static memory: it takes notes on what was said, not what was done. If nobody logs the action, as far as memory is concerned it never happened.

The same session, captured two ways. Only the action record can answer “did you send it?”

A second factor. Our agents are told to search working memory before saying “I don’t remember.” Here, the fallback model reasoned about searching, skipped the tool call entirely, and ignored the agent’s own “I just sent it” message sitting right in its context. Better capture alone would not have saved that answer.

What we changed.

• Structured action capture. When an agent sends an inter-agent message, files a ticket, or sends an email, Throughline now records the tool, a privacy-safe identifier for the target, and the success receipt, plus one sentence from the agent confirming it. Action records are excluded from long-term promotion by design, so they stay in working memory and expire on schedule. Replaying the July 11 session through the new pipeline produced exactly the record the agent had been missing. This shipped the same night.
• A recall guard. A nightly check scans transcripts for denials of past actions and grades each against the recorded actions. Clear contradictions are marked for a hard correction; supported-but-unproven cases get a gentler nudge that points to the matching action. On the real July 11 transcript it produces the nudge, since the record proves a message was sent but not what it contained. It merged July 13 with 42 engine tests and 51 guard tests, and it runs in observe mode: it reports what it would have corrected, but does not yet talk back to the agents. An automated correction that is itself mistaken would be worse than none, so it stays in observe mode until its judgment has proven itself.

Discovery 2: A Confident Mistake Became a Permanent Memory

Found: July 14 · Status: Contained; the archive is live, and retrieval is on our roadmap

At 7:11 PM, a team lead asked an agent to update a colleague on a project status change. The agent sent it at 7:15. One minute later, in a separate chat, the colleague checked in: were you asked to pass along an update? The agent said no.

That much was the same class of failure as Discovery 1. The denial was bad enough, but midnight made it worse. At 12:05 AM, nightly consolidation grabbed that denial and cemented it into long-term memory, with nothing in the pipeline stopping to ask whether the claim was true.

The empty shelf. The agent’s search worked correctly; there was nothing on the shelf to find.

Root cause. Here the failure was purely structural, and the villain was timing. The team lead’s conversation was still active when the colleague asked. Capture waited for a session to sit idle for ten minutes before picking it up, so that conversation could not be recorded before about 7:43 no matter how often the job ran. The agent searched at 7:17 and found ten older, unrelated entries, because that was everything that existed. The records of the update were created at 7:56.

Two flawed assumptions collided here: static memory only records a conversation after it ends, and it trusts whatever the agent writes down. A third showed up in the next morning’s measurements: the size limit meant for the memory file an agent loads had leaked into what we stored, so we were discarding information to fit a display budget.

What we changed. Containment came first: we archived all three copies of the false claim and ran a full capture cycle to confirm none came back. The larger fix was to separate storage from what the agent carries. The day after the failure, a raw observation archive went live. It records every message and action with who said it, when, and to whom, with no size limit.

A week later we learned where the problem had moved. A user asked the agent whether it had discussed a particular topic with a colleague earlier that day, and it said no. This time the archive had the conversation, correctly attributed. The agent had no way to read it, because its recall tools only searched the curated memory tier.

Where things stand. The foundation and the top layer are live; the bridge between them is next on our roadmap.

What comes next. The retrieval layer is designed, and its core rules are written and tested as code. An agent may answer “no” only after searching a clearly defined scope and finding nothing there; otherwise the answer is “I don’t have a record of that.” The design also includes a check just before an answer goes out, so a denial that contradicts the record is replaced with the true answer. Wiring it into live agents is the next step, and until then this class of failure can return in a different shape.

Discovery 3: Two Minutes Was Too Long

Found: July 28 · Status: Fixed

At 7:07 PM, an agent forwarded a news article into a colleague’s chat at a team member’s request. Just two minutes later, at 7:09, the colleague asked about it. The agent checked its session history, working memory, long-term memory, and daily notes, found nothing in any of them, and said it had no record of sending anything.

Root cause. Two gaps overlapped. A message sent into someone else’s chat was recorded only in the conversation where it was requested, so the recipient’s conversation never learned about it. And capture ran every fifteen minutes, only for sessions that had gone quiet. That is the batch mentality at work: a fifteen-minute schedule applied to something that unfolds in seconds.

What we changed.

• Stage one: register the direct-message tool in the structured action capture from Discovery 1 (it had simply never been added), and move background capture from every fifteen minutes to every five.
• Stage two: a send-time trigger. When a send succeeds, a small hook immediately queues capture of that one event, keyed to the send receipt so it cannot be recorded twice. If the hook fails, the five-minute sweep picks it up. The memory write never blocks or delays the message.

Only the send-time trigger beats a two-minute question. The sweep is a backstop, not the answer.

Look closely at that chart. Even our five-minute sweep, the backstop we added in the same fix, would have lost this race. Only capture at the exact moment of the send closes the gap, and going from twenty-plus minutes to 73 seconds in a single evening is a result I am proud of. As an extra backstop, agents also note every cross-recipient send in their daily notes in the same turn.

The Pattern Behind All Three

Net-net, across all three failures, capture and recall were out of sync. Discovery 1 captured on time but grabbed the wrong data. Discovery 2 could not capture because the session was still active. Discovery 3 arrived during the batch interval. Each time, the agent searched at a moment when the answer was not in memory and treated the empty result as proof that nothing had happened.

An empty search result is not evidence that something did not happen. Agents need to be built to know the difference.

Structured action capture and the send-time trigger work on the capture side, making sure evidence exists when it is needed. The recall guard and the “no only with coverage” rule work on the answer side, making sure missing evidence never turns into a confident denial. Discovery 2 drives home a deeper lesson: when a memory system treats an agent’s words as gospel, it will eventually enshrine false claims as facts. The record of what actually happened has to live apart from what the agent said about it.

How Other Memory Systems Approach This

Cross-channel memory is not just our challenge, and the landscape has moved fast since July. Going by each project’s own documentation, here is how the main approaches stack up:

Most of these systems are excellent at remembering across sessions over days and weeks. The narrower problem we keep running into is the live one: an agent in two conversations at once, where an action in one needs to be visible in the other within seconds, and where a missing record must never become a false denial. As far as I can tell, no one has fully solved the live-conversation case behind Discovery 2, and we have not either.

Next on the Meaning Memory Roadmap

Every item here is scoped and on our roadmap. When teams evaluate memory for their own agents, I want them to see the real edges today, and where we are heading next.

• Retrieval into the archive. Give agents a governed way to query the archive when they answer, with the “no only with coverage” rule built in. The design is done and its core rules are tested as code; wiring it into live agents is next.
• One identity across channels. The same person has a different ID in chat, messaging, and email. Binding those into one identity means a question like “did I already tell the team lead?” searches every channel that person uses. Every reviewer on our design panel independently flagged this as a prerequisite for retrieval, so it comes first.
• A truth check before promotion. Nightly consolidation promotes by significance today. The plan is to check each candidate against the archive before it becomes long-term memory. Action records are already excluded, and the July 14 case was contained.
• Recall guard, from observing to acting. Move the guard from reporting what it would correct to nudging agents directly, once its judgment has proven itself in observe mode.
• Steadier behavior on fallback models. Discovery 1 began with a rate limit that pushed an agent onto a weaker model. Our guard is built to hold regardless of which model answers, and we will keep hardening that path. Fragile fallback behavior is an industry-wide headache, not just ours.

What I Would Tell Someone Building This Today

1. Capture actions, not just conversation. A successful tool call with a receipt is a far more reliable record than a summary of what the agent said it did.
2. Line up capture with recall. If capture runs on a schedule, agents will search during the gap and find nothing. Capture at the moment of the action, or design answers around the blind window.
3. Never let “nothing found” become “no.” An agent should deny something only after checking a defined scope it has reason to believe is complete. Otherwise the answer should be that it has no record.
4. Do not promote without a truth check. Keep the record of what happened separate from what the agent said about it.

None of this would have surfaced in an architecture review. Real production traffic broke our assumptions, and it didn’t take long: the first one showed up within a week of launch, and all three inside the first month. That has been the pulse of 2026 for me. The failures hit fast, and each time, we turned them into a stronger engine.

If you are building memory architectures, wrestling with multi-channel fleets, or have watched your own agents swear they never did something they did five minutes ago, drop me a note at [email protected]. I read these myself, and a few of the ideas on our roadmap started as someone else’s war story.

Common questions

What is Meaning Memory?

Meaning Memory is a persistent memory layer for AI agent fleets. It stores four types of memory (semantic, episodic, procedural, and commitment), scores each entry across five STARE 5D dimensions (Significance, Temporal, Asymmetry, Relational, Episodic), and links every entry to its source. It is a licensed, self-hosted engine that runs inside the customer’s own infrastructure and works with agent frameworks such as OpenClaw and Hermes, and with tools such as Claude and Cursor, through an MCP server and SDK.

What is Throughline in Meaning Memory?

Throughline is Meaning Memory’s cross-channel working memory. It captures what an agent says and does in chat sessions, scheduled jobs, and inter-agent messages into a shared working tier that any other session can search, promotes significant entries to long-term memory each night, and lets the rest expire after 72 hours. Outbound messages now become searchable from other sessions in about 73 seconds.

Why would an AI agent deny doing something it actually did?

Usually because it searched its memory at a moment when the record did not exist yet, or existed in a form that did not mention the action, and then treated the empty result as proof. In our production testing the agent’s search worked correctly; capture and recall were not aligned in time or in content. The fix is to capture actions as structured records when they happen, and to treat an empty search result as “no record found”, never as “no”.

What is the difference between static agent memory and working memory?

Static agent memory is a file loaded at the start of each session and refreshed periodically (in our case, nightly), so an agent cannot see what it did in another conversation earlier the same day. Working memory is a shared, short-lived tier that captures activity from every channel within seconds to minutes and makes it searchable from all of them, with a nightly pass that decides what becomes long-term memory.

Can a memory system store a false fact about its own agent?

Yes. If consolidation treats an agent’s own words as authoritative, a confident false denial can be promoted into long-term memory as if it were true. We saw this happen once and contained it. The durable fix is to keep a raw archive of what actually happened, separate from what the agent said about it, and to check claims against that archive.