JERR: Joint Enhancement of Relational Reasoning

• JERR is a training-free agent framework that enhances long-context reasoning by converting documents into a deduplicated graph of synopsis-level atoms.
• It segments texts into concise synopses, constructs a directed acyclic graph to represent relationships, and employs Monte Carlo Tree Search to identify key reasoning paths.
• The system addresses challenges like lost context and incoherent multi-hop reasoning while achieving superior performance on benchmarks such as QuALITY, MuSiQue, and NarrativeQA.

Searching arXiv for the specified paper and closely related context. JERR, short for Joint Enhancement of Relational Reasoning, is a training-free agent framework for long-context LLMs that is designed to improve long-context comprehension via graph-based reasoning, while also improving transparency and reducing hallucinations (Chen et al., 28 Aug 2025). It addresses several long-context failure modes identified for LLMs, including being “lost in the middle,” weak maintenance of long-range dependencies, poor handling of explicit relational structures, inconsistent multi-hop reasoning, and hallucinated connections unsupported by the source text. Its central design is to transform a long document into an explicit graph of synopsis-level atoms and relations, then apply Monte Carlo Tree Search (MCTS) over that graph to discover relevant reasoning paths for a query (Chen et al., 28 Aug 2025).

1. Problem formulation and design rationale

JERR is motivated by the observation that context-window capacity does not guarantee effective understanding. Even when a passage fits inside a window such as 128k tokens, performance can degrade as length grows, and important details embedded earlier in the document may be ignored. The framework is specifically intended for tasks requiring complex relational reasoning across long contexts, including multi-hop question answering, narrative understanding, and causal explanation (Chen et al., 28 Aug 2025).

The framework targets three failure modes. First, answers may rely on recent context or superficial matches while neglecting earlier key details. Second, multi-hop reasoning may become incoherent, mixing unrelated passages without a consistent chain. Third, the model may hallucinate relations between entities or events not supported by the document. JERR responds to these problems by replacing unconstrained free-form reading with a structured pipeline in which synopsis extraction compresses the document, graph construction makes relations explicit, and MCTS searches for high-value reasoning paths (Chen et al., 28 Aug 2025).

This suggests that JERR is best understood not as a new base model, but as an inference-time control and representation layer around existing LLMs. A plausible implication is that its contribution lies in improving effective long-context utilization rather than extending the underlying architecture’s nominal context length.

2. System architecture

At a high level, JERR consists of three tightly integrated components: synopsis extraction, graph construction, and relational reasoning via MCTS (Chen et al., 28 Aug 2025). The system wraps around existing LLMs such as Qwen-plus-128k and GPT-4-128k, and its operation is explicitly described as training-free.

The pipeline begins by segmenting a long document into chunks, each of which is summarized into a compact synopsis. These synopses are then processed to extract entities and “information atoms,” which are deduplicated and assembled into a directed acyclic graph (DAG) $G = (V, E)$. Nodes represent entities or atomic facts, and edges represent relations inferred from the synopses. Given a query $q$, MCTS operates over this DAG to retrieve the top-$k$ relevant nodes. These selected nodes, together with associated synopses and source chunks, form a focused context for final answer generation (Chen et al., 28 Aug 2025).

The components are jointly designed. Synopsis extraction compresses long text into manageable units; graph construction resolves redundancy and imposes relational and hierarchical structure; MCTS balances exploration and exploitation to identify useful reasoning paths. The resulting context presented to the LLM is therefore curated rather than raw, relationally grounded rather than flat, and accompanied by an explicit structure that can be inspected (Chen et al., 28 Aug 2025).

3. Synopsis extraction and document compression

JERR uses the autogen package’s chunking function to segment the original long context $T$ into manageable chunks:

$chunk(T) = \{ t_1, t_2, \dots, t_n \}$

Chunking is configurable by maximum tokens per chunk, overlap between chunks, treatment of empty lines as boundaries, and chunking mode such as paragraph-based or line-based. The reported settings include 600 maximum tokens per chunk for QuALITY and 2000 for NarrativeQA/MuSiQue (Chen et al., 28 Aug 2025).

For each chunk $t_i$, synopsis generation uses the prompt:

“Please transfer the following chunk of a passage into synopsis. Just give me a synopsis version. No extra explanation. Passage: {CHUNK}”

The resulting synopses are represented as

$S = \{ s_1, s_2, \dots, s_n \}$

where each $s_i$ is a concise summary of the corresponding chunk (Chen et al., 28 Aug 2025). The paper states that synopsis quality is controlled through chunking and prompt design rather than an explicit optimization objective such as maximizing coverage or minimizing redundancy.

Ablation results reported in the source indicate that chunk size materially affects downstream reasoning quality. For NarrativeQA, performance peaks at a chunk size of 2000 tokens; for QuALITY, best accuracy is obtained at 600 tokens. Larger chunks degrade synopsis quality and harm recall and coherence, whereas overly small chunks may fragment context excessively (Chen et al., 28 Aug 2025). This suggests that synopsis extraction in JERR is not merely a preprocessing convenience; it is a core inductive bias that determines the granularity of the graph.

4. Graph construction and DAG-based relational representation

Graph construction starts from the synopsis set $S$. Two prompt families are used. The first extracts information atoms:

“Given a chunk of paragraph, summarize it into information atoms. (Information Atoms: brief statements represent the most fundamental, indivisible facts, covering propositions, theories, entities, concepts, cause-effect relationships, event sequences, social interactions, timelines, etc.)”

The second extracts core components:

“Given a chunk of paragraph of a story, extract only 3 core components (fundamental nouns, verbs, adjectives central to progression).”

Information atoms provide minimal factual units; core components provide anchor elements for graph nodes and relations (Chen et al., 28 Aug 2025).

Deduplication is performed in two stages. Exact deduplication uses a Bloom Filter (pybloom) and a Trie to remove exact textual duplicates:

$C = \{ c_i \mid c_i = ddp_{\mathrm{exact}(s_j),\ \forall s_j \in S \}$

A second stage performs similarity-based deduplication using SimHash (simhash). If the bitwise Hamming distance between hashes is below a threshold $q$0, for example 3 bits, near-duplicates are merged:

$q$1

The final node set $q$2 therefore represents non-redundant entities or information atoms (Chen et al., 28 Aug 2025).

Edges are constructed by prompting for attributes between node pairs using associated atomic facts:

“Based on the atomic facts: ‘{INFORMATION ATOMS1}’ and ‘{INFORMATION ATOMS2}’, what are the attributes between {ELEMENT1} and {ELEMENT2}? Use no more than three words.”

If the response is non-empty, a directed edge is created:

$q$3

The graph is then

$q$4

and is constrained to be a Directed Acyclic Graph (DAG) (Chen et al., 28 Aug 2025).

DAG enforcement is described as heuristic: edges are oriented according to narrative time, causal direction, or hierarchical dependency, and cycles are avoided. The paper attributes several consistency benefits to this design: deduplication suppresses redundant or conflicting representations, edge semantics preserve only meaningful relations, and acyclicity avoids feedback loops that could confuse traversal and reasoning (Chen et al., 28 Aug 2025). No external symbolic knowledge graph or manual annotation is required; the graph is automatically built through LLM prompting plus standard algorithmic tools.

5. Relational reasoning via Monte Carlo Tree Search

The reasoning component applies Monte Carlo Tree Search over the DAG to identify a small set of nodes most relevant to a query $q$5. The graph is $q$6, and the search tree $q$7 is defined over graph nodes $q$8. Each state $q$9 tracks visit count $k$0, total reward $k$1, and average reward

$k$2

Actions correspond to traversing outgoing edges to neighboring graph nodes (Chen et al., 28 Aug 2025).

JERR follows the standard four-phase MCTS procedure:

1. Selection
2. Expansion
3. Simulation
4. Backpropagation

The overall retrieval is expressed as

$k$3

where $k$4 is the number of returned nodes (Chen et al., 28 Aug 2025).

During selection, JERR uses an Upper Confidence Bound policy:

$k$5

and chooses

$k$6

This balances exploitation of high-average-reward nodes with exploration of under-visited nodes (Chen et al., 28 Aug 2025).

Expansion adds unexplored neighbors of the current graph node:

$k$7

Simulation extracts query keywords $k$8, then follows a path of depth up to $k$9, with the paper giving 10 as an example. Reward is defined by keyword overlap between the query and node-associated content:

$T$0

Backpropagation updates visit counts and cumulative rewards along the traversed path:

$T$1

$T$2

The retrieved set is finally given as

$T$3

or equivalently

$T$4

(Chen et al., 28 Aug 2025)

Algorithm 1 in the source specifies the concrete control flow: input graph $T$5, query text $T$6, start nodes $T$7, and number of simulations $T$8; initialize the root with $T$9; extract keywords from $chunk(T) = \{ t_1, t_2, \dots, t_n \}$0; perform repeated selection, expansion, simulation up to depth 10, and backpropagation; then sort root children by win/visit ratio and return the top nodes (Chen et al., 28 Aug 2025).

The paper argues that MCTS is valuable because it searches over paths rather than assigning static scores to isolated chunks or nodes. This enables multi-hop relational retrieval and provides an explicit reasoning trace. In ablation on QuALITY, replacing MCTS with PageRank reduces accuracy from 86.39% to 81.69%, indicating that active search over the graph adds substantial value beyond static graph centrality (Chen et al., 28 Aug 2025).

6. End-to-end pipeline, integration, and computational profile

The full JERR pipeline proceeds as follows: input long context $chunk(T) = \{ t_1, t_2, \dots, t_n \}$1 and query $chunk(T) = \{ t_1, t_2, \dots, t_n \}$2; chunk $chunk(T) = \{ t_1, t_2, \dots, t_n \}$3 with autogen.chunk(T); generate synopses $chunk(T) = \{ t_1, t_2, \dots, t_n \}$4; extract information atoms and core components; deduplicate first with Bloom Filter and Trie, then with SimHash; construct directed edges and enforce DAG constraints; run $chunk(T) = \{ t_1, t_2, \dots, t_n \}$5 with $chunk(T) = \{ t_1, t_2, \dots, t_n \}$6; retrieve associated synopses and original chunks; and generate the final answer from this focused context (Chen et al., 28 Aug 2025).

Answer generation differs by benchmark. For QuALITY, the prompt provides article, question, and options for multiple-choice answering. For NarrativeQA and MuSiQue, the prompt provides “Relevant nodes text + synopses” together with the question and requests a short, concise answer (Chen et al., 28 Aug 2025).

JERR is explicitly training-free. It does not fine-tune the base LLM and learns no new parameters. Instead, all intermediate representations—chunks, synopses, entity sets, DAGs, and MCTS scores—are implemented externally in Python tooling, while the LLM is invoked through APIs for synopsis generation, information atom extraction, core component extraction, edge attribute labeling, and final answer generation (Chen et al., 28 Aug 2025).

The computational profile is mixed. Graph construction is token-intensive initially but can be reused across queries for the same document. On MuSiQue, token cost is reported as approximately 98.54k tokens per question when graph construction is included and 44.33k tokens per question when reusing an existing graph (Chen et al., 28 Aug 2025). MCTS complexity is described as roughly $chunk(T) = \{ t_1, t_2, \dots, t_n \}$7, controlled by the number of simulations $chunk(T) = \{ t_1, t_2, \dots, t_n \}$8 and rollout depth $chunk(T) = \{ t_1, t_2, \dots, t_n \}$9. The paper further reports that JERR costs approximately 1.23× the tokens of ReadAgent, while delivering better performance (Chen et al., 28 Aug 2025).

A plausible implication is that JERR is particularly attractive in repeated-query regimes over the same long document, where graph construction can be amortized.

7. Empirical results, transparency, limitations, and positioning

JERR is evaluated on three standard benchmarks: QuALITY (dev set, 230 samples), MuSiQue (200 samples), and NarrativeQA (200 samples) (Chen et al., 28 Aug 2025). QuALITY is a multiple-choice long-context QA benchmark with 4.1k average tokens and 6.0k maximum; MuSiQue is multi-hop long-context QA with 15.5k average and 16.0k maximum; NarrativeQA is single-hop long narrative comprehension with 29.7k average and 63.7k maximum (Chen et al., 28 Aug 2025).

The baselines include BM25 chunk retrieval, neural retrieval via Qwen embedding (text-embedding-v3), direct long-context inference with qwen-plus-128k, and agent-based or graph-based systems including ReadAgent, LongRAG, GraphRAG, and, in a separate GPT-4 comparison, GraphReader (Chen et al., 28 Aug 2025).

The principal quantitative results are summarized below.

Benchmark	Key JERR result	Comparison stated in source
QuALITY	86.39% accuracy	Best; higher than BM25 Top-6 79.91%, neural Top-6 83.32%, qwen-plus-128k 84.80%, ReadAgent 83.80%, LongRAG 84.91%, GraphRAG 85.02%
MuSiQue	LR-1 0.455, LR-2 0.595, F1 0.505, R-1 0.226, R-2 0.212, R-L 0.218	Best across all metrics
NarrativeQA	LR-1 0.540, LR-2 0.760, F1 0.269, R-1 0.234, R-2 0.215, R-L 0.216	Best across all metrics
GPT-4-128k setting	LR-1(MQ) 60.5, LR-2 64, F1 49.2; LR-1(NR) 68, LR-2 83, F1 30.1	Better than GraphReader

These results support the paper’s claim that JERR consistently outperforms all baselines on ROUGE and F1 metrics and achieves the highest scores on the LLM-Rater evaluation (Chen et al., 28 Aug 2025).

The framework’s transparency claims are grounded in its explicit graph structure, constrained reasoning paths, and inspectable top-$t_i$0 nodes. The selected nodes serve as “reasoning anchors,” and the source describes a QuALITY case involving “Korvin and Tr’en society,” in which the graph and MCTS path connect societal mental limitations, subconscious behavior, and the presence of an unlocked door and nearby weapon. The point of the example is that the answer can be traced to specific nodes and relations rather than emerging as an opaque free-form generation (Chen et al., 28 Aug 2025).

The limitations identified by the authors are also explicit. JERR has only been evaluated on QuALITY, MuSiQue, and NarrativeQA. Its generalization to domains such as technical manuals, legal texts, or scientific papers remains untested. Graph construction is complex, involving multiple prompt-based stages and algorithmic deduplication components. The framework is oriented toward complex reasoning tasks, and its overhead may not be justified for trivial or short-context questions (Chen et al., 28 Aug 2025).

Within broader long-context and retrieval literature, JERR is positioned at the intersection of long-context LLMs, retrieval-augmented generation, agent-based long-context reasoning, and graph-structured reasoning. The source contrasts it with classic RAG, which retrieves chunks independently; with agent systems such as ReadAgent, Pearl, and LongRAG; and with graph-based systems such as GraphRAG and GraphReader. The distinctive combination identified by the paper is synopsis extraction + deduplicated DAG + MCTS-based relational reasoning in a training-free framework (Chen et al., 28 Aug 2025). This suggests that JERR’s main novelty lies in treating long-context reasoning as graph search over document-derived relational structure rather than as direct attention over the raw sequence.