The 5 Types of AI Agent Memory Every TypeScript Developer Should Know

Most developers try to fix AI agents with better prompts.

In practice, most agent problems are memory problems.

The agent forgets context. It repeats the same mistake. It uses outdated information. It cannot connect past actions to current decisions. Or it behaves inconsistently across sessions.

That is not a model issue. That is a memory design issue.

In real systems, memory is not one thing. It is a combination of different layers, each solving a different problem. Once you understand this, your agent design becomes much simpler and much more reliable.

Here are the five types of memory I would use in a TypeScript AI agent in 2026.

1. Short-term memory keeps the current task coherent

Short-term memory is what the agent knows right now.

It includes the current goal, recent steps, tool outputs, and intermediate results. Without it, the agent loses track of what it is doing within a single run.

Most “looping” or “confused” agent behavior comes from weak short-term memory. The model simply does not have a clear picture of what already happened.

In TypeScript, this is usually just part of your runtime state.

type AgentState = {
  goal: string;
  steps: Array<{
    name: string;
    input: unknown;
    output?: unknown;
  }>;
};

This does not need to be complicated. The important part is that every step is recorded and passed back into the next decision.
Use short-term memory when:
The agent needs to track progress within a task
Tool outputs influence the next step
You want to prevent repeated or redundant actions
If your agent keeps repeating the same tool call, this is the first place to look.

2. Semantic memory stores reusable facts

Semantic memory is long-term knowledge that does not change frequently.
This includes things like user preferences, account details, product configurations, or domain knowledge that the agent should remember across sessions.
For example:
A user prefers morning flights
A customer is on an enterprise plan
A project uses React and PostgreSQL
This type of memory is usually stored in a database or a vector store and retrieved based on relevance.

type SemanticMemory = {
  userId: string;
  key: string;
  value: string;
};

The key idea is selective retrieval. You do not want to send all stored knowledge to the model. You only want to retrieve what is relevant to the current goal.
Use semantic memory when:
The agent needs to remember user preferences
Context should persist across sessions
Decisions depend on stable facts
If your agent feels “stateless” across sessions, this is what is missing.

3. Episodic memory remembers past actions

Episodic memory is about what happened before.
This includes past agent runs, previous decisions, failures, retries, and outcomes. It is different from semantic memory because it captures events, not facts.
For example:
The agent already created a support ticket yesterday
A payment sync failed earlier and should not be retried immediately
A previous request was escalated to a human

type EpisodicMemory = {
  event: string;
  result: string;
  timestamp: string;
};

This type of memory is useful for preventing repeated mistakes and improving consistency over time.
Use episodic memory when:
You want to avoid repeating the same action
The agent needs awareness of past outcomes
Decisions depend on historical behavior
If your agent keeps retrying something that already failed, it likely lacks episodic memory.

4. Procedural memory stores how things should be done

Procedural memory is often overlooked, but it is one of the most important types.
This is not data. This is behavior.
It defines how the agent should perform tasks, what steps to follow, what rules to enforce, and what constraints to respect.
In practice, this lives in prompts, system instructions, or structured workflows.
For example:
Always validate tool input before execution
Ask for approval before sending emails
Prefer cheaper tools unless confidence is low
Stop after a fixed number of steps

const agentRules = [
  "Validate all tool inputs",
  "Do not call high-risk tools without approval",
  "Stop after 5 steps if no progress is made"
];

Use procedural memory when:
You want consistent behavior across runs
You need to enforce business rules
You want to reduce unpredictable decisions
If your agent behaves differently for similar inputs, this is usually the missing piece.

5. Audit memory records what happened

Audit memory is not used by the model directly. It is used by developers, systems, and compliance processes.
This includes logs, traces, step history, tool calls, and decision paths.

type AuditLog = {
  runId: string;
  step: string;
  input?: unknown;
  output?: unknown;
  timestamp: string;
};

This is what allows you to answer questions like:
Why did the agent choose this tool?
What input did it send?
What did the tool return?
Why did the agent stop?
Use audit memory when:
You need debugging visibility
You want to evaluate agent behavior
You have compliance or audit requirements
If you cannot explain why your agent made a decision, you are missing audit memory.

How these memory types work together

These memory types are not independent. They work together in a layered way.
Short-term memory drives the current task.
Semantic memory provides relevant facts.
Episodic memory gives historical awareness.
Procedural memory enforces behavior.
Audit memory records everything for inspection.
Most production issues happen when one of these layers is missing.
Too much focus on prompts without memory leads to inconsistent behavior.
Too much memory without structure leads to noise and confusion.
The goal is balance.

A simple mental model

If I had to simplify everything into one idea, it would be this:
Short-term memory answers: What is happening right now?
Semantic memory answers: What do we know?
Episodic memory answers: What happened before?
Procedural memory answers: How should we act?
Audit memory answers: What actually happened?
Once you design your agent with these questions in mind, most problems become easier to reason about.

The real takeaway

Most developers try to make agents smarter by improving prompts or switching models.
In real systems, the biggest improvements come from better memory design.
When memory is structured correctly, the agent becomes more consistent, more reliable, and easier to debug. It stops repeating mistakes. It adapts to users. It follows rules. And most importantly, it becomes predictable.
That is what turns an AI agent from a demo into a system you can actually trust.