Paper deep dive

ELECT: Settling Identity Before Rendering for Scalable Story Visualization

Mehrajul Abadin Miraj, Md. Mahmudul Hasan, Meherun Farzana, Aniket Joarder, Mahmudul Hasan, Abir Chakraborty Partha, Md. Ahasanul Alam, Redwan Ahmed Rizvee, Md. Fahim Arefin, Md Mahmudur Rahman, Md. Tanvir Alam, Md Mosaddek Khan

Year: 2026Venue: arXiv preprintArea: cs.CVType: PreprintEmbeddings: 52

Intelligence

Status: not_run | Model: - | Prompt: - | Confidence: 0%

Entities (0)

No extracted entities yet.

Relation Signals (0)

No relation signals yet.

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Training-free story visualization without reference images must preserve recurring entities across frames while scaling to long narratives. Existing methods typically maintain consistency by conditioning each frame on other frames of the same story, coupling generation time, VRAM, or both to story length. We introduce ELECT, which instead settles cross-frame identity before final rendering through a language-guided scene-entity mapping and stationary anchors elected from the model's own drafts. This makes the per-frame cost of the final rendering pass independent of story length. Joint attention exceeds 96 GB of VRAM at 32 scenes, whereas ELECT remains at 8.3 s per frame and under 20 GB VRAM from 10 to 1000 scenes. On the Story50 long-story benchmark, ELECT reaches 0.833 average Character Consistency Similarity (aCCS), compared with 0.826 for ten-round refinement, at one seventh of its generation cost, with lower text alignment (0.327 vs. 0.340). At 1000 scenes, to our knowledge, the first evaluation of training-free story visualization at this length, ELECT exceeds ten-round refinement by 0.017 aCCS and the nearest flat-cost baseline by 0.091, while also surpassing refinement in text alignment at one twenty-fourth of its generation time. These results show that long-horizon consistency need not require increasingly expensive inter-frame conditioning as stories grow.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

48,813 characters extracted from source content.

Expand or collapse full text

ELECT: Settling Identity Before Rendering for Scalable Story Visualization Mehrajul Abadin Miraj* Md. Mahmudul Hasan Meherun Farzana Aniket Joarder Mahmudul Hasan Abir Chakraborty Partha Md. Ahasanul Alam Redwan Ahmed Rizvee Md. Fahim Arefin Md Mahmudur Rahman Md. Tanvir Alam Md Mosaddek Khan University of Dhaka *Corresponding author: mehrajulabadin-2020115630@cs.du.ac.bd Abstract Training-free story visualization without reference images must preserve recurring entities across frames while scaling to long narratives. Existing methods typically maintain consistency by conditioning each frame on other frames of the same story, coupling generation time, VRAM, or both to story length. We introduce ELECT11 1 Code and the long-story dataset are provided in the supplementary material and will be made publicly available upon acceptance., which instead settles cross-frame identity before final rendering through a language-guided scene–entity mapping and stationary anchors elected from the model’s own drafts. This makes the per-frame cost of the final rendering pass independent of story length. Joint attention exceeds 96 GB of VRAM at 32 scenes, whereas ELECT remains at 8.3 s per frame and under 20 GB VRAM from 10 to 1000 scenes. On the Story50 long-story benchmark, ELECT reaches 0.833 average Character Consistency Similarity (aCCS), compared with 0.826 for ten-round refinement, at one seventh of its generation cost, with lower text alignment (0.327 vs. 0.340). At 1000 scenes, to our knowledge, the first evaluation of training-free story visualization at this length, ELECT exceeds ten-round refinement by 0.017 aCCS and the nearest flat-cost baseline by 0.091, while also surpassing refinement in text alignment at one twenty-fourth of its generation time. These results show that long-horizon consistency need not require increasingly expensive inter-frame conditioning as stories grow. 1 Introduction A coherent visual story requires recurring entities to remain consistent across scenes; otherwise, identity drift breaks narrative continuity even when individual frames are visually plausible. Story visualization addresses this challenge by rendering narrative text as a sequence of images while preserving entity identity across frames. The task was introduced in a closed-world form by StoryGAN [16], where the cast is fixed and seen during training. We study the open-ended form: the cast is unknown until the text is read, no reference images are provided, and recurring entities may disappear for long stretches before reappearing later in the story. This setting better reflects practical story-generation scenarios, where the cast emerges from the narrative and character-specific visual references are not assumed to be available. Given only raw prose, a system must determine which entities recur, establish their visual identities, and preserve those identities throughout the narrative. Training-based approaches [27, 13, 28] bind identity into model parameters, but admitting a new character then requires additional optimization, which is poorly suited to open-ended narratives in which new characters may be encountered throughout the story. Moreover, requiring a photograph or appearance sheet for each character as a reference would instead shift identity specification to the user, becoming increasingly impractical as the cast grows. We therefore work in the training-free, reference-free setting, with the prose as the only input. In this setting, the central technical difficulty is that independently generated diffusion frames have no persistent channel through which entity identity can be carried across scenes. A character described in scene i may be absent for many scenes and return in scene j, with j≫ij i; each frame follows a separate denoising trajectory from independent noise, and nothing in the generation of scene j knows what was drawn in scene i. Training-free methods therefore differ mainly in how they construct such a channel. Autoregressive conditioning [24, 18] passes each frame to its successor, propagating appearance and errors alike. Attention sharing [29, 38] jointly generates a batch and extends self-attention across frames, reducing compounding drift at the cost of keeping the batch resident in VRAM. Story-Iter [21] instead regenerates the story over multiple rounds, conditioning each frame on all frames from the previous round. The mechanisms differ, but the underlying premise is shared: maintaining consistency requires visual information from other frames of the same story to remain in the conditioning path during generation. This shared premise makes long-horizon consistency increasingly costly in generation time, VRAM, or both. Under all-pairs conditioning, the N reference image embeddings from previous round form a sequence attended at every denoising step, so one refinement round incurs O⁡(N2)O(N^2) attention work and a key/value cache that grows linearly with N; repeated rounds compound these costs. The effect becomes pronounced as stories grow: Story-Iter’s per-frame time increases by a factor of 3.9 between 10 and 1000 scenes, while ConsiStory’s joint attention exceeds 96 GB of VRAM at 32 scenes (Sec. 4.3). These bottlenecks arise from the mechanism used to maintain cross-frame consistency, rather than from any intrinsic requirement of the narrative itself. To break this coupling, we propose ELECT, a training-free, reference-free approach that settles cross-frame identity before final rendering rather than maintaining it through inter-frame visual conditioning. This allows each frame to be rendered independently, decoupling per-frame generation cost from story length. ELECT remains competitive with iterative refinement at benchmark length, while at 1000 scenes it surpasses ten-round refinement in both identity consistency and text alignment using one twenty-fourth of the generation time and one third of the VRAM. The relative advantage therefore grows substantially as the story horizon increases. Our contributions are as follows: • ELECT operationalizes pre-render identity settlement through a symbolic scene–entity map and a stationary visual anchor for each recurring entity, elected from the model’s own drafts. This avoids both per-character optimization and user-provided visual references while enabling independent final-frame generation. • At benchmark length, ELECT reaches 0.833 in average Character Consistency Similarity (aCCS), outperforming ten-round refinement by 0.007 at one seventh of its generation cost, while giving up only 0.013 in text alignment. This demonstrates that stationary identity conditioning can match or exceed iterative refinement without repeated cross-frame generation. • We introduce a long-horizon evaluation suite of 1000-scene stories and, to our knowledge, provide the first evaluation of training-free story visualization at this scale. ELECT reaches 0.805 aCCS, 0.017 above ten-round refinement and 0.091 above the nearest flat-cost baseline, while maintaining 8.3 s per frame and 19.7 GB VRAM, at $20 in GPU cost for the suite versus $487 for ten-round refinement. At this length, refinement takes 55.6 hours, while joint attention exhausts VRAM at 32 scenes. • Through controlled ablations, we identify where ELECT’s gains arise: anchored conditioning contributes +0.100+0.100 aCCS at benchmark length and +0.081+0.081 at 1000 scenes; electing the anchor improves aCCS by 0.027 over random selection and by 0.100 over the worst candidate, while reversing the injection schedule costs 0.048 aCCS. 2 Related Work Prior work relevant to ELECT spans open-ended story visualization, methods for preserving character identity, and training-free mechanisms for maintaining that identity across frames. Story visualization began as a closed-world problem. StoryGAN [16] fixed the cast in advance and showed it during training, and the work that followed improved the generator or its conditioning without disturbing that assumption [20, 15, 5]. StoryGen [18] named the open-ended form we study here, in which characters exist only as descriptions in the prose, and released a large dataset of illustrated stories spanning hundreds of character categories. Once the cast is unknown until the text is read, the question becomes where an entity’s appearance is stored and how it reaches a frame that needs it. One answer stores it in weights. Subject-driven personalization [27, 11, 31, 17] learns a token or a low-rank update per character, and story systems built on it compose the learned characters into scenes [13, 28, 32]. Identity fidelity can be strong, but admitting a new character costs an optimization run, and continual customization [9, 36] reports identity degrading as learned characters accumulate, which is the wrong direction for a narrative whose cast keeps growing. The training-free alternative stores appearance in the frames themselves and manufactures a channel between them. Autoregressive conditioning [24, 18] hands each frame to its successor, keeping neighbours consistent while inheriting every error it is given. Attention sharing [29, 38] generates a batch jointly and keeps it resident in VRAM; StoryDiffusion additionally bootstraps long stories from its first generated frames, tying everything later to those initial outputs. Story-Iter [21] instead regenerates the story over several rounds, conditioning each frame on all frames of the previous round compressed to a fixed number of global tokens, which keeps per-frame conditioning cheap at the price of repeated full passes over the story (Sec. 4.3) which is still quadratic. The injection mechanism is largely shared, IP-Adapter’s decoupled cross-attention [35]; what separates these methods is which visual references reach each frame, and that choice is what couples their cost to story length. A second family breaks that coupling by conditioning on the character rather than the frame, fixing the conditioning before rendering: clustering samples into an identity, minting a portrait from an LLM description, sharing one reference panel, or grounding mentions to entity features [1, 14, 8, 10]; concurrent multi-shot video work accumulates per-entity banks across shots. ELECT belongs here, but where these approaches accept the reference obtained at construction time, we elect it from evidence distributed across the complete story. A parallel line delegates narrative structure to a language model [7, 6, 34, 37], and existing benchmarks [4, 10, 39] run to tens of frames, so neither the mechanism nor the evaluation has yet been pushed to the horizon we target. Taken together, prior work addresses long horizon identity consistency through either per-character optimization or story-length-dependent inter-frame visual conditioning, which becomes impractical in generation time and VRAM as stories grow. 3 The ELECT Framework We now describe ELECT, which transforms a sequence of story scenes into a visually consistent image sequence through three stages: script construction, drafting and anchor election, and anchored regeneration. Figure 1 provides an overview of the complete pipeline. Figure 1: Overview of ELECT. Stage 1, script construction: an LLM reads the full story and writes a Script, a recurring cast with short descriptions and a per-frame participant map, establishing cross-frame consistency symbolically. Stage 2, drafting and election: SDXL drafts each frame from text alone, a detector proposes crops for that frame’s cast, DINOv2 filtering removes misfires, and the best crop per entity is elected as its canonical anchor. Stage 3, anchored regeneration: each frame is regenerated from scratch using its own text and its participants’ anchors via IP-Adapter, independently of other frames, so the pass stays parallel and flat in N. 3.1 Problem Setting A story is a sequence of N scene descriptions p1,…,pNp_1,…,p_N, one per frame, with no cast list, reference photographs, or guarantee that an entity’s first mention provides a usable visual description. We produce frames x1,…,xNx_1,…,x_N in which recurring entities remain visually consistent, each xix_i remains faithful to pip_i, and the cost of producing xix_i depends on neither i nor N. Every component is a frozen pretrained model [25, 35, 23, 26, 30] composed at inference; no weights are updated at any point. 3.2 Script Construction ELECT begins by constructing a symbolic representation of the story. A local language model (Qwen3-14B [33]) reads the full prompt sequence in one pass and emits a Script S. =LLM(p1:N)=(ℰ,Π)S\;=\;LLM(p_1:N)\;=\;(E,\, ) (1) As defined in Eq. 1, ℰ=e1,…,eME=\e_1,…,e_M\ is the cast of recurring entities, each a character the story returns to, and Π:1,…,N→2ℰ :\1,…,N\→ 2^E assigns to each frame the entities it casts. The model is asked for exactly two things: a cast of recurring entities, each carrying a one-line description d⁡(e)d(e), and, for every frame, the subset of that cast supported by the frame’s own text. The prompt is reproduced in full in the supplementary material. Everything required by the later stages is read from this pair. An entity’s description d⁡(e)d(e) is used unchanged as the grounding phrase that queries the detector, while its frame set F⁡(e)=i:e∈Π⁡(i)F(e)=\i:e∈ (i)\ is obtained by scanning Π . Both come directly from S, with no further judgment asked of the model once it has named the cast and placed its members scene by scene. The map Π is where the cross-frame channel is established. Other training-free methods construct it in pixel space, implicitly asserting that entity e in frames i and j is the same by making their latents attend to one another; Eq. 1 asserts it symbolically. Deciding that “the knight,” “he”, and “Sir Aldric” denote one entity in scene j as in scene i, with j≫ij i, is a coreference-resolution problem, handled notably more reliably in text than in latent space. 3.3 Drafting and Election Each frame is first generated once from its own prompt with a pretrained text-to-image diffusion model [25] under a fixed style template, with no conditioning on any other frame. These drafts are not shown; instead, they provide the candidate pool from which entity anchors are selected. Anchor construction proceeds in two steps. Harvesting and filtering. An open-vocabulary detector [30] runs on every draft, queried only with that frame’s Script participants, yielding a pool of candidate crops for each entity across the story. Each pool is embedded with DINOv2 [23] and clustered with k-means. Crops outside the dominant cluster are discarded, leaving a candidate pool ⁡(e)C(e) for each entity. This filtering also removes two common errors: detections of the wrong object and lookalike characters that match the same grounding phrase. Such incorrect crops appear as outliers in the embedding space. Election. Given the filtered candidate pool ⁡(e)C(e), the anchor for entity e is selected as the highest-scoring surviving crop, a⁡(e)=arg⁡maxc∈⁡(e)⁡q⁡(c)a(e)= _c (e)q(c), where the quality score combines three per-crop signals, q⁡(c)=wcconf(c)+wssharp(c)+waarea(c),q(c)\;=\;w_c\,conf(c)\;+\;w_s\,sharp(c)\;+\;w_a\,area(c), (2) with the balanced default (wc,ws,wa)=(0.4,0.3,0.3)(w_c,w_s,w_a)=(0.4,0.3,0.3). The three terms capture complementary aspects of reference quality. conf⁡(c)conf(c) is the detector’s confidence, which is low for partial, occluded, and weakly grounded instances; sharp⁡(c)sharp(c) is a normalised Laplacian response, which is low for blurred and out-of-focus crops; and area⁡(c)area(c) is the crop’s area as a fraction of its frame, which is low for distant instances that contain too few pixels to encode appearance reliably. These criteria matter because the elected anchor is re-encoded and injected into every frame in which its entity appears, so defects in the selected crop can propagate throughout the story. Section 4.4 varies (wc,ws,wa)(w_c,w_s,w_a) and shows that no single signal suffices. By the time Eq. 2 is applied, two earlier decisions have already been made. Harvesting determines whether a crop corresponds to the target entity, since a candidate exists only because the detector matched it to the entity’s grounding phrase. Filtering then determines whether that crop is representative of the entity: restricting ⁡(e)C(e) to the dominant DINOv2 cluster removes unrepresentative crops as a hard constraint rather than treating representativeness as a soft penalty traded against image quality. Election therefore addresses the remaining question: which of the surviving, matched, and representative crops provides the cleanest instance to re-encode. 3.4 Anchored Regeneration With the anchor bank fixed, every frame is regenerated independently from fresh Gaussian noise and its own scene text. Each frame is conditioned through IP-Adapter’s decoupled cross attention [35] only on the bank entries of the entities participating in that scene, with one token block per active entity built from the CLIP embedding of its anchor. Because the bank entries are entity crops rather than whole frames, composition and background are not transferred along with identity. Moreover, because each frame is conditioned only on the entities in its own scene, the conditioning set does not grow with story length. Because a scene casts a bounded number of entities, what a frame is conditioned on does not grow with the number of frames preceding it, and a 50-scene and a 1000-scene story pay the same per-frame cost. Injection schedule. The remaining design choice is how strongly, and when, the anchor should influence generation. We scale the anchor token block by a factor λent(t) _ent(t) inside the decoupled cross-attention and vary it linearly over the sampling trajectory, λent(t)=λhi+(λlo−λhi)T−tT, _ent(t)= _hi+ ( _lo- _hi )\, T-tT, (3) with t=T,…,0t=T,…,0 over the T sampling steps, from λhi=0.85 _hi=0.85 at the first, highest-noise step to λlo=0.35 _lo=0.35 at the last. Early steps determine coarse structure, where silhouette, build, and palette are established and weak anchor guidance can lose identity; later steps determine texture and local detail, where reducing anchor strength leaves more capacity for the scene text. Tab. 4 compares this decay with constant scales and the reverse sweep. 4 Experiments We evaluate ELECT along the dimensions that motivate its design: identity consistency and text alignment, scalability in generation time and VRAM, and the contribution of its individual components. We first describe the evaluation setting and implementation. 4.1 Setup We evaluate on the Story50 long-story benchmark (20 stories of 50 frames each) [21] and on five 1000-scene stories adapted from public-domain books: The Mysterious Island, Taras Bulba, the Shahnameh, a Russian fairy tale, and the Völsunga saga. Their construction is described in the supplementary material. We report CLIP-T for text–image alignment and aCCS for cross-frame identity consistency, following [7]. Implementation details. All runs use SDXL [25] at 1024×10241024× 1024 with 50 sampling steps on a single NVIDIA RTX 6000 PRO Blackwell (96 GB). Anchors are injected through base IP-Adapter with four pooled tokens per entity using the schedule in Eq. 3. Script extraction uses Qwen3-14B. Harvesting uses YOLOE [30], and candidate crops are embedded with DINOv2 [23] for the cluster filter in Sec. 3.3. In preliminary experiments, YOLOE grounded the Script descriptions more accurately than the alternatives tested, while DINOv2 separated visually similar characters more reliably than CLIP Table 1: Story50 [21] benchmark comparison. Rows below the rule are our own reproductions, run on identical stories, seeds and hardware; rows above are quoted from prior publications. Method CLIP-T ↑ aCCS ↑ AR-LDM [24] 0.216 0.673 StoryGen [18] 0.223 0.740 IP-Adapter [35] 0.274 0.751 FLUX.1.Kontext [2] 0.290 0.783 Nano Banana 0.310 0.791 IP-AdapterXL [35] 0.297 0.787 DALL⋅·E 3 [3] 0.301 0.674 SEED-LLaMA [12] 0.279 0.688 ConsiStory [29] 0.316 0.761 1Prompt1Story [19] 0.340 0.7287 StoryDiffusion [38] 0.351 0.8103 DreamStory [14] 0.3193 0.7627 Story-Iter [21] 0.340 0.8264 ELECT (ours) 0.3273 0.8334 4.2 What does anchoring buy? Anchoring drives consistency. Anchoring replaces per-frame identity guesswork with a single settled reference: Pass 0 drafts every scene independently from text, one crop per entity is elected as the anchor, and the second pass conditions all remaining scenes on it according to the mapping. On the standard story50 benchmark (Tab. 1), this puts ELECT at 0.83340.8334 aCCS, the highest of any method we compare against, ahead of Story-Iter (0.82640.8264) and StoryDiffusion (0.81030.8103), while CLIP-T sits at 0.32730.3273, within 0.0240.024 of the best value and above most baselines. The benchmark therefore places us where anchoring should: identity is held tighter than by iterative refinement or reference-injection methods, at a small and expected cost in per-frame prompt adherence, since conditioning on a fixed appearance necessarily pulls each frame slightly away from its own text. Pass 0 isolates the anchor’s contribution: it shares prompts, backbone, style template and seeds with the final pass and differs only in that no anchor is injected (Tab. 2). Anchoring raises aCCS by 0.1000.100 at 50 scenes and by 0.0810.081 at 1000, while CLIP-T falls by only 0.0250.025 and 0.0120.012. The trade is strongly asymmetric, and it does not degrade with story length. Table 2: Effect of anchored conditioning. Pass 0 is ELECT’s own draft: identical prompts, backbone and seeds, generated independently from text with no cross-frame conditioning. The 50-scene row is the mean over 20 benchmark stories. aCCS ↑ CLIP-T ↑ Pass 0 ELECT Pass 0 ELECT 50-scene benchmark Mean over 20 stories 0.7334 0.8334 0.352 0.3273 Δ +0.100+0.100 −0.025-0.025 1000 scenes Mean 0.7239 0.8050 0.318 0.306 Δ +0.081+0.081 −0.012-0.012 4.3 What does story length cost? Table 3: Quality and cost at N=1000N=1000 scenes (102421024^2, RTX 6000 PRO Blackwell, 96 GB). ConsiStory exceeds VRAM at 32 scenes; its peak is reported at N=16N=16. s/frame is end-to-end wall clock divided by N, covering every stage each method runs: for ELECT, Script extraction, the Pass 0 drafts, detection, embedding and clustering, and the anchored regeneration pass; for Story-Iter, all ten refinement rounds. Total (h) is this average per story generation time CLIP-T and aCCS are mean over 5 stories. Method CLIP-T ↑ aCCS ↑ s/frame Total (h) VRAM (GB) Cost grows with N ConsiStory [29] OOM OOM – – 92.7 (N=16N=16) Story-Iter [21] 0.3044 0.7885 200.1 55.6 59.7 Cost flat in N 1Prompt1Story [19] 0.309 0.714 7.37 2.05 16.7 StoryDiffusion [38] 0.315 0.639 4.40 1.22 66.4 DreamStory [14] 0.3089 0.6976 38.42 10.7 32.9 ELECT (ours) 0.306 0.8050 8.30 2.30 19.7 00505010010015015020020024×24× at N=1000N=1000ELECT: constant 8.38.3 s/frameTime / frame (s)ELECT (ours)Story-IterConsiStory1Prompt1StoryStoryDiffusionDreamStory01002003004005006007008009001000002020404060608080100100GPU limit 9696 GBConsiStory OOM (N≥32N≥32)Story length N (frames)Peak VRAM (GB) Figure 2: Scaling from 4 to 1000 scenes. Top: amortized cost per frame. ELECT is constant at 8.38.3 s/frame while Story-Iter degrades from 51.851.8 to 200.1200.1 s/frame, a 24×24× gap at N=1000N=1000 (8.38.3 s vs. 200200 s end-to-end); the shaded band is the resulting speedup. Bottom: peak VRAM. ELECT is constant at 19.719.7 GB, whereas ConsiStory exceeds the 9696 GB device budget at N=32N=32 (cross), while StoryDiffusion and DreamStory hold fixed budgets of 66.466.4 and 32.932.9 GB. Baselines limited to short horizons are plotted only over the range they complete. Existing benchmarks typically cover only tens of frames, leaving the long-story regime largely unexplored. We therefore evaluate stories up to 1000 scenes to examine how quality and computational cost scale with narrative length. Figure 2 reports scaling from 4 to 1000 scenes, while Tab. 3 summarizes quality and cost at 1000 scenes. ELECT keeps its cost fixed as stories grow. The difference is clearest in per-frame cost. ConsiStory cannot reach 32 scenes because its shared attention state exceeds 96 GB of VRAM (Fig. 2). Story-Iter reaches 1000 scenes, but its per-frame cost grows from 51.851.8 s at 10 scenes to 200.1200.1 s at 1000, requiring 55.6 hours for one story. ELECT instead remains at 8.38.3 s per frame and 19.719.7 GB VRAM from 10 to 1000 scenes, completing the same story in 2.30 hours. This behavior follows from how ELECT carries cross-frame information. The Script and frozen anchor bank fix the relevant entity information before rendering, so each scene is conditioned only on the entities it contains and the conditioning size does not grow with story length. 1Prompt1Story and StoryDiffusion also maintain nearly constant per-frame cost and are faster than ELECT at 1000 scenes, at 7.377.37 s and 4.404.40 s per frame, respectively. However, this speed advantage comes with substantially lower identity consistency: ELECT reaches 0.80500.8050 aCCS, compared with 0.7140.714 for 1Prompt1Story and 0.6390.639 for StoryDiffusion. Thus, ELECT retains markedly stronger identity consistency while keeping its per-frame cost nearly constant as stories grow. The efficiency does not come at the cost of identity. At 1000 scenes, ELECT reaches 0.80500.8050 aCCS, which is 0.0910.091 higher than 1Prompt1Story, 0.1660.166 higher than StoryDiffusion, and 0.0170.017 higher than Story-Iter (Tab. 3). CLIP-T is similar across the three flat-cost methods, with ELECT only 0.0090.009 below StoryDiffusion. Thus, the methods that keep their cost fixed do not all preserve identity equally well. StoryDiffusion, for example, is only 0.0230.023 behind ELECT at the benchmark length but falls 0.1660.166 behind at 1000 scenes. Against Story-Iter, ELECT is better on both quality measures at 1000 scenes while using about 24×24× less generation time and one-third the peak VRAM. 4.4 How hard should the anchor push, and which crop should it push with? Results in Tab. 2 already show that anchoring improves identity consistency. We next examine two choices that determine how much of this gain is realised: how the anchor is injected during sampling (Tab. 4) and which crop is elected as the anchor (Tab. 5). When the anchor pushes matters more than how hard. At a constant scale, increasing λent _ent from 0.350.35 to 0.850.85 raises identity monotonically, from 0.787 to 0.829 aCCS, while reducing alignment from 0.343 to 0.327 CLIP-T. A fixed scale therefore acts largely as a dial between the two objectives. The scheduled variants reveal that timing also matters. Both use the same endpoints and differ only in direction, yet they finish 0.0480.048 aCCS apart: decaying →0.350.85\!→\!0.35 is the best arm in the table, while rising →0.850.35\!→\!0.85 is the worst. Because the two schedules have the same average anchor strength, the difference comes from when that strength is applied. The rising schedule performs no better on either metric than holding the weakest scale throughout, consistent with identity-relevant structure being established early in denoising. Conversely, decay outperforms a constant 0.850.85 on both metrics despite using lower strength for most of the trajectory, suggesting that strong early guidance and weaker late guidance provide a better balance. The flat schedules remain useful for other operating points: a constant 0.500.50 reaches 0.8080.808 aCCS and 0.3380.338 CLIP-T, matching our Story-Iter reproduction’s alignment to within 0.0020.002 at 0.0180.018 lower consistency. Anchor election is necessary, not merely anchoring. To separate having an anchor from having a good one, we cross the election rule with the pool it draws from: argmax of Eq. 2, a random survivor, or argmin, over either the cluster-filtered pool or the raw one (Tab. 5). aCCS is monotonic in the rule on both pools, 0.8334/0.8065/0.79110.8334/0.8065/0.7911 filtered and 0.8244/0.7951/0.73350.8244/0.7951/0.7335 raw, and the best cell requires both stages: filtering without a careful election, or election over an unfiltered pool, each falls short of the two together. A random anchor already recovers much of the benefit of anchoring, but a poor one gives most of it back, especially in the raw pool, where argmin falls 0.0910.091 below argmax. The two stages guard against different failures. Filtering helps every rule, but by 0.0090.009 aCCS for argmax and 0.0110.011 for random against 0.0580.058 for argmin, so its work is almost entirely the removal of unusable candidates, while the election decides which of the survivors is actually re-encoded. Alignment is essentially unaffected by the choice: argmax and random read 0.32730.3273 and 0.32800.3280 CLIP-T on the filtered pool. The identity gain therefore comes from choosing the anchor well, at no meaningful cost in alignment. Combining the three signals is better than using any one alone. We ablate the three terms in the election score by comparing the balanced configuration with each single-signal variant, keeping all other settings fixed (Tab. 6). The balanced weights achieve the highest aCCS (0.8334), outperforming area only (0.8291), confidence only (0.8118), and sharpness only (0.7980). This shows that no single signal is sufficient to select the best anchor, while combining confidence, sharpness, and area gives the strongest overall selection. CLIP-T follows the same trend except for area only, which is marginally higher than the balanced setting (0.3279 vs. 0.3273). We therefore use the balanced weights (0.4,0.3,0.3)(0.4,0.3,0.3) throughout. Table 4: Anchor strength during regeneration. λent _ent scales the anchor token block inside IP-Adapter’s decoupled cross-attention, either held flat across the 50 sampling steps or swept linearly by Eq. 3. The two scheduled arms share their endpoints and differ only in direction. Mean over the story50 stories; everything else fixed, including Script, drafts, harvest, election and seed. The last row is the configuration reported throughout. λent _ent aCCS ↑ CLIP-T ↑ Flat 0.350.35 0.7872 0.3427 0.500.50 0.8083 0.3382 0.750.75 0.8107 0.3300 0.850.85 0.8293 0.3268 Scheduled rising →0.850.35\!→\!0.85 0.7850 0.3426 decaying →0.350.85\!→\!0.35 0.8334 0.3273 Table 5: Where the anchor’s quality comes from: the rule that picks one crop per entity, crossed with whether the pool it picks from has been cluster-filtered. All cells share the pipeline, prompts, backbone and seeds, and differ only in these two factors. Random is the mean of three seeds, whose spread is at most 0.009 aCCS. The top-left cell is the reported configuration of Tab. 1. Mean over the 20 benchmark stories. aCCS ↑ CLIP-T ↑ Selection rule Filtered Raw pool Filtered Raw pool argmax of Eq. 2 0.8334 0.8244 0.3273 0.3260 Random survivor 0.8065 0.7951 0.3280 0.3226 argmin of Eq. 2 0.7911 0.7335 0.3206 0.3136 Table 6: Weights of the election score on the story50 benchmark, driving (wc,ws,wa)(w_c,w_s,w_a) of Eq. 2 to each corner of the simplex with everything else fixed. The first row is the reported configuration. (wc,ws,wa)(w_c,w_s,w_a) aCCS ↑ CLIP-T ↑ balanced (0.4,0.3,0.3)(0.4,0.3,0.3) 0.8334 0.3273 confidence only (1,0,0)(1,0,0) 0.8118 0.3262 sharpness only (0,1,0)(0,1,0) 0.7980 0.3243 area only (0,0,1)(0,0,1) 0.8291 0.3279 4.5 Can Stage 3 reuse the draft’s trajectory? Pass 0 achieves higher CLIP-T (Tab. 2), suggesting that re-entering its trajectory while supplying identity through the anchor might retain both alignment and consistency. We test this following SDEdit [22]: the draft is forward-noised to a start index determined by strength s, and only the remaining steps are run under injection (s=0.75s=0.75 skips 13 of 50 steps; our default is s=1s=1). The resulting trade-off is less favorable (Tab. 7). Alignment improves because composition is established by a pass with no competition from anchor tokens, and the variant preserves that decision. Identity degrades for the same reason: diffusion commits low-frequency structure early, precisely where Eq. 3 assigns λent _ent its highest values. Entering mid-trajectory leaves the anchor only the low-noise tail, where it can restyle surfaces but not re-shape a participant already established by the draft. The ordering in Tab. 4 remains unchanged, showing that the schedule effect is not an artefact of starting from noise. Table 7: Draft-trajectory reuse (s=0.75s=0.75) instead of fresh noise; story50 benchmark. Against the fresh-noise default (0.8334 aCCS, 0.3273 CLIP-T), reuse costs 0.039 aCCS for 0.017 CLIP-T. λent _ent aCCS ↑ CLIP-T ↑ flat 0.150.15 0.7626 0.3512 flat 0.500.50 0.7807 0.3478 flat 0.700.70 0.7867 0.3457 decaying →0.350.85\!→\!0.35 0.7947 0.3442 4.6 Is the planning layer a bottleneck? If the Script has to come from a strong reader, ELECT inherits the cost and deployment constraints of one. We therefore replace Qwen3-14B with Qwen3-4B, a quarter of the parameters, and re-run the pipeline with everything else fixed. The smaller planner costs 0.01180.0118 aCCS, 0.82160.8216 against 0.83340.8334 (Tab. 8), and moves alignment a negligible 0.00070.0007 the other way. Since nothing downstream of the Script changes, the whole difference lies in what the two models write: which entities they promote to the cast, which frames they credit them to, and how usable each one-line description is as a grounding phrase for the detector. A small model recovers about 99%99\% of the reported score, so the symbolic layer does not depend on frontier-scale reading. It is not free either: the penalty exceeds the 0.0070.007 by which ELECT leads Story-Iter at this length, so the planner is material to that comparison, though it stays small against the 0.1000.100 anchoring supplies and the 0.0480.048 the schedule’s direction is worth (Tab. 4). Table 8: Planner capacity. The Script is re-extracted with a smaller language model and the pipeline re-run end to end on the 50-scene benchmark, everything else fixed. The first row is the configuration reported throughout. Script extractor aCCS ↑ CLIP-T ↑ Qwen3-14B 0.8334 0.3273 Qwen3-4B 0.8216 0.3280 4.7 What does it cost to run? Time and VRAM capture architectural efficiency, but practical deployment also depends on generation cost. At $1.74 per GPU-hour (Vast.ai rate for an NVIDIA RTX 6000 PRO Blackwell), the difference is small at benchmark scale but compounds sharply with length: on the long-story suite (5 stories × 1000 frames), ELECT costs $20 versus $487 for ten-round refinement ($4.01 vs. $97.44 per story), with the gap widening from 6.7×6.7× to 24×24× because refinement’s per-frame cost grows with N while ELECT’s does not. Scaled to 100 thousand-scene stories, this is $401 versus $9,744. ELECT is not the cheapest method (StoryDiffusion: $10.63; 1Prompt1Story: $17.82 for the suite), but it is the cheapest that preserves identity at this length, with both cheaper alternatives scoring lower on aCCS (by 0.166 and 0.091, Tab. 9). Table 9: Cost of generating each evaluation set, at $1.74 per GPU-hour (NVIDIA RTX 6000 PRO, on-demand(vast.ai), 22 August 2026). Story50 is 20 stories of 50 frames; the long-story suite is five stories of 1000 frames. Totals are the generation times of Tab. 3 and Fig. 2; hourly rates and hardware availability vary, so the ratios matter more than the absolute figures. Story50 Long-story suite Method Hours USD Hours USD Story-Iter [21] 15.74 27.39 280.0 487.20 1Prompt1Story [19] 2.16 3.76 10.24 17.82 DreamStory [14] 10.99 19.123 53.5 93.09 StoryDiffusion [38] 1.22 2.12 6.11 10.63 ELECT (ours) 2.35 4.09 11.53 20.06 Figure 3: One recurring entity per 1000-scene story, shown at five frames sampled across the full length for the five stories. 4.8 What this looks like at 1000 scenes Figure 3 tracks a single recurring entity in each long-story suite, at frames drawn from across the whole 1000, rather than from one neighbourhood. Silhouette, palette, and costume survive the span even when hundreds of scenes separate two appearances, which is what the flat per-frame cost protects: the anchor is the same crop at frame j as at frame i, with j≫ij i, so there is no accumulated drift. It is not exact. Garment detail, facial features, and accessories vary between appearances, and the 0.80500.8050 aCCS of Tab. 3 is the quantitative form of that gap. What the anchor fixes is the entity’s identity at recognition level, not its appearance pixel for pixel. 5 Conclusions Training-free story visualization has typically maintained consistency through visual dependencies between frames, making long-horizon generation increasingly expensive. ELECT instead separates entity correspondence from appearance: a language model resolves recurring entities from the prose, while one elected visual anchor per entity fixes appearance before final rendering. The resulting frames can be generated independently, with per-frame cost determined by the cast of a scene rather than the length of the story. At benchmark length, ELECT reaches higher identity consistency than ten-round refinement at one seventh of its generation cost, while trading some text alignment. At 1000 scenes, it exceeds refinement by 0.017 aCCS and 0.002 CLIP-T while using one twenty-fourth of its generation time and one third of its VRAM. Controlled ablations further show that anchored conditioning provides the dominant consistency gain, while anchor selection and injection timing materially affect the final result. These findings suggest that long-horizon consistency need not rely on increasingly expensive inter-frame conditioning, opening a path toward scalable visual story generation. References [1] O. Avrahami, A. Hertz, Y. Vinker, M. Arar, S. Fruchter, O. Fried, D. Cohen-Or, and D. Lischinski (2024) The chosen one: consistent characters in text-to-image diffusion models. In ACM SIGGRAPH 2024 Conference Papers, p. 1–12. Cited by: §2. [2] S. Batifol, A. Blattmann, F. Boesel, S. Consul, C. Diagne, T. Dockhorn, J. English, Z. English, P. Esser, and S. Kulal (2025) FLUX.1 kontext: flow matching for in-context image generation and editing in latent space. arXiv e-prints. Cited by: Table 1. [3] J. Betker, G. Goh, L. Jing, T. Brooks, J. Wang, L. Li, L. Ouyang, J. Zhuang, J. Lee, Y. Guo, et al. (2023) Improving image generation with better captions. Computer Science. https://cdn. openai. com/papers/dall-e-3. pdf 2 (3), p. 8. Cited by: Table 1. [4] E. Bugliarello, H. H. Moraldo, R. Villegas, M. Babaeizadeh, M. T. Saffar, H. Zhang, D. Erhan, V. Ferrari, P. Kindermans, and P. Voigtlaender (2023) StoryBench: a multifaceted benchmark for continuous story visualization. In Advances in Neural Information Processing Systems (NeurIPS) Datasets and Benchmarks Track, Cited by: §2. [5] H. Chen, R. Han, T. Wu, H. Nakayama, and N. Peng (2022) Character-centric story visualization via visual planning and token alignment. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing (EMNLP), p. 8259–8272. Cited by: §2. [6] J. Cheng, X. Lu, H. Li, K. L. Zai, B. Yin, Y. Cheng, Y. Yan, and X. Liang (2024) AutoStudio: crafting consistent subjects in multi-turn interactive image generation. arXiv preprint arXiv:2406.01388. Cited by: §2. [7] J. Cheng, B. Yin, K. Cai, M. Huang, H. Li, Y. He, X. Lu, Y. Li, Y. Li, Y. Cheng, Y. Yan, and X. Liang (2024) TheaterGen: character management with llm for consistent multi-turn image generation. arXiv preprint arXiv:2404.18919. Cited by: §2, §4.1. [8] D. Dinkevich, M. Levy, O. Avrahami, D. Samuel, and D. Lischinski (2026) Story2Board: a training-free approach for expressive visual storytelling. Computer Graphics Forum. External Links: Document Cited by: §2. [9] J. Dong, W. Liang, H. Li, D. Zhang, M. Cao, H. Ding, S. Khan, and F. S. Khan (2024) How to continually adapt text-to-image diffusion models for flexible customization?. In Advances in Neural Information Processing Systems (NeurIPS), Cited by: §2. [10] S. Dong, I. Shaheen, and S. A. Bargal (2026) FreeStory: training-free character consistency for free-form visual storytelling. arXiv preprint arXiv:2606.25079. Cited by: §2. [11] R. Gal, Y. Alaluf, Y. Atzmon, O. Patashnik, A. H. Bermano, G. Chechik, and D. Cohen-Or (2023) An image is worth one word: personalizing text-to-image generation using textual inversion. In International Conference on Learning Representations (ICLR), Cited by: §2. [12] Y. Ge, S. Zhao, Z. Zeng, Y. Ge, C. Li, X. Wang, and Y. Shan (2024) Making LLaMA SEE and draw with SEED tokenizer. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: Table 1. [13] Y. Gong, Y. Pang, X. Cun, M. Xia, Y. He, H. Chen, L. Wang, Y. Zhang, X. Wang, Y. Shan, and Y. Yang (2023) TaleCrafter: interactive story visualization with multiple characters. In SIGGRAPH Asia 2023 Conference Papers, Cited by: §1, §2. [14] H. He, H. Yang, Z. Tuo, Y. Zhou, Q. Wang, Y. Zhang, Z. Liu, W. Huang, H. Chao, and J. Yin (2025) DreamStory: open-domain story visualization by llm-guided multi-subject consistent diffusion. IEEE Transactions on Pattern Analysis and Machine Intelligence 47 (12), p. 11874–11891. External Links: Document Cited by: §2, Table 1, Table 3, Table 9. [15] B. Li (2022) Word-level fine-grained story visualization. In European Conference on Computer Vision (ECCV), p. 347–362. Cited by: §2. [16] Y. Li, Z. Gan, Y. Shen, J. Liu, Y. Cheng, Y. Wu, L. Carin, D. Carlson, and J. Gao (2019) StoryGAN: a sequential conditional gan for story visualization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 6329–6338. Cited by: §1, §2. [17] Z. Li, M. Cao, X. Wang, Z. Qi, M. Cheng, and Y. Shan (2024) PhotoMaker: customizing realistic human photos via stacked id embedding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 8640–8650. Cited by: §2. [18] C. Liu, H. Wu, Y. Zhong, X. Zhang, Y. Wang, and W. Xie (2024) Intelligent grimm — open-ended visual storytelling via latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 6190–6200. Cited by: §1, §2, §2, Table 1. [19] T. Liu, K. Wang, S. Li, J. van de Weijer, F. S. Khan, S. Yang, Y. Wang, J. Yang, and M. Cheng (2025) One-prompt-one-story: free-lunch consistent text-to-image generation using a single prompt. In International Conference on Learning Representations (ICLR), External Links: Link Cited by: Table 1, Table 3, Table 9. [20] A. Maharana and M. Bansal (2021) Integrating visuospatial, linguistic and commonsense structure into story visualization. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP), Cited by: §2. [21] J. Mao, X. Huang, Y. Xie, Y. Chang, M. Hui, B. Xu, Z. Zheng, Z. Wang, C. Xie, and Y. Zhou (2026) Story-iter: a training-free iterative paradigm for long story visualization. In International Conference on Learning Representations (ICLR), External Links: Link Cited by: §1, §2, §4.1, Table 1, Table 1, Table 1, Table 3, Table 9. [22] C. Meng, Y. He, Y. Song, J. Song, J. Wu, J. Zhu, and S. Ermon (2022) SDEdit: guided image synthesis and editing with stochastic differential equations. External Links: 2108.01073, Link Cited by: §4.5. [23] M. Oquab, T. Darcet, T. Moutakanni, H. Vo, M. Szafraniec, V. Khalidov, P. Fernandez, D. Haziza, F. Massa, A. El-Nouby, et al. (2024) DINOv2: learning robust visual features without supervision. Transactions on Machine Learning Research. Cited by: §3.1, §3.3, §4.1. [24] X. Pan, P. Qin, Y. Li, H. Xue, and W. Chen (2024) Synthesizing coherent story with auto-regressive latent diffusion models. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), p. 2920–2930. Cited by: §1, §2, Table 1. [25] D. Podell, Z. English, K. Lacey, A. Blattmann, T. Dockhorn, J. Müller, J. Penna, and R. Rombach (2024) SDXL: improving latent diffusion models for high-resolution image synthesis. In International Conference on Learning Representations (ICLR), Cited by: §3.1, §3.3, §4.1. [26] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever (2021) Learning transferable visual models from natural language supervision. In International Conference on Machine Learning (ICML), p. 8748–8763. Cited by: §3.1. [27] N. Ruiz, Y. Li, V. Jampani, Y. Pritch, M. Rubinstein, and K. Aberman (2023) DreamBooth: fine tuning text-to-image diffusion models for subject-driven generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 22500–22510. Cited by: §1, §2. [28] M. Tao, B. Bao, H. Tang, Y. Wang, and C. Xu (2024) StoryImager: a unified and efficient framework for coherent story visualization and completion. In European Conference on Computer Vision (ECCV), p. 479–495. Cited by: §1, §2. [29] Y. Tewel, O. Kaduri, R. Gal, Y. Kasten, L. Wolf, G. Chechik, and Y. Atzmon (2024) Training-free consistent text-to-image generation. ACM Transactions on Graphics 43 (4), p. 1–18. Cited by: §1, §2, Table 1, Table 3. [30] A. Wang, L. Liu, H. Chen, Z. Lin, J. Han, and G. Ding (2025) YOLOE: real-time seeing anything. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 24591–24602. Cited by: §3.1, §3.3, §4.1. [31] Y. Wei, Y. Zhang, Z. Ji, J. Bai, L. Zhang, and W. Zuo (2023) ELITE: encoding visual concepts into textual embeddings for customized text-to-image generation. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 15943–15953. Cited by: §2. [32] J. Wu, C. Tang, J. Wang, Y. Zeng, X. Li, and Y. Tong (2025) DiffSensei: bridging multi-modal llms and diffusion models for customized manga generation. In Proceedings of the Computer Vision and Pattern Recognition Conference (CVPR), p. 28684–28693. Cited by: §2. [33] A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, C. Zheng, D. Liu, F. Zhou, F. Huang, F. Hu, H. Ge, H. Wei, H. Lin, J. Tang, J. Yang, J. Tu, J. Zhang, J. Yang, J. Yang, J. Zhou, J. Zhou, J. Lin, K. Dang, K. Bao, K. Yang, L. Yu, L. Deng, M. Li, M. Xue, M. Li, P. Zhang, P. Wang, Q. Zhu, R. Men, R. Gao, S. Liu, S. Luo, T. Li, T. Tang, W. Yin, X. Ren, X. Wang, X. Zhang, X. Ren, Y. Fan, Y. Su, Y. Zhang, Y. Zhang, Y. Wan, Y. Liu, Z. Wang, Z. Cui, Z. Zhang, Z. Zhou, and Z. Qiu (2025) Qwen3 technical report. External Links: 2505.09388, Link Cited by: §3.2. [34] S. Yang, Y. Ge, Y. Li, Y. Chen, Y. Ge, Y. Shan, and Y. Chen (2024) SEED-story: multimodal long story generation with large language model. arXiv preprint arXiv:2407.08683. Cited by: §2. [35] H. Ye, J. Zhang, S. Liu, X. Han, and W. Yang (2023) IP-adapter: text compatible image prompt adapter for text-to-image diffusion models. arXiv preprint arXiv:2308.06721. Cited by: §2, §3.1, §3.4, Table 1, Table 1. [36] J. Zhang, J. Tang, R. Zhang, T. Lv, and X. Sun (2025) StoryWeaver: a unified world model for knowledge-enhanced story character customization. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 9951–9959. External Links: Document Cited by: §2. [37] C. Zhao, M. Liu, W. Wang, W. Chen, F. Wang, H. Chen, B. Zhang, and C. Shen (2025) MovieDreamer: hierarchical generation for coherent long visual sequences. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §2. [38] Y. Zhou, D. Zhou, M. Cheng, J. Feng, and Q. Hou (2024) StoryDiffusion: consistent self-attention for long-range image and video generation. Advances in Neural Information Processing Systems 37, p. 110315–110340. Cited by: §1, §2, Table 1, Table 3, Table 9. [39] C. Zhuang, A. Huang, Y. Hu, J. Wu, W. Cheng, J. Liao, H. Wang, X. Liao, W. Cai, H. Xu, X. Zhang, X. Zeng, Z. Huang, G. Yu, and C. Zhang (2026) ViStoryBench: comprehensive benchmark suite for story visualization. External Links: 2505.24862, Link Cited by: §2.

Instant research discovery