Blog

AI Agents

The Two Types of Agent Memory

Explore the two types of agent memory, how they work, and why they matter for building smarter, more reliable AI agents.

AI AGENTS

February 5, 2026

3 min

Michel Tricot

Summarize with AI:

Teams building agents run into the same problem: memory. The agent feels sharp in a single session, then the user comes back, and it forgets everything. Or the opposite happens. Teams store every conversation forever, and retrieval slows to a crawl while relevance disappears.

Both failure modes stem from the same mistake: treating memory as a single undifferentiated blob.

Teams struggle with memory because they keep building like it's 2022, when context windows were tiny and every token counted. That playbook is obsolete.

Production agents need memory that works like human memory. Immediate recall for the current conversation. Persistent knowledge that carries across sessions. And the ability to compress and forget so the system doesn't collapse under its own weight.

Why Agents Need Memory At All

Context is everything not encoded in the LLM. Without it, you're tied to what the model was trained on.

Memory is how you preserve context across time. Without it, every conversation feels like the first conversation. The agent asks your name every time, and it doesn't remember your preferences.

Users don't trust systems that forget.

Type One: Session Memory

Session memory holds everything about the current interaction. The full message history, tool calls the agent made, intermediate reasoning steps, and any temporary context assembled for this specific task.

Because it supports live reasoning, session memory must stay high-fidelity. Exact wording, order, and nuance. All of that matters. If a user says “the invoice I mentioned earlier,” the agent needs to resolve that reference precisely, without guessing or losing context.

Session memory is also temporary. It expires when the session ends. What persists is not the transcript itself, but what the conversation taught the system. That knowledge is extracted through summarization and compression, then stored in persistent memory.

This makes the session boundary critical. A session might be a single support ticket, a short conversation about a customer issue, or a multi-step task that unfolds over an hour. Once the user closes the tab or the task completes, the session ends. At that point, everything in session memory becomes a candidate for compression.

Type Two: Long-Term Memory

Long-term memory is what survives beyond a single session. It captures information the agent should know without being told again. This includes user preferences, learned facts about users and entities, and the relationships between those entities. It also stores past decisions and their outcomes.

This layer has to be retrievable. When a new session starts, the agent pulls relevant long-term memory back into context, and loads only what matters for the current task.

It also has to be updateable. Long-term memory needs to evolve as a persistent knowledge base that grows and refines continuously. It's not a write-once archive.

The difference between remembering a conversation and learning from a conversation matters here. You store the insight, not the transcript. “Joe prefers technical depth in answers,” not “On March 15th at 2:43 pm, Joe said he prefers detailed explanations.”

The Unbounded Growth Problem

The naive approach to long-term memory is to append everything. Each session gets summarized and added to the knowledge base, with little consideration for how that information will be used later.

Over time, this creates compounding problems. Retrieval breaks at scale. When you have ten memories, finding the right one is easy. When you have ten thousand, relevance ranking becomes hard. The signal-to-noise ratio drops, and the agent increasingly retrieves irrelevant context.

Without filtering, memory stops providing clarity, and context becomes noise. The agent sees more information, but understands less. The key to effective agentic systems is not to store everything, but to assemble what's relevant in the moment an agent needs it. That assembly is the job of a dedicated context layer for ai agents that sits between your raw sources and the model and serves only what each task requires.

Summarization As Compression

Summarization is the control mechanism that prevents long-term memory from growing without bound.It acts as a compression function that converts verbose session histories into retrievable facts.

When a session ends, summarization reviews what happened and extracts what matters for future interactions. The goal is to preserve knowledge that will remain useful later.

A support conversation might span fifty messages yet reduce to three durable facts: “User reported latency issues with Salesforce connector. Root cause was rate limiting. Issue resolved by adjusting sync frequency.” That distilled record is what belongs in long-term memory.

The tradeoff is between fidelity and retrievability. You lose exact wording and conversational nuance, but gain the ability to find this information six months later when it's relevant again.

What should you summarize versus preserve verbatim?

Summarize verbose back-and-forth conversations where the conclusion is clear and can be distilled into actionable insights. Compress intermediate reasoning that led to a decision but preserve the final conclusion. Condense context that was assembled for one task but might inform future ones.

Some information, however, should never be compressed. Explicit user preferences should be preserved verbatim. Factual corrections must remain exactly as stated. Decisions that depend on specific reasoning should be kept intact, not paraphrased.

How Memory Types and Summarization Interact

A user starts a new session. The agent retrieves relevant long-term memory and loads it into session context. As the conversation progresses, session memory accumulates. The agent makes tool calls, retrieves data, and reasons through the task.

When the session ends, a summarization function extracts persistent insights from the high-fidelity session memory and compresses them into structured knowledge that gets stored in long-term memory.

The key is knowing when to promote information from session to long-term memory. Not everything should persist. Temporary context assembled for one task doesn't need to live forever. But learned preferences, entity relationships, and outcome patterns do.

Practical Architecture Patterns

The architecture challenge is knowing what to optimize for.

Session memory needs speed. Long-term memory needs both semantic search for finding relevant past experiences and structured storage for facts that shouldn't degrade. Most teams try to force one storage pattern to handle both and wonder why retrieval degrades over time.

The hardest question isn't how to store memories, but when to let them go.

Without explicit eviction policies, you end up with unbounded growth. With too-aggressive policies, you lose context that matters. Most teams don’t get this right upfront. They tune it over time by watching retrieval quality degrade or improve in production.

The best approach depends on your usage patterns.

You'll know your memory architecture is working when retrieval stays fast as you scale and when the agent consistently surfaces relevant context without hallucinating facts. It’s failing when query latency increases over time, relevant information gets buried as memory grows, or users report that the agent forgot something important.

Getting This Right

Memory architecture is what makes the difference between agents that feel intelligent and agents that feel like they’re meeting you for the first time every session.

‍

Without deliberate architecture, agents either forget everything between interactions or accumulate so much history that relevant context gets buried.

Both failure modes destroy trust.

We don't have perfect answers yet, but the framework is clear enough to start building:

Two types of memory with clear boundaries between them
Compression strategies that balance fidelity and retrievability

The shift is from "dump everything in a vector database" to deliberately architecting what persists, what compresses, and what expires. Treat memory as a blob, and the system will collapse under its own history. Treat it as an architecture, and the agent earns trust.

Most teams won't get this right on the first try. Those shipping production agents are the ones who accept this and rebuild anyway.

Users already expect agents to remember. If we meet that expectation now, we’ll define the baseline everyone else has to catch up to.

Subscribe to Agent Blueprint to learn more about agentic data infrastructure.