Agent memory types are the four kinds of memory an AI agent draws on to do its work: short-term memory holds the current conversation, long-term memory keeps facts across sessions, episodic memory records what happened before, and semantic memory supplies general knowledge. Each type does a different job, lasts a different length of time, and lives in a different place.
TL;DR: AI agents use four memory types. Short-term is the live conversation, long-term keeps facts between sessions, episodic remembers past events, and semantic holds general knowledge. Taskade stores an agent's long-term memory as real workspace projects you can read and edit, not a hidden black box. Build an agent that remembers free.
You already sort memory this way without naming it. The sticky note on your monitor is short-term: it matters today and you toss it tomorrow. Your customer list is long-term: it keeps a contact's history for years. The story you tell about last quarter's launch is episodic. What you know about how invoices work in general is semantic. An agent needs all four, for the same reasons you do.
Why Agent Memory Types Matter in 2026
The reason one AI assistant forgets who you are between chats, and another remembers your whole account history, comes down to which memory types it has. A language model on its own has only short-term memory: the words inside its current context window. Close the tab and that memory is gone, because the model itself is stateless and starts every request from zero.
That gap stopped mattering as a curiosity and started mattering as a product problem once agents began running for hours instead of seconds. An agent that handles a support queue, files expenses, or ships code across many steps cannot re-learn your business on every turn. It needs long-term memory to keep the facts, episodic memory to recall what it already tried, and semantic memory to reason with general knowledge. The four types together are the difference between a demo that impresses once and a teammate you can rely on the next morning. This taxonomy has a long pedigree: psychologist Endel Tulving drew the line between episodic and semantic memory in his 1972 chapter "Episodic and Semantic Memory," and agent designers borrow the same map today.
How the Four Memory Types Work Together
The four types are not rivals. They run in one loop, and most of the agent loop is memory moving between them. Short-term memory holds the live turn, semantic and episodic memory feed context into the agent's reasoning, and anything worth keeping gets written to a long-term store the agent can read back next time.
- Short-term memory takes in your message and holds the running thread of the current session. It is fast and free, but it disappears when the session ends.
- Semantic memory supplies the general knowledge the model already carries, its parametric knowledge from training, plus any facts you taught it about your domain.
- Episodic memory hands back specific past events: the ticket it resolved last week, the plan it tried and abandoned, so it does not repeat itself.
- The agent reasons over all three, decides, and answers.
- Long-term memory is where the agent writes anything worth keeping, so the next session starts warm instead of cold. When short-term memory fills up, context compaction summarizes the older turns into this store rather than dropping them.
The Four Types of Agent Memory
Here is the whole taxonomy in one place. Each type is defined by three things: how long it lasts, where it physically lives, and the job it is best at.
| Memory type | How long it lasts | Where it lives | Best for |
|---|---|---|---|
| Short-term (working) | This conversation only | The model's context window | Following the thread of a live task |
| Long-term | Across sessions, indefinitely | An external store or vector database | Remembering the customer, the policy, your preferences |
| Episodic | Kept as dated events | The same store, timestamped | Recalling what happened last time and not repeating it |
| Semantic | Built in, plus what you teach it | Model training plus your knowledge base | General facts and how your business works |
Two of these lean on retrieval. Long-term and episodic memory are usually stored as embeddings so the agent can search them by meaning and pull only the relevant pieces into short-term memory, the pattern called retrieval-augmented generation. Semantic memory splits in two: the general half is baked into the model and bounded by its knowledge cutoff, while the business-specific half is knowledge you supply.
Short-Term vs Long-Term Memory
The pair people confuse most is short-term versus long-term, because both just sound like "memory." The real split is simple: short-term memory is what the agent is holding right now, and long-term memory is what it can get back after the conversation ends.
| Trait | Short-term memory | Long-term memory |
|---|---|---|
| Scope | One conversation | Every conversation |
| Survives a new session? | No | Yes |
| Storage | The context window | An external store |
| Practical size | Bounded by the context window | Effectively unbounded |
| Fails by | Context rot, running out of room | Retrieving the wrong fact |
| Fix when strained | Context compaction | Better search over embeddings |
Episodic and semantic memory are both kinds of long-term memory, sorted by what they hold. Episodic is a record of events ("on Tuesday the customer asked for a refund"). Semantic is timeless fact ("refunds take five business days"). That is exactly Tulving's 1972 distinction, applied to software instead of the human mind.
Connection to Taskade
Taskade makes an agent's long-term and episodic memory something you can actually see. Instead of a hidden vector store, an agent's memory lives as real Projects in your workspace: every remembered fact and past event is a task or note you can open, edit, or delete. Short-term memory is the live chat with the agent. Semantic memory comes from two sources: the 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers that Taskade routes to automatically, and the knowledge you connect from your own projects and documents.
Because the store is your workspace, the same memory an agent builds is available to your automations and to the other agents on the team. When one agent learns something, the workspace keeps it, and the next run starts from there. That loop, memory feeding intelligence feeding execution and back again, is the reason a Taskade agent gets more useful the longer it works with you rather than resetting every morning.
What You Would Build in Taskade
Picture a client concierge agent for your business. On the first call it has only semantic memory: it knows how your service works in general because you taught it. As it talks with a client, short-term memory tracks the conversation. When the call ends, it writes the important parts to long-term memory: this client prefers email, their renewal is in March, they had a billing question last month. That last item is episodic, a dated event it can recall by name.
Two weeks later the client writes back. The agent opens the same project, reads its own notes, and picks up mid-relationship instead of asking who they are. You never wired a database or chose a memory system. You described the concierge, and the four memory types fell into place behind it. You already keep these threads in your head and your inbox. The app just keeps them for you and acts on them. Describe yours and build it free →
Related Concepts
- Agent Memory: the full deep dive on how agents remember and learn
- Persistent Memory: the capability that makes memory survive across sessions
- Agent Knowledge Memory: teaching an agent your own data
- Agent Session: the boundary short-term memory lives inside
- Stateless vs Stateful: why a raw model forgets by default
- Context Compaction: how short-term memory makes room without losing the thread
- Context Window: the size limit on short-term memory
- History of Agent Memory: why AI kept forgetting you, and how that changed
Frequently Asked Questions About Agent Memory Types
What are the four types of agent memory?
The four types are short-term, long-term, episodic, and semantic. Short-term memory holds the current conversation, long-term memory keeps facts across sessions, episodic memory records past events like "the customer asked for a refund last week," and semantic memory supplies general knowledge and how your business works.
What is the difference between short-term and long-term memory in AI?
Short-term memory is what an AI agent holds during one conversation, inside its context window. It vanishes when the session ends. Long-term memory is stored outside the model, so the agent can recall a fact days or months later. Short-term is fast and small; long-term is durable and effectively unbounded.
What is episodic memory in an AI agent?
Episodic memory is an agent's record of specific past events, tied to when they happened: the ticket it closed on Tuesday, the plan it tried and dropped, the question a customer asked last month. It lets the agent recall what it already did so it does not repeat work. The term comes from psychologist Endel Tulving's 1972 distinction between event memory and fact memory.
What is semantic memory in an AI agent?
Semantic memory is timeless general knowledge, the facts and concepts an agent reasons with. Half of it is parametric knowledge baked into the model during training. The other half is the domain knowledge you supply, such as your policies and product details connected as agent knowledge.
Where do AI agents store long-term memory?
Long-term memory lives in an external store, usually a database or a vector database, so it survives after a session ends. Agents often save memories as embeddings and search them by meaning. In Taskade, an agent's long-term memory is stored as real Projects in your workspace that you can read and edit.
Do AI agents remember between sessions?
Only if they have long-term memory. A raw language model is stateless and forgets everything when the session ends. An agent remembers across sessions by writing facts and events to a long-term store and reading them back the next time. That storage layer, not the model, is what makes an agent feel continuous.
How does Taskade give agents memory?
Taskade stores each agent's long-term and episodic memory as Projects in your workspace, so every remembered fact is visible and editable. Short-term memory is the live chat, and semantic memory comes from 15+ frontier models plus the knowledge you connect. The same memory is shared with your automations and other agents. Build one free →