AI uses for records
Episodic memory in business workflows: reuse a past case, not its outcome
By SourceX Editorial · Updated
10 sections
Short answer
Treat a prior case as evidence of how a decision was made under specific conditions, not as a forecast. Store each episode with its decisive features, the policy version in force, the decider's authority, the outcome's final status and explicit reuse conditions. At decision time, check those conditions against the new case and current policy, derive the outcome again, and cite the episode only as support.
Agent run
Episodic memory business
Key takeaways
- A remembered case is evidence about a past decision under specific conditions, not a prediction of the next one.
- Each episode needs decisive features, the policy version in force, the decider's authority, the outcome's final status and explicit reuse conditions.
- Similarity ranking decides what to retrieve; separate applicability checks decide whether the case may guide the new decision.
- A counterexample pack of look-alike cases with different decisive facts shows quickly whether an agent copies outcomes.
- Retire episodes when outcomes reverse or policies change, and delete them and their derivatives when permission or retention ends.
How should an agent use a prior case without assuming the same outcome applies?
Treat the prior case as evidence about how a decision was made under specific conditions, never as a prediction of today's result. The agent retrieves the episode, checks whether the conditions that decided it still hold in the new case and under the current policy, then derives the outcome again from current rules and current system state, citing the episode as support rather than as the answer.
That sounds obvious, but most workflow memory is stored as "what happened" without "why it happened here". A refund that was approved, a vendor that was onboarded without a second review, a claim that was paid in full: each is a true record and a dangerous template. The agent sees a surface match, copies the outcome and quietly turns one exception into a rule.
The fix is structural. Every remembered case needs its decisive features separated from incidental ones, the policy version in force at the time, the authority of whoever decided, the final status of the outcome, and the conditions under which it may be reused. This page gives that structure as an episodic memory schema, a counterexample pack that tests whether an agent respects it, and the checks that should reject a malformed episode before it is ever retrieved.
What separates an episode from a fact or a rule?
An episode is a dated record of one situation, the action taken and what followed; a fact is a claim about the world; a rule says what to do. The Cognitive Architectures for Language Agents framework (CoALA) draws the same line: episodic memory stores sequences of the agent's past behavior, semantic memory holds knowledge about the world and the agent, and procedural memory holds the agent's code and model parameters.
The LangMem conceptual guide describes episodic memory as preserving the full context of an interaction, including the situation, the reasoning and why the approach worked, so the agent can adapt based on what has worked before. That is useful, and it is also where the risk sits: an episode that records only successes, and only the reasoning that led to them, teaches the agent that the path is reliable without telling it when the path fails.
The distinction matters for storage. A fact can be overwritten when it changes. A rule should be versioned. An episode should almost never be edited in place, because it describes what happened at a point in time; what changes is its status (corrected, outcome reversed, superseded by policy, withdrawn) and whether the agent is still allowed to use it.
Where does overgeneralization creep into workflow memory?
Overgeneralization enters through a handful of predictable gaps between what the episode records and what the reuse decision needs. Each gap has a field in the schema below that closes it.
| Failure mode | What the agent does | Why the record allowed it | Field that closes the gap |
|---|---|---|---|
| Surface match | Reuses a case because the customer, product or wording looks alike | Situation stored as free text with no decisive features marked | decisive_features, incidental_features |
| Policy drift | Applies an outcome that was correct under last quarter's policy | No policy or rule version recorded with the decision | policy_ref with version and effective dates |
| Authority mismatch | Copies an exception a manager granted into a case an agent tier cannot approve | Decider's role and approval limit not stored | decided_by_role, authority_basis |
| Immature outcome | Treats an approved-but-unpaid or later-reversed outcome as final | Outcome captured once at decision time and never revisited | outcome_status, outcome_observed_at |
| Survivorship | Learns only from cases that went well | Failed or escalated episodes not retained or not retrievable | retention rule covering failures; lesson_scope |
| Lesson inflation | Turns one exception into a standing rule | Lesson text written as a general instruction | lesson_scope limited to stated conditions; reuse_conditions |
| Permission leak | Reveals details of another customer's case while explaining a decision | No permission or visibility scope on the episode | permission_ref, disclosure_scope |
The episodic memory schema: what each remembered case must carry
The core schema answers three questions for every remembered case: what exactly happened, what made it come out that way, and when the agent may lean on it. The fields below are the minimum for a workflow episode; the example column uses an illustrative support refund case, not real customer data.
| Field | Purpose | Illustrative value | Validation rule |
|---|---|---|---|
| episode_id and source_records | Ties the episode to the system records it was built from | EP-0192; Zendesk ticket 48812, Shopify order 1043, carrier tracking event | At least one source record with system name and record ID |
| event_time and recorded_time | Separates when it happened from when memory learned it | Decision 2026-03-04; written to memory 2026-03-06 | Both present; recorded_time not before event_time |
| situation | Plain summary of the case as the decider saw it | Return requested 9 days past window; carrier delay scan on file | Under 60 words; no names or contact details |
| decisive_features | The facts that changed the decision | carrier_delay_documented = true; days_late <= 10 | At least one feature, each tied to a source field |
| incidental_features | Facts present but not relevant to the decision | Customer tenure 4 years; product category footwear | Listed so retrieval can ignore them |
| action_and_outcome | What was done and what followed | Late return accepted; full refund issued | Action and outcome stored as separate values |
| outcome_status and outcome_observed_at | Whether the outcome is final, pending or reversed, and when that was checked | final; checked 2026-04-10 after the refund settled | Status from a fixed list; date after event_time |
| policy_ref | Policy or rule version in force when decided | Returns policy v7, effective 2026-01-01 to 2026-06-30 | Version and effective range required |
| reuse_conditions and lesson_scope | When the case may guide a new one, and what it teaches | Reuse only if delay is documented and policy v7 or a successor keeps the clause | Conditions written as checks, not advice |
Governance fields, and the checks that reject a malformed episode
The second half of the schema records who could make the decision, who may see it, and how the record has changed, because an episode the agent should not rely on or disclose is worse than no episode. Provenance standards already model this: W3C PROV-O links derived entities to their sources with wasDerivedFrom and records an agent's responsibility for an activity or entity with wasAssociatedWith and wasAttributedTo. An episode is a derived entity, so it should carry the same kind of link back to its records and its decider.
A validator should reject an episode at write time and again at read time, because an episode that was valid when stored can become unusable later. The checks listed after the table are mechanical enough to run in code against both halves of the schema.
- Source check: every source record exists, resolves in its system of record, and is covered by the permission named in permission_ref.
- Time check: event_time, recorded_time and outcome_observed_at are present and in order; the policy_ref effective range contains event_time.
- Feature check: at least one decisive feature, each mapped to a named source field, and no decisive feature that is also listed as incidental.
- Outcome check: outcome_status is final before the episode is retrievable for reuse; pending and reversed episodes are retrievable only as history.
- Authority check: decided_by_role is recorded and authority_basis cites a policy section or approval record.
- Lesson check: lesson_scope restates the reuse conditions; any lesson phrased as an unconditional instruction fails.
- Privacy check: the situation summary contains no names, contact details or account numbers, and disclosure_scope is set.
- Lifecycle check: valid_until or review_by is set, and an episode past either date is held until reviewed.
| Field | Purpose | Illustrative value | Validation rule |
|---|---|---|---|
| decided_by_role and authority_basis | Shows the decision was within the decider's authority | Support lead; exception authority under returns policy section 4 | Role required; basis cites a policy section or approval record |
| permission_ref | The permission that lets this case be stored and reused | Internal support operations, retention schedule RS-12 | Must resolve to a current permission record |
| disclosure_scope | What the agent may say about the case to others | Internal reasoning only; never quote to another customer | One of a fixed list of scopes |
| correction_history | Every change to the episode with date, reason and author | 2026-04-10 outcome_status pending to final | Append-only; no silent edits |
| valid_until and review_by | When the episode stops being usable without review | Valid until policy v7 is superseded; review by 2026-09-30 | At least one of the two present |
| delete_by and deletion_basis | When and why the episode and its derivatives must be removed | Delete with source ticket under RS-12 | Deletion propagates to summaries and embeddings |
Reuse at decision time: match decisive features, then re-derive
Retrieval finds candidates; reuse is a separate decision that has to pass its own checks. Case-based reasoning has described this split for decades as a cycle of retrieve, reuse, revise and retain, and recent reviews of case-based reasoning for LLM agents keep that cycle as the frame: the retrieved case proposes, the current situation revises, and only a checked result is retained as a new case.
Similarity scores do not answer the reuse question. The Generative Agents architecture, for example, ranks memories by a combination of recency, importance and relevance, which is a good way to decide what the agent should notice, but none of those three signals says whether the old decision's conditions hold now. Applicability needs explicit checks against decisive features and the current policy.
A reuse step that works in practice runs in this order:
- Retrieve candidate episodes by decisive features, not by full-text similarity of the situation summary.
- Drop any episode whose outcome_status is not final, whose valid_until has passed, or whose permission_ref no longer resolves.
- Check each reuse condition against the new case's live system state, field by field, and record pass or fail per condition.
- Compare policy_ref with the policy in force today; if the clause the decision relied on changed, the episode can explain history but cannot support the new decision.
- Derive the new outcome from current rules, then cite the episode as consistent or inconsistent with it; never let the episode supply the outcome directly.
- Retain the new decision as its own episode, with its own decisive features and a link to the episodes it consulted.
Worked example (illustrative): a late return that looks like last month's
Here is how the schema plays out on one illustrative case. All IDs, dates and counts are invented for this example, and the systems named are only examples of where such records live.
The stored episode EP-0192 says a return requested 9 days after the window closed was accepted because a carrier scan documented a delivery delay. Its decisive features are carrier_delay_documented = true and days_late <= 10; its policy_ref is returns policy v7, whose section 4 lets a support lead accept late returns when a carrier delay is documented. Outcome status is final.
A new request arrives in August: 8 days late, same product line, same long-tenured customer profile. Full-text similarity ranks EP-0192 first. The reuse check then fails on two conditions. The order's tracking history shows on-time delivery, so carrier_delay_documented is false. And returns policy v8, effective July 1, removed the section 4 exception and moved late-return approval to a finance reviewer.
The correct agent behavior is to decline to reuse the outcome, explain that the earlier exception depended on a documented carrier delay under a policy that has since changed, and route the request to the finance reviewer named in v8. The agent should not mention the earlier customer's case to this customer, because EP-0192's disclosure_scope is internal reasoning only.
A failing version of the same episode makes the risk concrete. If EP-0192 had been stored as "Late returns from long-term customers can be accepted" with no decisive features, no policy_ref and the lesson written as a general instruction, it would pass a naive similarity search and fail most of the validator checks above, and the agent would have approved the August return.
The counterexample pack: pairs that punish copying the outcome
A counterexample pack is a set of paired cases in which the new case resembles a stored episode on the surface but differs on a decisive feature, so the right answer is different. It is the fastest way to find out whether an agent reuses reasoning or copies outcomes. Each pair should be built from real case histories where possible, with a recorded reason the outcomes differ.
| Pair | Shared surface features | Decisive difference | Correct agent behavior |
|---|---|---|---|
| Late return | Same product, similar lateness, loyal customer | No documented carrier delay; policy clause removed | Decline reuse; route to the current approver |
| Vendor onboarding | Same vendor category and contract size band | Earlier vendor had a completed security review on file | Require the review; do not skip it by precedent |
| Insurance claim payment | Same peril, similar loss amount band | Earlier policy had a rider covering the loss type | Check coverage on the current policy before citing the case |
| Discount approval | Same account, same quarter | Earlier discount approved by a VP above the agent's limit | Escalate; authority does not transfer |
| Expedited shipping | Same customer, same complaint wording | Earlier case resolved before the outcome was later reversed | Treat episode as reversed; cite the reversal |
| Contract renewal terms | Same plan, same renewal month | Earlier renewal used a pricing schedule since retired | Use the current schedule; flag the change |
| Access request | Same role title, same application | Earlier grant was a temporary exception with an end date | Do not grant standing access from a temporary case |
| Support escalation | Same error message | Earlier root cause was a now-fixed product defect | Check current incident status before reusing the fix |
When should a remembered case be corrected, retired or deleted?
Correct an episode when its source records are corrected; retire it from reuse when its outcome is reversed, its policy is superseded or its review date passes; delete it when the permission or retention rule that allowed it ends. Each of those is a different operation, and mixing them up is how stale precedent survives.
Retiring should preserve history. Graphiti's documentation describes facts with validity windows that are invalidated rather than deleted when information changes, so a system can answer what is true now or what was true at a point in time, with every derived fact tracing back to the episode that produced it. System-versioned temporal tables in SQL Server follow the same pattern for rows: the database keeps a current table and a history table, and closes the old row's validity period when it is updated or deleted.
Deletion is different. When retention ends or a permission is withdrawn, invalidating the episode is not enough: the episode, its summaries, its embeddings and any lesson derived only from it should be removed, and the deletion recorded without the deleted content. A memory store that can only invalidate cannot honor that, so design deletion in from the start.
Licensing real case histories for episodic memory work
Teams building or evaluating episodic memory need case histories with the parts synthetic data rarely has: decisions tied to the policy in force, approvals with authority, outcomes followed to their final state and corrections recorded over time. Those live in ticketing, claims, approvals and order systems at operating companies.
Case histories of this kind are not something SourceX keeps on a shelf: it finds them at U.S. businesses when a buyer asks, after the buyer sets out scope, volume, format, timing and licensing needs in a request. Each supplying company approves the scope and terms and signs before delivery, with de-identification carried out by SourceX through approved processing routes. Being able to open a ticketing system gives neither privacy permission nor a license, and removing identifiers does not supply the licensing right either.
Frequently asked questions
What is episodic memory in an AI agent?
Episodic memory is the store of the agent's past experiences: dated records of a situation, the action taken and what followed. Frameworks such as CoALA separate it from semantic memory, which holds facts, and procedural memory, which holds the agent's code and model parameters. In business workflows an episode is usually one handled case, such as a ticket, claim or approval.
Why is copying a past outcome risky even when the cases look identical?
Cases that look identical often differ on the one fact that decided the earlier outcome, such as a documented exception, a policy clause or the decider's authority. Policies also change, so a correct decision last quarter can be wrong today. The agent should re-derive the outcome from current rules and cite the episode only as support.
How is an episode different from a lesson or a rule?
An episode records what happened in one case at one time and should not be edited in place. A lesson is a generalization drawn from one or more episodes and must stay scoped to the conditions that produced it. A rule is a standing instruction with its own version history, owned by whoever owns the policy.
Should failed or escalated cases be kept in episodic memory?
Yes, within the same permission and retention rules as successful ones. If only successes are retained, the agent learns that an approach is reliable without seeing where it breaks. Failed, escalated and reversed cases are also the raw material for a counterexample pack.
Does invalidating a memory satisfy a deletion request?
No. Invalidating keeps the record as history and stops the agent relying on it, which suits a reversed outcome or a superseded policy. A deletion obligation requires removing the episode and anything derived only from it, including summaries and embeddings, and recording that the deletion happened.
How many counterexample pairs does a useful pack need?
There is no fixed number; what matters is coverage of each failure mode the agent could fall into, such as policy drift, authority mismatch and immature outcomes. Start with several pairs per failure mode drawn from your own case history, then add pairs whenever a production miss reveals a new pattern.
Sources
- CoALA organizes language-agent memory into working memory and long-term episodic, semantic and procedural stores; episodic memory holds the agent's past experiences. Source
- LangMem's conceptual guide describes episodic memory as preserving the full context of successful interactions, including the situation, the reasoning and why the approach worked. Source
- W3C PROV-O links derived entities to sources with wasDerivedFrom and records agent responsibility with wasAssociatedWith and wasAttributedTo. Source
- A review of case-based reasoning for LLM agents frames agent case reuse around the retrieve, reuse, revise and retain cycle. Source
- Generative Agents retrieves memories from its memory stream by combining recency, importance and relevance scores. Source
- Graphiti stores facts with validity windows, invalidates rather than deletes superseded facts, and traces derived facts back to the episodes that produced them. Source
- SQL Server system-versioned temporal tables keep a current and a history table and close a row's validity period when it is updated or deleted. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.