Memory & RAG

~8 min readUpdated: October 2026

The Four Types of Agent Memory (And How to Make an Agent That Learns)

The four types of agent memory — persistent memory architecture in Smoke Monkey

An agent without memory starts from zero every session, repeating mistakes and relearning your codebase. The fix is a memory architecture, and the clearest model comes from cognitive science: **working**, **procedural**, **episodic**, and **semantic** memory. This guide explains each type, how they map onto an agent runtime, and how [Smoke Monkey Harness](/solutions/what-is-an-ai-agent-harness) persists them while **Smoke Monkey Canvas** lets you inspect what your agents have learned.

Technical Review: Smoke Monkey Core Architecture Team

|Tested on Node.js 18+ & Bun|TypeScript 5.x

Quick Answer & Executive Definition

The Four Types of Agent Memory (And How to Make an Agent That Learns): An agent without memory starts from zero every session, repeating mistakes and relearning your codebase. The fix is a memory architecture, and the clearest model comes from cognitive science: **working**, **procedural**, **episodic**, and **semantic** memory. This guide explains each type, how they map onto an agent runtime, and how [Smoke Monkey Harness](/solutions/what-is-an-ai-agent-harness) persists them while **Smoke Monkey Canvas** lets you inspect what your agents have learned. Designed as a zero-dependency, open-source TypeScript architecture under the MIT License with native Model Context Protocol (MCP) support and deterministic phase state machines.

Key Architectural Takeaways

Working memory is the context window; the other three types live outside it and must be persisted deliberately.
Procedural memory is "how" (skills and tools), semantic is "what" (facts), episodic is "when" (past runs).
Smoke Monkey Harness persists memory across sessions and isolates tasks in subcontexts.
Smoke Monkey Canvas makes memories visible, so you can inspect and correct what an agent has learned.

Quick Implementation Exampleagent-memory.ts

agent-memory.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3// Memory that persists across sessions: semantic + episodic + procedural
4const agent = createAgent({
5  provider: 'anthropic',
6  model: 'claude-sonnet-5',
7  workspacePath: process.cwd(),
8  memory: {
9    semantic: { store: './.agent/memory/facts.json', retrieve: 'embeddings' },
10    episodic: { store: './.agent/memory/runs.jsonl' },
11    procedural: { skills: ['./.agent/skills'] },
12  },
13  context: { maxTokens: 120000, compaction: { threshold: 0.75 } },
14});
15
16await agent.run('Continue the migration you started last session and recall prior decisions');

Video Guides

Watch: Related Video Guides

Anthropic Just Built an Agentic OS — Open Source Harness Breakdown

Smoke Monkey

The Four Types of Memory Every AI Agent Needs

IBM Technology

Working Memory Is the Context Window

The agent's working memory is the context window: what it can see right now. It is fast and immediate, and it is also the most fragile — overflow it and the earliest messages, including your original goal, fall out. This is why context window management is the foundation of any memory design: compaction and subcontexts keep working memory coherent so the other three memory types have something stable to build on. Smoke Monkey Harness manages working memory automatically, and Smoke Monkey Canvas shows its live size per agent.

A bigger window is not memory

Throwing tokens at the problem just delays overflow and inflates cost. Real memory lives outside the window and is loaded selectively.

Episodic and Semantic Memory

Episodic memory is the record of what happened: which runs, which decisions, which failures and fixes. Semantic memory is durable facts: your architecture, conventions, and domain rules. Together they answer "have we been here before?" and "what is true about this system?" In practice that means an append-only run log plus a retrieval store over your code and docs. Smoke Monkey persists both to disk, so a new session starts with context rather than amnesia, and it retrieves only the relevant slice instead of dumping everything into the window. Smoke Monkey Canvas surfaces which memories an agent loaded on each run.

episodic-semantic.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3const agent = createAgent({
4  provider: 'anthropic',
5  model: 'claude-sonnet-5',
6  workspacePath: process.cwd(),
7  memory: {
8    // semantic: durable facts retrieved by similarity
9    semantic: { store: './.agent/facts.json', retrieve: 'embeddings', topK: 8 },
10    // episodic: an append-only record of past runs and decisions
11    episodic: { store: './.agent/runs.jsonl', summarize: true },
12  },
13});
14
15// This run can recall decisions from previous sessions
16await agent.run('Apply the same auth pattern we standardized on last week');

Procedural Memory and Making an Agent Learn

Procedural memory is *how* to do things: a skill, a reusable tool, a refined prompt for a recurring task. This is where an agent that merely recalls becomes an agent that improves. When a workflow succeeds, capture it as a stored skill; next time, the agent invokes it instead of rediscovering the steps. In Smoke Monkey, procedural knowledge lives as tools and skill files the runtime loads, and the deterministic state machine makes those skills reproducible. Combine it with context compaction so learned procedures survive long sessions and knowledge-base retrieval for project facts. Review and curate learned skills per agent on Smoke Monkey Canvas before they spread.

learning-loop.tstypescript

1import { createAgent, defineTool } from 'smoke-monkey-harness';
2
3// Procedural memory: capture a successful workflow as a reusable skill
4const deploySkill = defineTool({
5  name: 'deploy_checklist',
6  description: 'Run the team\'s proven pre-deploy checklist',
7  parameters: { type: 'object', properties: { service: { type: 'string' } } },
8  handler: async ({ service }) => runChecklist(service),
9});
10
11const agent = createAgent({
12  provider: 'anthropic',
13  model: 'claude-sonnet-5',
14  workspacePath: process.cwd(),
15  tools: [deploySkill],          // learned procedure, reused every run
16  memory: { episodic: { store: './.agent/runs.jsonl' } },
17});

Inspecting Memory on the Canvas

Memory you cannot see is memory you cannot trust. Smoke Monkey Canvas (npx @smoke-monkey/canvas start) makes an agent's memory a visible part of the workspace: each card shows what the agent currently recalls, which past runs it drew on, and which skills it loaded. That transparency is how you catch a wrong "fact" before it spreads across a fleet. With 300+ MCP tools, Canvas also lets you route memory operations — read, write, forget — through the same permission gates as any other action. Related reading: subcontext memory architecture and agent knowledge base. All four memory types are persisted by Smoke Monkey Harness and rendered by Smoke Monkey Canvas.

Google Search Questions & Answers

Frequently Asked Questions

Q:What are the four types of agent memory?

Working memory (the context window), episodic memory (the record of past runs and decisions), semantic memory (durable facts about the system), and procedural memory (reusable skills and how-to knowledge). Effective agents combine all four.

Q:How does Smoke Monkey Harness persist agent memory?

You configure semantic and episodic stores plus a skills directory in `createAgent()`. The runtime writes and retrieves them to disk, so a new session starts with relevant context instead of a blank slate.

Q:What is the difference between RAG and agent memory?

RAG retrieves documents for a single answer; agent memory persists experience and facts across many sessions and tasks. Smoke Monkey supports both, and routes retrieval through MCP tools.

Q:Can I inspect what an agent has learned?

Yes. Smoke Monkey Canvas renders each agent's recalled facts, past runs, and loaded skills on its card, so you can verify and correct memory before it propagates across a fleet.

MCP Server Security Best Practices: Hardening Model Context Protocol Agents in 2026

Read Guide

Open Source

Open Source Coding Agent Harness: Build a Forkable, Local AI Engineering Runtime

Read Guide

Build with Smoke Monkey Harness

Zero dependencies. 24 built-in tools. Human-in-the-loop safety. 100% open source under the MIT License.

npm install smoke-monkey-harness