Why Your AI Agent Forgets, and What to Do About It
Most people meet an AI agent the same way every morning. They open a fresh chat, re-explain who they are, paste in the context, and start over. The agent is capable, but it does not know you. It has no memory of yesterday’s decision, last week’s client call, or the preference you stated three times.
In the latest episode of our Agentic AI podcast, Gavin Franklin and Tim Harting open a four-part series on the agentic operating system by tackling the part almost everyone skips: the layer underneath the chat. Not the model. Not the prompt. The plumbing that turns a firehose of raw information into something an agent can actually use six months from now.
They call it the signal layer, and it is the difference between a clever assistant and a system that runs your work.
The short version
- A signal is a change, not a document. A deal moves stages, a decision lands in a thread, an email shifts a priority. You are not asking the agent to swallow your inbox, only to catch the moments that change the picture.
- Storing is easy. Sorting is the whole game. Collect signals into one growing file and by month three it is a landfill the agent has to dig through.
- Four tiers, decided on arrival. Transient observation, durable facts, project layer, archive. An agent that keeps everything is as useless as one that keeps nothing.
- The human owns intent. The agent owns the execution picture. That division is also the answer to the human-in-the-loop question.
- The real test is at six months. Anything demos well on day one. Treat every wrong answer as a bug and fix the source, not the output.
A signal is a change, not a document
Start with the word itself. A signal is not a file or a folder. It is a change in a source system that the agent needs to recognize. A deal moves stages in Salesforce. A decision lands in a Slack thread. An email arrives that shifts a priority. Each one is a state change, a move from what was true to what is true now.
That reframing matters because it tells the agent what to look for. You are not asking it to swallow every message in your inbox. You are asking it to catch the moments that change the picture.
Three ways to pull a signal
Once you define signals as changes worth catching, the next question is how the agent catches them. Gavin and Tim describe three:
Structured skills
A reusable capability, not a one-off query.
Hover for detail
Structured skills
Defined, repeatable ways for the agent to reach into a system and pull exactly what it needs.
On-demand
Gathered live, in the moment.
Hover for detail
On-demand
Information pulled while you are working with the agent and a question comes up.
Scheduled runs
A nightly pass that updates the picture while you sleep.
Hover for detail
Scheduled runs
Routine syncs that keep the agent current on their own, so the agent starts the day already caught up and you never re-brief it.
Most real systems use all three. The live path answers your questions now. The scheduled path makes sure you never have to re-brief the agent in the morning.
Storing is easy. Sorting is the whole game.
Here is where most agent setups quietly fail. They collect signals and dump them into one growing file. It works for a week. By month three it is a landfill, and the agent spends more effort digging than deciding.
The fix is to sort every signal into a tier the moment it arrives. Gavin and Tim use four:
Transient observation. Short-term context tied to the task in front of you. Roughly half of everything coming in belongs here, and half of that is meant to be forgotten once the task is done. Discarding is a feature, not a failure.
Durable facts. Long-lived truths about you, your preferences, your systems, the way you work. These are worth keeping indefinitely.
Project layer. Information tied to a specific, time-bound effort, like a client engagement or a launch. It matters intensely for now and gets archived when the project closes.
Archive. Stale or completed information moved out of the active picture but still reachable when you need it.
The point is not the labels. It is the discipline of deciding, every time, what deserves to be remembered and for how long.
“An agent that keeps everything is as useless as one that keeps nothing.”
Gavin Franklin and Tim Harting, Agentic AI podcast
The Common Operating Picture
To keep the human and the agent looking at the same reality, the team borrows an idea from the military: the Common Operating Picture, or COP. In a command center, everyone works from one shared, current view of the situation. No one is acting on a version of the map that is three hours old.
An agentic COP does the same thing for your work. It holds the current state of a project or an area in one place, organized with the PARA method, projects, areas, resources, and archives. And it draws a clean line down the middle of who owns what:
- The human owns the intent. Mission, end state, and the critical tasks that define success. The agent does not get to decide where you are going.
- The agent owns the execution picture. Conclusions, recommendations, and status updates, generated from the signals it is tracking, always inside the guardrails you set.
That division is also the answer to the human-in-the-loop question. You do not choose between micromanaging every step and turning the agent loose. You let it run freely on the parts it owns, and you keep your hands on the parts that set direction.
The real test is at six months
The through-line of the whole conversation is discipline, and Tim frames the test bluntly. The measure of an agentic operating system is not how impressive it looks in week one. Anything demos well on day one. The measure is whether it is still useful, still accurate, still trusted after six months of accumulated data.
Getting there takes one habit above all: treat every wrong answer as a bug. When the agent gets something wrong, the lazy move is to correct it by hand and move on. The disciplined move is to ask why the system produced the wrong answer, then fix the source, the prompt, the memory, the logic, so the mistake cannot happen again.
The mechanism they use for this is a running session scratch, a log where the agent records its actions, the gaps where information was missing, the patterns it notices repeating, and the friction points that slow work down. A weekly review of that log turns a static tool into a system that improves itself.
Build the operating system, then run apps on it
The last reframing is the one that ties it together. Stop thinking about individual AI tricks and start thinking in layers. Build a foundation that manages signals and memory well, and specific skills become applications that run on top of it, predictably, because the ground underneath them is solid.
That is the whole argument for treating this as an operating system rather than a collection of prompts. Get the signal layer right and everything you build on it inherits the discipline. This was part one of the series. It continues from here.
Watch AAI Episode 062 on YouTube.
Ready to build your own agentic operating system?
At Cirrius Solutions, this is not theory. It is how we build the agentic systems we run internally and deliver for our customers. If you want to talk about standing up an agentic operating system in your own organization, reach out to our team.
