Agent memory breaks when facts change. Given

#0    "User lives in Delhi"
#41   "User lives in Bangalore"
#306  "User lives in Mumbai"

ask "Where did I live before Mumbai?" and production memory systems guess: on the public conflict benchmark (MemoryAgentBench, ICLR 2026) Mem0 scores 18% and Zep/Graphiti 7% — because every version of the fact lands in the prompt and one model call must untangle ordering, meaning, and answer at once.

Don't Ask the LLM to Track Freshness (May 2026) showed the fix for the simplest case: let the LLM only find relevant facts, then pick the newest with Python max() — jumping single-hop accuracy to ~95%. But max() answers exactly one question shape. Real questions about changing facts have four:

tempora implements the missing three, plus the one-call router that picks the right one.

Architecture

question ─────────────────────────────────────────────┐
   │                                                  │
   ▼                                                  ▼
route()                 LLM sees only the question:   extract()   LLM sees facts + question:
"what KIND of           returns one label             "which facts are about this
question is this?"      current|previous|             subject?" Told explicitly NOT to
                        count|history                 judge recency. Returns ALL versions.
   │                                                  │
   └────────────────────┬─────────────────────────────┘
                        ▼
                   resolve()          pure Python: sort candidates by serial,
                                      dedupe, apply the one-line operator.
                                      No LLM. Cannot hallucinate ordering,
                                      cannot miscount, fully auditable.

Two constrained LLM calls for understanding; zero LLM involvement in the temporal logic.

Results

Both arms below share identical BM25 retrieval and identical candidate extraction — the only difference is whether the deterministic step knows more operations than max(). Questions are generated mechanically from MemoryAgentBench's own fact conflicts, so gold answers are computed from data, never by an LLM.

The residual gap is candidate-extraction misses on a small open model, not resolver error — the resolvers are pure functions with unit tests.

We also reproduce the freshness paper's single-hop pipeline at 91% (openai/gpt-oss-120b, n=100, 6k context), against published memory-system baselines of 54% (HippoRAG-v2), 18% (Mem0), and 7% (Zep/Graphiti).

Install

pip install git+https://github.com/nitininhouse/tempora.git

Core has a single dependency (rank-bm25, used only by the benchmarks). No LLM SDK: you pass any callable (system: str, user: str) -> str.

Quickstart

import os
from tempora import answer
from tempora.llm_helpers import openai_compatible   # optional convenience

llm = openai_compatible(api_key=os.environ["GROQ_API_KEY"])   # any OpenAI-compatible endpoint

facts = [                     # (serial, text) — higher serial = recorded later
    (0,   "User lives in Delhi."),
    (41,  "User lives in Bangalore."),
    (306, "User lives in Mumbai."),
]

answer("Where did the user live before Mumbai?", facts, llm)
# {'answer': 'Bangalore', 'operator': 'previous', 'candidates': [...]}

Run python examples/quickstart.py for all four operators against the same facts.

API

Reproduce the numbers

pip install -e ".[bench]"
export GROQ_API_KEY=...                  # or any OpenAI-compatible endpoint via base_url
cd benchmarks
python generate_operator_set.py          # 160 questions from real MAB conflicts
python run_operators.py                  # baseline vs tempora, per-operator table
python run_freshness.py                  # single-hop reproduction

Prior art, honestly

• Don't Ask the LLM to Track Freshness proved deterministic-newest beats LLM judgment and named non-freshness operators as open future work. tempora is that future-work section, built.
• Temporal KGQA (TEQUILA, CronKGQA) used operator decomposition — before/after/first/last — over structured temporal knowledge graphs years ago. Agent memory forgot this; tempora re-applies the idea to serial-ordered conversational facts.
• Zep/Graphiti stores bitemporal history and Mem0 exposes a history() API — storage without question routing, which is how a system that stores history still scores 7% answering questions about it.

Limitations

• Operator set derives from one benchmark's synthetic conflicts; phrasing diversity is limited.
• Serial order stands in for time. Inferring order from language ("after I graduated…") is the next milestone.
• Four operators. Real usage will want as-of(date), still-valid, duration.
• Multi-hop conflict chains remain open here as everywhere (published best ≤7%; the freshness paper's chain extension reaches ~30%).

License

MIT © Nitin Gupta