💬 NLP

Narrative Knowledge Weaver: Narrative-Centric Retrieval-Augmented Reasoning for Long-Form Text Understanding

The paper introduces Narrative Knowledge Weaver (NKW), a source-grounded framework that integrates textual evidence, graph structures, and narrative-specific tools to enhance reasoning over evolving story worlds, demonstrating superior performance in long-form narrative QA tasks compared to existing retrieval and graph-augmented methods.

Original authors: Qiuyu Tian, Fengyi Chen, Yiding Li, Youyong Kong, Fan Guo, Yuyao Li, Jinjing Shen, Zhijing Xie, Yiyun Luo, Xin Zhang, Yingce Xia, Zequn Liu

Published 2026-06-05

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Qiuyu Tian, Fengyi Chen, Yiding Li, Youyong Kong, Fan Guo, Yuyao Li, Jinjing Shen, Zhijing Xie, Yiyun Luo, Xin Zhang, Yingce Xia, Zequn Liu

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 solve a mystery, but instead of a few pages of clues, you have a whole novel, a movie script, or a long series of stories. The problem with current AI assistants is that they are great at finding a specific sentence if you ask, "What color was the car?" But they often get lost when you ask, "Why did the hero feel betrayed in the third act, considering what happened in the first act and how their relationship changed in the second?"

Current AI tools treat stories like a pile of loose bricks. They can grab a brick (a paragraph) or look at a single connection between two bricks (a relationship). But they struggle to see the house being built—the flow of the plot, the changing feelings of the characters, and the cause-and-effect chain that spans hundreds of pages.

This paper introduces a new system called Narrative Knowledge Weaver (NKW). Think of NKW not as a librarian who just hands you a book, but as a master storyteller and detective combined.

Here is how it works, using simple analogies:

1. The Problem: The "Flat Map" vs. The "Living City"

Imagine a city map.

Old AI (The Flat Map): It shows you where the buildings are (characters) and the roads connecting them (relationships). But it doesn't tell you that the bakery closed at 5 PM, or that the mayor got angry at the baker yesterday, which is why the baker is sad today. It sees the city as static.
The Reality of Stories: Stories are like a living city where time moves, people change their minds, and one small event (a spilled coffee) causes a chain reaction (a missed train, a missed meeting, a broken engagement).
The Mismatch: When you ask an old AI a complex story question, it grabs the wrong "brick" because it doesn't understand the story role of that brick. Is this scene a setup? A climax? A consequence?

2. The Solution: The "Weaver"

NKW is called a "Weaver" because it doesn't just store facts; it weaves them into a tapestry that captures the story's flow. It builds a special "backpack" of information before you even ask a question.

Step A: Building the "Character ID Cards"
Instead of just knowing a name like "John," NKW creates a dynamic profile for John. It tracks:

Who he is: (Stable facts: He is a detective).
What he is doing right now: (Changing facts: He is currently angry, holding a gun, and hiding in a closet).
Analogy: Imagine a character sheet in a video game that updates every time the character takes damage or finds a new item, rather than a static biography.

Step B: Creating "Story Chapters" (Episodes)
NKW groups small events into bigger chunks called Episodes.

Example: Instead of seeing "John enters," "John sees a gun," and "John shoots" as three separate lines, NKW bundles them into one "Confrontation Episode."
Analogy: It's like turning a long list of ingredients into a finished recipe. You don't just have flour and eggs; you have "The Cake."

Step C: Drawing the "Plot Highway" (Storylines)
This is the most unique part. NKW connects these episodes into a Storyline. It figures out which event caused the next one.

Analogy: If a story is a train ride, NKW doesn't just list the stations. It draws the track, showing you that Station A caused the train to speed up to reach Station B, and that Station C is a detour caused by a storm at Station A.

3. How It Answers Questions: The "Toolbox"

When you ask a question, NKW doesn't just search for keywords. It uses a specialized toolbox with three different lenses:

The Text Lens: Looks at the actual words in the script (for exact details).
The Graph Lens: Looks at who knows whom and where they are (for relationships).
The Narrative Lens: Looks at the timeline and cause-and-effect (for "Why?" and "What happened next?").

The "Reading Skills" (The Editor)
Before giving you the answer, NKW has a final "Editor" step. It checks the evidence like a strict teacher:

"Did you pick the right character?" (Not the wrong John).
"Is this happening at the right time?" (Not yesterday, but today).
"Did you confuse a cause with an effect?"
This ensures the answer isn't just plausible, but factually grounded in the story's timeline.

4. Does It Work?

The authors tested NKW on three types of story challenges:

Full Movie Scripts (STAGE): Long, complex stories with many characters.
Children's Fairytales (FairytaleQA): Shorter stories with clear morals and sequences.
Long Articles (QuALITY): General long texts.

The Results:

The Big Win: NKW crushed the competition on the Movie Scripts. It was much better at answering questions that required understanding how a character's mood changed over time or how one event led to another days later.
The Trade-off: For very simple questions (like "What color was the dress?"), simpler AI tools were almost as good. NKW shines when the question requires thinking like a human reader who remembers the whole story arc, not just a single page.

5. A Real-World Use Case Mentioned

The paper mentions one specific practical use: Movie Production Continuity.

The Problem: In a movie set, if a character wears a red coat in Scene 1 and a blue coat in Scene 5, but the director wants to film Scene 5 before Scene 1, the crew needs to know if they can reuse the same set or costumes.
The NKW Solution: Because NKW tracks exactly where and when objects and characters appear, it can automatically tell the production team: "These two scenes can be filmed together because the character and the room are in the same state."

Summary

Narrative Knowledge Weaver is an AI system that stops treating stories like a pile of words and starts treating them like a living, breathing timeline. It builds a map of who is who, what they are doing, and how one event leads to another. This allows it to answer complex questions about long stories that other AIs usually get wrong, making it a powerful tool for understanding movies, books, and scripts.

Technical Summary: Narrative Knowledge Weaver (NKW)

Problem Statement

Long-form narrative understanding presents a unique challenge distinct from general long-document processing. While standard Retrieval-Augmented Generation (RAG) systems excel at locating relevant passages, they struggle with the functional and dynamic nature of narrative evidence. In narratives, the same passage can serve as a premise, a turning point, a consequence, or a state update depending on its position in the evolving story world. Furthermore, characters and their relationships are not static; they change over time based on events, interactions, and causal triggers.

Existing RAG and graph-augmented methods rely on units like chunks, entities, relations, or community summaries. These units locate material but fail to encode narrative function (e.g., "this is the motivating event") or dynamic states (e.g., "this character's belief changed after Scene 5"). Consequently, general-purpose systems often retrieve relevant content but fail to assemble it correctly for questions requiring reasoning over evolving states, temporal order, causal motivation, and plot progression.

Methodology: Narrative Knowledge Weaver (NKW)

NKW is a source-grounded framework designed to align textual evidence with a multi-layered narrative structure. It separates the construction-time asset building from query-time reasoning.

1. Construction-Time Asset Building

NKW constructs a source-grounded asset bundle $B = (G, U, F, P, H, X)$ comprising:

Canonical Entity–Relation Graph Backbone: A stable graph of narrative entities (characters, locations, objects) and binary relations. Narrative process units (events, interactions) are not treated as native graph nodes to maintain stability; instead, they are stored separately to avoid graph destabilization.
Source-Grounded Narrative Assets: Extraction of atomic facts, events (actions, decisions), interactions (directed communication/conflict), and occasions (stable contexts). These remain linked to source evidence.
Entity Canonicalization: Merging aliases and local references into stable narrative entities. For entities with sufficient connectivity, NKW extracts time-sensitive atomic facts regarding states, goals, and mental states, creating dynamic character profiles.
Global Episode and Storyline Construction:
- Episodes: Local narrative units are aggregated into coherent episodes based on shared participants, goals, conflicts, and temporal continuity.
- Storylines: A global DAG (Directed Acyclic Graph) of episodes is constructed using the SABER algorithm, which breaks cycles and prunes redundant shortcuts to ensure a clean progression graph. Storylines are extracted as chains through a trunk-branch view, enabling long-range temporal and causal reasoning.

2. Query-Time Reasoning

NKW employs a channel-separated tool interface and post-retrieval reading skills:

Evidence Views: The system provides access to source passages, atomic facts, entity profiles, event/interaction records, and episode/storyline layers.
Tool Interface: Instead of a flat retriever, NKW exposes tools for Text (source evidence), Graph (entity/relation grounding), and Narrative (temporal/causal progression).
Evidence Assembly: The agent decomposes questions into requirements (e.g., actor, scope, polarity, temporal position) and assembles an evidence packet $E_q$ using the available tools.
Post-Retrieval Reading Skills: Lightweight "Reading Skill Cards" (derived from cognitive theories like QUEST and Situation Models) are injected into the final prompt. These operators audit the assembled evidence for constraints such as "wrong actor," "wrong time," or "wrong causal direction," ensuring the answer aligns with the narrative logic rather than just surface similarity.

Key Contributions

A Narrative-Centric RAG System: NKW represents long-form narratives through a hierarchy of canonical entity graphs, source-grounded narrative assets (events, interactions), and aggregated episodes/storylines. It separates stable identity from changing states.
Inference Tools for Narrative Evidence Assembly: The framework introduces a channel-separated tool interface (text, graph, narrative) and post-retrieval reading skills to audit evidence for actor, scope, polarity, and temporal constraints.
Comprehensive Evaluation: NKW is evaluated on three datasets (STAGE, FairytaleQA, QuALITY) across seven LLM backbones, demonstrating specific gains in reasoning over evolving story worlds.

Experimental Results

The evaluation covers STAGE (screenplay-level reasoning), FairytaleQA (children's stories), and QuALITY (long passages).

STAGE Performance: NKW achieves the best Pass@5 scores across all backbones and the best Overall scores for medium, large, and closed-source models. It shows the most significant improvement on questions requiring reasoning over temporal order, causal motivation, and plot progression. For smaller models, Hybrid RAG sometimes slightly outperforms NKW in one-shot accuracy, but NKW consistently improves Pass@5, suggesting its structured evidence benefits multi-sample reasoning.
Secondary Benchmarks: On FairytaleQA and QuALITY (more passage-centered), NKW remains competitive. While lightweight retrieval (e.g., LightRAG) performs well on these shorter or local tasks, NKW excels in higher-capacity settings, particularly for Pass@5, indicating its value in multi-constraint scenarios.
Ablation Studies:
- Removing episode/storyline aggregation causes the largest drop in Temporal and Narrative Progression reasoning.
- Removing entity attributes primarily hurts Character Understanding and Role-Relation tasks.
- Removing graph-channel tools leads to broad degradation, confirming the value of structured access over flat retrieval.
- Reading skills significantly improve performance on causal and temporal questions by correcting interpretation errors.
Tool Usage: Analysis shows STAGE queries heavily utilize graph and narrative tracing tools (91.5% require follow-up rounds), whereas FairytaleQA and QuALITY rely more on atomic facts and text extraction, with fewer follow-up rounds.

Significance and Claims

The paper claims that narrative QA benefits from modeling how evidence functions inside a story, not just where relevant passages occur.

Functional vs. Locational Evidence: NKW addresses the mismatch where general RAG retrieves content but misses its narrative role (e.g., distinguishing a cause from a consequence).
Dynamic State Tracking: By separating stable entity identities from time-sensitive atomic facts, NKW captures the evolving nature of character states and relationships, which static graph nodes fail to represent.
Source Grounding: The framework ensures that all high-level narrative assets (episodes, storylines) and reasoning steps are traceable back to source evidence, mitigating hallucination and supporting auditability.
Downstream Utility: The paper demonstrates that the constructed assets can be reused for production tasks, such as production continuity checking (identifying scenes that can share sets/props) and character state tracking, suggesting the framework's utility extends beyond QA.

The authors maintain modesty regarding limitations, noting that NKW incurs higher construction and query-time costs than flat retrieval and that its advantages are most pronounced when questions require evidence across character states, events, and plot progression. For shorter or purely passage-centered questions, the additional narrative structure may offer diminishing returns compared to lightweight retrieval.