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

Agentic systems for collaborative data visualization via deep research paradigm [ICLR 2026]

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 LLM system that decomposes natural-language-to-visualization tasks into four specialized pipeline stages—Understanding, Planning, Generation, and Self-Reflection—each handled by dedicated agents communicating through a shared memory buffer. By operating on metadata summaries rather than raw data files, CoDA sidesteps LLM token limits while a quality-driven reflection loop iteratively refines outputs. On MatplotBench and Qwen Code Interpreter benchmarks, CoDA outperforms the best single- and multi-agent baselines by up to 41.5% overall score.

Problem

Existing NL-to-visualization systems—both single-agent (MatplotAgent) and naive multi-agent (VisPath, CoML4VIS)—concentrate reasoning on initial query parsing and ingest raw data directly, causing token limit violations, brittleness on multi-file datasets, poor error recovery, and no persistent quality-driven refinement. They lack coordinated specialization across the full pipeline from data understanding through aesthetic evaluation.

Method

CoDA instantiates a seven-agent collaborative pipeline backed by any LLM backbone (tested with Gemini-2.5-Pro/Flash, Claude-4-Sonnet, Qwen3-VL):

  1. Query Analyzer — parses intent, builds a global TODO list, emits plotting guidelines.
  2. Data Processor — extracts schemas, statistics, and transformation hints via lightweight tools (e.g., pandas) without loading raw files, circumventing context window limits.
  3. VizMapping Agent — maps semantics to chart primitives, selects chart type, validates data-to-visual bindings against metadata.
  4. Search Agent (tool) — retrieves ranked code examples from Matplotlib docs / Python Graph Gallery to seed generation.
  5. Design Explorer — generates color schemes, layout specs, quality metrics, and implementation guidelines.
  6. Code Generator — synthesizes executable Python integrating all upstream specs.
  7. Debug Agent — executes code with timeouts, web-searches error fixes, returns corrected code and output image.
  8. Visual Evaluator — scores the rendered image across clarity, accuracy, aesthetics, layout, and TODO completion; routes low-scoring dimensions back to the responsible upstream agent.

Agents communicate via a shared memory buffer; the reflection loop halts when scores exceed threshold \(\theta_q = 0.85\) or after a maximum of 3 iterations.

Key Contributions

  • CoDA framework: modular, extensible multi-agent pipeline with role-specialized LLM agents covering the full NL→visualization lifecycle.
  • Metadata-centric preprocessing: avoids raw data ingestion, resolving token-limit failures on large/multi-file datasets.
  • Quality-driven self-reflection: image-based Visual Evaluator feeds structured issue reports back upstream, enabling iterative refinement grounded in perceptual quality metrics.
  • Backbone-agnostic design validated across four model families (two proprietary, one open-source VLM).
  • Global TODO list as a shared task tracker that agents update collaboratively throughout execution.

Results

MatplotBench (100 queries): - 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 VisPath 81.6% (+7.4%) - CoDA EPR: 93.3%; VSR: 95.4%

DA-Code Benchmark (78 SWE-oriented tasks): - CoDA OS: 39.0% vs. DS-STAR 20.5% (~2Ă— gain) and DA-Agent (Gemini-2.5-Pro) 19.23% (+19.77% absolute)

Cross-backbone (MatplotBench OS): - Gemini-2.5-Pro: 79.5% | Gemini-2.5-Flash: 77.7% | Claude-4-Sonnet: 75.2% | Qwen3-VL: 73.7% - CoDA consistently exceeds all baselines across all four backbones; best baseline never exceeds 65.2% OS.

Ablation (stated as significant): self-evolution loop, global TODO list, and Search Agent each provide statistically significant positive impact on OS.

Limitations

  • Maximum 3 reflection iterations is a hard cap; deeper or more ambiguous tasks may not converge within budget.
  • Visual Evaluator is LLM-based, introducing circular evaluation risk if the same model generates and judges.
  • Efficiency analysis is noted but not fully detailed in the provided text; latency and token cost at scale are unquantified.
  • Evaluated only on visualization-oriented benchmarks; generalization to other code-generation domains is unverified.
  • Claude-4-Sonnet underperforms Gemini variants under high-context loads, suggesting agent interaction design remains backbone-sensitive in practice.

Relevance to Harnesses / Meta-Harnesses

CoDA exemplifies a domain-specific agentic harness: it wraps multiple LLM agents in a structured pipeline with shared state, quality-gated feedback loops, and modular interchangeability—precisely the architecture pattern that meta-harnesses formalize. The global TODO list functions as a persistent task registry (analogous to a harness task queue), and the Visual Evaluator's score-threshold halting criterion mirrors harness-level loop control logic. The backbone-agnostic design demonstrates how a harness abstraction can decouple orchestration logic from the underlying model, a key property for building reusable meta-harness frameworks. Work in this area should study CoDA's metadata-centric preprocessing and quality-gated reflection as concrete instantiation patterns for harness components that manage context limits and convergence conditions.