ArXiv: 2512.14336

🎯 Pitch

Vision-language models can plan animations and write code, yet they still produce broken SVG motion because native vector files fragment meaningful parts into disconnected low-level shapes. This paper shows that recovering the semantic grouping of SVG primitives—via statistical aggregation of noisy VLM predictions—is the missing step that unlocks coherent animation, outperforming even Sora 2 video generation at a fraction of the file size.

1. Executive Summary

This paper introduces Vector Prism, a framework that recovers the semantic structure of Scalable Vector Graphics (SVG) files to enable vision-language models (VLMs) to animate them reliably. The system operates on a curated dataset of 114 animation instructions paired with diverse SVG files sourced from SVGRepo, using GPT-5-nano as the underlying VLM for semantic labeling and GPT-5 for animation code generation. The core mechanism is a statistical inference process based on the Dawid-Skene model that aggregates multiple weak, view-dependent part predictions from VLMs—rendered through focused visualizations such as highlighting, isolation, zoom-in, outlining, and bounding boxes—and recovers the underlying reliability of each rendering method via eigenvector analysis of pairwise agreement patterns, then applies a Bayes decision rule to assign robust semantic labels to each SVG primitive. Vector Prism achieves a GPT-T2V instruction-following score of 76.14, outperforming both existing vector animation methods (GPT-5 at 40.92) and state-of-the-art video generation models (Sora 2 at 69.08), while producing vector-based animations that are ~54× smaller in file size than raster video equivalents. The improvement holds only when the input SVG provides sufficient primitive granularity, establishing that semantic recovery unlocks coherent VLM-driven animation but cannot compensate for atomic primitives that lack the internal decomposition required by the animation instruction.

2. Context and Motivation

The Core Problem: SVGs Are Structurally Mismatched to Semantic Reasoning

The fundamental problem this paper addresses is architectural rather than algorithmic: Scalable Vector Graphics files, as they exist in the wild, encode visual information in a way that is actively hostile to semantic reasoning by vision-language models. An SVG file describes a graphic not as a collection of meaningful objects (a "car," a "sun," a "tree"), but as a flat or arbitrarily nested list of geometric primitives—<path>, <rect>, <circle>, <ellipse>, <line>, <polyline>, and <polygon>—organized primarily to satisfy the constraints of the rendering pipeline. The hierarchy reflects paint order (what gets drawn on top of what), not part-whole relationships. As Figure 2 illustrates, visually coherent elements like bunny ears and nose are often fragmented across multiple disconnected primitives, while unrelated shapes may be grouped together under a single <g> tag because they happen to share a transformation matrix or were authored in the same editing session.

This mismatch creates a specific, diagnosable failure mode when VLMs attempt to animate SVGs. The VLM, which reasons about visual content at a semantic level ("the sun should rise upward"), must issue animation commands that operate at the syntactic level of the SVG ("apply a translation transform to the element with id #path47"). If the mapping between semantic concepts and SVG primitives does not exist—and in practice, it almost never does—the VLM has no way to target the correct shapes. The paper formalizes this as a semantic-syntactic gap: VLMs possess strong semantic understanding (they can look at a rasterized SVG and describe what should move) but cannot connect that understanding to the engineering task of actually moving the right pixels because the SVG's internal structure provides no semantic scaffolding.

Why This Problem Matters: The Economic and Technical Imperative for SVG Animation

The significance of this problem extends well beyond an interesting technical curiosity about file formats. SVGs have become "increasingly central to modern web experiences" (Section 1) for three compounding reasons that collectively create enormous economic pressure to solve the animation problem:

1. Resolution independence is non-negotiable in modern web design. SVGs describe graphics through mathematical curves rather than pixel grids, meaning they scale infinitely without quality loss. As the web fragments across an ever-expanding landscape of device sizes, pixel densities, and aspect ratios—from smartwatches to 8K monitors—the alternative of shipping multiple resolution variants of raster assets (PNGs, JPEGs) becomes combinatorially unmanageable. SVGs solve this problem at the representational level, but only if they can participate fully in the dynamic, animated experiences that modern interfaces demand.

2. Bandwidth constraints make video unconscionably expensive for web animation. The paper quantifies this directly in Section 5.1: Sora 2, a state-of-the-art video generation model, produces animation files that are on average 54× larger than SVG-based equivalents. This is not an implementation inefficiency—it is a fundamental consequence of the representational formats. A raster video must encode every pixel of every frame, growing with resolution and duration. An SVG animation describes motion through symbolic CSS keyframes applied to geometric primitives, independent of output resolution. For web environments where page load time directly impacts user engagement and revenue, a 54× compression ratio is transformative. Video-based animations, however visually impressive, cannot compete economically for the lightweight assets that modern web performance budgets require.

3. The demand for animation is growing faster than the supply of skilled animators. As web interfaces evolve toward richer, more dynamic experiences, the volume of animation assets needed across an organization's digital surface area grows proportionally. Hand-authoring CSS animations for each SVG in a design system is expert-intensive, slow, and brittle to design changes. An automated pipeline that accepts an SVG and a natural language instruction ("make the buttons bounce in one by one") and produces production-ready animated output would represent a step-change in design tooling productivity. The paper's framing—"generating animations simply by instructing a VLM given the SVG file" (Section 1)—directly addresses this economic bottleneck.

The problem also carries theoretical significance that transcends vector graphics specifically. The semantic-syntactic gap is a general phenomenon in AI systems that must bridge symbolic, human-interpretable reasoning (what should happen) with engineering-level, machine-executable representations (how to make it happen). The same gap appears in code generation (VLMs reasoning about what a function should compute vs. producing correct syntax), robotic planning (reasoning about goals vs. generating motor commands), and 3D scene manipulation (reasoning about object relationships vs. editing mesh vertices). SVG animation is a clean, self-contained instance of this broader challenge—one where the gap is stark enough to study in isolation but the solution principles may generalize. If the paper's approach to recovering semantic structure from an ill-structured symbolic representation succeeds here, it suggests a template for bridging similar gaps in other domains where VLMs must interact with engineering-optimized representations.

Where Existing Approaches Fall Short

The paper situates its contribution against three distinct classes of prior work, each of which fails for a different reason that the paper's approach is designed to address.

Optimization-based animation methods (e.g., AniClipart) operate on pixels, not structure. As described in Section 2, this line of work—represented by AniClipart [35] and earlier approaches [17, 31, 42, 43]—optimizes animation parameters (keypoint movements, deformation fields) by computing gradients from pre-trained image or video diffusion models, typically via Score Distillation Sampling (SDS) [22]. The diffusion prior provides strong perceptual signals that encourage temporally smooth, appearance-preserving motion. However, the gradient flows through rasterized renderings, not through the SVG's structural representation. The optimization sees a sequence of pixel grids and pushes animation parameters to produce plausible pixel-level transitions. It has no mechanism to learn that a particular set of <path> elements collectively constitutes a "hand" that should rotate at the wrist. The consequences are visible in the paper's qualitative results (Figure 4): AniClipart animations tend toward uniform, small-amplitude motion (swaying, gentle pulsing) rather than the semantically targeted, large-displacement transformations (spinning, bouncing, sequential reveals) that user instructions request. The paper's diagnosis is precise:

"Without explicit temporal regularization, the optimization often settles into short repetitive motions with visible jitter." (Section 2)

This is not a failure of the optimization—it is a natural consequence of operating on the wrong representational level. The diffusion prior carries rich visual information but no structural information about which pixels belong to which semantic part. Without that structural knowledge, the optimizer cannot safely move one part independently of its neighbors without risking visual artifacts, so it conservatively produces small, global motions that avoid breaking spatial coherence.

Fine-tuned LLM approaches scale with data, not understanding. A second active stream (Section 2), represented by InternSVG [29], StarVector [25], and OmniSVG [40], fine-tunes large language models to directly output vector graphics parameters or animation commands from text or image inputs. These models are trained end-to-end on large paired datasets of SVGs and human instructions. The paper's critique is pointed:

"Because LLMs carry little understanding for vector geometry and scene hierarchies, performance scales primarily with data, often requiring millions of examples." (Section 2, citing [19, 46])

The implication is that these models learn a kind of statistical shortcut—a mapping from instruction text to animation code that works on in-distribution examples but does not reflect genuine comprehension of the SVG's spatial or semantic structure. The paper positions its approach as orthogonal to data scaling: rather than training the LLM to be better at SVGs, restructure the SVGs so that even a naive LLM can succeed. This is a fundamentally different philosophy: fix the representation, not the model.

The paper also cites specific evidence (Section 4.2) that naive prompting of even the most capable LLMs "rarely produces meaningful motion." When GPT-5—which the paper acknowledges as having "one of the best understandings of symbolic representation among LLMs" [20]—is prompted directly to generate animation code for an unstructured SVG, the results are poor. The paper augments GPT-5 with the same planning and generation pipeline used in Vector Prism for fair comparison, but the semantic recovery step remains the decisive differentiator.

Video generation models produce the wrong output modality. The paper's inclusion of Sora 2 [21] and Wan 2.2 [28] as baselines (Section 4.2) serves a specific rhetorical purpose: it demonstrates that even the most advanced generative models, producing visually impressive raster video, are solving a fundamentally different problem than the one that web animation requires. These models generate pixel-level video output where what is needed is lightweight, resolution-independent, code-based animation. The paper emphasizes this distinction with the "Vector" column in Table 1: AniClipart, GPT-5, and Vector Prism produce vector-based output (✓); Wan 2.2 and Sora 2 do not (✗). The 54× compression ratio quantified in Section 5.1 makes this more than a format preference—it is an order-of-magnitude difference in deployability for bandwidth-constrained web contexts.

How Existing SVGs Fail: The Semantic Fragmentation Problem

The paper provides concrete evidence of the semantic-syntactic gap through Figure 2, but the underlying mechanism is worth examining in detail because it explains why even sophisticated VLMs fail. SVG files are typically authored in vector graphics editors (Adobe Illustrator, Inkscape, Figma) where the designer's workflow involves creating layers, grouping objects for organizational convenience, and applying shared styles. When the file is exported to SVG, this authoring structure is flattened and transformed by several lossy processes:

  • Layers become <g> (group) elements, but the grouping logic reflects editing convenience, not semantic coherence. A single "character" might be split across multiple groups because the designer used separate layers for outlines, fills, and shadows.
  • Visually continuous shapes may be decomposed into multiple primitives because the renderer uses a specific triangulation or path decomposition algorithm. A single curved line might become a <path> with a complex d attribute, while a filled region with a hole might be expressed as two overlapping shapes with a fill rule.
  • The element IDs and class names are often auto-generated (#path47, .cls-3) and carry no semantic information. Even when a designer manually names elements, there is no standard ontology—one designer's "arm" is another's "limb_right_upper."
  • The paint order (what renders on top) constrains grouping. Two semantically related primitives (both part of the left eye) cannot be grouped together if one must be drawn behind the face shape and the other in front of the iris, because SVG groups enforce a single paint-order position.

The result, as the paper describes it in Section 1, is an SVG that is "optimized for rendering efficiency rather than semantic clarity." Every primitive has a precise geometric definition and a rendering instruction, but nothing in the file indicates which primitives collectively constitute a named, animatable part.

This is the specific gap that Vector Prism fills. The paper's framing—"the overlooked step of restructuring SVGs so that vision-language models can reason about meaningful parts during animation" (Section 1)—positions the work not as a new animation technique or a better language model, but as a preprocessing infrastructure that makes existing animation pipelines viable. The contribution is infrastructural: provide the missing semantic layer, and the downstream models (VLMs for planning, LLMs for code generation) can succeed.

How This Paper Positions Itself: A Principled Recovery of Lost Structure

The paper's intellectual positioning can be understood through the analogy embedded in its name. A prism takes an apparently uniform beam of white light and reveals the structured spectrum of wavelengths within it—information that was always present but inaccessible to a sensor that treats the light as a single color. Similarly, Vector Prism takes an SVG's flat, unstructured collection of primitives and reveals the semantic structure that was lost during the authoring-to-export pipeline—information that is visually present (a human looking at the rendered SVG can immediately see the parts) but syntactically absent (a VLM looking at the SVG code cannot).

Crucially, the paper argues that this structure can be recovered rather than imposed. The primitive-level visual appearance contains sufficient information for a VLM to recognize that a particular <path> belongs to a "hand" or a "lightning bolt" or a "button"—but that recognition is noisy, inconsistent, and view-dependent. A VLM shown a primitive in isolation might misclassify it; shown the same primitive with a bounding box overlay, it might classify correctly but with different confidence. The paper's key theoretical move is to model these noisy VLM predictions not as failures to be eliminated through better prompting or fine-tuning, but as weak signals that can be statistically aggregated into reliable labels using an established framework from the crowdsourcing literature: the Dawid-Skene model [9].

This is a distinctive positioning relative to prior work on SVG understanding. Rather than:

  • Training a specialized model to parse SVG structure (the domain-specific classifier approach),
  • Fine-tuning a VLM to better understand SVG syntax (the data-scaling approach), or
  • Designing a new SVG format with embedded semantics (the standards approach),

the paper proposes a zero-training, statistical inference layer that sits between existing VLMs and existing SVG files. The VLM does not need to understand that it is being used in a Dawid-Skene framework; it simply responds to rendering queries, and the framework post-processes those responses. This modularity is deliberate: as VLMs improve, the statistical inference layer can remain unchanged, simply operating on better-quality weak labels. Conversely, improvements to the inference framework (different noise models, better reliability estimation) can benefit from better VLMs without retraining either component.

This positioning also explains the paper's emphasis on the semantic-syntactic gap as a general challenge rather than an SVG-specific quirk. The Dawid-Skene inference framework is domain-agnostic—it requires only that multiple noisy labelers (here, multiple renders of the same primitive shown to a VLM) produce conditionally independent predictions of the same latent variable. If the same gap appears in other symbolic representations (3D scene graphs, CAD assemblies, program abstract syntax trees), the same recovery strategy applies: render, query, aggregate, restructure.

3. Technical Approach

3.1 Reader Orientation

Vector Prism is a preprocessing system that takes an unstructured SVG file—where visually coherent parts are split across dozens of anonymous geometric primitives—and rewrites it into a semantically organized hierarchy where every primitive is tagged with a meaningful part label (e.g., “left_eye,” “lightning_bolt,” “button_3”). The system solves the semantic-syntactic gap by using a vision-language model to look at each primitive rendered in multiple complementary ways, collecting its noisy, inconsistent guesses about what that primitive represents, and then applying a statistical inference procedure based on the Dawid-Skene model to extract a single reliable label from that noisy evidence—without ever training or fine-tuning the VLM.

3.2 Big-Picture Architecture (Diagram in Words)

The system has two major stages connected by a semantic restructuring step:

  1. Animation Planning — The input SVG is rasterized into a single image. A VLM (GPT-5-nano) inspects this image alongside the user’s natural-language animation instruction and produces a JSON dictionary mapping semantic part names (e.g., “sun,” “cloud_left,” “button_1”) to short animation plans (e.g., “move upward while gradually increasing opacity”).

  2. Vector Prism (Semantic Restructuring) — Every primitive in the SVG is rendered individually through five different focused views (bounding box, isolation, highlight, outline, zoom-in). The VLM classifies each rendered primitive into one of the semantic categories from the planning stage, producing five weak labels per primitive. A Dawid-Skene statistical model estimates each rendering method’s reliability from pairwise agreement patterns across all primitives in that SVG. A Bayes-weighted vote then assigns each primitive its most probable true label. Finally, the SVG hierarchy is flattened and regrouped so that all primitives sharing a label become a single, animation-ready <g> group with a descriptive class name.

  3. Animation Generation — A separate LLM (GPT-5) receives the restructured SVG plus the animation plan, iterating one semantic class at a time, and produces CSS keyframe animation code that moves each semantic group according to the plan. Previously generated CSS is fed back as context, and a “lanes” convention prevents animation collisions.

Information flows: user instruction + raw SVG → planning VLM → semantic plan → Vector Prism (multiple renders per primitive → VLM weak labels → agreement matrix → reliability estimates → Bayes decision rule → labeled SVG) → restructured SVG + plan → iterative code-generation LLM → animated SVG.

3.3 Roadmap for the Deep Dive

This section proceeds in the order data flows through the system, because each stage’s output constrains the next stage’s input:

  • First, the animation planning stage (Section 3.2), which establishes the set of semantic categories and their intended motions—this defines the target vocabulary that Vector Prism must map primitives onto.
  • Second, the problem formalization and the Dawid-Skene model (Section 3.3), which is the mathematical core—understanding the statistical assumptions is essential before seeing how they are instantiated in the rendering and inference pipeline.
  • Third, the multi-view rendering strategy and the burn-in pass that collects weak labels and builds the empirical agreement matrix—this is the data-collection mechanism that feeds the statistical model.
  • Fourth, the reliability estimation procedure via eigenvector analysis of the centered agreement matrix—this is where the model recovers each rendering method’s unknown accuracy from observable agreement.
  • Fifth, the Bayes decision rule that converts estimated reliabilities into a single semantic label per primitive—this is the prediction step.
  • Sixth, the restructuring algorithm that transforms labeled primitives into an animation-ready SVG hierarchy—this is the engineering bridge between semantic inference and code generation.
  • Seventh, the animation generation stage with iterative CSS production and the lanes convention—this closes the loop from semantic labels to executable animation.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems paper with a statistical inference core, whose central technical contribution is not a new model architecture or training procedure, but rather the recognition that the Dawid-Skene framework for aggregating noisy crowd-worker labels can be repurposed to aggregate noisy VLM predictions across multiple renderings of the same SVG primitive, recovering reliable semantic labels without any VLM fine-tuning.

Animation Planning: Establishing the Semantic Vocabulary

The planning stage (Section 3.2) defines what semantic categories exist for a given SVG. The input SVG is rasterized into a single image at 512 × 512 resolution so that the VLM can process it visually, since “VLMs lack an understanding of the symbolic structures (i.e., SVG syntax)” (Section 3.3) but possess strong visual reasoning when shown raster renderings. The VLM (GPT-5-nano, chosen for being “25× more cost-efficient than GPT-5” per Section 4.3) receives this raster image and the user’s natural-language animation instruction.

The VLM is prompted to produce a JSON dictionary where each key is a human-interpretable semantic part name and each value is a short description of the intended motion. The prompt enforces several constraints:

  • Elements should be animated individually or in “thoughtfully grouped sets” that share similar motion or timing.
  • Elements of similar type that should have different animations (e.g., multiple stars) must be named distinctly (e.g., left_star, center_star).
  • Names must avoid generic SVG tag-based identifiers (circle, rect, path) and instead use meaningful role- or position-based names.
  • The total number of elements should be kept in a “manageable range (e.g., 5–10)” so that animation complexity remains tractable.
  • Special characters that interfere with JSON or directory paths (#, :, \, /, ;) are forbidden.

The output is a mapping from semantic categories to animation plans—for example, when the instruction is “make the sun rise,” the planner might output {"sun": "move upward from below horizon to center-top", "sky": "gradually brighten from dark blue to light orange"}. This plan defines the label set $\mathcal{Y} = \{1, \dots, k\}$ that Vector Prism will use in the next stage: every primitive in the SVG must ultimately be assigned to one of these $k$ categories.

The planning stage provides semantic understanding (what should move and how) but deliberately avoids any contact with SVG syntax. This separation of concerns is critical: the planner reasons about visual content at the level a human designer would, freed from the engineering detail of which primitive element corresponds to which semantic part. Closing that gap is the sole responsibility of Vector Prism.

Problem Formalization: The Dawid-Skene Model for SVG Primitives

The paper formalizes the semantic labeling problem (Section 3.3) by mapping SVG primitives to a standard statistical model for aggregating noisy labels. Let $\mathcal{X}$ be the set of all primitives in the SVG—these are the atomic geometric elements: <path>, <rect>, <circle>, <ellipse>, <line>, <polyline>, and <polygon>. Each primitive $x \in \mathcal{X}$ has an unknown true semantic label $y(x) \in \mathcal{Y} = \{1, \dots, k\}$ where $k$ is the number of semantic categories identified in the planning stage.

The VLM cannot inspect a primitive directly—primitives are syntactic objects defined by coordinates and path strings. To make a primitive visually interpretable, it must be rendered into a raster image. The paper uses $M$ different rendering methods indexed by $i \in \{1, \dots, M\}$, each providing a “complementary view” of the same primitive (Section 3.3). The five methods used are bounding box overlay, isolation on a blank background, highlighting on the original canvas, outlined rendering, and zoomed crop (detailed in Section 3.4 under Multi-View Rendering). When rendering method $i$ is applied to primitive $x$ and the resulting raster image is shown to the VLM, the VLM returns a label $s_i(x) \in \mathcal{Y}$. This label is a weak prediction—potentially correct, potentially wrong, with unknown reliability.

The paper models these VLM responses using the Dawid-Skene model [9], a classical model from the crowdsourcing literature originally developed to estimate the error rates of multiple human annotators labeling the same items. The model makes two key assumptions:

  1. Each rendering method $i$ has an unknown accuracy $p_i$, which is the probability that the VLM, when shown a primitive rendered with method $i$, outputs the correct label:

Pr⁡[si=ℓ]={pi,ℓ=y,1−pik−1,ℓ≠y.\Pr[s_i = \ell] = \begin{cases} p_i, & \ell = y, \\ \frac{1-p_i}{k-1}, & \ell \neq y. \end{cases}

where $s_i$ is the VLM’s output label, $y$ is the true (unknown) label of the primitive, and $\ell$ is any candidate label in $\mathcal{Y}$. The first case ($\ell = y$) is the probability of a correct response, which is $p_i$. The second case ($\ell \neq y$) covers all $k-1$ possible wrong labels; the model assumes that when the VLM makes an error, it picks uniformly among the $k-1$ incorrect labels, so the probability of any specific wrong label is $\frac{1-p_i}{k-1}$.

What this equation computes: for a given rendering method $i$ with accuracy $p_i$, the probability that the VLM outputs label $\ell$ when shown a primitive of true class $y$. If $\ell$ matches the truth, the probability is $p_i$; if not, the probability is split evenly among the $k-1$ wrong answers.

Why this form: the symmetric error assumption (uniform distribution over wrong labels) is the simplest noise model that captures the idea that a rendering method has a single reliability parameter $p_i$ independent of which specific wrong answer is produced. A more complex model could assign different confusion probabilities to different label pairs (e.g., the VLM might confuse “left_eye” with “right_eye” more often than with “background”), but that would require estimating $O(k^2)$ parameters per rendering method rather than $O(k)$, which is intractable given the modest number of primitives in a typical SVG. The symmetric model requires estimating only $M$ parameters (one $p_i$ per rendering method), making estimation stable even with relatively few primitives.

  1. The VLM responses from different rendering methods are conditionally independent given the true label. This means that knowing the VLM’s answer from the bounding-box render does not change the probability distribution over answers from the isolation render, once the true class is known. This assumption would be violated if, for example, a particular primitive is inherently ambiguous (a shape that genuinely could be either “nose” or “beak”) and all rendering methods tend to fail on it in correlated ways. The paper implicitly relies on the diversity of views to decorrelate errors—different views emphasize different visual features, so even if the primitive is ambiguous, different views might fail for different reasons, partially satisfying independence.

The goal of Vector Prism is to recover (a) the unknown reliabilities $p_1, \dots, p_M$ and (b) the true label $y(x)$ for each primitive $x$, using only the observed VLM responses $s_i(x)$ collected across all primitives and all rendering methods.

Multi-View Rendering: Producing Weak Labels

Before the statistical machinery can operate, the system must collect VLM responses for every primitive under every rendering method. This happens in a burn-in pass (Section 3.3, Figure 3b) that traverses all primitives in the SVG exactly once per rendering method.

The paper uses $M = 5$ rendering methods, each designed to provide a “focused visualization” that emphasizes different aspects of the primitive’s visual identity:

  1. Bounding box overlay: The primitive is shown in context on the original canvas, with a tight bounding box drawn around it. This provides spatial context—the VLM can see what other primitives are nearby—while the bounding box disambiguates which specific shape is being queried.

  2. Isolation on a blank background: The primitive is rendered alone, separated from all other visual elements. This eliminates distraction from adjacent shapes but removes contextual cues about the primitive’s role within the whole composition. A small curved path that belongs to a character’s smile might be unrecognizable in isolation but clearly a facial feature with context.

  3. Highlight on the original canvas: The primitive is rendered in the full scene but visually highlighted (e.g., with a distinct color or glow). This is a middle ground between bounding box and isolation: the VLM sees the global context but has a strong visual cue about which element is the query target.

  4. Outlined rendering: Only the outline (stroke) of the primitive is shown, without fill. This emphasizes the shape’s contour geometry independently of its color or texture, which can be diagnostic for primitives whose identity depends more on shape than appearance.

  5. Zoomed crop: A magnified view of the region around the primitive. This helps when the primitive is small at the default 512 × 512 render resolution and its details are below the VLM’s effective resolution threshold.

For each primitive $x$ and each rendering method $i$, the system renders the primitive at 512 × 512 resolution, shows the raster image to GPT-5-nano, and asks it to classify the primitive into one of the $k$ semantic categories from the planning stage. The VLM returns a label $s_i(x)$, which may be correct or incorrect depending on the rendering method’s (unknown) reliability for that particular SVG’s visual characteristics.

The key design insight is that different rendering methods have complementary failure modes. A primitive that is ambiguous in isolation (because it lacks context) may be unambiguous with a bounding box; a primitive whose details are invisible at standard zoom may be clear when zoomed in. By collecting multiple weak labels per primitive, the system creates redundancy that the statistical inference stage can exploit: methods that tend to agree with each other are likely both reliable; methods that frequently disagree with the consensus are likely unreliable.

The paper notes an important practical detail: “We do not share the agreement matrix across SVGs, since we find that the reliability of each rendering method can vary depending on the visual complexity and structure of the SVG” (Section 4.3). This means the burn-in pass is repeated for every new SVG. The computation is linear in the number of primitives times the number of rendering methods ($M \times |\mathcal{X}|$ VLM queries), which the paper characterizes as “minimal computational overhead” for the lightweight GPT-5-nano model.

Building the Agreement Matrix: From Pairwise Co-Occurrence to Reliability

After the burn-in pass collects VLM responses for all primitives under all rendering methods, the system builds an empirical agreement matrix $\hat{\mathbf{A}} \in \mathbb{R}^{M \times M}$. For any pair of rendering methods $i$ and $j$, the entry $\hat{\mathbf{A}}_{ij}$ is the fraction of primitives for which methods $i$ and $j$ produced the same label:

A^ij=1∣X∣∑x∈X1[si(x)=sj(x)].\hat{\mathbf{A}}_{ij} = \frac{1}{|\mathcal{X}|} \sum_{\mathbf{x} \in \mathcal{X}} \mathbf{1}[s_i(\mathbf{x}) = s_j(\mathbf{x})].

where $|\mathcal{X}|$ is the total number of primitives in the SVG, and $\mathbf{1}[\cdot]$ is the indicator function (1 if the labels match, 0 if they differ). This is a purely observational statistic: it counts how often two rendering methods agree, without knowing which (if either) is correct.

What this computes: for every pair of rendering methods $(i, j)$, the empirical probability that they output the same label when shown the same primitive. If both methods are highly accurate, they will agree on most primitives because they both produce the true label. If one method is accurate and the other is random, their agreement rate will be close to $1/k$ (chance). The diagonal entries $\hat{\mathbf{A}}_{ii}$ are trivially 1 (a method always agrees with itself) and are not used in the subsequent analysis.

Why this form: agreement is the only observable signal that does not require ground-truth labels. The system does not know which primitives belong to which semantic category—if it did, there would be no labeling problem to solve. But it can observe that the bounding-box view and the highlight view tend to agree on 80% of primitives, while the zoom-in view agrees with both only 35% of the time. This differential agreement is the fingerprint of differential reliability. The Dawid-Skene model provides the mathematical link between these observable agreement rates and the unobservable accuracies $p_i$.

The paper now uses the Dawid-Skene model to derive the relationship between agreement and reliability. Under the model’s assumptions, the expected agreement between methods $i$ and $j$ (for $i \neq j$) is:

Aij=Pr⁡[si=sj]=pipj+(1−pi)(1−pj)k−1.\mathbf{A}_{ij} = \Pr[s_i = s_j] = p_i p_j + \frac{(1-p_i)(1-p_j)}{k-1}.

The derivation (Lemma B.1 in the Appendix) decomposes agreement into two mutually exclusive events: both methods are correct (probability $p_i p_j$), or both are wrong but happen to pick the same incorrect label (probability $\frac{(1-p_i)(1-p_j)}{k-1}$ because there are $k-1$ possible wrong labels and the uniform-error assumption means each wrong label has equal probability).

This equation still mixes true skill with chance agreement—even two completely random methods (with $p_i = p_j = 1/k$) would agree with probability $1/k$ by pure guessing. To isolate skill from chance, the paper defines a centered skill parameter for each method:

δi=pi−1k.\delta_i = p_i - \frac{1}{k}.

This measures how much better method $i$ is than random guessing. A perfect method has $\delta_i = 1 - 1/k$; a random method has $\delta_i = 0$; a method worse than random (unlikely but possible if the VLM systematically misinterprets a view) would have negative $\delta_i$.

Substituting $p_i = 1/k + \delta_i$ into the agreement equation and simplifying yields:

Aij=1k+kk−1δiδj(i≠j).\mathbf{A}_{ij} = \frac{1}{k} + \frac{k}{k-1} \delta_i \delta_j \quad (i \neq j).

What this equation means: the agreement between two methods decomposes into a baseline chance rate ($1/k$) plus a product term that depends on both methods’ skills. If either method is random ($\delta_i = 0$ or $\delta_j = 0$), the product term vanishes and agreement equals chance. If both methods are better than random, their agreement exceeds chance in proportion to the product of their skills—two strong methods agree more than two weak methods.

The next step is to subtract the chance baseline to isolate the skill-dependent component. Define the centered agreement matrix $\mathbf{B}$ with entries:

Bij=Aij−1k(i≠j),Bii=0.\mathbf{B}_{ij} = \mathbf{A}_{ij} - \frac{1}{k} \quad (i \neq j), \quad \mathbf{B}_{ii} = 0.

The diagonal is set to zero because self-agreement carries no information about relative reliability. Substituting the expression for $\mathbf{A}_{ij}$:

Bij=kk−1δiδj(i≠j).\mathbf{B}_{ij} = \frac{k}{k-1} \delta_i \delta_j \quad (i \neq j).

This is the $(i, j)$-th entry of the matrix $\frac{k}{k-1} \boldsymbol{\delta} \boldsymbol{\delta}^\top$ on the off-diagonals, where $\boldsymbol{\delta} = [\delta_1, \dots, \delta_M]^\top$ is the vector of skill parameters. This matrix has a critical property: it is rank one (Proposition 1, Appendix B.1). An $M \times M$ rank-one matrix can be expressed as the outer product of a single vector with itself, which means all of its information is contained in one dimension—specifically, in the direction of $\boldsymbol{\delta}$.

Why rank one matters: if $\mathbb{E}[\mathbf{B}]$ is a scaled outer product $\frac{k}{k-1} \boldsymbol{\delta} \boldsymbol{\delta}^\top$, then $\boldsymbol{\delta}$ is proportional to the top eigenvector of $\mathbb{E}[\mathbf{B}]$. This means that by computing the top eigenvector of the empirical centered agreement matrix $\hat{\mathbf{B}}$ (built from the observed $\hat{\mathbf{A}}_{ij}$), the system can recover the unknown skill vector $\boldsymbol{\delta}$ up to a scaling factor—without ever knowing which labels are correct. This is the mathematical engine that makes the framework “zero-training”: the VLM never needs to be told whether its answers are right; the system infers reliability purely from the structure of agreements and disagreements.

Reliability Estimation: Eigenvector Analysis of the Centered Agreement Matrix

The empirical centered agreement matrix $\hat{\mathbf{B}}$ is computed from the burn-in pass data by substituting $\hat{\mathbf{A}}_{ij}$ for $\mathbf{A}_{ij}$:

B^ij=A^ij−1k(i≠j),B^ii=0.\hat{\mathbf{B}}_{ij} = \hat{\mathbf{A}}_{ij} - \frac{1}{k} \quad (i \neq j), \quad \hat{\mathbf{B}}_{ii} = 0.

Let $\lambda$ be the largest eigenvalue of $\hat{\mathbf{B}}$ and $\mathbf{v} \in \mathbb{R}^M$ be the corresponding eigenvector (the “top eigenvector”). Under the Dawid-Skene model, this eigenvector is proportional to the true skill vector $\boldsymbol{\delta}$. The proportionality constant is determined by requiring that the reconstructed matrix $\frac{k}{k-1} \hat{\boldsymbol{\delta}} \hat{\boldsymbol{\delta}}^\top$ matches the scale of $\hat{\mathbf{B}}$. Specifically:

δ^=λ(k−1)kv,\hat{\boldsymbol{\delta}} = \sqrt{\frac{\lambda(k-1)}{k}} \mathbf{v},

with the sign of $\mathbf{v}$ chosen so that $\sum_i \hat{\delta}_i \geq 0$ (the convention that most rendering methods are better than random—if this assumption were violated, the sign convention would produce negative $\hat{p}_i$, but the paper does not report this occurring in practice).

From $\hat{\boldsymbol{\delta}}$, the estimated reliability of each rendering method is simply:

p^i=1k+δ^i.\hat{p}_i = \frac{1}{k} + \hat{\delta}_i.

What this step computes: an estimate of how accurate each rendering method is, on a scale from $1/k$ (random guessing) to 1 (perfect), derived purely from pairwise agreement patterns. A method that agrees frequently with other methods that also agree with each other will receive a high $\hat{p}_i$. A method whose labels are uncorrelated with the consensus will receive a $\hat{p}_i$ near $1/k$. A method that systematically disagrees with the consensus could in principle receive $\hat{p}_i < 1/k$ (anti-correlated), though the sign convention prevents this.

Why eigenvector rather than, say, averaging agreement rates: the eigenvector decomposition exploits the rank-one structure that the Dawid-Skene model predicts. Simply averaging each method’s agreement with every other method would produce a vector $\bar{\mathbf{a}}$ where $\bar{a}_i = \frac{1}{M-1} \sum_{j \neq i} \hat{\mathbf{A}}_{ij}$, but this average agreement is a noisy function of $\delta_i$ that depends on the distribution of other $\delta_j$ values and has no clean theoretical justification. The eigenvector approach is the maximum-likelihood-motivated solution under the rank-one model: it finds the single direction that explains the most variance in the off-diagonal agreement structure.

The paper provides a theoretical quality guarantee in Theorem B.2 (Appendix B.2): with high probability, the estimated skill vector $\hat{\boldsymbol{\delta}}$ is close to the true skill vector $\boldsymbol{\delta}$ up to a scaling factor, with error decreasing as the number of primitives $n = |\mathcal{X}|$ increases and as the agreement estimates become more precise. The Davis-Kahan theorem from matrix perturbation theory bounds the eigenvector estimation error in terms of the spectral gap (the difference between the largest and second-largest eigenvalues) and the noise level in $\hat{\mathbf{B}}$. Since $\hat{\mathbf{B}}$ is an average over $n$ primitives, the noise decreases at a $1/\sqrt{n}$ rate, meaning that even SVGs with modest numbers of primitives (tens to low hundreds) provide enough samples for stable estimation.

A nuance worth noting: the Dawid-Skene model assumes that all primitives share the same set of reliabilities $p_i$. In reality, a rendering method’s reliability might vary across primitives—the zoom-in view might be highly reliable for large primitives but unreliable for tiny ones. The paper addresses this indirectly by computing a separate agreement matrix per SVG, so that the estimated $\hat{p}_i$ reflect the average reliability on that particular SVG’s characteristic primitive distribution. Within-SVG heterogeneity is absorbed into the noise of the agreement estimates.

The Bayes Decision Rule: From Reliabilities to Semantic Labels

With estimated rendering method reliabilities $\hat{p}_1, \dots, \hat{p}_M$ in hand, the system can now assign a single semantic label to each primitive by optimally weighting the five weak VLM labels. The decision rule is derived from Bayes’ theorem with a uniform prior over the $k$ semantic categories.

For a given primitive $x$ with observed VLM responses $\mathbf{s} = [s_1(x), \dots, s_M(x)]$, the log-posterior probability that the true label is $y \in \mathcal{Y}$ is:

log⁡P(y∣s)=const+∑i:si=ylog⁡p^i+∑i:si≠ylog⁡1−p^ik−1.\log P(y \mid \mathbf{s}) = \text{const} + \sum_{i: s_i = y} \log \hat{p}_i + \sum_{i: s_i \neq y} \log \frac{1 - \hat{p}_i}{k - 1}.

What this equation computes: the log-probability that $y$ is the correct label given the observed VLM responses. The first sum adds log-likelihood from every rendering method that agrees with the candidate label $y$—each such method contributes $\log \hat{p}_i$, which is large and positive for reliable methods, small and possibly negative for unreliable ones. The second sum adds log-likelihood from every rendering method that disagrees with $y$—each contributes $\log \frac{1-\hat{p}_i}{k-1}$, which is the log-probability that an unreliable method would output some specific wrong label. The constant term is independent of $y$ and can be dropped for the purpose of comparing candidate labels.

The paper simplifies this to an equivalent weighted vote:

wi=log⁡(k−1)p^i1−p^i,y^(x)=arg⁡max⁡y∈Y∑i:si(x)=ywi.w_i = \log \frac{(k-1)\hat{p}_i}{1 - \hat{p}_i}, \quad \hat{y}(x) = \arg\max_{y \in \mathcal{Y}} \sum_{i: s_i(x) = y} w_i.

What this step computes operationally: for each primitive, assign a weight $w_i$ to each rendering method $i$. The weight is the log-odds that the method is correct versus outputting a specific wrong answer. Then, for each candidate label $y$, sum the weights of all rendering methods that voted for $y$. Pick the label with the highest total weight as the final semantic label $\hat{y}(x)$.

Why weighted rather than majority vote: the paper provides a formal proof in Appendix B.3 (Theorem B.5) that the Bayes-weighted vote has a strictly better error exponent than majority voting whenever the rendering methods have unequal reliabilities. Intuitively, majority voting treats a confident, accurate bounding-box vote (weight $w_i$ large) identically to a chance-level zoom-in vote (weight $w_i \approx 0$), allowing a few unreliable methods to swing the decision on primitives where the reliable methods are nearly tied. The weighted vote amplifies the influence of reliable methods and suppresses the influence of unreliable ones.

The paper quantifies this improvement in the small-error regime (where all $p_i$ are close to $1/k$) using Hoeffding’s inequality. The error probability for the Bayes decision rule is bounded by:

Pr⁡[error]≤exp⁡(−(∑iwidi)22∑iwi2),\Pr[\text{error}] \leq \exp\left(-\frac{(\sum_i w_i d_i)^2}{2 \sum_i w_i^2}\right),

where $d_i = p_i - \frac{1-p_i}{k-1} = \frac{k p_i - 1}{k-1}$ is a discrimination parameter measuring how much better method $i$ is at identifying the true label versus any specific wrong label. For majority voting, all weights are 1, and the exponent becomes $\frac{(\sum_i d_i)^2}{2M}$. Under the small-error approximation $w_i \approx k d_i$, the Bayes exponent becomes $\frac{1}{2} \sum_i d_i^2$, and the improvement factor is:

ExponentBayesExponentMajority≈1+Var(d)(Mean(d))2.\frac{\text{Exponent}_{\text{Bayes}}}{\text{Exponent}_{\text{Majority}}} \approx 1 + \frac{\text{Var}(d)}{(\text{Mean}(d))^2}.

What this ratio means: if all methods have the same discrimination $d_i$, the variance term is zero and Bayes weighting is equivalent to majority voting. If methods vary in reliability, the Bayes exponent is strictly larger, meaning the error probability decays faster as more rendering methods are added. The more heterogeneous the reliabilities, the greater the advantage of weighting. The paper’s qualitative example in Figure 7 illustrates this concretely: with one unreliable method (correct only by chance) and four reliable ones, majority voting occasionally lets the unreliable method flip the decision, fragmenting semantically coherent groups, while Bayes weighting consistently downweights the noisy method and produces stable, correct labels across all primitives.

After the Bayes decision rule assigns a label $\hat{y}(x)$ to every primitive, the system has transformed a flat list of anonymous geometric primitives into a labeled collection where each primitive is tagged with a human-interpretable semantic category (e.g., “left_ear,” “right_button,” “lightning_bolt”).

Semantic Restructuring: From Labels to Animation-Ready SVG

The final step of Vector Prism (Section 3.3, “From semantic labels to a new structure,” and Appendix F, Algorithm 2) converts the labeled primitives into an SVG hierarchy that the downstream animation generator can manipulate. This step is described as “straightforward” once labels are available, but involves non-trivial engineering to ensure that regrouping does not alter the visual appearance.

The restructuring algorithm proceeds in four phases:

1. Flattening. The original SVG is traversed in paint order (the order primitives are drawn, which determines what renders on top of what). All nested <g> groups are dissolved: every primitive $e$ is cloned, and any visual properties (fill, stroke, opacity, transform) that were inherited from its parent groups are baked directly into the clone’s attributes. This produces a flat list $E$ of primitives, each with:

  • A clone of the original geometry with all inherited properties explicitly applied.
  • An original paint-order index $\text{idx}$ to preserve rendering order.
  • The predicted semantic label $\ell = \hat{y}(e)$ appended as a CSS class.
  • A screen-space bounding box $B$ for overlap testing.

The key invariants are that the flattened SVG renders identically to the original and that every primitive now carries its semantic label as a directly attached class attribute.

2. Conflict-aware regrouping. Primitives are grouped by label, but naive grouping—placing all primitives with label $\ell$ into a single <g>—would break paint order. If primitives A and C are both labeled “eye” but primitive B (labeled “face”) lies between them in draw order, wrapping A and C into a single group would pull C in front of B (because SVG groups render atomically at a single position in the paint order). The paper introduces a barrier test to prevent this: two primitives with the same label can be merged into the same group only if no primitive of a different label that lies between them in paint order overlaps them in screen space. If a barrier primitive overlaps, the candidate primitives must remain in separate groups (e.g., eye-group-1 and eye-group-2).

3. Metadata annotation. Each resulting group is augmented with:

  • Its collective bounding box (union of member bounding boxes).
  • Its geometric center (computed from the bounding box), which serves as the default transform-origin for rotation and scale animations.
  • Paint-order index (position of the group’s earliest member in the original order).
  • Parent and children links derived from the animation plan (e.g., a “hand” group might be marked as a child of “arm” if the plan specifies hierarchical motion).

This metadata is what enables the downstream animation generator to write physically plausible CSS: knowing the geometric center of a “hand” group allows the LLM to set transform-origin correctly so that rotation pivots around the wrist rather than some arbitrary coordinate.

4. Output composition. The regrouped SVG $S'$ is assembled by copying the original SVG’s root attributes (viewBox, xmlns) and non-drawable elements (defs, style blocks), then emitting each group as a <g> element with class $\ell$-group (or $\ell$-group-$k$ if the label was split across multiple groups). Group members appear in their original relative paint order, and the groups themselves are ordered by the earliest paint index among their members.

The result is an SVG that “looks identical but is organized into meaningful parts ready for animation” (Section 3.3). A human inspecting the code would see <g class="sun-group">, <g class="cloud_left-group">, etc., each containing the relevant primitives with all visual properties intact.

Animation Generation: Iterative CSS Production with Lanes Convention

The final stage (Section 3.4) takes the restructured SVG and the animation plan and produces executable CSS animation code. The paper adopts an iterative generation strategy to work around the token-generation limits of LLMs: “Animation code can become lengthy, often exceeding the token generation limits of many models.”

The process iterates over the semantic categories one at a time. For each category class_name:

  1. The LLM (GPT-5, the more capable model, used for code generation rather than the lightweight GPT-5-nano used for labeling) receives three inputs:

    • The restructured SVG (the full file, so the model can inspect element geometry and coordinate systems).
    • All previously generated CSS from earlier iterations (retained in context to maintain consistency).
    • The animation plan for class_name (a short natural-language description from the planning stage).

  2. The LLM produces a <style> block containing CSS keyframe animations specifically for the target class. The prompt enforces a lanes convention to prevent animation conflicts across iterations. Rather than writing transform properties directly inside @keyframes blocks—which would cause later animations to overwrite earlier ones if both target the transform property—the model writes to typed CSS custom properties:

    • --{class_name}-tx1 / --{class_name}-tx2 for translation x (start/end)
    • --{class_name}-ty1 / --{class_name}-ty2 for translation y
    • --{class_name}-rot1 / --{class_name}-rot2 for rotation
    • --{class_name}-sx1 / --{class_name}-sx2 for scale x
    • --{class_name}-sy1 / --{class_name}-sy2 for scale y
    • --{class_name}-op1 / --{class_name}-op2 for opacity
    • --{class_name}-blur1 / --{class_name}-blur2 for blur filter
    • --{class_name}-stroke1 / --{class_name}-stroke2 for stroke properties
    • --{class_name}-bright1 / --{class_name}-bright2 for brightness

    A single composer rule per class assembles these custom properties into the actual transform, opacity, filter, and other properties. Because each class uses its own namespace of custom properties, multiple animations targeting different classes never collide—each animates its own variables, and the composer rule per class reads only those variables.

  3. The generated CSS is appended to the accumulated style block and fed back as context for the next iteration. The prompt explicitly instructs: “Do NOT edit existing lanes. Put new motion on the next free lane(s).”

This iterative design solves several problems simultaneously. It prevents context-length overflow by generating CSS incrementally. It prevents animation conflicts through namespace isolation. It allows the model to reason about spatial relationships and timing coordination across classes (since previous animations are visible in context) while keeping each generation step focused on a single semantic unit. The paper notes that this approach enforces “strict animation rules that ensure mutual exclusivity between generated effects.”

Design choice: CSS over JavaScript or SMIL. The paper states that CSS was chosen “for its simplicity” but that the pipeline “has the capability to extend to complex animations using JavaScript or specialized libraries.” The CSS choice is pragmatic: CSS animations are declarative, hardware-accelerated in modern browsers, and produce compact code. The lanes convention extends naturally to CSS custom properties, which have wide browser support. For animations requiring complex sequencing logic (e.g., “bounce three times, then pause, then spin”), JavaScript might be necessary, but the paper’s evaluation dataset (Table 3) predominantly features animations (appearance/reveal, state transitions, organic movement) that are expressible in CSS keyframes.

Why iterative rather than generating all CSS at once: a single prompt that asks an LLM to animate all 5–10 semantic categories simultaneously would require the model to hold the full SVG, all animation plans, and all generated CSS in a single context window—which can easily exceed typical limits for complex SVGs with many primitives. The iterative approach amortizes context usage across multiple generation calls, trading latency (sequential API calls) for feasibility (staying within token limits). The lanes convention ensures that this decomposition does not introduce correctness bugs from later generations overwriting earlier ones.

4. Key Insights and Innovations

Innovation 1: Reframing the SVG Animation Problem as a Semantic-Syntactic Gap

The paper’s most fundamental conceptual move is diagnostic rather than methodological. Prior work on SVG animation—whether optimization-based methods like AniClipart [35] or LLM fine-tuning approaches like InternSVG [29]—implicitly assumed that the bottleneck was the model’s capability: if the VLM were better at understanding SVG syntax, or if the diffusion prior were stronger, or if the training dataset were larger, animation quality would improve. The dominant strategy was to build more capable models.

Vector Prism argues that this diagnosis is wrong. The bottleneck is not model capability but representational mismatch. The paper formalizes this as the semantic-syntactic gap (Section 1): VLMs possess the semantic reasoning required to plan animations (they can look at a rasterized SVG and correctly describe what should move and how), but they cannot connect that reasoning to the SVG’s engineering-level representation because the SVG encodes primitives optimized for rendering efficiency, not semantic coherence. A <path> that constitutes the left eye of a character has no syntactic marker distinguishing it from the thousands of other <path> elements in the file. The native SVG hierarchy reflects draw order, not part-whole relationships.

This reframing is distinctive because it relocates the problem from the model to the representation. The implication is that improving the VLM (through fine-tuning, better prompting, or scaling) is treating the symptom rather than the cause. If the SVG provides no semantic scaffolding, no amount of VLM capability can bridge the gap because the necessary information is simply absent from the input. As the paper demonstrates through its GPT-5 baseline (Table 1: 40.92 GPT-T2V score, versus 76.14 for Vector Prism), even a state-of-the-art model equipped with the identical planning and generation pipeline—just without semantic restructuring—performs dramatically worse.

The significance of this reframing extends beyond SVG animation. The semantic-syntactic gap is a general phenomenon in AI systems that must bridge human-level conceptual reasoning with machine-optimized symbolic representations: 3D scene graphs in graphics, abstract syntax trees in code generation, mesh representations in robotics. In each case, the representation is designed for a specific engineering purpose (rendering, compilation, simulation) and loses the semantic structure that would make it tractable for a reasoning system. Vector Prism provides a template for how to address this gap: recover the lost semantics from the visual signal, using the VLM as a perceptual sensor rather than as an end-to-end solver, and restructure the representation so that downstream models can operate at the semantic level they were designed for. This is not an incremental engineering contribution; it is a fundamental reframing of what problem needs to be solved and where the leverage lies.

Evidence for the gap being the true bottleneck: the qualitative results in Figure 4 show that both AniClipart and GPT-5, operating on unstructured SVGs, produce “uniform motion across entire figures, leading to swaying or barely moving animations,” while Vector Prism produces targeted, part-specific motion from the identical instruction. If model capability were the bottleneck, GPT-5—which the paper acknowledges as having “one of the best understandings of symbolic representation among LLMs” [20]—would perform substantially better than it does. The fact that a lightweight model (GPT-5-nano) with semantic restructuring dramatically outperforms a frontier model without it is direct evidence that the gap, not the model, is the active constraint.

Innovation 2: Treating VLM Predictions as Weak, View-Dependent Signals Rather Than as Authoritative Classifications

The paper’s second distinctive contribution is a philosophical stance on what VLM outputs mean. The dominant paradigm in VLM applications—whether for image captioning, visual question answering, or code generation—treats the model’s output as an authoritative answer to be accepted or rejected. If the model misclassifies an object, that is a failure to be corrected through better prompting, fine-tuning, or model improvement.

Vector Prism inverts this relationship. It models VLM responses as weak, noisy signals whose value lies not in their individual correctness but in their aggregate statistical structure. The VLM, when shown a primitive rendered in isolation, might confidently misclassify it. When shown the same primitive with a bounding box, it might classify correctly. When shown it zoomed in, it might produce a different error. The paper’s insight is that these inconsistent, view-dependent predictions are not failures to be eliminated but information to be exploited: the pattern of which views agree with which other views reveals each view’s reliability, and the reliability-weighted aggregate is more accurate than any individual view.

This stance is formalized through the Dawid-Skene model [9], but the innovation is not the adoption of Dawid-Skene per se—that model has been used in crowdsourcing for decades. The innovation is the recognition that VLMs function, in this context, as noisy crowd workers responding to different renderings of the same stimulus. The paper’s contribution is the connection between two previously unrelated domains: the statistical aggregation literature (Dawid-Skene, spectral methods for reliability estimation) and the VLM prompting literature (multi-view rendering, visual question answering about SVG parts).

The implication is that VLM reliability is view-dependent and unknown a priori, and that recovering it from agreement patterns is both possible and necessary. Prior work on using VLMs for SVG understanding (e.g., [44, 46]) assumed a single rendering modality and treated VLM accuracy as a fixed property of the model-dataset pair. Vector Prism demonstrates that accuracy varies substantially across rendering methods for the same primitive, and that this variation can be estimated without ground-truth labels via the rank-one structure of the centered agreement matrix (Proposition 1, Appendix B.1). The eigenvector recovery procedure (Section 3.3) is elegant precisely because it requires no labels: it infers reliability from the observable signal of which methods agree with which others on which primitives.

This is a fundamental shift in how to use VLMs for structured prediction tasks. Rather than asking “is the VLM correct?”, the framework asks “given that the VLM’s reliability varies across views and is initially unknown, how can I optimally combine its predictions?” The answer—estimate reliability from agreement, then apply Bayes-weighted voting—is principled and theoretically grounded (Theorem B.5 proves strictly better error bounds than majority voting whenever reliabilities differ). The shift from authoritative oracle to noisy sensor opens up a design space where VLMs can be deployed for tasks where they are individually unreliable but collectively informative—a pattern that likely generalizes to other domains where multiple complementary views of the same stimulus are available.

Evidence: the DBI clustering quality improvement from 33.8 (original SVG groupings) to 12.6 (majority voting) to 0.82 (Vector Prism) in Section 5.2. Majority voting, which treats all views as equally authoritative, is nearly 16× worse than reliability-weighted voting at producing semantically coherent clusters. This quantifies the gap between the “authoritative answer” paradigm and the “noisy sensor” paradigm in practical terms.

Innovation 3: Vector-Based Animation Can Outperform Raster Video Generation on Instruction Following When Semantics Are Recovered

This finding is counterintuitive and empirically surprising. The dominant narrative in the generative AI community is that video generation models—trained on internet-scale video-text datasets with billions of parameters—represent the ceiling of what is possible for motion generation. The paper’s inclusion of Sora 2 and Wan 2.2 as baselines (Section 4.2) reflects an expectation that these models, while producing the wrong output modality (raster video rather than vector animation), would at least achieve superior instruction-following and visual quality due to their massive scale and training data advantage.

The results in Table 1 directly contradict this expectation. Vector Prism achieves a GPT-T2V score of 76.14, exceeding Sora 2 (69.08) by a substantial margin and nearly quadrupling the naive GPT-5 baseline (40.92). On the CLIP-T2V metric, which measures video-text alignment using a pre-trained CLIP model, Vector Prism scores 21.55 versus Sora 2’s 20.29 and Wan 2.2’s 21.14. On DOVER, a perceptual quality metric, Vector Prism scores 4.97 versus Sora 2’s 4.19. The method achieves the best score on all three metrics while producing output that is ~54× smaller than raster video equivalents (Section 5.1).

What makes this finding significant beyond the raw numbers is what it reveals about the nature of the animation task versus the video generation task. Video generation models like Sora 2 are trained to produce visually plausible video from text descriptions, but “plausible video” and “instruction-following animation” are different objectives. The paper’s qualitative analysis (Section 4.5) diagnoses the failure mode precisely: video models “often collapse into static frames or distorted scenes when given dynamic, animation-focused instructions such as ‘An opening scene of the SVG.’” These models have learned to generate videos that look real, but animation instructions demand precise, semantically targeted motion—specific parts moving in specific ways at specific times—which is a different competency than photorealism.

Vector Prism succeeds not because it generates better pixels, but because it operates entirely in the symbolic domain. The planning stage reasons about semantic parts and their intended motions. The restructuring stage ensures that these semantic parts map correctly to executable SVG groups. The animation stage generates CSS keyframes that deterministically produce the specified motion. At no point does the system attempt to generate video pixels from scratch—it leverages the existing SVG geometry and applies mathematically precise transformations to it. This symbolic precision avoids the fundamental tension that video models face between visual realism and instruction fidelity.

This is a conceptual win for structured, interpretable representations over end-to-end generation for tasks where precision matters. It suggests that for certain classes of generative tasks—particularly those where the output must be executable (code), editable, or compositionally controllable—maintaining a symbolic representation throughout the pipeline may be strictly preferable to generating raster output, even when the raster generator is vastly larger. The 54× compression ratio (Figure 6) is the economic manifestation of this advantage: symbolic output encodes intent rather than appearance, and intent compresses dramatically better.

The finding also carries a methodological implication for evaluation: video generation models are often benchmarked on realism and visual quality, but instruction fidelity—does the output actually do what was asked?—may require separate evaluation and reveals different model rankings. The paper’s use of GPT-T2V as an instruction-following metric (Section 4.4) and the user study showing 83.4% alignment between GPT-T2V and human preferences (Appendix C) establishes that this dimension is measurable and that it surfaces differences that visual quality metrics alone would miss.

Evidence: Table 1 shows the clean sweep across all three metrics. Figure 5 shows human preference: Vector Prism is preferred over Sora 2 in pairwise comparisons despite Sora 2’s massive scale advantage. Figure 4 shows qualitative examples where video models produce static or distorted output on animation-specific instructions that Vector Prism handles correctly.

Innovation 4: Providing a Formal, Principled Alternative to Data Scaling for Symbolic Domains

The paper’s fourth contribution is positional rather than technical: it demonstrates, through a concrete working system, that the dominant data-scaling paradigm for LLM-based symbolic generation can be circumvented by restructuring the input representation. This is not an abstract argument—it is an empirical demonstration backed by a theoretical framework.

The data-scaling approach, represented by InternSVG [29], StarVector [25], and OmniSVG [40], fine-tunes LLMs on large paired datasets of vector graphics and human instructions. The underlying assumption is that LLMs “carry little understanding for vector geometry and scene hierarchies” (Section 2, citing [19, 46]) and that the path to competence is to expose them to enough examples that they learn the statistical regularities connecting instructions to SVG manipulations. This approach works—these models do improve with scale—but at the cost of requiring “millions of examples” and producing models that are brittle to distribution shift.

Vector Prism proposes an orthogonal path: fix the representation so that even an untuned VLM can succeed. The system uses a lightweight, cost-efficient model (GPT-5-nano, “25× more cost-efficient than GPT-5,” Section 4.3) for the semantic labeling that is the critical bottleneck step. This model is never fine-tuned; it is prompted in a standard zero-shot manner. The statistical inference layer handles the noise in its predictions. The result is a system that generalizes to “diverse, in-the-wild graphics” (Section 2) without ever seeing a training example of those specific SVGs or animation styles.

The theoretical framework supporting this position is the Dawid-Skene model, which provides sample-complexity guarantees that do not depend on the number of training examples seen. The reliability of each rendering method is estimated from n = |X| primitives in the target SVG, with estimation error scaling as 1/√n (Theorem B.2). For a typical SVG with tens to low hundreds of primitives, this is sufficient for stable estimation. The system does not need millions of training SVGs because it does not attempt to learn a general mapping from SVG primitives to semantic labels—it re-estimates the mapping per SVG, using the VLM’s inherent visual recognition capability as the base signal and the statistical framework to filter noise.

The improvement over majority voting provides the formal justification for why this approach is principled rather than heuristic. Theorem B.5 proves that when rendering methods have heterogeneous reliabilities—which is empirically the case, as different views emphasize different visual features—the Bayes-weighted decision rule achieves a strictly better error exponent. The improvement factor is 1 + Var(d) / (Mean(d))², meaning the gain is proportional to how much the rendering methods’ reliabilities differ. This quantitative relationship connects the design choice (using multiple complementary views) to the performance outcome (better labeling accuracy) through a rigorous statistical argument, not just empirical trial-and-error.

The practical implication is significant for resource-constrained settings: an organization does not need to collect millions of annotated SVGs or fine-tune a large model to enable SVG animation. A lightweight VLM, a statistical inference layer, and a restructuring algorithm suffice. This democratizes the capability in a way that data-scaling approaches, which concentrate capability in organizations with the resources to collect massive training corpora, do not.

The negative result with the ReST^EM-trained revision model (Appendix K in the paper, Figure 16, though the ReST^EM reference appears in the main paper’s Section 8) reinforces this point: attempting to improve the model through additional training actually degraded performance, suggesting that the revision task is sensitive to training data distribution in ways that the zero-shot + statistical inference approach elegantly sidesteps.

Evidence: Table 1 shows that a system built on an untuned, cost-efficient VLM exceeds the performance of commercial video generation models and massively outperforms the naively-prompted version of the same base model (GPT-5). The compression ratio (54×) and DBI improvements (33.8 → 0.82) quantify additional practical advantages that do not depend on model scaling. The paper’s design choice to report agreement matrices per SVG rather than sharing them across SVGs (Section 4.3) is motivated by the observation that reliability varies with SVG complexity—a choice that reflects the philosophy of adapting to each input rather than learning a universal model.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The test dataset consists of 114 hand-crafted animation instructions paired with 57 unique SVG files (averaging two instructions per SVG), sourced from SVGRepo. The SVGs span six thematic categories—Nature/Environment (31.6%), Objects/Miscellaneous (26.3%), UI/Interface Elements (15.8%), Tech Logos/Brands (10.5%), Animals/Characters (8.8%), and Faces/Emojis (7.0%)—and the instructions cover five interaction pattern categories: Appearance/Reveal (28.1%), State Transition (13.2%), Organic/Natural Movement (12.3%), Rotational Movement (8.8%), and Other/Mixed (37.7%) (Appendix D, Tables 2 and 3). The dataset was curated to “test a variety of SVG animation techniques” and “simulate real-world use cases in web environments” (Section 4.1). There is no mention of a separate training or validation split—the full 114 instruction-SVG pairs are used as the test set. This means all strategy selection and hyperparameter choices (e.g., which rendering methods to use, the number of difficulty bins in computing the agreement matrix per SVG) are either hardcoded or validated on this same set, with no held-out tuning data reported.

  • Base model(s). The system uses two models from the GPT family, partitioned by role. GPT-5-nano serves as the vision-language model for the planning and semantic labeling stages; the paper notes it is “25× more cost-efficient than GPT-5” (Section 4.3) and characterizes its use as enabling “lightweight models to perform reliably.” GPT-5 is used for the animation code generation stage, where “one of the best understandings of symbolic representation among LLMs” is required (Section 4.2). The paper provides no parameter counts, architecture details, or training data information for either model—both are accessed as commercial API services (OpenAI, 2025 [20, 21]), making the system not independently reproducible without API access to these specific model versions.

  • Metrics. Three complementary metrics are reported in Table 1, each capturing a different dimension of animation quality:

    • CLIP-T2V: Measures video-text alignment by computing the correspondence between the rendered animation video and the original instruction text using a video-pretrained CLIP model [24, 30]. Following InternSVG [29], this metric captures whether the visual content of the animation relates to the text instruction.
    • GPT-T2V: An LLM-as-judge metric where GPT grades each rendered animation video based on “how accurately its motion follows the given instruction” (Section 4.4). The evaluator prompt (Appendix C, Figure 9) asks the model to assign a score from 0–100 across five quality tiers (Perfect match 90–100, Good match 70–89, Partial match 50–69, Weak match 30–49, No match 0–29) and to provide reasoning. The paper reports 83.4% agreement between GPT-T2V pairwise preferences and human judgments in a user study (Appendix C), substantially higher than CLIP-T2V’s 53.4% agreement, establishing GPT-T2V as the more human-aligned automatic metric.
    • DOVER[33]: An off-the-shelf video quality assessment model that evaluates perceptual quality along both technical fidelity and aesthetic dimensions. The paper notes a potential tension between instruction following and perceptual quality: “limiting motion often leads to higher visual quality, whereas enforcing movement to meet the instruction can reduce perceptual fidelity” (Section 4.4). A “Vector” column in Table 1 indicates whether each method produces vector-based output (✓) or raster video (✗).

  • Baselines. Four baselines are compared (Section 4.2):

    • AniClipart[35]: Represents optimization-based animation methods that optimize animation parameters (keypoint movements) using Score Distillation Sampling (SDS) loss from pre-trained diffusion models. It outputs Bézier curves for keypoints within SVG files, producing vector-based animation. This is the only baseline that does not use an LLM/VLM for planning or generation.
    • GPT-5[20]: The same frontier model used by Vector Prism for code generation, but operating on the raw (unstructured) SVG. The paper augments GPT-5 with “the same high-level planning and animation generation pipeline employed in our framework to ensure fair comparison” (Section 4.2)—meaning this baseline strips out only the Vector Prism semantic restructuring step. This is the critical ablation: the gap between this baseline and Vector Prism isolates the contribution of semantic recovery.
    • Wan 2.2[28]: An open-source video generation model (14B parameters) that produces raster video (.mp4) output from text instructions. Included to represent the open-source video generation frontier.
    • Sora 2[21]: OpenAI’s commercial video generation service, producing raster video output. Included as the state-of-the-art in video generation overall. The video generation baselines (Wan 2.2, Sora 2) serve a specific comparative purpose: they demonstrate that even models trained on internet-scale video-text data, producing visually sophisticated output, underperform a symbolic, vector-based approach on instruction fidelity when that approach recovers semantic structure.

  • Generation budget / compute accounting. The paper does not standardize generation budget across methods in a way that enables direct FLOPs or cost comparisons. The key dimensions are:

    • For Vector Prism: The burn-in pass costs M × |X| VLM queries per SVG, where M = 5 rendering methods and |X| is the number of primitives. The planning stage costs one additional VLM query. The animation generation costs one LLM call per semantic category (typically 5–10). The paper characterizes this as “minimal computational overhead” (Section 4.3) but provides no absolute FLOPs counts, no wall-clock time measurements, and no dollar-cost estimates for the API calls.
    • For baselines: AniClipart uses gradient-based optimization with SDS loss; its compute cost scales with optimization steps and is not directly comparable. GPT-5 uses the same number of LLM calls as Vector Prism’s generation stage. Video models (Wan 2.2, Sora 2) use a single generation call.
    • Compression ratio (Section 5.1, Figure 6) provides an indirect comparison: Sora 2 produces files that are on average 54× larger than Vector Prism’s output. This measures storage/bandwidth efficiency rather than generation cost. The absence of normalized compute accounting is a significant gap: it is not possible to determine from the reported experiments whether Vector Prism’s accuracy gains are “worth” the additional VLM queries required for the burn-in pass compared to a single-pass baseline.

  • Cross-validation / statistical protocol. The paper reports no cross-validation, no statistical significance tests, and no confidence intervals on any of the reported metrics. The 114-instruction test set is used holistically, with all comparisons reported as point estimates. The user study (Section 4.6, Figure 5) involved 19 participants making 760 pairwise comparisons, with preferences aggregated into bar charts. Appendix C reports that GPT-T2V preferences agree with user preferences in 83.4% of pairs, but does not report inter-annotator agreement among the 19 participants, confidence intervals on the preference proportions, or the specific wording of the user study instructions beyond “asked to select the one that better followed the instruction” (Section 4.6).

Main Quantitative Results

Headline Comparison: Vector Prism vs. All Baselines (Table 1)

The primary results table (Table 1) compares all five methods across the three metrics on the full 114-instruction test set. Vector Prism achieves the highest score on every metric:

MethodCLIP-T2VGPT-T2VDOVERVector Output
AniClipart [35]15.6623.963.35✓
GPT-5 [20]20.6740.924.92✓
Wan 2.2 [28]21.1465.213.72✗
Sora 2 [21]20.2969.084.19✗
Vector Prism (Ours)21.5576.144.97✓

Several patterns in this table merit attention:

The critical ablation—GPT-5 vs. Vector Prism—is the largest gap among vector-based methods. GPT-5 achieves a GPT-T2V score of 40.92; Vector Prism achieves 76.14, a relative improvement of roughly 86% (or 35.22 absolute percentage points). Since GPT-5 uses the identical planning and generation pipeline as Vector Prism, differing only in whether the SVG has been semantically restructured, this gap isolates the contribution of the Vector Prism preprocessing stage. On CLIP-T2V, the gap between GPT-5 (20.67) and Vector Prism (21.55) is substantially smaller (approximately 4.3% relative), and on DOVER the gap is negligible (4.92 vs. 4.97). This metric-specific pattern aligns with the paper’s claim: semantic restructuring primarily improves instruction following (captured by GPT-T2V, which explicitly evaluates whether the motion matches the instruction), while visual quality (DOVER) and coarse video-text alignment (CLIP-T2V) are less sensitive to whether the correct parts are moving.

Vector Prism outperforms video generation models on instruction following but not by a uniform margin across metrics. On GPT-T2V, Vector Prism (76.14) exceeds Sora 2 (69.08) by 7.06 points and Wan 2.2 (65.21) by 10.93 points—substantial gaps. On CLIP-T2V, the margins narrow: Vector Prism (21.55) edges out Wan 2.2 (21.14) by 0.41 points and Sora 2 (20.29) by 1.26 points—differences that, without confidence intervals, may not be statistically meaningful. On DOVER, Vector Prism (4.97) leads Sora 2 (4.19) by 0.78 points. The pattern suggests that Vector Prism’s advantage is most pronounced on the metric explicitly designed to capture instruction fidelity (GPT-T2V), where the gains from moving the correct semantic parts are directly measurable, and less pronounced on metrics that evaluate overall visual appearance or coarse video-text alignment.

AniClipart substantially underperforms all other methods. Its GPT-T2V of 23.96 is less than one-third of Vector Prism’s score and roughly 59% of the GPT-5 baseline. This is consistent with the paper’s diagnosis (Section 2) that optimization-based methods operating on pixel-level diffusion gradients, without access to semantic part structure, “settle into short repetitive motions with visible jitter” and cannot target motion to specific parts. The qualitative results in Figure 4 confirm this: AniClipart produces “uniform motion across entire figures, leading to swaying or barely moving animations” (Section 4.5).

The vector-vs-raster distinction does not determine instruction-following quality. Both Wan 2.2 (65.21 GPT-T2V) and Sora 2 (69.08) substantially outperform the vector-based GPT-5 baseline (40.92) on GPT-T2V, despite producing raster output. This demonstrates that generating pixels directly from a strong video prior can, to some degree, compensate for the lack of vector structure. However, these raster models are not producing SVG output and therefore cannot serve web animation use cases that require lightweight, resolution-independent assets. The 54× compression ratio advantage (Section 5.1, Figure 6) is orthogonal to the quality metrics but critical for deployment.

User Study: Human Preferences (Figure 5)

The user study collected 760 pairwise comparisons from 19 participants. In each trial, participants viewed two animations generated from the same instruction by different methods and selected the one that better followed the instruction. The aggregated preferences (Figure 5) show:

  • Vector Prism is preferred over AniClipart in a larger proportion of comparisons (exact percentages are not reported numerically but are visually depicted as pink-vs-orange bar segments in Figure 5).
  • Vector Prism is preferred over GPT-5, with the bar chart showing the pink segment substantially larger than the competing segment.
  • Vector Prism is preferred over Wan 2.2 and Sora 2, despite these models’ massive scale and training data advantages.

The paper reports 83.4% alignment between GPT-T2V pairwise preferences and human judgments (Appendix C), but does not report the raw human preference percentages for each method pair—the bar chart in Figure 5 must be read visually. The absence of numerical preference ratios, confidence intervals, or inter-annotator agreement statistics limits the ability to assess the reliability of the user study findings.

Encoding Efficiency: Compression Ratio vs. Animation Fidelity (Figure 6)

Section 5.1 and Figure 6 compare the compression ratio and animation fidelity of vector-based animations against Sora 2 raster video output. The key finding is quantitative: Sora 2 produces animation files that are on average 54× larger than Vector Prism’s output. This is depicted in Figure 6 as a dual-axis bar chart where solid bars represent compression ratio (left y-axis) and hatched bars represent animation fidelity (right y-axis). The paper explains the mechanism:

“The resulting file size is primarily dependent on the complexity of the SVG structure (number of primitives) and the length of the animation code, not the output resolution or frame rate.” (Section 5.1)

As raster video resolution increases (the paper mentions the progression from 480p to 720p as an example), the file size grows while compression ratio decreases. In contrast, SVG animation size is decoupled from output resolution—the same CSS keyframes describe the motion whether rendered at 480p or 4K. The paper characterizes this gap as widening “as video resolution and duration increase.”

This finding is not a quality metric per se, but it establishes the practical deployability advantage of vector-based animation for web contexts. The paper explicitly frames this in economic terms: “lightweight assets are essential for fast loading times, responsive UI/UX, and reduced data consumption across networks” (Section 5.1).

Semantic Clustering Quality: DBI Comparison (Section 5.2)

Section 5.2 evaluates the quality of semantic groupings produced by different labeling strategies using the Davies-Bouldin Index (DBI) [8], a clustering metric that quantifies the ratio of within-cluster scatter to between-cluster separation. The paper computes feature-space distances using DINO v3 [27] embeddings, which “provides semantically meaningful visual embeddings.”

The reported DBI scores (lower is better, as DBI measures the ratio of within-cluster to between-cluster distances) are:

  • Original SVG groupings (rendering-oriented organization): DBI = 33.8
  • Majority voting (aggregating five multi-view labels without reliability weighting): DBI = 12.6
  • Vector Prism (Bayes-weighted decision rule): DBI = 0.82

The progression is stark: the original SVG hierarchy produces extremely poor semantic clusters (DBI 33.8), which is expected since the SVG groups primitives by draw order rather than by part identity. Majority voting improves this by a factor of roughly 2.7× (33.8 → 12.6), demonstrating that even unweighted aggregation of multi-view VLM predictions substantially improves semantic coherence. Vector Prism’s reliability-weighted decision rule provides an additional improvement of roughly 15× over majority voting (12.6 → 0.82), producing “near-perfect semantic clustering” as the paper characterizes it.

This result directly supports the paper’s central theoretical claim—that the Bayes-weighted vote is statistically superior to majority voting when rendering methods have heterogeneous reliabilities. The DBI metric measures the practical consequence of this theoretical advantage: mislabeled primitives fragment what should be coherent semantic groups, increasing within-cluster scatter and degrading clustering quality. Majority voting, by treating unreliable and reliable views equally, allows “the weakest reliable responses to occasionally flip the predicted label for certain primitives, creating inconsistent groupings” (Section 5.2). The quantitative degradation from 0.82 to 12.6 is consistent with the mechanism illustrated qualitatively in Figure 7, where a single unreliable method can swing majority-vote decisions on borderline primitives.

However, several caveats attend this DBI analysis. The paper does not specify how many primitives are in a typical SVG from the test set, which affects the reliability of the DBI estimate (smaller primitives-per-SVG counts produce noisier DBI values). The DBI comparison uses DINO v3 features, but does not validate that DINO v3 embeddings correctly capture the semantic similarity structure that is relevant for animation (e.g., two primitives that are visually distinct but belong to the same animatable part should be close in the embedding space). The paper also does not report whether the DBI improvements are consistent across the 57 SVGs or whether a small number of high-primitive-count SVGs drive the aggregate statistic.

Ablation Studies and Robustness Checks

The paper’s ablation analysis is relatively thin compared to the complexity of the system. The key ablations and robustness checks are:

  • GPT-5 vs. Vector Prism (the central ablation): Both use the identical planning and generation pipeline; the only difference is whether Vector Prism’s semantic restructuring is applied. This is reported in Table 1 (GPT-5: GPT-T2V 40.92, Vector Prism: 76.14) and is the single most important empirical result in the paper. It demonstrates that the semantic restructuring stage, not the planning prompt or the iterative code generation strategy, is the active ingredient driving the improvement. The fact that GPT-5—which the paper characterizes as having the best symbolic understanding among LLMs—scores 40.92 on the same pipeline without restructuring is direct evidence for the paper’s core claim that the SVG’s native structure, not model capability, is the bottleneck.

  • Majority voting vs. Bayes-weighted decision rule (Section 5.2, DBI comparison): This ablation isolates the contribution of the reliability-weighting mechanism within Vector Prism. Both conditions use the identical five rendering methods and VLM queries; the only difference is whether the labels are aggregated by simple majority vote (each method gets equal weight) or by the reliability-weighted Bayes decision rule. The DBI improvement from 12.6 to 0.82 quantifies the value of estimating and using rendering method reliabilities. The paper also provides the theoretical bound (Theorem B.5, Appendix B.3) proving that this improvement is expected whenever reliabilities differ, with the gain proportional to the variance of the discrimination parameters. However, the paper does not report the estimated reliability values p_i for each rendering method on any specific SVG, so the reader cannot assess how heterogeneous the reliabilities actually are in practice—the DBI improvement suggests they differ substantially, but the magnitude of difference is not quantified.

  • Agreement matrix computed per-SVG vs. shared across SVGs (Section 4.3, design justification): The paper reports that “We do not share the agreement matrix across SVGs, since we find that the reliability of each rendering method can vary depending on the visual complexity and structure of the SVG.” This is a design choice rather than a controlled ablation, but it implies that a shared agreement matrix would produce worse results. The paper does not report the quantitative impact of this choice—what DBI or GPT-T2V score would result from using a globally estimated set of reliabilities rather than per-SVG estimates. Given that the per-SVG approach requires a full burn-in pass over every new SVG (costing M × |X| VLM queries), a shared matrix would substantially reduce inference cost, making this a practically significant missing ablation.

  • GPT-T2V alignment with human judgments (Appendix C): The paper validates the GPT-T2V metric against the user study, reporting 83.4% agreement between GPT’s pairwise preferences and human preferences. This is compared to CLIP-T2V’s 53.4% agreement (close to chance for a binary choice). This validation establishes GPT-T2V as a reliable proxy for human evaluation in this domain, which is important because the main quantitative results (Table 1) rely on GPT-T2V as the primary metric. However, the paper does not report whether this 83.4% alignment is computed across all method pairs uniformly or whether GPT-T2V is systematically biased toward or against specific methods.

  • Qualitative failure case analysis (Section 5.3, Figure 8): The paper presents a failure case where the input SVG contains a lightning bolt defined as a single atomic <path> primitive, while the animation instruction requests that it “shatter into pieces.” Vector Prism correctly labels this primitive as “lightning_bolt” but cannot subdivide it further because it “treats primitives as atomic units and does not subdivide or decompose further” (Section 5.3). This failure case serves as an important robustness check because it establishes a hard boundary condition on when the method works: the input SVG must already contain primitive-level granularity matching the animation requirements. The paper suggests that this limitation “could be addressed if users can refine their SVG files using vectorization tools such as VTracer [11] or recent image-to-SVG models [25, 40],” placing the responsibility for resolving the limitation outside the Vector Prism system itself.

Missing ablations that would have strengthened the paper:

  • Number of rendering methods (M): The paper uses M = 5 methods (bounding box, isolation, highlight, outline, zoom-in). There is no ablation showing performance with subsets of these methods (e.g., M = 3 or M = 1). Since each additional rendering method adds |X| VLM queries to the burn-in pass cost, knowing the marginal value of the fifth method versus the fourth is practically important. The Dawid-Skene framework can operate with any M ≥ 2 (M = 2 produces a trivial 2×2 agreement matrix; M = 1 reduces to using the VLM’s raw prediction with no aggregation). An ablation curve showing GPT-T2V or DBI as a function of M would reveal whether the current choice of five methods is near-optimal or whether further methods would continue to improve performance.

  • VLM model scale for labeling: The paper uses GPT-5-nano for semantic labeling and GPT-5 for code generation, citing cost efficiency. There is no ablation showing GPT-T2V when GPT-5 is used for labeling as well (i.e., a stronger but more expensive VLM in the burn-in pass). This would quantify the tradeoff between VLM capability and cost in the labeling stage. The Dawid-Skene framework is designed to handle noisy labels, so a weaker VLM with statistical aggregation might be sufficient—but this is an empirical question that the paper does not test.

  • Rendering resolution: All primitives are rendered at 512 × 512 resolution for VLM input. There is no ablation showing performance at lower resolutions (e.g., 256 × 256) or higher resolutions. Resolution directly affects both the VLM’s ability to perceive fine details and the cost of the VLM API call (many commercial VLMs charge by input image resolution or token count). For SVGs with very small primitives, 512 × 512 may be insufficient; for SVGs with large, simple shapes, lower resolution might suffice.

  • Animation plan quality vs. final output quality: The paper’s pipeline separates planning (VLM produces semantic plan from rasterized SVG) from generation (LLM produces CSS from restructured SVG + plan). There is no ablation that directly measures the quality of the intermediate animation plans or that varies plan quality to see how it affects final animation quality. If the planner produces a poor plan, can the generation stage recover? Or does plan quality tightly constrain output quality? This is relevant for understanding where future improvements should focus.

  • Per-category breakdown of GPT-T2V: Table 1 reports aggregate metrics across all 114 instructions. The dataset spans six subject themes and five interaction patterns (Appendix D, Tables 2–3). There is no breakdown of performance by category, making it impossible to assess whether Vector Prism’s advantage is uniform or concentrated in specific animation types (e.g., does it particularly excel at rotational movement but struggle with organic/natural movement?).

  • Number of semantic categories (k): The planning prompt instructs the VLM to keep the number of elements “in a manageable range (e.g., 5–10).” There is no analysis of how GPT-T2V varies with k—do SVGs with k = 3 perform better than SVGs with k = 12 because the labeling problem is easier (fewer classes to confuse), or does animation quality suffer because the part decomposition is too coarse to support the requested motion?

  • The barrier test’s impact on animation quality: The restructuring algorithm (Algorithm 2, Appendix F) includes a conflict-aware regrouping step that prevents merging primitives with the same label if an overlapping primitive of a different label lies between them in paint order. There is no ablation comparing animation quality with and without this barrier test. The paper asserts that it “prevents rendering changes” but does not quantify whether it ever splits semantic groups that should have remained unified (i.e., false negative barrier detections) or whether removing it would produce visible rendering artifacts.

Critical Assessment

Claim: “Semantic recovery unlocks coherent VLM-driven SVG animation” / Vector Prism “enables VLMs to produce animations with far greater coherence”

The evidence for this claim is strong but narrow. The central ablation—GPT-5 with vs. without Vector Prism preprocessing—shows a 35.22-point GPT-T2V improvement (Table 1), which is substantial by any reasonable standard. The DBI clustering metric (33.8 → 0.82, Section 5.2) provides converging evidence from a completely different measurement methodology (unsupervised clustering quality rather than human-judged instruction following). The qualitative results in Figure 4 visually demonstrate the difference: the same instruction produces semantically targeted, part-specific motion with Vector Prism and unfocused, fragmentary motion without it. The user study (Figure 5) shows that human evaluators prefer Vector Prism’s output, confirming that the automatic metrics track human judgment.

However, the claim requires several qualifications that the paper does not adequately address:

The demonstration is on a single test set of 114 examples. This is a modest size for establishing the generality of a method. The dataset was “meticulously designed” and “hand-crafted” (Appendix D), which means it may reflect the authors’ implicit selection criteria about what constitutes a reasonable animation instruction. It is unknown whether the method would maintain its advantage on SVGs and instructions collected from a different source (e.g., real user requests from a deployed animation tool, or SVGs from a different repository with different authoring conventions).

The demonstration uses a single commercial VLM family (GPT). The Dawid-Skene framework is model-agnostic in principle—it should work with any VLM that can produce reasonable (even if noisy) semantic labels from rendered primitives. But the paper does not test with alternative VLMs (e.g., open-source models, models with different visual encoders, models of substantially different scales). The estimated reliabilities p_i, and consequently the improvement over majority voting, depend on the VLM’s specific failure modes. If a different VLM has different view-dependent accuracy characteristics—for example, if it performs equally well across all five rendering views—the Bayes-weighted vote reduces to majority voting and the advantage of the Dawid-Skene framework disappears. The paper provides no evidence about how sensitive the results are to the choice of VLM.

The claim of “semantic recovery” is validated indirectly through animation quality, not directly through ground-truth part labels. The DBI metric in Section 5.2 measures clustering quality using DINO v3 embeddings, but does not compare predicted labels against ground-truth semantic part annotations. The test set has no ground-truth part labels (the paper explicitly notes the absence: “Evaluating the quality of semantic groupings in SVGs is challenging without ground truth labels,” Section 5.2). This means the DBI score of 0.82, while suggestive of coherent clusters, cannot be interpreted as a measure of correctness—it measures that primitives with the same predicted label are visually similar in DINO v3 feature space and visually distinct from primitives with different labels, but does not verify that the predicted label matches what a human would call that part. It is possible for Vector Prism to produce visually coherent but semantically wrong clusters (e.g., confusing “left_eye” with “right_eye” but producing a single coherent “eye” cluster). The animation quality results (GPT-T2V, user study) partially address this by measuring downstream task performance, but they conflate semantic labeling accuracy with the quality of the planning and code generation stages.

The method’s success is conditional on input SVG granularity, which is not controlled in the test set. The failure case in Section 5.3 (Figure 8) demonstrates that when an SVG primitive is too coarse—a single <path> contains an entire lightning bolt that should shatter—Vector Prism cannot execute the instruction regardless of labeling accuracy. The paper does not characterize what fraction of the 114 test examples fall into this insufficient-granularity regime or how much this limitation depresses the reported scores. If 20% of the test instructions require sub-primitive decomposition, the reported GPT-T2V of 76.14 would understate what Vector Prism could achieve on a dataset filtered for sufficient granularity.

Claim: “Vector Prism outperforms state-of-the-art video generation models (Sora 2, Wan 2.2) on animation quality and instruction faithfulness”

This claim is supported by the metrics in Table 1 but requires careful interpretation about what is being compared.

The comparison is across output modalities with fundamentally different deployment properties. Sora 2 and Wan 2.2 produce raster video; Vector Prism produces SVG animation with embedded CSS. A raster video is self-contained and will play identically on any device with a video decoder. An SVG animation requires a browser or SVG renderer that supports CSS animations and the specific CSS properties used (custom properties, the lanes convention). The paper notes this implicitly in Figure 1’s caption: “Please view them in Adobe Acrobat or the Firefox browser for the best experience,” acknowledging that the output is not universally compatible. This modality difference means the comparison is not strictly apples-to-apples: a user who needs an .mp4 file cannot use Vector Prism’s output, and a user who needs a lightweight, resolution-independent web animation cannot use Sora 2’s output. The “better” method depends on the deployment context.

The metrics may have a structural bias toward vector-based output. GPT-T2V evaluates “how accurately its motion follows the given instruction” by analyzing sampled frames. Vector-based animations, which apply deterministic, mathematically precise transformations to known geometric primitives, inherently produce cleaner, more predictable motion boundaries than raster video models, which must hallucinate every pixel and may introduce visual artifacts or distortions that the evaluator penalizes even when the intended motion is correct. The user study (Figure 5), which shows human preference for Vector Prism over Sora 2, partially addresses this concern—human evaluators also prefer the vector output. But the specific instructions in the dataset may favor the kind of clean, targeted motion that vector animation excels at, rather than the organic, textured motion that video models are designed for. The dataset composition (Appendix D, Table 3) shows 37.7% “Other/Mixed” patterns, making it difficult to assess whether specific pattern types drive the preference.

The compression ratio advantage (54×, Figure 6) is a separate claim from quality superiority. Even if Sora 2 produced higher-quality animations (which it does not, per the reported metrics), the 54× compression ratio would still make Vector Prism preferable for bandwidth-constrained web deployment. This is an important nuance: Vector Prism’s practical advantage is the combination of competitive-or-better quality and dramatically better deployability, not necessarily raw visual quality superiority in all contexts.

Claim: “Our semantic labeling stage is statistically robust to noise and operates with minimal computational overhead”

The statistical robustness claim is theoretically well-supported (Theorem B.5, DBI results) but the “minimal computational overhead” claim is unquantified and potentially misleading.

The burn-in pass requires M × |X| VLM queries. For an SVG with 100 primitives (which is modest—complex icons can have hundreds), this is 500 VLM queries. Using GPT-5-nano (“25× more cost-efficient than GPT-5”) mitigates the per-query cost, but the paper provides no dollar figures, no latency measurements, and no comparison to the cost of the GPT-5 baseline (which uses zero additional VLM queries for semantic labeling). The characterization “minimal” is relative to an unspecified baseline. If the alternative is hiring a human animator to manually label and animate the SVG, 500 cheap API calls is indeed minimal. If the alternative is the GPT-5 baseline (one planning call + K generation calls), the additional 500 labeling queries may represent a substantial fraction of total cost.

The computational overhead is not included in any efficiency metric. The paper reports compression ratio (storage efficiency) and quality metrics (output quality) but does not report a cost-normalized quality metric (e.g., GPT-T2V per dollar of API cost). This makes it impossible to assess whether the quality gains justify the additional inference cost. A deployment-focused evaluation would plot a Pareto frontier of quality vs. cost for different methods.

Claim: “Experiments demonstrate significant improvements over state-of-the-art methods”

The claim of “significant improvements” is numerically supported (Table 1) but the paper does not report any statistical significance tests, confidence intervals, or measures of variability. The 114-instruction test set produces point estimates. Without knowing the variance across the 114 examples (e.g., standard deviation of GPT-T2V scores per method, or whether the differences are consistent across SVGs vs. driven by a subset of examples), the practical reliability of the reported gaps cannot be assessed. It is possible that Vector Prism outperforms GPT-5 on 60% of examples, ties on 30%, and loses on 10%, producing a large mean difference that is not representative of the typical case; or that it wins consistently across nearly all examples. The aggregate metrics alone cannot distinguish these scenarios.

Missing experiments that would strengthen confidence:

  • A test set with ground-truth part labels would enable direct evaluation of semantic labeling accuracy (precision, recall, F1 per part category), separating labeling errors from planning and generation errors. Without this, the pipeline’s error attribution is opaque: when animation fails, is it because a primitive was mislabeled, because the plan was poor, or because the CSS generation produced buggy code?

  • A human baseline—professional animator producing CSS animations for the same instructions—would contextualize the absolute scores. A GPT-T2V of 76.14 is the highest among tested methods, but is it 76% of the way to perfect? Or is it approaching a ceiling where further improvement is diminishing? Without a human reference point, the absolute scale of the metric is uncalibrated.

  • Cross-validation or a held-out set would address the concern that the system’s design choices (five rendering methods, barrier test threshold, lanes convention) are implicitly tuned to the 114 examples. The Dawson-Skene model has no learned parameters, but the rendering method selection, the prompt engineering for planning and generation, and the restructuring algorithm all involve design decisions that could be overfit to the test set in the absence of a separate validation set.

  • Cost-normalized comparison: A figure with GPT-T2V on the y-axis and estimated API cost (or latency, or total VLM queries) on the x-axis, with each method as a point, would directly address the efficiency claim. Vector Prism should appear in the upper-left region (high quality, moderate cost) if the “minimal overhead” claim holds.

  • Sensitivity to the number of semantic categories (k): The planning prompt asks for 5–10 categories, but actual plans may vary. If the method degrades when k is large (because the Dawid-Skene model’s uniform-error assumption becomes less plausible with many categories, and the agreement matrix becomes sparser), this would be an important limitation for complex SVGs with many animatable parts.

6. Limitations and Trade-offs

Granularity Ceiling: Atomic Primitives Cannot Be Subdivided

The assumption or constraint. Vector Prism operates on SVG primitives as atomic, indivisible units. The paper is explicit about this constraint in Section 5.3:

"We treat primitives as atomic units and do not subdivide or decompose further, which limits its animation flexibility when the input SVG lacks granularity."

The restructuring algorithm (Appendix F, Algorithm 2) assigns a single semantic label to each primitive and groups primitives by label, but has no mechanism for splitting a primitive that contains multiple semantic parts or that is too coarse to support the requested motion. The failure case in Figure 8 demonstrates this concretely: a lightning bolt authored as a single <path> element cannot be "shattered into pieces" because the pieces do not exist as independent primitives.

The consequence. For any animation instruction that requires motion at a finer granularity than the input SVG's primitive decomposition, Vector Prism will fail regardless of how accurately it labels the existing primitives. This is not a failure of the semantic recovery process—the system correctly identifies the lightning bolt as a single semantic unit—but of the input representation itself. The consequence is that Vector Prism's applicability is bounded above by the SVG author's original choice of primitive decomposition. If the SVG was authored with coarse primitives (e.g., a single <path> for an entire character silhouette), the system can only animate that character as a rigid whole, even if the instruction requests articulated motion of individual limbs.

This limitation interacts with the test set composition in ways the paper does not characterize. The 57 SVGs were sourced from SVGRepo, a public repository with diverse authoring conventions. Some SVGs may have been exported from vector editors with automatic path simplification that merges semantically distinct regions into single primitives. Others may have been hand-coded with fine-grained decomposition. The paper does not report what fraction of the test examples push against the granularity ceiling, so a practitioner cannot estimate how often this limitation will manifest in their own SVG corpus.

What evidence exists in the paper. The failure case is documented qualitatively in Figure 8 (Section 5.3) with a single example. The paper provides no quantitative measurement of how many of the 114 test instructions require sub-primitive decomposition, no analysis of primitive granularity across the 57 SVGs (e.g., distribution of primitive counts, distribution of primitive sizes relative to canvas), and no metric for predicting in advance whether a given instruction-SVG pair will hit this ceiling. The GPT-T2V score of 76.14 (Table 1) must therefore be interpreted with the understanding that it includes failures caused by insufficient input granularity, not just failures of semantic labeling or animation generation.

Mitigation status. The paper does not attempt to mitigate this limitation within Vector Prism itself. Section 5.3 suggests that the problem "could be addressed if users can refine their SVG files using vectorization tools such as VTracer [11] or recent image-to-SVG models [25, 40], which generate SVGs with controllable levels of detail," and notes that "future work could explore automatic primitive subdivision strategies that identify and split overly coarse elements based on the animation requirements." Both suggestions punt the solution outside the Vector Prism system—either requiring the user to pre-process their SVG with a separate tool, or deferring to unspecified future research. There is no integration with any vectorization or subdivision tool in the current system, so a practitioner deploying Vector Prism today inherits whatever granularity the input SVG provides with no recourse.

Burn-In Computational Cost Is Unaccounted for in Headline Efficiency Claims

The assumption or constraint. The semantic labeling stage requires a burn-in pass that queries the VLM M × |X| times, where M = 5 rendering methods and |X| is the number of primitives in the SVG. The paper characterizes this cost as "minimal computational overhead" (Section 4.3), but provides no absolute cost measurements and does not include this overhead in any efficiency comparison with baselines:

"Our semantic labeling stage is statistically robust to noise and operates with minimal computational overhead, enabling lightweight models to perform reliably without sacrificing accuracy." (Section 4.3)

The paper's only cost-related claim about the model used for labeling is that GPT-5-nano is "25× more cost-efficient than GPT-5" (Section 4.3), which is a relative comparison between two models, not an absolute cost figure or a comparison to the cost of alternative approaches.

The consequence. The reported quality improvements (GPT-T2V 76.14 vs. GPT-5 baseline 40.92, Table 1) are not cost-normalized. A practitioner cannot determine from the paper whether the 35.22-point GPT-T2V improvement justifies the additional VLM queries required for the burn-in pass. For an SVG with 100 primitives, the burn-in requires 500 VLM queries for labeling plus one query for planning, compared to one query for the GPT-5 baseline's planning stage. If each GPT-5-nano query costs 0.01,thelabelingoverheadperSVGisapproximately0.01, the labeling overhead per SVG is approximately 5.00. Whether this is "minimal" depends entirely on the practitioner's budget and the value of improved animation quality—a question the paper does not equip the reader to answer.

The absence of cost normalization also complicates comparisons with video generation baselines. Sora 2 and Wan 2.2 have their own per-generation costs (API pricing or GPU-hours), and AniClipart has optimization-time costs (gradient steps through a diffusion model). Without a common cost axis—dollars, FLOPs, or wall-clock time—the quality comparisons in Table 1 cannot be converted into value-per-unit-cost comparisons. The paper's compression ratio analysis (54× smaller files, Section 5.1, Figure 6) addresses storage and bandwidth efficiency, not generation efficiency. A deployment setting where generation cost dominates (e.g., generating animations on-demand for user requests) needs cost-normalized quality metrics; a deployment setting where storage cost dominates (e.g., serving pre-computed animations to many users) benefits from the compression ratio. The paper provides only the latter.

What evidence exists in the paper. The paper provides no cost measurements whatsoever—no dollar figures, no FLOPs estimates, no latency measurements, no query counts for representative SVGs. The "25× more cost-efficient" claim about GPT-5-nano is asserted without citation or measurement methodology. The number of primitives in a typical test SVG is not reported, making it impossible to estimate burn-in cost from the information provided. The agreement matrix computation (Section 4.3) requires a full pass over all primitives—the paper notes that "a single full pass over all primitives within each SVG provides a good balance between estimation stability and computational efficiency," but does not quantify what "good balance" means in cost terms or whether a partial pass (sampling a subset of primitives) would suffice.

Mitigation status. The paper acknowledges that sharing the agreement matrix across SVGs could reduce cost ("We do not share the agreement matrix across SVGs, since we find that the reliability of each rendering method can vary depending on the visual complexity and structure of the SVG," Section 4.3), but does not quantify the performance degradation that would result from sharing. This is a straightforward cost-quality tradeoff that the paper identifies but leaves unexplored. The suggestion to use cheaper VLM models (GPT-5-nano rather than GPT-5) partially addresses cost but does not eliminate the linear scaling with primitive count. No method for reducing the number of rendering methods M below 5 is evaluated. No method for reducing the number of primitives that must be labeled (e.g., by labeling only primitives that are visually distinctive and propagating labels to similar neighbors) is proposed.

Single Model Family, Single Test Set: Generality Is Untested

The assumption or constraint. All experiments use models from a single commercial family (GPT-5-nano for semantic labeling and planning, GPT-5 for code generation) on a single test set of 114 hand-crafted examples. The paper does not test with any alternative VLM (open-source models, models with different visual encoders, models of substantially different scale or training distribution) or on SVGs and instructions sourced from a different distribution. The dataset composition is described in Appendix D (Tables 2–3): 57 SVGs from SVGRepo across six thematic categories, with 114 instructions covering five interaction pattern categories, "meticulously designed to reflect the diverse animation needs encountered in modern web development" (Appendix D).

The authors assert that their approach "generalizes to diverse, in-the-wild graphics" (Section 2), but this claim is supported only by the diversity within their own test set—which, at 57 unique SVGs, is modest.

The consequence. Three distinct generalization risks are unaddressed:

First, VLM-dependence of the Dawid-Skene estimation. The statistical inference framework assumes that VLM responses follow a symmetric error model (correct with probability p_i, uniformly wrong with probability (1-p_i)/(k-1)). The accuracy parameters p_i are estimated from agreement patterns and depend on the VLM's specific visual recognition capabilities, failure modes, and biases. If a different VLM has qualitatively different error patterns—for example, if it systematically confuses certain semantic categories (e.g., "left_eye" vs. "right_eye" produces non-uniform errors) or if its accuracy does not vary substantially across rendering methods (making all p_i similar and the Bayes-weighted vote barely distinguishable from majority voting)—the framework's advantage would shrink or vanish. The paper provides no evidence about whether the five rendering methods produce heterogeneous reliability estimates with other VLMs, or whether the Dawid-Skene model's symmetric error assumption holds approximately for models other than GPT-5-nano.

Second, instruction distribution sensitivity. The 114 test instructions were "hand-crafted" (Appendix D) by the authors. This introduces potential for unconscious bias toward instructions that are well-suited to the method's capabilities—for example, instructions that request clearly separable part motions (which benefit from semantic restructuring) rather than instructions that request global stylistic changes (which do not). If a practitioner's use case involves different instruction types—e.g., "make the whole logo pulse with a heartbeat rhythm" rather than "make the buttons bounce one by one"—the relative advantage of semantic recovery may differ.

Third, SVG distribution sensitivity. SVGs from SVGRepo may have specific authoring conventions (level of nesting, use of <g> tags for organizational purposes, primitive granularity, naming conventions) that affect both the difficulty of the semantic labeling task and the benefit of restructuring. SVGs from other sources—design tools with different export pipelines, hand-coded SVGs with different structural conventions, SVGs embedded in web pages with inline styles—may produce different reliability patterns and different restructuring outcomes.

What evidence exists in the paper. The paper does not report any cross-model, cross-dataset, or cross-instruction-distribution experiments. The ablation that compares GPT-5 (with the same planning and generation pipeline, without restructuring) to Vector Prism (Table 1) isolates the restructuring step within the GPT family but does not test whether the same improvement would hold if the underlying VLM were replaced. The diversity statistics in Appendix D describe the test set's composition but do not constitute a test of generalization.

Mitigation status. No mitigation is attempted. The paper does not claim to have tested generalization, does not discuss these limitations, and does not suggest cross-model or cross-dataset validation as future work. The Dawid-Skene framework is model-agnostic in principle (it requires only conditionally independent noisy labels, regardless of the labeler's identity), but the empirical validation of this agnosticism is absent.

Semantic Labeling Accuracy Is Never Directly Evaluated — Only Downstream Task Performance

The assumption or constraint. The paper never evaluates whether Vector Prism's semantic labels are correct—that is, whether each primitive is assigned to the part that a human would identify. Instead, all evaluation is either indirect (clustering quality via DBI, Section 5.2) or downstream (animation quality via GPT-T2V, user study, Table 1 and Figure 5). The paper acknowledges this measurement gap explicitly:

"Evaluating the quality of semantic groupings in SVGs is challenging without ground truth labels, yet crucial for understanding whether our statistical inference produces coherent clusters." (Section 5.2)

The DBI metric measures whether primitives with the same predicted label are visually similar (in DINO v3 feature space) and visually distinct from primitives with different labels, but does not verify that the label assigned to a cluster corresponds to what a human would call that part. A system that consistently swaps "left_eye" and "right_eye" labels (producing two visually coherent but semantically swapped clusters) would achieve a good DBI score while producing semantically incorrect animations.

The consequence. When an animation fails or succeeds, it is impossible to attribute the outcome to specific stages of the pipeline. A poor animation could result from: (a) incorrect semantic labels causing primitives to be assigned to the wrong groups, (b) correct labels but a poor animation plan from the planning VLM, (c) correct labels and plan but buggy or unexpressive CSS from the generation LLM, or (d) correct labels, plan, and CSS but insufficient primitive granularity in the input SVG (the limitation in Section 5.3). The aggregate GPT-T2V score conflates all these error sources, making it impossible to determine where to invest improvement effort.

This is particularly problematic for the paper's central claim that semantic recovery is the key bottleneck. The GPT-5 baseline (Table 1: 40.92) differs from Vector Prism (76.14) not only in whether semantic labels are available, but also in whether the generation LLM receives restructured SVG code with descriptive class names, bounding box metadata, and geometric center annotations. The improvement could be partially attributable to the enhanced metadata and code organization (which aid the LLM's code generation) rather than to the correctness of the semantic labels per se. Without a direct label-accuracy measurement, these contributions cannot be disentangled.

What evidence exists in the paper. The DBI comparison (33.8 original → 12.6 majority voting → 0.82 Vector Prism, Section 5.2) provides evidence that Vector Prism's labels produce more visually coherent clusters than alternatives. But DBI measures cluster quality in an unsupervised feature space, not label correctness against ground truth. A DBI of 0.82 indicates that, on average, primitives within a predicted class are about 0.82 times as distant from each other (in DINO v3 space) as they are from primitives in the nearest other class—which suggests tight, well-separated clusters but does not confirm that the class labels match human semantic categories. The user study (Figure 5) and GPT-T2V scores (Table 1) demonstrate that downstream animations are preferred by humans and automatic evaluators, but a preferred animation could result from labels that are partially wrong but still "good enough" for motion coherence (e.g., confusing two visually similar buttons produces no visible animation error if both buttons are supposed to move together anyway).

Mitigation status. The paper acknowledges the absence of ground-truth labels ("Evaluating the quality of semantic groupings in SVGs is challenging without ground truth labels," Section 5.2) but does not attempt to create even a small ground-truth dataset for diagnostic purposes—for example, by manually labeling the primitives of 5–10 test SVGs and measuring precision/recall of Vector Prism's predictions. The DBI metric is presented as a proxy, with the limitation acknowledged but not resolved. The paper's reliance on downstream task evaluation is reasonable as a primary metric (ultimately, animation quality is what matters), but the absence of any intermediate diagnostic measurement limits the paper's ability to support its specific causal claims about semantic labeling accuracy.

No Confidence Intervals or Statistical Significance on Any Reported Comparison

The assumption or constraint. All quantitative results in the paper are reported as point estimates without any measure of variability, confidence intervals, or statistical significance tests. Table 1 reports scalar values for each method-metric pair. Figure 5 reports user study preferences as proportions without confidence bounds. Section 5.2 reports DBI scores as scalars (33.8, 12.6, 0.82) without any indication of variance across the 57 SVGs. The paper's entire empirical argument—that Vector Prism outperforms baselines, that the improvement is "significant," that the DBI improvement is meaningful—rests on these point estimates.

The consequence. A practitioner cannot assess whether the reported performance differences are reliable or could be reversed by sampling noise. With 114 test examples and (presumably) substantial per-example variance in animation quality, the standard error of the mean GPT-T2V score could easily be several points. A difference of 7.06 points between Vector Prism (76.14) and Sora 2 (69.08) on GPT-T2V may or may not be statistically significant at conventional thresholds depending on the per-example variance, which the paper does not report. The CLIP-T2V gap between Vector Prism (21.55) and Wan 2.2 (21.14) is 0.41 points—a difference that, without variance estimates, could easily be noise.

The user study (19 participants, 760 pairwise comparisons, Figure 5) aggregates preferences across all method pairs and all test examples, but does not report the number of comparisons per method pair, the proportion of ties, inter-annotator agreement (e.g., Cohen's kappa or Fleiss' kappa), or confidence intervals on the preference proportions. A preference proportion of 60% for Vector Prism over a baseline, with a 95% confidence interval of [51%, 69%], would be substantially weaker evidence than the same point estimate with a [57%, 63%] interval. The paper provides neither.

The DBI comparison (33.8 → 12.6 → 0.82) involves point estimates aggregated across an unspecified number of clusters (which depends on the number of semantic categories per SVG). If one SVG in the test set has particularly poor original groupings and particularly good Vector Prism groupings, it could dominate the aggregate DBI statistic. Without per-SVG DBI distributions or standard deviations, the robustness of the DBI improvement to outlier SVGs is unknown.

What evidence exists in the paper. None. The paper does not report standard deviations, standard errors, confidence intervals, p-values, effect sizes, or any other measure of statistical reliability for any quantitative result. The only validation of metric reliability is the 83.4% alignment between GPT-T2V and human preferences (Appendix C), which is itself a point estimate without a confidence interval.

Mitigation status. No mitigation is attempted. The paper does not discuss the absence of statistical reporting, does not acknowledge it as a limitation, and does not suggest future work to establish statistical reliability. The 114-example test set is large enough to compute meaningful confidence intervals (via bootstrapping or standard parametric methods), and the user study methodology (760 pairwise comparisons) is amenable to standard inter-annotator agreement and preference-proportion confidence interval calculations. The omission appears to be a reporting choice rather than a fundamental constraint.

The Method Is Validated Exclusively on CSS Animation Generation with a Single Pipeline Architecture

The assumption or constraint. Vector Prism's semantic restructuring is positioned as a general preprocessing step that enables VLMs to animate SVGs, but the paper validates it exclusively within a specific downstream pipeline: (1) a GPT-series VLM for planning, (2) semantic restructuring via Vector Prism, (3) GPT-5 for iterative CSS animation generation with the lanes convention. The paper states that "the earlier pipeline steps do not restrict generating animations to the CSS markup type" and that "our method has the capability to extend to complex animations using JavaScript or specialized libraries" (Section 3.4), but provides no evidence that the semantic restructuring benefits other animation paradigms.

The consequence. The paper's central claim—that semantic recovery is the "missing layer" that current VLM systems overlook—is supported only for one specific way of using that recovered structure (CSS keyframe generation with GPT-5). If a practitioner wants to use a different animation approach—JavaScript animation libraries (GSAP, Anime.js), SMIL animations, programmatic animation via SVG's native <animate> elements, or a different code-generation model—the paper provides no evidence that Vector Prism's output remains useful. It is plausible that the semantic labels and regrouped hierarchy would benefit any animation approach that needs to target motion to specific parts, but this is an untested assumption.

More subtly, the paper's evaluation conflates the benefit of semantic restructuring with the benefit of the specific animation generation strategy (iterative generation with lanes convention). The lanes convention (Section 3.4, detailed in the planning and generation prompts in Appendix E) is a non-trivial engineering contribution that prevents CSS animation conflicts across iterative generation calls. If a different animation generation strategy—for example, a single-pass generation that produces all CSS at once, or a JavaScript-based approach that handles sequencing programmatically—were used, the relative performance of restructured vs. unstructured SVGs might differ. The paper's ablation (GPT-5 baseline, Table 1) strips out the restructuring but retains the iterative generation pipeline, so it isolates the combined effect of (restructuring + metadata annotation) on this specific pipeline, not the effect of restructuring independent of the generation strategy.

What evidence exists in the paper. The paper provides exactly one downstream pipeline architecture and one animation output format (CSS). The only variation tested is whether Vector Prism's preprocessing is applied (Vector Prism vs. GPT-5 baseline, Table 1). There are no experiments varying the animation generation strategy (e.g., single-pass CSS, JavaScript, SMIL), the code generation model (e.g., a different LLM, a template-based system), or the animation output format. The claim that the pipeline can extend to JavaScript or specialized libraries (Section 3.4) is stated without supporting evidence.

Mitigation status. The paper does not address this as a limitation—it frames the extension to other animation formats as a capability ("our method has the capability to extend") rather than an unvalidated claim. Future work demonstrating that the semantically restructured SVGs produced by Vector Prism improve performance across multiple downstream animation systems would substantially strengthen the argument that semantic recovery is a general solution rather than a pipeline-specific optimization.

7. Implications and Future Directions

How This Work Changes the Landscape

Vector Prism introduces a diagnostic reframing rather than a new model architecture or training paradigm. The paper's core intellectual move is to relocate the SVG animation bottleneck from model capability to representational structure. Prior to this work, the implicit assumption across optimization-based methods (AniClipart), fine-tuned LLM approaches (InternSVG, StarVector), and end-to-end video generation (Sora 2, Wan 2.2) was that animation quality scales with model scale, training data volume, or optimization sophistication. Vector Prism demonstrates, through the critical ablation in Table 1, that a lightweight VLM (GPT-5-nano) with semantic restructuring outperforms a frontier model (GPT-5) without it by 35.22 GPT-T2V points—an 86% relative improvement. The active constraint is not how smart the model is, but whether the input representation exposes the semantic units the model needs to reason about.

This reframing has several cascading consequences for how the field thinks about VLM interaction with symbolic formats:

The semantic-syntactic gap becomes a named, diagnosable problem rather than a vague frustration. Before this paper, the difficulty of getting VLMs to manipulate SVGs was attributed to "LLMs carrying little understanding for vector geometry and scene hierarchies" (Section 2, citing [19, 46])—a model-deficit diagnosis that motivated data scaling. Vector Prism provides a sharper, more productive diagnosis: the SVG's native hierarchy is optimized for rendering efficiency and actively obscures the part-whole relationships that animation requires. This shifts attention from improving the model to fixing the representation, which is a fundamentally different—and potentially cheaper—research program.

The Dawid-Skene model becomes a recognized tool for VLM applications beyond crowdsourcing. The paper's core technical innovation is not the Dawid-Skene model itself—which has existed since 1979—but the recognition that VLMs functioning as noisy labelers across multiple rendered views of the same stimulus produce agreement patterns with the rank-one structure that Dawid-Skene exploits. This opens a design pattern for any domain where a VLM must classify structured inputs that can be rendered in multiple complementary ways: 3D mesh part labeling (render from multiple camera angles, apply different material shadings), code snippet classification (show with different syntax highlighting, different levels of surrounding context), document layout analysis (render with different zoom levels, different color channels). The paper provides a complete, theoretically grounded recipe: collect M ≥ 2 weak labels through varied renderings → compute pairwise agreement matrix → extract top eigenvector of centered agreement → apply Bayes-weighted vote. Researchers in adjacent domains can adopt this recipe without reinventing the statistical machinery.

The data-scaling paradigm for symbolic generation is empirically challenged, within its proper scope. The paper does not claim that semantic restructuring replaces data scaling universally—it explicitly shows that the method fails when the input SVG lacks sufficient primitive granularity (Section 5.3, Figure 8), a limitation that data-scaling approaches might eventually learn to circumvent by inferring sub-primitive structure from training examples. But for the broad class of problems where the symbolic representation already contains the necessary information, just organized inaccessibly, the paper demonstrates that restructuring can unlock performance that data scaling alone cannot match at comparable cost. The 54× compression ratio (Figure 6) is the economic manifestation: restructuring produces output that is simultaneously higher quality (Table 1), drastically more deployable (54× smaller), and does not require training on millions of examples.

Video generation models are shown to have a specific, diagnosable weakness on instruction-following animation tasks. The paper's inclusion of Sora 2 and Wan 2.2 as baselines (Table 1) is more than a benchmarking exercise—it reveals that models trained on internet-scale video-text data, while producing visually sophisticated output, "often collapse into static frames or distorted scenes when given dynamic, animation-focused instructions" (Section 4.5). This suggests that the training objective of video generation (produce visually plausible pixels) is misaligned with the objective of animation (produce semantically targeted, temporally precise motion of specific parts). The paper's success via a purely symbolic pipeline—CSS keyframes applied to known geometric primitives—demonstrates that for tasks where precision matters more than photorealism, maintaining symbolic structure throughout the pipeline is a viable and potentially superior alternative to end-to-end pixel generation.

The work reconciles conflicting intuitions about VLM capability. There is a tension in the literature between findings that VLMs "can understand" vector graphics when shown rasterized renderings of simple, well-separated cases [44] and findings that they "quickly fail" on complex real-world SVGs. Vector Prism resolves this: VLMs do possess the visual recognition capability to identify semantic parts, but that capability is noisy, view-dependent, and unreliable when applied to individual primitives. The problem is not capability absence but signal-to-noise ratio. The statistical aggregation framework converts individually unreliable predictions into collectively reliable labels by exploiting the structure of agreements—a resolution that explains both the successes (simple cases where even single-view predictions are accurate) and failures (complex cases where single-view predictions are noisy but multi-view aggregation recovers the signal).

Follow-Up Research This Work Enables

Cross-VLM reliability profiling and the limits of the Dawid-Skene assumption. The paper uses a single VLM (GPT-5-nano) for semantic labeling, and the Dawid-Skene model's symmetric error assumption (uniform distribution over wrong labels) is never empirically validated. A follow-up study would run the Vector Prism burn-in pass with 3–5 different VLMs spanning open-source (LLaVA, Qwen-VL) and commercial (GPT-4V, Claude, Gemini) families on a set of 20–30 SVGs with ground-truth primitive labels, then compute per-VLM confusion matrices to test whether errors are truly uniform or whether systematic confusions (e.g., "left_eye" ↔ "right_eye") violate the Dawid-Skene model. The study would also measure whether the five rendering methods produce heterogeneous reliability estimates across different VLMs—if a particular VLM performs equally well regardless of rendering method, the Bayes-weighted vote reduces to majority voting and the Dawid-Skene framework provides no benefit. The paper's Theorem B.5 shows that the improvement over majority voting is proportional to Var(d)/(Mean(d))²; measuring this ratio across VLMs would identify which models benefit most from the framework and whether the benefit is a property of GPT-5-nano specifically or VLMs generally.

Adaptive rendering method selection with early stopping. The paper uses a fixed set of M = 5 rendering methods and a full burn-in pass over all primitives, costing M × |X| VLM queries per SVG. A follow-up could develop an adaptive strategy: start with 2 rendering methods, compute the provisional agreement matrix, estimate the spectral gap (difference between first and second eigenvalues of B̂), and add rendering methods only if the spectral gap is below a threshold indicating that the skill vector δ is not yet reliably separable from noise. The experiment would plot a cost-quality Pareto frontier—GPT-T2V on the y-axis, total VLM queries on the x-axis—for adaptive vs. fixed-M strategies across the 114-instruction test set. A successful adaptive strategy would achieve comparable GPT-T2V to the fixed M = 5 configuration while using 30–50% fewer queries on SVGs with clear visual structure (where the first 2–3 views already produce a strong spectral gap) and would automatically invest more queries on SVGs with ambiguous structure (where the gap is small until additional views are added). This directly addresses the paper's largest practical limitation—the unaccounted burn-in cost.

Ground-truth part labeling of the test set to enable error attribution. The paper's central causal claim—that semantic labeling accuracy drives animation quality—is supported only indirectly through DBI clustering scores and downstream GPT-T2V metrics. A follow-up study would manually annotate primitive-level ground-truth part labels for the 57 SVGs in the test set (or a representative subset of 20), then compute precision, recall, and per-category F1 for Vector Prism, majority voting, and single-view baselines. With ground-truth labels, the study could decompose animation failures into three components: (a) labeling errors (primitive assigned to wrong semantic group, causing incorrect motion targeting), (b) planning errors (VLM produces a poor animation plan even with correct labels), and (c) code generation errors (LLM produces buggy CSS even with correct labels and plan). The experiment would run the animation generation stage with ground-truth labels (bypassing Vector Prism's labeling) to establish an upper bound on what perfect labeling could achieve, then measure how much of that upper bound Vector Prism recovers. This would quantify the headroom for improving the labeling stage independently of the planning and generation stages.

Primitive subdivision as a pre-processing step to address the granularity ceiling. The failure case in Section 5.3 (Figure 8) shows that Vector Prism cannot animate a lightning bolt requiring shattering because the bolt is a single atomic <path>. A follow-up could integrate a primitive subdivision module upstream of Vector Prism: given an animation instruction that requires fine-grained motion (detected via keyword matching—"shatter," "break apart," "individually," "one by one"), apply a geometry-based decomposition algorithm (e.g., splitting a <path> at curvature inflection points, or using a segmentation model to partition the rasterized primitive into regions) to produce sub-primitives, then feed the expanded primitive set into Vector Prism for labeling and restructuring. The evaluation would compare GPT-T2V on a subset of the test set containing sub-primitive-motion instructions (e.g., the 14 Organic/Natural Movement and 10 Rotational Movement examples from Table 3, many of which may require part-level articulation) with and without the subdivision module. A successful integration would raise the ceiling on these instruction types without degrading performance on instructions that do not require subdivision (where the module should be a no-op).

Cross-domain application to 3D scene graph annotation. The semantic-syntactic gap is not unique to SVG. 3D assets (glTF, USD, OBJ files) similarly encode meshes as flat lists of vertices and faces organized for rendering efficiency, with no semantic grouping into animatable parts (a "door handle" is just a set of triangles with a material ID). A follow-up could adapt Vector Prism to 3D part labeling: for each mesh in a 3D scene, render it from M = 6 complementary views (e.g., front/back/left/right/top/bottom orthographic projections, or with different material shadings—wireframe, ambient occlusion, textured, unlit), query a VLM to classify the mesh into semantic categories from a planning stage, build the agreement matrix across views, and apply the same Dawid-Skene + Bayes decision rule pipeline. The evaluation would use a dataset of 3D assets with ground-truth part annotations (e.g., PartNet for manufactured objects, or manually labeled assets from Sketchfab) and measure part-labeling accuracy. This would test whether the paper's core contribution—recovering lost semantic structure from multi-view weak VLM predictions—generalizes beyond the 2D vector domain, and whether the Dawid-Skene model's assumptions hold when views are geometric projections rather than rendering stylizations.

Joint optimization of planning and restructuring via iterative refinement. The current pipeline is strictly feedforward: planning produces semantic categories → Vector Prism maps primitives to those categories → animation generation produces CSS. But the planning stage's choice of categories constrains what Vector Prism can recover: if the planner groups "left_button" and "right_button" into a single "buttons" category, Vector Prism will merge them even if they could be animated individually. A follow-up could close this loop: after Vector Prism produces semantic labels, feed the labeled SVG back to the planning VLM and ask it to refine the plan based on the discovered structure—e.g., detecting that "buttons" actually contains three visually separable clusters and splitting the plan into "button_1," "button_2," "button_3." The experiment would run this iterative refinement for 2–3 rounds on the 114-instruction test set and measure whether GPT-T2V improves (because the plan better matches the actual part decomposition) or degrades (because iterative VLM calls accumulate errors). This tests whether the semantic-syntactic gap can be narrowed from both sides simultaneously—better plans informed by structure, better structure informed by plans—rather than only from the representation side as the current paper does.

Practical Applications and Downstream Use Cases

Automated animation of icon libraries for web design systems. Organizations maintaining design systems (e.g., Google Material Design, IBM Carbon, Microsoft Fluent) ship hundreds of SVG icons that are currently static or hand-animated. Vector Prism could process an icon library in batch mode: for each icon, accept a natural-language instruction ("add a subtle hover bounce," "animate the checkmark drawing in on page load"), run the full pipeline (planning → semantic labeling → restructuring → CSS generation), and produce an animated variant. The 54× compression ratio over raster video (Figure 6) means these animations remain lightweight enough for performance-sensitive web delivery, and the resolution independence of SVG means a single animated icon works across all device sizes. The primary deployment constraint would be the burn-in cost—500 VLM queries per icon, which at current API pricing is manageable for a batch preprocessing step (run once, serve the resulting animated SVG to millions of users) but would need to be factored into the pipeline's total cost of ownership.

Accessibility-driven animation for data visualizations and educational graphics. SVGs are the dominant format for web-based data visualizations (D3.js, Observable Plot) and educational diagrams (textbook illustrations, scientific figures). Adding semantic animations—e.g., "highlight each bar in the bar chart sequentially while calling out its value," "animate the water cycle diagram so each arrow fades in order"—could improve comprehension and engagement, but manual authoring is expert-intensive. Vector Prism's natural-language interface lowers the barrier: an educator or data journalist could describe the intended animation in plain English without understanding SVG structure or CSS keyframes. The method's specific limitation—requiring sufficient primitive granularity—is less of a concern here because data visualizations are typically programmatically generated with fine-grained, semantically meaningful element decomposition (each bar, axis tick, and label is a separate SVG element). The primary integration challenge would be handling the iterative generation of CSS for potentially dozens of elements (a bar chart with 50 bars), which may stress the token limits of current LLMs even with the iterative generation strategy described in Section 3.4.

Rapid prototyping of animated UI mockups during design sprints. In UI/UX design workflows, designers create static SVG mockups in tools like Figma and need to produce animated prototypes to communicate interaction behavior to developers and stakeholders. Vector Prism could accept a Figma-exported SVG of a screen mockup plus an instruction like "animate the login button to pulse gently, and make the input fields slide in from the left one by one," and produce an animated SVG for presentation within minutes rather than the hours required for manual CSS animation authoring. The method's restartructured output—with descriptive class names and geometric metadata (bounding boxes, centers)—is itself valuable for developer handoff, as it provides a more readable, maintainable codebase than the auto-generated class names typically produced by design tools. The limitation is that complex UI animations with state-dependent logic (e.g., "when the user clicks the button, the modal slides up") would require JavaScript event handling beyond CSS keyframes; the paper's stated capability to extend to JavaScript (Section 3.4) would need to be validated for this use case.

When to Prefer This Method

The paper articulates a clear tradeoff between Vector Prism's semantic restructuring approach and two categories of alternatives: data-scaling approaches that fine-tune LLMs on large SVG-animation corpora (InternSVG, StarVector, OmniSVG), and end-to-end generation approaches that produce raster video (Sora 2, Wan 2.2). The following decision rule is directly supported by evidence in the paper:

  • Prefer Vector Prism when the SVG already contains sufficient primitive granularity for the intended animation and you need vector-based output for web deployment. The 35.22-point GPT-T2V improvement over the identically-pipelined GPT-5 baseline (Table 1) and the 54× compression ratio over Sora 2 (Figure 6) make this the dominant choice for bandwidth-constrained, resolution-independent web contexts. The burn-in cost (M × |X| VLM queries) is amortized over serving the resulting lightweight animated SVG.

  • Prefer data-scaling approaches (fine-tuned LLMs) when the input SVGs have very coarse primitive structure that requires sub-primitive decomposition. Vector Prism's granularity ceiling (Section 5.3, Figure 8) is a hard constraint: it cannot subdivide atomic primitives. A fine-tuned model trained on millions of examples may learn to infer sub-primitive part boundaries from visual patterns, a capability that Vector Prism's zero-training, geometry-preserving approach cannot match. The paper provides no head-to-head comparison with a fine-tuned approach, so this preference is inferred from the paper's own analysis of its limitation rather than from direct experimental evidence.

  • Prefer end-to-end video generation when photorealism or complex visual effects are prioritized over instruction-following precision. Vector Prism produces deterministic, mathematically precise motion of known geometric elements—which excels at targeted, instruction-following animation (GPT-T2V 76.14 vs. Sora 2's 69.08, Table 1) but cannot generate, for example, photorealistic smoke, fluid dynamics, or textured surface deformations. The paper's qualitative analysis notes that video models "generate richer motion" on some dimensions (Section 4.5), even though they underperform on the specific instruction-following metrics the paper prioritizes. For applications where visual richness is paramount and precise part-targeting is secondary, the video generation approach may be preferable despite worse GPT-T2V scores and the 54× file-size penalty.