🤖 AI

Agentic Authoring of Interactive Multiview Visualizations in Genomics

This paper investigates agentic LLM approaches for authoring interactive multiview genomics visualizations, finding that iterative agent-based schemes significantly improve output quality over direct generation and fixed pipelines, while more complex multi-agent architectures offer no additional benefit.

Original authors: Astrid van den Brandt, Kiroong Choe, Sehi L'Yi, Devin Lange, Nils Gehlenborg

Published 2026-06-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Astrid van den Brandt, Kiroong Choe, Sehi L'Yi, Devin Lange, Nils Gehlenborg

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a scientist trying to tell a story using a very complex, specialized language called Gosling. This language is used to draw maps of the human genome (our DNA) on a computer screen. These maps aren't just simple bar charts; they are like interactive, multi-layered atlases where you can zoom in from a whole chromosome down to a single letter of DNA, and different layers (like gene activity or protein binding) must line up perfectly.

The problem is that writing the code for these maps is hard. It's like trying to write a novel in a language you've only read about in a dictionary, without ever speaking it.

This paper asks: Can Artificial Intelligence (AI) learn to write these complex genome maps for us? And more specifically, is it better to ask one AI to do it all in one go, or to use a team of AIs working together?

Here is the story of their experiment, explained simply:

The Cast of Characters (The AI Schemes)

The researchers tested six different ways to get an AI to write these genome maps. Think of these as different "workforce strategies":

The "One-Shot" Artist: You ask the AI one question, and it tries to write the entire map code instantly. No second chances.
The "Assembly Line": You break the job into three strict steps (Find the data, Draw the shapes, Arrange the layout) and pass the work down a line.
The "Solo Specialist": One AI agent that does everything but gets to look at its own work, realize mistakes, and fix them before showing you the final result.
The "Team of Specialists": A team of three different AIs. One finds the data, one draws the shapes, and one arranges the layout. They pass the work back and forth to fix errors.
The "Solo Specialist + Critic": The solo agent works, but a second "Reviewer" AI checks the final product for style and clarity.
The "Team + Critic": The whole team works, plus a Reviewer checks the final product.

The Test Drive

They gave these AI "workers" 159 different tasks. Some tasks were easy (e.g., "Show me this specific gene"), some were vague (e.g., "Show me something interesting about this gene"), and some were very complex (e.g., "Build a whole interactive genome browser").

They measured two things:

Did it look good? (Perceived Quality: Did it make sense to a human expert?)
Was the code perfect? (Structural Similarity: Did the code match the "correct" answer exactly?)

The Big Surprises (The Results)

1. The "Team" didn't beat the "Solo" worker.
You might think a team of specialists plus a critic would be the best. But the researchers found that the "Solo Specialist" who could iterate (try, fail, fix, try again) was just as good as the complex teams. In fact, the complex teams were slower and cost more money (in computer processing power) without producing better maps. The extra "critic" agent didn't really help; it mostly just added noise.

2. Iteration is the magic sauce.
The biggest winner was Agentic Iteration. This means the AI gets to see a "screenshot" of the map it just drew, realize, "Oh, I put the gene labels in the wrong place," and then fix it. This "generate-render-inspect-fix" loop was much better than just trying to get it right the first time (One-Shot) or following a rigid assembly line.

3. The AI gets confused by "Vague" requests.
When the human user was vague (e.g., "Show me something cool"), the AI struggled to make the different parts of the map talk to each other (like zooming in on one part and having the other parts zoom in too). This "interaction" part was the hardest thing for the AI to get right, even with the best team.

4. The "Assembly Line" failed.
Surprisingly, the rigid, step-by-step assembly line performed worse than just letting the AI try to do it all at once. The researchers think this is because the steps were too separated. If you fix the data in step 1, you might break the layout in step 3, and the rigid system couldn't go back and fix the first step.

The Takeaway

The paper concludes that for building these complex, interactive genome maps:

Don't over-engineer the team. You don't need a huge committee of AIs.
Do give the AI a mirror. The most important thing is giving the AI a way to see its own mistakes (by rendering a picture of the map) and letting it fix them.
Grammar and AI are a good match. The strict rules of the Gosling language act like guardrails, keeping the AI from going off the road, while the AI's ability to iterate helps it navigate the tricky parts of the road.

In short: A single, self-correcting AI worker is currently the most efficient and effective way to build these complex scientific maps, beating out both the "one-shot" guessers and the "over-engineered" teams.

Technical Summary: Agentic Authoring of Interactive Multiview Visualizations in Genomics

Problem Statement

Genomics research demands highly specialized visualizations that integrate heterogeneous data types (e.g., BigWig, BED, BAM, VCF) into multi-view, interactive layouts. While Large Language Models (LLMs) show promise for democratizing visualization authoring via natural language, they face significant hurdles in this domain:

Complexity: Genomics visualizations often require multi-track compositions, coordinated interactions (brushing, linking), and domain-specific idioms (e.g., cytogenetic bands, gene directionality) that generic LLMs struggle to generate correctly in a single pass.
Ambiguity: User queries often lack explicit data references or visualization intent, requiring clarification and domain-informed design decisions.
Limitations of Current Approaches: Existing tools either lack customization or require programming expertise. While agentic systems have been proposed for general visualization, their efficacy in complex, multi-view genomics contexts remains underexplored, and there is no consensus on optimal agent architectures (e.g., single vs. multi-agent, presence of a reviewer).

Methodology

Dataset and Scenarios

The authors constructed an evaluation dataset of 159 cases derived from 53 ground-truth Gosling specifications (a declarative grammar for genomic visualization). These cases span:

Three Complexity Levels (L1–L3): From single-track charts (L1) to complex, application-style genome browsers with coordinated views and heterogeneous data (L3).
Three Query Scenarios (S1–S3):
- S1: Unambiguous queries with explicit data and intent.
- S2: Vague requests requiring data disambiguation or intent clarification.
- S3: Analytical goals without prescribed visual forms, requiring domain-informed design.
Evaluation Protocol: Each case was executed three times per scheme, totaling 2,862 runs using GPT-5.4-2026-03-05.

Authoring Schemes

Six distinct schemes were compared, ranging from non-agentic baselines to complex agentic configurations:

Direct Generation: A single LLM call producing a full Gosling spec (Vanilla baseline).
Fixed Pipeline: A hand-crafted, three-step chain (Data Resolution → Encoding → Composition) without iterative feedback.
Single-Agent: One generalist agent iteratively generates, renders, inspects, and fixes the spec.
Multi-Agents: Three specialist agents (Query-Data Alignment, Visual Element Compliance, Layout & Structure) collaborating in a shared loop.
Single-Agent + Reviewer: The generalist agent plus a holistic reviewer.
Multi-Agents + Reviewer: The three specialists plus a holistic reviewer.

All agentic schemes utilize a generate-render-inspect-fix loop, where agents modify specifications based on rendered screenshots and a shared coordination protocol. A User Proxy Agent simulated user clarification for ambiguous queries (S2/S3).

Evaluation Metrics

Output quality was assessed via two independent axes:

Perceived Quality: Scored by an LLM-as-a-judge on eight quality dimensions identified through preliminary analysis of vanilla LLM failures:
- D1: Mark & Encoding Appropriateness
- D2: Query Compliance
- D3: Layout & Composition
- D4: Interaction & Coordination
- D5: Axes & Legends
- D6: Proactive Enhancements
- D7: Styling & Visual Clarity
- D8: Data Compliance
Structural Similarity: Measured via Context-Free Grammar (CFG) similarity against the ground-truth specification.

Key Contributions

Characterization of Failure Modes: Identification of eight recurring quality dimensions where vanilla LLMs fail in genomics visualization (e.g., inability to render composite glyphs for gene tracks, failure to implement coordinated brushing, and bias toward suppressing genomic axes).
Evaluation Framework: A novel framework using a User Proxy Agent to simulate realistic query ambiguity, enabling evaluation beyond fully specified benchmarks.
Comparative Analysis: A systematic evaluation of six authoring schemes, isolating the effects of agentic iteration, agent specialization, and reviewer presence.

Results

Agentic Iteration vs. Baselines

Perceived Quality: Agentic schemes significantly outperformed both Direct Generation and Fixed Pipeline baselines (explaining 43.2% of variance). The iterative "generate-render-inspect" loop allowed models to self-correct design choices that a single pass missed.
Structural Similarity: Agentic schemes showed minimal improvement over baselines in structural similarity, though they were more resilient to increasing specification complexity (L3).
Complexity Resilience: As complexity increased from L1 to L3, Direct Generation quality dropped sharply (-0.45), while agentic schemes degraded much less (-0.31).

Architectural Choices

Specialization & Reviewers: Contrary to intuition, adding more agents (Multi-Agent) or a Reviewer did not significantly improve perceived quality.
- Single-Agent and Multi-Agent schemes achieved comparable quality.
- The Reviewer agent contributed near-zero improvement in perceived quality and slightly degraded structural similarity.
- Per-step analysis revealed that primary authoring agents (Query-Data, Visual Encoding) drove improvements, while Layout/Structure and Reviewer agents contributed minimally.
Cost Efficiency: Agentic schemes incurred significantly higher token and time costs. The Single-Agent configuration achieved the best balance, offering baseline-level quality at the lowest cost among agentic options.

Metric Independence

Perceived quality and structural similarity were found to be statistically independent ( $r = 0.001$ ), confirming that a visualization can be structurally different from the ground truth yet perceived as high quality (or vice versa).

Significance and Claims

The paper claims that agentic iteration is the primary driver of quality improvement in domain-specific visualization authoring, rather than architectural complexity. Key implications include:

Complementarity of Grammars and Agents: Specialized grammars (like Gosling) act as guardrails to limit the output space, while agentic iteration allows the system to flexibly search within that space and correct errors via visual feedback. This combination is more effective than rigid pipelines or single-pass generation.
Diminishing Returns on Complexity: Simply adding more agents or reviewers does not yield better results. The authors suggest that future gains may come from tighter coupling between agents and grammar semantics (e.g., finer-grained validation tools) rather than adding more roles.
Limitations: The study acknowledges that results are specific to the GPT-5.4 model and the Gosling grammar. The evaluation was fully autonomous, lacking human-in-the-loop validation, and the User Proxy may not fully capture the difficulty of real-world user interactions.

In conclusion, the authors posit that for complex, multi-view genomics visualization, a simple, iterative agentic loop is sufficient to outperform non-agentic baselines, and that further architectural complexity offers negligible benefits without more precise tooling integration.