---
title: 'InReAcTable: Interactive Data Story Assembly'
url: https://www.emergentmind.com/topics/inreactable
type: topic
---

# InReAcTable: Interactive Data Story Assembly

Searching arXiv for the specified paper to ground the article.
InReAcTable is a modular framework for interactive visual data story construction from tabular data. It addresses the problem of turning large numbers of automatically extracted insights into coherent narratives by interleaving three components—Interaction, Acting, and Reasoning—in a tight loop. Rather than treating insights as isolated bullets or enforcing a one-shot narrative, it supports branching visual stories organized as a tree of connected charts, with the analyst remaining “in the driver’s seat” through chart interactions and follow-up queries that continually update both the search graph and the large-language-model prompt [2508.18174].

## 1. Problem setting and pipeline position

InReAcTable is situated in the third stage of a three-phase workflow: data preparation and visualization, insight extraction, and story assembly [2508.18174]. The framework squarely addresses story assembly, but it does so by feeding back into the earlier stages through user interaction: clicks and typed queries drive both structural filtering of the insight space and semantic refinement via Retrieval-Augmented Generation.

The motivating problem is that insights in tabular data encode valuable patterns, but constructing a visual data story from them is difficult because the relations among extracted insights are complex. Analysts must often sift through a vast number of discrete insights and decide which ones should be integrated into a unified narrative that matches their analytical goals. Existing methods, as characterized in the source description, either rely heavily on user expertise and become inefficient, or use automated approaches that cannot fully capture evolving goals [2508.18174].

A central design distinction is that InReAcTable does not present story construction as either manual curation of isolated findings or fully automated narrative generation. Instead, it supports iterative narrowing of the insight space and iterative refinement of semantic relevance. This suggests a hybrid model in which exploratory analysis and narrative assembly are coupled rather than sequentially separated.

## 2. Formal representation of data, subspaces, and insights

The framework formalizes a table as $D = \{X_1,\ldots,X_n\}$, where the attributes may be categorical or numeric [2508.18174]. A data locator is defined as

$$
Loc = (X_{i_1}=x_1 \land \cdots \land X_{i_k}=x_k),
$$

which specifies a subspace $S \subseteq D$. Within a chosen subspace, one categorical breakdown $B$ and one aggregation $Agg(V)$ on a numeric column $V$ are used to define an Analysis Entity,

$$
AE := \langle S, B, Agg(V)\rangle.
$$

An insight is then represented as a 5-tuple,

$$
I = \langle AE, Type, Category, Score, Description\rangle,
$$

where $Type \in \{\text{trend}, \text{outlier}, \ldots\}$, $Category \in \{\text{point}, \text{shape}, \text{compound}\}$, $Score \in \mathbb{R}$ measures significance, and $Description$ is a short natural-language summary generated by template.

This representation makes the story-construction problem explicit at two levels. First, the analyst is not navigating arbitrary charts, but insights anchored in subspaces and analysis entities. Second, narrative assembly is not defined purely by semantic similarity; it is constrained by structural relations among locators. A plausible implication is that the framework is designed to preserve analytical provenance as stories expand.

## 3. Insight graph and the Acting module

The Acting module operates over a directed subspace graph $G=(V,E)$ whose vertices are the set of all locators $\{Loc\}$ [2508.18174]. Two edge types encode structural relations:

1. A sibling edge connects $Loc_1$ and $Loc_2$ if they have the same number of predicates, $|Loc_1|=|Loc_2|$, and differ in exactly one assignment.
2. A parent–child edge goes from $Loc_p$ to $Loc_c$ if $Loc_c$ adds exactly one extra predicate to $Loc_p$, so that $|Loc_c|=|Loc_p|+1$ and the assignments of $Loc_p$ are a subset of those of $Loc_c$.

When a user focuses on an insight $I^*$ in subspace $Loc^*$, the system searches the graph up to radius $r$, a tunable “step” parameter, and retrieves all subspaces within $r$ hops:

$$
S_r = \{Loc : dist_G(Loc^*,Loc) \le r\}.
$$

For each $Loc \in S_r$, the framework generates all analysis entities and extracts their insights, then discards those with $Score$ below a threshold $\tau$. The resulting set is the structurally filtered candidate set $C_{struct}$.

The pseudocode supplied for this phase is correspondingly direct:

```text
function ACT(Loc*, radius r):
  S_r = BFS(G, start=Loc*, depth=r)
  C_struct = { I | I.AE.S ∈ S_r and I.Score ≥ τ }
  return C_struct
```

The significance of this module is that it narrows the search space before any language-model reasoning occurs. A common misconception would be to view the system primarily as an LLM-driven recommender. Structurally, however, the first-stage operation is graph-based filtering over analytically related subspaces, with the LLM entering only after this reduction.

## 4. Reasoning module, RAG, and recommendation logic

The Reasoning module performs semantic filtering on the structurally reduced set $C_{struct}$ through a Retrieval-Augmented Generation design [2508.18174]. Each candidate insight $I \in C_{struct}$ is converted into a compact 4-tuple,

$$
D(I)=\langle Header, Type, Score, Sentence\rangle,
$$

where $Sentence$ is produced by a per-Type template. These sentences are encoded into $d$-dimensional vectors via Sentence-BERT and stored in a FAISS index for fast lookup.

Retrieval follows a dual-path design. Given a free-form query $q$ or a selected focus insight $I^*$, the framework computes:

- $C_{user}$, the top-$K$ nearest neighbors to $encode(q)$ by cosine similarity;
- $C_{ctx}$, the top-$K$ nearest neighbors to $encode(D(I^*))$ by cosine similarity.

The two rankings are merged by

$$
rank_{merged}(I) = \alpha \cdot rank_{user}(I) + (1-\alpha)\cdot rank_{ctx}(I),
$$

with $\alpha=0.7$ favoring user intent. After optional filtering by score and diversity across Type and Category, the system obtains $C_{final}$.

Prompt construction then uses a Chain-of-Thought format containing a short system instruction (“You are a data-story assistant…”), few-shot examples of $\{Query + Focus\text{-}Insight + Candidate\text{-}Insights \rightarrow Best\text{-}Next\text{-}Insights\}$, and the current query, focus insight, and top candidate descriptions. Multiple reasoning chains are sampled via Self-Consistency, and the most frequent recommendations are selected. The LLM returns a ranked subset that is visualized back in the interface.

The supplied pseudocode makes the control flow explicit:

```text
function RAG_REASON(I*, q, C_struct, α=0.7):
  for I in C_struct:
    d_I = template_desc(I)
    e_I = SBERT.encode(d_I)
  v_q = SBERT.encode(q)
  v_* = SBERT.encode(template_desc(I*))
  C_user = topK_knn(e_I, v_q)
  C_ctx  = topK_knn(e_I, v_*)
  for I in C_struct:
    score_merged[I] = α·rank(C_user,I) + (1−α)·rank(C_ctx,I)
  C_merged = top M by score_merged
  C_final = filter_by_score_and_diversity(C_merged)
  prompt = build_CoT_prompt(history, I*, q, C_final)
  out = LLM.generate(prompt, n_samples=N, self_consistency=True)
  return parse_recommendations(out)
```

This design indicates that semantic recommendation is constrained at every stage: by structural locality, by embedding retrieval, by merged ranking that privileges user intent, and by prompt context grounded in candidate descriptions rather than unrestricted generation.

## 5. System architecture and interactive prototype

The overall data flow begins with preprocessing: building the subspace graph $G$ from $D$, extracting all analysis entities and insights, generating sentence templates, and embedding those sentences into FAISS [2508.18174]. Interaction starts when a user picks a subspace $Loc_0$ or begins with the global locator $Loc=\varnothing$. The system shows initial insights as collapsible glyphs. A click to expand an insight $I^*$ or a typed query $q$ triggers the Acting module, then the Reasoning module, after which recommended insights are added as children of $I^*$ in a radial “insight tree.” The process repeats until the story is complete.

The prototype front end comprises three linked panels:

| Panel | Contents | Function |
|---|---|---|
| Subspace-Selection Panel | Categorical filters; list of extracted insights with small-multiples charts | Pick $Loc$ and inspect subspace-specific insights |
| Radial Exploration Panel | Force-directed, concentric layout of insight-nodes | Visualize the branching insight tree and relations |
| Insight Detail & History Panel | Full chart, template description, score, pin/move/delete, timeline of previous queries and focused insights | Support inspection, editing, and interaction history |

Within the Radial Exploration Panel, node color encodes Category, the inner icon encodes Type, and solid or dashed edges of varying thickness denote sibling, parent–child, or semantic relations. Nodes start in a collapsed icon-only state and expand to a full chart on click. When an insight is pinned, a query is entered, or “recommend” is selected, the Acting and Reasoning modules fire and the next ring of nodes appears around that insight. Hovering on edges shows the LLM’s textual justification of semantic links.

A notable property of the interface is that it is built around a branching tree rather than a linear slideshow or a static infographic. This reflects the framework’s underlying assumption that analytical stories often diverge into multiple connected explanatory paths rather than conforming to a single predetermined sequence.

## 6. Case study and experimental findings

The reported case study uses a dataset of 1,280 console-sales records with attributes Company, Brand, Location, Season, Year, and Sales [2508.18174]. In this example, the system surfaced a 2014 temporal outlier for Microsoft ($I_1$). Inspection of that subspace uncovered seasonal unevenness and the observation that 2014 did not follow the usual correlation ($I_2$). A query asking “Why the spike in Sept/Dec 2014?” led to brand-level temporal correlation insights for X360 and XOne ($I_3, I_4$). Further queries on a month-by-month breakdown in 2014 produced point insights ($I_5$–$I_9$). The final outcome was a branching tree of seven connected insights, each visualized and annotated, forming a coherent story of the outlier.

The user experiment involved 18 analysts, including 7 with professional-tool experience, and compared InReAcTable against AWS QuickSight and vizGPT. Two tasks were reported. In Task 1, a within-subject freeform study allocated 20 minutes per tool and measured number of stories, number of insights per story, total number of insights, and blind expert ratings on logicality, coherence, diversity, and relevance. InReAcTable produced 40% more insights per story and twice the total insights ($p < 0.01$), together with significantly higher expert scores on all four qualitative metrics. In Task 2, a between-subject targeted study gave participants an initial insight and question and 10 minutes with an assigned tool. Experts rated the resulting stories as more coherent ($p < 0.05$) and more relevant. User surveys placed InReAcTable highest on learnability, ease-of-use, interface satisfaction, and confidence in staying on task.

These results support the framework’s stated goal of helping analysts efficiently sift through thousands of automatically generated insights and assemble coherent narratives. They do not imply fully autonomous story generation; rather, they document the effectiveness of an interactive loop in which structural filtering, semantic retrieval, and user intent remain tightly coupled.

Source: https://www.emergentmind.com/topics/inreactable