Soul Memory Architecture: Episodic, Semantic, Procedural

OpenClaw splits a Soul's memory into three stores that act differently. Knowing what goes where is the difference between an agent that remembers you and one that pretends to.

11 min · Reviewed 2026

Three memories, one Soul

OpenClaw's memory model maps to a distinction cognitive scientists have been making for decades, and that Letta, MemGPT, and Open Souls all reach for in their own vocabulary. A Soul has three memory layers: episodic (what happened), semantic (what's true), and procedural (how it works). Each store has a different write policy, a different recall trigger, and a different retention curve. Conflating them is why so many agent demos look impressive on day one and feel amnesiac on day twenty.

Layer	Holds	Write policy	Recall trigger	Retention
Episodic	Time-stamped events the Soul lived through	Append on every meaningful turn	Vector similarity + recency	Decays unless promoted
Semantic	Stable facts the Soul knows are true	Write on confirmation or correction	Symbolic / keyword lookup	Long-lived, edited not expired
Procedural	How the Soul does specific tasks	Write when a workflow stabilizes	Triggered by task class	Versioned, supersedes old

Episodic — the Soul's diary

Episodic memory is a stream of events: 'Tuesday 3pm: Maya asked Atlas to draft the postmortem for incident-204. Atlas drafted three sections, Maya rewrote the timeline, the doc shipped at 4:15.' Each entry is small, dated, and embedded in a vector store so the runtime can pull semantically related episodes back when relevant input shows up.

Write trigger: end of every meaningful turn — a turn that changed state, learned a fact, or completed a task
Recall trigger: vector similarity to current input, weighted by recency (last 7 days outweigh last 7 months)
Decay: episodes older than N days drop out of recall unless they get promoted to semantic memory
Anti-pattern: storing every chat turn — the store fills with noise, recall starts pulling irrelevant chitchat

Semantic — the Soul's beliefs

Semantic memory is the Soul's stable picture of the world: 'Maya is a senior SRE on the platform team. The Tendril production database is Postgres 16 on RDS. Postmortems ship within 48 hours.' These are facts, not events — they don't get a timestamp, they get edited when wrong.

Write trigger: explicit confirmation ('yes, that's right'), explicit correction ('actually, it's Postgres 16'), or repeated observation across episodes
Recall trigger: keyword / symbolic lookup, often by entity (the Soul recalls 'what I know about Maya' not 'episodes near Maya')
Retention: long-lived; updated in place when superseded, archived when contradicted
Anti-pattern: pushing every episodic detail in here — semantic memory bloats and starts contradicting itself

Procedural — the Soul's muscle memory

Procedural memory is how the Soul does things — the saved workflow for 'draft a postmortem,' the 12-step deploy ritual, the macro for triaging a Sentry alert. Procedural memory is what makes a senior agent feel senior: not that it knows more, but that it has stable ways of working.

Write trigger: a workflow stabilizes — three successful runs of the same task pattern, or an explicit 'save this as a procedure'
Recall trigger: task classification — when current request matches a known task class, load the procedure
Versioning: procedures get version numbers; old versions are kept until the new one ships clean for N runs
Anti-pattern: hardcoding procedures into the system prompt — they balloon the prompt and can't be edited without redeploy

The write-vs-recall imbalance

Most teams over-engineer the recall side and under-engineer the write side. They build elegant vector search, then write everything indiscriminately and choke the store with noise. Recall is mostly solved infrastructure. Write policy is where the Soul earns or loses its memory. Be picky about what goes in.

// A small write-policy helper for an OpenClaw Soul.
// The runtime calls this after every turn; you decide what to keep.

export function decideWrites(turn: Turn, soul: SoulCtx) {
  const writes: MemoryWrite[] = [];

  // Episodic — only if the turn changed state.
  if (turn.toolCalls.length > 0 || turn.factsConfirmed > 0) {
    writes.push({
      store: 'episodic',
      payload: {
        ts: turn.endedAt,
        actor: turn.userId,
        summary: turn.summary,         // 1-2 sentences max
        tags: turn.entities,
      },
    });
  }

  // Semantic — only on confirmed/corrected facts.
  for (const fact of turn.confirmedFacts) {
    writes.push({
      store: 'semantic',
      key: fact.entity + ':' + fact.attribute,
      payload: { value: fact.value, source: turn.id },
    });
  }

  // Procedural — only when a workflow stabilizes.
  if (turn.workflowOutcome === 'stable-third-success') {
    writes.push({
      store: 'procedural',
      payload: {
        taskClass: turn.taskClass,
        steps: turn.steps,
        version: soul.nextProceduralVersion(turn.taskClass),
      },
    });
  }

  return writes;
}Write policy lives in code, not in the model. The model proposes what's worth remembering; this function decides what actually gets persisted.

Apply: classify ten memories

Open a recent agent transcript with at least ten distinct exchanges
For each exchange, decide which memory store should keep it (episodic, semantic, procedural, or nothing)
Tally: if more than ~60% landed in one store, your write policy is unbalanced
Look at the 'nothing' bucket — those are the noise you should keep filtering out
Update your Soul's writePolicy fixture so the next agent run mirrors your manual classification

The big idea: episodic remembers what happened, semantic remembers what's true, procedural remembers how things are done. Three different stores, three different write policies, one Soul that actually feels like it remembers you.

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-openclaw-souls-memory-architecture-creators

What is the core idea behind "Soul Memory Architecture: Episodic, Semantic, Procedural"?
1. OpenClaw splits a Soul's memory into three stores that act differently. Knowing what goes where is the difference between an agent that remembers you and one that pretends to.
2. Define the handoff payload shape for the two new Souls
3. memory consolidation
4. Run the brief past a teammate; ask them to roleplay the Soul.
Which term best describes a foundational idea in "Soul Memory Architecture: Episodic, Semantic, Procedural"?
1. semantic memory
2. episodic memory
3. procedural memory
4. write policy
A learner studying Soul Memory Architecture: Episodic, Semantic, Procedural would need to understand which concept?
1. episodic memory
2. procedural memory
3. semantic memory
4. write policy
Which of these is directly relevant to Soul Memory Architecture: Episodic, Semantic, Procedural?
1. episodic memory
2. semantic memory
3. write policy
4. procedural memory
Which of the following is a key point about Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Write trigger: end of every meaningful turn — a turn that changed state, learned a fact, or complete…
2. Recall trigger: vector similarity to current input, weighted by recency (last 7 days outweigh last 7…
3. Decay: episodes older than N days drop out of recall unless they get promoted to semantic memory
4. Anti-pattern: storing every chat turn — the store fills with noise, recall starts pulling irrelevant…
Which of these does NOT belong in a discussion of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Write trigger: end of every meaningful turn — a turn that changed state, learned a fact, or complete…
2. Recall trigger: vector similarity to current input, weighted by recency (last 7 days outweigh last 7…
3. Decay: episodes older than N days drop out of recall unless they get promoted to semantic memory
4. Define the handoff payload shape for the two new Souls
Which statement is accurate regarding Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Recall trigger: keyword / symbolic lookup, often by entity (the Soul recalls 'what I know about Maya…
2. Retention: long-lived; updated in place when superseded, archived when contradicted
3. Write trigger: explicit confirmation ('yes, that's right'), explicit correction ('actually, it's Pos…
4. Anti-pattern: pushing every episodic detail in here — semantic memory bloats and starts contradictin…
Which of these does NOT belong in a discussion of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Recall trigger: keyword / symbolic lookup, often by entity (the Soul recalls 'what I know about Maya…
2. Write trigger: explicit confirmation ('yes, that's right'), explicit correction ('actually, it's Pos…
3. Define the handoff payload shape for the two new Souls
4. Retention: long-lived; updated in place when superseded, archived when contradicted
What is the key insight about "Where to write what — the 5-second test" in the context of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. If the user could disagree with it next month and be right, it's episodic ('Tuesday Maya was on call').
2. Define the handoff payload shape for the two new Souls
3. memory consolidation
4. Run the brief past a teammate; ask them to roleplay the Soul.
What is the key insight about "Recall budget is finite" in the context of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Define the handoff payload shape for the two new Souls
2. Each turn the Soul can pull a fixed number of memories into context — typically 8-15 across all three stores.
3. memory consolidation
4. Run the brief past a teammate; ask them to roleplay the Soul.
What is the key insight about "From the community" in the context of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Define the handoff payload shape for the two new Souls
2. memory consolidation
3. Across the OpenClaw, Letta, and MemGPT communities the same observation keeps surfacing: the agents that 'feel' most ali…
4. Run the brief past a teammate; ask them to roleplay the Soul.
Which statement accurately describes an aspect of Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Define the handoff payload shape for the two new Souls
2. memory consolidation
3. Run the brief past a teammate; ask them to roleplay the Soul.
4. OpenClaw's memory model maps to a distinction cognitive scientists have been making for decades, and that Letta, MemGPT, and Open Souls all …
What does working with Soul Memory Architecture: Episodic, Semantic, Procedural typically involve?
1. Episodic memory is a stream of events: 'Tuesday 3pm: Maya asked Atlas to draft the postmortem for incident-204.
2. Define the handoff payload shape for the two new Souls
3. memory consolidation
4. Run the brief past a teammate; ask them to roleplay the Soul.
Which of the following is true about Soul Memory Architecture: Episodic, Semantic, Procedural?
1. Define the handoff payload shape for the two new Souls
2. Semantic memory is the Soul's stable picture of the world: 'Maya is a senior SRE on the platform team.
3. memory consolidation
4. Run the brief past a teammate; ask them to roleplay the Soul.
Which best describes the scope of "Soul Memory Architecture: Episodic, Semantic, Procedural"?
1. It is unrelated to tools workflows
2. It applies only to the opposite beginner tier
3. It focuses on OpenClaw splits a Soul's memory into three stores that act differently. Knowing what goes where is t
4. It was deprecated in 2024 and no longer relevant

← Back to interactive lesson

Tendril · Creators · Tools Literacy