Paper deep dive

AdaLens: Interactive Storyline for Monitoring and Steering Long-Running Agentic Data Analysis

Yangtian Liu, Yan Miao, Shuhan Liu, Yunfan Zhou, Dae Hyun Kim, Di Weng, Yingcai Wu

Year: 2026Venue: arXiv preprintArea: cs.HCType: PreprintEmbeddings: 102

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%

Last extracted: 8/19/2026, 5:31:33 AM

Summary

The paper introduces AdaLens, an interactive system designed to monitor and steer long-running agentic data analysis workflows driven by Large Language Models (LLMs). It addresses the limitations of conventional interfaces by providing observability through a storyline-based representation that unifies analytical plans, execution progress, intermediate findings, and data-column involvement. It also provides steerability via interactions grounded in these elements, allowing analysts to redirect the agent's course. The system was evaluated through case studies and a user study, demonstrating improved usability and support for interactive oversight.

Entities (9)

AdaLens · system · 100%Agentic Data Analysis · concept · 95%Large Language Models · technology · 95%Yonsei University · organization · 95%Zhejiang University · organization · 95%IEEE TVCG · publication · 90%Observability · requirement · 90%Steerability · requirement · 90%Storyline Visualization · technique · 90%

Relation Signals (7)

Yangtian Liu → affiliatedwith → Zhejiang University

confidence 95% · Y. Liu... are with the State Key Lab of CAD&CG, Zhejiang University

Dae Hyun Kim → affiliatedwith → Yonsei University

confidence 95% · D. H. Kim is with the Department of Computer Science and Engineering, Yonsei University

AdaLens → supports → Agentic Data Analysis

confidence 95% · AdaLens is an interactive system for monitoring and steering long-running agentic data analysis.

Large Language Models → enables → Agentic Data Analysis

confidence 90% · Large language models are pushing data science toward increasingly autonomous and agentic workflows

AdaLens → provides → Observability

confidence 90% · AdaLens combines a storyline-based representation... for observability for understanding an agent's evolving reasoning

AdaLens → provides → Steerability

confidence 90% · and steerability for redirecting low-value directions or deepening promising ones during execution.

AdaLens → uses → Storyline Visualization

confidence 90% · AdaLens combines a storyline-based representation that unifies analytical plans, execution progress, intermediate findings, and data-column involvement

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Large language models are pushing data science toward increasingly autonomous and agentic workflows, with recent systems already supporting multi-step and long-running analyses. As these workflows become more autonomous, conventional interfaces no longer provide adequate support for two critical requirements: observability for understanding an agent's evolving reasoning and evidence, and steerability for redirecting low-value directions or deepening promising ones during execution. Existing interactive approaches improve process visibility and open intervention points, but they remain largely designed for discrete, turn-by-turn exchanges rather than the parallel branches and evolving decision structures of long-running agentic analysis. We study this need as interactive oversight in long-running agentic data analysis and present AdaLens, an interactive system for monitoring and steering ongoing runs. AdaLens combines a storyline-based representation that unifies analytical plans, execution progress, intermediate findings, and data-column involvement with steering interactions grounded in these analytical elements for directional guidance and execution control. We evaluate AdaLens through two case studies and a user study, examining how it supports analysts in monitoring and steering long-running agentic data analysis.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

99,034 characters extracted from source content.

Expand or collapse full text

AdaLens: Interactive Storyline for Monitoring and Steering Long-Running Agentic Data Analysis Yangtian Liu Yan Miao Shuhan Liu Yunfan Zhou Dae Hyun Kim Di Weng Yingcai Wu Thanks: Y. Liu, Y. Miao, S. Liu, Y. Zhou, and Y. Wu are with the State Key Lab of CAD&CG, Zhejiang University, Hangzhou, Zhejiang, China. E-mail: yt-liu, ymiao, shliu, yf.zhou, ycwu@zju.edu.cn. Thanks: D. H. Kim is with the Department of Computer Science and Engineering, Yonsei University, Seoul, Republic of Korea. E-mail: dhkim16@yonsei.ac.kr. Thanks: D. Weng is with the School of Software Technology, Zhejiang University, Ningbo, Zhejiang, China. E-mail: dweng@zju.edu.cn. D. Weng is the corresponding author. Thanks: This work has been submitted to the IEEE TVCG for possible publication. Abstract Large language models are pushing data science toward increasingly autonomous and agentic workflows, with recent systems already supporting multi-step and long-running analyses. As these workflows become more autonomous, conventional interfaces no longer provide adequate support for two critical requirements: observability for understanding an agent’s evolving reasoning and evidence, and steerability for redirecting low-value directions or deepening promising ones during execution. Existing interactive approaches improve process visibility and open intervention points, but they remain largely designed for discrete, turn-by-turn exchanges rather than the parallel branches and evolving decision structures of long-running agentic analysis. We study this need as interactive oversight in long-running agentic data analysis and present AdaLens, an interactive system for monitoring and steering ongoing runs. AdaLens combines a storyline-based representation that unifies analytical plans, execution progress, intermediate findings, and data-column involvement with steering interactions grounded in these analytical elements for directional guidance and execution control. We evaluate AdaLens through two case studies and a user study, examining how it supports analysts in monitoring and steering long-running agentic data analysis. Index Terms: storyline visualization, human-AI interaction, agentic data analysis Fig. 1: AdaLens interface for monitoring and steering long-running agentic data analysis through three coordinated views. (A) The chat view records user and system messages, dispatched plans (A1), and stage/final reports (A2). (B) The storyline view serves as the primary workspace, combining steering tools (B1), insight-type legends (B2), report anchors (B3), plan/summary cards (B4, B7), data-column traces (B5), atomic insight glyphs (B6), on-demand detail popovers (B8), and the alternation between finding regions (B9) and converge regions (B10) to reveal stepwise progression and data-grounded analytical lineage over time. (C) The inspector view summarizes coverage across columns and insight types (C1) and reveals the selected task or finding with linked evidence such as plots, code, and outputs (C2). I Introduction Large language models (LLMs) are driving data science toward increasingly autonomous workflows [36, 82], freeing analysts from tedious manual execution to focus on high-level sensemaking. Recent agentic systems [79, 40, 84] push this trend further by enabling LLM-based agents to conduct end-to-end data analysis with minimal human intervention. Given an analytical objective and datasets, the agent formulates analytical plans, executes them to gather evidence, and iteratively refines or expands its investigation based on intermediate insights. Consequently, agentic data analysis becomes a multi-step, branching, and long-running process that unfolds through successive cycles of planning, execution, and synthesis over an extended timeframe. Across these cycles, the agent pursues multiple analytical directions and uses accumulated findings and evidence to determine what to analyze next. As the agent operates with increasing autonomy, the analyst’s role shifts from a step-by-step driver to a high-level overseer, making two complementary interface requirements especially important: observability and steerability [75, 28]. Observability concerns whether analysts can maintain a coherent understanding of the agent’s evolving analytical process—which directions have been explored, what insights have emerged, what evidence supports the results, and how the run has unfolded as a whole. Existing approaches, designed around turn-by-turn interaction, enhance visibility by exposing fine-grained details such as transformation provenance [16] and intermediate data states [75], or by surfacing high-level key insights [73]. However, they restrict analysts to inspecting outcomes sequentially, failing to capture the branching directions and interdependent analytical threads that characterize agentic analysis. Steerability concerns whether analysts can effectively redirect the agent’s course when they spot opportunities for improvement—pruning an unproductive branch, prioritizing a promising thread, or deepening a specific finding. Existing steering mechanisms typically operate at the level of individual analytical units: editing task decompositions or plan steps before execution [28, 82], manipulating nodes in a dataflow graph [17], or surgically correcting individual operations mid-execution [75]. While effective for controlling specific steps, these mechanisms do not support redirecting the overall course of an evolving investigation where the agent has accumulated context across many interdependent steps. When broader redirection is needed, analysts must fall back on natural language feedback [39], which still forces them to mentally reconstruct this accumulated context to articulate directional intent. Therefore, our goal is to support analysts in monitoring and steering multi-step, branching, and long-running agentic data analysis through structured representations of the agent’s evolving analytical process and interaction mechanisms grounded in these representations. Grounded in the characteristics of long-running agentic data analysis and informed by the recurring practice challenges identified through our six-month collaboration with three experts, as detailed in section I-B, we formulate two key design challenges: DC1 (Observability): How to build legible representations of evolving analytical processes? Long-running agentic data analysis produces a growing, heterogeneous collection of artifacts distributed across many interdependent steps, making the raw process difficult to follow. Legibility requires addressing two intertwined difficulties. First, analysts need to inspect the process at multiple levels of granularity, from tracking how analytical directions branch to examining specific findings and their supporting evidence. Because the analytical structure emerges dynamically as the agent iterates, the representation must accommodate new elements without disrupting the analyst’s orientation. Second, the representation must preserve analytical lineage: how findings and their data grounding remain connected as the process evolves. Without this traceability, analysts may struggle to understand how the analysis has evolved and how its findings remain grounded in the data. DC2 (Steerability): How to enable precise and timely steering of ongoing analysis? Given a legible representation, the second challenge is enabling analysts to act on it effectively. Steering is difficult because interventions span multiple interdependent levels: analysts may need to redirect the agent’s high-level analytical direction while also managing the lifecycle of individual plan threads. These levels are coupled, as a directional shift may render active threads obsolete, and a newly created plan must be coordinated with the agent’s accumulated context. Beyond choosing what to steer, analysts face the problem of when and how to intervene: the agent’s state evolves continuously, making intervention opportunities transient, while free-form natural language lacks the precision to express intent without burdening analysts with context reconstruction. Effective steering therefore requires interaction mechanisms grounded in the elements of the representation itself, letting analysts express intent directly on the artifacts they are inspecting. To address these challenges, we present AdaLens (Agentic data analysis Lens), an interactive system for monitoring and steering long-running agentic data analysis. For DC1, we design a storyline-based representation that supports multi-granularity inspection by organizing analytical plans, summaries, and atomic insights as visual elements along an evolving timeline, while preserving analytical lineage by threading data columns through the storyline as persistent characters whose participation across steps and findings remains visually traceable. For DC2, we design steering interactions grounded in these storyline elements, enabling analysts to redirect the agent’s analytical direction by acting on summaries, atomic insights, and data columns (Focus, Ignore, Elaborate) and to manage the lifecycle of plan threads through direct execution controls (Create, Launch, Pause, Modify, Terminate). We evaluate AdaLens through two case studies and a user study. The case studies illustrate how analysts used the storyline to monitor evolving analyses and apply both intention-level steering and execution-level control; the user study reports a mean System Usability Scale (SUS) score of 87.08 and positive participant assessments of observability and steerability. In summary, our core contributions are as follows: • We formulate the problem of monitoring and steering long-running agentic data analysis, identifying key challenges around building legible representations of evolving analytical processes and enabling precise steering grounded in these representations. • We propose AdaLens, an interactive system that integrates a storyline-based representation supporting multi-granularity inspection and data-grounded analytical lineage with steering interactions that operate at both the intention level and the execution level. • We evaluate AdaLens through two case studies on two real-world datasets and a user study on representative analytical tasks. I Related Work We review existing research on empowering data analysis with LLMs, visualizing data analysis processes, and interacting with LLMs. I-A Empowering Data Analysis with LLMs Large language models (LLMs) have enabled more open-ended data analysis through broad domain knowledge and strong reasoning capabilities [84], and the autonomy granted to them has grown progressively. Early tools focused on generating standalone visualizations from natural language [67, 8] and refining this mapping through prompt scaffolding, few-shot examples, and multimodal interactions [33, 5], though effective use still depends on prior analytical skill and careful inspection of intermediate outputs [19, 37]. Subsequent efforts extended LLM involvement to progressive workflows [36, 82, 70] that externalize analytical context [46, 68] and support iterative exploration, report adaptation, and hypothesis refinement [17, 65, 9]. These systems shift the LLM’s role from producing standalone artifacts to coordinating an evolving analytical process, though multi-step reasoning and intent disambiguation remain challenging [32, 11]. More recently, autonomous agents integrate planning, tool use, and iterative refinement for end-to-end workflows [20, 59, 79, 40], with some extending to automated report writing and narrative generation [76, 25]. However, benchmarks suggest that reliably achieving fully autonomous analysis remains an open challenge [22, 50, 30, 60]. Building on this line of work, AdaLens employs an orchestrator–worker architecture to support long-running agentic data analysis, enabling autonomous and multi-step reasoning. I-B Visualizing Data Analysis Processes Visualizing the data analysis process helps users trace and revisit how results were reached [49, 38, 14]. We review such visual representations at different abstraction levels. At the data transformation level, systems make intermediate states visible through live profiling [13], animated pipeline explanations [47], or inspectable query decompositions [43, 16]. For LLM-driven analysis, WaitGPT [75] renders streaming code as real-time dataflow graphs with table glyphs encoding data shape changes, while ViseGPT [83] visualizes test results as Gantt charts for error localization. At the workflow level, flow graphs foreground dependencies among data states and operations. NoteFlow [64] and NoteEx [46] extract or let analysts define inter-cell data dependencies for bidirectional tracing in computational notebooks, while Flowco [17] and LightVA [82] use dataflow and task-flow graphs respectively to structure the authoring and planning of analysis pipelines. Tree views externalize branching exploration. Data Formulator 2 [68] organizes iterative visualization authoring into Data Threads for branching and context reuse, Kang et al. [9] structure hypothesis exploration with ordered node-link diagrams, and Narrative Scaffolding [23] maintains branching narrative trees that record reasoning evolution. Timeline and history views, such as those combining artifact and search interfaces for fragment-level version foraging [29] or recording sensemaking provenance for post-hoc analysis [44], help reconstruct how a result was reached. At a higher abstraction, systems move beyond process steps to organize findings and track exploration coverage: InsightLens [73] clusters insights hierarchically with a temporal minimap, while Snowy [55] visualizes attribute and intent coverage to guide exploration breadth. AdaLens frames long-running agentic data analysis as an evolving narrative and adopts a storyline-based visualization to jointly support temporal progression, multi-granularity inspection, and data-grounded analytical lineage. I-C Interacting with LLMs Researchers have advanced interaction techniques that give users more control over LLMs, moving beyond standard chatbot interfaces. A core challenge is the “gulf of envisioning” [56]: users struggle to anticipate how prompts translate into outputs, which imposes substantial metacognitive demands [63] and motivates tighter alignment between user intent and model behavior [53]. To close this gap, one line of work supports post-hoc inspection, including provenance tracking [21], explanatory diagnostics [16], and empirical studies of analyst verification behavior [19, 18], while another opens pre-output intervention points such as editable task decompositions [28] and externalized intent-to-task mappings [80]. For multi-agent and code-generation workflows, recent tools provide checkpoint-based counterfactual replay [12], real-time visual monitoring of streamed code [75], and constraint-based test generation for automated error localization [83]. Another stream of research moves beyond single-text prompting by externalizing plans, context, and semantic structures as manipulable objects. Several systems externalize intermediate plans and processing steps as objects that users can inspect and edit [74, 4, 15, 42, 78]. Spatial interfaces move beyond linear dialogue by introducing navigable structures such as interactive node-link graphs [26], multilevel abstraction hierarchies [58], dimension-driven design-space maps [57], freeform canvases for side-by-side comparison [10], and editable conversational memory [24]. Multimodal interaction further reduces prompt ambiguity by combining natural language with direct manipulation, sketching, or dynamically synthesized widgets [41, 66, 5, 72, 85]. Beyond richer input modalities, ProactiveVA [81] shifts the locus of initiative by letting agents detect user difficulties and offer context-aware assistance unprompted. These interaction patterns, spanning structured plans, spatial workspaces, and multimodal or proactive support, have been adopted in iterative data analysis [69, 68, 46, 70, 65, 82], data-driven sensemaking and storytelling [23, 2, 9], and creative authoring interfaces [6, 1, 35, 48]. Unlike prior approaches designed around turn-by-turn interaction and discrete checkpoints, AdaLens supports intervention within continuous agentic data analysis through direct manipulation interactions grounded in visible analytical elements, enabling analysts to steer the evolving analytical process asynchronously and in situ. I Informing the Design AdaLens is designed for analysts who already use LLM-based assistants or agentic coding tools in their data analysis workflows. In these workflows, agents can carry out multi-step investigations beyond a single prompt--response exchange, making it important for analysts to follow intermediate progress and intervene when useful. To ground the design of AdaLens in realistic analytical practice, we collaborated closely with three researchers who actively use such tools in their data analysis work. We recruited them through direct verbal or instant-messaging invitations and provided no compensation.11 1 All experts in the formative collaboration and case studies, as well as all user-study participants, provided informed consent before taking part. EA is an assistant professor whose research focuses on emerging data analytical techniques driven by agentic LLMs. EB and EC are Ph.D. candidates in time-series and urban data analysis, respectively, who both frequently employ agentic LLM tools in processing relevant data. Together, they bring both research perspective and hands-on experience using LLM-based assistants and agentic coding tools for data analysis. The tools they currently use (e.g., ChatGPT [45], Julius AI [27]) already support extended agentic analysis, but mainly through natural-language interaction and sequential textual or code-oriented outputs, motivating our focus on structured visual oversight to address shared workflow needs in agentic data analysis. Our collaboration broadly followed the design study methodology of Sedlmair et al. [52]. Over approximately six months, we met with the experts in weekly hour-long sessions spanning the core phases of the methodology. In the discover phase, we asked the experts to walk through concrete analysis scenarios, describe how they would inspect and intervene in an ongoing agent-driven analysis, and identify what information they would need to do so effectively. These discussions led to the problem formulation, current practice challenges, and design goals described below. In the design and implement phases, we translated these goals into prototype designs and continued meeting with the experts to iteratively evaluate and refine the visual encodings, interaction mechanisms, and system workflow until the experts confirmed that the design adequately supported the identified design goals. I-A Problem Formulation Drawing on our discussions with the experts, we formulate agentic data analysis as a process in which an agent receives a high-level analytical goal and a dataset, then autonomously advances the investigation through repeated cycles of planning, execution, and synthesis. Unlike turn-by-turn LLM assistance, its central unit is not a single conversational turn but an evolving run that persists beyond any single interaction, during which the agent can pursue several candidate directions concurrently and revise them as evidence accumulates. Overseeing such a process requires analysts to understand its evolving structure and intervene as it unfolds—a problem we term interactive oversight. We characterize a run through the following recurring analytical elements and their relationships: • Step. One round in which the system updates the run state by deciding what to analyze next, executing the corresponding analysis, and producing the new results. • Plan and plan thread. A plan is an explicit analytical intention for one direction of inquiry. A plan thread refers to the ongoing lifecycle of that direction as it progresses from pending through active execution to completion, and may be paused or terminated by the analyst along the way. • Atomic insight. A fine-grained finding that states a specific observation about the data, such as a trend, an outlier, or a correlation, linked to concrete supporting evidence such as code, plots, and textual outputs. • Summary. When a thread completes its assigned analysis, the system produces a summary that synthesizes the resulting atomic insights into a thread-level conclusion. • Data column. The specific parts of the dataset implicated in a plan or finding. Data columns recur across multiple threads and steps, providing a persistent connective medium that grounds the analysis in the underlying data. These elements do not exist in isolation. We use the term analytical lineage to refer to the web of relationships that connects them: plans initiate threads, completed threads yield atomic insights that are synthesized into summaries, and those findings can motivate, refine, or constrain later plans in subsequent steps. This lineage is inherently difficult to follow because threads run concurrently within each step, data columns split across those threads and reconverge in later steps, and each completed thread produces a nested hierarchy of summaries and insights with their own internal structure. The underlying data unifies this lineage: every element is grounded in specific data columns, plans target them, insights are derived from them, and threads operating on overlapping columns share observable data grounding and are analytically related through their common data involvement even when they belong to different steps. Shared data therefore provides a natural connective tissue through which analytical lineage can be traced and made visible. I-B Challenges in Current Practice Across our ongoing collaboration with the experts, we identified three recurring practice challenges in their experiences with long-running agentic data analysis. Specifically, PC1 and PC2 characterize the observability challenge (DC1), whereas PC3 characterizes the steerability challenge (DC2). PC1: Analysts struggle to inspect the accumulating analytical artifacts of a run. As a run progresses, it continuously produces analytical artifacts at multiple levels of granularity, ranging from run-level steps and analytical plans to fine-grained findings and supporting evidence. Current tools often do not organize these artifacts for structured inspection, leaving them difficult to access, locate, or inspect. Analysts may therefore need to locate and review relevant information across extensive intermediate outputs, making it difficult to examine specific findings without losing sight of the run’s overall state. For example, EB described intermediate conclusions as difficult to inspect and follow up on in context, while EC reported having to explicitly save scripts and intermediate artifacts that would otherwise remain temporary and difficult to manage or inspect. EA further noted that existing end-to-end tools often prioritize final reports while providing little structured access to the underlying analytical process, making intermediate steps cumbersome to trace. PC2: Analysts struggle to trace the evolving analytical structure of a run. A run can unfold through multiple analytical directions that proceed concurrently and extend across successive steps. Although intermediate outputs collectively document the activities and findings produced throughout the run, the relationships among these analytical artifacts and their grounding in the underlying data remain implicit. Consequently, analysts find it difficult to reconstruct the analytical structure of the run and understand how it evolved as a connected process. For example, EC used a separate collaborative document to record analytical plans and track progress. However, EC noted that loose and sometimes outdated links among the document, intermediate artifacts, and results could obscure the overall analytical trajectory. EB likewise found it difficult to connect intermediate conclusions to the information from which they were derived, as the conclusions were numerous, inconsistently presented, and sometimes embedded in the agent’s intermediate reasoning. PC3: Analysts struggle to intervene effectively in a run as it unfolds. As a run unfolds, analysts may identify promising directions to pursue, irrelevant directions to deprioritize, unproductive plans whose execution should be adjusted, or new analytical ideas worth exploring. In current practice, analysts largely rely on natural-language instructions to express such intentions, requiring them to translate their judgments and relevant analytical context into actionable requests. Consequently, they find it difficult to intervene efficiently and precisely, both in redirecting future investigation and in regulating the execution of ongoing plan threads. For example, the tools used by EC did not support pausing an ongoing execution, and modifying or terminating one task required interrupting the overall analytical process. EB reported that steering a direction that emerged during a run required repeated follow-up questions to reconstruct its context, and EA similarly noted that current agentic tools offered limited support for redirecting the analysis when an agent began to drift from the high-level analytical goal. I-C Design Goals From the practice challenges above, we derive four design goals for interactive oversight in long-running agentic data analysis. G1 and G2 address the observability challenges identified in PC1 and PC2, respectively, while G3 and G4 address the intervention challenge described in PC3 at the levels of analytical direction and ongoing execution. G1: Represent analytical elements across multiple levels of granularity. The system should expose the key elements of a run, from active plan threads and step-level progress to summaries, atomic insights, supporting evidence, and involved data columns. Such a multi-granular representation is necessary because analysts overseeing long-running analyses need to alternate between global orientation and close inspection of specific findings. It should support fluid navigation across these levels so that analysts can shift between monitoring overall progress and examining individual results. G2: Visualize data-grounded analytical lineage across plans, summaries, and atomic insights. The system should make visible how plans, summaries, and atomic insights relate to one another through the data columns they share. Since overlapping data columns connect elements both within and across steps, they provide a structural basis for tracing how the process evolves, how threads diverge or converge, and how findings share data grounding. This goes beyond exposing isolated artifacts: analysts should be able to follow the data-grounded continuity of the run rather than manually reconstruct it from scattered outputs. G3: Steer analytical direction by interacting with visible elements. The system should allow analysts to influence what the agent investigates next by acting on the summaries, atomic insights, and data columns they observe, signaling which directions to prioritize, suppress, or deepen. Such steering should be grounded in visible elements of the ongoing run, enabling analysts to express intentions precisely and in context. This reduces the burden of reconstructing and restating accumulated context through free-form natural language. G4: Regulate the lifecycle of ongoing plan threads. The system should allow analysts to create, launch, pause, modify, and terminate plan threads as the run evolves. This control is necessary because the value of a thread can change over time, and analysts need to coordinate computational effort with emerging findings and domain knowledge. These actions should take effect during the run without requiring analysts to interrupt the overall analytical process. IV AdaLens This section first presents the orchestrator–worker framework that drives AdaLens (section IV-A). It then describes how the coordinated views, particularly the storyline visualization, help analysts understand the ongoing analytical process (DC1; section IV-B) and how the interaction mechanisms enable analysts to steer and control the run (DC2; section IV-C). Finally, it provides implementation details (section IV-D). IV-A System Framework Fig. 2: AdaLens framework for interactive oversight in long-running agentic data analysis. Analysts steer the run through intention-level actions and execution-level controls (A). The orchestrator manages context integration, plan creation, report generation, and progress evaluation (B). The orchestrator dispatches plans to parallel workers whose analyzer and summarizer produce summaries and atomic insights with supporting evidence (C), and these intermediate analytical elements are surfaced through the chat, inspector, and storyline views (D). Building on the process model in section I-A, AdaLens instantiates agentic data analysis as an autonomous and multi-step process while preserving observability and steerability for analysts throughout the run. To drive the autonomous workflow, AdaLens adopts an orchestrator–worker architecture consisting of an orchestrator agent and multiple worker agents. The orchestrator handles high-level reasoning and orchestrates the overall analytical process (fig. 2B). At each analytical step, the orchestrator decides how the workflow should proceed, including whether to generate new plans, dispatch them to workers, evaluate the progress, and synthesize findings. Each worker is responsible for executing a specific analytical plan issued by the orchestrator (fig. 2C). Internally, it comprises two sequential components: an analyzer (fig. 2C1) and a summarizer (fig. 2C2). The analyzer performs iterative reasoning and analysis under a ReAct-style prompting paradigm [77], including generating code, executing it, interpreting intermediate results, and reflecting on the current progress. The summarizer then consolidates the analysis process and outcomes into a structured finding hierarchy, including a summary and a set of atomic insights, each linked to concrete supporting evidence (e.g., code, plots, and textual outputs). These findings are returned to the orchestrator and utilized as context for subsequent decision-making. Complementing this autonomy, AdaLens is designed to keep analysts informed and in control throughout the long-running analysis. To support observability, the system preserves essential analytical artifacts produced during execution, including plans, summaries, atomic insights, and their supporting evidence, making them available for inspection on the user interface (fig. 2D) at any point. To support steerability (fig. 2A), the system captures analyst interventions in real time at both the intention level for the orchestrator (fig. 2A1) and the execution level for workers (fig. 2A2), enabling the analysis to adjust its trajectory without terminating and restarting the run. These two mechanisms form the architectural basis for the interactive oversight features detailed in the following sections. IV-B Understanding the Ongoing Analytical Process To maintain the observability of the ongoing analytical process for analysts (G1, G2), AdaLens organizes the analytical elements introduced in section I-A into three coordinated views: the storyline view (fig. 1B), the chat view (fig. 1A), and the inspector view (fig. 1C). They reveal how the analysis is structured and proceeds, how findings accumulate over time, and what evidence supports each result. IV-B1 Storyline View Inspired by storyline visualization techniques [61, 62], we conceptualize long-running agentic data analysis as an evolving narrative. To elucidate this dynamic progression, the storyline view integrates diverse analytical elements into a unified temporal representation, serving as AdaLens’s primary interface. We detail its visual elements, layout design, design rationale, and inspection-oriented interactions below. Visual elements. The storyline view visualizes three types of key analytical elements (section I-A) at multiple levels of granularity (G1). (1) Plans and summaries. Plan threads dynamically appear as analytical cards (fig. 1B4) showing the plan description and execution status (e.g., pending, analyzing, summarizing, completed, terminated, or failed). Once a thread completes, it is converted into a summary card (fig. 1B7) displaying a brief label and extracted atomic insights. These cards form the backbone of the storyline, marking key analytical events and conclusions as the analysis progresses. (2) Atomic insights. Within each summary card, AdaLens exposes fine-grained findings as atomic insight glyphs (fig. 1B6) arranged in order of generation. Glyph size reflects an importance score computed from statistical indicators (impact and significance) combined with LLM-judged interestingness. Insight types are informed by [73, 71] and encoded with distinct glyphs (fig. 1B2). This design helps analysts quickly identify important insights and navigate between high-level summaries and detailed findings without leaving the storyline view. (3) Data columns. To visualize recurring data grounding, we render data columns (fig. 1B5) as characters in the narrative of a long-running agentic data analysis. The label size of each column character reflects the number of atomic insights involving that column in the corresponding analytical step, visually conveying the extent of its involvement in that step. At the beginning of each step, these characters emerge and split into multiple instances that join different analytical events. During execution, these column instances visually converge into the summaries and insights in which they are involved. At the end of each step, they merge back into their original columns and either exit or continue into the subsequent step, depending on whether they remain involved in the next step. Through this metaphor, analysts can naturally follow how data columns dynamically participate across the analytical process and how findings remain grounded in the data. In addition to these core elements, the storyline view includes report anchors (fig. 1B3), which are compact markers for the orchestrator’s stage-level or final textual syntheses. Each anchor in the storyline links to the corresponding detailed report in the chat view. Layout design. To make the analytical lineage defined in section I-A legible within a single temporal workspace (G2), the layout arranges the storyline elements and connects them through column-character trajectories while maintaining visual clarity, compactness, and stepwise progression. It follows a timeline-based storyline metaphor in which analytical steps are arranged from left to right and the view alternates between finding regions (fig. 1B9) and converge regions (fig. 1B10). A finding region corresponds to one analytical step and contains summary cards with their nested atomic-insight glyphs, whereas a converge region lies between adjacent finding regions and gathers the column threads that continue from one step to the next. This alternation makes visible how recurring data columns are distributed across findings within a step and either exit or continue into subsequent steps. These spatial relations have specific meanings. Horizontal placement encodes stepwise progression; cards grouped within a finding region belong to the same analytical step, and atomic-insight glyphs nested within a card belong to that summary. A column trajectory entering a card or glyph indicates that the corresponding artifact involves that column. Within a converge region, instances of the same column merge into a shared lane when the column continues across adjacent steps, then split toward the artifacts that involve it in the next finding region. The vertical order of these lanes is inherited from the preceding converge region and adjusted through ordering, alignment, and compaction to preserve trace continuity and reduce crossings and wiggles. Thus, vertical proximity mainly reflects the inherited ordering and compaction of column trajectories, rather than an additional encoding of similarity or relationship strength. Our optimization principle follows StoryFlow [34]: ordering, alignment, and compaction are used to reduce crossings and wiggles while keeping the layout compact. Unlike classical storyline layouts, however, our setting evolves incrementally, may branch into concurrent analytical threads, and contains nested finding structure rather than a flat set of entities. We therefore apply these operations progressively from left to right instead of recomputing the entire storyline offline. In this adaptation, the finding/converge-region structure and the treatment of each summary card as a local storyline are design choices for representing incremental agentic runs. The algorithmic component is the repeated local application of ordering, alignment, and compaction, retaining the classical objective of preserving trace continuity, reducing crossings and wiggles, and keeping the visualization clear and compact. When a new finding region appears, it inherits the solved column order from the left converge region to arrange summary cards and their incoming boundary threads; within each summary card, atomic insights are treated as a local storyline whose column threads are again ordered, aligned across adjacent insight positions, and compacted under spacing constraints. When a new converge region is created, threads belonging to the same column are merged into a shared converge lane; when the next finding region appears, those lanes split again toward different summary cards and further converge onto the relevant insight glyphs. By reusing the same StoryFlow-inspired principles locally at each transition, the layout remains stable while accommodating newly arrived summaries, atomic insights, and columns. Additional implementation details of the progressive layout algorithm are deferred to the supplementary material. Design rationale. During the design process, we considered both topology-oriented and chronology-oriented representations for organizing an evolving run. Topology-oriented representations, such as tree, node-link, and dataflow views, can convey ordered progression, branching, and dependencies, but generally assume an explicit topology among entities. An analytical run instead combines successive steps, concurrent plan threads, containment relationships between summaries and atomic insights, and the recurring involvement of data columns without conforming to a single tree, dependency graph, or dataflow structure. Encoding these heterogeneous relationships uniformly as nodes and edges could therefore impose structural semantics that are not consistently present. Chronology-oriented representations, such as Gantt-style timelines and card-based history views, can effectively organize stepwise progression, execution status, and accumulated analytical artifacts, but typically retain data columns as attributes of individual artifacts or expose their recurrence through additional links. This local encoding leaves analysts to reconstruct how the same data dimensions recur across concurrent threads, findings, and successive steps. We therefore selected a storyline representation that organizes plans and summaries as analytical events, embeds atomic insights as nested findings, and represents data columns as persistent characters connecting the events in which they participate. In this way, the storyline preserves stepwise progression while making the data-grounded continuity across otherwise distributed analytical artifacts directly visible. Inspection-oriented interactions. The storyline view further supports understanding through a set of inspection-oriented interactions. Analysts can directly select plan cards, summary cards, atomic insights, and report anchors to activate the corresponding inspection state, with the inspector and chat views synchronized to reveal the associated detailed information. The selected elements will be highlighted to help analysts maintain their focus. Hovering over an atomic insight glyph or a summary card displays a popover (fig. 1B8) with detailed descriptions on the fly, allowing analysts to quickly scan and understand key findings without leaving the storyline view. The view also supports highlighting findings by selecting data columns and insight types of interest. In addition, the view supports horizontal panning and zooming, helping users navigate large storylines flexibly. IV-B2 Chat View The chat view (fig. 1A) presents an analysis run as a conversation list that records executed actions, agent responses, and generated reports. In addition to the initial analytical goal and subsequent user messages, it displays a sequence of system-generated entries corresponding to distinct stages of the workflow, including orchestrator thinking, plan creation, plan dispatch, progress evaluation, finding synthesis, and report generation. For dispatched plans, the view embeds compact plan cards (fig. 1A1) showing each plan’s current status and any corresponding summary produced from that plan. Stage-level and final reports (fig. 1A2) further include inline references to the corresponding summary cards or atomic insights in the storyline view, allowing analysts to move from textual reports to their associated visual context. The panel header also provides access to prior conversations, allowing users to switch between runs while preserving the current run context. Within a run, the chat view is coordinated with the other views: plan cards and summary entries can be selected from the conversation history, and items shown elsewhere in the interface can be traced back to their textual records. As a result, the chat view functions not merely as a transcript, but as a chronological record of how the analytical process progresses through planning, execution, and synthesis. IV-B3 Inspector View The inspector view (fig. 1C) enables analysts to move from process-level awareness to detailed examination of intermediate outputs through the coverage grid and the detailed view. The coverage grid (fig. 1C1) summarizes how extracted atomic insights are distributed across insight types and dataset columns, with color intensity encoding the degree of coverage. The detailed view (fig. 1C2) supports multiple inspection modes depending on the current selection. Selecting a plan activates a plan-focused mode, which presents the plan description, current execution status, and an analysis stream composed of live or recovered artifacts such as generated code, textual outputs, error messages, reflections, and plots. This mode allows analysts to inspect how an individual analytical task was carried out, including partially completed or failed executions. Selecting a summary or atomic insight activates a finding-focused mode. In this mode, the inspector presents the source task, the summary text, and the associated atomic insights. Each atomic insight is shown together with its taxonomy type, related data columns, importance-related metrics, and linked evidence, including a plot preview and expandable code and output panels. In addition, analysts can select data columns, insight types, or individual cells in the coverage grid to filter and inspect the corresponding atomic insights, which can be further prioritized by their importance. Together, these coordinated inspection modes help analysts trace high-level findings back to the concrete artifacts that support them. IV-C Steering the Ongoing Analytical Process To help analysts steer the ongoing analysis (G3, G4), AdaLens enables direct interaction with meaningful analytical elements in the interface, supporting both intention-level steering of the analytical direction and execution-level control of ongoing plan threads. IV-C1 Intention-Level Steering via Visual Elements To operationalize G3, AdaLens supports three recurrent intention-level steering actions (fig. 1B1): Focus, Ignore, and Elaborate. Rather than relying solely on free-form prompting, analysts issue these actions directly from visual elements in the storyline view, and AdaLens incorporates the resulting steering requests together with information from the selected elements into the orchestrator’s context at the next analytical step. Within this mechanism, Focus and Ignore redirect subsequent planning around selected summaries, insights, or columns, while Elaborate requests a narrower follow-up on a selected summary or insight. Focus. Analysts use Focus when they find one or more directions particularly promising and want the system to continue investing effort in those directions. For example, after noticing salient keywords in a finding or deciding to further examine specific data columns, analysts may want the system to prioritize those directions in subsequent analysis. To issue a focus action, the analyst first activates the Focus pen and then clicks a summary card, an atomic insight glyph, or one or more column characters. For summary cards and atomic insight glyphs, the interaction opens a popover that provides topic keywords distilled from corresponding text, an editable preview of the steering request, and the relevant summary or atomic text as optional background context. For column characters, the analyst can stage and toggle multiple selected columns before confirmation. After confirmation, AdaLens records a structured focus request and biases subsequent planning toward devoting more effort to the selected topics, while allowing already running plan threads to continue. Ignore. Analysts use Ignore when a direction appears redundant, low-value, or misaligned with the evolving analytical goal. For example, if the system keeps revisiting the same low-yield columns or repeatedly expands a branch that the analyst judges unhelpful, the analyst can suppress that direction before additional time and tokens are spent on it. The interaction largely mirrors Focus. The analyst activates the Ignore pen and selects a summary card, an atomic insight glyph, or one or more column characters. Summary- and glyph-level selections open the same keyword- and preview-based popover, while column-level selections support staged multi-column selection before confirmation. After confirmation, the resulting steering message tells the orchestrator to avoid future investigation along those directions unless they later become necessary for answering the main goal. Existing running plan threads are not cancelled, but subsequent planning shifts away from the ignored target. Elaborate. Analysts use Elaborate when a finding is important but still underspecified, and they want the system to explain it in greater depth rather than branch broadly. For example, after seeing an unusual atomic insight or a summary whose meaning is still unclear, an analyst may want the system to further unpack what drives that result and why it occurs. To do so, the analyst activates the Elaborate pen and clicks either a summary card or an atomic insight glyph; unlike Focus and Ignore, Elaborate does not target columns. The interaction opens a compact confirmation popover centered on the selected finding, without the keyword chooser used by the other two actions. After confirmation, AdaLens issues a narrowly scoped elaboration request that encourages the orchestrator to continue investigating the explanation, mechanism, and root causes of that specific insight while avoiding unnecessary branching into unrelated new plans. IV-C2 Execution-Level Control by Regulating Plan Threads To operationalize G4, AdaLens supports a set of execution-level control actions spanning the plan lifecycle, including creating, launching, pausing, modifying, and terminating plan threads. AdaLens supports these actions directly on plan cards, giving analysts fine-grained control over the execution of analytical tasks. Create adds a user-authored plan thread for a direction not covered by the current set. The analyst right-clicks a blank area in the storyline view and enters a new plan in the popover. If a dispatch is already in progress, the new plan joins the current batch; otherwise, it is dispatched at the next analytical step. Launch starts a pending plan thread or resumes a paused one from its preserved phase immediately, rather than waiting for later scheduling. Pause suspends a running thread that is not urgent enough to continue consuming time and tokens but may be worth revisiting later. AdaLens preserves the thread’s current execution phase and removes it from active execution until the analyst explicitly resumes it. Modify revises a plan whose direction remains valuable but whose formulation needs adjustment. To do so, the analyst first pauses the thread if it is still running, then clicks the modify button on the plan card and edits its description. After confirmation, AdaLens updates the plan and keeps the thread available for relaunch under the revised formulation. Terminate permanently stops a thread judged clearly unhelpful. For pending or paused threads, termination takes effect immediately; for actively running threads, AdaLens stops the thread after its current operation completes. The terminated thread is removed from subsequent execution. IV-D Implementation We developed AdaLens as a web-based application using a client–server architecture, with a React-TS frontend and a Flask-based Python backend. The backend exposes HTTP endpoints for execution and steering requests, and streams real-time events and generated artifacts to the frontend via Server-Sent Events (SSE). The system is model-agnostic by design. At the time of implementation, we used gemini-3.1-pro-preview for global orchestration and gemini-3.1-flash-lite-preview for workers through an OpenAI-compatible provider. Further implementation details are provided in the supplementary material. V Case Study This section presents two case studies and expert interviews to examine how AdaLens supports analysts in monitoring and steering agentic data analysis while pursuing their analytical tasks. Together, the cases cover complementary forms of interactive oversight: observing process progression, findings, and data involvement through the storyline view, and interacting with its analytical elements for intention-level steering and execution-level control. We invited two external analysts with domain expertise and practical experience using LLM-based tools for data analysis, neither of whom was involved in the design of AdaLens, to use the system to analyze datasets from their respective domains. Each session lasted approximately one hour and followed a think-aloud protocol, after which we interviewed the experts to gather their feedback. Although the sessions were bounded in duration, each analysis unfolded through successive stages as multiple analytical directions emerged and plans and findings accumulated. This progression allowed us to examine how the experts monitored the evolving process, regulated execution, and steered subsequent analysis. Fig. 3: Case 1 (Stages 1–2): using AdaLens to initiate the investigation of the ambiguous hot_degree metric in a Twitter dataset and regulate candidate plans. (A) ED starts from a focused chat request asking which columns relate to hot_degree. (B) When two candidate plans appear in parallel with their execution states, ED pauses both, reviews them, terminates the categorical/boolean branch, and launches the branch on numerical variables. Fig. 4: Case 1 (Stages 3–5): using AdaLens to inspect and extend the analysis of the ambiguous hot_degree metric and synthesize the resulting findings. (C) Column label sizes convey the extent of each variable’s involvement, highlighting hot_degree as the analytical focus; the resulting summary identifies statuses_count, media_count, and followers_count as its strongest related variables. (D) Based on these visible results, ED creates a targeted follow-up plan to model hot_degree from these variables; the same four column characters continue into the follow-up step, which yields a log-linear model for hot_degree. (E) AdaLens returns a final report that consolidates both the correlation findings and the resulting predictive model. V-A Case 1: Goal-Oriented Analysis of Social Media Data Expert D (male, ED) is a data analyst with two years of experience in social media data analysis. For this case, ED provided a crawled Twitter dataset in which each row represents an individual tweet and includes the post text, posting context, user-account statistics, and engagement measures. Among these variables was a metric labeled hot_degree, whose meaning was ambiguous and whose relationship to other variables was unclear to him. ED wanted to clarify what factors were associated with hot_degree before relying on it further, as this metric could affect how the dataset was interpreted in subsequent analysis. He therefore used AdaLens with a focused goal: to identify how hot_degree related to the other columns in the dataset. Stage 1: Initiating analysis with a focused question. ED uploaded the dataset and typed his question in the chat view (fig. 3A): “In the dataset, which other columns are related to the “hot_degree” column?” The system first responded in the chat view, after which ED observed AdaLens begin creating plans for the analysis in the storyline view. Stage 2: Reviewing and regulating candidate plans. Once the system created and dispatched the initial plans, ED saw two new plan cards appear in parallel in the storyline view, together with their execution states (fig. 3B). He first paused both threads to prevent the system from spending tokens on potentially unnecessary analysis while he reviewed them. After inspecting the two candidate plans, he terminated the branch on categorical and boolean variables, because he wanted to first focus on the numerical variables that were more likely to directly explain hot_degree. ED then launched the remaining plan and monitored its progress as the card state transitioned from analyzing to summarizing, eventually producing a summary card. Stage 3: Inspecting data involvement and the summary. After the storyline updated (fig. 4C), ED noticed that the label for hot_degree was displayed at the largest size among the columns in this step, indicating that the analysis remained centered on his target variable. He then inspected the resulting summary, which reported that hot_degree was most strongly related to statuses_count, followed by media_count and followers_count. The labels for these three columns were also relatively large, making their prominent involvement in this step readily visible. Stage 4: Creating a targeted follow-up plan. Based on this finding and the three identified variables, ED wanted to move beyond correlation and understand how hot_degree might be computationally derived. Because the main analytical run was still ongoing, he chose not to redirect it by sending a new prompt through the chat view. Instead, he right-clicked in the storyline view to trigger the Create interaction and entered a more targeted request (fig. 4D): “Investigate and propose a computational model to calculate hot_degree utilizing statuses_count, media_count, and followers_count.” After confirmation, AdaLens created a new plan card and dispatched it within the current execution batch. When this plan completed, the resulting summary card reported: “A linear regression model using log-transformed values of statuses_count, media_count, and followers_count effectively predicts hot_degree with an R-squared of 0.9466.” ED observed that the column characters for these four variables continued into the follow-up step, showing that the targeted analysis remained grounded in the same data dimensions as the preceding correlation analysis. Stage 5: Requesting a final synthesis. At this point, ED had identified the variables most strongly related to hot_degree and obtained a plausible computational model for estimating it. He returned to the chat view and issued a final summarization request, asking AdaLens to synthesize the overall findings. In response, the system generated a global report (fig. 4E) that consolidated the earlier results into a coherent account of how hot_degree related to the other columns in the dataset. Fig. 5: Case 2 (Stages 1–3): using AdaLens to explore an NBA spatiotemporal tracking dataset in an open-ended manner and steer the analysis toward a promising matchup. (A) E begins with a broad exploration request, after which the storyline presents early summaries, atomic insights, and the columns involved in them. (B) E notices two frame-level ball-coordinate columns that are not of particular interest and applies Ignore to ball_zone and ball_z to deprioritize them. (C) He then applies Focus to a promising summary card about Bogut and James, steering subsequent plans toward this matchup. Fig. 6: Case 2 (Stages 4–5): using AdaLens to elaborate a key insight and generate a final report. (D) Within the resulting summaries, an atomic insight reveals that blocked-shot interactions are more frequent in the first period than in the third, prompting E to apply Elaborate to it for a deeper explanation of this temporal pattern. (E) AdaLens finally generates a report that consolidates the exploratory findings into a coherent interpretation of the game. V-B Case 2: Exploratory Analysis of NBA Game Data Expert E (male, E) is a sports data analyst with three years of experience in basketball game data analysis. For this case, E provided an NBA spatiotemporal tracking dataset from the 2015–2016 Christmas Day game between the Cavaliers and the Warriors, organized by possession while retaining fine-grained spatial records. Because the dataset is high-dimensional and tactically rich, E did not begin with a single narrowly defined question. Instead, he used AdaLens for exploratory analysis to surface potentially meaningful patterns in the game. Stage 1: Starting with open-ended exploration. E uploaded the dataset and initiated an open-ended analysis: “Comprehensively and deeply explore this dataset.” As the initial plans completed, the storyline view (fig. 5A) began to accumulate summary cards and atomic insights connected to data columns. This allowed E to survey the emerging findings, potential analytical directions, and involved columns together during the early exploratory phase. Stage 2: Ignoring low-interest ball-coordinate columns. Among the column characters associated with the emerging findings, E noticed several that represented frame-level ball coordinates, which were not of particular interest to his exploration. He therefore activated the Ignore tool and selected two such column characters, labeled ball_zone and ball_z, directly in the storyline view (fig. 5B). After confirmation, the two columns were marked with the Ignore visual indicator in the storyline view, and AdaLens automatically sent a steering prompt in the chat view: “Deprioritize future analysis of dataset columns ball_zone and ball_z.” In subsequent rounds, these two columns no longer appeared in the storyline view, confirming that the system had successfully deprioritized them. Stage 3: Focusing on a promising summary. Among the accumulated findings, E noticed a summary card labeled “Bogut vs. James: Blocked-shot dominance.” This immediately drew his attention to the matchup between Bogut and James, and he decided to pursue this lead to better understand their head-to-head performance. E applied the Focus tool to this summary (fig. 5C). A temporary card appeared, prompting him to select topics from the summary. After choosing “Bogut” and “James”, E saw an automatically generated preview prompt, “In follow-up analysis, prioritize Bogut and James for this summary”, with the selected summary included as contextual background by default. After he confirmed, AdaLens sent the prompt to the chat view, and in the next round of analysis, all proposed plans centered on Bogut and James. Stage 4: Elaborating a key insight to understand why it emerged. Within the resulting Bogut–James summaries, E inspected an atomic insight stating, “Blocked-shot events between Andrew Bogut and LeBron James occur substantially more often in the first period than in the third period.” Rather than stopping at this observation, E wanted to understand why this temporal pattern emerged. He applied the Elaborate tool to the insight glyph (fig. 6D) to request a deeper explanation of this specific finding. After confirmation, AdaLens sent the prompt to the chat view, and the resulting follow-up analysis provided a more detailed account of the pattern. Through this progression, E acted successively on visible columns, a summary card, and an atomic insight to deprioritize low-interest variables, pursue a promising matchup, and deepen a specific finding. These interactions moved the analysis from identifying the salient Bogut–James matchup to developing a more detailed explanation of why their blocked-shot interactions were concentrated early in the game. Stage 5: Consolidating the exploratory findings. After the exploration, E returned to the chat view and requested a final synthesis of the key patterns surfaced during the run. AdaLens generated a global summary report (fig. 6E) that consolidated the findings into a coherent interpretation of the game. V-C Expert Interviews After completing their analyses, we conducted one-on-one semi-structured interviews with ED and E to gather their perspectives on AdaLens. We summarize their feedback in three aspects below. Visual Design and Interactions. Both experts highlighted the storyline view as the most valuable component of AdaLens. E felt it provided a clear overview of process progression and step-level findings, while ED particularly valued the persistent column traces and size encoding, explaining that “this size encoding is important” because it helped him see “what is mainly being analyzed here.” Both also valued the direct steering interactions. E felt that Ignore, Focus, and Elaborate made it easy to continue from visible results without composing new instructions from scratch, and ED called this form of direct manipulation “definitely better” than pure text control. Usability in real-world data analysis. Both experts familiarized themselves with the interface quickly after a brief tutorial and did not request additional help on system usage during the case studies, suggesting a low learning barrier. ED appreciated the fine-grained control over plan threads, such as terminating one thread without stopping the entire run, noting that AdaLens offered stronger support for maintaining context than his current workflow of tracking agent behavior through evolving text outputs. E felt the system suited exploratory work well and indicated he would use such a system in practice, though he noted that analysts who rely heavily on code inspection may want stronger support for following the code-level analytical process. Suggestions for Improvement. ED noted that related results can become difficult to connect when they are far apart along the timeline, explaining that “it becomes easy to get lost in the middle” and suggesting more explicit visual links between connected results. E raised a similar concern, suggesting that making inter-branch relationships more explicit, such as whether results are correlated or causally linked, would support better context management across longer runs. We discuss the broader challenge of maintaining readability and orientation in longer runs as a limitation in section VII. VI User Study We conducted a task-based user study to evaluate the usability of AdaLens and collect feedback on participants’ experiences with the system. VI-A Experiment Settings We recruited 12 undergraduate and graduate students (P1–P12; 8 male, 4 female; aged 20–26) with prior LLM and data analysis experience through a university forum. To ensure diverse perspectives, participants were drawn from varied academic disciplines across STEM (e.g., computer science, engineering), social sciences, and humanities. Each participant was compensated US$12 for their time. Procedure and Tasks. Our study procedure consisted of four stages: (1) Tutorial and Warm-up (15 mins). We first introduced the study background and AdaLens, then guided participants through a warm-up task with a video game sales dataset [54] to familiarize them with the interface and key functions. (2) Tasks (15 mins). Participants were asked to complete sequential tasks using AdaLens to analyze a student performance dataset [7]. Although limited to 15 minutes, the task phase was designed to cover the core monitoring and steering activities that arise in an evolving, multi-step run. Over the course of the run, participants needed to inspect the evolving analytical process, regulate concurrent plans, steer subsequent analysis based on visible results, and review the final output. The detailed task descriptions are provided in the supplementary material. (3) Free-form exploration (10 mins). After completing the tasks, participants were encouraged to freely use and explore the system. (4) Semi-structured interview (10 mins). Participants completed a SUS questionnaire [3] followed by a semi-structured interview regarding their experience. All sessions were screen-recorded and transcribed. VI-B Findings The average SUS score was 87.08, as shown in fig. 7, exceeding the A+A^+ rating threshold of 84.1 [51]. Following the SUS factor-structure study [31], we also separately calculated the system’s usability and learnability scores, which were 87.76 and 84.38, respectively. These scores suggest that participants found AdaLens highly usable and easy to learn. Furthermore, we analyzed the interview transcripts through thematic coding and reviewed the recordings for complementary observations of participants’ task performance and behavior. The main findings are as follows: Fig. 7: Usability results from a 5-point SUS questionnaire [3]. Negative questions (Q2, Q4, Q6, Q8, and Q10) are shown inverted for consistency. System usability and learnability. All participants (12/12) gave overall positive feedback on usability. They commonly described it as “useful”, “intuitive”, “clear”, and “easy to use”. Several participants (P2, P4, P10, P11, P12) particularly appreciated that AdaLens was feature-rich without feeling overly complex. As P2 said, “This system has quite a few features, but they are well integrated and clearly defined, so I do not find it very complex.” Regarding learnability, most participants (10/12) explicitly stated that AdaLens was easy to learn. As P5 noted, “I think this (AdaLens) was very quick to get started with, and it was easy to understand what each of its functions meant.” Nevertheless, several participants (P1, P8, P10, P12) pointed out that diverse insight glyphs and steering interactions could take some time to fully master. Observed task performance provided complementary context: 9/12 participants completed the prescribed task sequence using only the provided task instructions, whereas the remaining three required additional guidance for some operations. Observability of the analytical process. All participants (12/12) commented positively on AdaLens’s support for observing the analytical process. Many participants (P2–P4, P7, P10, P11, P12) especially appreciated how the storyline view made the stepwise process and intermediate findings visible. As P7 noted, “I could clearly see how it analyzed the data step by step, how many steps there were, and what insights it produced along the way.” Many participants (8/12) also highlighted the value of being able to inspect supporting evidence and trace the reasoning process, rather than relying solely on final textual answers. For example, P4 explained, “I could clearly see how it reasoned through each step instead of just throwing out a result, and I could immediately tell whether its direction had gone off track.” Several participants (P3, P4, P6, P11) further noted that this visibility increased their trust, confidence, or sense of control over the analytical process. Participants (P2, P5, P7, P9, P10) also appreciated how the storyline view made data-column involvement visible, helping them track which variables were used, how they were recombined across steps, and where a particular finding came from. The recordings also captured participants actively using these inspection capabilities during free-form exploration: 11/12 participants independently revisited previously generated atomic insights for closer inspection and then examined their associated data columns or supporting evidence. Steerability of the analytical process. Many participants (9/12) expressed positive sentiments regarding AdaLens’s direct steering interactions. They particularly appreciated being able to redirect the ongoing analysis by interacting with visible analytical elements. Several participants (P1, P2, P4, P6, P8, P9) described these interactions as useful for refining analysis goals on the fly. P6 summarized this benefit by noting, “I could adjust the analysis directly in the graphical interface, such as focusing on a specific insight, which was much more convenient than writing prompts myself.” Participants (P2, P8, P9) also noted that the steering actions made the relationship between intervention and subsequent analysis more visible, helping them understand how their guidance affected later steps. The recordings also captured participants actively using these steering interactions during free-form exploration: 9/12 participants independently identified analytical directions of interest in the storyline and used Focus or Elaborate to initiate follow-up analysis. Among them, five further edited the generated steering prompts to add more specific instructions. However, some participants (P7, P8) pointed out that using these interactions effectively still required users to keep up with the agent’s progress and maintain a clear understanding of the current analytical structure. Perceived contrast with chat-based workflows. In this self-reported comparison, all participants (12/12), drawing on their prior LLM-use experience, felt that AdaLens would better support long-running agentic data analysis workflows than a chat-only interface. Participants (P1, P2, P4, P6, P7, P8, P9) emphasized that it supported a different mode of work from chat-only systems. P8 described this difference succinctly: “The interaction shifts from a cycle of asking, getting a result, and then adding more conditions, to adjusting the analysis in real time through the graphical interface.” Several participants (P1, P2, P4, P7, P8, P9) noted that this reduced the need to reconstruct context or rewrite extensive prompts when continuing the analysis. Participants (P3, P4, P11, P12) further remarked that, relative to their prior experience with pure chat interfaces, AdaLens felt more grounded and trustworthy because they could inspect the running analysis rather than diagnose problems only after a final answer was produced. Suggestions. Participants also proposed several concrete suggestions for AdaLens, mainly around more explicit hints for visual elements and interactions (P1, P4, P8, P10, P11). Others focused on scalability and layout organization, recommending more compact layouts to accommodate numerous analytical elements (P2, P9), reduced visual clutter (P2, P5, P7, P9), and clearer ordering of important items (P10, P12). These suggestions highlight opportunities to further improve the learnability and usability of the system. VII Discussion In this section, we reflect on the implications and lessons learned from AdaLens, then discuss its limitations and directions for future work. Implications. We discuss this from three perspectives: Interaction paradigm. Our evaluation suggests that long-running agentic data analysis would benefit from interfaces beyond prompt–response exchanges: analysts tracked evolving run state, examined accumulated context through the storyline, and intervened mid-run, indicating that continuous monitoring and in-situ redirection are important interaction requirements for this setting. Techniques. This work extends classical storyline visualization by framing long-running agentic data analysis as an evolving narrative: plan threads are represented by plan cards that become summary cards upon completion, marking analytical events; atomic insights represent fine-grained findings nested within completed summaries; and data columns act as persistent characters whose trajectories connect the analytical events and findings that involve them. This mapping unifies analytical elements of different granularity in a temporal representation that preserves data-grounded analytical lineage across steps. To support ongoing runs rather than post-hoc histories, the progressive layout incrementally extends the storyline as new analytical elements arrive, preserving previously rendered context while maintaining visual clarity and compactness. Across the case studies, the storyline served not only as a representation for monitoring evolving analytical elements and their data-grounded lineage, but also as an interaction surface for steering the ongoing analysis. Grounding monitoring and steering in the same visible elements allowed analysts to translate what they noticed into contextualized actions. Applicability. Both the focused social-media case and the exploratory NBA case suggest that combining conversational framing with structured visual oversight can support both directed follow-up and open-ended exploration. This combination may generalize to other long-running agentic workflows, such as automated report generation or iterative model-building pipelines, where analysts similarly need to monitor evolving state and intervene selectively. Lessons learned. Four lessons emerged from the design of AdaLens. First, effective oversight benefits from semantically meaningful, multi-granular abstractions rather than exhaustive exposure of low-level traces, because analysts naturally reasoned in terms of plans, findings, and data columns. Second, observability and steerability become more coherent when they are built on the same analytical objects, allowing users to move directly from understanding to intervention without restating accumulated context elsewhere. Third, because long-running analyses expand incrementally and branch over time, layout stability is not merely presentational but essential for preserving orientation and maintaining the visibility of analytical lineage as new findings arrive. Finally, richer oversight must balance expressiveness with learnability and scalability, as participants’ feedback on insight glyphs, steering operations, and storyline density showed that expressive interfaces also require clear guidance, visual simplification, and scalable organization. Limitations and future work. (1) Our current evaluation offers an initial assessment of AdaLens through case studies and a task-based user study. While the results indicate promising support for monitoring and steering evolving, multi-step agentic data analyses, longitudinal, in-situ, and comparative studies involving analytical runs of longer duration are still needed to examine how these benefits carry over to extended real-world use. (2) AdaLens is currently instantiated in a structured-data setting, and its storyline deliberately uses recurring data columns as a persistent connective layer for representing analytical lineage. Shared columns reveal common data involvement, but they are limited in their ability to explicitly reveal other relationships among analytical elements, such as semantic relatedness, causal dependence, shared conclusions, or data provenance. Future work can extend this foundation with complementary relationships based on hypotheses, assumptions, operations, models, results, or finer-grained row-level provenance, and examine how these abstractions generalize to richer data modalities and workflows. (3) As runs become longer and denser, maintaining readability and orientation remains an important design challenge. The user feedback on more compact layouts and clearer guidance suggests opportunities to further improve scalability and usability, while the quality of the interface also depends on the quality of backend summarization. Future work could explore multiscale storyline abstractions, richer interaction feedback, and tighter integration between interface design and backend support. VIII Conclusion In this paper, we presented AdaLens, an interactive system for monitoring and steering long-running agentic data analysis. Through close collaboration with three researchers experienced in agentic data analysis, we formulated this problem and identified two key design challenges. We designed AdaLens around a storyline-based representation with a progressive layout, together with steering interactions grounded in analytical elements. Through two case studies and a user study, we examined how AdaLens supports analysts in monitoring and steering long-running agentic data analysis. References [1] T. Angert, M. Suzara, J. Han, C. Pondoc, and H. Subramonyam (2023) Spellburst: a node-based interface for exploratory creative coding with natural language prompts. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–22. External Links: Document Cited by: §I-C. [2] G. Aodeng, G. Li, Y. Feng, Q. Chen, Y. Zhang, and C. H. Liu (2025) InReAcTable: LLM-powered interactive visual data story construction from tabular data. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–16. External Links: Document Cited by: §I-C. [3] J. Brooke (1996) SUS: a “quick and dirty” usability scale. In Usability Evaluation in Industry, p. 189–194. Cited by: Fig. 7, §VI-A. [4] Y. Cai, S. Mao, W. Wu, Z. Wang, Y. Liang, T. Ge, C. Wu, W. You, T. Song, Y. Xia, N. Duan, and F. Wei (2024) Low-code LLM: graphical user interface over large language models. In Proc. Annu. Conf. North Am. Chapter Assoc. Comput. Linguist., p. 12–25. External Links: Document Cited by: §I-C. [5] J. Chen, J. Wu, J. Guo, V. Mohanty, X. Li, J. P. Ono, W. He, L. Ren, and D. Liu (2025) InterChat: enhancing generative visual analytics using multimodal interactions. Comput. Graph. Forum 44 (3), p. e70112. External Links: Document Cited by: §I-A, §I-C. [6] J. J. Y. Chung, W. Kim, K. M. Yoo, H. Lee, E. Adar, and M. Chang (2022) TaleBrush: sketching stories with generative pretrained language models. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–19. External Links: Document Cited by: §I-C. [7] P. Cortez Student Performance. Note: UC Irvine Machine Learning RepositoryAvailable: https://archive.ics.uci.edu/dataset/320/student+performance(Last accessed: Mar 27, 2026) External Links: Document Cited by: §VI-A. [8] V. Dibia (2023) LIDA: a tool for automatic generation of grammar-agnostic visualizations and infographics using large language models. In Proc. Annu. Meet. Assoc. Comput. Linguist., p. 113–126. External Links: Document Cited by: §I-A. [9] Z. Ding, M. Brachman, J. Chan, and W. Geyer (2025) “The diagram is like guardrails”: structuring GenAI-assisted hypotheses exploration with an interactive shared representation. In Proc. Conf. Creat. Cogn., p. 606–625. External Links: Document Cited by: §I-A, §I-B, §I-C. [10] Z. Ding and J. Chan (2024) Intelligent canvas: enabling design-like exploratory visual data analysis with generative AI through rapid prototyping, iteration and curation. arXiv preprint arXiv:2402.08812. External Links: Document Cited by: §I-C. [11] A. Dutta, P. Gupta, H. Hasanbeig, R. P. Singh, H. Nigam, S. Gulwani, A. Radhakrishna, G. Soares, and A. Tiwari (2025) ConDABench: interactive evaluation of language models for data analysis. arXiv preprint arXiv:2510.13835. External Links: Document Cited by: §I-A. [12] W. Epperson, G. Bansal, V. C. Dibia, A. Fourney, J. Gerrits, E. (. Zhu, and S. Amershi (2025) Interactive debugging and steering of multi-agent AI systems. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–15. External Links: Document Cited by: §I-C. [13] W. Epperson, V. Gorantla, D. Moritz, and A. Perer (2024) Dead or alive: continuous data profiling for interactive data science. IEEE Trans. Vis. Comput. Graph. 30 (1), p. 197–207. External Links: Document Cited by: §I-B. [14] S. Esmaeili, I. D. Suarez, E. Ajayi, and E. D. Ragan (2024) Empirical insights into analytic provenance summarization: a study on segmenting data analysis workflows. arXiv preprint arXiv:2410.11011. External Links: Document Cited by: §I-B. [15] K. J. K. Feng, K. Pu, M. Latzke, T. August, P. Siangliulue, J. Bragg, D. S. Weld, A. X. Zhang, and J. C. Chang (2024) Cocoa: co-planning and co-execution with AI agents. arXiv preprint arXiv:2412.10999. External Links: Document Cited by: §I-C. [16] Y. Feng, X. Wang, B. Pan, K. K. Wong, Y. Ren, S. Liu, Z. Yan, Y. Ma, H. Qu, and W. Chen (2024) XNLI: explaining and diagnosing NLI-based visual data analysis. IEEE Trans. Vis. Comput. Graph. 30 (7), p. 3813–3827. External Links: Document Cited by: §I, §I-B, §I-C. [17] S. N. Freund, B. Simon, E. D. Berger, and E. Jun (2025) Flowco: mixed-initiative authoring of reliable end-to-end data analyses via dataflow graphs and LLMs. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–20. External Links: Document Cited by: §I, §I-A, §I-B. [18] K. Gu, M. Grunde-McLaughlin, A. McNutt, J. Heer, and T. Althoff (2024) How do data analysts respond to AI assistance? A Wizard-of-Oz study. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–22. External Links: Document Cited by: §I-C. [19] K. Gu, R. Shang, T. Althoff, C. Wang, and S. M. Drucker (2024) How do analysts understand and verify AI-assisted data analyses?. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–22. External Links: Document Cited by: §I-A, §I-C. [20] S. Hong, Y. Lin, B. Liu, B. Liu, B. Wu, C. Zhang, D. Li, J. Chen, J. Zhang, J. Wang, L. Zhang, L. Zhang, M. Yang, M. Zhuge, T. Guo, T. Zhou, W. Tao, R. Tang, X. Lu, X. Zheng, X. Liang, Y. Fei, Y. Cheng, Y. Ni, Z. Gou, Z. Xu, Y. Luo, and C. Wu (2025) Data Interpreter: an LLM agent for data science. In Find. Assoc. Comput. Linguist., p. 19796–19821. External Links: Document Cited by: §I-A. [21] M. N. Hoque, T. Mashiat, B. Ghai, C. D. Shelton, F. Chevalier, K. Kraus, and N. Elmqvist (2024) The HaLLMark effect: supporting provenance and transparent use of large language models in writing with interactive visualization. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–15. External Links: Document Cited by: §I-C. [22] X. Hu, Z. Zhao, S. Wei, Z. Chai, Q. Ma, G. Wang, X. Wang, J. Su, J. Xu, M. Zhu, Y. Cheng, J. Yuan, J. Li, K. Kuang, Y. Yang, H. Yang, and F. Wu (2024) InfiAgent-DABench: evaluating agents on data analysis tasks. In Proc. Int. Conf. Mach. Learn., p. 19544–19572. Cited by: §I-A. [23] O. Huang, M. Fatir, S. Luo, S. Suh, H. Subramonyam, and C. Nobre (2025) Narrative scaffolding: a narrative-first framework for data-driven sensemaking. arXiv preprint arXiv:2512.18920. External Links: Document Cited by: §I-B, §I-C. [24] Z. Huang, S. Gutierrez, H. Kamana, and S. Macneil (2023) Memory Sandbox: transparent and interactive memory management for conversational agents. In Adjun. Proc. ACM Symp. User Interface Softw. Technol., p. 1–3. External Links: Document Cited by: §I-C. [25] M. S. Islam, M. T. R. Laskar, M. R. Parvez, E. Hoque, and S. Joty (2024) DataNarrative: automated data-driven storytelling with visualizations and texts. In Proc. Conf. Empir. Methods Nat. Lang. Process., p. 19253–19286. External Links: Document Cited by: §I-A. [26] P. Jiang, J. Rayan, S. P. Dow, and H. Xia (2023) Graphologue: exploring large language model responses with interactive diagrams. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–20. External Links: Document Cited by: §I-C. [27] Julius AI Julius AI: excel, slides, tasks with ai. Note: Julius AIAvailable: https://julius.ai/(Last accessed: Mar 27, 2026) Cited by: §I. [28] M. Kazemitabaar, J. Williams, I. Drosos, T. Grossman, A. Z. Henley, C. Negreanu, and A. Sarkar (2024) Improving steering and verification in AI-assisted data analysis with interactive task decomposition. In Proc. ACM Symp. User Interface Softw. Technol., External Links: Document Cited by: §I, §I-C. [29] M. B. Kery, B. E. John, P. O’Flaherty, A. Horvath, and B. A. Myers (2019) Towards effective foraging by data scientists to find past analysis choices. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–13. External Links: Document Cited by: §I-B. [30] F. Lei, J. Meng, Y. Huang, J. Zhao, Y. Zhang, J. Luo, X. Zou, R. Yang, W. Shi, Y. Gao, S. He, Z. Wang, Q. Liu, Y. Wang, K. Wang, J. Zhao, and K. Liu (2025) DAComp: benchmarking data agents across the full data intelligence lifecycle. arXiv preprint arXiv:2512.04324. External Links: Document Cited by: §I-A. [31] J. R. Lewis and J. Sauro (2009) The factor structure of the system usability scale. In Proc. Int. Conf. Hum. Centered Des., p. 94–103. External Links: Document Cited by: §VI-B. [32] J. Li, N. Huo, Y. Gao, J. Shi, Y. Zhao, G. Qu, Y. Wu, C. Ma, J. Lou, and R. Cheng (2024) Tapilot-Crossing: benchmarking and evolving LLMs towards interactive data analysis agents. arXiv preprint arXiv:2403.05307. External Links: Document Cited by: §I-A. [33] S. Li, X. Chen, Y. Song, Y. Song, and C. Zhang (2024) Prompt4Vis: prompting large language models with example mining and schema filtering for tabular data visualization. arXiv preprint arXiv:2402.07909. External Links: Document Cited by: §I-A. [34] S. Liu, Y. Wu, E. Wei, M. Liu, and Y. Liu (2013) StoryFlow: tracking the evolution of stories. IEEE Trans. Vis. Comput. Graph. 19 (12), p. 2436–2445. External Links: Document Cited by: §IV-B1. [35] Z. Liu, X. Xie, M. He, W. Zhao, Y. Wu, L. Cheng, H. Zhang, and Y. Wu (2025) Smartboard: visual exploration of team tactics with LLM agent. IEEE Trans. Vis. Comput. Graph. 31 (1), p. 23–33. External Links: Document Cited by: §I-C. [36] P. Ma, R. Ding, S. Wang, S. Han, and D. Zhang (2023) InsightPilot: an LLM-empowered automated data exploration system. In Proc. Conf. Empir. Methods Nat. Lang. Process., p. 346–352. External Links: Document Cited by: §I, §I-A. [37] Q. Ma, K. Koedinger, and T. Wu (2025) Not everyone wins with LLMs: behavioral patterns and pedagogical implications for AI literacy in programmatic data science. arXiv preprint arXiv:2509.21890. External Links: Document Cited by: §I-A. [38] K. Madanagopal, E. D. Ragan, and P. Benjamin (2019) Analytic provenance in practice: the role of provenance in real-world visualization and data analysis environments. IEEE Comput. Graph. Appl. 39 (6), p. 30–45. External Links: Document Cited by: §I-B. [39] B. P. Majumder, H. Surana, D. Agarwal, S. Hazra, A. Sabharwal, and P. Clark (2024) Position: data-driven discovery with large generative models. In Proc. Int. Conf. Mach. Learn., p. 34350–34382. Cited by: §I. [40] A. Manatkar, A. Akella, P. Gupta, and K. Narayanam (2024) QUIS: question-guided insights generation for automated exploratory data analysis. In Proc. Conf. Empir. Methods Nat. Lang. Process., p. 1523–1535. External Links: Document Cited by: §I, §I-A. [41] D. Masson, S. Malacria, G. Casiez, and D. Vogel (2024) DirectGPT: a direct manipulation interface to interact with large language models. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–16. External Links: Document Cited by: §I-C. [42] H. Mozannar, G. Bansal, C. Tan, A. Fourney, V. Dibia, J. Chen, J. Gerrits, T. Payne, M. K. Maldaner, M. Grunde-McLaughlin, E. Zhu, G. Bassman, J. Alber, P. Chang, R. Loynd, F. Niedtner, E. Kamar, M. Murad, R. Hosn, and S. Amershi (2025) Magentic-UI: towards human-in-the-loop agentic systems. arXiv preprint arXiv:2507.22358. External Links: Document Cited by: §I-C. [43] A. Narechania, A. Fourney, B. Lee, and G. Ramos (2021) DIY: assessing the correctness of natural language to SQL systems. In Proc. ACM Int. Conf. Intell. User Interfaces, p. 597–607. External Links: Document Cited by: §I-B. [44] P. H. Nguyen, K. Xu, A. Wheat, B. L. W. Wong, S. Attfield, and B. Fields (2016) SensePath: understanding the sensemaking process through analytic provenance. IEEE Trans. Vis. Comput. Graph. 22 (1), p. 41–50. External Links: Document Cited by: §I-B. [45] OpenAI (2022) Introducing ChatGPT. Note: OpenAIAvailable: https://openai.com/index/chatgpt/(Last accessed: Mar 27, 2026) Cited by: §I. [46] M. H. Payandeh, L. Yuan, and J. Zhao (2025) NoteEx: interactive visual context manipulation for LLM-assisted exploratory data analysis in computational notebooks. arXiv preprint arXiv:2511.07223. External Links: Document Cited by: §I-A, §I-B, §I-C. [47] X. Pu, S. Kross, J. M. Hofman, and D. G. Goldstein (2021) Datamations: animated explanations of data analysis pipelines. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–14. External Links: Document Cited by: §I-B. [48] W. Qian, C. Gao, A. Sathya, R. Suzuki, and K. Nakagaki (2024) SHAPE-IT: exploring text-to-shape-display for generative shape-changing behaviors with LLMs. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–29. External Links: Document Cited by: §I-C. [49] E. D. Ragan, A. Endert, J. Sanyal, and J. Chen (2016) Characterizing provenance in visualization and data analysis: an organizational framework of provenance types and purposes. IEEE Trans. Vis. Comput. Graph. 22 (1), p. 31–40. External Links: Document Cited by: §I-B. [50] G. Sahu, A. Puri, J. A. Rodriguez, A. Abaskohi, M. Chegini, A. Drouin, P. Taslakian, V. Zantedeschi, A. Lacoste, D. Vazquez, N. Chapados, C. Pal, S. Rajeswar, and I. H. Laradji (2025) InsightBench: evaluating business analytics agents through multi-step insight generation. In Proc. Int. Conf. Learn. Represent., Cited by: §I-A. [51] J. Sauro (2011) Measuring usability with the system usability scale (SUS). Note: MeasuringUAvailable: https://measuringu.com/sus(Last accessed: Mar 27, 2026) Cited by: §VI-B. [52] M. Sedlmair, M. D. Meyer, and T. Munzner (2012) Design study methodology: reflections from the trenches and the stacks. IEEE Trans. Vis. Comput. Graph. 18 (12), p. 2431–2440. External Links: Document Cited by: §I. [53] H. Shen, T. Knearem, R. Ghosh, K. Alkiek, K. Krishna, Y. Liu, Z. Ma, S. Petridis, Y. Peng, L. Qiwei, S. Rakshit, C. Si, Y. Xie, J. P. Bigham, F. Bentley, J. Chai, Z. Lipton, Q. Mei, R. Mihalcea, M. Terry, D. Yang, M. R. Morris, P. Resnick, and D. Jurgens (2024) Position: towards bidirectional human-AI alignment. arXiv preprint arXiv:2406.09264. External Links: Document Cited by: §I-C. [54] G. Smith Video Games Sales. Note: ZenodoAvailable: https://zenodo.org/records/5898311(Last accessed: Mar 27, 2026) External Links: Document Cited by: §VI-A. [55] A. Srinivasan and V. Setlur (2021) Snowy: recommending utterances for conversational visual analysis. In Proc. ACM Symp. User Interface Softw. Technol., p. 864–880. External Links: Document Cited by: §I-B. [56] H. Subramonyam, R. Pea, C. Pondoc, M. Agrawala, and C. Seifert (2024) Bridging the gulf of envisioning: cognitive challenges in prompt based interactions with LLMs. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–19. External Links: Document Cited by: §I-C. [57] S. Suh, M. Chen, B. Min, T. J. Li, and H. Xia (2024) Luminate: structured generation and exploration of design space with large language models for human-AI co-creation. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–26. External Links: Document Cited by: §I-C. [58] S. Suh, B. Min, S. Palani, and H. Xia (2023) Sensecape: enabling multilevel exploration and sensemaking with large language models. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–18. External Links: Document Cited by: §I-C. [59] J. Sun, G. Li, P. Zhou, Y. Ma, J. Xu, and Y. Li (2025) AgenticData: an agentic data analytics system for heterogeneous data. arXiv preprint arXiv:2508.05002. External Links: Document Cited by: §I-A. [60] M. Sun, Y. Xie, Y. Wu, R. Han, B. Jiang, D. Sun, Y. Yuan, and J. Huang (2026) DSAEval: evaluating data science agents on a wide range of real-world data science problems. arXiv preprint arXiv:2601.13591. External Links: Document Cited by: §I-A. [61] Y. Tanahashi and K. Ma (2012) Design considerations for optimizing storyline visualizations. IEEE Trans. Vis. Comput. Graph. 18 (12), p. 2679–2688. External Links: Document Cited by: §IV-B1. [62] T. Tang, S. Rubab, J. Lai, W. Cui, L. Yu, and Y. Wu (2019) iStoryline: effective convergence to hand-drawn storylines. IEEE Trans. Vis. Comput. Graph. 25 (1), p. 769–778. External Links: Document Cited by: §IV-B1. [63] L. Tankelevitch, V. Kewenig, A. Simkute, A. E. Scott, A. Sarkar, A. Sellen, and S. Rintel (2024) The metacognitive demands and opportunities of generative AI. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–24. External Links: Document Cited by: §I-C. [64] Y. Tian, D. Deng, S. Yang, H. Zheng, B. Shi, K. Xiong, X. Yi, and Y. Wu (2025) NoteFlow: recommending charts as sight glasses for tracing data flow in computational notebooks. arXiv preprint arXiv:2502.02326. External Links: Document Cited by: §I-B. [65] Y. Tian, C. Zhang, X. Wang, S. Pan, W. Cui, H. Zhang, D. Deng, and Y. Wu (2025) ReSpark: leveraging previous data reports as references to generate new reports with LLMs. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–18. External Links: Document Cited by: §I-A, §I-C. [66] P. Vaithilingam, E. L. Glassman, J. P. Inala, and C. Wang (2024) DynaVis: dynamically synthesized UI widgets for visualization editing. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–17. External Links: Document Cited by: §I-C. [67] AI Data Visualization & Analytics Platform. Note: vizGPTAvailable: https://vizgpt.ai/(Last accessed: Mar 27, 2026) Cited by: §I-A. [68] C. Wang, B. Lee, S. M. Drucker, D. Marshall, and J. Gao (2025) Data Formulator 2: iterative creation of data visualizations, with AI transforming data along the way. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–17. External Links: Document Cited by: §I-A, §I-B, §I-C. [69] C. Wang, J. Thompson, and B. Lee (2024) Data Formulator: AI-powered concept-driven visualization authoring. IEEE Trans. Vis. Comput. Graph. 30 (1), p. 1128–1138. External Links: Document Cited by: §I-C. [70] H. W. Wang, L. Birnbaum, and V. Setlur (2025) Jupybara: operationalizing a design space for actionable data analysis and storytelling with LLMs. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–24. External Links: Document Cited by: §I-A, §I-C. [71] Y. Wang, Z. Sun, H. Zhang, W. Cui, K. Xu, X. Ma, and D. Zhang (2020) DataShot: automatic generation of fact sheets from tabular data. IEEE Trans. Vis. Comput. Graph. 26 (1), p. 895–905. External Links: Document Cited by: §IV-B1. [72] Z. Wen, L. Weng, Y. Tang, R. Zhang, Y. Liu, B. Pan, M. Zhu, and W. Chen (2025) Exploring multimodal prompt for visualization authoring with large language models. arXiv preprint arXiv:2504.13700. External Links: Document Cited by: §I-C. [73] L. Weng, X. Wang, J. Lu, Y. Feng, Y. Liu, H. Feng, D. Huang, and W. Chen (2025) InsightLens: augmenting LLM-powered data analysis with interactive insight management and navigation. IEEE Trans. Vis. Comput. Graph. 31 (6), p. 3719–3732. External Links: Document Cited by: §I, §I-B, §IV-B1. [74] T. Wu, M. Terry, and C. J. Cai (2022) AI chains: transparent and controllable human-AI interaction by chaining large language model prompts. In Proc. ACM CHI Conf. Hum. Factors Comput. Syst., p. 1–22. External Links: Document Cited by: §I-C. [75] L. Xie, C. Zheng, H. Xia, H. Qu, and C. Zhu-Tian (2024) WaitGPT: monitoring and steering conversational LLM agent in data analysis with on-the-fly code visualization. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–14. External Links: Document Cited by: §I, §I-B, §I-C. [76] W. Xu, Y. Mao, X. Zhang, C. Zhang, X. Dong, M. Zhang, and Y. Gao (2025) DAgent: a relational database-driven data analysis report generation agent. arXiv preprint arXiv:2503.13269. External Links: Document Cited by: §I-A. [77] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao (2023) ReAct: synergizing reasoning and acting in language models. In Proc. Int. Conf. Learn. Represent., Cited by: §IV-A. [78] R. Yen, J. S. Zhu, S. Suh, H. Xia, and J. Zhao (2024) CoLadder: manipulating code generation via multi-level blocks. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–20. External Links: Document Cited by: §I-C. [79] S. Zhang, J. Fan, M. Fan, G. Li, and X. Du (2025) DeepAnalyze: agentic large language models for autonomous data science. arXiv preprint arXiv:2510.16872. External Links: Document Cited by: §I, §I-A. [80] W. Zhang, L. Shen, S. Xu, J. Wang, J. Zhao, H. Qu, and L. Yuan (2025) NeuroSync: intent-aware code-based problem solving via direct LLM understanding modification. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–19. External Links: Document Cited by: §I-C. [81] Y. Zhao, X. Shu, L. Fan, L. Gao, Y. Zhang, and S. Chen (2026) ProactiveVA: proactive visual analytics with LLM-based UI agent. IEEE Trans. Vis. Comput. Graph. 32 (1), p. 451–461. External Links: Document Cited by: §I-C. [82] Y. Zhao, J. Wang, L. Xiang, X. Zhang, Z. Guo, C. Turkay, Y. Zhang, and S. Chen (2025) LightVA: lightweight visual analytics with LLM-agent-based task planning and execution. IEEE Trans. Vis. Comput. Graph. 31 (9), p. 6162–6177. External Links: Document Cited by: §I, §I, §I-A, §I-B, §I-C. [83] J. Zhu, X. Cheng, Z. Luo, Y. Zhou, X. Shu, D. Weng, and Y. Wu (2025) ViseGPT: towards better alignment of LLM-generated data wrangling scripts and user prompts. In Proc. ACM Symp. User Interface Softw. Technol., p. 1–16. External Links: Document Cited by: §I-B, §I-C. [84] Y. Zhu, L. Wang, C. Yang, X. Lin, B. Li, W. Zhou, X. Liu, Z. Peng, T. Luo, Y. Li, C. Chai, C. Chen, S. Di, J. Fan, J. Sun, N. Tang, F. Tsung, J. Wang, C. Wu, Y. Xu, S. Zhang, Y. Zhang, X. Zhou, G. Li, and Y. Luo (2025) A survey of data agents: emerging paradigm or overstated hype?. arXiv preprint arXiv:2510.23587. External Links: Document Cited by: §I, §I-A. [85] C. Zhu-Tian, Z. Xiong, X. Yao, and E. Glassman (2024) Sketch then generate: providing incremental user feedback and guiding LLM code generation through language-oriented code sketches. arXiv preprint arXiv:2405.03998. External Links: Document Cited by: §I-C.

Instant research discovery