💬 NLP

Tokengeist: Multi-Turn Attribution Tracing in Agentic Conversations

This paper introduces Tokengeist, a scalable framework that addresses the limitations of single-pass attribution methods in multi-turn conversations by recursively tracing token-level dependencies across conversation turns, achieving significantly higher accuracy in recovering complex provenance graphs compared to existing approaches.

Original authors: Jessica Tang, Shraddha Barke, Sharad Agarwal

Published 2026-07-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jessica Tang, Shraddha Barke, Sharad Agarwal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to figure out why your favorite detective character in a TV show suddenly decided to solve a case in a specific way. You know the final answer, but the show jumps around in time, showing the detective talking to a witness, then checking a map, then calling a friend, and finally making a decision. If you only looked at the very last scene, you might think the decision came from the friend. But what if the friend was just repeating something the witness said, who got the info from the map? To truly understand the story, you can't just look at the final moment; you have to trace the trail of clues backward, step-by-step, through every conversation and action that led there. This is the kind of puzzle scientists are trying to solve with Artificial Intelligence (AI).

In the world of AI, specifically with Large Language Models (the super-smart chatbots we use today), there is a growing problem. These models often have long conversations with us, where they ask questions, we answer, they check a database, and then they give a final answer. Sometimes, the final answer depends on a tiny detail we mentioned five turns ago, which the model then summarized, which the model then used to call a tool, which finally led to the answer. The big question is: How can we see exactly which parts of that long conversation shaped the final answer? Currently, most tools that try to answer this question act like a flashlight that only shines on the immediate room. They can tell you which words in the whole chat seem important, but they miss the "storyline" of how information traveled from the beginning to the end. This matters because if we can't trace where an AI got its facts, we can't trust it, fix its mistakes, or understand why it might be lying to us.

Enter Tokengeist, a new method introduced by researchers Jessica Tang, Shraddha Barke, and Sharad Agarwal. Think of the old way of tracing AI thoughts as a "flat" map. If you ask a flat map to find the source of a rumor, it might point to the person who told you the rumor last, but it won't tell you who told them. The researchers call this failure "provenance collapse." It's like a game of telephone where the final player is blamed for the message, even though the message was distorted three people back. The flat method collapses the whole history into a single layer, missing the deep, multi-step journey of the information.

To fix this, the team built Tokengeist, which acts like a recursive detective. Instead of just looking at the final answer and asking, "Who did you talk to?", Tokengeist asks, "Who did you talk to?" and then, for every person you named, it asks, "And who did they talk to?" It keeps digging backward, step-by-step, through the conversation turns. It treats the conversation like a branching tree (or a family tree of ideas), where it follows the branches back to the very first leaves—the original user inputs or tool results.

The researchers tested this idea using a new benchmark they created called MTCABENCH, which contains 3,845 specific parts of answers from 665 different multi-turn conversations. These conversations were tricky, involving tools like booking flights or checking bank accounts, where the AI had to chain together information from many steps. They found that the old "flat" methods were terrible at this. When asked to find the original source of information, the flat methods only succeeded less than 20% of the time. They kept getting stuck at the middle of the story.

In contrast, Tokengeist was a game-changer. By recursively tracing the path backward, it successfully found the original source of the information more than 90% of the time. It didn't just guess; it mapped out the full journey. For example, if an AI said, "You can cancel your flight because you have insurance," a flat method might just point to the cancellation confirmation. Tokengeist, however, traced it back to the tool result that showed the insurance, then back to the user's ID that unlocked that tool result, and finally to the user's original request.

The paper suggests that this recursive approach is the key to making AI transparent. It shows that simply looking at the whole conversation at once isn't enough; we need to understand the structure of the conversation, how one turn depends on another. While the method works best with the specific AI models they tested (which are open-source and relatively small), the results strongly suggest that for complex, multi-step AI agents, we need to stop treating conversations as a flat list of words and start treating them as a connected web of dependencies. Tokengeist doesn't just tell us what the AI said; it helps us understand the entire story of how it came to say it.

Technical Summary: Tokengeist: Multi-Turn Attribution Tracing in Agentic Conversations

1. Problem Definition: Multi-Turn Context Attribution (MTCA)

Current context attribution methods are primarily designed for single-turn settings, treating the input context as a flat sequence of tokens. When applied to multi-turn agentic conversations, these "flat" methods fail to capture the layered, non-linear structure of real-world dialogues. In complex interactions involving tool calls, intermediate assistant summaries, and multi-step reasoning, a model's final response often depends on information introduced several turns prior, which may have been summarized, reformatted, or transformed by intermediate steps.

The paper defines Multi-Turn Context Attribution (MTCA) as the task of tracing the provenance of a specific target span in a model response backward across turns. The goal is not merely to identify which prior turns are relevant, but to reconstruct the full dependency chain, including how intermediate turns (e.g., assistant summaries or tool results) depend on earlier context. The authors identify a systematic failure mode in single-pass attribution termed "provenance collapse," where a method attributes a response to an immediate intermediate turn (e.g., a summary) but fails to trace back to the original exogenous source (e.g., a user input or tool output) because the model did not attend to the original source directly in the final turn.

2. Methodology: TOKENGEIST

The authors propose TOKENGEIST, a framework that casts MTCA as a recursive traversal of a Directed Acyclic Graph (DAG) over conversation turns. The framework is attribution-method-agnostic, meaning it can utilize any existing single-turn attribution method as a base scorer.

Core Mechanism

TOKENGEIST constructs a provenance graph via a backward breadth-first search (BFS) starting from the target span:

Recursive Attribution: At each step, the framework applies a base attribution method ( $A$ ) to the current target span against the concatenation of all preceding turns.
Turn Aggregation: Sentence-level scores are aggregated into a single score per preceding turn.
Node Selection: The top- $k$ turns with the highest scores are selected as candidates for the next recursion step.
Role-Aware Dispatch: The recursion proceeds differently based on the role of the selected turn:
- Exogenous Turns (User/System): These are added as leaf nodes; recursion stops.
- Tool-Result Turns: Since these contain no model-generated attention weights, the framework follows a deterministic structural edge to the nearest preceding assistant turn that issued the tool invocation, then resumes recursion from that invocation turn.
- Assistant Turns: These are added as intermediate nodes, and the framework recurses into them, attributing their full content against the earlier context.
Termination: Recursion stops when exogenous turns are reached, a maximum depth ( $d_{max}$ ) is hit, or no turns exceed a score threshold.

Graph Construction and Pruning

The resulting structure is a DAG where edges represent dependencies. To produce the final provenance graph, the framework applies relative-threshold extraction. Instead of using a global absolute threshold, edges are retained if their score is above a fraction ( $\alpha$ ) of the maximum edge score from that node. This adapts to local score distributions, allowing the graph to capture multi-source dependencies where a turn relies on multiple earlier sources with varying confidence.

3. Benchmark: MTCABENCH

To evaluate MTCA, the authors introduce MTCABENCH, a benchmark comprising:

Scale: 3,845 annotated target spans across 665 multi-turn conversations.
Sources: Data drawn from ConFETTI (10 task families, e.g., travel, banking) and TauBench (airline and retail domains).
Annotation: Target spans are annotated with "gold" provenance graphs (DAGs) reaching depths of up to 14 turns. Annotations cover four dependency types:
- Direct: Single-hop from source to target.
- Chained: Multi-hop through intermediate turns.
- Multi-source: Dependencies on two or more independent source turns.
- Hallucination: Spans unsupported by context or factually incorrect, requiring tracing of the "hallucinated-source" turns that primed the error.
Quality Control: Annotations were generated via a two-phase pipeline using GPT-5.4, followed by human review, achieving a 98% acceptance rate.

4. Experimental Results

The authors evaluated TOKENGEIST against flat attribution baselines using four open-weight instruction-tuned models (Llama-3.1-8B, Qwen2.5-7B, Phi-4-Mini, DeepSeek-R1-Distill-Qwen-7B) and three base attribution backends (Avg. Attention, AT2, AttnTrace).

Key Findings

Source Recall: Flat attribution methods consistently failed to recover multi-hop dependencies, achieving <20% source recall** (identifying the original exogenous source). In contrast, TOKENGEIST achieved **>90% source recall across all models.
Edge F1: Recursive attribution significantly outperformed flat methods. On ConFETTI, TOKENGEIST improved Edge F1 by 20–40 percentage points over flat baselines. On TauBench, flat methods dropped to under 35% Edge F1 on chained dependencies, while TOKENGEIST reached ~70%.
Dependency Types: The performance gap was most pronounced for chained and multi-source dependencies. Flat methods performed adequately on direct (single-hop) dependencies but collapsed on complex structures.
Hallucination Tracing: TOKENGEIST substantially improved the recovery of "hallucinated-source" turns, helping to localize where erroneous values entered the agentic trace.
Base Scorer Independence: The gains from recursion were consistent across all three base scorers, including the weakest (AttnTrace), indicating that TOKENGEIST is a robust upgrade applicable to any single-turn attribution method.

5. Significance and Claims

The paper claims that TOKENGEIST and MTCABENCH address a critical gap in interpretability for agentic systems.

Systematic Failure Modes: The work formally identifies "provenance collapse" as a systematic failure of single-pass attribution in multi-turn settings, demonstrating that flat methods cannot recover layered dependencies.
Recursive Necessity: The results motivate a shift toward attribution methods that reason recursively across turns, rather than treating context as a flat window.
Debugging and Trust: By recovering full provenance paths, the framework enables developers to debug agentic workflows, verify that claims are grounded in original sources (rather than intermediate summaries), and trace the origin of hallucinations.
Modesty on Scope: The authors acknowledge that their results are bounded by the quality of the base attribution method and that the benchmark is currently limited to English text and specific domains (travel/retail). They note that attribution scores are correlational (based on attention) rather than causal, and that the framework currently operates post-hoc on transcripts rather than online within the agent loop.

The paper concludes that while MTCA is not a substitute for correctness or safety, it provides a foundational mechanism for making information flow in multi-turn conversations inspectable, serving as a step toward more transparent agentic interactions.