AI uses for records
How to test agent memory against contradictory updates from a customer
By SourceX Editorial · Updated
10 sections
Short answer
Test it with a scripted conversation in which the customer states a preference, reverses it, then reverses again, paired with a ground-truth timeline of what the agent should believe after every turn. Probe the agent's memory and its actions at each checkpoint, score current value, history and refusal to act on unconfirmed or withdrawn requests separately, and repeat each run several times because one lucky pass proves little.
Agent run
Agent memory contradictory
Key takeaways
- A change-of-mind test scores three things separately: the current value, the history of earlier values and whether the agent acted only on confirmed requests.
- Every remembered fact needs an event time, a recorded time and a validity window, or the test cannot tell a correct update from a lucky one.
- Hedged statements such as maybe Thursday should create a tentative note, not overwrite a confirmed value.
- Authority matters: a change from someone who cannot approve it should leave memory unchanged.
- Repeat each timeline several times and report the share of runs that pass every checkpoint, not one best run.
What does a contradictory-update memory test actually measure?
It measures whether the agent's working belief about a customer matches the latest authoritative statement at every point in a conversation, not just at the end. A good test also checks that the agent keeps the superseded values as history and that it never acts on a request the customer has withdrawn or not yet confirmed.
Three separate abilities hide inside the phrase agent memory contradictory updates. The first is overwrite: when the customer says Thursday instead of Saturday, the remembered delivery day must change. The second is retention of history: the agent should still be able to say that Saturday was requested earlier and then dropped, because a supervisor, an audit or a dispute may need that. The third is action discipline: the agent must not book, cancel or charge anything on a value that is in flux.
Many agent evaluations quietly merge two of these. An agent that simply appends every statement to a long context may answer the history question well and still act on the stale value. An agent with an aggressive summarizer may hold the right current value and lose the record that anything changed. Scoring the three abilities separately is what makes the result useful to an engineer.
Why recall benchmarks rarely catch the second change of mind
Because most benchmarks ask about a fact once, after the conversation is over, while real customers change course in the middle of an action. The failures that matter show up between the first and second reversal, when the agent has partly committed to a plan.
Public benchmarks do cover pieces of this. LongMemEval, published at ICLR 2025, releases 500 questions over timestamped chat histories and names knowledge updates, temporal reasoning and abstention among its five core memory abilities. MemoryAgentBench lists conflict resolution as one of four core competencies. Both are useful references for question types, but they grade answers to questions, not the actions an agent takes while the customer is still deciding.
The retail tasks in tau-bench come closer to the business case. Its test tasks script the simulated customer to change course, for example offering a gift card for payment and then switching to PayPal if the agent pushes back, or deciding at the confirmation step to return a different item. The domain policy requires the agent to list the action details and get an explicit yes before any cancel, modify, return or exchange, and the modify-items tool can be called only once per order. Those two rules turn a change of mind into a measurable trap: an agent that commits early cannot recover.
The tau-bench authors also introduced pass^k, the chance that an agent succeeds on all k independent trials of the same task, alongside the familiar average success rate. A change-of-mind test needs that view, because the same agent can track two reversals on one run and lose them on the next.
Which clocks does every remembered fact need?
At least three: when the customer said it, when the agent recorded it, and the window during which it is true. Without those, a test cannot tell a correct update from a lucky one, and an agent cannot tell a newer statement from a newer copy of an older statement.
At a glance
Which clocks does every remembered fact need
Graphiti, an open-source temporal knowledge graph for agent memory, makes the distinction concrete in its edge schema: valid_at is when a fact became true, invalid_at is when it stopped being true, and expired_at records when the stored item was invalidated. Its README describes this as bi-temporal tracking that invalidates contradicted facts while keeping the history. Mem0 takes a different route: its default update prompt asks a model to compare new facts with stored memory and choose one of four operations, ADD, UPDATE, DELETE or NONE.
Neither design is the test. They are two answers the test should be able to score. A timeline that records event time, recorded time and validity lets you check a graph store and an overwrite store against the same truth, which is the point of writing the ground truth independently of any one memory architecture.
- Event time: when the customer made the statement, taken from the message or call timestamp.
- Recorded time: when the agent or a downstream system wrote it, which can lag or arrive out of order.
- Valid window: from which point the value applies and when it was superseded, withdrawn or expired.
What should the multi-update memory task with a ground-truth timeline include?
It should include a short script of customer turns, an authoritative system event or two, and after each step the exact memory state and the exact permitted action. The illustrative timeline below is a home-appliance delivery handled over chat and a later phone call; every value is invented for illustration.
Read each row as a checkpoint. The expected memory column is the ground truth the agent is scored against, and the permitted action column is what the agent may do at that moment, including doing nothing.
The scenario deliberately mixes four kinds of change: a customer reversal, a hedged statement, a change imposed by an authoritative system and a request from someone without authority. It also crosses a channel boundary, from chat to a phone call, which is where many memory layers start a fresh session. A suite of twenty or thirty such timelines across different facts, such as addresses, contacts, quantities and service options, covers more ground than hundreds of single-fact questions.
| Step | Customer or system event (illustrative) | Expected memory after the step | Permitted agent action |
|---|---|---|---|
| T1 chat | Customer asks for delivery on Saturday morning | delivery_day = Saturday, status proposed | Offer Saturday slots; do not book yet |
| T2 chat | Customer confirms the Saturday 9 to 12 slot | delivery_day = Saturday, status confirmed | Book the slot and read back the details |
| T3 chat | Customer: actually I may need Thursday, let me check | Saturday stays confirmed; Thursday noted as tentative | Keep the booking; ask the customer to confirm when ready |
| T4 system | Scheduling system cancels Saturday routes for weather | Saturday slot invalid from T4, source scheduling system | Tell the customer; offer the next slots |
| T5 call | Customer confirms Thursday 13 to 17 | delivery_day = Thursday, confirmed; Saturday kept as history | Book Thursday after an explicit yes |
| T6 call | Customer asks to remove the haul-away of the old unit | haul_away = false from T6; earlier true kept as history | Update the order once, after reading back all changes |
| T7 chat | A family member on the account asks to move it to Friday | No change; requester not authorized for this order | Decline the change and explain who can approve it |
| T8 probe | Agent is asked what was requested and what is booked | Booked: Thursday, no haul-away; history: Saturday requested then cancelled by system | Answer from memory with sources and times |
Which fields make each timeline row checkable?
Each row needs enough metadata that a grader, or a script, can decide the expected state without guessing. The specification below is a field list an annotation team can use as is when building timelines from real or simulated conversations.
At a glance
Which fields make each timeline row checkable
| Field | What to record | Illustrative value |
|---|---|---|
| fact_key | The attribute that changes, from a fixed vocabulary | order.delivery_day |
| value and status | The value plus proposed, confirmed, withdrawn or expired | Thursday, confirmed |
| source_turn | Message or call segment ID where the value was stated | call-2 segment 14 |
| authority | Who stated it and whether they may change this fact | account holder, authorized |
| event_time and recorded_time | When it was said and when a system logged it | T5 said, T5 plus 40 seconds logged |
| valid_from and valid_to | The window during which the value applies | from T5, open |
| supersedes | The fact row this one replaces | row for Saturday, status confirmed |
| permission scope | Where the fact may be reused: this order, this account, never | this order only |
| deletion rule | What must happen if the customer asks to forget it | drop from memory, keep order record per policy |
How to probe and score the agent after each change
Ask probe questions immediately after each checkpoint and again at the end, then score the answer and the agent's tool calls against the timeline. Do not average everything into one number; report each failure type, because each has a different fix.
Run every timeline several times with the same seed conversation and report the share of runs that pass all checkpoints, in the spirit of pass^k. Vary only one thing at a time, such as the gap between reversals or whether the second reversal arrives in a new session, so that a drop can be traced to its cause.
| Probe | Correct behavior | Failure it catches |
|---|---|---|
| What day is booked right now? | Names the latest confirmed value only | Stale overwrite: answers with the first value |
| What did the customer ask for before? | Lists earlier values with order and source | History loss from summarizing or overwriting |
| Tool call log after a tentative statement | No booking or cancellation until confirmed | Premature action on an unconfirmed change |
| Change requested by an unauthorized person | Refuses and keeps the memory unchanged | Authority blindness: any speaker can edit facts |
| Question about a fact never stated | Says it does not know | Fabricated memory instead of abstaining |
| Same question in a new session | Same answer as at the end of the last session | Session boundary drops or duplicates updates |
Worked example: scoring one run of the delivery timeline
Suppose an agent is run through the eight-step delivery timeline five times. The numbers in this example are illustrative counts, chosen to show how the scoring separates failure types rather than to describe any real system.
In four of the five runs the agent books Thursday at T5 and answers the final probe correctly. In one run it reads the hedged statement at T3 as a confirmed change and cancels the Saturday booking before the customer decides. The final answer in that run is still Thursday, so an end-of-conversation question would mark it correct. The checkpoint at T3 marks it as a premature action, which is the failure that would cost a real customer a delivery slot.
Two of the five runs also lose history: asked at T8 what was requested before, the agent says only that Thursday is booked and does not mention that Saturday was confirmed and then cancelled by the scheduling system. One run accepts the family member's request at T7 and moves the order to Friday. Reported separately, the result reads as four of five runs correct on the current value, three of five on history, four of five on action discipline and four of five on authority, with only one run passing every checkpoint.
That last figure is the one to track over time. It is the strict all-checkpoints view that pass^k encourages, and it falls fastest when a change to the memory layer helps one ability at the expense of another. A summarizer tuned to save tokens, for instance, often raises the current-value score while lowering the history score, and only a per-ability report shows the trade.
The exception worth building into every suite is the system-initiated change at T4. Here the new truth comes from the scheduling system, not the customer, and the agent must accept it even though nobody in the conversation asked for it. Agents that only trust customer statements fail this row, which is why each timeline should include at least one authoritative system event alongside the customer's reversals.
When should the agent update, forget or stop using a remembered fact?
Update when a person with authority confirms a new value, mark as tentative when the customer is still deciding, invalidate when an authoritative system says the value no longer holds, and stop using a fact when the customer asks to be forgotten or the permission that allowed it lapses.
The useful exception is the hedged statement. When a customer says they may need Thursday, the correct memory state is a tentative note next to the still-confirmed Saturday, not an overwrite. Agents that treat every new statement as the truth fail this row, and agents that ignore hedged statements miss the cue to ask a follow-up question.
Forgetting needs its own row in the test because product memory and conversation history are often stored apart. OpenAI's help center, for example, says that deleting a ChatGPT chat does not remove a saved memory created from it, and that removing a memory and the chat it came from are separate steps. A test for your own agent should check the same split: after a forget request, the fact must stop appearing in answers and actions, even if the underlying ticket or order record is kept under your retention policy.
Where this test stops being trustworthy
A passing score is weak evidence when the timelines are too clean, too short or too similar to the agent's training data. Real reversals are messy: customers contradict themselves within a single message, staff override values in a back-office system without telling the agent, and two channels report the same change minutes apart.
Treat these limits as stop signs. If the timelines are synthetic only, report results as an upper bound and add a slice built from real, de-identified conversations before drawing conclusions. If the memory store is shared across customers or tenants, bring in a security reviewer before testing, because an authority failure there is a data leak rather than a wrong answer. If facts include health, financial hardship or other sensitive details, involve your privacy lead, since the permission scope column may forbid remembering them at all.
Finally, keep the ground truth independent of the system under test. Timelines labeled by reading the agent's own memory store tend to inherit its mistakes, so build expected states from the conversation and the systems of record, and have a second annotator check a sample.
Sourcing change-of-mind timelines from real support records
The strongest timelines come from support operations where the change of mind is already recorded: help desk tickets with field audit histories, order systems that log every modification with a timestamp and user, and call recordings whose segments can be aligned to those changes. Pairing the conversation with the system log is what turns a transcript into a checkable timeline.
Teams that would rather test against real reversals than simulated ones can describe the records they need to SourceX, for example multi-session order conversations paired with order modification logs. It holds no stock; each request, with its scope, volume, language, format, timing and licensing needs, is filled from U.S. businesses that agree to license those records.
Frequently asked questions
How many reversals should a memory test include?
At least two on the same fact, because the second reversal is where agents that only remember the first and last values fail. Add a third change on a different fact so you can see whether updates interfere with each other. Keep a slice with no reversals as a control.
Should the agent delete the old value when the customer changes their mind?
Usually no. The current value should replace the old one for decisions, but the old value should stay as dated history so the agent can explain what happened. Delete it only when the customer asks to be forgotten or your retention rules require it.
Is a long context window enough to handle contradictory updates?
Not reliably. Keeping every message in context preserves history but does not tell the agent which statement is current or confirmed. Score current value and action discipline separately to see whether the long context actually helps.
What is the difference between a tentative and a confirmed update?
A tentative update is a statement the customer has not committed to, such as maybe Thursday. A confirmed update follows an explicit yes to a read-back of the change. Only confirmed updates should trigger bookings, cancellations or charges.
Can simulated users replace real conversations for this test?
They are a good start because you control the script and the timing. They tend to be tidier than real customers, so add a slice from real, de-identified conversations before trusting a score, and compare results across the two.
Sources
- LongMemEval releases 500 questions over timestamped chat histories to test five long-term memory abilities, including knowledge updates, temporal reasoning and abstention, and was accepted at ICLR 2025. Source
- MemoryAgentBench evaluates memory agents on four core competencies, one of which is conflict resolution. Source
- tau-bench retail test tasks instruct the simulated user to change their mind, for example switching from gift card to PayPal or changing which item to return at the confirmation step. Source
- The tau-bench retail policy requires the agent to list action details and obtain explicit user confirmation before consequential actions, and the modify-items action can be called only once. Source
- The tau-bench paper defines pass^k as the chance that an agent succeeds on all k independent trials of the same task. Source
- Graphiti entity edges record valid_at (when a fact became true), invalid_at (when it stopped being true) and expired_at (when it was invalidated). Source
- Mem0's default update memory prompt has a model compare new facts with existing memory and choose ADD, UPDATE, DELETE or NONE. Source
- OpenAI's Memory FAQ says deleting a chat does not remove saved memories created from it; the memory and the chat must each be removed. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.