CoDA: Agentic Systems for Collaborative Data Visualization
Authors: Zichen Chen
Jiefeng Chen
Sercan O Arik
Misha Sra
Tomas Pfister
Jinsung Yoon
Venue: ICLR 2026 Poster (2026)
Keywords: LLM
multi-agent system
visualization
Primary area: foundation or frontier models, including LLMs

Abstract: Deep research has revolutionized data analysis, yet data scientists still devote substantial time to manually crafting visualizations, highlighting the need for robust automation from natural language queries. However, current systems struggle with complex datasets containing multiple files and iterative refinement. Existing approaches, including simple single- or multi-agent systems, often oversimplify
the task, focusing on initial query parsing while failing to robustly manage data complexity, code errors, or final visualization quality. In this paper, we reframe this challenge as a collaborative multi-agent problem. We introduce CoDA, a multi-agent system that employs specialized LLM agents for metadata analysis, task planning, code generation, and self-reflection. We formalize this pipeline, demonstrating how metadata-focused analysis bypasses token limits and quality-driven refinement ensures robustness. Extensive evaluations show CoDA achieves substantial gains in the overall score, outperforming competitive baselines by up to 41.5%. This work demonstrates that the future of visualization automation lies not in isolated code generation but in integrated, collaborative agentic workflows.

Published as a conference paper at ICLR 2026
CoDA: AGENTIC SYSTEMS FOR COLLABORATIVE DATA VISUALIZATION
Zichen Chen UC Santa Barbara zichen_chen@ucsb. edu
Jiefeng Chen
Sercan Ö. Arik Google soar iearikggogle.com com
Google Cloud Al Research
jiefengc@google. com
Misha Sra
Tomas Pfister & Jinsung Yoon
UC Santa Barbara
Google Cloud Al Research
sraêcs. ucsb. edu
(tpfister, jiinsungyonn@googgee.cooo
https: .i Aohubb.o//CDA/
ABSTRACT
Deep research has revolutionized data analysis, yet data scientists still devote substantial time manually crafting visualizations, highlighting the need for robust automation from natural language queries. However, current systems struggle with complex datasets containing multiple files and iterative refinement. Existing approaches, including simple single- multi-agent systems, often oversimplify the task, focusing on initial query parsing while failing to robustly manage data complexity, code errors, final visualization quality. In this paper, we reframe this challenge as a collaborative multi-agent problem. We introduce CoDA, a multi-agent system that employs specialized LLM agents for metadata analysis, task planning, code generation, and self-reflection. We formalize this pipeline, demonstrating how eetaaata--ocussee analysis bypasses token limits and quality- driven refinement ensures robustness. Extensive evaluations show CoDA achieves substantial gains in the overall score, outperforming competitive baselines by up 41.5%. This work demonstrates that the future of visualization automation lies not in isolated code generation but integrated, collaborative agentic workflows.
INTRODUCTION
Data visualization plays an important role business intelligence, data science and decision-making, enabling professionals to uncover insights from complex datasets through intuitive graphical rep- resentations (Ramesh & Rajabiyazdi, 2024; Gahar et al., 2024; Jambor, 2024; Beschi et al., 2025; Rogers al., 2024). In practice, data analysts might spend over two-thirds of their time low-level data preparation and visualization tasks, often iterating manually to achieve clarity, accuracy, and aesthetic appeal (Lai et al., 2025; Rezig et al., 2021; Lee et al., 2021). This "unseen tax" diverts focus from insight generation, highlighting the critical need for automated systems that can transform natural language queries and complex data into effective visualizations (Wu al., 2024; Chen et al., 2024; Wang & Crespo-Quee Quiroonuuin.s.... 2023). With the rise of large language models (LLMs) (Naveed al., 2025; Achiam et al., 2023; Team et al., 2024; Comanici et al., 2025), there immense potential to automate this pipeline. However, realizing this potential requires addressing core challenges: (1) handling large datasets, (2) coordinating diverse expertise (e.g.. linguistics, statistics, design), and (3) incorporating iterative feedback to refine outputs against real-world complexities like messy multi-file data and complex visualization needs.
Current approaches automate visualization suffer from various limitations. Traditional rule-based systems, such as Voyager (Wongsuphasawat et al., 2017; 2016) and Draco (Yang et al., 2023), formalize design knowledge constraints but remain confined predefined templates, struggling with natural language queries or diverse data patterns (Wu et al., 2024: Hoque & Islam, 2025). LLM- based methods, like CoML4VIS (Chen al., 2024), leverage chain-of-thouug prompting generate visualizations (Comanici et al., 2025), but often ingest raw data directly, risking token limit violations, hallucinations, and failures on multi-source data (Bai al., 2024; Chen al., 2024). Multi-agent
This work done while Zichen was research intern Google Cloud AT Research.

---

Published as a conference paper at ICLR 2026
Input Query
Ground Truth
MatplotAgent
VisPath
COMLAVIS
Gecerate Pytnon
acripe That
plo. upand
Elaud aeed
gererati lon to
reprocicibsitty
LUM Eva luater
100 / 100
25 109 (X]
45 / 100 (X)
35 100 (X)
90 / 100
M
topographae the elevation teon "data, riaueliout.o
IMAGE COMING FAILED
asructured in..
(X0
1X0
100
Greate plot aide-by aidd pie
bar chast nith
deta: let pie regresents the distributiinn
LLM Evaluator
188 / 100
78 / 180 (X)
65 / 108 (30
35 / 180 (XI
95 / 188
based "data Jean",
of eneicy in (7Ah) conta-ns
file
IMAGE COMING
IMAGE COMING
IMAGE
COMING
100
Figure 1: Qualitative comparison of visualizations generated by baselines (MatplotAgent VisPath, CoML4VIS) and CoDA. Provided with a natural language query and data files (if has), models produce code to create plots. CoDA yields outputs that more faithfully capture complex patterns, chart types, and aesthetics, while baselines often fail on ambiguity, 3D structures, or multi-source integration.
frameworks, such as VisPath and MatplotAgent, introduce collaboration system to generate plot code but lack metadata-focused analysis, leading brittle data processing and poor robustness under iterative refinement (Seo et al., 2025; Yang et al., 2024b). We argue these issues stem from a common limitation in current agentic visualization systems: they concentrate reasoning and coordination on initial query parsing, which proves insufficient for handling complex data environments (e.g., multiple and large files), code errors, and iterative refinement. This design limits their ability adapt to unexpected data challenges.
To address these challenges and limitations, we propose CoDA (Collaborative Data-visualization Agents), a multi-agent system that advances visualization automation through self-evolving pipeline where agents specialize in understanding, planning, generating, and reflecting. By analyzing metadata schemas and statistics without raw data file uploads, we circumvent the context window limits of LLMs: specialized agents enhance domain reasoning; and image- evaluation assesses output quality from human-centric perspective. This builds robust framework for complex, iterative, and multi-source agentic visualizations, where agents collaborate deeply to ensure visualization quality. The key contributions of this work
follows:
We propose CoDA, an extensible framework with specialized agents for metadata analysis, task planning, code generation and debugging, and self-reflection, enabling robust handling of complex data and visualization needs (see Figure and Appendix B for qualitative analyses). Extensive experiments stantial gains in the overall score over strong baselines such as MatplotAgent, VisPath, and COML4VIS. with maximum improvements of 24.5%. 41.5% and 26.5%, 66,%, respectively. Further-
MatplotBench and Qwen Code Interpreter benchmarks yield sub-
2

---

Published as a conference paper at ICLR 2026
more, CoDA significantly outperforms competitive baselines the DA-Code benchmark, which
features complex, real-world software engineering scenarios.
A comprchensive ablation study validates the necessity of CoDA's components. Results demonstrate that self-evolution, the global TODO list, and the example search agent each provide statistically significant positive impact on overall performance.
2
RELATED WORK
Natural Language to Visualization (NL2Vis). NL2Vis approaches have revolutionized data ex- ploration data science by allowing users to articulate queries in natural language and receive target visualizations (Wang & Crespo-Quinones, 2023; Shen et al., 2022; Wu et al., 2024), thereby accelerating initial data scouting and ad-hoc reporting (Voigt et al., 2022). A survey on natural lan- guage generation for visualizations provides taxonomy of techniques and highlights the challenges in ensuring coherence and fidelity to underlying data information (Hoque & Islam, 2025). Many methods have formalized this evaluation landscape (Chen al., 2024; Ouyang et al., 2025; Bai et al., 2025; Shin et al., 2025) and use chain-of-thought prompting strategies to enhance LLM accuracy on single-table tasks (Liu al., 2025). These tools are important for data scientists navigating the exploratory phase (Zhang et al., 2025; Chen et al., 2025), but they exhibit gaps in LLM reasoning under ambiguity or multi-source data environments (Zhu al., 2025; Davila et al., 2025). Empir- ical evaluations of LLMS in visualization generation reveal shortcomings in CoT-bbsee methods, emphasizing the need for robust handling of abstract and multifaceted queries in decision-making workflows (Khan et al., 2025), motivating our shift toward autonomous multi-agent teams.
Agentic Visualization Systems. Agentic systems mark paradigm shift in visualization for data science, framing it as distributed problem-solve process among AI agents that mirror collaborative human co-workers (Sapkota et al., 2025; Tran et al., 2025; Wolter et al., 2025; Xu et al., 2025). Goswami al. (2025) and Zhang & Elhamod (2025) exemplify this by deploying multi-agent LLM frameworks for autonomous professional visualization, streamlining visual analytics from raw, unstructured data. Yang al. (2024b) introduce multi-step reasoning agent framework for scientific plotting, empowering data scientists with code-free handling of complex visualizations. Seo et al. (2025) enhance this through multi-path reasoning and feedback optimization for code synthesis from natural language. Efforts to extract agent-based design patterns from visualization systems provide a blueprint for balancing autonomy with human oversight, laying groundwork for scalable tools in collaborative data environments (Dhanoa et al., 2025). These agentic systems help compress hours of manual labor in data science (Moss, 2025; Gridach et al., 2025). However, they commonly take shortcuts, focusing adaptations on initial planning stages without persistent reflection (Wang et al., 2025; Sapkota et al., 2025). This shallow agentic alignment contributes to vulnerabilities in complex scenarios (Cemri al., 2025; Tian et al., 2025). Our proposed multi-agent system counters this by enforcing deeper collaboration, via specialized agents for planning, building, criticism, and reflection, yield robust narratives.
3 METHOD
In this section, we formalize the collaborative multi-agent paradigm for data visualization and introduce CoDA. We begin by outlining the key design principles that support agentic visualization systems, drawing parallels to human collaborative workflows in data analysis and plotting. We then describe CoDA's architecture, including the specialized agents and their interactions, and explain how this framework addresses core challenges in automated visualization.
3.1 THE COLLABORATIVE MULTI-AGENT PARADIGM
Conventional visualization systems, whether rule-based or LLM-driven (Khan et al., 2025; Zhu et al., 2025; Hutchinson et al., 2024; Shin et al., 2025), typically treat visualization monolithic, single-pase process of parsing a query, ingesting data, and generating code. This leads to unstable performance on complex queries involving multi-file datasets, ambiguous requirements, or iterative refinements. We reframe visualization as a collaborative mooblem-solvin endeavor. Our approach employs team of specialized LLM agents, each with a distinct professional persona, that uses
3

---

Published as a conference paper at ICLR 2026
Understanding
Planning
Wiite Pyttes script cenpoend sloe cennr catt Maguaat
Compaced Contt
Styliay
Ure
Google
Teat: we Search
Trar aeraffomation
sull
Virklapping Agent
Search Agent
Inputa
Query Analyoer
Besign Saet
Orioe
tats Inda
Jana Stape
Colamatix's
Eestos Recomordating
Implmertattcor Guidelzze
Tedicators
insights
Input Date
Dara Processor
Design Exploror
Flaad Lade
Hreal mg search
Pewekctttyy ctartty,
FAN PHOINE M
succutiinn mecaltt
Daso
Overlas, tayen, motd ploe.
Priority Froes
Generator
Debug Agent
Generated Plat
Visual Evalustor
Poot
Reterte
Generation
Self Roffection
Figure 2: Overview of the CoDA framework for agentic data visualization. The workflow decomposes natural language queries into modular phases: Understanding (query intent and data metadata extraction), Planning (example code search, visual mappings, and design optimization), Generation (code generation and debugging), and Self- Leff-Reflecton (quality evaluation with feedback loops for self-reflection refinement).
structured communication and quality-driven feedback loops to decompose queries, process data, and iteratively refine outputs.
Inspired by multi-agent systems in software engineering (Yang al., 2024a) and interactive reason- ing (Yao et al., 2022), this paradigm leverages the emergent capabilities of LLMs to simulate division of labor. Each agent designed focus on a well-defined expertise area, such as metadata extraction or code debugging, while communicating via shared state to adapt dynamically. This not only mitigates token limits by avoiding raw data ingestion but also enhances robustness through reflection and error correction, mirroring how data analysts collaborate to refine insights. Key principles guiding this approach include:
Specialization for Depth: Assign agents to distinct roles (e.g., planning vs. execution) to deepen reasoning without overwhelming single model.
Metadata-Centes Preprocessing: Summarize data structures upfront to inform downstream deci- sions, bypassing the need for full data loading.
Iterative Reflection: Incorporate human-like evaluation of outputs (e.g., via image analysis) to detect and correct issues like visual clutter or factual inaccuracies.
Modular Extensibility: Design agents as interchangeable modules, allowing integration of new tools or models for evolving tasks.
By unifying query understanding, data handling, code generation, and quality assurance into self-refiection workflow, this approach transforms visualization from isolated code generation into a resilient, adaptive process. We demonstrate its efficacy through CoDA, which operationalizes these principles for real-world benchmarks.
3.2
CoDA: COLLABORATIVE DATA VISUALIZATION AGENTS
CoDA instantiates the collaborative paradigm multi-agent system that takes natural language query and data files as input, producing refined visualization as output. Figure 2 provides high- level overview and Table 1 summarizes the inputs and outputs of different agents in the workflow. Full agent prompts and I/O are shown in Appendix F.
The workflow proceeds as follows, with iterative refinement triggered by quality assessments: The Query Analyzer interprets the query (c.g.. "Plot sales trends by region" ") to extract intent, decomposes it into global TODO list (e.g., data filtering, aggregation, chart selection), and generates guidelines
4

---

Published as a conference paper at ICLR 2026
Table I: Inputs and outputs of different agents in the proposed CoDA framework.
Agent Name
Inputs
Outputs
Query Analyzer
Query; meta_data
(c.g..
Visualization types; key points for plotting; global TODO list.
README.
Data Processor
Data inputs
Data info (e.g., shapes, columns); ); insights (e-g-, ligregations_needeee processing steps; visu- alization hints.
VizMapping Agent
Query; query analyzer, data pro- cessor results
Chart types; styling hints; transformations (c.g.. aggregations, filters); visualization goals.
Search Agent
Visualization types; chart types Query analyzer; data processor results
Code examples.
Design Explorer
Design specifics (e.g.. volor_scheeee Layout); implementation guidelines: quality metries; de- sign recommendations; alternatives; success indi- cators.
Code Generator
Design explorer; data processor; search agent; visual evaluator Code generator results
Generated code; code quality score; dependencics; documentation.
Debug Agent
Debugging outputs/errors: web-searched fixes: corrected code; execution results: output file.
Visual Evaluator
Output file; query; analyzer, pro- cessor results
Scores (c.g., overall_ _cooe, readabi lity); strengths; issues; priority fixes; modifications; rec- ommendations.
for downstream agents. The Data Processor extracts metadata summaries (schemas, statisties, patterns) from data files using lightweight tools like pandas, avoiding token limits while identifying insights and potential transformations. The VizMapping Agent maps query semantics to visualization primitives, selects appropriate chart types (e.g., line chart for trends), defines data-to-visual bindings, and validates compatibility based on metadata. This agent ensures insightful outputs that adapt to data complexitics without raw ingestion. The Search Agent (as a tool) retrieves relevant code examples from plotting libraries (e.g., Matplotlib) to inspire generation, formulates search queries and ranks results by relevance. The Design Explorer generates content and aesthetic concepts, optimizes elements like colors and layout, and evaluates designs for user experience. The Code Generator synthesizes executable Python code integrating specifications, ensuring best practices and documentation. The Debug Agent executes code with timeouts, diagnoses solutions), applies fixes (potentially via searched solutions), and outputs results like visualization images. The Visual Evaluator assesses the output image across multi-dimensional quality metrics (clarity, accuracy, aesthetics, layout, correctness), verifying TODO completion and suggesting refinements.
(e.g., via searched
Agents exchange structured messages through a shared memory buffer, propagating context (e.g.. metadata informs planning, plans guide code). Feedback loops trigger self-reflection: If quality scores (from evaluation) are below thresholds, issues are routed back to upstream agents (e.g., low aesthetics back to the Design Explorer). The system halts when quality converges or reflection limits are reached. CoDA's 's modular design promotes scalability-agent can be parallelized extended robustness through quality-drivee halting (c.g., stopping when
(c.g., for scientific plotting)- scores exceed thresholds). In experiments (Section 4), this yields substantial gains over baselines, validating the value of this agentic approach in visualization automation.
4 EXPERIMENTS
We evaluate CoDA's ability to generate high-quality visualizations from natural language by testing it on a diverse set of visualization benchmarks. We compare CoDA against state-of-the-an baselines using standardized metrics that capture execution reliability, visualization correctness. and overall task success. All experiments are conducted using gemini-2.5-pre as the underlying LLM, with a maximum of refinement iterations and quality threshold of 0g 0.85 for halting.
5

---

Published as a conference paper at ICLR 2026
4.1 BENCHMARKS
We select benchmarks that span varying levels of complexity in natural language to visualization tasks, including handling diverse data types, chart styles, and user intents. The primary datasets are:
Qwen Code Interpreter Benchmark (Visualization) (Yang et al., 2025): This subset focuses on visualization tasks within code interpretation framework, with 163 examples emphasizing numerical data handling, pattern recognition, and code synthesis for plots. It tests robustness to ambiguous queries and data inconsistencies.
MatplotBench (Yang et al., 2024b): A comprehensive benchmark for matplotibb-assd visualization generation, comprising 100 queries across domains such as time-series analysis, categorical compar- isons, and multi-diment diteesiiimn plotting. Queries require interpreting user intent, selecting appropriate chart types, and ensuring visual clarity.
These benchmarks represent mid-to-high complexity tasks suitable for evaluating agentic systems in controlled environments. Additionally, we separately evaluate on the more challenging DA- Code benchmark (Huang al., 2024), which involves repository-based software engineering tasks with visualization components. Unlike the above, DA-Code (vis) requires navigating codebases, integrating visualizations into broader workflows, and handling domain-specific constraints (e.g.. performance optimization in plots). It comprises 78 tasks and is treated independently due to its elevated difficulty and shift toward SWE-oriented reasoning.
4.2 BASELINES
We compare CoDA against recent visualization-specife methods that leverage LLMs for code genera- tion and refinement:
MatplotAgent (Yang et al., 2024b): A single-agent system focused on matplotlib code synthesis from queries, with basic error handling but limited multi-step planning.
VisPath (Seo et al., 2025): An approach based on multiple solution planning that decomposes visualization tasks into sequential steps, emphasizing path optimization for chart mapping.
CoML4VIS (Chen et al., 2024): A workflow-cent centric framework that follows structured pipeline to generate visualizations, incorporating table descriptions and code execution.
All baselines use the same gemini-2.5-pe 5-pro backhone for fair comparison, and we follow their papers to set up the parameters (e.g., iteration limits).
4.3 EVALUATION METRICS
To provide a multi-dimensional assessment, we define three key metrics that capture execution reliability, visualization quality, and overall task success:
Execution Pass Rate (EPR): The proportion of queries for which the generated Python code executes without runtime errors, capturing basic syntactic and dependency reliability. Formally, EPR IgeQ:exer(e,. sancess
where Cg is the code for query E Q.
[0]
Visualization Success Rate (VSR): The average score reflecting the quality of rendered visualizations among executable codes, where higher scores indicate closer alignment with intended representations
(e.g., accurate data mappings). Formally, VSR Eneque s.(() where s. (q) is the LLMMevaluated Quael visualization score for query q, and Qexes is set of queries with successful execution. On binary-scored benchmark (e.g., Qwen Code Interpreter), VSR reduces to the proportion of correct visualizations among executable cases.
Overall Score (OS): The overall score reflects the average of code and visualization quality scores and provides a holistic view of system effectiveness. Formally, OS Egeo (v)(=.(0)...(0)) where (g) is the code quality score and s,) is defined above.
Additional technical details on the judging prompts and model setup are provided in Appendix We emphasize that all reported metrics computed against benchmark ground truth; the Visual

---

Published as a conference paper at ICLR 2026
Table 2: Performance comparison against three baselines on the MatplotBench and Qwen Code as the base LLMs.
Interpreter benchmarks. All baselines utilize gemini
MatplotBench
Qwen Code Interpreter
Method
EPR (%)
VSR (%) f
OS (%)
EPR (%)
VSR (%) 1
OS (%)
MatplotAgent
97.0
56.7
55.0
81.6
79.7
65.0
VisPath
75.0
37.3
86.5
94.3
81.6
CoML4VIS
76.0
69.7
53.0
87.1
90.9
79.1
CoDA (Ours)
99.0
79.8
79.5
93.3
95.4
89.0
Table 3: Comparison of CoDA against DS-STAR (Nam al., 2025) and DA-Agent (Huang et al., 2024) on the DA-Code benchmark, where DA-Agent is powered by various LLMs including gemini-2.5 5-pro, gpt-4o, gpt-4, and deepseek-coder. Green shading marks the best within each group.
CoDA (Ours)
DS-STAR
DA-Agent (backbone LLM)
Metric
Gemini-2. 5-pro
Gemini-2. 5-pro
Gemini-2.5-por
GPT-4o
GPT-4
Deepseck-Coder
Overall Score (%)
39.0
20.5
19.23
17.0
16.0
11.0
Evaluator within CoDA serves solely as internal guidance signal for self-refinement and is not used as an evaluation metric.
4.4 MAIN RESULTS
Table presents the main results MatplotBench and the Qwen Code Interpreter Benchmark (vis). CoDA outperforms all baselines across metrics, achieving substantial gains in OS of 24.5% on MatplotBench and 7.4% Qwen over the best alternative, demonstrating superior handling of complex queries through agent collaboration and feedback loops. The high EPR reflects robust code generation, while VSR highlights effective refinement in visualization quality.
4.5 RESULTS DA-CODE BENCHMARK
In this evaluation, we extend CoDA to more complex, real-world SWE scenarios where visualizations are embedded within broader codebases. Table summarizes these findings, revealing CoDA's 's score of 39.0%, 9.77% absolute gain over DA-Agen with Compared to DS-STAR (Nam et al., 2025), a recent state-of-the-ar data-science agent system, CoDA achieves nearly 2x the overall score (39.0% vs. 20.5%). This superiority arises from the multi- agent decomposition: the Query Analyzer routes repo navigation subtasks to the Data Processor for metadata extraction, while the Code Generator and Visual Evaluator iteratively resolve integration conflicts (e.g., matplotlib dependencies clashing with existing imports). The overall score benefits particularly from the Design Explorer's aesthetic refinements tailored to code-embedded plots. These refinements address nuances like subplot scaling in simulation outputs, which single-I.LM baselines overlook due token limits on raw repo ingestion.
the strongest baseline.
4.6 PERFORMANCE WITH DIFFERENT BACKBONE LLMS
To assess the generality of CoDA across diverse LIM backbones, evaluate its performance when sub- stituting the primary gemini-2.. 5-pro with alternative strong capability I.LMs: gemini-2.5-f11 claude-4-sonnet. and the open-source Qwen3-VL (Yang et al., 2025). This experiment isolates the impact of the backbone LLM on visualization generation, holding constant the multi-agent architecture. We focus on the MatplotBench, it emphasizes robust handling of numerical data, pattern recognition, and code synthesis under ambiguous queries- tasks that stress the backbone's 's reasoning and code generation capabilities.
We select these backbones for their complementary strengths: gemini-2 5-flash priori- tizes efficiency and low-latency inference, making it suitable for real-time applications, while
7

---

Published as a conference paper at ICLR 2026
Table 4: comparison of CoDA with different backbone LLMs against three baselines on the MatplotBench benchmark. All results are presented in percent (%)
Base LLMs
Gemini-2.5-Pro
Gemini-2.5-
Claude-4-Soneet
Qwen3-VI
Method
EPR
VSR 1
0S
EPR
VSR
OS f
EPR
VSR
OS
EPR 1
VSR
05
MarplotAgent
92.0
55.4
51.0
99.0
46.4
45.9
93.0
58.8
54.7
86.0
69.9
60.1
VisPath
73.0
60.5
44.2
95.0
45.8
43.5
57.0
77.5
44.2
55.2
43.6
COMLAVIS
99.0
63.2
62.6
99.0
57.8
57.2
99.0
65.9
65.2
73.0
62.1
45.3
CoDA (Ours)
80.3
79.5
99.0
78.5
77.7
98.0
76.7
75.2
79.2
73.7
claude-4-sonnet excels in language understanding and multi-step reasoning, potentially en- hancing agent collaboration in complex scenarios. All models are configured with identical hy- perparameters. Table 4 presents the results. CoDA with gemini-2. 5-flashh achieves an OS of 77.7%, showcasing efficient handling of real-time scenarios with minimal degradation (1.8% rel- ative to 1omini-2.5-pro) attributable to streamlined agent interactions that leverage metadata over raw data ingestion. claude-4-sonnet, conversely, attains OS of 75.2%, 4.3% drop from gemini-2. 5-pro, likely stemming from its enhanced semantic parsing but reduced robustness in code execution under high-context loads. These outcomes highlight CoDA's ' backbone- -agnostic design, amplifying each LLM's inherent strengths while mitigating weaknesses through collaborative work- flows. To further validate this generality beyond proprietary models, we evaluate with the open-source Qwen3-VL (Yang et al., 2025). As shown in Table 4, CoDA consistently achieves the highest scores, improving over the strongest baseline (MatplotAgent) by +7.0% EPR, +9.3% VSR, and +13.6% OS. both proprietary and open-source, text-centric
The consistency across four model Ponnilessssaannne and vision- lassun-language architectures confirms that the performance gains stem from the collaborative multi-agent design rather than any single backbone's capabilities.
We compare CoDA against the baselines using the three backbone LLMs as described above. Across the board, CoDA outperforms baselines significantly, with the best-performing variant, CoDA with gemini-2 22 5-pro achieving 79.5% OS. MatplotAgent, VisPath, and CoML4VVS struggle to exceed 65.2% OS in any setting, highlighting the challenges of visualization tasks without multi-agent refinement. We also observe that CoDA trends similarly across different backbones, with EPR and VSR remaining consistently high (98.0-99.09 .0% and 76. 76.3%....%
LLMs tend to generate simpler visualizations. Baseline-generatee code tends to produce fewer refinements than CoDA, As shown in Table 4, compared CoDA, baselines like MatplotAgent achieve lower VSR (46.4-58.8%) and rarely handle complex multi- multi-faceted queries.
4.7 EFFICIENCY ANALYSIS
A key challenge in agentic systems is balancing accuracy with computational efficiency, particularly in real-world visualization tasks where latency impacts user experience. Here, we conduct a detailed efficiency analysis of CoDA, comparing its latency against baselines the MatplotBench dataset. We measure latency in terms of (1) average number of input/output tokens per query, which captures the communication overhead in multi-agent interactions, and (2) average number of LLM calls, reflecting the iterative refinement and routing demands. All methods use gemini-2 5- as the backbone.
Table 5 presents the results. CoDA achieves an average of 32,095 input tokens, 18, 124 output tokens, and 14.8 LLM calls per query. We compare CoDA against baselines on efficiency. Across the board, multi-agent systems like CoDA and MatplotAgent incur higher computational costs than simpler baselines like CoMI4VIS and VisPath, which rely on fewer iterations and less collaborative overhead. However, CoDA outperforms MatplotAgent efficiency, using 17.6% fewer total tokens (50,219 vs. 60,969) and 3.9% fewer LLM calls, while achieving substantially higher overall accuracy (79.5% vs. 51.0% OS). In terms of wall-clock time, CoDA averages 849.3 s per instance compared to 990.6 for MatplotAgent, further demonstrating that the collaborative multi-agent design achieves stronger results with lower end-to-end latency than comparable agentic baselines.
To analyze the trade-off between efficiency and performance, we observe that simpler methods trend toward lower costs but diminished visualization quality. For example, CoML4VIS, with only 1.0 L.M call and 6, 138 total tokens, resolves 62.6% OS, yet struggles with complex, ambiguous queries
8

---

Published as a conference paper at ICLR 2026
Table 5: Efficiency comparison on MatplolBench using gemini-2.5-pro. Metrics: Average In-
put/Output Tokens (# Tokens), Average LLM Calls (#f Calls), and Average Wall-Clock Time per instance (# Time).
Method # Input Tokens
# Output Tokens
# Calls
#'ime (s) 1
MatplotAgent
34,177
26,792
15.4
990.6
VisPath
16,224
13,056
7.0
311.2
CoML4VIS
2,350
3,788
1.0
36.1
CoDA (Ours)
32,095
18,124
14.8
849.3
Table 6: Human expert evaluation on MatplotBench. Elo: overall preference rating (initialized at 1500) derived from pairwise judgments. Remaining columns: mean of 1-5 Likert ratings across five aesthetic dimensions.
Method Elo
Harmony
Balance f
Color
Simplicity
Query Al,
MatplotAgent
1506
3.65
3.65
3.52
1.22
3.63
VisPath
1484
2.71
2.71 1..80
2,65
2.92:11.99
2.78
CoML4VIS
1309
3.16-1.24
3.22
3.22
4.00
3.59
CoDA (Ours)
1701
4.82 40.39
4.73 -0.53
4.96 4027
4.94
4.86 -0.40
requiring refinement. In contrast, CoDA's higher calls enable iterative improvements, justiifi the cost for superior results.
4.8 HUMAN EXPERT EVALUATION
To complement the automated metrics, we conduct human evaluation with three domain experts: visualization and interaction design specialist and two data-analysis practitioners, each with several years of experience creating charts in professional settings. The study covers 200 visualiza- tions (50 MatplotBench instances 4 methods). Each expert provides pairwise overall-preference judgments and rates every output on 1-5 Likert scale across five aesthetic dimensions (definitions Appendix C).
From the pairwise judgments, we derive Elo ratings (Elo, 1966) following the protocol of Chiang al. (2024). As shown in Table 6, CoDA attains the highest Elo rating by a substantial margin and achieves the highest mean score on every aesthetic dimension, with notably lower variance than all baselines. These results demonstrate that the iterative self-reflection mechanism improves not only benchmark accuracy but also the perceived visual quality of the generated visualizations.
ABLATION STUDY
To validate the contributions key components in CoDA, we conduct controlled ablation experiments on the MatplotBench dataset, using gemini-2.5-pre
the backbone. These studies isolate the impact of (I) iterative self-reflection through refinement loops, (2) the global TODO list for high-level planning, and (3) the Search Agent for code example retrieval. All ablations maintain the multi- agent pipeline but adjust the specified components. This analysis not only confirms the necessity of each feature but also provides insights into design trade-offs, such
balances, highlighting CoDA's principled architecture for robust and autonomous visualization. We evaluate the impact of these components on the OS metric. Figure 3 summarizes the findings.
5.1 IMPACT OF SELF-EVOLUTION
Figure 3 shows that OS generally improves with additional iterations, from 75.6% at iteration to 79.5% at 3 iterations (CoDA default), with further gains to 80.1% 9% at 5 iterations, though with fluctuations and marginal benefits beyond 3 (+0.6% in OS from to 5). EPR increases by 8.0% from 1 to 3 iterations due to robust initial code generation by the Code Generator, stabilizing 100%

---

Published as a conference paper at ICLR 2026
Gooa
15.0
120
$6.0
78.5
753
(a) Iterations Ablation
(b) Global TODO Ablation
(c) Search Agent Ablation
Figure 3: Ablation results. (a): Performance (EPR, VSR, OS) across different iteration counts. (b) Comparison of EPR. VSR, and OS with without Global TODO. (c) Comparison of EPR, VSR, and OS with vs. without the Search Agent.
thereafter. VSR fluctuates initially but converges around 80%, as the Visual Evaluator identifies and refines subtle mismatches in data mappings and aesthetics. Beyond iterations, latency increases without proportional accuracy benefits, validating our lightweight configuration optimization that tunes limits based on validation performance. With minimal iterations, performance degrades toward baseline levels, emphasizing that shallow, one-shot generation fails in messy environments.
5.2 ROLE OF GLOBAL TODO LIST
The global TODO list, generated by the Query Analyzer, serves as a high-level blueprint for task decomposition and routing, ensuring coherence across agents. We ablate this by replacing it with inveerstandinggueer--eee
prompts (no structured decomposition). As shown in Figure 3, removing the global TODO list yields stark drop in OS to 75.1% 1% (-4.4% absolute), with EPR falling by 5.0% due fragmented intent extraction, c.g.. the VizMapping Agent selects suboptimal chart types without cross-referencing subtasks like "highlight peaks." " VSR remains stable, indicating that visual quality is less dependent on global planning, but overall success suffers from incomplete workflows, such as unaddressed statistical insights from the Data Processor. This confirms the value of structured planning in agentic workflows, where prevents the noise of unstructured agent interactions.
5.3 EFFECTIVENESS OF EXAMPLE SEARCH AGENT
The Search Agent retrieves relevant plotting code examples (e.g., from Matplotlib repositories) to inspire the Code Generator, addressing L.MM limitations in recalling domain-specifie syntax. We study this by disabling retrieval, relying solely on the backbone LLM's M internal knowledge. Figure reveals that without the Search Agent, OS declines to 76.0% (-3.5%), primarily due 9.0% drop in EPR from syntactic errors in specialized visualizations (e.g., custom subplots). Enabling code search improves accuracy by providing ranked snippets, grounding LLM agents' coding knowledge to specific problems. This ablation highlights the extensibility of CoDA, where external inspiration bridges gaps LLM training data, making the system more reliable without post-training.
6 CONCLUSION
We introduce CoDA, an agentic multi-agent framework that decomposes natural language queries into specialized stages-tar task and data understanding, planning, code generation, and self-reflection- delivering up to 41.5% overall score gains over baselines like MatplotAgent gent,, VisPath, and COMI4VIS on MatplotBench and Qwen benchmarks. Through metadata-centric preprocessing and self-reflection refinement, CoDA overcomes input token limits, robustly managing messy multi-file data and enabling analysts to prioritize insights over manual work. A key limitation is the computational overhead from multi-tum agent communications. Future efforts could distill agents or adapt multimodal inputs. CoDA paves the way for collaborative agentic systems, revolutionizing automation in data science and beyond.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGMENTS
The authors would like to thank Jun Yan and Zhangchen Xu for the helpful discussion and comments on the work.
REFERENCES
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, llge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et Gpt-4 technical report. arXiv preprint arXiv:2303.08874, 2023.
Tian Bai. Huiyan Ying, Kailong Suo. Junqiu Wei, Tao Fan, and Yuanfeng Song. Text-to- trajvis: Enabling trajectory data visualizations from natural language questions. arXiv preprint arXiv:2504. 16358, 2025.
Zechen Bai, Pichao Wang, Tianjun Xiao, Tong He, Zongbo Han, Zheng Zhang, and Mike Zheng Shou. Hallucination of multimodal large language models: A survey. arXiv preprint arXiv:2404. 18930, 2024.
Sara Beschi, Davide Falessi, Silvia Golia, and Angela Locoro. Characterizing data visualization literacy: a systematic literature review. arXiv preprint WrXiv:2503.14466 2025.
Mert Cemri, Melissa Pan, Shuyi Yang, Lakshya A Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, et al. Why do multi-agent Ilm systems fail? arXiv preprint arXiv:2503.1 1.n::2333.33337 13657, 2025.
Nan Chen, Yuge Zhang, Jiahang Xu, Kan Ren, and Yuqing Yang. Viseval: benchmark for data visualization in the era of large language models. IEEE Transactions on Visualization and Computer Graphics, 2024.
Qiguang Chen, Mingda Yang, Libo Qin, Jinhao Liu, Zheng Yan, Jiannan Guan, Dengyun Peng, Yiyan Ji, Hamjing Li, Mengkang Hu, et al. Ai4research: A survey of artificial intelligence for scientific research. arXiv preprint arXiv:2507.01900 2025.
Wei-Lin Chiang. Lianmin Zheng, Ying Sheng, Anastasios Nikolas Angelopoulos, Tianle Li, Dacheng Li, Banghua Zhu, Hao Zhang, Michael Jordan, Joseph E Gonzalez, al. Chatbot arena: An open platform for evaluating Ilms by human preference. In Forty-first International Conference Machine Learning, 2024.
Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Marcel Blistein, Ori Ram, Dan Zhang, Evan Rosen, et al. Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities. arXiv preprint arXiv: 2025.
Ana Davila, Jacinto Colan, and Yasuhisa Hasegawa. Beyond single models: Enhancing Ilm detection of ambiguity in requests through debate. arXiv preprint arXiv:2507. 12370, 2025.
Vaishali Dhanoa, Anton Wolter, Gabriela Molina León, Hans-Jörg Schulz, and Niklas Elmqvist. Agentic visualization: Extracting agent-based design patterns from visualization systems. arXiv preprint 2505 2025.
Arpad Elo. The USCF rating system: Its development, theory, and applications. United States Chess Federation, 1966.
Rania Mkhinini Gahar, Olfa Arfaoui, and Minyar Sassi Hidri. Open research issues and tools for visualization and big data analytics. arXiv preprint arXiv:2404.1252 2024.
Kanika Goswami, Puneet Mathur, Ryan Rossi, and Franck Dernoncourt. Plotgen: Multi-agent
I1m- based scientific data visualization via multimodal feedback. arXiv preprint arXiv:2502.00988 2025.
11

---

Published as a conference paper at ICLR 2026
Mourad Gridach, Jay Nanavati, Khaldoun Zine El Abidine, Lenon Mendes, and Christina Mack. Agentic ai for scientific discovery: A survey of progress, challenges, and future directions. arXiv preprint arXiv:2503.0891 2025.
Enamul Hoque and Saidul Islam. Natural language generation for visualizations: State of the art, challenges and future directions. In Computer Graphics Forum, volume 44, pp. e15266. Wiley Online Library, 2025.
Yiming Huang, Jianwen Luo, Yan Yu, Yitong Zhang, Fangyu Lei, Yifan Wei, Shizhu He, Lifu Huang, Xiao Liu, Jun Zhao, and Kang Liu. Da-code: Agent data science code generation benchmark for large language models. In Conference Empirical Methods in Natural Language Processing, 2024. URL http:::/app..sssniticchoooo.. www.oggg//oooo wergg/oorpus::::00 273334033.
Maeve Hutchinson, Radu Jianu, Aidan Slingsby, and Pranava Swaroop Madhyastha. Llm-assisted visual analytics: Opportunities and challenges. Comput. Graph., 130:104246, 2024. URL
https://api semanticscholar. wtt.://oo.....rro/ooouro//221171
Helena Klara Jambor. From zero to figure hero. a checklist for designing scientific data visualizations. arXiv preprint arXiv:2408. 2024.
Saadiq Rauf Khan, Vinit Chandak, and Sougata Mukherjea. Evaluating Ilms for visualization generation and understanding. Discover Data, 3(1):15, 2025.
Eugenie Y. Lai, Yuze Lou, Brit Youngmann, and Michael J. Cafarella. Toward standardized data preparation: bottom-up approach. In EDBT, pp. 609-622, 2025. URL https://doi. org/10 48786/edbt.200 2025. 49.
Ga Young Lee, Lubna Alzamil, Bakhtiyar Doskenov, and Arash Termehchy. A survey on data cleaning methods for improved machine learning model performance. arXiv preprint arXiv:2109.07/12 2021.
Si- Yang Liu, Qile Zhou, and Han-Jia Ye. Make still further progress: Chain of thoughts for tabular data leaderboard. arXiv preprint arXiv:2505. 13421, 2025.
Adam Moss. The ai cosmologist i: An agentic system for automated data analysis. arXiv preprint 23X1:22004.03244, 2025.
Jaehyun Nam, Jinsung Yoon, Jiefeng Chen, and Tomas Pfister. Ds-star: Data science agent via iterative planning and verification. arXiv preprint arXiv:2509.2/825, 2025.
Humza Naveed, Asad Ullah Khan, Shi Qiu, Muhammad Saqib, Saeed Anwar, Muhammad Usman, Naveed Akhtar, Nick Barnes, and Ajmal Mian. comprehensive overview of large language models. ACM Transactions Intelligent Systems and Technology, 16(5):1-72, 2025.
Geliang Ouyang, Jingyao Chen, Zhihe Nie, Yi Gui, Yao Wan, Hongyu Zhang, and Dongping Chen. nvagent: Automated data visualization from natural language via collaborative agent workflow. arXiv preprint 2502:22002.00066 2025.
Shri Harini Ramesh and Fateme Rajabiyazdi. Challenges and opportunities of teaching data visualiza- tion together with data science. In 2024 IEEE VIS Workshop on Visualization Education, Literacy, and Activities (EduVIS), pp. 7-13. IEEE, 2024.
El Kindi Rezig, Michael Cafarella, and Vijay Gadepally. Technical report on data integration and preparation. arXiv preprint 21X1::2103.01986, 2021.
Jen Rogers, Marie Anastacio, Jürgen Bernard, Mehdi Chakhchoukh, Rebecca Faust, Andreas Kerren, Steffen Koch, Lars Kotthoff, Cagatay Turkay, and Emily Wall. Visualization and automation in data science: Exploring the paradox humans in loep.. In 2024 IEEE Visualization in Data Science (VDS), pp. 1-5, 2024. doi: 10. (099//DS63397.2222.000
Ranjan Sapkota, Konstantinos Roumeliotis, and Manoj Karkee. Ai agents vs. agentic ai: A conceptual taxonomy, applications and challenges. arXiv preprint arXiv:2505. 10468, 2025.
12

---

Published as a conference paper at ICLR 2026
Wonduk Seo, Seungyong Lee, Daye Kang, Hyunjin An, Zonghao Yuan, and Seunghyun Lee. Au- tomated visualization code synthesis via multi-path path reasoning and feedback- driven optimization. arXiv preprint ar wrXhv22502.111400 2025.
Leixian Shen, Enya Shen, Yuyu Luo, Xiaocong Yang. Xuming Hu, Xiongshuai Zhang, Zhiwei Tai, and Jianmin Wang. Towards natural language interfaces for data visualization: A survey. IEEE transactions on visualization and computer graphics, 29(6):121-3114,, 2022.
Sungbok Shin, Sanghyun Hong, and Niklas Elmqvist. Visualizationary: Automating design feedback for visualization designers using llms. IEEE Transactions on Visualization and Computer Graphics 2025.
Gemma Team, Thomas Mesnard, Cassidy Hardin, Robert Dadashi, Surya Bhupatiraju, Shreya Pathak, Laurent Sifre, Morgane Rivière, Mihir Sanjay Kale, Juliette Love, et al. Gemma: Open models based on gemini research and technology. arXiv preprint arXiv:2403.08295, 2024.
Fangqiao Tian, An Luo, Jin Du, Xun Xian, Robert Specht, Ganghua Wang, Xuan Bi, Jiawei Zhou, Ashish Kundu, Jayanth Srinivasa, al. An outlook the opportunities and challenges of multi-agent ai systems. arXiv preprint arXiv:2505. 10.00..88350 /8397, 2025.
Khanh- Tung Tran, Dung Dao, Minh-Duong Nguyen, Quoc-Vice Viet Pham, Barry O'Sullivan, and Hoang D Nguyen. Multi-agent collaboration mechanisms: A survey of llms. arXiv preprint arXiv:2501.0632 2025.
Henrik Voigt, Ozge Alacam, Monique Meuschke, Kai Lawonn, and Sina ZarrieB. The why and the how: A survey natural language interaction in visualization. In Marine Carpuat, de Marneffe, and Ivan Vladimir Meza Ruiz (eds.), Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Veccnnloogie, pp. 348-374, Seattle, United States, July 2022. Association for Computational Linguistics. doi: 10.18653/v122222.naas http:////2222...mmmma.....mm URL httpss://allanthoolgg org/ 2022. naacl-main. 27/.
Huanting Wang. Jingzhi Gong, Huawei Zhang, and Zheng Wang. Ai agentic programming: A survey of techniques, challenges, and opportunities. arXiv preprint arXiv:2508. / ///66, 2025.
Shuo Wang and Carlos nvbench dataset. arXiv preprint arXiv:23 2023.
Natural language models for data visualization utilizing
Anton Wolter, Georgios Vidalakis, Michael Yu, Ankit Grover, and Vaishali Dhanoa. Multi-agent data visualization and narrative generation. arXiv preprint arXiv:2509, 2540022500000881,,, 2025.
Kanit Wongsuphasawat, Dominik Moritz, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. Voyager: Exploratory analysis via faceted browsing of visualization recommendations. IEEE Transactions on Visualization and Computer Graphics, (211)66496658 2016. doi: 10.1 109/TTG..
2015.2467191.
Kanit Wongsuphasawat, Zening Qu, Dominik Moritz, Riley Chang, Felix Ouk, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. Voyager 2: Augmenting visual analysis with partial view specifications. In Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems, CHI '17, pp. 2648-2659, New York, NY, USA, 2017, Association for Computing Machinery. ISBN 9781450346659, doi: 10. 10.1145532254533325576. URL https: //doi. orwoorr///// //wgg///.11. /145/11254535 3025768.
Yang Wu, Yao Wan, Hongyu Zhang, Yulei Sui, Wucai Wei, Wei Zhao, Guandong Xu, and Hai Jin. Automated data visualization from natural language via large language models: An exploratory study. Proceedings of the ACM on Management of Data, 2(3):1-28, 2024.
Chao Xu, Qi Zhang, Baiyan Li, Anmin Wang, and Jingsong Bao. Visual analysis of time series data for multi-agent systems driven by large language models. In Proceedings of the 3rd International Con- ference on Signal Processing. Computer Networks and Communications, SPCNC '24, pp. 427-431, New York, NY, USA, 2025. Association for Computing Machinery. ISBN 0798400710884 doi: 10. 00.1145/71223353372222 URL https::///// org/1e 1ew.111111135...... 371241 e.
13

---

Published as a conference paper at ICLR 2026
An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayiheng Liu, Fan Zhou, Fei Huang, Feng Hu, Hao Ge. Haoran Wei, Huan Lin, Jialong Tang. Jian Yang. Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxin Yang, Jingren Zhou, Jingren Zhou, Junyan Lin, Kai Dang, Keqin Bao, Ke- Pei Yang. Le Yu, Li-Chun Deng, Mei Li, Min Xue, Mingze Li, Pei Zhang, Peng Wang, Qin Zhu, Rui Men, Ruize Gao, Shi-Qiang Liu, Shuang Luo, Tianhao Li, Tianyi Tang, Wenbiao Yin, Xingzhang Ren, Xinyu Wang, Xinyu Zhang, Xuancheng Ren, Yang Fan, Yang Su, Yi- Chao Zhang, Yinger Zhang, Yu Wan. Yugiong Liu, Zekun Wang. Zeyu Cui, Zhenru Zhang, Zhipeng Zhou, and Zihan Qiu. Qwen3 technical report. ArXiv, abs/2505 hbs/2505.09988, 2025. URL https://api. semanticn wwwholaar.......occooooooorar..a
John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Adriano Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-computer interfaces enable automated soft- ware engineering. ArXiv, abs/2405.15793, 2024a. URL https://api semanticscholar.om org/
Corpus10:270063388
Junran Yang, Péter Ferenc Gyarmati, Zehua Zeng. and Dominik Moritz. Draco 2: An extensible platform model visualization design. In 2023 IEEE Visualization and Visual Analytics (VIS), pp. 166-170. IEEE, 2023.
Zhiyu Yang, Zihan Zhou, Shuo Wang, Xin Cong, Xu Han, Yukun Yan, Zhenghao Liu, Zhixing Tan, Pengyuan Liu, Dong Yu, et al. Matplotagent: Method and evaluation for llm-based agentic scientific data visualization. In Findings of the Association for Computational Linguistics ACL 2024, pp. 11789-11804, 2024b.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting language models. ArXiv, abs/2210.03629, 2022. URL https://apt. semanti semanticccholalee cscholar org/CorpusII: 25000orp20010:2222233555 252762395.
Ran Zhang and Mohannad Elhamod. Data-to-dashboard: Multi-agent Ilm framework for insightful visualization in enterprise analytics. arXiv preprint arXiv:2505.2 2.399, 2025.
Yanbo Zhang, Sumeer Khan, Adnan Mahmud, Huck Yang. Alexander Lavin, Michael Levin, Jeremy Frey, Jared Dunnmon, James Evans, Alan Bundy, et al. Exploring the role of large language models in the scientific method: from hypothesis to discovery. upj Artificial Intelligence, 1(1):14, 2025.
Yuqi Zhu, Yi Zhong, Jintian Zhang, Ziheng Zhang, Shuofei Qiao, Yujie Luo. Lun Du, Da Zheng, Ningyu Zhang, and Huajun Chen. Why do open-source 1lms struggle with data analysis? systematic empirical study. arXiv preprint 25v6 19794, 2025.
14

---

Decompose query into task list Published as a conference paper at ICLR 2026
A CoDA WORKFLOW AND IMPLEMENTATION DETAILS
Algorithm outlines the CoDA multi-agent visualization workflow, illustrating the sequential and iterative interactions among specialized agents to transform natural language queries into refined visualizations.
Algorithm CoDA Multi-Agent Visualization Workflow
1: Input: Query q, Data files D
2: Output: Visualization plot P
3: Initialize agents: Aquery: Adata. Agcarchs Adesigu- Acodes Adebug. Aeval
4: todo +- Aquary (q)
5: metadata &- Adma (D)
b Extract metadata without raw data Map visualization primitives
6: mappings
Adesign (todo, metadala)
7: examples + Asarch (mappings)
D Optional: Retrieve code examples
8: designs Asssign mappings)
Optimize aesthetics
9: code + Acode (mappings, designs, ezamples)
>> Generate executable code
while not converged do
11: output + Atchug Atthug(code] (code)
Execute, debug, produce plot Evaluate clatiy/lccuracyllloo/aaattttiiic
scores + Aeval A (oul)ppa)
>
13: if scores threshold then
14:
return output
15: else
16:
refined t Adesign: Acade, Adehug Altbugsscores) (scores)
b Feedback to refine
17:
end if
18:
end while
B ADDITIONAL VISUALIZATION EXAMPLES
We present additional visualization examples drawn from the DA-Code, and MatplotBench to illustrate CoDA's performance. For each example, show the natural language query, the ground truth visualization, and the output generated by CoDA. These instances highlight CoDA's ability to handle complex data patterns, ambiguous queries, and multi-file inputs through collaborative agentic refinement, often producing outputs that closely match or exceed ground truth fidelity.
B. DA-CODE EXAMPLE
Example Inputs
Example 1
#ttt Task Instruction
**Task:**
Please compile the total scores for each year from **1950 to 2018**
Plot the results in line chart according to the format specified in plot.yaml and save the chart as "result.png".
#B Environment
--- nsa.csv # Core dataset (season-level data) @ba_extra.css # Supplemental dataset (optional fields)
Seasons_Stats.. csv Player-season statistics
12
Players. csv Player metadata
13
player_data_ csv # Additional player/game-lewe data
plot.yaml Primary plot configuration
psot.json Alternative plot configuration
Verbose Instruction (Human-curated) The following detailed instructions manually orga- nized by the authors to ensure clarity and reproducibility. Note: Several aspects below represent human-identinn challenges that are not directly contained in the raw datasets.
15

---

Published as a conference paper at ICLR 2026
1. Check Available Resources and Directory Structure Confirm presence of nba. csv, nba_extra.. ext.e.csv. Aasoos_Statts csv,, Players. player_data. csv, and plotting configuration files jolot.yaml plot. Human note: The dataset does not explicitly define dependencies across files; we curated which files are relevant.
2. Data Review
Inspect nba.csv and nba_extra, csv to extract season-level total points.
Use
csv Seasons_Stats. csv player_date _ayte. csv if aggregation is required.
Human note: None the datasets directly contain "total league points per year"; this metric must be manually constructed.
3. Primary Metric Construction (Default)
Aggregate all scoring fields by season (year) to compute Total Points Scored.
Human note: The "total scores per year" metric is absent; manual aggregation logic was designed by the authors.
4. Filtering / Top-K Selection (Optional)
Apply year range restrictions (1950-2018) Exclude lockout seasons highlight anomalies if needed.
Human note: Anomaly handling (e.g., lockout years) is not specified in the data, but added through human judgment.
5. Read Plot Configuration
Parse style and formatting options from plot. yaml (or fallback plot. json). Human note: Plot configurations are not embedded datasets; authors manually crafted the YAML spec.
6. Create the Figure
Plot line chart with year on x-axis, total points on y-axis. Apply formatting (color palette, grid, axis labels, legend). Save as result.png. Human note: Visualization design choices (palette, annotations) are not given in raw data and were human-curated
7. Reproducibility
Document assumptions and preprocessing steps. Maintain transparency about human decisions in data aggregation and figure styling.
Human note: The reproducibility statement itself is an author-side contribution; the dataset alone cannot ensure this.
Total Points According To Years
Total Pointss
(a) CoDA Output
(b) Ground Truth
Figure Comparison between our generated visualization and the ground truth. The results demonstrate that system faithfully reproduces the intended trends, achieving exact match with the reference output (score: 100/100).
Result Analysis. The comparison in Figure 4 illustrates that our approach able to reproduce the target visualization with high fidelity. Despite the complexity of the task and the absence of direct "total score per season" fields in the datasets, our CoDA correctly aggregated and rendered the results without deviation from the ground truth. This outcome highlights both the robustness of our data processing pipeline and the reliability of our visualization module in faithfully capturing benchmark specifications.
Our Generated Code
16

---

Published as a conference paper at ICLR 2026
import pandas as pd
import matplotlib.pype pyplot plt import yaml
import sys
5
The EXPANDED QUERY REQUIREMENT specifies using 'plot.yaml' file for styling.
# To make this script self-contained and reproducible, we will create this file programnatically.
yaml_config_str -..
title: 'Total NBA Points Scored Per Year (1950-2018)*
xlabel: 'Year'
ylabel: 'Total Points Scored'
figsize: [12,
13
line_color: '#007ACC'
14 marker: 'o'
linestyle: !-'
grid: True
18
with open( (renn(plot.yee ylmt..yml', 'w') as f:
f. f.write((am___ofig__sy
Step Load the primary dataset from Seasons_Stats csv,
22
try:
Note: The prompt's "AVAILABLE DATA" section seems incorrect. We follow the textual instructions
which clearly state to Seasons_Statt Sta.s.ssvtt csv'.
stats_df pd. read_csv( "raa_css("Sessoss_Sttaa" Seasons
26
except FileNotFoundError:
print("Erron The file SeessonsSSttts.oo was not found.
sys.exit(1)
30
Data Cleaning and Preparation
Handle potential NaN values in critical columns. Drop rows where 'Year' is NaN they cannot be used for time-series analysis. stats_df (rropna(uusset(("Yerrr
inplace=True)
35
Fill NaN 'PTS' with 0, assuming missing points data means points were scored. stats_dfi ' PTS'] = stats_df[ PTS fillna(0)
Convert data types for consistency and proper calculations.
39
"eats_df['Verr'' stats_df[ Yearrf((YY']]r. a.stteee)yy stats_ stats_df('PTs') = stats_df[' PTS astt
40
Step 2: De-duplicate player-season records. Players who were traded mid-season have multiple entries for year, plus summary row with 'Tm' (Team) as 'TOT'. The 'TOT' row typically appears first in the dataset for given player-year. # By dropping duplicates 'Player' and 'Year' and keeping the first entry, we retain the summary row. cleaned_df stats_df. drop.dupllcaceesubssttt-/
'Year'l, keep='first')
47
Step 3: Filter data by year and aggregate total points. Filter the data include only the years from 1950 to 2018, inclusive. filtered_dF cleaned_df ( 1950 <= Year 2018')
(1950
Group the cleaned data by 'Year' and calculate the sum of 'PTS' for each year. annual_points =
Step Load plotting configuration.
56
Read the styling parameters from the YAML file created earlier. with open( paa.'pppoaaall...... 'r') as f: plot_params = yaml. saae_load(f)
Step Generate style the line chart.
17

---

Published as a conference paper at ICLR 2026
Set the figure size from the loaded parameters:
plt. www.gureefiisserpplttoprrraaaa (figiizee
Plot the aggregated annual total points against the year. plt. (ontuloonnnll inde
annual_points. valuue,
marker=plot_params: get
n'marree',, get''arrer',, 'o'),
68
Linestyle=plot__arramm get "et(""nnetylle"" 1-)), color=plot_params..
attaaanseeeiiiiecllll line_color',, 'b'))
Apply visual styles speci fied in the YAML confi configuration. pit.:iitlepllot_prrrms tiill''
72
plt. vit.xlabel (plot..aaam ['xlabel })
(ptpppppppaassay________ 'l)
if plot_params. get( grid', False):
plt.grid(True)
77
Ensure the layout is clean and labels do not overlap. plt. tight_layout()
Step 6: Save the final plot.
x2
Save the resulting chart as an image file. plt. savefig(" result.png')
Close the plot to release system resources.
close()
("Visuulalzzaiionn saved successfully 'result.png pnu'.")
Example 2 Inputs
Task Instruction
**
Calculate the **Pearson correlation coefficient** between the standardized Average
Playtime and standardized Positive Ratings using the Steam Store Games dataset.
Filter the data to only include games with positive ratings and positive playtime.
Plot the results in scatter plot following "plot.yaml" requirements and save it trssul..png"
s# Environment
--- steam.cst csv Core dataset with game-level metadata (title, ID, release info, etc.)
dtram_descriptionn datadddtaaaccc # Game descriptions textual metadata
@ream_media_.m satta_ddta.cco csv Media assets metadata (images, videos, links)
steam_requirenee weweeteedataaaattaee csv # System requirements (Windows, Mac, Linux)
Steam_support__e t_ # Support information (developer contact, website, etc.) steamspy_tar harppy__tt___atte data.data..sso Community tags and genre/category labels plot.yaml Plotting configuration file (primary)
Verbose Instruction (Human-curated) The following detailed instructions manually orga- nized by the authors to ensure clarity and reproducibility. Note: Several aspects below represent human-identifie challenges that are not directly contained in the raw datasets.
1. Check Available Resources and Directory Structure
Confirm presence of steam. csv, steam_ dewaadddecrpppiion.cmm data. esv, steam_ aate__eddi_dddaee csv, Steam_requirente cetpuuureeenssstteee csv, steam_support_info.cmm csv, steamspy_tag_data csv, and plotting configuration file (plot.yaml).
Human note: The dataset does not explicitly document dependencies across these tables; authors curated the relevant set manually.
2. Data Review
Parse steam. csv for core identifiers (app ID, title, release year).
Use auxiliary tables enrich attributes (tags, system requirements, support info, descriptions).
18

---

Published as a conference paper at ICLR 2026
Worsterk Flgline Poslint Setrege (Pearont 2264)
Staetue Plyilin
(a) CoDA Output
(b) Ground Truth
Figure 5: Comparison between generated visualization and the ground truth for the Steam dataset. The results indicate that our approach successfully integrates multiple heterogeneous tables and reproduces the intended visualization with complete fidelity (score: 100/100).
Human note: None of the datasets provide a unified schema; integration must be designed manually.
3. Primary Metric Construction (Default)
Define the analysis target (c.g., distribution of games per year, tag frequency, platform coverage). Construct aggregated metrics aligned with the visualization goal. Human note: The specific analytical objective (e.g., "game releases per year") is not included in the dataset and was defined by the authors.
4. Filtering/ / Top-K Selection (Optional)
Restrict to a target period (e.g., 2000-2020).
Apply Top-K filters by popularity, tags, or developer if required.
Human note: Filtering logic is absent in the raw data and was designed for clarity in visualization.
5. Read Plot Configuration
Parse style and formatting options from plot.yaml. Human note: Plot specifications are not embedded in the dataset; authors manually authored the
YAML configuration.
6. Create the Figure
Generate visualization according to aggregated metrics.
Apply palette, axis labels, and layout as specified in configuration.
Save output result. png.
Human note: Visualization design decisions (choice of chart type, color scheme) are external to the dataset and human-curated.
7. Reproducibility
Document assumptions in data integration and filtering. Provide a transparent link between raw tables and the constructed figure. Human note: Reproducibility relies on explicit author-side documentation rather than inherent dataset properties.
Result Analysis. The comparison (Figure 5) between our generated visualization and the reference output demonstrates that our system is capable of handling heterogeneous and fragmented data sources, such as the Steam metadata tables, with high fidelity. Despite the absence a unified schema and the need for manual integration across multiple files, our pipeline successfully reproduced the intended visualization without error. This outcome confirms that our method not only aggregates and processes complex datasets effectively but also renders results fully consistent with the ground truth, achieving perfect score of 100/100.
Our Generated Code
import pandas as pd
import numpy as
from wwleern.prrerrceesee import StandardScaler
19

---

Published as a conference paper at ICLR 2026
from scipy. import pearsonr import matplotlib, pyplot plt
6 import yaml
7
import os
--- Step 1: Create the plot. configuration file
10
This file dictates visual styling plot.
11
yaml_config_str_ ...
title: Standardized Playtime vs. Positive Ratings (Pearson (correlation: .3f))
xlabel: "Standardized Average Playtime'
ylabel: "Standardized Positive Ratings'
15
font_sizes:
16
title: 16
axes_labels 14
tick_labels: 12
scatter_plot:
20
color: '#007ACC' alpha: 0.6
marker: 'o'
edgecolor: 'k'
s:
figure:
figsize: [12, 7]
dpi: 120
style: sinboonn-o_-wwhteerrrr
29
...
with open(' ppen('plot.yann yaml', 'w') as f:
f. (.rite(yyml__coffigsst))
Step 2: Load plotting specifications from yaml with open( pllp.. 'r') as f:
34
config yaml. safe_load(f)
Step Load process the The user specified "steam.csv'. will use this file.
39 Note: The 'AVAILABLE DATA' section mentioned aetam_media_data.com but the query was explicit.
file_ 1__aatth "steam. csv'
not (aithhexiiss(fie__attt)
42
As a fallback, check for the other filename if steam.csv is not found. # This handles potential environment discrepancies. if os. os.patt.exists( asteam_media__atee : file_path
sitea_meeii__dal daataa_ddaacccmmmm csv"
else:
raise (FFaNotfounddError(("Clllll not find the required data file: '(file_path)' or iitam_media_data.com
Load the dataset into pandas DataFrame df = pefieeeat.
50
# Filter the DataFrame to keep only rows with positive values for both variables Using () avoid SettingWi thcopwarnng filtered_df (df[aaaaa average_playtineg
> 0) (dfl' "iae'ppoiiiieerrttnggss p)].copy/
-- Step 4: Standardize the relevant columns
Select the columns for standardization data_to_scale filtered_df[C average__pla playtimme.. 'positive_ratings ']]
Initialize and apply the StandardScaler scaler standardScaler() scaled_data scaler. fit_trranformmaattttoo.
64 Add the new standardized columns to the filtered DataFrame
filtered_dFr atd_ave_playttme'1 = scaled_data[;, 0]
filtered_dfs df[ rtdttnn scaled_dataf: 1]
20

---

Published as a conference paper at ICLR 2026
Step 5: Calculate the Pearson correlation coefficient
69
Calculate the correlation on the standardized data correlation, pearsonr (filterddd std_avg_playtime 'J, filtered_df[ sttoodddddsd__pp__rattt std_poo__rtting']]
72
Step 6: Create style the scatter plot Apply a base style for the plot from the config plt.
73
Create figure and with specified size and DPI
77
fig, ax ppt..subllottsfiisizzecoommm figure " (''fiiiiz'), dpi=config[ [['dpi 'J)
Generate the scatter plot using data and styling from config scatter(
82
filtered_dfr st___pos_
color=config[" scatter_plot color=coofiig"ssatter.lloo:: "o
alpha=config[" scatter_plot alphaaccorriggssstttee.looo// "[''aa_pa""'"''''aa''"a"
marker=config(" (iariig((sctatrpl/llil "I
edgecolors=config(" scatter_plot. [['edgecolor'], s=config[ cccatter_plot]]]
Set titles and labels, formatting the title with the calculated correlation ax set_titleeeeeeeeeee tite
configl 'tttl'' fommatcoorreltiioooorrreltttto
fontsize=config("" font_sizes [[ tittel''', fontweight='bolle bolld
96
ax. ex..st_xxlabed
configt xlabel'],
fontsize=config["
font_sizes fontioooooiiiioooossiiiieeee
aal'axes_labbll
100
ax set (ert_ylabee(
101
configl config['ylabel") ylybel '],
fontsize=config(" fant_sizes' ][ [['axes__]le labell
104
105
Customize tick label sizes ax. (acc_paarammsxiss"bbottt which='majors
106
labelsize=configl" font_sizes" ][" tick tabelsab
108
Ensure the layout is tight to prevent labels from being cut off plt. tight_layout()
109
Step 7: Save the final plot file the plot 'result.png"
112
113
plt. savefig(" savefiig"resuuttpnn""
114
("Sucessslyylluuull generated and saved the plot 'result.png'. PPPanss" Correlation Coefficient: [correlation:.31)
B.2 MATPLOTBENCH EXAMPLE
Example 1 Inputs
Example 1
## Task Instruction
**Task:**
21

---

Published as a conference paper at ICLR 2026
Utilize the following data columns from 'data.cvv' create sunburst plot:\n- "country": for the names of the countries, An- 'continent's continent each country is in, \r- 'lifeExp': showing the expected lifespan in each country, \n- pop': representing the population of each country. AnYour chart should:An= An- Organize the data hierarchically, starting with continents and then breaking down into countries. An- Use the population of each country determine the size of its segment expected lifespan, transitioning from red to blue across the range of values. An- Set the central value of the color scale to the average lifespan, weighted by the population of the countries. An- Finally, include legend to help interpret the lifespan values indicated by the color coding.
indicate which
the chart. An- Color code each segment by country's
#B Environment
data.
Popt lntionnion and Life Expectoncy by Continent and Country
Inda
CPYA
Indtoeest
China
Palasten
Carone
ATSOPUAN
(a) CoDA Output
(b) Ground Truth
Figure 6: Comparison between generated sunburst plot and the reference output. The visualization organizes data hierarchically by continent and country, with population determining segment size and life expectancy driving the color scale. The results demonstrate full fidelity to the specification and highlight that our system achieves a perfect score of 100/100.
Result Analysis. The sunburst visualization task required multi-level hierarchical organization of the data, starting from continents and further breaking down into individual countries. Our method successfully utilized population size to determine segment area and applied a red-to-blue color scale based on life expectancy (Figure 6), with the weighted average lifespan as the central pivot for normalization. This design ensured both interpretability and faithful representation of the dataset's structure. The resulting chart aligns precisely with the ground truth and provides intuitive overview of demographic and geographic patterns, achieving perfect score of 100/100.
C EXPERT AESTHETIC EVALUATION DETAILS
This appendix provides the full definitions of the five aesthetic dimensions used in the human expert evaluation (Section 4.8). Three domain experts (one visualization/interaati design specialist and two data-analysis practitioners) rated each of the 200 outputs (50 MatplotBench instances methods) on a 1-5 Likert scale per dimension. Quantitative results are reported in Table 6.
The five dimensions are defined follows:
1. Visual Harmony: "Colors, lines, and shapes feel coherent and not jarring."
2. Balance & Alignment: "The layout feels balanced and well aligned, top-heavy or cluttered."
3. Color Mood: "The color palette consistent and appropriate for the content."
22

---

Published as a conference paper at ICLR 2026
4. Simplicity & Restraint: "The figure looks clean and restrained, without unnecessary visual elements."
5. Query Alignment: "The visualization matches what the natural-language query is asking for."
D ANALYSIS OF FAILURE CASES AND LIMITATIONS
To better understand when and why CoDA may struggle, we analyze a representative hard example in MatplotBench. This task requires two-level hierarchical donut chart of browser market share (inner ring browser totals; outer ring version breakdown) with a hollow center, explicit white gaps between rings and wedges, and readable leader-line labels for dozens of fine- fin-grained outer segments (complete task is shown below).
Example 1
#2 Task Instruction
**Task:**
have dataset named \ddata. csv\" containing browser market share information in CSV format with the following columns: An- Browser: The name of the web browser. An- Version: The specific version number of the browser. An- Data: The market share percentage associated with each browser version. AnI want to create two-layered sunburst chart to visualize this data. The chart should be designed The inner layer should represent different browsers, with the browser names (Browser column) written on the segments. An- The outer layer should depict the versions of these browsers (Version column), with labels and lines pointing to the specific data points the chart's edge. An- There should be white gaps between the layers and also between the segments wi with each layer for visual separation. An- The center of the chart should hollow, creating a donut-like appearance. \nPlease generate the sunburst chart using Python, ensuring that the 'Browser' and 'Version' columns are used for the hierarchical structure, and the 'Data' column is used to determine the size of each segment. The chart should be titled 'Browser Market Share'.
follows: An-
If Environment
data.cs
Brwwe Shatat
Browser Market Share
Gara 200
talan
says
12
Map
Mec
Wrbce GLD
(a) Failure Output
(b) Success Output
Figure 7: CoDA's outputs. (a) Output after three self-reflection iterations (failure). (b) Output after four iterations (success).
The core difficulty lies not only correct hierarchical aggregation and proportional geometry. but equally in (i) deep understanding of the underlying data distribution and (ii) deliberate perceptual planning of information display. With more than 40 outer segments, naively rendering all labels at once inevitably produces catastrophic overlap and visual chaos. Success therefore requires the system
23

---

Published as a conference paper at ICLR 2026
to make informed choices about radius ratios, wedge spacing, label placement strategy, and color contrast.
With CoDA's 's default setting of three self-reflection iterations, the system reliably fails (Figure 7 (a)). When the maximum number of reflection iterations is raised to four, CoDA recovers completely (Figure 7 (b)). The final chart exhibits correct hierarchical nesting, clean hollow center with balanced radii, uniform white spacing, and fully readable leader-line annotations. The recovery process is instructive. Table presents the key feedback trace.
Iter
Evaluator Feedback (excerpt)
Triggered Fix
Code fails to run: CSV file not found; no figure produced.
Debug Agent -> Corrects filename to data. csv.
2 Two-layer donut appears, but outer labels clutter the entire perimeter; arrows overlap; inner labels unreadable.
Design Explorer VizMapping -> Re- orders hierarchy, applies browser-level color palette, adjusts ring radii for clearer structure.
Structure is correct but readability poor: tiny slices still labeled; text crowded; fonts too small.
Design Explorer + Adds size thresholds for labeling, restricts inner-ring labels, increases font sizes and title weight.
Two-level hierarchy clear; spacing visible; only major slices labeled; overlaps; chart rated high readability.
Halt.
Table 7: Iteration trace for the browser sunburst task, showing how deeper reflection improves structure and readability.
This case demonstrates that complex visualization generation tasks can benefit from multi-step self-reflection. Shallow reflection tends to fix superficial bugs, while deeper self-reflection allows the model re-plan the solution holistically, leading both correctness and visual clarity.
While CoDA substantially advances automated visualization, it is by no means panacea. From experimental results, we observe several limitations. First, inherently ambiguous or purely aesthetic queries (e.g., "make it professional") lack clear ground truth and can trap the system in unresolved refinement loops. Second, domain-specifit visualization conventions often cannot be inferred from metadata alone, leading to reasonable but non-canonical designs. CoDA remains powerful assistant rather than a full substitute for human expertise. Addressing these limitations constitutes an important direction for future agentic visualization systems.
E JUDGING PROMPTS AND MODEL SETUP
To ensure consistent and objective evaluation of generated visualizations, employ an LLM-based judge, specifically
to assign code and visualization quality scores.
We adapt prompts from the original MatplotBench (from the MatPlotAgent repository) and Qwen- Agent evaluations (official evaluation for Qwen Code Interpreter). This ensures consistent, scalable assessment while reducing bias. MatplotBench overall score averages the two; Qwen uses binary 100/0 via combined prompt. Non-executable code scores 0.
The prompts for MatplotBench and Qwen Code Interpreter benchmark shown in the following.
MatplotBench Evaluation Prompts
2
Code
You are an excellent judge at evaluating generated code given an user query. You will be
giving scores how well a piece of code adheres to an user query by carefully reading each line of code and determine whether each line of code succeeds in carrying out the user query.
user query, a piece of code and an executability flag will be given to you. If the Executability is False, then the final score should be 0.
RnUser Query**: (query)
*cCode*;: (code)
24

---

Published as a conference paper at ICLR 2026
**Executabilityyx: (executable)
Carefully read through each line of code. Scoring can carried the following
aspect:
Code correctness (Code executability): Can the code correctly achieve the requirements in the user query? You should carefully read each 1ine of the code, think of the effect each line of code would achieve, and determine whether each line of code contributes the successful implementation the Executability is False, then the final score should be 0.
requirements
the user query. If
After scoring from the above aspect, please give final score. The final score is preceded by the [FINAL SCORE] token.
For example [FINAL SCORE]: 40. final score must be generated.
12
13
## Plot
You are an excellent judge at evaluating visualization plots between model generated plot and the ground truth. You will be giving scores how well it matches the ground truth plot.
15
**Generated plot**; (generated_plott)
15
**Ground truth**: {GT}
The generated plot will be given to you the first figure. If the first figure is blank, that
the code failed generate figure.
18
Another plot
given you as the second figure, which is the desired outcome the user query, meaning it is the ground truth for you to reference.
Please compare the two figures head to head and rate them.
Suppose the second figure has score of 100, rate the first figure scale from 0 100.
21 Scoring should be carried out in the following aspect:
Plot correctness:
Compare closely between the generated plot and the ground truth, the more resemblance the generated plot has compared the ground truth, the higher the score. The should proportionate to the resemblance between the two plots.
24 In some rare occurrence, see if the data points are generated randomly according to the query, if so, the generated plot not perfectly match the ground truth, but it is correct nonetheless.
Only rate the first figure, first figure blank, that means code failed to generate figure. Give score of on the Plot correctness.
second figure is only for reference.
26
After scoring from the above aspect, please give final score. The final score is preceded by the [FINAL SCORE] token.
28 For example [FINAL SCORE]: 40.
Qwen Code Interpreter Benchmark Evaluation Prompts
2 Please judge whether the image is consistent with the [Question] below, if it is consistent then reply "right", if not then reply "wrong".
Consider these relaxed conditions
Allow reasonable interpretations and creative variations
5 Focus on whether the core visualization requirement is addressed Accept different implementation approaches that achieve similar goals Be lenient with styling and formatting differences
**Question*:: {query}
10 After your judgment, please also provide a brief explanation of your reasoning in 2-3 sentences.
Expected leading token (normalized by code): CORRECT WRONG
F PROMPTS USED CoDA
The prompts employed CoDA are designed to imbue each agent with a professional persona, standardize structured outputs via dataclasses (e.g., AueryynnalyssReesutt) and facilitate quality- driven feedback without requiring model one-tunnng. These prompts encapsulate domain-specific reasoning mangginggraanging from semantic parsing in the Query Analyzer statistical inference in the Data Processor, visualization mapping in the VizMapping Agent, external knowledge retrieval in the Search Agent, design recommendations in the Design Explorer, executable code synthesis in
25

---

Published as a conference paper at ICLR 2026
the Code Generator, error diagnosis in the Debug Agent, and perceptual assessment in the Visual Evaluator while incorporating context from prior outputs and the global TODO list to maintain workflow coherence. Below, enumerate all core prompts used across the agents, including variations for refinement iterations.
Query Analyzer
You are Dr. Sarah Chen, visualization query expert. Analyze this query and create master TOD0 list.
USER QUERY: "[query)" {meta_files) Respond with concise JSON:
"Interpreted_intenn"" "what user wants to visualize", cesuuliiaatio_typpe"" "plot type
etc)",
pentting_key_pointe
"key point 1: specific visualization requirement", "key point data processing requirement",
"key point 3: styling/design requirement",
14
"key point 4: additional features//onstraints
].
"implemnntationnplan"" ("step": 1, "action"; "Load and prepare data", "details": "specific data
- Loadingg/rocessing steps", "functions": rypd.read_cos "etc"]),
18
("step": 2, "action"; "Create base plot", "details": "basic chart creation", "functions": figure", plot", "etc"]),
("step": 3, "action": "Apply formatting", "details": "styling and formatting", - "functions": x'abee,,abel", "ax. tick_params" "etc"]),
20
("step": 4, "action": "Finalize and save", "details": "final touches and save", "functions": ["plt. layou_, "plt. plt.savefig", "etc"])
J.
@llbba_ttdoo_iis
23
("id": "todo_1", "task": "specific task description", "agent": Slata_processor design_expla | woodee_gneaattroocom agent "assuullevllatoor" "status": "pending", "priority": "high [medimm| ("id": "todo_2" _", "task": "specific task description", "agent": "agent_name", "status": "pending", "priority": "priority_level""
1, "success_criteriaa" ["criteria for completion"],
IMPORTANT:
The belotting.key_pointt. should be comprehensive breakdown of ALL key visualization requirements from the query, including: Chart type and specific visualization style
Data columns/varialles to use Color schemes, styling requirements Interactive elements or special features
33
Layout, axis, legend requirements Any memaain-specifeee fic requirements (scientific, business, etc.)
Create 3-5 specific TODO items covering data processing, design, code generation, debugging, and evaluation.
Data Processor
You are Prof. Marcus Rodriguez (Stanford Statistics PhD), expert in statistical analysis, data quality assessment, and insight extraction. Analyze this data for visualization.
3 (data_section)
TASKS TO COMPLETE:
(todo_text)
ANALYSIS NEEDED;
7
1. What transformations are required? (groupby, pivot, filter)
2. which columns are key for visualization?
3. Any data quality issues to fix?
4. What's the simplest way prepare this data?
26

---

Published as a conference paper at ICLR 2026
Output JSON:
13
prrocssiing_steps..
"step 1: specific transformation",
"step 2: another transformation"
1.
"insights": {
18
"key_columns" ["col1", "col2"], iereegatioonsneeddd" [*sum sales by region"],
"quslity_issues": ["nulls in X column"]
}.
22
'visualization.hing "best chart type for this data"
<(optional) If there data files in the input>
Create simple data a matplotlib visualization. The visualization requirements are: [query_text]
27
TODO items from analysis:
(todo_text)
Generate Python code that creates the RIGHT data (pandas DataFrame) that works this specific plot.
Deep understanding approach:
1. ANALYZE the visualization requirements carefully
2. UNDERSTAND what type of data this plot needs
35 3. DETERMINE the appropriate data structure and format
4. DECIDE the optimal number of data points based on plot type
VizMapping Agent
You are Dr. Sarah Kim, a data visualization expert UX designer. You are a data visualization expert. Map this user query to specific data columns and chart configuration.
USER QUERY: "[query)"
4
[context_block
AVAILABLE DATA:
Shape: (data_sume) ciitta_smmar[""" shape' ][0]} rows {data_summary[ 'shaee ][1]] columns
Columns:
[data_structure)
Sample data:
(json. aumpasddaa__smmaa (ammmary['samlle_eeem ssmple__ddtt ][:2], indent=2))
TASK:
Determine the optimal visualization mapping.
Respond with JSON:
13
"chart_type" :yprtt "bar| line scatter |pie hpte//istogrrrreeeeeeeeeeeeee |bx heatmap""
_esta_mappings": {
"x_axis": "column_name_for
"y_axis": "column_name_ff""ee for_y"
18
"color": Bowuuu__foorgruping..o.mmm
"size": "column_for_siie"
"category": ccolumn_for_categoriie
),
22
"aggregations":
("operation": "sum |mean| count max max|min", "column": "column_name" "group_by"; "grouping_columm"
25
"filters": ("column": "column_name", "condition tion": "filter_coni tion")
26
].
Styling_hints"s
"title": "Chart title based on query",
30
"xlabel": "X-axis label",
"ylabel": "Y-axis label".
"color_palette": Buggested__alettee
}
27

---

Published as a conference paper at ICLR 2026
"cransformations": "pandas operation if needed, e.g., 'df. (x) sum()
J,
"goal": "Brief description of what this visualization shows", "rationale": "why this mapping fits the query and data", "confidence": 0.0-1.0
41 IMPORTANT:
If a requested chart type is provided in context, PREFER that type; only deviate if truly unsuitable and explain why in 'rationale'.
Use TO00/key requirements to decide aggregations/fillers exactly.
Map time-like/ordered fields to x, numeric measures to y, categories to color.
Be precise with column names they must match the available columns exactly.
Search Agent
As Dr. Michael Zhang, expert in data visualization and matplotlib, generate a high-quality matplotlib example for the plot type: "(plot_type)".
4 IMPORTANT CONSTRAINTS:
Base your code PRIMARILY matplotlib official examples: https://matplotlib. http:///wwoooll.ooooorraaaaaaaaa hrg//stable/glllee//iieee.. html and httpp:://attpotllib.. wttpii..rgg/saaeeppott.... tesotttypes/iiini http:/ddexx..hht html
5 You may also use Python Graph Gallery as style reference:
Do NOT invent new APIS. Follow official patterns exactly.
Your task:
10
1. Understand what type of visualization "pplot_typee" refers to according to matplotlib's official plot types
2. Generate complete, executable matplotlib code example following official matplotlib patterns
12
3. Use the exact style approach shown matplotlib's official documentation
13
4. Include proper imports, sample data, styling, and annotations as shown in official examples
5. Follow matplotlib's official best practices and naming conventions
15
Requi for the matplotlib code:
Use ONLY patplotlib.pypl.. (import matplotlib. pyplot as plt) Follow the exact patterns from https://mattlotilne arg/stable/gallery/ documentation examples
Include numpy for data generation needed (as shown official examples)
20
Create realistic sample data appropriate for the plot type (following official examples)
Add proper labels, title, and styling (matching official documentation style) Include plo.show() the
Make the code self-contained and executable
24
Add informative comments that match matplotlib documentation style
Respond with ONLY the Python code in this format:
... ppythhn
28
[Brief description matching matplotlib docs style]
import matplotlib. pyplot as plt
import numpy
32 Your complete example code here following official matplotlib patterns Include comments matching matplotlib documentation style
33
show()
37
Plot type to implement: (plot_type) Primary references:
httpss//mmppolliiooorrrraaaaallp html
28

---

Published as a conference paper at ICLR 2026
https://maapplotlib htt.pppp.......ees//saaaaa///l/e
Secondary reference: http:://pyyhorrrraan---allllee.
Design Explorer
2. You are Isabella Nakamura, RISD Apple Senior Designer specializing visual
- design and user experience.
Analyze the following requirements to create comprehensive design specifications:
Query Analysis:
Original Query: "[queryrresult.originaa_.c
6 Interpreted Intent: "(query_result.
7 Visualization Type: [ooerr_eessl.ineeereeee..n.eeee interpreted__intent
Data Characteristics: dison.duppsdatt__com chhraacteristics, indent=2, default=str))
Design TODO Items:
(json.dumps) dumps (desinnggig. indent=2)}
[constraints_stee
(examples_str)
Please provide comprehensive design analysis in JSON format. Consider the examples above when making design decisions:
+
15
"design_objective""
"Primary design goals",
"User experience objectives", "Communication goals"
19
1.
Carget_audience {
"primary_audience" "Who is the main audience",
"expertise_ seeeleleell; "beginner| intermediate lexpeett "context_of
24
reporting",
ciccesibilityy.rquireeeeeet ["specific accessibility needs"]
}. "visual_hierarchy" ["most important visual elements")
"primary_elemenss
"secondary_ellments".. ["supporting elements"), "emphasis_strateey"" "how to create visual emphasis"
).
color_strategy":
"primary_colors": ["#hex1", "#hex2"],
"color_meaning" "what colors comunicate",
"accessibility_comp complicceem..... "WCAG compliance level", ccultural_consideratiioo "any cultural color meanings"
), "layout_principles""
38
orriiio hasaai///aaytterr//aalaaaaaa
sspacing_strateey" (moderate Igenerous",
"alignment__syttem" "left] Iright Iustiiiisiiiiiie"""" justified", "proportion_ratios" "golden ratiol of thirds custom"
}. "dyypgraahyyreeuuieemeetts
"font_hierarchy": "titlel tlbbiitleie body caption sizes",
"readability_prioritt""" "high medium llow", "brand_alignment": "corporate academic creative technical"
47
}. "interactiion_design""
"interacttin_levelll
"user_controlss ["zoom", "filter", "hover"), "FeedbackKmechanismss" "visual audio hapticc ), "Gechnical_constraints""
"outputt_ormat":: "static interactive " animated", |nteracctiveaanimatee""
56
"size_limitations" "print porint/screen |screen mobile",
"fast moderate detailed"
}.
iimovationn.oportuuiitt
29

---

Published as a conference paper at ICLR 2026
"Areas for creative enhancement", "Unique design elements explore"
62 ], "desiggnconfiieecce" 0.95
Design Explorer (eself-reflection)
You are Isabella Nakamura, an expert designer. The current design received feedback from visual evaluation.
ORIGINAL DESIGN SPECIFICATIONS:
Primary Design: http://www.aaaaaaaaaaaaaaaaaaaaa indent=2,
default=str))
6
Alternative Designs Available:
7
VISUAL FEEDBACK ANALYSIS:
Feedback Comments: srisual_feedbade www.faack..eeteiiissaaaaee...eee get (})}
Quality Issues: {quality_issues)
10
Target Quality Threshold: (target_quality)
Current Quality Score: Below threshold
REF INFMEEEENT STRATEGY:
Based on the feedback, determine what needs change:
1. **Color Issues**: If feedback mentions colors, provide new color scheme
15 2. **Layout Issues**: If feedback mentions spacing/layout, adjust layout specifications
3. **Typography Issues**; If feedback mentions text/fonts, update typography
4. **Overall Aesthetic*:: If feedback mentions visual appeal, try alternative design
REFINEMENT ACTION:
19 Choose the best approach and provide updated design specifications the same JSON
- format as the original primary design.
Focus on addressing the specific feedback while maintaining design coherence.
Return the refined design specification JSON.
Code Generator
and Microsoft Engineer specializing high-quality You are Alex Thompson, a code generation.
Analyze the following requirements to create CONCISE code generation plan: Context:
[safe__jso__dump (contxxt,, indent=2))
5
Design Specifications:
indent=2)}
Data Characteristics:
Shape: (data_result. pesult.proccssed..co _atasseedddddd.deee shape)
10 Columns: (distadat_resuult, www.esse.dpocseeeeco.. data..cluuns))
Quality Score: (data_result.dataa wtw.daaaaaalltlyscrrrrreo
(enhanced_ fixes_str)(requuu tttgggirreeeettsssttttoooo..... strr
Please provide detailed code generation analysis in JSON format:
"code_arche" aerieurcccttttree" [
16
: ["function names and purposes"], ffllttoonf" ["utility functions needed"], "class_structure:: "needed classes if any", "modular_design". "how to structure the code"
20
), "maaplottib_apprroo"t {
meattttinn_method.:: "plt. sulplots figure| wwwpo/bteeeeetttteeeeeeeee
maaylle_mmnaeement: "rcParams stylemsstsllleeeeesseeeee Imanual".
24
"colorr_imlemmnteaie "colormap maanull_colors cycler",
"layout_strategy" "tight_layout hartt_llyoutggrrdspppp cor.ddsecccootttaaineellllgeeeie
},
"data_ "aatta_handiig":
"iata_preparratio"" ["preprocessing steps"],
29
"data_validation" ["validation checks"],
"error_handling ["error scenarios to handle"],
"performance_consiie considerttiiis.."sss" ["optimization strategies"]
},
30

---

Published as a conference paper at ICLR 2026
"imports": ["required imports"), "configuration": "setup and configuration code", "main poaiinnpotting: "core plotting logic", "customization": "styling and customization", "output__handlngg.. "save and display logic"
35
}.
40
qualitty_reuuirementt"... {
"code_style"" "PEP8 looglelspecific_sstyle tetummentttio__eeell' sunnima//standdrd/o/mrreeeeeette
"error_ jarror__aadling_leeee level": "basici comprehensive", pnrrformance_prioritt "readability" (tl.ancybaaaadddaaaae speed"
Focus on creating clean, maintainable, efficient code that accurately implements the
design speci ficaiiicssoos.
Debug Agent
You are Jordan Martinez, debugging specialist. Fix this Python matplotlib code. ISSUE ANALYSIS:
(json.dumps (emporperr__aaalyyee indent=2))
5
CURRENT CODE:
"python
(code)
ERROR MESSAGE:
10
(error_msg)
TASK: Search the internet to fix this issue completely. Provide your analysis in this JSON format:
14
oowoooeeelllllplol synter (rnntimm | importt llggic", "root_cause": "detailed explanation of the issue", Goverllapiingeeeeentte. ["if overlap, list affected elements"], criissing_reqirremenn
"error_type":
"what needs to be added changed", "error_low lerrorrlocation": "where the issue occurs in the code", "fixed_codee code": "your fixed matplotlib code", "confidence" 0.0-1.0
18
19
Visual Evaluator
You are Dr. Elena Vasquez, Harvard Psychology PhD and Adobe UX Researcher specializing in human perception, visual cognition, and chart validation. Analyze this matplotlib visualization with STRICT semantic accuracy requirements: wty__context((ke_ooonnne Image Properties: [safe__soon_dmml dumps (image_propertien indent=2))
5
Data Context:
Shape: (data.shape)
Columns: (list (distdddaaccollumms)
Data Types: [dict(zip columns, [str(dtype) for dtype in data. (ata.dtypes]))3
PERFORM DETAILED SEMANTIC VALIDATION:
1. **Data-Query Alignment**; Does the visualization show the EXACT data relationships
- requested?
15
2. **Mathematical Accuracy**: Are formulas, functions, and calculations correctly implemented?
3. **Visual Element Compliancex*: Are all requested visual elements (colors, markers, labels, axes) present correct?
17 4. **Layout and Structure**; Does the plot structure match the specification (subplots, dimensions, arrangement)?
5. *MProfessional Standardsw:: Does it meet publication-quality visualization standards?
IMPORTANT SEMANTIC CHECKS:
31

---

true/false, Published as a conference paper at ICLR 2026
If query asks for specific mathematical functions, verify they correctly visualized
If query specifies data ranges or axis limits, verify they correctly set
22 If query requires specific colors or styling, verify exact compliance
If query asks for multiple subplots with specific content, verify each subplot individually
If query specifies markers, line styles, visual effects, verify they correctly applied
25
Respond with detailed JSON assessment:
"semantic_accuracy"::
"data_query_mateh" matchh": rexcellent fair
29
cetthemmticcl_corrreteeeeee "excellent goodd fair sailppoo", "excellent good fairr crait_sstruuuur__eee "excellent goood fair |porr",
"visual_e www.eeeeeeemmppllleeeeeeeeeeeeee
"specification ampecifiiatiionddddernneee..ee
wwwpeaaaeeeeeeerrrreeeeeeeeeeeee :coree: 0.0 0-0
),
qquality_assessment {
overall_quality"" "excellent / good fair
"readability": "excellent good fair|
"visual_appeal": thigh/mediuee low",
[professional_ppeaaa apppearacce. pyossnolpartially"
39
}. "requirement_analyiis" ["list specific requirements correctly implemented"),
fecsy_oonntscoovree
they_pointt__missinn"" ["list specific requirements implemented"), "critical_errors" ["list major deviations from requirements"", 0.0-1.0
}. "accessibility_cheet"" {
48
true truelfalsse false, ceext_size_adeuutte fause, "wcag_complliace__eeww level": "AA]Alnone"
faaborbiind_fiendd]]
},
riiiallrrccomeeaation"... [
"decision": "approve revise
"confidence__evee" 0.0-1.0,
"pprimaryjisuues" ["list main problems"), "improvement_prioritt""" "high medium llow"
Be extremely strict in semantic validation. A visualization that doesn't t match the query requirements should receive scores regardless of aesthetic quality.
32


Reviews:
[{"review_id": "QGok3LAcmA", "reviewer": "Reviewer_LJKQ", "summary": "This paper addresses the limitations of existing natural language-to-visualization (NL2Vis) systems in handling complex datasets (e.g., multi-file, large-scale) and iterative refinement. It proposes CoDA (Collaborative Data-visualization Agents), a multi-agent framework that decomposes visualization tasks into specialized modules: Query Analysis, Data Processing, VizMapping, Search, Design Exploration, Code Generation, Debugging, and Visual Evaluation. CoDA leverages metadata-centric preprocessing to bypass LLM token limits, iterative reflection for quality refinement, and modular agent collaboration to handle diverse expertise (linguistics, statistics, design). Key contributions include: (1) a collaborative multi-agent paradigm reframing visualization as a distributed problem-solving task; (2) specialized agents and structured workflows that robustly handle complex data and iterative edits; (3) extensive evaluations showing CoDA outperforms baselines (MatplotAgent, VisPath, CoML4VIS) by up to 41.5% on benchmarks like MatplotBench and Qwen Code Interpreter; and (4) validation of core components (self-evolution, global TODO list, Search Agent) via ablation studies.", "questions": "See Weaknesses.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "1. CoDA introduces originality through a task-specific multi-agent decomposition tailored to visualization workflows. Unlike prior single-agent (MatplotAgent) or simplistic multi-agent (VisPath) systems that focus on initial query parsing, CoDA’s specialization (e.g., metadata-focused Data Processor, image-based Visual Evaluator) and iterative reflection loops address unmet needs in handling multi-file data and post-generation refinement. \n2. The work demonstrates high quality through rigorous experimentation: (1) diverse benchmarks (MatplotBench, Qwen Code Interpreter, DA-Code) covering mid-to-high complexity tasks and real-world software engineering scenarios; (2) clear metrics (Execution Pass Rate, Visualization Success Rate, Overall Score) that capture both code reliability and visualization fidelity.\n3. CoDA’s significance lies in its practical and foundational impacts: (1) it reduces the “unseen tax” of manual data preparation/visualization for analysts, aligning with real-world needs in data science and business intelligence; (2) it establishes a scalable, extensible multi-agent template for NL2Vis that can integrate new tools/models (e.g., scientific plotting); (3) it addresses critical gaps in prior work (token limits, multi-source data, iterative refinement) that hindered adoption of NL2Vis systems.", "weaknesses": "1. CoDA’s multi-agent collaboration incurs non-trivial overhead: it uses 32,095 input tokens and 14.8 LLM calls per query (Table 5), far exceeding simpler baselines like CoML4VIS (2,350 tokens, 1 call). The paper acknowledges this but provides limited analysis of latency in real-world use cases (e.g., interactive dashboards, real-time data exploration). For example, the authors do not report end-to-end response times, making it unclear if CoDA’s performance gains justify the computational cost for time-sensitive applications.\n2. While CoDA outperforms baselines on DA-Code (a real-world SWE benchmark), the comparison is only against DA-Agent. Recent multi-agent NL2Vis systems like NVAgent  or PlotGen also target complex scenarios but are not included. \n3. The paper tests CoDA with gemini-2.5-pro, gemini-2.5-flash, and claude-4-sonnet, but provides little insight into performance with weaker or domain-specific LLMs (e.g., qwencoder, starcoder, opencoder). For example, it is unclear if CoDA’s metadata preprocessing or example retrieval can compensate for LLMs with poor code generation capabilities—a critical consideration for adoption in resource-constrained environments.\n4. The paper highlights successful cases but provides little analysis of when CoDA fails. For example: What types of queries (e.g., highly ambiguous, domain-specific) or data characteristics (e.g., unstructured metadata, missing schema information) lead to poor performance?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "bUPkLBUcaO", "reviewer": "Reviewer_uC8e", "summary": "This paper proposes CoDA, a highly comprehensive multi-agent system for data visualization. Through extensive experiments across various benchmarks, the authors demonstrate the superiority of the proposed system and the effectiveness of its individual modules.", "questions": "Please refer to the weakness", "limitations": "", "rating": 8, "confidence": 4, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "- A **well-designed multi-agent system** for data visualization is implemented, capable of **self-iterative optimization** through multiple rounds of refinement, achieving strong performance across benchmarks.\n\n- Extensive validation experiments are conducted, including comparisons with multiple existing agent systems and **ablation studies** to verify the effectiveness of individual modules. The paper also evaluates **efficiency and computational cost**, which is a valuable contribution for multi-agent system research.\n\n- In the input stage, the authors propose **pattern recognition for metadata** instead of directly processing raw data, effectively reducing computational overhead from model calls.", "weaknesses": "- The **accuracy of the visual evaluation module** within the multi-agent system lacks validation. Comparative experiments with human evaluations and repeated evaluations for stability could strengthen the claims.\n\n- The paper lacks **independent evaluation metrics for visualization aesthetics**. It is unclear whether the iterative process in the multi-agent system leads to noticeable improvements in visual quality.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "yAbYC58EX2", "reviewer": "Reviewer_Qu8H", "summary": "This paper presents CoDA (Code Data Acquisition), an agentic system for automating the collection, filtering, and augmentation of code datasets. CoDA integrates agents for discovery, filtering, and enhancement (e.g., annotations, test cases, cross-language code), enabling task-specific, high-quality data construction. Experiments show that datasets built with CoDA improve performance on tasks like code summarization and bug fixing, highlighting its value as a scalable framework for dynamic code data acquisition.", "questions": "1. You frame CODA as \"collaborative,\" yet the workflow appears to be a sequential pipeline with a feedback loop. Are there more dynamic, non-sequential interactions, such as negotiation or conflict resolution between agents, that justify the \"collaborative\" paradigm over a \"pipeline\" model?\n2. How does CODA handle queries with high-level semantic ambiguity (e.g., \"show the impact of marketing\")? If the Query Analyzer makes a conceptually flawed plan from such a query, can downstream agents detect this fundamental misinterpretation of intent, or is their feedback limited to the execution of the flawed plan?", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The paper shows strong originality by proposing the first systematic agentic framework for code data acquisition, moving beyond static scraping of repositories to a dynamic, multi-agent pipeline.\n\nIn terms of quality, the framework is well-structured, covering discovery, filtering, augmentation, and evaluation with clear design choices such as iterative feedback loops and cross-language code generation.\n\nThe work has good clarity, with the overall workflow, agent roles, and experimental settings described in a logical and understandable way, making the contribution easy to follow.\n\nIts significance is high: CoDA demonstrates measurable improvements on downstream tasks like code summarization and bug fixing, providing a scalable and adaptable approach to building higher-quality datasets for code LLMs.", "weaknesses": "1. The system includes multiple components (discovery, filtering, augmentation, evaluation), but there is no ablation study to quantify the contribution of each. Such analysis would clarify which parts of CoDA are most critical.\n2. I suggest using this framework to synthesize data and apply SFT or RL (Reinforcement Learning) to improve the performance of open-source models.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)