Language models answer questions about a changing world with facts frozen at their training date. Giving them fresh documents through retrieval, meaning a search step that pastes relevant text into the prompt, helps less than expected. When the pasted text is itself out of date, models trust it over their own correct knowledge. Even when the right, current fact is sitting in the prompt, they often reach for an older, more familiar one, and asking them to reason step by step makes this worse. We argue these failures share one cause. The model is left to decide, inside free-running text, which of several conflicting facts with different dates is still true, and it decides badly.
We propose a two-stage generator. The first stage writes a dated content plan: a short list of the claims the answer will make. Each claim is tagged with the date its evidence was written, the date the fact started holding, how long such facts typically last, and where it came from (the model's own memory or a retrieved passage). A small deterministic rule, not the language model, then picks which version of each claim survives. A second stage turns only the surviving claims into fluent text. Because every claim passes through a fixed set of decision points, any wrong answer can be traced to a specific stage and failure type without a separate diagnosis model. In two sentences: separate what to say from how to say it, add dates to the what, and let a fixed rule rather than the model settle conflicts between old and new facts. The record that rule leaves behind doubles as an automatic classification of temporal errors.
Core Claim
The central hypothesis is that temporal hallucination is mostly an arbitration failure, not a knowledge failure. The evidence is already in the literature. When Benchmarks Age audits factuality benchmarks against current facts and documents a "Context Trap": a stale retrieved snippet overrides correct internal knowledge. Can Agent Memory Systems Track Evolving State? finds that state drift (answering with a superseded value) persists even when all the relevant information is in the prompt, and that chain-of-thought lowers accuracy because models spend the extra tokens justifying the salient older fact. Empty Shelves or Lost Keys? finds that parametric failures are often recall failures rather than missing knowledge.
If the information is present but misused, the fix is to change who decides, not to add more information. We claim that moving the decision into a typed, dated record, resolved by a rule the model cannot argue with, will beat the same model making the same decision in text with identical inputs. That model-versus-rule ablation is the decisive test of the proposal.
The secondary claim is about diagnosis. Post-hoc attribution, meaning reading a finished trace and guessing which step went wrong, is hard: on AgentHallu the best model localizes the responsible step only 41.1% of the time. A pipeline whose intermediate record names the deciding evidence for every claim should make attribution largely a lookup.
Relation to Prior Work
Several systems already split generation into stages to reduce hallucination. Each one motivates part of the design and leaves the temporal decision untouched.
Step-by-Step plans over data triples before realizing them as text, and reports 90% fewer hallucinated facts on WebNLG. Its triples carry no dates, so a superseded fact is verbalized as faithfully as a current one. We reuse its plan-then-realize split and add validity information to the plan.
SeeKeR searches, copies phrases from results, then responds. Its copy-only step is a useful factual bottleneck, but it copies whatever the search engine ranks highest, stale or not.
WikiChat generates a draft, extracts its claims, and checks each against Wikipedia as supported, refuted, or unknown. It reaches above 94% accuracy on recent topics, against 47.5% for GPT-4. However, its check asks only whether a passage supports a claim, not whether that passage is still current, so it inherits the Context Trap whenever the corpus holds both versions. It is the strongest architectural competitor.
Monitoring Decoding revises suspicious tokens using a larger reference model. Its authors note the method is blind to facts both models lack, which covers all post-cutoff facts.
On the temporal side, Mitigating Temporal Misalignment by Discarding Outdated Facts supplies a method we reuse: predict how long a fact typically lasts and lower confidence once the gap between question date and evidence date exceeds that lifespan. Its own stated limitation is that it ignores when a fact started, so it cannot place the expiration point. Our plan records start dates extracted from evidence, which fixes that limitation. Its output also only triggers retrieval; it never constrains the generated text.
StateMem, from Can Agent Memory Systems Track Evolving State?, tracks dependencies between memory units, and its "trace-then-resolve" wrapper asks the model to write out a timeline before answering. This is the closest idea to ours. The difference is that the wrapper still lets the model resolve the timeline in text. We test directly whether a rule-based resolver beats that.
DateLogicQA shows that accuracy depends on how a date is written (57% in "YYYY, Mon DD" format, 31% in compressed formats). This constrains our design: dates in the plan must be stored in a single normalized format, not copied verbatim from sources.
TARDIS shifts hidden states toward a target time period, but only for classification tasks. Bold Claims or Self-Doubt? separates confident from uncertain hallucinations using sampling agreement. We use that signal as one tag on parametric claims, not as the decision rule.
Research Program
The planner is an instruction-tuned open model, for example Qwen2.5-14B or Llama-3-8B. Given a question and its date $t_q$, it first lists the facts the answer needs without retrieval. Each one is tagged as parametric and given a confidence score from agreement across samples.
The system then retrieves passages for each fact. Each passage is converted into a candidate record holding four things: a value; an evidence date $t_E$ (from document metadata, or from date expressions in the text); a fact start date $t_s$ when the text states one; and a typical lifespan $\hat d$ from the duration predictor of Zhang and Choi, fine-tuned on the TimeQA and TimePre data that paper uses. All dates are normalized to ISO format at this point.
The resolver is about thirty lines of code. For each fact it discards candidates whose expected expiry, $t_s + \hat d$ (or $t_E + \hat d$ if no start date is known), falls before $t_q$ with probability above a threshold. It then keeps the surviving candidate with the latest start date, breaking ties by evidence date. If nothing survives, it emits an explicit "unknown as of $t_q$" claim rather than falling back to the parametric value. Parametric claims are allowed to win only if no retrieved candidate is newer than the training cutoff.
The realizer is the same base model, prompted to verbalize only the resolved claims, with a copy constraint on values in the style of SeeKeR. A claim-level check after generation flags any value in the output that is not in the plan.
The resolver's log is the taxonomy. Each wrong final claim falls into exactly one of seven categories:
- no candidate retrieved (retrieval insufficiency, the category RealTime QA blames for 34% of its errors);
- the correct candidate was retrieved but expired by the duration model (lifespan underestimate);
- a stale candidate survived (lifespan overestimate or a missing start date);
- dates were wrongly extracted or normalized (the representation failure documented by DateLogicQA);
- a parametric value won when it should not have;
- the realizer departed from the plan;
- the question itself was misread.
We will check this taxonomy against human labels on a sample, and against an LLM attributor in the style of AgentHallu run on the same traces.
Baselines
The naive reference point is closed-book answering by the same base model with the question date stated in the prompt. It tells us how much any retrieval-based method adds.
The second reference is plain retrieval-augmented generation over the same time-stamped corpus, with no plan. It is the setting in which the Context Trap was observed.
The strongest architectural baseline is WikiChat's seven-stage pipeline, reimplemented with the same base model, the same retriever, and the same corpus snapshot. To keep the comparison fair, it gets an equal number of language-model calls per question and has its prompts tuned on the same development split with the same budget. On its own benchmark WikiChat G4 reports above 94% factual accuracy on recent topics. Beating it means higher accuracy on questions where the corpus holds conflicting versions of a fact, with no loss on stable-fact questions.
The strongest temporal baseline is the adaptive retrieval method of Zhang and Choi. It reports 20.5 exact match on SituatedQA while retrieving on 45% of queries. The best fine-tuned retrieval model in the original SituatedQA paper reaches 23% exact match, and humans reach about 57%. We rerun the Zhang and Choi method on the same backbone so that differences reflect method, not model size.
On StateMemBench we compare against StateMem and StateMemWrapper, run with the same backbone. StateMem reports current-state accuracy rising from 0.205 to 0.363 on DeepSeek-V4-Flash, and the wrapper reports gains of +32 to +67 points across six memory backends. Since we cannot assume access to that exact backbone, we rerun both on ours.
On RealTime QA the reported reference is 66.5% multiple-choice accuracy and 34.6 exact match for GPT-3 with Google search. We will rerun a search-plus-read baseline on our backbone rather than compare to that number directly.
The key ablation keeps everything identical, including the full dated plan in the prompt, but replaces the deterministic resolver with the language model told to "choose the currently valid value." This isolates the core ingredient. Two further ablations remove start dates (recovering Zhang and Choi's setting) and remove date normalization.
No reported result was found on Lacuna for any method on an injected stale-context condition, so that setting has no prior number.
Why not just…?
Why not just let the model write a timeline first, as StateMemWrapper does? This is the most serious threat. The wrapper's gains of +32 to +67 points show that making the change history explicit already helps a great deal. Our bet rests on the same paper's finding that extra reasoning tokens get spent rationalizing salient stale facts. The model-resolver ablation settles the question directly: if the model choosing from our dated plan matches the rule, then the contribution reduces to better plan construction. We would report it that way and drop the rule claim.
Why not just use WikiChat with a fresher corpus? A fresher corpus does not remove older passages that sit alongside newer ones, and WikiChat's "supported" judgment cannot tell current support from outdated support. Most retrieval corpora contain both versions of a changed fact, which is the setting where the Context Trap appears. The injected-staleness experiment below measures this gap. If WikiChat stays robust when stale passages are injected, the proposal's motivation fails.
Why not just add a prompt line like "prefer the most recent source"? This is cheap and may capture much of the gain. It is included as a baseline. Our prediction is that it fails for two reasons. First, recency of publication is not recency of fact: a 2024 article can describe a 2019 state of affairs, which is exactly why we record start dates. Second, prompt instructions do not stop the realizer from drifting back to parametric values.
Why not just steer hidden states toward the present, as TARDIS does? Steering has only been shown on classification, and it gives no per-claim record. We treat it as a secondary baseline on SituatedQA but do not expect it to resolve specific conflicting values.
Proposed Experiments
The main evaluation uses four sources. The first is the temporal split of SituatedQA, scored with exact match and expected calibration error. The second is RealTime QA's real-time questions, against a corpus snapshot frozen at each question's date. The third is the time-sensitive subsets of BoolQ and NQ-Open re-labeled with current answers by the When Benchmarks Age pipeline, scored against updated labels so that correct current answers are not penalized. The fourth is StateMemBench, with dialogue turns converted into dated records. DateLogicQA is used to measure whether date normalization removes the gap between date formats when questions are routed through the plan.
The decisive experiment injects stale evidence. For each SituatedQA and RealTime QA question we add one superseded but topical passage to the retrieved set, at rank 1 or rank 3. We then measure how often each system switches from a correct answer to the stale one. The proposal is confirmed if three things hold:
- this flip rate falls well below both plain retrieval and WikiChat;
- the deterministic resolver beats the model-resolver ablation by a margin outside bootstrap confidence intervals;
- the gain is concentrated in questions whose correct candidate has an explicit start date.
That last pattern is what we would expect if start dates, rather than general prompt hygiene, are doing the work.
For attribution, we deliberately insert each of the seven failure types: deleting the evidence, perturbing the duration estimate, reformatting dates, injecting stale passages, and so on. We then check whether the resolver's log assigns the error to the planted category, comparing against an LLM attributor in the style of AgentHallu reading the same traces.
Failure would also be informative. If most residual errors land in the "no candidate retrieved" category, the bottleneck is retrieval, not arbitration, and the field should invest there instead.
References
- When Benchmarks Age: Temporal Misalignment through Large Language Model Factuality Evaluation
- Can Agent Memory Systems Track Evolving State?
- Empty Shelves or Lost Keys? Recall Is the Bottleneck for Parametric Factuality
- AgentHallu: Benchmarking Automated Hallucination Attribution of LLM-based Agents
- Step-by-Step: Separating Planning from Realization in Neural Data-to-Text Generation
- Language Models that Seek for Knowledge: Modular Search & Generation for Dialogue and Prompt Completion
- WikiChat: Stopping the Hallucination of Large Language Model Chatbots by Few-Shot Grounding on Wikipedia
- Monitoring Decoding: Mitigating Hallucination via Evaluating the Factuality of Partial Response during Generation
- Mitigating Temporal Misalignment by Discarding Outdated Facts
- DateLogicQA: Benchmarking Temporal Biases in Large Language Models
- TARDIS: Mitigating Temporal Misalignment via Representation Steering
- Bold Claims or Self-Doubt? Factuality Hallucination Type Detection via Belief State
- RealTime QA: What's the Answer Right Now?
- SituatedQA: Incorporating Extra-Linguistic Contexts into QA