Picture someone asking an assistant questions about their own scattered data: calendar entries, workout logs, emails, music history, each stored in a different format with different field names. Partway through, the user says "no, not those." That correction is ambiguous. Either the system mapped the user's word to the wrong field (by "sessions" they meant workouts, not calendar meetings), or the user has actually changed what they want (they now care about weekends only). These two failures look identical in the transcript, but they call for opposite repairs. A word-to-field mapping that the user has corrected should be remembered and reused for the rest of the session. A preference the user has abandoned should be dropped. Current systems treat every past turn as one undifferentiated history. They either keep all of it, so stale wants linger, or they discount old turns by age, so hard-won fixes to word meanings get forgotten. This note proposes to keep two separate session stores, one for how the user's words map onto fields across sources and one for what the user currently wants, and to add a component that decides which store each correction belongs to.
The bet is that this attribution step, and not more agents, more retrieval, or more context, is the missing piece in multi-turn querying over heterogeneous data. Its value should show up specifically in sessions where vocabulary errors and genuine preference changes are interleaved, which is the normal case in exploratory analysis. The proposal builds a benchmark of such sessions with labeled corrections, a typed-state system, and the ablations needed to show whether the separation of state is what does the work.
Core Claim
Three bodies of work each handle one half of the problem and assume the other half away. On the drift side, Right Now, Wrong Then: Non-Stationary Direct Preference Optimization under Preference Drift (NS-DPO) down-weights older preference data by an exponential factor $\gamma^{T-t_i-1}$, where $T$ is the current time and $t_i$ the time of sample $i$. The research file notes its limitation directly: the weighting is uniform within a time step, so it cannot protect durable facts from the decay meant for drifting wants. Dynamic Adaptation to Preference Drift in Interactive Evolutionary Multi-Objective Optimization goes further and argues that smooth decay is insufficient, and that a discrete reset which purges conflicting history on detected change works better. A reset is exactly the wrong operation to apply to a corrected word mapping. On the vocabulary side, query rewriters such as RaFe: Ranking Feedback Improves Query Rewriting for RAG and Synergistic Interplay between Search and Large Language Models for Information Retrieval (InteR) bridge the gap between a user's phrasing and an index's phrasing, but they treat each query as a fresh, frozen information need. They therefore never accumulate session knowledge about what a particular user's words mean. On the data side, Recursive Question Understanding for Complex Question Answering over Heterogeneous Personal Data (REQAP) decomposes analytical questions into executable operator trees over multiple personal-data sources, and DBCopilot routes questions to the right schema. Both are single-shot and assume the user's intent is fixed.
The claim is that in multi-turn, multi-source querying, (a) a large share of final-answer errors comes from mis-attributed corrections: re-making a word-mapping mistake the user already fixed, or keeping a constraint the user abandoned; (b) a system that keeps a persistent "binding store" (user term to schema elements across sources) separate from a decaying-and-resettable "preference store" (current filters, groupings, priorities), and routes each correction to one store, removes most of these errors; and (c) the gain is concentrated in sessions that mix both correction types and should largely vanish in sessions that contain only one. Prediction (c) is what makes the claim falsifiable rather than a general "more structure helps."
Research Program
The system has a planner that turns the current request into a REQAP-style operator tree (RETRIEVE, FILTER, JOIN, AGGREGATE, EXTRACT). REQAP supplies this method, and we reuse it rather than compete with it. The planner reads two stores instead of raw history. The binding store holds entries of the form "user term → one or more schema elements in named sources," for example "sessions → workouts.activity; calendar.event where category = gym." Each entry carries the turn where it was established and how it was confirmed. Bindings are never time-discounted. They change only when contradicting evidence arrives. The preference store holds the user's active constraints and uses drift handling from the preference literature: exponential recency weighting as in NS-DPO, plus a reset of conflicting constraints when a change is detected, as in the multi-objective work. We use both because the file documents a real tension between smooth decay and reset. Applying them only to the preference store is the one situation where neither risks erasing durable knowledge.
The new component is the attribution step. When the user pushes back on a result, it forms two repair hypotheses. One is a rebinding: some user term should map to a different element, found by retrieving alternative candidates across all sources. The other is a preference edit: some constraint is added, removed, or changed. It scores them on three kinds of evidence. The first is lexical: does the user's phrasing have competing matches across sources? The second is referential: does the complaint mention field identity ("those are meetings, not runs") or values ("too many from last month")? The third is consistency: does the rebinding hypothesis, executed, satisfy every earlier confirmed constraint without any preference change? When the scores are close, the system does not ask an open clarification question. It shows the user a single contrastive pair, the two repaired results side by side, and lets them pick. This choice is driven by AcCoRD, which found that open-ended uncertainty prompting makes agents over-ask and exhaust interaction budgets. It found too that "triggered" preferences, the ones users discover only when they see concrete options, are where agents fail worst. A contrastive pair is a concrete option, so it can trigger the latent preference and resolve the attribution in one turn.
We treat role specialization as an implementation choice to be tested, not as the claim. Multi-agent work like MALADE, where a dedicated critic corrected the category agent in 44.5% of cases, and LEGO suggests that a separate checker catches errors a generator misses. It is therefore plausible that attribution works better as its own agent with its own context. But a single model writing to a typed scratchpad might do just as well, and the experiments include that ablation.
The benchmark is the main artifact. We start from PERQA: 20 personas, roughly 40,000 events each across workouts, email, calendar and music, and 3,567 analytical questions. We turn its questions into multi-turn sessions using an LLM user simulator in the style of AcCoRD. Each simulated user has a hidden goal script with scheduled preference changes and speaks in colloquial vocabulary deliberately mismatched to field names, following the vague-question construction of Spider-real used in DBCopilot. Because we script both the goal changes and the vocabulary substitutions, every user correction carries a ground-truth label: lexical, preference, or both. Sessions are stratified into lexical-only, drift-only, and mixed. To test transfer beyond personal data, we build a smaller relational variant from BIRD databases that requires cross-database joins, which DBCopilot explicitly does not support. We also evaluate unchanged on AcCoRD-Shop and AcCoRD-Travel, where we can only measure outcome and not attribution.
Baselines
The naive reference point is a stateless rewriter. At each turn, the latest user message plus the previous system answer is rewritten into a standalone question, RaFe style but without its trained rewriter, and passed to REQAP. Nothing is remembered beyond one turn. This shows how much any session memory is worth at all.
The strongest existing method for the underlying single-turn task is REQAP. On single-turn PERQA it reports 38.6% Hit@1 with GPT-4o, against 14.9% for standard retrieval-augmented generation, and 38.0% with a distilled 1B LLaMA model (REQAP). On our multi-turn sessions we run REQAP with the full concatenated session history in its prompt. This "full-history REQAP" is the most important competitor, because it is exactly what a practitioner would build. There is no reported result on Lacuna for any system on multi-turn, drift-plus-mismatch sessions over PERQA, so we report REQAP's single-turn number as an anchor and measure everything else ourselves. For interactive agents, the reference is AcCoRD's finding that frontier models reach a perfect outcome in under 30% of scenarios, with triggered-preference scores as low as 0.09 (AcCoRD). We run its ReAct and UncReAct agents on our sessions and run our system on AcCoRD's environments.
Two drift baselines isolate the key ingredient. The first, uniform-decay history, keeps all prior turns but weights or prunes them by NS-DPO-style exponential recency, with $\gamma$ tuned on a development split. The second, uniform-reset history, clears all prior state when a change detector fires, following the multi-objective drift paper. Both apply drift handling to the whole history rather than only to preferences. If they match our system, then separating the stores adds nothing.
The ablations are as follows. The first is a single model writing to the same two typed stores, which tests whether separate agents matter. The second gives the system oracle attribution labels, which bounds what better attribution could buy. The third uses inverted attribution, sending lexical fixes to the decaying store and preference changes to the persistent one; this sanity check should be clearly worst on mixed sessions. The fourth removes the contrastive probe and substitutes an open clarification question.
All systems use the same backbone models (one frontier API model and one open 8B-class model), the same REQAP executor, and the same simulator seeds. They get equal prompt-tuning budgets on a shared development split and the same cap on user-facing turns. Beating the strongest competitor means a statistically significant improvement in final-turn Hit@1 over full-history REQAP on mixed sessions, at equal or fewer user turns, with paired bootstrap over sessions. It must also show a large reduction in the two specific error types described below.
Why not just…?
Why not just give a long-context frontier model the whole session and let it sort things out? This is the real threat. A strong model reading the full transcript may infer implicitly which corrections were about words and which were about wants. The file's evidence against monolithic prompting comes from single-turn settings: REQAP's 38.6% versus 14.9% for plain retrieval, and DBCopilot's 4.43% to 11.22% execution-accuracy gains from separating routing and generation. That evidence does not settle the multi-turn question. We settle it in two ways. Full-history REQAP is the main baseline. We also probe the full-history model by asking it to label each past correction as lexical or preference, then compare its accuracy with our attribution step against the ground-truth labels. If its implicit attribution is near the oracle and its final accuracy matches ours, the idea is unnecessary and we will say so.
Why not just discount old turns, as NS-DPO does for old preference data? Recency weighting handles drift but treats a word-mapping fix from turn two as just as stale as an abandoned filter from turn two. The file flags this limitation of NS-DPO's uniform time weighting. The uniform-decay and uniform-reset baselines test it directly. Our prediction is specific: they should match us on drift-only sessions, where there is nothing durable to forget. They should fall behind on mixed sessions through a higher "re-mismatch rate," meaning the system repeats a lexical error the user already corrected.
Why not just rewrite each turn from scratch with a strong query rewriter or dense retriever? Stateless rewriting, as in RaFe or InteR, has the opposite problem. Every turn re-pays the vocabulary cost, and the system cannot learn that this user's "sessions" means workouts. InteR also reports that iterating retrieval-and-expansion past two rounds adds noise, which argues against simply looping a rewriter until the answer stabilizes. The stateless baseline measures this cost. We expect it to be competitive on drift-only sessions and weakest on lexical-heavy ones.
Why not just use one agent with a structured memory? That may be enough, and it is an ablation rather than a strawman. If the single-model typed-store variant matches the multi-agent version, the contribution is the typed state and the attribution rule, and we report it that way. The multi-agent version earns its cost only if it attributes more accurately, which MALADE's critic results make plausible but do not establish.
Proposed Experiments
The decisive experiment is the stratified comparison on PERQA-derived sessions. The claim holds if three things happen together. On mixed sessions, the typed-state system beats full-history REQAP and both uniform drift baselines in final-turn Hit@1. On lexical-only and drift-only sessions, the gap shrinks substantially. The inverted-attribution ablation is worst on mixed sessions. Gains spread evenly across all strata would point to generic extra structure rather than attribution, and would undercut the claim.
Alongside accuracy, we measure the two error types the idea targets. The re-mismatch rate is the fraction of turns that repeat a corrected binding error. The stale-constraint rate is the fraction of answers still applying a constraint the script retired. We also report attribution accuracy against the labels, the gap to oracle attribution, user turns to recovery after a scheduled change, and total tokens per session, since the file documents latency and cost as the standing weakness of multi-agent loops (LEGO).
A second experiment tests the contrastive probe. On AcCoRD-Shop and AcCoRD-Travel, we compare it with open clarification and with UncReAct on triggered-preference scenarios, measuring perfect-outcome rate and turns used. Success means improving triggered-preference scores without the over-asking AcCoRD observed. A third experiment tests transfer to the BIRD-derived cross-database sessions. Here bindings span several databases, so a correct rebinding can turn an unanswerable single-database route into a valid join. We measure execution accuracy against full-history and DBCopilot-style single-database routing.
Finally, we check that the simulator is not doing the work. We hand-annotate a few hundred real-language corrections from human pilot sessions on PERQA personas and verify that attribution accuracy on human corrections stays within a modest margin of its accuracy on simulated ones. If it does not, the benchmark is measuring the simulator's quirks, and we revise the simulator before drawing conclusions.
References
- Right Now, Wrong Then: Non-Stationary Direct Preference Optimization under Preference Drift
- Dynamic Adaptation to Preference Drift in Interactive Evolutionary Multi-Objective Optimization
- RaFe: Ranking Feedback Improves Query Rewriting for RAG
- Synergistic Interplay between Search and Large Language Models for Information Retrieval
- Recursive Question Understanding for Complex Question Answering over Heterogeneous Personal Data
- DBCopilot: Natural Language Querying over Massive Databases via Schema Routing
- AcCoRD: Evaluating User-Agent Collaboration Under Realistic User Preference Dynamics
- MALADE: Orchestration of LLM-powered Agents with Retrieval Augmented Generation for Pharmacovigilance
- LEGO: A Multi-agent Collaborative Framework with Role-playing and Iterative Feedback for Causality Explanation Generation