Paper deep dive
Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data Analysis
Junran Yang, Shruti Badrish, Teanna Barrett, Leilani Battle
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 10/9/2026, 8:12:44 AM
Summary
The paper introduces DAG-EDA, a system that facilitates exploratory data analysis (EDA) by using an intent graph and a multi-layered knowledge graph to co-navigate analytical reasoning with Large Language Models (LLMs). The intent graph decomposes ambiguous natural language questions into concrete analysis tasks, while the knowledge graph links domain concepts to dataset variables, allowing analysts to inspect, contest, and steer the exploration process transparently.
Entities (6)
Relation Signals (7)
DAG-EDA → uses → Intent Graph
confidence 95% · We present DAG-EDA, a system that lets analysts and an LLM co-navigate the space of possible analyses through two linked structures. An intent graph...
DAG-EDA → uses → Knowledge Graph
confidence 95% · We present DAG-EDA... through two linked structures... A multi-layered knowledge graph externalizes the LLM’s domain knowledge
Intent Graph → decomposes → Natural Language Questions
confidence 92% · An intent graph... decomposes an ambiguous natural-language question into progressively concrete analysis tasks
Knowledge Graph → links → Domain Concepts
confidence 90% · A multi-layered knowledge graph externalizes the LLM’s domain knowledge, linking domain concepts to the dataset variables
Knowledge Graph → links → Dataset Variables
confidence 90% · A multi-layered knowledge graph externalizes the LLM’s domain knowledge, linking domain concepts to the dataset variables that can measure them
DAG-EDA → generates → Interactive Dashboards
confidence 88% · the analyses the analyst reaches are rendered as interactive dashboards.
Large Language Models → provides → Domain Knowledge
confidence 85% · Large language models (LLMs) can supply such knowledge... A multi-layered knowledge graph externalizes the LLM’s domain knowledge
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Exploratory data analysis (EDA) is rarely open-ended in practice: analysts work from high-level domain questions toward the concrete analyses that can answer them, prioritizing directions with domain knowledge and prior hypotheses. Large language models (LLMs) can supply such knowledge, but their responses are unstructured, leaving analysts no way to see what has been explored, what is missing, or why one direction was chosen over another. We present DAG-EDA, a system that lets analysts and an LLM co-navigate the space of possible analyses through two linked structures. An intent graph, governed by a grammar of analytical intent, decomposes an ambiguous natural-language question into progressively concrete analysis tasks, keeping alternative framings open and letting analysts branch, backtrack, and compare paths. A multi-layered knowledge graph externalizes the LLM's domain knowledge, linking domain concepts to the dataset variables that can measure them, so analysts can inspect and contest how their question is grounded in the data. Both graphs are constructed from only the dataset and the analyst's question, and the analyses the analyst reaches are rendered as interactive dashboards. We illustrate the system through a usage scenario and describe a user study design for examining whether the system scaffold analysts' reasoning and navigation.
Tags
Links
- Source: https://arxiv.org/abs/2610.11025v1
- Canonical: https://arxiv.org/abs/2610.11025v1
Trouble viewing inline? Open PDF directly →
Full Text
116,003 characters extracted from source content.
Expand or collapse full text
Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data Analysis Junran Yang junran@cs.washington.edu University of Washington Seattle, Washington, USA Shruti Badrish shrutib@uw.edu University of Washington Seattle, Washington, USA Teanna Barrett tb23@cs.washington.edu University of Washington Seattle, Washington, USA Leilani Battle leibatt@cs.washington.edu University of Washington Seattle, Washington, USA Abstract Exploratory data analysis (EDA) is rarely open-ended in practice: analysts work from high-level domain questions toward the con- crete analyses that can answer them, prioritizing directions with domain knowledge and prior hypotheses. Large language models (LLMs) can supply such knowledge, but their responses are un- structured, leaving analysts no way to see what has been explored, what is missing, or why one direction was chosen over another. We present DAG, a system that lets analysts and an LLM co-navigate the space of possible analyses through two linked structures. An in- tent graph, governed by a grammar of analytical intent, decomposes an ambiguous natural-language question into progressively con- crete analysis tasks, keeping alternative framings open and letting analysts branch, backtrack, and compare paths. A multi-layered knowledge graph externalizes the LLM’s domain knowledge, linking domain concepts to the dataset variables that can measure them, so analysts can inspect and contest how their question is grounded in the data. Both graphs are constructed from only the dataset and the analyst’s question, and the analyses the analyst reaches are ren- dered as interactive dashboards. We illustrate the system through a usage scenario and describe a user study design for examining whether the system scaffold analysts’ reasoning and navigation. CCS Concepts • Do Not Use This Code→Generate the Correct Terms for Your Paper; Generate the Correct Terms for Your Paper; Generate the Correct Terms for Your Paper; Generate the Correct Terms for Your Paper. Keywords dashboard, exploratory data analysis, analytical intent Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from permissions@acm.org. Conference acronym ’X, Woodstock, NY © 2018 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-1-4503-X-X/18/06 https://doi.org/X.X ACM Reference Format: Junran Yang, Shruti Badrish, Teanna Barrett, and Leilani Battle. 2018. Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data Analysis. In Proceedings of Make sure to enter the correct conference title from your rights confirmation emai (Conference acronym ’X). ACM, New York, NY, USA, 18 pages. https://doi.org/X.X 1 Introduction The traditional view of exploratory data analysis (EDA) was intro- duced by Tukey as an open-ended, bottom-up process of finding in- teresting patterns in a dataset, operationalized by domain-agnostic approaches such as data profiling (e.g., summarize distributions, flag anomalies, enumerate correlations, etc.). This framing has shaped how many EDA tools are built: treating variables and their combi- nations as equally worth examining [82,97], or passively surfacing variables of interest through statistics [89]. Due to the opportunistic nature of EDA, analysts face two interleaving challenges. First, the space of possible variable combinations is vast. Without a princi- pled basis for prioritization, analysts must make ad hoc decisions about where to look. Second, there is no natural stopping condition since EDA has no formal criterion of completion. Both challenges are compounded by the reality that analysts operate under limited time, resulting in them moving on to other tasks before feeling ready [96]. In reality, analysts do not treat all attribute combinations as equally worth exploring. They prioritize based on domain knowl- edge, prior hypotheses, and what they already believe matters [39, 96]. This is not a deviation from good analytical practice, but a nec- essary and plausible approach to an otherwise intractable search problem. In practice, the EDA process is often guided by high-level intents, motivated by the context in which the analysis is embedded, such as business requirements, stakeholder questions, or research goals [1]. EDA activities exist along a spectrum from exploratory to directed, at the far end of which executions can be clearly specified by top-down planning [1]. These intents do not specify the analysis in detail, but they shape which directions are worth pursuing and which findings would be considered relevant. EDA, in this light, is less about open-ended discovery and more about goal-directed analytical reasoning: working from a high-level domain question toward the concrete analyses that can answer it. Pre-LLM tools automate steps that are mechanical and repeat- able to reduce manual implementation burden. Domain knowledge arXiv:2610.11025v1 [cs.HC] 8 Oct 2026 Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. is still required from the analyst to interpret results and prioritize directions. Deciding what to look for, and why, remains unsup- ported. Analysts’ depth and breadth of exploration are constrained by the time required to manually construct and inspect enough combinations. LLMs change what is possible by surfacing which variables are likely to matter, which relationships are theoretically plausible, and which analytical directions are worth pursuing given a domain context. However, LLM responses are unstructured and not navigable: they offer no way to enumerate what has been ex- plored, identify what is missing, or explain why one direction is more appropriate than another given the data available. Critically, the analyst has no way to see into the LLM’s reasoning, contest its assumptions, or steer the exploration with confidence. This moti- vates our research question: How can we enable users and LLMs to co-navigate the space of possible analyses during EDA in a transparent way? We identify two intertwined challenges that together constitute this problem. RQ1: Scaffolding and Navigation: How can systems scaffold the analytical reasoning process and help analysts navigate from am- biguous, open-ended goals toward concrete data operations without over-constraining their exploration? Analytical questions are am- biguous at several levels at once: in how the question is framed (exploratory vs. confirmatory), in what the terms mean (concepts vs. variables), and in which of many valid analytical directions to pur- sue. This ambiguity is a natural property of open-ended questions, so scaffolding must resolve it without prematurely eliminating al- ternatives the analyst might find inspiring. At the same time, the reasoning process itself is not a single decision but a sequence of choices across a space of possible framings, variables, and opera- tions, and it is nonlinear: analysts branch into parallel framings, backtrack when a direction proves unfruitful, and reframe their question in light of what they discover. Without support, analysts lose track of where they are, how their current thread relates to oth- ers, and how to recover a coherent picture of their own reasoning process. Scaffolding this process requires defining what analytical moves are valid and in what order. RQ2: Shared Representation of Analytical Intent: How can systems establish a shared representation of analytical intent that remains meaningful to human analysts, LLMs, and executable code while preserving the ambiguity and flexibility that exploration requires? Humans reason in domain concepts, LLMs operate on nat- ural language, and code operates on data variables. For a system to meaningfully augment rather than replace analytical reasoning [31], all three must stay aligned around a common understanding of what the analyst is trying to do, yet each operates in a fundamentally different vocabulary. A shared representation must bridge all three to balance competing demands: it must be concrete enough for the system to act on and specific enough for analysts to have agency over their intent, yet flexible enough to hold multiple interpreta- tions open until the analyst is ready to commit. Resolving ambiguity too early forecloses valid analytical directions; leaving it unresolved too long prevents the system from providing meaningful guidance. We address these challenges through a system that bridges the gulf between high-level analytical goals and low-level data oper- ations by establishing shared context between the user and the LLM. We propose an intent grammar, which formally constrains how intents instantiate, propagate across parameters, and evolve. Complementing the grammar, an NL parsing component translates open-ended analytical questions into the initial intent specification at the entry point to be propagated. To let analysts traverse the structure, maintain awareness of where they are in the process, and revisit prior branches, the system interface extends the capa- bility of the grammar, making the grammar rules navigable and interactive. The intent specification serves as this shared language for goals, while the knowledge graph externalizes LLM-generated domain knowledge into a form the analyst can inspect and agree with, bridging the gap between what the system infers and what the analyst understands. These two challenges are deeply interdependent. Shared repre- sentation is what makes scaffolded navigation meaningful: analysts are not merely traversing an abstract graph but moving through a conceptual space they and the system mutually understand. Scaf- folding is what makes shared representation actionable: the repre- sentation is not a static snapshot but becomes progressively more concrete as the analyst makes choices, with each grounded pa- rameter narrowing the space of what comes next. The interface operationalizes both challenges together: the intent DAG makes the scaffolded reasoning process traversable, while the knowledge graph visualization makes the shared representation legible. Neither component alone addresses both challenges. It is their combination that constitutes our system contribution. We demonstrate DAG through a walkthrough of an analyst working from an ambiguous question to a grounded dashboard (section 4). What this chapter reports is the design and the ratio- nale behind it; an empirical evaluation of how analysts use the two graphs remains to be carried out. In this chapter, we make the following contributions: •A graph-based representation of analytical intent that scaffolds the analyst’s intent and reasoning process for con- ducting exploratory data analysis (EDA) while authoring dashboards (subsection 5.2). The formalism consists of multi- ple granularities, from a high-level NL question to a concrete set of analysis tasks, supporting flexible navigation and ex- ploration style. •A multi-layered knowledge graph that informs the con- struction of the intent graph (subsection 5.3). It consists of two layers. The concept layer contains domain concepts that guide the decomposition of high-level questions into inves- tigable sub-questions. The data layer, containing causal rela- tionships of data variables existing in the provided dataset, grounds abstract concepts to measurable data that can be visualized based on concrete analytical tasks. •LLM-based methods that construct both graphs from minimal context, namely the dataset and the analytical question (subsection 5.5). The framework consists of a bottom- up approach that groups data columns into semantically meaningful domain concepts and a top-down approach that extracts domain concepts based on the question, so that the knowledge graph is generated and the intent graph construc- tion steered without a curated ontology for the domain. • An interface that integrates NL queries with intent graph manipulation (subsection 5.6), supporting iterative Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY refinement of EDA intent and dashboard creation, and gener- ating interactive dashboards from the terminal analyses the analyst reaches. Closing the loop, so that the system reads the analyst’s interactions with those dashboards to update the intent graph, is a direction we outline as future work. 2 Related Work Characterizing analytical intent. Intent is commonly described as the translation of a high-level question into low-level actions [10], and has been formalized at several granularities: classes of anal- ysis goals derived from design studies [39], low-level task tax- onomies [2,60], and narrower operationalizations as attribute-and- filter selections [41], an “interestingness” metric over analytic ac- tions [40], or prompts to be triaged by a data-driven system [49,87]. Pyxis [8] is closest to our stance, placing insight on two axes, an- alytic and domain knowledge, so that an analyst’s beliefs about the domain are as constitutive of an insight as the data relation- ships they infer; hypotheses play a corresponding role in models of knowledge generation [67]. A related line formalizes intent as a grammar rather than a taxonomy. Suh et al. [78] contribute a hypothesis space, containment, and grounding, but their gram- mar is descriptive, enumerating every parseable hypothesis; ours is prescriptive, constraining the semantic gaps a language model fills rather than closing a language. For the shapes a grounded claim can take we adopt Choi et al.’s recursive typology [14], which shares its goal vocabulary with Lam et al. [39] but carries no notion of sequence; composing its types into a graph reintroduces ordering and makes it dynamic, since the shortest route to an unvisited anal- ysis is recomputed as the analyst descends. Outside visualization, work on search and conversational intent likewise treats intent as inferred and progressively refined rather than stated once [15,57]. Dashboard recommendation. Dashboard automation is well surveyed [102] and divides into approaches that encode designer knowledge as intents, templates, or mined rules [21,47,61,77] and approaches that learn composition from data [13,16,63,100]. Med- ley [61] derives high-level dashboard intents from over 200 dash- boards, and Bolt [77] maps natural language onto a taxonomy of five objectives, whose authors note that static taxonomies cannot flexi- bly translate an utterance into low-level tasks. Both families share two limits: the set of intents a system can implement stays small, and both concentrate on the analytic dimension of intent while leaving its domain knowledge dimension implicit. DAG answers the first by generating the decomposition per dataset and per question instead of fitting an utterance to a fixed taxonomy, and the second by constructing an explicit conceptual knowledge graph along- side it. Work on coordinating multiple views and recording how they were reached [9,74], on characterizing dashboard design and use [6,70,76,81], on mapping data to effective encodings [36,53,59] and extracting and sequencing data facts [19,44,73,75,94], and on laying out the resulting views [17,64,72] all operate once the analytical question has been settled, which is the step we target. Navigating the space of analyses. EDA is often treated as open- ended pattern finding, with tools that surface variables and com- binations to browse [88,97], but hypothesis-driven analysis is a real and distinct behavior when observed through free-form proto- cols [99], and the two are not separable: there is no hypothesis-free exploration [22], and exploratory and confirmatory work proceed in tandem [37]. We therefore treat every state from a vague ques- tion to a grounded claim as a degree of hypothesis formation, so awareness and refinement are two faces of one thing rather than two phases of a workflow. Visualization recommenders are a gen- uine precedent for reasoning over a constrained space, enumerating candidates under rules and completing them from a partial specifi- cation [46,97,98], but they assume the analyst can already supply that specification, which is the hard part, and they aim to navigate toward a good result rather than to convey the space itself—an aim whose evaluation criteria rarely transfer between systems [103]. We give ranking a different job, ordering the moves we offer by how much each would distinguish the analyses downstream rather than by how good the resulting analysis is judged to be. Multi- verse analysis makes decision structure an auditable artifact [52], but it executes exhaustively because its outcomes are comparable point estimates; ours are heterogeneous analyses on no common axis, and the specification is still being formed. That same precon- dition, a cheaply scorable objective, is what lets LLM tree search discover empirical methods automatically [5], and it does not hold when the alternatives are competing readings of an ambiguous question. Closest in shape are systems that give guidance a repre- sentation the user can see: insight networks over findings already produced [4,25,33,42], in-situ next-step suggestions that leave the space implicit [12,45,105], and shared diagrams or node can- vases that user and model both edit [20,84], all following Heer’s argument that agency and automation are reconciled by a shared representation of possible actions [26,31,38]. Ours differs in what that representation is made of: the intent graph is generated by a grammar, so every node is a well-formed claim and every edge a single legal refinement, which is what lets the same structure both constrain generation and be checked by the analyst. Language models for open-ended analysis. Natural language in- terfaces for visualization predate large language models [24,60,71] and now use them to generate and edit specifications [43,68,80, 86,90,91], sometimes relaxing the turn structure itself [3,79]; each returns a single view or transformation per turn rather than composing a dashboard around the question that prompted it. A parallel thread applies language models to insight generation and summarization [48,50,54,92,95,107], asking what the data shows rather than what is worth asking of it. A third asks how far models carry open-ended analysis [29,55,56,83,106], and benchmarks temper the answer: models give surface-level recommendations despite broad domain knowledge [28], cannot reliably navigate ambiguity [69], and produce queries that are valid but answer the wrong question [58]. Whether such assistance helps also de- pends on whether the analyst can inspect, attribute, and correct it, which studies of analyst–AI collaboration find is the binding constraint [11,66,85,101]. Rather than ask a model to resolve an ambiguous question in one shot, DAG makes the decomposition itself an inspectable artifact the analyst can validate, extend, and redirect, records provenance for every refinement, and derives its offers from the grammar so that an unhelpful suggestion can be traced to a rule and overridden rather than merely re-prompted. Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. 3 Design Considerations Our aim is to help an analyst move from a vague question toward a set of well-formed, executable hypotheses, not necessarily a single one, along a path that is rarely linear. Two goals sit behind this aim. The analyst should be able to account for the choices the system makes on their behalf, which is a matter of deliberateness, and the process should surface alternatives the analyst would not have found alone, which is a matter of discovery. These pull in the same direction rather than against each other, because both reduce to one question: would this choice make a difference? To keep the process deliberate, every interpretive choice made on the analyst’s behalf is visible, justified, and reversible, and moving between live branches costs the analyst nothing. We derive the following design considerations from the chal- lenges users face during scaffolded EDA, informed by prior work on human-AI collaboration, analysis intent, and interactive data systems. DC1: Provide a Shared Representation of Analysis Intent Between the User and System. A core challenge in human-AI collaboration is establishing a common representation of goals that both parties can inspect and reason about [31,34,51,104]. Heer [31] frames this as a shared representation of possible actions, which presumes a space of candidate actions the system can already enumerate. Our setting inverts that presumption: which actions are worth taking depends on an intent the analyst has not yet finished forming, so the representation has to carry intent before it can carry actions. A human-readable grammar provides scaffolding for the user to express their intent to the system in a structured way. A grammar also allows the user (and system) to quickly verify if LLM suggestions match the expressed intent. Grammars have long served as a way to abstract away execution details, letting users reason at the level of what they require rather than how the system will deliver it. In systems with LLM components, this role becomes more important: the grammar simultaneously steers generation by providing a structured space of valid analytical outputs, and applies a shared contract by supplying a verifiable specification against which suggestions can be checked. This dual function molds LLM-assisted output from opaque recommendations into auditable results, enabling users to inspect, override, and trust the system’s reasoning. DC2: Verify That the Selected Dataset Is Appropriate for Answering the User’s Analysis Question. Users frequently ap- proach EDA with analysis questions that are conceptually under- specified relative to the available data: the question may invoke ab- stract concepts that map to data variables in non-obvious ways, or it may be premised on data relationships the dataset does not actually support [62]. Bridging this conceptual gap is non-trivial, as it re- quires anchoring abstract analytical vocabulary in domain-specific knowledge before reaching the level of concrete data variables. Our system addresses this through a two-stage grounding process: we first situate the user’s question within an LLM-generated domain knowledge graph that captures abstract conceptual relationships, then progressively refine those concepts toward concrete data vari- ables using structured LLM assistance. This approach separates the semantic interpretation of the question from its operationalization in data, reducing the risk of silently mismatching a question to an inappropriate dataset. DC3: Enable Both the User and the System to Reason About the Space of All Possible Analysis Paths. Traditional visualiza- tion recommendation systems for EDA, predating LLMs, generate a set of “top-푘” suggestions ranked and selected by manually de- signed metrics or ML-based models. Although these methods are designed to be data-centric, they are domain-agnostic, which misses the opportunity to incorporate domain knowledge into data explo- ration. Typical LLMs, by contrast, surface a limited set of analysis suggestions that are closely relevant to the domain context of the data, providing limited rationale for why these particular paths were selected over alternatives that were not mentioned at all [27]. This behavior occludes the full space of valid analyses and denies users the ability to reason about what they might be missing. Rather than committing to a fixed number of suggestions, our system is de- signed to make the entire space of valid analysis paths enumerable and navigable. Because the system represents all analyses deriv- able from the formal grammar and the knowledge graph, users can observe how it traverses this space. Then, the user can request explanations for analysis steps that do not make sense, intervene to redirect the system towards more relevant analysis paths, refine their original intent to better reflect their analysis goal, or accept a suggested analysis path if it matches their intended analysis goal. DC4: Enable the User to Verify How Any Given Analysis Step Is Grounded in Data Science Best Practices and the Relevant Domain Context. Users distrust AI-generated suggestions they cannot understand [93]. In data science, trust in suggested analyses requires understanding the domain context that explains why it makes sense to combine the selected variables [28]. Trust also requires understanding why these analysis methods are appropriate for the selected data types [23,28]. Therefore, the system should generate explanations that facilitate the user’s ability to verify its choice of domain context and analysis methods. DC5: Enable the User to Compare Multiple Dashboard De- signs Simultaneously. Because a user’s analysis question may be underspecified, multiple valid analytical paths may exist for an- swering it, potentially yielding distinct dashboard designs that each represent a coherent interpretation of the question [7,39,77]. Prior systems that generate multiple dashboard alternatives typically do not provide users with a basis for comparing them beyond their visual appearance [18,36,53]. We seek to provide users with the ability to compare and contrast these possible designs in terms of the line of reasoning for why the data should be analyzed along these paths to produce an answer. This approach is distinct from prior work, which does not ground the evaluation of multiple dash- boards through comparison of sequences of analysis decisions. This makes it possible to compare how different interpretations of the same question lead to different analytical paths, supporting more principled selection among valid alternatives. Grounding Principles. Five commitments follow from these con- siderations and constrain every part of the design. The analyst can always see how much of the candidate space remains open, not only the current selection (space-awareness). Every narrowing is Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY either a grammar consequence, auditable by construction, or an explicit inference the analyst can inspect and reverse (no silent shrinking). Grounding one branch never removes or hides its sib- lings (no premature convergence). The system’s only license to rank, highlight, or offer a move is how much it would distinguish the analyses downstream, never raw plausibility (discriminability). And the shape of what is still open is shown, not only what is resolved (visible skeletons). 4 The Interface in Use This section follows one analyst through one session to show what the grammar and the two graphs of section 5 look like from the analyst’s side of the screen. Anna is a data analyst working for a movie production company. Her dataset covers movies released before 2016, 3,201 rows and 16 columns spanning financial infor- mation (e.g., budget and worldwide gross), production metadata (e.g., genre, director, distributor, MPAA rating, and release date), and audience response (e.g., IMDB rating and vote count). Her brief is a single sentence: “What are the main characteristics of successful movies?” How Anna does this today. In a commercial BI tool such as Tableau, the question is not something Anna can act on, so her first move is to make it concrete in her head. She decides privately what “success” will mean, brainstorms conceptual variables before she looks at the schema so as not to fixate on whatever columns happen to exist, then maps those concepts onto attributes and derives the ones the dataset lacks, such as ROI or budget tier or release season. Only then does she start building: a scatter plot for budget against gross, a bar chart of movie volume by genre, a histogram of IMDB scores, and a genre filter to tie them together. Two costs are hidden in that sequence. The interpretation of “success” that survives into the dashboard is the one Anna committed to before she had looked at the data, and the alternatives she considered leave no trace, so neither she nor anyone reviewing her work can tell which readings were rejected and which never came to mind. And she learns that the dataset cannot support a reading only by building the charts that fail to answer it. The interface. Figure 1 shows the interface Anna works in instead. She types her question into the question bar (A) and parses it, and the canvas (B) fills with the claims the question could resolve into, one node per candidate analysis. Each node states the claim it makes, renders it as a sentence, and shows its slots as chips; the moves available from it hang beneath it, grouped by the state they would produce and collapsed to a count, so Anna can see how much is still open without reading through it. Selecting a node fills the active node panel (C), which gives the claim in full, lists its slots, and, once the required ones are grounded, offers to complete the claim to a dashboard. The knowledge graph (D) sits beside the canvas throughout, its concept and data layers joined by bridge edges and filterable by layer and edge type. Dashboards are not a fixed region of this layout: each is completed from a particular node and opened on its own, so Anna accumulates them over the session rather than being shown a running recommendation. The session below is otherwise entirely a matter of what she selects and what the two graphs say back. The question. Anna types her question and expects a dashboard. What she gets is three readings of it side by side, each carrying the system’s confidence that it is the one she meant (Figure 1-B, and across the top of Figure 2). The strongest, at 94%, is a relation asking which quantitative factors drive movie success. A comparison of success across movie categories follows at 38%, and a trend of success over time at 22%. “Success” is held as an unresolved concept in all three, and no combination of columns has been enumerated under any of them. This is the first thing Anna has to adjust to, and it is deliberate: her question admits several readings, and the system commits to none of them on her behalf. The knowledge graph answers a question about the dataset. Before descending into any of them, Anna opens the knowledge graph to see what “success” could even mean here (Figure 1-D). The concept layer places movie success at the center of a small neighborhood of readings: Box Office Success, Audience Success, and Critical Success. Following the bridge edges down to the data layer tells her which of these the dataset can carry, and on what terms. Box Office Success operationalizes cleanly, reaching production budget and worldwide gross. Critical Success does not: the only columns beneath it are rating columns, and IMDB rating in particular is an audience score standing in for a critic’s judgment. The graph says so rather than quietly substituting one for the other, and Anna decides she can work with the proxy provided she treats the two ratings as separate measures rather than as one. That is a decision about her question, made before she has built anything, on evidence the system put in front of her rather than on charts that failed to answer it. Opening a concept costs nothing. Anna descends “success” from the relation reading (Figure 2). It resolves into two children on the canvas, a relation over Box Office Success and a relation over Critical Success, and she works on both in turn. Neither displaces the other, and the comparison and trend readings above them are untouched. This matters more than it sounds: in her Tableau workflow, choosing one of these meant the others existed only in her memory, and revisiting one meant rebuilding it. Grounding a branch to columns. The Box Office Success branch descends in steps rather than in one jump (Figure 2, left). The concept first pairs with production budget, then the claim moves to production budget against worldwide gross, and only at the bottom of the chain do the slots reach the columns themselves. At that point the node is marked renderable: its required slots are grounded, so it can be completed to a dashboard. Each step is a single move Anna made, and each intermediate claim stays on the canvas as its own node, so the path from an abstract concept to two concrete columns is legible afterwards rather than only in her head. A commitment reshapes the claim. The Critical Success branch takes a different kind of step. Rather than descending to a column directly, Anna makes a branch selection that narrows the concept to Rotten Tomatoes rating, leaving a relation with one slot filled and one still open. From there the branch forks. Filling the open slot with IMDB rating produces a relation between the two ratings, which is exactly the critic-against-audience comparison the proxy warning had made her want. Filling it with genre produces something else: Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. A B C D Figure 1: The DAG interface, early in Anna’s session. The question bar (A) holds the analytical question the session started from and the control that parses it. The state DAG canvas (B) shows the claims Anna has formed, one node per candidate analysis. Here it holds the interpretations the parser returned, each labeled with the claim it makes, a natural-language rendering of what it would ask, the confidence that it is the intended reading, and its slots as chips. The moves available from each node hang beneath it, grouped by the state they would produce and collapsed to a count, so that the shape of what is still open is visible without enumerating it; the toolbar names the four families of move the grammar admits. The active node panel (C) describes the selected claim in full, lists its slots, and offers to complete it to a dashboard once its required slots are grounded. The knowledge graph (D) shows the concept layer and the data layer joined by bridge edges, with filters for which layers and edge types to display. genre is categorical, and because a claim’s type follows from what fills its slots, the relation reshapes into a comparison of Rotten Tomatoes rating across genre rather than forcing a category into a slot meant for a measure. Anna reads this as the system following her rather than correcting her. It is the one move in her session that settles what fills a slot and changes the shape of the claim in the same step. Choosing without committing. With the comparison selected, Anna works on which categorical variable it should use. The panel beside the canvas lists the candidates as a checklist, and ticking one re-renders the claim without changing it: the node is not re- placed, nothing new appears on the canvas, and she can try major genre against creative type as often as she likes at no cost. Only when she decides a selection is worth keeping does she commit it, which creates a child node and puts the choice on the record. The distinction matters to her for a small reason and to the system for a larger one. She gets to browse without littering the canvas, and the system gets a clean answer to what a node is: the claim it makes, not every variable she looked at on the way to making it. Two paths, one claim. The comparison reading the parser ranked second, at 38%, is not idle. Anna descends it, and it runs the same three moves the relation reading did: success resolves to Critical Success, a branch selection narrows that to Rotten Tomatoes rating, and a final descent settles the slot that is left. Nothing the two readings produce along the way is shared. They differ, too, in what that last move had to do: on the relation side it bound a category into an open slot and reshaped the claim, while on the comparison side the shape was fixed at parse time and the move only had to say which category. They end on the same node all the same, and it carries both of them as parents. Had the canvas been a tree it Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY path A path B Node Panel reshape Figure 2: Anna’s intent graph at the end of her session, with the dashboards she has open and the node she has selected. Across the top are the three readings the parser returned for “What makes a movie successful?” Two paths A and B are outlined. Each outline encloses the claims Anna formed while following that reading, and the two enclose one card in common, the comparison of Rotten Tomatoes rating across genre that both readings resolve to. The move marked reshape is the one that changes the shape of the claim as it binds, which turns a relation into a comparison. The node panel at the right describes the selected claim A node is marked renderable once its slots reach data and it can be completed to a dashboard. would hold two of these, one under each reading, and Anna would have no way to tell they were the same analysis. As it is she can see that the reading the system ranked first and the reading it ranked second converge, which is a substantive thing to learn about her own question, and not something she would have found by taking the 94% suggestion and stopping there. Dashboards, and what is left open. From each renderable node Anna completes the claim to a dashboard, which opens on its own rather than replacing whatever she was looking at. By the end of the session she has three open at once: production budget against worldwide gross from the box office branch, IMDB against Rotten Tomatoes rating from the critical branch, and Rotten Tomatoes rating across major genre from the node the two branches share. Each names the template it instantiates and the bindings that fill it, and carries controls for how values are aggregated and how many categories are shown. What she compares across them is not three chart designs but three readings of what makes a movie successful, each traceable back through the moves that produced it, and no one of them is put forward by the system as the answer. Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. The canvas also records what she did not do. The moves still available from her selected node sit beside it, collapsed to counts rather than enumerated, and among them is a compose offer she never takes. The trend reading is still where the parser left it, never descended. These are not loose ends but the parts of the ques- tion Anna chose not to pursue, still visible at the point where she stopped. What the session shows. Anna never told the system what “suc- cess” meant, and the system never decided for her. Every narrowing was one she made, from a set of alternatives the system could enu- merate and she could audit, and the readings she did not take are still on the canvas at the end of the session (DC1, DC3). The one thing she settled before building anything came from the knowledge graph reporting the terms on which the dataset could operational- ize a concept (DC2), and the convergence she found was legible only because each path is recorded on the node it reached (DC4). What she leaves with is not a dashboard but several, positioned against each other by the reasoning that produced them (DC5). One thing the session does not show is the return path: DAG does not yet read Anna’s interactions with a rendered dashboard back into the intent graph, which we take up in subsection 7.2. 5 System Design DAG turns an ambiguous analytical question into a navigable space of concrete analyses. A session starts when the analyst types a ques- tion over a dataset, such as “What are the main characteristics of successful movies?” From the question and the dataset schema, the system builds two structures (Figure 3). A knowledge graph (Fig- ure 3, B ○) grounds the vocabulary of the question in the data, con- necting the abstract terms the analyst reasons with to the columns the dataset actually provides. An intent graph (Figure 3, A ○) lays out the analyses the question could resolve into, one node per candidate analysis. Every node is a partial analysis: a claim with some of its parts settled and the rest still open. The analyst refines the question by moving through the intent graph one step at a time, settling what an ambiguous term denotes, committing to how two variables relate, drilling into a mediator, or binding a slot to a column. Each move is a single grammar rule made interactive, and each fully specified analysis maps to a recommended dashboard. The one idea that holds the graph together is that a node is identified by the claim it makes, not by the path the analyst took to reach it. Two routes that arrive at the same claim over the same columns arrive at the same node, so the intent graph is a DAG by construction rather than a tree the system has to prune. This is what makes exploration cost-free. Branches never overwrite one another, a node the analyst leaves is exactly where they left it when they return, and backing out of a step is just stepping back to a claim that was never destroyed. We organize this section around the design considerations from Section 3. A grammar of analytical claims gives the user and the system a shared representation of intent (DC1). The knowledge graph and its two-stage grounding test whether the dataset can answer the question (DC2). The intent graph and its one-step of- fers keep the space of valid analyses enumerable and navigable rather than reducing it to a ranked shortlist (DC3). Provenance and inspectable candidates let the analyst verify why each step was taken (DC4). Convergence and side-by-side comparison let the analyst hold competing interpretations of the same question against each other (DC5). We describe the grammar, then the two graphs it works over, then how they fit together, giving each its concrete realization where it is introduced. 5.1 The Grammar The analyst and the system work over one shared representation of intent: a small grammar of analytical claims (DC1). We describe it in the large before pinning down the small structure that stands in for a claim. A claim is drawn from a small typology of shapes [14]: a value summarizes one variable, a trend follows a variable over time, a relationship ties two variables together, and a comparison contrasts a measure across a category. A relationship folds correlation and causation into one shape, committing a direction only once the evidence supports it rather than assuming one at the outset. Each claim is built from named slots, each carrying a role and a type (measurable, categorical, or temporal). A claim’s type follows from what fills its slots rather than a label the analyst sets: a lone measure reads as a value, a measure and a category as a comparison, two measures as a relationship, a measure over time as a trend. Because the type follows the slots, adding or changing a slot can reshape the claim, so naming a categorical driver of an outcome turns a rela- tionship into a comparison across that category rather than forcing the category into a measure. A slot may be an open placeholder, an unresolved concept (“success” before it is pinned to revenue or ratings), or grounded to one or more columns. Grounding is the act of binding a slot to data; a claim becomes executable, and offers a dashboard, once its required slots are grounded. When a concept has no adequate column, the system says so and holds it anyway, which is itself an answer: the dataset does not support that reading of the question (DC2). The analyst refines a claim along two independent axes, which the draft grammar had conflated. Referential moves resolve what a term denotes, opening an unresolved concept into the concepts it could mean. Relational moves change the claim’s structure, either the shape it instantiates or how it composes with other claims. The two constrain each other: fixing “success” to a categorical genre rules out the relationships that would treat it as a measurable out- come, and asking for a driver of an outcome requires that outcome to be measurable. Keeping the axes separate lets a commitment on one prune the other, and lets the analyst make the two kinds of commitment independently rather than through a single tangled choice. Formally, a claim is a state: a set of at most two typed slots 푆=(휏 1 ,푏 1 ), . . .,(휏 푘 ,푏 푘 )with푘 ≤2. Each type휏 푖 is measurable, categorical, or temporal (푄,퐶, or푇), and each binding푏 푖 is an open placeholder, a concept in the hierarchy, or a set of grounded columns. The type multiset alone decides the claim. A pure func- tion푓maps it to a hypothesis type (푓(푄)= Value,푓(푄,푄)= Relation,푓(푄,퐶)= Comparison,푓(푄,푇)= Trend), and a sec- ond function푔maps a hypothesis type to the dashboard template or templates that render it. Neither푓nor푔is stored on the node; both are computed on demand, so the type and the template of a state are always a function of its slots and cannot drift out of sync Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY “What makes movies successful?” Dataset schema Relation RT rating against IMDB Rating Q rt_rating Relation What relates to critical success? Q Critical successopen Q imdb_rating Comparison RT rating across Genre Q rt_rating C genre descend reshape Intent Graph - propagator Box office successMovie successCritical success part of part of Concept Layer- built once per query US gross imdb_ratingrt_rating associated with causes Data Layer- built once per dataset budget award operationalized by Knowledge Graph binding parse graph construction A B C D 1 2 Figure 3: The DAG architecture, instantiated on “What makes movies successful?” The analyst’s question and the dataset schema are the only inputs. 1 ○Parsing the question seeds the intent graph A ○with the claims it could resolve into, and 2 ○graph construction builds the knowledge graph B ○ from the question and the schema together. In the intent graph, each node is a claim whose slots carry a type, measurable (Q) or categorical (C), and a binding that is open, an unresolved concept, or a set of columns; a chart icon marks a node whose required slots are grounded and which therefore renders to a dashboard. The two edge families appear here as one descend step, which resolves “critical success” to the columns beneath it, and one reshape step, which turns a relationship into a comparison by admitting a categorical slot. The knowledge graph splits into a concept layer C ○ , built once per question, and a data layer D ○ , built once per dataset, joined by operationalized by bridge edges. The binding edge is where the two structures meet: grounding a slot is a walk from the concept a slot holds to the columns that operationalize it. The dashed “award” concept has no column to operationalize it, which the system reports rather than silently dropping. with them. A type multiset with no image under푓is a partial state: a legitimate stopping point the analyst can extend or compose, not an error. We separate the engine from the typology: the engine instan- tiates states, discovers candidates, and applies productions, while the typology says which claims exist and how they render. The typology is realized as the tables behind푓and푔rather than as a document the engine interprets, so swapping those tables swaps the analytical vocabulary without touching the engine, and the Choi et al. set is the reference instantiation. Table 1 gives that in- stantiation, and it is short:푓is defined only up to arity two, so a base state binds at most two variables and every analysis over three or more is a composite. The bound is not a budget on com- plexity but a consequence of what an unordered multiset can say. Two variables need no designation, because their types settle their roles: in푄,퐶the measure is what is compared and the category is what it is compared across, and no other reading is available. A third variable always introduces a choice the multiset cannot record. Three measures do not say which is the mediator; a mea- sure with two categories does not say which category the other is read across. Composition exists to supply exactly that missing designation, which is why the boundary falls where it does rather than at four or five slots. One consequence matters downstream: an open slot’s type is provisional and adopts the type of whatever it first binds to. Binding a categorical driver to an open slot therefore reshapes a relationship into a comparison, rather than pinning a category into a measurable slot. This is what makes the system’s behavior auditable (DC1). Every candidate the system surfaces, every move it offers, and every check on whether an analysis is well-formed follows a grammar rule rather than ad hoc logic, so the analyst can hold a suggestion to the same rule the system does. 5.2 The Intent Graph The intent graph (Figure 3, A ○) records where the analyst has been and where they can go. Each node is a claim, an instance of the Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. Table 1: The reference instantiation of the typology, as the two tables behind푓and푔.푓is defined only up to arity two: these four multisets are every base state the grammar admits.푔is multi-valued where more than one framing is defensible; choosing among them is a render-time decision, not a production. Swapping these tables swaps the analytical vocabulary. Every analysis over three or more variables is a composite, given in Table 2. Examples are drawn from the dataset of Section 4. multiset 푘 푓 : hypothesis 푔: template example claim Q1Value M1The distribution of worldwide gross. Q, Q2Relation M3Production budget against worldwide gross. Q, C2Comparison CAT1 M2Rotten Tomatoes rating across genre. Q, T2Trend CH1Worldwide gross over release year. grammar, and each edge is a refinement move. The graph is a DAG rather than a tree because two paths often reach the same claim: an analyst can start from “What drives revenue?” and drill down, or ground revenue and budget separately and compose them, and both routes land on the same relationship over the same two columns. Because a node is identified by the claim it makes, not by the path taken to reach it, the two routes do not produce two nodes to be reconciled after the fact; they produce one node with two parents. There is nothing to merge, because the node was never two things. How each path reached the node is kept as provenance, so the analyst can still see why the node is on their path. Because paths converge (see Figure 2), the order in which analy- ses appear is not a fixed sequence. The shortest route from the root question to any node the analyst has not yet visited is recomputed as they descend, and moving sideways between live branches costs nothing: the state of a branch is preserved when the analyst leaves it and restored when they return. This is what lets the analyst hold several readings of a question open at once instead of committing to one and backtracking (DC3). The system realizes this identity by content-addressing. A node is addressed by what it is, not by how it was reached: the sys- tem computes a key from the state itself, a normalized hash of its slots and bindings, and that key is the node’s identity, exactly as a version-control system names an object by a hash of its content so that identical content is one object no matter who produced it. Interning a newly produced state either returns the existing node with that key or creates a new one, and records the move as a provenance edge. Content-addressing collapses a cluster of algorithms an earlier design carried separately. Consolidation is not a pass that finds and merges duplicates: two paths that produce the same state produce the same key and therefore the same node, with several incoming edges. Reversibility is not a snapshot the system restores: a move only ever adds a node, so backing out is re-selecting the parent, which was never altered. Lateral movement between branches is free for the same reason, since a state is im- mutable once interned and nothing one branch does can reach into another. The provenance graph is kept acyclic: a move that lands on an existing ancestor is recorded as a revisit rather than a back-edge, so the history stays a legible record of productions rather than a tangle. The edges of the graph are productions, and they come in a few families. Structural productions reshape the type multiset: add a slot, drop a slot, or retype one, each of which changes the hypothe- sis type and hence the template. Binding productions move a single slot through the concept hierarchy: descend to a more specific con- cept or column, or ascend to a more general one. A descent that reaches a column grounds the slot, and committing a hand-picked set of columns is a binding production of its own. Composition pro- ductions create or unwind the composite structures of Section 5.5. Every production validates its precondition (arity at most two, no two slots grounded to the same columns, a descent staying within its slot’s subtree), and an illegal move is refused rather than allowed to produce an invalid state. The offers the analyst sees at a node are its frontier: the set of productions found legal from the current state, computed on demand rather than stored as ghost nodes. Each frontier entry carries the state it would produce, and therefore the hypothesis type the analyst would get, together with a confidence score drawn from the knowledge graph, a description of the result- ing claim, and a fixed goal explaining why the analyst might want it. A separate preview walks the frontier several steps ahead, following the highest-confidence child at each level, so the analyst can see where a line of refinement leads before committing to it; nothing along the preview is materialized until it is chosen. Selecting and toggling columns within a slot to watch the effect is view-state on the node, not a production: it changes what is displayed, not the claim’s identity, and only the explicit commit of a chosen set enters identity and creates a child. 5.3 The Knowledge Graph The knowledge graph (Figure 3, B ○) bridges the gap between the concepts the analyst reasons with and the columns the dataset stores. It has two layers. The concept layer (Figure 3, C ○ ) holds the domain concepts implied by the question and how they relate, so “success” sits near “financial performance” and “audience reception”. The data layer (Figure 3, D ○) holds the dataset’s columns and the causal or associative relationships among them. The two layers are joined by bridge edges that operationalize a concept as one or more columns, each tagged with whether the column is available, a proxy, or missing. Bridge edges are connections, not a third layer of their own. The genuine third structure is the intent graph itself, which attaches to concepts and columns as the analyst grounds slots over the course of the session. Splitting concepts from data lets the system reason about the question before it reasons about the dataset. It first situates the question in the concept layer, then follows bridge edges to find Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY the columns that operationalize each concept. When a concept operationalizes only through a proxy or has no column at all, the availability tag surfaces the mismatch instead of silently dropping the concept. The graph is built before exploration begins, in three LLM passes from the question and the schema (Figure 3, 2 ○). The first pass generates the concept layer, the domain concepts the question im- plies and the relationships among them. The second pass grounds each concept to columns, routing through a canonical data con- cept so the match is made against a domain standard before it is made against a particular column name. The third pass adds the causal and associative edges among columns that constitute the data layer, together with the bridge edges that operationalize each concept, tagged with whether the column is available, a proxy, or missing. The two layers are cached on different keys, because they depend on different things. The data layer describes relationships that hold among the dataset’s columns whatever is being asked of them, so it is keyed on the dataset alone and is reused across every question posed against it. The concept layer and the bridge edges depend on the question as well, so they are keyed on the question and the dataset together; returning to a question reuses them, and posing a new question over a dataset already seen rebuilds only this question-specific part on top of the data layer already in hand. Manual edits to the graph are versioned and can be rolled back, and are replayed when the graph is rebuilt, so the analyst’s corrections survive. The concepts and bridges the graph produces are the seed for the hierarchy the analyst then refines slot by slot. 5.4 How the Two Graphs Work Together The grammar says what claims are possible; the two graphs make a claim answerable, and they divide the labor between them. The knowledge graph carries meaning: what the concepts in the ques- tion are, and which columns could operationalize them. The intent graph carries exploration: the claims the analyst has formed and the moves between them. Neither is useful alone. A claim in the intent graph is only executable once its slots are grounded, and grounding is exactly a walk through the knowledge graph from a concept to the columns beneath it, drawn as the binding edge of Figure 3. The two meet at every move. When the analyst refines a claim, the intent graph asks what could fill a slot, and the knowledge graph answers by following bridge edges from the slot’s concept to the columns that operationalize it, surfacing those as candidates. When a slot is still open beside one that is already grounded, the knowledge graph’s causal edges seed it, so asking for a driver of revenue starts from revenue’s actual factors rather than from every column in the dataset. And when the analyst grounds a slot, the claim advances in the intent graph and its offers are recomputed, which may send the next question back to the knowledge graph. Grounding is the loop that binds the two: the intent graph poses the questions, and the knowledge graph answers them in data. Four components run this loop. A parser (Figure 3, 1 ○) reads the question and proposes one or more claims, each with hints for the slots the question mentions. A knowledge-graph builder (Figure 3, 2 ○) constructs the concept and data layers and the bridges between them. A propagator maintains the intent graph: it applies the ana- lyst’s moves, consults the knowledge graph to discover and rank the candidates that fill a slot, and records where paths converge. A can- vas (Figure 1) renders both graphs and the dashboards, and routes the analyst’s moves back to the propagator. The two components that need world knowledge, the parser and the construction of the knowledge graph, sit at the edges of the pipeline; everything be- tween them, the enumeration of claims and the checking of what is valid, follows grammar rules and runs deterministically. This keeps the parts of the system the analyst navigates predictable and au- ditable (DC4), and confines generation to the two points where the system genuinely needs world knowledge. Two stages of the loop rely on generated knowledge and warrant a closer look: turning the question into claims, and filling a slot from the hierarchy. Parsing. Parsing (Figure 3, 1 ○) is the one place the system reads the analyst’s free text. The parser sends the question and the dataset schema to an LLM and receives one or more interpretations, each a state with hints for the slots the question mentions. A question that admits several readings produces several interpretations, which become parallel framings in the intent graph rather than a single classification the analyst has to accept. What the parser returns is a partial state: some slots hinted and the rest left open. Turning those hints into slot bindings is deterministic and needs no further LLM call. For each slot the system decides, from the hint alone, whether the question bound it to a single concept, named an open concept with several readings, or said nothing about it. When the type multiset the parser produces has no image under푓, the reading is lifted into a well-formed composite, so that every entry point is a valid state or composite: a categorical mention alongside a relationship, for instance, becomes a moderation. Discovery and the dynamic hierarchy. Discovery fills a slot by walking the concept hierarchy to the columns beneath a concept, following bridge and part-of edges until it reaches data, which it surfaces as checkbox candidates rather than as new nodes, so a deep operationalization does not spawn a subtree. The hierarchy is generated lazily and conditioned on context rather than precom- puted once. A concept’s children are produced when the analyst first descends into it, and an open slot beside a grounded one is seeded from the grounded variable’s causal neighborhood in the knowledge graph, so asking for a driver of revenue starts from revenue’s actual factors, of every type. Because a categorical factor keeps its type, descending into one reshapes the claim from a rela- tionship into a comparison rather than forcing it into a measure. Two obligations come with generating the hierarchy on the fly. First, deduplication: a generated concept that already exists must resolve to the existing node, or content-addressing silently breaks. A concept carrying a knowledge-graph identifier is resolved by that identifier; a free concept falls to a normalized-label match and, if still ambiguous, an LLM check for semantic equivalence. Second, bounded generation: every generation call is capped in depth and breadth, so the termination guarantees the rest of the system relies on hold against a finite hierarchy. When a concept bottoms out at the cap without reaching data, the system grounds to the nearest columns rather than dead-ending. When a column is semantically apt but the wrong type for a slot, the system asks the LLM for a Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. transformation, a binning or a ratio, and materializes the result as a derived column. 5.5 Composition Composition reaches beyond a single filled-in claim, building an anal- ysis from several claims when one is not enough. Moderation facets a relationship by a category, asking whether the budget–revenue relationship holds across genres; mediation places a variable on the path between two others, asking whether budget drives revenue directly or through marketing spend; and comparison sets two full analyses side by side, comparing not two columns but two lines of reasoning. Composition is why the base claims can stay small: rather than growing a claim to three or more slots, the analyst composes bounded pieces. The division of labour is sharp because the arity bound of subsection 5.1 makes it so. A base state carries variables whose roles their types already settle; a composite carries a designation that no multiset can express, naming the mediator of a chain, the variable a pattern is conditioned on, or the axis two analyses are aligned along. A composition is a recursive extension of the state. WritingSpec for either a base state or a composite, Spec ::= State | Condition(Spec,푧) | Chain(Spec, Spec,푚) | Compare(Spec, . . .). Table 2 gives each form its well-formedness condition and the layout it compiles to. In the grammar, moderation, mediation, and comparison areCondition,Chain, andComparerespectively, which lifts them out of the flat templates of earlier drafts: a chain is liter- ally two relationships that share a column, not a bespoke mediation template. Well-formedness here is relational, a property of how the sub-specs fit together that a single state cannot express. ACompare requires its legs to share a hypothesis type and to be distinct; a Chainrequires both legs to be relationships that actually share the mediator; aCondition’s conditioning variable must be categorical, and may be left open to be bound afterward. Each composite com- piles to a qualitative layout rather than a single template: faceted small multiples for a condition, linked panels for a chain, overlaid or side-by-side panels for a comparison. Creation productions bridge from a base state to a composite, and because푓stops at arity two they are offered wherever a third variable is added at all: from a relationship, adding a category offers a moderation and adding a mediating measure offers a chain; from a comparison, adding a second category offers a moderation; from a trend, adding a second measure offers a comparison of trends. There is no competing route, since the multiset the added slot would produce has no image under 푓and is never surfaced as a state. Inverse productions unwind a composite back toward the base. 5.6 Implementation Notes The canvas is a Next.js and React application. It lays out the intent graph with ReactFlow and the concept trees with D3, and holds the analyst’s selections, folds, and open dashboards, including the fluid, uncommitted column selections of Section 5.2, in a client-side store. A concept’s variable leaves are grounded through a checklist that binds the checked set in one action, and a node-level group-by picker facets that node’s dashboards over categorical columns at render time. Each node carries a natural-language description ren- dered from its state and specialized by how much of it is grounded, with the slots rendered as chips the analyst can click to select the corresponding data. Dashboards are pre-authored Mosaic [32] template specifications, compiled to SQL and run in the browser over DuckDB-WASM [65]. The feasible templates for a terminal node are filtered and ranked by how well its bindings cover each template’s roles and by the availability of the data, with the best marked as recommended, and a node can open several dashboards to branch into more than one design. The mapping from a grounded claim to its dashboards is itself a small graph rather than a single choice. 6 User Study Design We conducted a user study to evaluate how DAG supports open- ended exploratory data analysis through its two core components, the intent graph and the knowledge graph. Rather than measuring task completion against a ground truth, which open-ended EDA does not admit, we study how analysts interact with the two struc- tures while exploring an unfamiliar dataset to answer a question of their own. Our overarching concern is whether the system aug- ments analytical reasoning rather than automating or confusing it. We organize the study around four questions, which we label SQ1–SQ4. SQ1: Intent graph alignment and user agency. Does the sys- tem’s decomposition of a question reflect the direction the analyst is actually pursuing, and does moving through the nodes help them form their intent? Are the alternative analyses the system surfaces inspiring and useful, or noise? We are particularly interested in how analysts navigate between following the system’s suggested scaffolding and redirecting the system with their own reasoning, which speaks directly to DC1 and DC3. SQ2: Knowledge graph utility. Does the knowledge graph produc- tively inform and reframe the analyst’s thinking behind their ques- tion? This tests whether externalizing the LLM’s domain knowledge into an inspectable structure (DC2, DC4) changes how analysts in- terpret both the question and the dataset, or whether it is treated as decoration. SQ3: Scaffold or menu, across domains. Are the intent and knowledge graphs used as scaffolds for the analyst’s own thinking, or as a menu of pre-set options to pick from? Because participants formulate their own question on both datasets, we can observe this stance twice per participant, once in an everyday domain and once in a specialized one, and ask whether analysts lean harder on the system’s suggestions when they have less domain knowledge of their own to bring. SQ4: Cognitive load and perceived performance. How much effort does it take to work with the system relative to what analysts feel they accomplish? A scaffold that is faithful but expensive to operate is not a usable scaffold. Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY Table 2: The three composites of the reference instantiation, which extend the base states of Table 1 and are the only route to an analysis over three or more variables. Composites are not states and so have no image under푓or푔. Each carries a well-formedness condition that is relational, a property of how its sub-specs fit together that a single state cannot express, and each compiles to a qualitative layout over templates rather than to one template. The layouts subsume the multi-variable templates directly: a Condition over a Comparison yields the two-wayCAT2crosstab, and a Compare over two Trends sharing a time axis yields the CH2 dual-series chart. Examples are drawn from the dataset of Section 4. compositewell-formed whencompiles toexample Condition(Spec,푧) 푧is categorical. It may be left open and bound afterwards. A facet over푧: small multiples or a colour encoding; theCAT2 crosstab where the conditioned spec is a Comparison. Does the budget–gross rela- tion hold across genres? Chain(Spec, Spec,푚) Both legs are Relations, both bind 푚, and their remaining ends differ. Two linked Relation panels, brushed on the shared 푚. Budget→vote count→ worldwide gross. Compare(Spec, . . .) At least two legs, sharing a hypoth- esis type, pairwise distinct. Overlay on the shared axis for Re- lations and for Trends, the latter givingCH2; a slope chart for Com- parisons; side-by-side otherwise. The box-office reading against the critical reading. 6.1 Participants We recruit 10–12 participants in two phases. First, we distribute a short screening survey (approximately 5–10 minutes) through university mailing lists, research lab channels, and professional networks. The survey asks about the respondent’s role, domain, and years of experience, how often they build dashboards, how and how much they currently use LLMs in their data work along with the biggest challenge they face in doing so, what other tools they use, and how they decide where to start a new analysis; an optional second section collects age group, gender, and education. Beyond establishing eligibility, these responses give us a baseline account of each participant’s current practice against which to read their behavior with DAG. We target data analysts, data scientists, business intelligence pro- fessionals, and similar practitioners with considerable experience creating dashboards or conducting exploratory data analysis, in either an academic or a professional context. Participants must be 18 or older, and we recruit across a variety of domains so that the questions participants formulate in the tasks are not drawn from a single analytical culture. Eligible respondents are invited to a 90-minute session and compensated with a $45 gift card. 6.2 Setup All sessions are conducted remotely over video conferencing, with the participant driving DAG in their own browser through screen sharing. Before each session we confirm that the recording software and interaction logging are functioning, that the system and both task datasets are loaded and ready to share, and that the tutorial video and warm-up materials are prepared. We also prepare one reference sheet per dataset, each containing a short summary of the dataset followed by a list of its attributes with a brief description and unit of measurement for each, and a slide of reminders for the participant to keep visible during the tasks. With the participant’s consent we collect three kinds of data. First, audio and screen recordings of the full session, which cap- ture the think-aloud narration alongside what the participant is doing in the interface. Second, post-session questionnaire and inter- view responses. Third, system interaction logs captured throughout both tasks, which record path and branch creation in the intent graph, brushing on charts, highlighting and dragging within the knowledge graph, and dashboard bookmarking. The logs let us reconstruct each participant’s trajectory through the intent graph after the fact and align it with the moments in the recording where they explained what they were doing, so that a claim about how the scaffolding was used can be grounded in the actual sequence of moves rather than in recollection alone. Recordings and logs are used for research purposes only and are not shared outside the research team. 6.3 Procedure Each session lasts approximately 90 minutes. We open by describing the session structure, asking the participant to think aloud through- out, and obtaining consent to record after stating exactly what the recordings and interaction logs capture. A short pre-recorded video walkthrough of the interface follows, which keeps the in- troduction identical across participants. Participants then spend five minutes warming up on the movies dataset with a question we supply, “what makes a movie successful”. The warm-up serves two purposes: it separates the cost of learning the interface from the cost of reasoning with it, so that the first task does not conflate the two, and it demonstrates what a guiding question looks like at the level of abstraction DAG is designed for, one that names a concept the dataset does not directly contain, which participants need before writing their own. Participants then complete two 25-minute tasks, separated by a two-minute break, one on the movies dataset and one on NHANES, the National Health and Nutrition Examination Survey. At the start of each we hand the participant a reference sheet summarizing the Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. dataset and describing each attribute with its unit of measurement, and ask them to formulate their own high-level question and state it aloud before the timer starts, along with what they are looking for in it. This gives us a record of their intent that is independent of anything the system later shows them, and against which the system’s decomposition can be compared. The task is to explore the data to answer that question, not to produce a dashboard: dash- boards are what the system offers at the analyses the participant reaches, and whether they open, compare, or bookmark any is it- self an observation rather than a requirement. Participants may refine their question as they go, which is deliberate, since an intent graph that never prompts a revision would be scaffolding a fixed target rather than a reasoning process, and refinement is itself an observable outcome. The order is fixed rather than counterbalanced, so that the movies task follows directly from the warm-up on the same data and the specialized domain comes second. We give a two-minute warning in each task and afterwards ask whether there is anything the participant would like to note about what they were trying to do. The experimenter is present throughout but does not guide the analysis; when a participant is stuck, we ask them to narrate their thinking and keep interacting with the system rather than intervene. Immediately after the second task, participants complete a five- minute questionnaire while the experience is still fresh. Its first half adapts the NASA-TLX [30] dimensions to the analytical setting, asking how mentally demanding and time-pressured the tasks felt, how much effort went into working out how to operate the system, how successfully participants feel they explored their question, and how frustrating the system’s unexpected responses were (SQ4). Its second half targets the two components: whether being redirected along the system’s suggestions was helpful or disruptive, whether the intent graph felt like a scaffold for the participant’s own thinking or a menu of pre-set options, how much the knowledge graph improved their understanding of the dataset, and, as free response, whether what they arrived at answers the question they started from (SQ1–SQ3). A ten-minute semi-structured interview closes the session. We ask participants to recall specific moments where the system’s de- composition of the question matched or diverged from what they were trying to explore (SQ1) and where its interpretation of a con- cept felt accurate or surprising (SQ2), which features were most useful and which most confusing, and what they would change about how the intent graph responds to their actions. Two paired questions ask for a moment where the system helped their reason- ing and a moment where it got in the way; we keep them symmetric so that participants are as licensed to report breakdowns as suc- cesses. 7 Discussion 7.1 Implications A grammar is what makes an LLM’s contribution checkable. The role the grammar plays here is not primarily to define a lan- guage but to bound one. Because every node the system can offer is a well-formed claim and every edge a single legal refinement, an offer that is wrong is wrong in a way the analyst can name: it binds the wrong column to a slot, or refines along a relation the question did not call for. This is a different footing from a system whose suggestions arrive as free-form text, where an unhelpful suggestion can only be re-prompted because there is no structure against which to say what was unhelpful about it. The general implication is that steering generation and auditing it are the same problem: a representation expressive enough to constrain what a model may produce is, by that fact, expressive enough for a person to check what it did produce. Revisability is the right response to unverifiable knowledge. DAG depends on a language model for exactly the knowledge that cannot be checked against the data. That two rating systems aggregate different voter pools, or that a metric is a proxy rather than a measure, is domain knowledge with no oracle in the dataset to verify it against, and no amount of grounding in the schema will settle it. The resolution is not to verify but to make revisable, which is why the knowledge graph is an editable object rather than a fixed input: the analyst, not the system, is the authority on their own domain. Where a claim can be checked it should be; where it cannot, exposing it for correction is not a weaker substitute but the appropriate response to a different kind of claim. Ranking can serve navigation instead of standing in for judg- ment. Recommenders order candidates by how good the resulting analysis is estimated to be, which presumes a scoring function over analyses. No such function is available for competing readings of an ambiguous question, since the alternatives are interpretations rather than implementations and none of them is correct in a sense a metric could capture. DAG responds by changing what ordering is for: offers are ordered by how much each move would distin- guish the analyses downstream, a property of the space rather than a verdict on the analysis. This suggests a general move available to systems operating where quality is undefined, namely to rank for the information a choice yields rather than for the value of its outcome. 7.2 Limitations and Future Work DAG has not been evaluated with analysts, so the claims of this chapter rest on the design and its rationale and on the walkthrough of section 4, not on evidence about how analysts behave when using the system. The questions this leaves open are the ones the design cannot settle on its own: whether the intent graph’s progression aligns with the direction an analyst is actually pursuing, whether the knowledge graph meaningfully augments their understanding of the data domain and the intent graph branching, and whether the two graphs are used as scaffolds for the analyst’s own reasoning. Answering them calls for a study in which practitioners explore unfamiliar datasets under questions they formulate themselves, which we regard as the immediate next step for this work. Two further limitations follow from what the system is made of. The knowledge graph is generated by an LLM from prompts centered on the schema and the question, so its coverage of a do- main is bounded by what the model knows and biased toward domains well represented in its training data; a specialized field with idiosyncratic vocabulary is the case most likely to produce a plausible-looking graph that a practitioner would not recognize. Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY Editability is the mitigation, and it shifts effort onto the analyst rather than removing the problem. Separately, the guarantee that the space of valid analyses stays enumerable and navigable is a guarantee about the representation, not about the display: the num- ber of derivable claims grows quickly with the size of the schema and the richness of the knowledge graph, and while the interface offers one legal step at a time rather than the whole space at once, we have not established at what scale the graph stops being legible to a person. A grounded state is a specification, not a chart. Its slots, types, and bindings describe an analysis precisely enough to drive targets other than a dashboard, and we see two directions worth pursu- ing. A terminal relationship whose outcome and predictors are grounded could drive a notebook regression, with the bindings surfaced as editable variables; composable notebook cells in the style of Engraft [35] would let the terminals of a path merge into one environment whose shape mirrors the analyst’s traversal. A terminal could also bound a Boba [52] multiverse: the grounded slots fix the decisions in scope, and the candidates the analyst ruled out during disambiguation give a grammar-derived account of what the multiverse need not enumerate, a boundary that multiverse tools otherwise ask the analyst to draw by hand. Two further directions extend the reasoning rather than the output. The grammar of Suh et al. [78] raises the possibility of measuring and comparing hypothesis spaces by coverage and con- tainment, which it does not itself realize in a system; our intent graph is a natural place to compute such measures over the space an analyst has opened. And the discriminability of options, which we approximate here through relevance and availability, could be computed directly as the divergence in what each candidate unlocks downstream in the graph, turning the principle into the system’s ranking signal. A final direction concerns the signals the system learns from. To- day the analyst’s influence on ranking is entirely constructive: they build claims up, and the system orders what it offers by relevance in the knowledge graph and by data availability, never by what the analyst has turned away from. Treating the analyst’s moves themselves as feedback signals would let that ranking, ideally the discriminability signal of Section 3, adapt to the analyst and not to the graph alone. The clearest positive signal is an evidence-backed commitment: when the analyst weighs several candidate columns for a slot against the data and then commits to one (an interaction we sketch but set aside here), the choice reports what they find worth pursuing, not merely that the option was well-formed, and read as a signal it could lift kindred concepts and columns across the branches still open. The signal the current design lacks entirely is a negative one: letting the analyst deliberately remove the paths they judge ir- relevant and reading those removals as evidence of what not to pursue. Removal carries information precisely because exploration is otherwise non-destructive. Content-addressing keeps every sib- ling alive, and nothing needs pruning for the graph to stay correct (Section 5.2), so an explicit deletion is unambiguous: the analyst is not tidying up but stating disinterest. The system could then down-weight directions like the one removed, de-prioritizing the concepts, columns, and claim shapes it shared, so discarding a “suc- cess as awards” reading pushes award-related offers down across the branches that remain. Two constraints keep this honest, and are what make feedback a design problem in its own right rather than a single new move: a demoted direction must show that it was demoted because the analyst pruned a sibling, so the space never shrinks silently (Section 3), and a removal must be as reversible as any other move, so one the analyst reconsiders can be undone without the subtree having been lost. How far a removal should generalize, and how strongly it should propagate, are the open questions. Acknowledgments References [1] Sara Alspaugh, Nava Zokaei, Andrea Liu, Cindy Jin, and Marti A Hearst. 2018. Futzing and moseying: Interviews with professional data analysts on exploration practices. IEEE transactions on visualization and computer graphics 25, 1 (2018), 22–31. [2]Robert Amar, James Eagan, and John Stasko. 2005. Low-level components of analytic activity in information visualization. In IEEE Symposium on Information Visualization, 2005. INFOVIS 2005. IEEE, 111–117. [3] Tyler Angert, Miroslav Suzara, Jenny Han, Christopher Pondoc, and Hariharan Subramonyam. 2023. Spellburst: A Node-based Interface for Exploratory Cre- ative Coding with Natural Language Prompts. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (San Francisco, CA, USA) (UIST ’23). Association for Computing Machinery, New York, NY, USA, Article 100, 22 pages. doi:10.1145/3586183.3606719 [4] Gerile Aodeng, Guozheng Li, Yunshan Feng, Qiyang Chen, Yu Zhang, and Chi Harold Liu. 2025. InReAcTable: LLM-powered Interactive Visual Data Story Construction from Tabular Data. In Proc. of the 38th Annual ACM Symposium on User Interface Software and Technology. Article 139, 16 pages. doi:10.1145/ 3746059.3747719 [5] Eser Aygün, Anastasiya Belyaeva, Gheorghe Comanici, Marc Coram, Hao Cui, Jake Garrison, Anton Kast, Cory Y. McLean, Peter Norgaard, Zahra Shamsi, Subhashini Venugopalan, Lizzie Dorfman, Shibl Mourad, and Michael P. Brenner. 2025. An AI System to Help Scientists Write Expert-Level Empirical Software. arXiv preprint arXiv:2509.06503 (2025). doi:10.48550/arXiv.2509.06503 [6]Benjamin Bach, Euan Freeman, Alfie Abdul-Rahman, Cagatay Turkay, Saiful Khan, Yulei Fan, and Min Chen. 2023. Dashboard Design Patterns. IEEE Trans. on Visualization and Comp. Graphics 29, 1 (2023), 342–352. doi:10.1109/TVCG. 2022.3209448 [7] Leilani Battle and Jeffrey Heer. 2019. Characterizing Exploratory Visual Anal- ysis: A Literature Review and Evaluation of Analytic Provenance in Tableau. Computer Graphics Forum (2019). doi:10.1111/cgf.13678 [8] Leilani Battle and Alvitta Ottley. 2024. What Do We Mean When We Say “In- sight”? A Formal Synthesis of Existing Theory. IEEE Transactions on Visualization and Computer Graphics 30, 9 (2024), 6075–6088. doi:10.1109/TVCG.2023.3326698 [9]L. Bavoil, S.P. Callahan, P.J. Crossno, J. Freire, C.E. Scheidegger, C.T. Silva, and H.T. Vo. 2005. VisTrails: enabling interactive multiple-view visualizations. In VIS 05. IEEE Visualization, 2005. 135–142. doi:10.1109/VISUAL.2005.1532788 [10]Matthew Brehmer and Tamara Munzner. 2013. A Multi-Level Typology of Abstract Visualization Tasks. IEEE Transactions on Visualization and Computer Graphics 19, 12 (2013), 2376–2385. doi:10.1109/TVCG.2013.124 [11] Ángel Alexander Cabrera, Marco Tulio Ribeiro, Bongshin Lee, Robert Deline, Adam Perer, and Steven M. Drucker. 2023. What Did My AI Learn? How Data Scientists Make Sense of Model Behavior. ACM Trans. Comput.-Hum. Interact. 30, 1, Article 1 (March 2023), 27 pages. doi:10.1145/3542921 [12]Chen Chen, Jane Hoffswell, Shunan Guo, Ryan Rossi, Yeuk-Yin Chan, Fan Du, Eunyee Koh, and Zhicheng Liu. 2023. WhatsNext: Guidance-enriched Exploratory Data Analysis with Interactive, Low-Code Notebooks. In 2023 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). 209– 214. doi:10.1109/VL-HCC57772.2023.00033 [13]Yiru Chen and Eugene Wu. 2022.PI2: End-to-end Interactive Visualiza- tion Interface Generation from Queries. In Proceedings of the 2022 Interna- tional Conference on Management of Data (Philadelphia, PA, USA) (SIGMOD ’22). Association for Computing Machinery, New York, NY, USA, 1711–1725. doi:10.1145/3514221.3526166 [14]In Kwon Choi, Taylor Childers, Nirmal Kumar Raveendranath, Swati Mishra, Kyle Harris, and Khairi Reda. 2019. Concept-driven visual analytics: an ex- ploratory study of model-and hypothesis-based reasoning with visualizations. In Proceedings of the 2019 chi conference on human factors in computing systems. 1–14. [15]Yoonseo Choi, Eunhye Kim, Hyunwoo Kim, Donghyun Park, Honggu Lee, Jin Young Kim, and Juho Kim. 2025. BloomIntent: Automating Search Eval- uation with LLM-Generated Fine-Grained User Intents. In Proceedings of the Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. 38th Annual ACM Symposium on User Interface Software and Technology (UIST ’25). Association for Computing Machinery, New York, NY, USA, Article 177, 34 pages. doi:10.1145/3746059.3747677 [16] Dazhen Deng, Aoyu Wu, Huamin Qu, and Yingcai Wu. 2022. DashBot: Insight- driven dashboard generation based on deep reinforcement learning. IEEE Trans. on Visualization and Comp. Graphics (Sept. 2022). http://arxiv.org/abs/2208. 01232 arXiv:2208.01232 [cs]. [17]Vaishali Dhanoa, Andreas Hinterreiter, Vanessa Fediuk, Niklas Elmqvist, Eduard Gröller, and Marc Streit. 2024. D-Tour: Semi-Automatic Generation of Inter- active Guided Tours for Visualization Dashboard Onboarding. IEEE Trans. on Visualization and Comp. Graphics (2024). [18]Victor Dibia and Çağatay Demiralp. 2019. Data2Vis: Automatic Generation of Data Visualizations Using Sequence-to-Sequence Recurrent Neural Networks. IEEE Computer Graphics and Applications 39, 5 (Sept. 2019), 33–46. doi:10.1109/ MCG.2019.2924636 [19]Rui Ding, Shi Han, Yong Xu, Haidong Zhang, and Dongmei Zhang. 2019. Quick- Insights: Quick and Automatic Discovery of Insights from Multi-Dimensional Data. In Proc. ACM Manag. Data (Amsterdam, Netherlands) (SIGMOD ’19). As- sociation for Computing Machinery, New York, NY, USA, 317–332. doi:10.1145/ 3299869.3314037 [20]Zijian Ding, Michelle Brachman, Joel Chan, and Werner Geyer. 2025. "The Diagram is like Guardrails": Structuring GenAI-assisted Hypotheses Exploration with an Interactive Shared Representation. In Proceedings of the 2025 Conference on Creativity and Cognition (C&C ’25). Association for Computing Machinery, New York, NY, USA, 606–625. doi:10.1145/3698061.3726935 [21] Will Epperson, Kanit Wongsuphasawat, Allison Whilden, Fan Du, and Justin Talbot. 2023. A Declarative Specification for Authoring Metrics Dashboards. In IEEE Visualization in Data Science (VDS). 6–10. doi:10.1109/VDS60365.2023.00006 [22]Teppo Felin, Jan Koenderink, Joachim I Krueger, Denis Noble, and George FR Ellis. 2021. The data-hypothesis relationship. Genome Biology 22, 1 (2021), 57. [23]Stephen N Freund, Brooke Simon, Emery D Berger, and Eunice Jun. 2025. Flowco: Rethinking Data Analysis in the Age of LLMs. arXiv preprint arXiv:2504.14038 (2025). [24]Tong Gao, Mira Dontcheva, Eytan Adar, Zhicheng Liu, and Karrie G. Karahalios. 2015. DataTone: Managing Ambiguity in Natural Language Interfaces for Data Visualization. In Proceedings of the 28th Annual ACM Symposium on User Interface Software & Technology (Charlotte, NC, USA) (UIST ’15). Association for Computing Machinery, New York, NY, USA, 489–500. doi:10.1145/2807442. 2807478 [25]Sneha Gathani, Anamaria Crisan, Vidya Setlur, and Arjun Srinivasan. 2024. Groot: A System for Editing and Configuring Automated Data Insights. In 2024 IEEE Visualization and Visual Analytics (VIS). IEEE, 36–40. [26]Spence Green, Sida I Wang, Jason Chuang, Jeffrey Heer, Sebastian Schuster, and Christopher D Manning. 2014. Human effort and machine learnability in computer aided translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP). 1225–1236. [27]Madeleine Grunde-McLaughlin, Hussein Mozannar, Maya Murad, Jingya Chen, Saleema Amershi, and Adam Fourney. 2026. Overseeing Agents Without Con- stant Oversight: Challenges and Opportunities. arXiv preprint arXiv:2602.16844 (2026). [28] Ken Gu, Ruoxi Shang, Ruien Jiang, Keying Kuang, Richard-John Lin, Donghe Lyu, Yue Mao, Youran Pan, Teng Wu, Jiaqian Yu, Yikun Zhang, Tianmai M. Zhang, Lanyi Zhu, Mike A Merrill, Jeffrey Heer, and Tim Althoff. 2024. BLADE: Bench- marking Language Model Agents for Data-Driven Science. In Findings of the Association for Computational Linguistics: EMNLP 2024, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). Association for Computational Linguistics, Miami, Florida, USA, 13936–13971. doi:10.18653/v1/2024.findings-emnlp.815 [29]Yi Guo, Danqing Shi, Mingjuan Guo, Yanqiu Wu, Nan Cao, and Qing Chen. 2024. Talk2Data: A Natural Language Interface for Exploratory Visual Analysis via Question Decomposition. ACM Trans. Interact. Intell. Syst. 14, 2, Article 8 (April 2024), 24 pages. doi:10.1145/3643894 [30]Sandra G. Hart and Lowell E. Staveland. 1988. Development of NASA-TLX (Task Load Index): Results of Empirical and Theoretical Research. In Human Mental Workload, Peter A. Hancock and Najmedin Meshkati (Eds.). Advances in Psychology, Vol. 52. North-Holland, 139–183. doi:10.1016/S0166-4115(08)62386- 9 [31]Jeffrey Heer. 2019. Agency plus automation: Designing artificial intelligence into interactive systems. Proceedings of the National Academy of Sciences 116, 6 (2019), 1844–1850. [32] Jeffrey Heer and Dominik Moritz. 2024. Mosaic: An Architecture for Scalable & Interoperable Data Views. IEEE Transactions on Visualization and Computer Graphics 30, 1 (2024), 436–446. doi:10.1109/TVCG.2023.3327189 [33] Jane Hoffswell, Victor S. Bursztyn, Shunan Guo, and Eunyee Koh. 2025. A Case Study of Human-Authored versus Automatic Dashboard Summaries, In CHI Conference on Human Factors in Computing Systems (CHI LBW). arXiv preprint arXiv:2501.13309. doi:10.1145/3706599.3720155 [34]Md Naimul Hoque, Tasfia Mashiat, Bhavya Ghai, Cecilia D. Shelton, Fanny Chevalier, Kari Kraus, and Niklas Elmqvist. 2024. The HaLLMark Effect: Sup- porting Provenance and Transparent Use of Large Language Models in Writing with Interactive Visualization. In Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems (Honolulu, HI, USA) (CHI ’24). Associ- ation for Computing Machinery, New York, NY, USA, Article 1045, 15 pages. doi:10.1145/3613904.3641895 [35]Josh Horowitz and Jeffrey Heer. 2023. Engraft: An API for Live, Rich, and Composable Programming. In Proc. ACM User Interface Software & Technology (UIST). doi:10.1145/3586183.3606733 [36]Kevin Hu, Michiel A Bakker, Stephen Li, Tim Kraska, and César Hidalgo. 2019. Vizml: A machine learning approach to visualization recommendation. In Proc. of the 2019 CHI conference on human factors in comp. systems. 1–12. [37]Jessica Hullman and Andrew Gelman. 2021. Designing for interactive ex- ploratory data analysis requires theories of graphical inference. Harvard Data Science Review 3, 3 (2021), 10–1162. [38]Sean Kandel, Andreas Paepcke, Joseph Hellerstein, and Jeffrey Heer. 2011. Wran- gler: interactive visual specification of data transformation scripts. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (Vancouver, BC, Canada) (CHI ’11). Association for Computing Machinery, New York, NY, USA, 3363–3372. doi:10.1145/1978942.1979444 [39] Heidi Lam, Melanie Tory, and Tamara Munzner. 2018. Bridging from Goals to Tasks with Design Study Analysis Reports. IEEE Transactions on Visualization and Computer Graphics 24, 1 (2018), 435–445. doi:10.1109/TVCG.2017.2744319 [40]Doris Jung-Lin Lee, Vidya Setlur, Melanie Tory, Karrie Karahalios, and Aditya Parameswaran. 2021. Deconstructing categorization in visualization recommen- dation: A taxonomy and comparative study. IEEE Transactions on Visualization and Computer Graphics 28, 12 (2021), 4225–4239. [41]Doris Jung-Lin Lee, Dixin Tang, Kunal Agarwal, Thyne Boonmark, Caitlyn Chen, Jake Kang, Ujjaini Mukhopadhyay, Jerry Song, Micah Yong, Marti A. Hearst, and Aditya G. Parameswaran. 2021. Lux: Always-on Visualization Recommendations for Exploratory Dataframe Workflows. arXiv:2105.00121 [cs.DB] https://arxiv. org/abs/2105.00121 [42]Guozheng Li, Runfei Li, Yunshan Feng, Yu Zhang, Yuyu Luo, and Chi Harold Liu. 2024. CoInsight: Visual Storytelling for Hierarchical Tables With Connected Insights. IEEE Trans. on Visualization and Comp. Graphics (2024). doi:10.1109/ TVCG.2024.3388553 [43]Haotian Li, Nithin Chalapathi, Huamin Qu, Alvin Cheung, and Aditya G. Parameswaran. 2024. Inferring Visualization Intent from Conversation. In Pro- ceedings of the 33rd ACM International Conference on Information and Knowledge Management (Boise, ID, USA) (CIKM ’24). Association for Computing Machinery, New York, NY, USA, 1184–1194. doi:10.1145/3627673.3679589 [44]Haotian Li, Lu Ying, Haidong Zhang, Yingcai Wu, Huamin Qu, and Yun Wang. 2023. Notable: On-the-fly Assistant for Data Storytelling in Computational Notebooks. In Proc. of the 2023 CHI Conf. on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Machinery, New York, NY, USA, Article 173, 16 pages. doi:10.1145/3544548.3580965 [45]Xingjun Li, Yizhi Zhang, Justin Leung, Chengnian Sun, and Jian Zhao. 2023. EDAssistant: Supporting Exploratory Data Analysis in Computational Note- books with In Situ Code Search and Recommendation. ACM Trans. Interact. Intell. Syst. 13, 1, Article 1 (March 2023), 27 pages. doi:10.1145/3545995 [46]Halden Lin, Dominik Moritz, and Jeffrey Heer. 2020. Dziban: Balancing Agency & Automation in Visualization Design via Anchored Recommendations. In Proceedings of the 2020 CHI Conference on Human Factors in Computing Systems (CHI ’20). Association for Computing Machinery, Honolulu, HI, USA, 1–12. doi:10.1145/3313831.3376880 [47]Yanna Lin, Haotian Li, Aoyu Wu, Yong Wang, and Huamin Qu. 2024. DMiner: Dashboard Design Mining and Recommendation. IEEE Trans. on Visualization and Comp. Graphics 30, 7 (2024), 4108–4121. doi:10.1109/TVCG.2023.3251344 [48]Yanna Lin, Haotian Li, Leni Yang, Aoyu Wu, and Huamin Qu. 2024. InkSight: Leveraging Sketch Interaction for Documenting Chart Findings in Computa- tional Notebooks. IEEE Trans. on Visualization and Comp. Graphics (2024). doi:10.1109/TVCG.2023.3327170 [49]Tavor Lipman, Tova Milo, Amit Somech, Tomer Wolfson, and Oz Zafar. 2024. LINX: A Language Driven Generative System for Goal-Oriented Automated Data Exploration. arXiv:2406.05107 [cs.DB] https://arxiv.org/abs/2406.05107 [50]Mengsha Liu, Daoyuan Chen, Yaliang Li, Guian Fang, and Ying Shen. 2024. Chartthinker: A contextual chain-of-thought approach to optimized chart sum- marization. arXiv preprint arXiv:2403.11236 (2024). [51] Michael Xieyang Liu, Advait Sarkar, Carina Negreanu, Benjamin Zorn, Jack Williams, Neil Toronto, and Andrew D Gordon. 2023. “What it wants me to say”: Bridging the abstraction gap between end-user programmers and code- generating large language models. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems. 1–31. [52]Yang Liu, Alex Kale, Tim Althoff, and Jeffrey Heer. 2020. Boba: Authoring and visualizing multiverse analyses. IEEE Transactions on Visualization and Computer Graphics 27, 2 (2020), 1753–1763. Intent Graph: Navigating the Analytical Reasoning Space for Exploratory Data AnalysisConference acronym ’X, June 03–05, 2018, Woodstock, NY [53]Yuyu Luo, Xuedi Qin, Nan Tang, and Guoliang Li. 2018. Deepeye: Towards automatic data visualization. In IEEE 34th Int. Conf. on data engineering. IEEE, 101–112. [54] Pingchuan Ma, Rui Ding, Shuai Wang, Shi Han, and Dongmei Zhang. 2023. Demonstration of InsightPilot: An LLM-empowered automated data exploration system. arXiv preprint arXiv:2304.00477 (2023). [55] Bodhisattwa Prasad Majumder, Harshit Surana, Dhruv Agarwal, Sanchaita Hazra, Ashish Sabharwal, and Peter Clark. 2024. Data-driven Discovery with Large Generative Models. arXiv:2402.13610 [cs.CL] https://arxiv.org/abs/2402. 13610 [56]Bodhisattwa Prasad Majumder, Harshit Surana, Dhruv Agarwal, Bhavana Dalvi Mishra, Abhijeetsingh Meena, Aryan Prakhar, Tirth Vora, Tushar Khot, Ashish Sabharwal, and Peter Clark. 2024. DiscoveryBench: Towards Data-Driven Discovery with Large Language Models. arXiv:2407.01725 [cs.CL] https://arxiv. org/abs/2407.01725 [57]Yu Mei, Yuanxi Wang, Shiyi Wang, Qingyang Wan, Zhuojun Li, Chun Yu, Weinan Shi, and Yuanchun Shi. 2025. Interquest: A mixed-initiative framework for dynamic user interest modeling in conversational search. In Proceedings of the 38th Annual ACM Symposium on User Interface Software and Technology. 1–23. [58]Shubham Mohole and Sainyam Galhotra. 2025. VeriMinder: Mitigating Ana- lytical Vulnerabilities in NL2SQL. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), Pushkar Mishra, Smaranda Muresan, and Tao Yu (Eds.). Association for Compu- tational Linguistics, Vienna, Austria, 448–459. doi:10.18653/v1/2025.acl-demo.43 [59]Dominik Moritz, Chenglong Wang, Greg L Nelson, Halden Lin, Adam M Smith, Bill Howe, and Jeffrey Heer. 2018. Formalizing visualization design knowledge as constraints: Actionable and extensible models in draco. IEEE Trans. on Visualization and Comp. Graphics 25, 1 (2018), 438–448. [60]Arpit Narechania, Arjun Srinivasan, and John Stasko. 2020. NL4DV: A toolkit for generating analytic specifications for data visualization from natural language queries. IEEE Transactions on Visualization and Computer Graphics 27, 2 (2020), 369–379. [61]Aditeya Pandey, Arjun Srinivasan, and Vidya Setlur. 2023. MEDLEY: Intent- based Recommendations to Support Dashboard Composition. IEEE Transactions on Visualization and Computer Graphics 29, 1 (2023), 1135–1145. doi:10.1109/ TVCG.2022.3209421 [62] Samir Passi and Solon Barocas. 2019. Problem formulation and fairness. In Proceedings of the conference on fairness, accountability, and transparency. 39–48. [63]Joanna Purich, Anthony Wise, and Leilani Battle. 2025. An Adaptive Benchmark for Modeling User Exploration of Large Datasets. Proc. ACM Manag. Data 3, 1, Article 8 (Feb. 2025), 24 pages. doi:10.1145/3709658 [64]Zening Qu and Jessica Hullman. 2018. Keeping Multiple Views Consistent: Constraints, Validations, and Exceptions in Visualization Authoring. IEEE Trans. on Visualization and Comp. Graphics (2018). doi:10.1109/TVCG.2017.2744198 [65]Mark Raasveldt and Hannes Mühleisen. 2019. DuckDB: An Embeddable Analyt- ical Database. In Proceedings of the 2019 International Conference on Management of Data (Amsterdam, Netherlands) (SIGMOD ’19). Association for Computing Machinery, New York, NY, USA, 1981–1984. doi:10.1145/3299869.3320212 [66] Jen Rogers and Anamaria Crisan. 2023. Tracing and Visualizing Human-ML/AI Collaborative Processes through Artifacts of Data Work. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Ger- many) (CHI ’23). Association for Computing Machinery, New York, NY, USA, Article 837, 22 pages. doi:10.1145/3544548.3580819 [67] Dominik Sacha, Andreas Stoffel, Florian Stoffel, Bum Chul Kwon, Geoffrey Ellis, and Daniel A. Keim. 2014. Knowledge Generation Model for Visual Analytics. IEEE Transactions on Visualization and Computer Graphics 20, 12 (2014), 1604– 1613. doi:10.1109/TVCG.2014.2346481 [68]Subham Sah, Rishab Mitra, Arpit Narechania, Alex Endert, John Stasko, and Wenwen Dou. 2024. Generating analytic specifications for data visualization from natural language queries using large language models. arXiv preprint arXiv:2408.13391 (2024). [69]Irina Saparina and Mirella Lapata. 2024.AMBROSIA: A Benchmark for Parsing Ambiguous Questions into Database Queries. In Advances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (Eds.), Vol. 37. Curran Associates, Inc., 90600–90628.https://proceedings.neurips.c/ paper_files/paper/2024/file/a4c942a8405c910f0a833d28d2573c-Paper- Datasets_and_Benchmarks_Track.pdf [70] Alper Sarikaya, Michael Correll, Lyn Bartram, Melanie Tory, and Danyel Fisher. 2019. What Do We Talk About When We Talk About Dashboards? IEEE Trans. on Visualization and Comp. Graphics 25, 1 (2019), 682–692. doi:10.1109/TVCG. 2018.2864903 [71] Vidya Setlur, Melanie Tory, and Alex Djalali. 2019. Inferencing underspeci- fied natural language utterances in visual analysis. In Proceedings of the 24th international conference on intelligent user interfaces. 40–51. [72]Danqing Shi, Weiwei Cui, Danqing Huang, Haidong Zhang, and Nan Cao. 2023. Reverse-engineering information presentations: recovering hierarchical grouping from layouts of visual elements. Visual Intelligence (2023). doi:10. 1007/s44267-023-00010-1 [73]Danqing Shi, Xinyue Xu, Fuling Sun, Yang Shi, and Nan Cao. 2021. Calliope: Automatic Visual Data Story Generation from a Spreadsheet. IEEE Trans. on Visualization and Comp. Graphics 27, 2 (Feb. 2021), 453–463. doi:10.1109/tvcg. 2020.3030403 arXiv:2010.09975 [cs]. [74]Cláudio T. Silva, Erik Anderson, Emanuele Santos, and Juliana Freire. 2011.Using VisTrails and Provenance for Teaching Sci- entific Visualization.Computer Graphics Forum 30, 1 (2011), 75– 84.arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1111/j.1467- 8659.2010.01830.x doi:10.1111/j.1467-8659.2010.01830.x [75]Arjun Srinivasan, Steven M. Drucker, Alex Endert, and John Stasko. 2019. Aug- menting Visualizations with Interactive Data Facts to Facilitate Interpretation and Communication. IEEE Trans. on Vis. and Comp. Graphics 25, 1 (2019), 672–681. doi:10.1109/TVCG.2018.2865145 [76]Arjun Srinivasan, Joanna Purich, Michael Correll, Leilani Battle, Vidya Setlur, and Anamaria Crisan. 2024. From Dashboard Zoo to Census: A Case Study With Tableau Public. IEEE Trans. on Visualization and Comp. Graphics (2024). [77] Arjun Srinivasan and Vidya Setlur. 2023. BOLT: A Natural Language Interface for Dashboard Authoring. In EuroVis 2023 - Short Papers, Thomas Hoellt, Wolfgang Aigner, and Bei Wang (Eds.). The Eurographics Association. doi:10.2312/evs. 20231035 [78] Ashley Suh, Ab Mosca, Eugene Wu, and Remco Chang. 2022. A grammar of hypotheses for visualization, data, and analysis. arXiv preprint arXiv:2204.14267 (2022). [79]Roderick S Tabalba, Nurit Kirshenbaum, Jason Leigh, Abari Bhattacharya, Veron- ica Grosso, Barbara Di Eugenio, Andrew E Johnson, and Moira Zellner. 2023. An Investigation into an Always Listening Interface to Support Data Exploration. In Proceedings of the 28th International Conference on Intelligent User Interfaces (Sydney, NSW, Australia) (IUI ’23). Association for Computing Machinery, New York, NY, USA, 128–141. doi:10.1145/3581641.3584079 [80]Yuan Tian, Weiwei Cui, Dazhen Deng, Xinjing Yi, Yurun Yang, Haidong Zhang, and Yingcai Wu. 2024. Chartgpt: Leveraging llms to generate charts from abstract natural language. IEEE Transactions on Visualization and Computer Graphics 31, 3 (2024), 1731–1745. [81] Melanie Tory, Lyn Bartram, Brittany Fiore-Gartland, and Anamaria Crisan. 2023. Finding Their Data Voice: Practices and Challenges of Dashboard Users. IEEE Computer Graphics and Applications 43, 1 (Jan. 2023), 22–36. doi:10.1109/MCG. 2021.3136545 Conference Name: IEEE Computer Graphics and Applications. [82] Trifacta. 2017. Trifacta Wrangler. https://w.trifacta.com/products/wrangler/. Data preparation software. [83] Immanuel Trummer. 2023. Demonstrating NaturalMiner: Searching Large Data Sets for Abstract Patterns Described in Natural Language. In Companion of the 2023 International Conference on Management of Data (Seattle, WA, USA) (SIGMOD ’23). Association for Computing Machinery, New York, NY, USA, 139–142. doi:10.1145/3555041.3589694 [84] Yuki Ueno, Bretho Danzy I, Zhuojun Jiang, and Chris Bryan. 2026. VisCanvas: A Node-based Interface for Exploratory Visualization Authoring with LLMs. arXiv preprint arXiv:2607.21886 (2026). [85] Priyan Vaithilingam, Ian Arawjo, and Elena L Glassman. 2024. Imagining a future of designing with ai: Dynamic grounding, constructive negotiation, and sustainable motivation. In Proceedings of the 2024 ACM Designing Interactive Systems Conference. 289–300. [86]Priyan Vaithilingam, Elena L. Glassman, Jeevana Priya Inala, and Chenglong Wang. 2024. DynaVis: Dynamically Synthesized UI Widgets for Visualization Editing. In Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems (Honolulu, HI, USA) (CHI ’24). Association for Computing Machinery, New York, NY, USA, Article 985, 17 pages. doi:10.1145/3613904.3642639 [87]Priyan Vaithilingam, Munyeong Kim, Frida-Cecilia Acosta-Parenteau, Daniel Lee, Amine Mhedhbi, Elena L. Glassman, and Ian Arawjo. 2025. Semantic Commit: Helping Users Update Intent Specifications for AI Memory at Scale. 18 pages. arXiv:2504.09283 [cs.HC] https://arxiv.org/abs/2504.09283 [88] Manasi Vartak, Samuel Madden, Aditya Parameswaran, and Neoklis Polyzotis. 2014. SEEDB: automatically generating query visualizations. (2014). [89]Manasi Vartak, Sajjadur Rahman, Samuel Madden, Aditya Parameswaran, and Neoklis Polyzotis. 2015. SeeDB: Efficient Data-Driven Visualization Recom- mendations to Support Visual Analytics. Proceedings of the VLDB Endowment International Conference on Very Large Data Bases 8, 13 (Sept. 2015), 2182–2193. https://w.ncbi.nlm.nih.gov/pmc/articles/PMC4714568/ [90] Chenglong Wang, Bongshin Lee, Steven M. Drucker, Dan Marshall, and Jianfeng Gao. 2025. Data Formulator 2: Iterative Creation of Data Visualizations, with AI Transforming Data Along the Way. In Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems (CHI ’25). Association for Computing Machinery, New York, NY, USA, Article 677, 17 pages. doi:10.1145/3706598. 3713296 [91]Chenglong Wang, John Thompson, and Bongshin Lee. 2024. Data Formulator: AI-Powered Concept-Driven Visualization Authoring. IEEE Transactions on Visualization and Computer Graphics 30, 1 (Jan. 2024), 1128–1138. doi:10.1109/ TVCG.2023.3326585 Conference acronym ’X, June 03–05, 2018, Woodstock, NYTrovato et al. [92]Huichen Will Wang, Larry Birnbaum, and Vidya Setlur. 2025.Jupybara: Operationalizing a Design Space for Actionable Data Analysis and Story- telling with LLMs. arXiv preprint arXiv:2501.16661, Article 1005, 24 pages. doi:10.1145/3706598.3713913 [93]Xinru Wang and Ming Yin. 2021. Are explanations helpful? a comparative study of the effects of explanations in ai-assisted decision-making. In Proceedings of the 26th International Conference on Intelligent User Interfaces. 318–328. [94]Yun Wang, Zhida Sun, Haidong Zhang, Weiwei Cui, Ke Xu, Xiaojuan Ma, and Dongmei Zhang. 2020. DataShot: Automatic Generation of Fact Sheets from Tabular Data. IEEE Trans. on Visualization and Comp. Graphics 26, 1 (Jan. 2020), 895–905. doi:10.1109/TVCG.2019.2934398 [95]Luoxuan Weng, Xingbo Wang, Junyu Lu, Yingchaojie Feng, Yihan Liu, Haozhe Feng, Danqing Huang, and Wei Chen. 2025. InsightLens: Augmenting LLM- Powered Data Analysis With Interactive Insight Management and Navigation . IEEE Transactions on Visualization and Computer Graphics (2025). doi:10.1109/ TVCG.2025.3567131 [96]Kanit Wongsuphasawat, Yang Liu, and Jeffrey Heer. 2019. Goals, process, and challenges of exploratory data analysis: An interview study. arXiv preprint arXiv:1911.00568 (2019). [97]Kanit Wongsuphasawat, Dominik Moritz, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. 2016. Voyager: Exploratory Analysis via Faceted Browsing of Visualization Recommendations. IEEE Transactions on Visualization and Computer Graphics 22, 1 (Jan. 2016), 649–658. doi:10.1109/TVCG.2015. 2467191 Conference Name: IEEE Transactions on Visualization and Computer Graphics. [98] Kanit Wongsuphasawat, Zening Qu, Dominik Moritz, Riley Chang, Felix Ouk, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. 2017. Voyager 2: Augmenting Visual Analysis with Partial View Specifications. In ACM Hu- man Factors in Computing Systems (CHI). http://idl.cs.washington.edu/papers/ voyager2 [99]Dylan Wootton, Amy Rae Fox, Evan Peck, and Arvind Satyanarayan. 2024. Charting EDA: Characterizing Interactive Visualization Use in Computational Notebooks with a Mixed-Methods Formalism. IEEE Transactions on Visualization and Computer Graphics 31, 1 (2024), 1191–1201. arXiv:2409.10450 [cs.HC] https: //arxiv.org/abs/2409.10450 [100]Aoyu Wu, Yun Wang, Mengyu Zhou, Xinyi He, Haidong Zhang, Huamin Qu, and Dongmei Zhang. 2022. MultiVision: Designing Analytical Dashboards with Deep Learning Based Recommendation. IEEE Trans. on Vis. and Comp. Graphics 28, 1 (2022), 162–172. doi:10.1109/TVCG.2021.3114826 [101]J.D. Zamfirescu-Pereira, Richmond Y. Wong, Bjoern Hartmann, and Qian Yang. 2023. Why Johnny Can’t Prompt: How Non-AI Experts Try (and Fail) to Design LLM Prompts. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Machinery, New York, NY, USA, Article 437, 21 pages. doi:10.1145/3544548. 3581388 [102]Zehua Zeng, Leilani Battle, et al.2024. A Systematic Review of Visualization Recommendation Systems: Goals, Strategies, Interfaces, and Evaluations. Foun- dations and Trends® in Databases 14, 1 (2024), 1–71. [103]Zehua Zeng, Phoebe Moh, Fan Du, Jane Hoffswell, Tak Yeon Lee, Sana Malik, Eunyee Koh, and Leilani Battle. 2022. An Evaluation-Focused Framework for Visualization Recommendation Algorithms. IEEE Transactions on Visualization and Computer Graphics 28, 1 (Jan. 2022), 346–356. doi:10.1109/TVCG.2021. 3114814 [104]Shuning Zhang, Hui Wang, and Xin Yi. 2025. Exploring collaboration patterns and strategies in human-ai co-creation through the lens of agency: A scoping review of the top-tier hci literature. Proceedings of the ACM on Human-Computer Interaction 9, 7 (2025), 1–43. [105]Yuheng Zhao, Xueli Shu, Liwen Fan, Lin Gao, Yu Zhang, and Siming Chen. 2025. Proactiveva: Proactive visual analytics with llm-based ui agent. IEEE Transactions on Visualization and Computer Graphics (2025). [106] Yuheng Zhao, Junjie Wang, Linbing Xiang, Xiaowen Zhang, Zifei Guo, Cagatay Turkay, Yu Zhang, and Siming Chen. 2024. Lightva: Lightweight visual analytics with llm agent-based task planning and execution. IEEE Trans. on Visualization and Comp. Graphics (2024), 1–13. doi:10.1109/TVCG.2024.3496112 [107] Yuheng Zhao, Yixing Zhang, Yu Zhang, Xinyi Zhao, Junjie Wang, Zekai Shao, Cagatay Turkay, and Siming Chen. 2024. Leva: Using large language models to enhance visual analytics. IEEE Trans. on Visualization and Comp. Graphics 31, 3 (2024), 1830–1847. Received 20 February 2007; revised 12 March 2009; accepted 5 June 2009