Language models are poor at two problems that turn out to be one problem. The first is higher-order theory of mind, meaning reasoning about nested beliefs such as "Alice thinks Bob believes the meeting moved to Tuesday." Accuracy collapses as the nesting gets deeper. The second is knowledge obsolescence, where a model keeps using a fact after it has been superseded, even when the newer value is sitting in its context window. Our proposal rests on a simple observation. In settings where facts change over time, every nested belief is a question about staleness. "What does Alice think Bob believes about X?" amounts to asking for the most recent update to X that Alice knows Bob witnessed, and then returning X's value at that moment. Answering it well requires three things: a log of updates, a record of who observed each update, and a lookup. Long chains of free-form reasoning are not needed.
We propose a team of narrowly scoped language-model agents. Each agent reads only the slice of the transcript that one character could have observed, and records which updates that character witnessed and when. A small deterministic program then resolves any belief question, of any nesting depth, by finding the latest jointly witnessed update. A separate communicator role uses the resulting "who holds a stale value" sets to decide which teammates to update, so the system can act on beliefs as well as report them. The claim is that this decomposition removes the main failure mechanisms documented on both sides. On the theory-of-mind side these are perspective leakage and error compounding in chain-of-thought. On the obsolescence side the failure is anchoring on loud but outdated facts. We expect the advantage over single-call prompting to grow with the number of updates, the length of the interaction, and the gap between reporting a belief and acting on it.
What the evidence says and where the gap is
Three findings motivate the proposal. The Hi-ToM benchmark shows two failure patterns as nesting deepens: accuracy falls sharply by fourth order, and models give the same answer to high-order and low-order questions. It also finds that chain-of-thought hurts on deceptive stories because early mistakes compound. StateMem finds the mirror-image failure for a single agent tracking changing facts, which it calls state drift. Drift persists even when every relevant fact is in context, and reasoning traces make it worse because the model uses its extra tokens to rationalize the outdated value. EnactToM shows that models which answer belief probes correctly still fail to act on them. It reports 0.0% Pass^3 (success on all three of three independent runs) on hard embodied tasks, and attributes 93% of failures to epistemic coordination, such as withholding information a partner needed.
Three lines of work supply methods we reuse. Decompose-ToM breaks an n-th order question into first-order "pretend-play" simulations that filter the story to one character's view. It raises GPT-4o's fourth-order Hi-ToM accuracy from about 43% to 83.3%, but it works on closed stories and reports a snowball effect in 8B models, where one early tracking mistake ruins every later recursion. DEL-ToM formalizes belief updates in dynamic epistemic logic, a formal logic of how announcements and observations change what agents know. It trains a process verifier to score candidate reasoning traces and reaches 87.0% on Hi-ToM with Qwen3-4B under beam search, but it relies on synthetic updates from its own simulator. StateMem's dependency graph invalidates derived facts when a base fact changes, and its trace-then-resolve wrapper makes a model list a fact's values in chronological order before answering. Both are single-agent and record nothing about what anyone else knows.
The multi-agent coordination work constrains the design. A-ToM shows that fixing every agent at a high reasoning depth produces an "overthinking trap": two depth-1 agents score 0.00 in a repeated matrix game, while an adaptive agent scores 75.00. Deeper reasoning is therefore not automatically better. A-ToM estimates how deeply a partner reasons, but never asks whether the partner's facts are outdated. The role-specialization results in Self-collaboration and LEGO show that separating generation from checking breaks confirmation bias. Self-collaboration also warns that models under 13B struggle to stay within role boundaries.
None of these systems handles beliefs about other agents' beliefs when the underlying facts change over long, multi-party interactions. The question "does Bob know the value changed, and does Alice know whether Bob knows?" sits exactly in that gap. StateMem explicitly leaves the multi-agent case as future work.
Core Claim
Under changing facts, a k-th order belief reduces to finding the latest update visible along a perspective chain. Write $W_a$ for the set of update events that agent $a$ observed. Write $W_{a \to b}$ for the subset of those events where $a$ also observed that $b$ observed them, for example because they were in the room together or because $a$ sent $b$ a message $a$ knows was received. Let $v_x(s)$ be the value of variable $x$ immediately after event $s$. The system's answer for "what does $a_1$ think $a_2$ thinks … $a_k$ believes about $x$ at time $t$" is
$$\hat{b}_{a_1 \cdots a_k}(x,t) = v_x(\tau), \qquad \tau = \max\{\, s \le t : s \in W_{a_1} \cap W_{a_1 \to a_2} \cap \cdots \cap W_{a_{k-1} \to a_k},\ s \text{ updates } x \,\}.$$
A variable is stale for a perspective chain whenever $\hat{b}$ differs from the current true value of $x$. This single rule covers ordinary obsolescence (the chain has length one and the agent missed the update) as well as nested false beliefs. The rule itself is trivial to run. The hard, error-prone part is building the witness sets from natural language. We therefore assign that part to the language model, and only in a form that can be checked locally.
Deception and hearsay need one extra rule. A public claim or a private whisper is logged as an update event carrying a source tag. An agent's own direct observation takes precedence over hearsay that arrived earlier. Whether this precedence rule matches the conventions used in Hi-ToM's deceptive stories is an empirical question we test, not an assumption we make.
Research Program
The system has four roles, and the decomposition follows lines of information access rather than generic job titles.
The first role is a set of per-character observers. Each is a language-model instance that sees only the transcript events its character could perceive. It writes entries to that character's ledger: the variable, the value, the timestamp, who else was present, and the source. Restricting each observer's context is aimed directly at perspective leakage, where the model's omniscient view seeps into a character's beliefs, as documented in Evaluating Theory of Mind in Question Answering.
The second role is a deterministic resolver. It evaluates the equation above for any nesting depth, and it propagates invalidation through StateMem-style derived_from links across ledgers. For example, if Alice's plan was built on a value Bob told her, and that value later changed in a session Alice missed, her plan is flagged as stale.
The third role is an extraction critic. It audits one ledger entry at a time against the raw transcript span that produced it. It never sees the final question, so it cannot rationalize toward an answer. This is the analogue of separating coder from tester, but applied to extraction rather than to reasoning chains, which is where we expect the 8B snowball effect to originate.
The fourth role is a communicator, used only in interactive tasks. It ranks stale variables by how many downstream plan steps depend on them and spends the message budget on the highest-ranked ones. This is the act-on-beliefs step that EnactToM shows is missing.
The analysis program asks where errors arise. Every end-task error will be attributed to one of three sources: a wrong ledger entry, the resolver's precedence rule, or the action policy. If most errors turn out to be extraction errors, the paper's contribution shifts from "decomposition fixes reasoning" to "the reasoning was never the bottleneck." That would be an important finding in its own right, and we will report it either way.
Benchmarks and data
Existing benchmarks cover static higher-order belief tracking: Hi-ToM up to fourth order with deception, FANToM's multi-party conversations where characters leave and rejoin (FANToM), and the adversarially generated ExploreToM stories (paper). Single-agent obsolescence is covered by StateMemBench (234 multi-session scenarios). Functional coordination is covered by EnactToM.
None of these crosses higher-order beliefs with long-horizon changes, so we will build two derived splits. The first extends StateMemBench into a multi-party version: participants are assigned to sessions, so a fact can change while some of them are absent. Questions are then generated up to third order using the equation above. The second uses ExploreToM's program-guided generator, which offers search-based adversarial story construction, to add repeated updates to the same variable and long temporal gaps between them. Both splits come with exact gold answers because the generators know the true witness sets. We will release the generators and avoid relying on a single fixed test set.
Baselines
The naive reference point is a single long-context model given the full history and the question, with and without chain-of-thought. Prior work predicts this baseline will degrade with nesting depth and with the number of updates. On FANToM, GPT-4 scores 12.3% on the strict all-question-types metric against 87.5% for humans (FANToM). On StateMemBench, DeepSeek-V4-Flash reaches 0.205 current-state accuracy (StateMem).
The strongest existing methods for nested belief questions are Decompose-ToM and DEL-ToM. Decompose-ToM reports GPT-4o at 83.3% on Hi-ToM fourth order, and DEL-ToM reports Qwen3-4B with its verifier under beam search at 87.0% on Hi-ToM. We will run both on the same backbone models as our system. DEL-ToM's verifier will be retrained on DEL labels converted from our new splits, so it is not handicapped on new data. Every method gets the same budget of model calls and output tokens per question, with that budget set by our system's median usage, and DEL-ToM may spend its share on Best-of-N.
For changing facts, the strongest competitors are StateMem and StateMemWrapper. StateMem reaches 0.363 with DeepSeek-V4-Flash, and the wrapper gives lifts of +32 to +67 points across six backends. On the functional side the reference is EnactToM's reported 0.0% Pass^3 for frontier models on the hard split. Its reported 6.7% average functional success for Gemini-Pro applies to the benchmark overall rather than to the hard split, and we will run our own backbone baselines on identical splits.
Beating the strong baselines means two things. On the new multi-party, changing-fact splits, we must exceed the best of Decompose-ToM, DEL-ToM, and the perspective-chain wrapper described below by a margin larger than seed-to-seed variance, at third order and above. On Hi-ToM itself, we must not fall below the published numbers.
The ablations isolate each ingredient. Removing timestamps, so that the resolver uses co-presence only, tests whether staleness is really the key quantity. Giving observers the full transcript tests context isolation. Replacing the deterministic resolver with an LLM call tests whether a symbolic lookup matters once the ledgers are correct. Removing the critic tests whether verifying extraction is where checking pays off. A gold-ledger oracle, which feeds true witness sets to the resolver, gives an upper bound and cleanly separates extraction error from resolution error.
Why not just…?
Why not just apply StateMemWrapper, asking one model to list each perspective's timeline before answering? This is the most serious threat, and we take it seriously enough to build it ourselves. We will extend the wrapper so that it traces, in a single call, which updates each character in the perspective chain witnessed. On short Hi-ToM stories it may match our system, and if it does we will say so. Our prediction is that it degrades as interactions span many sessions and many updates. A single call must then keep several perspective timelines separate in one context, which is exactly the isolation that Hi-ToM and the question-answering leakage study show models lack. The decisive check is accuracy as a function of the number of updates and the number of characters. If the wrapper's curve stays flat alongside ours, the multi-agent decomposition is unnecessary and the contribution reduces to the witness-set formulation.
Why not just add timestamps to Decompose-ToM? Decompose-ToM already filters the story to one character's view, so this version is plausible and we will run it as a baseline. The difference lies in where errors can compound. Decompose-ToM recurses through language-model steps, and the paper itself reports that a single early mistake ruins later recursions in 8B models. In our design, recursion depth costs nothing extra once the ledgers exist, because the lookup is deterministic. We predict that Decompose-ToM's error grows with order while ours stays flat given the ledgers. The 8B-model comparison will show whether that holds.
Why not just use a symbolic belief tracker with no language models at all? On fully structured synthetic stories, a symbolic tracker would essentially solve the problem, and our resolver is one. What it cannot do is read FANToM conversations or StateMemBench sessions and decide who perceived what. The gold-ledger oracle condition quantifies exactly how much of the problem is perception versus logic. If the oracle is near perfect and extraction is the bottleneck, that tells the field where to work.
Why not just reason more carefully with chain-of-thought or raise every agent's reasoning depth? Chain-of-thought hurts on both deceptive higher-order stories (Hi-ToM) and changing-state tracking (StateMem). Fixed high reasoning depth causes coordination failures (A-ToM). Our system adds no free-form reasoning at answer time. We include the chain-of-thought baseline to confirm that these known failures reproduce on the new splits.
Decisive experiments
The central experiment plots accuracy against the number of updates per variable and against nesting order, from one to four, on the multi-party StateMemBench and ExploreToM splits. It compares our system, the perspective-chain wrapper, Decompose-ToM, and DEL-ToM, using 8B and frontier backbones under matched call budgets. The claim survives only if our curve is flatter than every baseline's, the gap is largest on long-horizon, many-update scenarios, and the gold-ledger oracle shows that the remaining error is mostly extraction.
The second experiment tests whether better belief tracking leads to better action. On EnactToM's hard split, measured by Pass^3, we ask whether communicating by stale-set priority beats both the same agents without the communicator and an A-ToM-style depth-adaptive policy. Any nonzero Pass^3 on the hard split would already exceed the reported 0.0%. The meaningful test, however, is whether gains concentrate in the information-withholding failures that make up EnactToM's 93% epistemic-coordination error share.
The third experiment checks generalization. We run unchanged on Hi-ToM's deception splits and on FANToM's strict "All" metric to confirm that the hearsay precedence rule does not break where the benchmarks assume different conventions about trust.
References
- Hi-ToM: A Benchmark for Evaluating Higher-Order Theory of Mind Reasoning in Large Language Models
- Can Agent Memory Systems Track Evolving State?
- EnactToM: An Evolving Benchmark for Functional Theory of Mind in Embodied Agents
- Decompose-ToM: Enhancing Theory of Mind Reasoning in Large Language Models through Simulation and Task Decomposition
- DEL-ToM: Inference-Time Scaling for Theory-of-Mind Reasoning via Dynamic Epistemic Logic
- Adaptive Theory of Mind for LLM-based Multi-Agent Coordination
- Self-Collaboration Code Generation via ChatGPT
- LEGO: A Multi-agent Collaborative Framework with Role-playing and Iterative Feedback for Causality Explanation Generation
- Evaluating Theory of Mind in Question Answering
- FANToM: A Benchmark for Stress-testing Machine Theory of Mind in Interactions
- Explore Theory of Mind: program-guided adversarial data generation for theory of mind reasoning