Skip to content

CoDA: Agentic Systems for Collaborative Data Visualization

🕒 Published (v1): 2026-01-01 · Source: ICLR · Venue: ICLR 2026 · link

Why this paper was selected

Tomas Pfister/Sercan Arik (Google); agentic collaboration for automated data visualization

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

CoDA is a multi-agent system for automated data visualization that decomposes natural language-to-plot tasks across specialized LLM agents—query analysis, data processing, visual mapping, code generation, debugging, and self-reflective quality evaluation. By operating on metadata rather than raw data and applying iterative feedback loops, CoDA avoids context-window exhaustion and brittle single-pass pipelines. It outperforms strong baselines by up to 41.5% in Overall Score across multiple benchmarks.

Problem

Existing NL-to-visualization systems—whether single-agent (MatplotAgent), multi-step planners (VisPath), or workflow-centric (CoML4VIS)—concentrate reasoning on initial query parsing and ingest raw data directly. This causes token limit violations on large or multi-file datasets, brittle error recovery, and poor iterative refinement. None robustly combines metadata-aware data handling with persistent quality-driven self-reflection across the full pipeline.

Method

CoDA instantiates a collaborative multi-agent pipeline with seven specialized agents communicating through a shared memory buffer:

  1. Query Analyzer — parses intent, decomposes query into a global TODO list and downstream guidelines.
  2. Data Processor — extracts metadata (schemas, statistics, column types) via lightweight tools (pandas), bypassing raw-data ingestion to avoid token limits.
  3. VizMapping Agent — maps query semantics to chart primitives (chart type, data-to-visual bindings) using metadata, not raw data.
  4. Search Agent (tool) — retrieves relevant code examples from Matplotlib documentation and the Python Graph Gallery.
  5. Design Explorer — generates aesthetic specifications (color scheme, layout, typography) and quality metrics/success indicators.
  6. Code Generator — synthesizes executable Python code from all upstream specs.
  7. Debug Agent — executes code with timeouts, diagnoses errors via web search, and applies fixes.
  8. Visual Evaluator — scores the output image across multi-dimensional quality metrics (clarity, accuracy, aesthetics, layout, TODO completion); if scores fall below threshold \(\theta_q = 0.85\), it triggers targeted re-routing to upstream agents. The loop halts at convergence or after a maximum of 3 refinement iterations.

The metadata-centric approach is the key architectural invariant: agents never load full data files, operating only on summarized schema and statistical metadata.

Key Contributions

  • CoDA framework: extensible multi-agent system with role-specialized agents covering the full NL→visualization pipeline, including a quality-gated self-reflection loop.
  • Metadata-centric preprocessing: structured upfront data summarization that circumvents LLM context-window limits on large/multi-file datasets.
  • Substantial benchmark gains: up to +41.5% OS over VisPath, +24.5% over MatplotAgent on MatplotBench, +7.4% over the best baseline on Qwen Code Interpreter, and ~2Ă— DA-Agent's score (39.0% vs. 20.5%) on DA-Code.
  • Backbone-agnostic design: consistent OS gains across Gemini-2.5-Pro/Flash, Claude-4-Sonnet, and open-source Qwen3-VL, demonstrating gains are architectural, not model-specific.
  • Ablation validation: global TODO list, self-evolution loop, and Search Agent each provide statistically significant independent contributions.

Results

  • MatplotBench (100 queries, matplotlib-based):
  • CoDA OS: 79.5% vs. MatplotAgent 55.0% (+24.5%), VisPath 38.0% (+41.5%), CoML4VIS 53.0% (+26.5%)
  • CoDA EPR: 99.0%, VSR: 79.8%
  • Qwen Code Interpreter Benchmark (163 examples):
  • CoDA OS: 89.0% vs. best baseline (CoML4VIS) 79.1% (+7.4% absolute)
  • CoDA EPR: 93.3%, VSR: 95.4%
  • DA-Code Benchmark (78 SWE-oriented visualization tasks):
  • CoDA OS: 39.0% vs. DS-STAR 20.5% (~1.9Ă—) and DA-Agent (Gemini-2.5-Pro) 19.23% (+19.77% absolute)
  • Backbone ablation on MatplotBench OS: Gemini-2.5-Pro 79.5%, Gemini-2.5-Flash 77.7%, Claude-4-Sonnet 75.2%, Qwen3-VL 73.7% — all outperform the best baseline under each backbone (max baseline OS ≤ 65.2%)

Limitations

  • Maximum 3 refinement iterations and threshold \(\theta_q = 0.85\) are fixed hyperparameters; optimal values likely task- and domain-dependent.
  • Self-reflection quality is bounded by the Visual Evaluator's own LLM judgment, which may be miscalibrated for uncommon chart types.
  • Efficiency analysis is mentioned but truncated in the provided text; runtime/cost overhead of 7-agent coordination relative to single-agent baselines is not fully reported here.
  • Evaluated exclusively on Python/Matplotlib-centric benchmarks; generalization to declarative visualization stacks (Vega-Lite, D3.js) is untested.
  • DA-Code performance (39%) still leaves substantial headroom, reflecting difficulty of open-ended SWE-embedded visualization tasks.

Relevance to Agentic AI / LLM Agents

CoDA is a concrete demonstration of role-specialized multi-agent decomposition solving a practical engineering task that monolithic LLM calls and shallow multi-agent systems fail at. Its metadata-centric context management—having agents operate on summaries rather than raw inputs to avoid token exhaustion—is a transferable design principle applicable to agentic pipelines over large files or repositories. The quality-gated self-reflection loop (Visual Evaluator → upstream re-routing) is a practical instantiation of the evaluate-and-correct feedback pattern studied broadly in agentic AI. The backbone-agnostic results directly validate a recurring hypothesis in the multi-agent literature: that collaborative architecture yields gains orthogonal to base model capability, not simply from scaling the underlying LLM.