AI uses for records
Long horizon agent memory drift: when an early assumption turns false
By SourceX Editorial · Updated
10 sections
Short answer
Plant an assumption the agent must rely on early, let it build work on top, then invalidate it at a checkpoint with authoritative new evidence. Grade four things: whether the agent noticed, whether it revised the belief with source and time, whether it found and redid the work that depended on it, and whether the final records are right. Run the same checkpoint without the change as a control.
Agent run
Long horizon agent memory
Key takeaways
- Recall of a changed fact is not enough; long tasks fail when work built on the old fact is never revisited.
- List every planted assumption and its dependents before the run, marked must change, may stay or must not change.
- Vary the type of evidence, its authority and its timing, and include changes that should be ignored.
- Fork the run at a checkpoint so the control and the invalidation branch share every earlier step.
- Grade the final records against a goal state and report pass^k across repeated runs.
How do you test an agent after an early assumption becomes false mid-task?
Build the falsehood into the task on purpose. Give the agent a fact early that is true at the start, let it make decisions that depend on that fact, and then change it partway through, using a channel the agent should be watching. The test is not whether the agent can recall the new value; it is whether the work already done gets revisited.
Most memory tests ask a question after the update and check the answer. LongMemEval, for example, includes knowledge updates among five core long-term memory abilities, alongside information extraction, multi-session reasoning, temporal reasoning and abstention. That measures whether a changed fact is remembered. A long-horizon task adds the harder part: by the time the fact changes, schedules, messages and records already depend on it.
So each case has a starting state, a planted assumption, a list of dependent actions, an invalidating event with a defined authority, and a verified end state. The grader reads the end state from the system of record and the agent's notes, never from the agent's closing summary.
Three ways memory drift shows up in long tasks
Drift is the gap between what the agent is acting on and what is now true. It appears in three forms, and a task set should be able to tell them apart because they call for different fixes.
At a glance
Three ways memory drift shows up in long tasks
- Stale belief kept: the agent never registers the change and keeps acting on the original assumption, often with growing confidence as more work agrees with it.
- Belief updated, dependents left alone: the agent records the new value correctly but does not trace which earlier decisions were derived from the old one, so half the work reflects each version.
- Over-update: the agent accepts a change from a source without authority, or from a rumor in a thread, and unwinds correct work. This is drift in the other direction, and a set that only rewards updating will train it.
- A fourth pattern, partial rollback, sits between the second and third: the agent redoes some dependents and silently drops others when the cost of rework grows.
Starting state: write down every assumption and what rests on it
Before any run, list the assumptions the task plants and, for each, the decisions and records that will rest on it. This dependency list is the answer key for rework; without it, the grader cannot say which downstream actions should have changed.
Keep the list concrete. An assumption is a field value with a source and a time, such as a date in a signed document, an approver named in a policy, or a quantity on an order. A dependent is an action with a record the grader can read: a booking, a sent message, a task assigned, a field updated. Mark each dependent as must change, may stay, or must not change, because a correct agent leaves unaffected work alone.
| Planted assumption | Source and time | Dependent actions | Expected after invalidation |
|---|---|---|---|
| Delivery window is the second week of the month | Customer order note, task start | Crew booking, parts order, customer confirmation | Booking and confirmation change; parts order may stay |
| Purchase approver is the regional manager | Approval policy page, task start | Approval request, vendor notice, audit note | Request re-routed to the new approver; vendor notice unchanged |
| Budget cap for the project phase | Project charter, task start | Vendor shortlist, quote requests, plan totals | Quotes over the new cap withdrawn; totals recomputed |
| Product version in the customer's environment | Ticket metadata, first reply | Troubleshooting steps, linked knowledge article, escalation tier | Steps and article replaced; escalation tier re-checked |
| Primary contact for the account | CRM record, day one | Kickoff invite, document share, reminder schedule | Invite and share moved; prior contact's access reviewed |
The changing evidence and memory update task set
The task set varies three things independently: what kind of assumption breaks, how the change arrives, and when. Varying them separately lets you see whether an agent handles late changes worse than early ones, or human edits worse than record updates. The rows below are task families; each family should hold several cases with different wording and domains.
| Family | Invalidating evidence | Arrives when | Correct update | Grader checks |
|---|---|---|---|---|
| Record changed in the system of record | Field value updated by another user | After two or more dependents exist | New value adopted with source and time | All must-change dependents redone; others intact |
| Human edited the plan | Person changes a requirement in the shared task | Mid-task, between agent steps | Requirement replaced; reason noted | Plan, messages and records follow the edit |
| Authority changed | Policy or role update names a new approver | After a request was already sent | Old request withdrawn; new one routed | No action taken on the old approval |
| Conflicting evidence, one authoritative | Two sources disagree; only one may decide | Close together | Authoritative source adopted; other flagged | No rework driven by the non-authoritative source |
| Unverified claim of change | Message from someone without authority | Mid-task | Belief held; confirmation requested | No dependents changed; question logged |
| Change after a handoff | Update lands while another agent or person holds the task | Across a session or owner boundary | Receiver applies it to inherited work | Handoff note and records reflect the change |
| Late change near completion | Update after most dependents are done | Final fifth of the task | Full rework or explicit escalation | No partial rollback left unreported |
What a handoff drops: the reason, the approval and the rework surface
The reason behind a fact is the part most often lost, and it is the part rework needs. A handoff summary or a compacted context usually keeps the current value of a field and drops why it was believed, who said it and what was built on it. The next owner then cannot tell that a later change should ripple backward.
Permissions are lost the same way. An agent that inherits a task may inherit the approvals attached to the old assumption, such as a budget sign-off or an access grant that only made sense before the change. A case should check that these are re-examined, not carried forward.
Shared state adds a third risk: another actor may change the world while the agent works. The tau-squared-bench paper builds this into evaluation with a dual-control setting in which both the agent and the simulated user have tools to observe, act on and verify a shared environment, and it reports that agents perform worse in that setting than when they act alone. Mid-task invalidation is the same pressure applied over a longer horizon.
- Requirement: carry the original requirement, its source and the time it was last confirmed across every handoff.
- Permission: list approvals and access tied to the assumption so the receiver can revoke or renew them.
- State: record which records the agent changed under the old assumption, so the receiver knows the rework surface.
Injecting the change at a checkpoint without contaminating the control
Fork the run at the moment the change should arrive, and compare a branch with the change against a branch without it. Both branches then share every step up to that point, so differences after it come from the invalidation and not from luck earlier in the run.
Checkpointing frameworks make this practical. LangGraph's documentation describes persistence through checkpoints for thread-scoped state, and a fork operation that calls update_state on a prior checkpoint to create a new branch with modified state; it warns that update_state does not roll back the thread and that the original history stays intact. Its replay guidance notes that nodes after the checkpoint re-execute, including model calls, so they may produce different results. That last point means the control branch should be run more than once too.
Whatever framework you use, inject the change through the same channel a real change would use: a record update, a message from the named authority, an edit in the shared plan. Writing the new fact straight into the agent's memory tests a different thing, because it skips the noticing step.
Grading the revision: decision log links and the final goal state
The decision is proven by a link from the agent's revised belief to the invalidating record, and the outcome by a read of the final state. Ask the agent to keep a short decision log, then check that each rework action cites the changed source and that every must-change dependent was handled.
At a glance
Grading the revision: decision log links and the final goal state
Keep the log small and structured so it can be graded automatically: the belief, its source record, the time it was adopted, and the actions taken because of it. When the belief changes, the new entry should point to the record that changed it and list which earlier actions it reopens.
Grade the final state against an annotated goal state rather than the transcript. The tau-bench paper compares the database state at the end of a conversation with an annotated goal state, and it proposes pass^k, the chance that all k independent trials of a task succeed, to measure reliability rather than one lucky success. Invalidation cases suit pass^k well, because an agent that reworks dependents in some runs and not others is not safe to deploy on long jobs.
- Noticed: the decision log or a tool call shows the agent read the invalidating record within a set number of steps.
- Revised: the new belief carries the source, the time and the authority that justified it.
- Reworked: every must-change dependent was redone or explicitly escalated; must-not-change records are untouched.
- Outcome: the final records match the goal state, read by the grader from the system of record.
- Reliability: pass^k across repeated runs of the treatment branch, reported beside the control branch.
Worked case: the lease date that moved (illustrative)
This case is illustrative; the company, dates and counts are invented. An operations agent is moving a small distribution site to a new building. At the start it reads the lease file, which says the current lease ends on March 31, and over the next 30 steps it books movers for March 27 to 29, schedules utility shutoff for March 31, and drafts a notice to 40 customers giving March 28 as the last pickup day.
At step 34 the property manager, who the task file names as the authority on lease terms, emails an extension to April 30. The must-change dependents are the utility shutoff and the customer notice, which is still a draft. The mover booking may stay, because the move itself can still happen in March. The correct agent records the new end date with its source, cancels the shutoff, rewrites the draft and leaves the movers alone.
The counterexample case uses the same run, but the extension arrives in a chat message from a warehouse lead who has no authority over the lease. Here the correct behavior is to hold the original belief, ask the property manager to confirm, and change nothing. Running both cases from the same checkpoint shows whether the agent updates because of evidence or because of any mention of a new date.
What this task set does not measure
It does not measure how long a task an agent can complete. METR's time-horizon work defines that differently, as the length of tasks, measured by how long skilled humans take, that an agent completes with a 50% success rate. An agent can score well there and still miss invalidations, because most of those tasks never change their premises midway.
It also does not measure recall across very long histories, which LongMemEval and similar benchmarks cover, or general robustness to interface changes. Keep the task set focused on one question: when a premise breaks, does the work follow? Cases that also test retrieval or navigation should report those failures separately so they do not mask the rework result.
Nor does it say how often premises change in real work. The task families fix the timing and type of each change by design, which is right for isolating behavior but says nothing about frequency. If you need a realistic mix of change types for training rather than evaluation, derive it from records of actual jobs, and keep that mix separate from the controlled cases so neither contaminates the other.
Business records that already contain mid-course corrections
The best invalidation cases come from records where a premise really did change mid-job: an order amended after scheduling, an approver replaced during a purchase, a ticket reclassified after the first reply. Those histories show which dependents people actually reworked and which they missed, which is the answer key a synthetic case has to guess.
Records of premises that changed mid-job can be requested from SourceX, which goes looking for them at U.S. businesses once a buyer describes scope, volume, language, format, timing and licensing needs. Nothing reaches SourceX until the supplying business has approved those terms and signed.
Frequently asked questions
What is memory drift in a long-horizon agent?
It is the gap between what the agent is acting on and what is currently true. It shows up as a stale belief the agent never revises, a revised belief whose dependent work is left unchanged, or an over-update driven by a source without authority.
How is this different from testing knowledge updates in a memory benchmark?
A knowledge-update question checks that the agent remembers the new value. An invalidation case also checks that bookings, messages and records built on the old value were found and redone, which is where long tasks usually fail.
Should the agent always adopt the newest information?
No. It should adopt changes from a source with authority over that fact and hold its belief when the change comes from someone without it. Include counterexample cases so a grader does not reward updating on any mention of a new value.
How many runs does each invalidation case need?
Enough to estimate consistency, because rework that happens in some runs but not others is the main risk. Report the share of tasks where all repeated runs succeed, alongside the control branch from the same checkpoint.
Can I inject the change by editing the agent's memory directly?
That tests whether the agent uses its memory, not whether it notices change in the world. Inject through the channel a real change would use, such as a record update or a message from the named authority.
Sources
- LongMemEval evaluates five core long-term memory abilities: information extraction, multi-session reasoning, temporal reasoning, knowledge updates and abstention. Source
- The tau-bench paper grades an agent by comparing the database state at the end of a conversation with an annotated goal state and proposes the pass^k metric for reliability across trials. Source
- The tau-squared-bench paper introduces a dual-control environment in which the agent and the user both have tools to observe, act on and verify a shared environment, and reports performance drops when agents move from no-user to dual-control settings. Source
- METR's paper defines an agent's time horizon as the length of tasks, measured by human completion time, that it completes with a 50% success rate. Source
- LangGraph documents forking from a prior checkpoint with update_state to create a new branch with modified state, notes that this does not roll back the thread, and says nodes after the checkpoint re-execute and may return different results. Source
- LangGraph documents checkpointers that persist a thread's graph state as checkpoints for thread-scoped memory, human-in-the-loop workflows, time travel and fault tolerance. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.