Memory types, and why agents forget
Most agent failures come from memory gaps. Here is how to fix them.
Do agents forget things?
Yes, it happens.
More often than people expect.
Some people think the model is broken.
Others blame the tools.
Some assume the agent should remember everything by default.
That is not how it works.
Agents forget for very specific reasons.
And most people do not realise how many types of memory an agent can have.
If you started here, you may have missed the earlier episodes:
What an AI agent actually is
The agent thinking loop explained in simple language
How to give an agent a goal it can actually follow
You may want to read those first.
They give the foundation you need.
In this episode, we focus on memory.
Why agents forget.
The types of memory they use.
And how you can design memory so the agent stops losing track of the task.
By the end of this, you will understand the main memory types, when to use each one, and how memory shapes the behaviour of the entire agent loop.
This is it.
Let’s get into it.
Why memory matters
Memory is what stops an agent from repeating mistakes.
It helps the agent understand context.
It keeps the loop stable.
It stops the agent from starting from zero every time.
Without memory, even a good agent will behave strangely.
It will lose steps.
Lose instructions.
Lose progress.
Understanding memory is one of the fastest ways to improve your agent.
The three types of memory
There are three main types you will work with:
Short-term memory
Long-term memory
Functional memory
Each one has a different purpose.
Each one solves a different problem.
Let’s break them down.
1. Short term memory
This is the memory inside the loop.
It only lasts for the current cycle.
It includes:
• the observation
• the thought
• the action result
• the reflection
The agent uses this memory only for the current pass through the loop.
Once it moves on, most of this disappears unless you store it.
Short-term memory helps the agent decide the next step.
But it does not help the agent remember what happened ten steps ago.
This is why long tasks break without long-term memory.
2. Long term memory
This is the memory the agent can return to later.
It survives across loops.
It survives across sessions.
It might be stored in:
• a vector database
• a structured file
• a notes system
• a memory log
• a knowledge base
The agent uses long-term memory to:
• remember past steps
• carry insights into future tasks
• store important information
• keep track of goals and subgoals
• avoid repeating old mistakes
Agents with good long-term memory feel stable.
Agents without it feel confused and scattered.
3. Functional memory
This is the memory inside specific tools.
It is not part of the model.
It is not part of the loop.
It is inside the action itself.
Examples:
• a tool that saves previous API calls
• a tool that tracks file edits
• a tool that collects user preferences
• a tool that stores conversation turns
Functional memory makes tools smarter without touching the agent’s core memory.
It is useful for:
• tracking progress
• remembering previous tool actions
• improving tool accuracy
• reducing repeated work
Functional memory is the hidden engine behind many advanced agent systems.
Why agents forget
Agents forget when:
• the short-term memory is not passed forward
• long-term memory is not stored
• the agent is not instructed to recall memory before acting
• the memory is saved in the wrong format
• the memory is too large to fit back into the loop
• the system has no rules for what to remember and what to ignore
Forgetting is not a bug.
It is a design issue.
Fix the memory design, and the agent becomes reliable.
A simple example
Goal: plan a three step project outline.
Short-term memory:
Each step the agent decides.
Long-term memory:
Stores the full outline so the agent does not lose earlier steps.
Functional memory:
A planning tool might keep track of previous drafts.
If any of these memory layers are missing, the outline will drift or collapse.
How to use this today
Before you build or test an agent, ask:
• What should the agent remember
• How long should it remember it
• Where should this memory live
• Does the memory help the loop
• Is this short-term, long-term or functional
A clear memory plan strengthens the agent’s behaviour more than most people expect.
Save this.
Good memory design is one of the core skills in agent building.
Up Next
Tools, and how agents use them to act
In the next episode in this series, you will learn how tools give agents the ability to take action, why tools matter more than model size, and how to pick the right tools for your system.
Tip: Find this helpful? Subscribe to get new episodes automatically.