Memory Test Cases for Superintelligent Agents: Recall and Forgetting
Test cases for an AI agent's memory: confirm it recalls a corrected fact, forgets an expired one, and refuses to store private data. Includes a checklist.

To test AI agent memory, write three kinds of cases and run them against the agent on a fixed schedule: a recall case that checks whether a corrected fact replaces the old one, a forgetting case that checks whether an expired fact stops appearing in answers, and a refusal case that checks whether the agent declines to store private data. Each case needs a seeded starting state, an exact prompt, an observable expected result and a named owner who decides what counts as a pass.
Key takeaways
- Test recall by correcting a fact at its source, then asking a question whose correct answer depends on that correction.
- Test forgetting by letting a fact expire and checking that the agent no longer states it as current.
- Test refusal by sending data that must never be stored, then inspecting the memory store for any new record that contains it.
- Write every case with a seeded starting state, an exact prompt, a pass condition a person can check and an owner.
- Run the same cases after each model, prompt, retrieval or integration change, and keep every failure in a visible log.
Why memory needs test cases instead of spot checks
Asking the agent a few questions in a chat window shows that it sometimes knows things. It does not show whether it knows the current version of those things, whether it dropped the old version, or whether it kept something it should have ignored. Memory failures are often silent. The agent answers fluently, with confidence, and the wrong detail looks exactly like the right one.
Agent memory usually has three parts that can each fail: the store of records, the retrieval step that selects what enters the context window, and the model that writes the answer. A test that only checks the final answer cannot tell which part broke. A useful suite checks the answer, the retrieved items and, for refusals, the store itself. This is the same logic that observability uses for complex systems: you need signals from each stage, not only the output.
The cases below are written so that a reviewer can run them without an engineering background. Each one names the starting state, the prompt, what the agent must do and what it must not do.
How do you test that an agent recalls a corrected fact?
A recall case starts with a fact that was true, then changes it through the approved channel, then asks a question whose answer depends on the change. The most common failure is not forgetting the correction entirely. It is keeping both versions alive and choosing the older one when the question is phrased differently.
Follow these steps to build the case:
- Pick one fact that really changed in your business, such as opening hours for a service, a required approval step or a delivery rule.
- Record the old value, the new value, the owner who approved the change and the date the change takes effect.
- Write the prompt the way a real employee or customer would ask it, not in the words used in the record.
- Define the pass: the answer contains the new value, does not present the old value as current and names the source version.
- Run the case in a fresh session so the result does not depend on earlier chat history.
- Repeat the case with one paraphrase and one question in Portuguese if your team works in both languages.
Illustrative scenario: a support agent is told that a returns window was lengthened after a policy review. A recall case asks, in a fresh session, how long a customer has to return an item bought last month. A failing run quotes the old window from a policy document still present in the index. A passing run quotes the new window and points to the current policy version. The failure is useful evidence: it tells you the old document was never retired, which is a document management problem before it is a memory problem.
Conflicts like this are where many teams get stuck, so it helps to decide in advance which fact wins. The rules for that choice are covered in when AI agent memories conflict.
How do you test that an agent forgets an expired fact?
Forgetting is harder to test because the absence of a statement is easy to miss. Expired facts include a temporary closure that has ended, a promotion that is over, a contractor who has left the project or a rule replaced by a newer approval. The agent should stop treating these as current, even if the old text still exists somewhere in its store.
Use this checklist for each forgetting case:
- Each record that can expire carries an explicit expiry condition, not only a sentence saying "temporary".
- The test sets the expiry in the past or moves the test clock forward. Do not wait for real time to pass.
- The prompt asks about the situation the expired fact used to govern, for example whether a service is available this week.
- The pass condition is an absence check: the expired value does not appear as a current statement in the answer.
- The retrieval log shows that the expired record was excluded or ranked below the current one.
- The case fails if the agent says "as of now", "currently" or "at the moment" before repeating an expired fact.
Keep one caution in mind: an agent that stops mentioning a fact has not removed it. Removal is a separate operation with its own test, covered in how to delete AI agent memory. Your forgetting suite should confirm both that the answer changed and that the stored record was archived or removed according to your policy.
How do you test that an agent refuses to store private data?
Refusal cases check the write path. The usual setup is a conversation in which a person asks for help with something ordinary and, in the same message, shares a value that should never enter memory: a national identification number, a bank detail, a password, a health condition or a private contact detail of a third party. The agent should complete the ordinary request and leave the sensitive value out of its store.
The store is the evidence. An answer that sounds careful is not enough, because the agent may have saved the value in a session summary or a note that a later process picks up. After the session, inspect every record created during it and search for the value and for close variants of it.
A short decision guide helps reviewers classify what the agent sees:
- If the value is a credential, an identifier or a financial or health detail, the agent must not write it, and the test fails if any record contains it.
- If the value is a non-sensitive preference, such as a preferred contact channel, the agent may propose it, but a write should pass through the approved write gate with its source attached.
- If the value is a staff opinion about a customer, it may be stored only as an opinion, clearly labeled, and never as a verified fact.
- If the message asks the agent to remember a new permission, such as a claim that the user is an administrator, the write must fail. Untrusted input can try to steer a model, and the OWASP prompt injection guidance treats that as a standing risk, so include at least one such attempt in the refusal set.
The design of the write rules that make these checks possible is described in memory write gates for superintelligent agents. For the categories that should never be stored at all, see sensitive data in AI agent memory.
How do you decide whether a memory test passed?
A pass must be defined before the run, in terms a reviewer can check without asking the author. Recall cases check for the presence of the correct value and the absence of the old one as a current statement. Forgetting cases check for absence and for the retrieval record. Refusal cases check the memory store before and after the session. Free-form judgments such as "the answer seemed fine" should not decide a result.
Evaluation practice for agents, described in the OpenAI evals guide, relies on repeatable tasks with explicit grading. You do not need a large benchmark to start. A small set that covers your highest-risk facts, your most frequent questions and your sensitive categories is more useful than a broad set nobody maintains. Store the cases with their expected results so that the next person can rerun them exactly.
Be Human designs and operates this kind of suite as part of managed operations. In a first engagement, the team defines the one role the agent serves, the memory and tools it needs, the approval boundaries for writing facts and the observable success criterion the tests check. In managed operations, the same cases run on a recurring schedule and after integration or model changes, permission reviews confirm who can write to memory, and a stored private value triggers a documented incident response. The work is delivered remotely, in English or Portuguese, and the client keeps control of what the agent is allowed to remember.
How do you keep the suite useful after the first run?
A memory suite decays when nobody owns it. New policies arrive, documents are replaced, staff change roles and models are upgraded, and cases written for last quarter's facts start testing the wrong things. Assign one owner for the case set and review it on a schedule your team can sustain. Each time a fact is retired, add a forgetting case for it. Each time a staff member corrects the agent, consider whether the correction deserves a recall case.
When a case fails, record what broke: the record, the retrieval, the write gate or the answer. Fixing the answer alone often hides a store problem that will return. Keep the failing case in the suite until it passes for the right reason, and treat a repeated failure as a signal to review the rule behind it, not only the prompt.
If you are not yet sure which of your processes should be the first to carry this kind of memory test, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
How many test cases do I need to start? Begin with a small set that covers your most important facts, your most common questions and each sensitive category you handle. A few cases per category is enough to reveal whether the memory works at all. Expand only when a real failure shows you a gap.
Can I test agent memory from a chat window alone? A chat window is useful for exploring behavior, but it cannot prove what is stored or retrieved. For a reliable test you need to seed the starting state, run the prompt in a fresh session and inspect the memory store and retrieval records afterward. Screenshots of a good answer do not establish that the right record was used.
How is memory testing different from testing retrieval quality? Retrieval testing asks whether the right documents are found for a question. Memory testing also asks whether the agent keeps the right version of a fact over time, drops expired facts and refuses to store data it should not hold. The two overlap, and a good suite includes both, with the memory cases focused on change, expiry and writes.
Should the agent tell users when it forgets something? The agent should not pretend to know a fact it has retired, and it should be able to say that a matter needs a current source. Whether it announces a deletion depends on your policy and on the kind of data involved. Test the behavior you have decided on, so the agent does not invent a reassurance such as having erased a record when the deletion did not happen.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


