1 Introduction↩︎

Multimodal large language models (MLLMs) are increasingly being used to power agentic visualization systems, where (semi-)autonomous agents convert natural-language requests into concrete visualization actions [1]–[4]. Scientific visualization (SciVis) transforms complex scientific data, such as volumes, meshes, flow fields, and molecular structures, into interpretable visual representations for analysis and discovery. As simulations and instruments generate increasingly complex data, SciVis has become essential for exploring, validating, and communicating findings across disciplines such as physics, biology, climate science, and materials science. In SciVis, tasks often require long, multi-step workflows combining domain knowledge and tool interaction. At the same time, the emergence of the model context protocol (MCP) [5] has made complex visualization tools more accessible by enabling agents to interact with software via structured interfaces. Recent MCP agents [6]–[9] and agentic systems [10]–[12] have demonstrated the feasibility of long-horizon SciVis workflows.

Alongside these domain-specific systems, general-purpose coding agents are becoming increasingly capable. These agents can already execute commands, inspect files, write code, and iteratively refine outputs. Rather than building a custom agent for every tool or task, one can start from a strong general-purpose harness and adapt it to SciVis workflows through procedural guidance. This motivates our central question: how can general-purpose agents be equipped with the domain knowledge needed for effective and efficient scientific data analysis and visualization?

One promising answer is the use of agent skills. An agent skill is a structured package of instructions, code templates, references, and verification logic that augments agent behavior at inference time without changing model parameters [13]. Agent skills capture procedural knowledge such as recommended workflows, environment-specific conventions, software usage patterns, and domain heuristics. In this sense, agent skills serve as a reusable layer between a base model and a specialized application domain: foundation models provide general capabilities, agent harnesses manage context and tool execution, and agent skills inject task- and domain-specific expertise.

The broader agent skill ecosystem has expanded rapidly, with community repositories now hosting thousands of user-contributed agent skills for software engineering, analysis, and enterprise workflows. Prior work suggests that general-purpose coding agents such as Claude Code [14], Codex [15], and Gemini CLI [16] are already competitive on long-horizon visualization tasks, and that agent skills can further improve both success rate and efficiency [17]. Recent work also compares interaction paradigms for SciVis agents and shows tradeoffs among structured tool use, CLI- or GUI-based general interaction, and persistent memory [18]. Despite this momentum, SciVis remains underexplored from the perspective of reusable agent skills. There are still a few published skills tailored to core SciVis workflows, and limited evidence on how portable skills behave across different tools, harnesses, and task types.

To address this gap, we present SciVisAgentSkills, a collection of agent skills designed specifically for scientific data analysis and visualization. Our agent skills target core operations across several representative SciVis environments, including basic operations such as volume rendering, isosurface extraction, flow visualization, and scientific plotting in ParaView [19], molecular visualization in VMD [20], bioimage visualization in napari [21], and topology visualization in TTK [22]. We build on SciVisAgentBench, which introduced a napari skill case study and baseline measurements for coding agents [17]. We release a broader multi-tool skill collection, document the common design protocol used to produce it, and evaluate its behavior across agents, task suites, and token budgets. Finally, we evaluate Claude Code and Codex on SciVisAgentBench [17] with and without these agent skills. Our results show higher mean benchmark scores with skills across the evaluated suites, while token usage varies by agent harness and tool. More broadly, we position this paper as both an empirical study of SciVis skills in current coding-agent harnesses and a call for collaboration on building a reusable skill ecosystem for scientific data analysis and visualization.

2 Related Work↩︎

Agent evaluation and agent skills. General-agent benchmarks such as AgentBench [23], GAIA [24], and \(\tau\)-bench [25] evaluate multi-turn reasoning and tool use, but treat visualization as a generic task and do not capture multi-step SciVis workflows or domain-specific interpretation. Recent work on agent skills [26], [27] instead models agent behavior as reusable procedural modules loaded at inference time. SkillsBench [28] shows that curated skills improve performance, while self-generated skills are often unreliable; prior analysis [29] further shows that existing skill ecosystems remain concentrated in software engineering.

Agentic workflows for visualization. Dhanoa et al. [1] frame this space as agentic visualization, balancing automation and analyst control. Existing systems include conversational and collaborative analysis tools (VOICE [30], IntuiTF [31], CoDA [32]), tool-centered SciVis assistants (AVA [2], ChatVis [3], ParaView-MCP [6]), and more autonomous or multi-agent workflows (VizGenie [11], NLI4VolVis [10], TexGS-VolVis [33], InferA [12], SASAV [4], VIS co-scientist [34]). Vonderhorst et al. [18] further compare interaction paradigms for SciVis agents, including structured tool use, CLI/GUI interaction, and persistent memory. While these systems demonstrate the promise of agentic SciVis, most are tailored to specific tools, interfaces, or applications. We instead focus on portable agent skills that improve general-purpose coding agents across multiple SciVis tools.

Agentic visualization evaluation. Existing evaluations focus on charts, plotting code, or human literacy rather than long-horizon SciVis agents. VisEval [35] and Drawing Pandas [36] study chart understanding and code generation, while LIDA [37] introduces visualization-specific metrics and SVLAT [38] measures human SciVis literacy. Ai et al. [39] call for systematic evaluation of agentic SciVis. In response, NL2SciVis [40] introduces a benchmark for evaluating natural-language-driven SciVis in ParaView through atomic operations with deterministic validation. SciVisAgentBench [17] further extends this direction to multi-step tasks spanning data analysis, tool use, and end-to-end SciVis workflows, and serves as the testbed for our study of agent skills.

3 SciVisAgentSkills: Design and Evaluation↩︎

Agent skills for SciVis tools. To enable general-purpose coding agents to operate effectively in SciVis environments, we design a set of domain-specific agent skills tailored to four representative tools: ParaView [19], napari [21], VMD [20], and TTK [22]. These tools collectively cover core SciVis workflows, bioimage analysis, molecular visualization, and topology visualization.

Our design is motivated by several recurring failure modes observed when general-purpose coding agents interact with these tools. Even in well-configured environments, agents often spend multiple turns probing libraries and execution settings, leading to unnecessary overhead. Due to incomplete grounding in tool-specific documentation, agents may misuse APIs or follow incorrect usage patterns. We also observe errors in output generation, such as capturing the entire napari GUI rather than the visualization viewport. These issues highlight the need for structured, domain-aware guidance beyond generic coding ability.

To address these challenges, we construct agent skills that encode environment assumptions, usage conventions, and best practices for each tool. We fix software versions and specify the execution environment, including dependencies and runtime constraints. This reduces ambiguity and redundant exploration. We then distill official documentation into structured usage patterns that guide agent behavior. To further ground execution, we incorporate representative code snippets and function usage patterns from existing SciVis agents, including ParaView-MCP [6], BioImage-Agent [7], GMX-VMD-MCP [8], and TopoPilot [9]. These examples provide references for common workflows and reduce trial-and-error during task execution. We also incorporate constraints from empirical observations, such as enforcing headless rendering and capturing outputs from the visualization viewport.

We therefore define an agent skill operationally as a self-contained, version-pinned procedural module for one SciVis tool, constructed through a unified process that combines environment specification, documentation alignment, executable exemplars, and failure-aware refinements. Following this process, we develop four agent skills corresponding to ParaView, napari, VMD, and TTK. Each skill encapsulates procedural knowledge for interacting with the target tool, providing a reusable layer that enables general-purpose coding agents to execute SciVis tasks more reliably and efficiently.

Skill format and construction. All four skills follow the agent skill format [13]: YAML frontmatter for discovery, followed by Markdown guidance that includes usage rules, script templates, API summaries, and troubleshooting notes. The ParaView skill additionally includes separate reference files because its API surface is larger. In the context of coding agents, this structure supports progressive disclosure, where the skill metadata is checked first, and the body and references are loaded only when relevant.

The skills were manually authored by visualization researchers and refined through several rounds of observing agents on representative SciVis workflows. Refinements targeted recurring tool-use failures, such as incorrect headless rendering and API misuse. To avoid benchmark leakage, the skills contain only tool-general procedural knowledge, including environment assumptions, documented API patterns, and reusable examples. They do not include benchmark-specific solutions, expected outputs, hidden labels, or evaluation rubrics. Exemplars are adapted from official documentation and public SciVis agent code [6]–[9]. Before evaluation, the authors reviewed and tested each skill for correctness and safe headless execution in sandboxes.

Evaluating agent skills on SciVisAgentBench. We evaluate the effectiveness of our agent skills by comparing Codex and Claude Code with and without skills on SciVisAgentBench [17], a benchmark designed for realistic, multi-step SciVis workflows. Unlike prior benchmarks that focus on short-horizon or 2D visualization tasks, SciVisAgentBench comprises 108 expert-crafted cases spanning diverse domains, data types, and visualization operations, with an emphasis on outcome-centric evaluation.

The benchmark includes five task suites. The ParaView visualization suite focuses on core operations, including volume rendering, isosurface extraction, flow visualization, and data analysis. Additional suites target molecular visualization (VMD), bioimage visualization (napari), and topology visualization (TTK). An object identification suite further evaluates whether agents can construct visualizations from anonymized volumetric data and infer the underlying object category from visual evidence, using the benchmark’s hidden labels and case-specific rubrics for outcome evaluation. Representative examples are shown in Figure 1.

SciVisAgentBench provides a suitable testbed for agent skills because its tasks are grounded in real tools and require coordinated, multi-step workflows, making performance sensitive to procedural knowledge. Its outcome-centric evaluation framework, combining multimodal LLM judges and deterministic metrics, enables reliable comparison of execution quality and efficiency without relying on unstable trajectory-level analysis.

Each task suite aligns naturally with one of our SciVisAgentSkills: the ParaView skill supports ParaView visualization and object identification; the napari skill targets bioimage visualization; the VMD skill supports molecular visualization; and the TTK skill addresses topology visualization. This alignment enables a direct with-versus-without comparison of domain-specific guidance under the same benchmark protocol.

width=

width=

width=

4 Experiments↩︎

Prior work shows that general-purpose coding agents, specifically Codex and Claude Code, can outperform many domain-specific SciVis agents [17]. We evaluate SciVisAgentSkills by comparing both agents with and without skills across all five task suites of SciVisAgentBench.

Each configuration is executed over three independent trials using the standardized evaluation pipeline of SciVisAgentBench, which combines multimodal LLM judges, image-based metrics, code validators, rule-based checks, and case-specific evaluators for outcome-based assessment. Table [tab:main95results] and Figure 2 report the primary results using Claude-Opus-4.6 as the judge, which has been shown to align well with human SciVis expert assessments [17]. Completion rate measures whether runs terminate without execution errors, while pass metrics additionally require valid outputs (e.g., correctly saved, non-empty visualizations), providing a stricter measure of task success. Figure 2 reports pass@\({1,2,3}\) and pass\(^{{1,2,3}}\) to characterize run-to-run consistency. For ParaView tasks, we additionally report image-based quality metrics (PSNR, SSIM, and LPIPS) in Table [tab:paraview95image95metrics], using scaled aggregates to avoid overestimating partially completed results.

Overall, incorporating agent skills consistently improves performance across all task suites for the overall score, though the magnitude of improvement varies by task type and agent. The largest improvement is in Claude Code’s topology visualization (about 60%). More broadly, weaker baselines tend to benefit more from skills, highlighting the value of procedural guidance in challenging settings. Completion rate does not always follow the same trend as score: for example, Codex on object identification improves in overall score but drops from \(92.59\pm9.80\) to \(80.25\pm5.66\) in completion rate, indicating that skills can improve output quality while still introducing additional execution paths that sometimes fail.

We also analyze token usage in Table [tab:token95cost95all95parts]. For Claude Code, output tokens decrease consistently, and input tokens decrease for bioimage, topology, and object identification while increasing for molecular visualization. In contrast, Codex shows mixed trends, with increased token usage in bioimage and molecular visualization. Because the same skill content can reduce tokens in Claude Code but increase them in Codex, we interpret token cost as a property of the interaction among skill content, model behavior, and harness-level context management rather than as a property of skill verbosity alone. Overall, we do not observe a clear correlation between token usage and performance.

5 Discussion↩︎

Skills, CLI, and MCP. Skills, CLI access, and MCP-based tool calls are orthogonal design axes. A skill is a knowledge layer that describes how to use a CLI, a Python API, an MCP server, or a combination of these interfaces. Interactions through CLI are typically more flexible and token-efficient, and their performance further improves when augmented with agent skills that encode tool usage patterns. In contrast, protocols like MCP provide more structured and constrained interfaces, which can improve reliability but often at the cost of higher token usage and reduced generalization across tasks. Our experiments do not directly isolate CLI-MCP interaction paradigms. Rather, they demonstrate that procedural knowledge encoded as skills can improve agent performance regardless of the underlying interaction interface. A systematic comparison of CLI- and MCP-based interaction is beyond the scope of this work and has been investigated separately in recent SciVis agent studies [18].

When do skills help, and when do they fail? Our four skills share a common recipe: fix the tool version, distill official documentation, reuse SciVis agent exemplars, and encode empirical fixes. Viewed more broadly, this recipe can be interpreted as a form of procedural knowledge distillation for scientific software. Rather than relying on agents to repeatedly rediscover environment assumptions, API conventions, and common failure modes during execution, agent skills externalize this knowledge into reusable artifacts that can be shared across tasks and users. This perspective may provide a useful framework for building skills beyond the specific tools studied here.

Across tasks, however, we see two recurring limits. First, gains may be limited when the base model already handles well-documented tools effectively; for example, Claude Code shows only modest improvement over VMD for molecular visualization with skills. Second, the interaction between skills and the underlying agent harness appears to be model-dependent. While Codex shows increased token usage on molecular and bioimage tasks, the same skills substantially reduce token usage for Claude Code. This suggests that token cost is not determined solely by skill verbosity. Instead, it likely depends on how the agent retrieves, caches, and reuses skill content during execution. Claude Code appears to benefit from more efficient use of skills, whereas Codex may repeatedly revisit skill content during planning and verification. Understanding these interactions remains an important direction for future work.

We also observe that skill benefits vary substantially across task suites. The largest improvements occur in topology visualization, object identification, and ParaView workflows, which require multi-step reasoning and involve APIs or workflow patterns that are less commonly represented in the training of foundation models. In contrast, gains in molecular visualization are smaller, particularly for Claude Code, suggesting that strong foundation models may already possess substantial knowledge of mature and widely documented tools such as VMD. These results indicate that agent skills are most valuable when procedural knowledge is specialized, fragmented across sources, or poorly represented in the model’s training data.

Beyond skills: the role of the agent harness. Agent skills alone are not sufficient to support long-horizon workflows. Recent work on agent harness design emphasizes that reliable agents depend on the surrounding system that manages execution, context, and recovery [41]. In particular, long-running agents require persistent state (e.g., progress tracking), structured interaction protocols, and mechanisms for incremental execution and rollback to maintain consistency across sessions [42]. Recent work on AI VIS co-scientists further demonstrates that complex SciVis tasks benefit from specialized harness components, including orchestrators, domain-specific subagents, evaluation loops, memory systems, and tool integrations that coordinate end-to-end workflows [34]. From this perspective, skills act as reusable procedural knowledge, while the harness provides the infrastructure for planning, memory, and control. Future work should therefore study skills and harnesses jointly, rather than in isolation.

Call for collaboration. We view this work as a starting point toward a broader ecosystem of agent skills for scientific data analysis and visualization. Beyond the performance improvements themselves, the consistent gains observed across ParaView, napari, VMD, and TTK suggest that agent skills can generalize across substantially different scientific software ecosystems rather than being tied to a single tool. We invite the community to contribute new skills, share evaluation cases, and explore how skill design interacts with agent harnesses in real-world, long-horizon workflows.

6 Conclusions↩︎

We present SciVisAgentSkills, a set of domain-specific agent skills that enhance general-purpose coding agents for scientific data analysis and visualization. Experiments on SciVisAgentBench show that these skills improve mean performance across diverse tools and task types, while token usage depends on the agent harness and how skill context is managed. Our results suggest that improving long-horizon agent performance is not solely a matter of stronger models, but also of better procedural knowledge and system harness design. In particular, we believe that agent skills offer a low-cost and extensible entry point for improving practical agent performance in complex scientific settings.

References↩︎