Systems that draw a story as a sequence of panels with recurring characters now usually work in two stages. A language model first writes a plan: for every panel, a box marking where each named character should appear. A diffusion model, a generator that turns random noise into an image by gradually removing the noise, then paints each panel. To stop characters from blending into one another, it restricts each character's visual features to that character's box. The restriction is what keeps characters distinct, and it is also the weak point. The painter treats the plan as ground truth. If the plan puts Alice's label on the box where Bob stands, omits a character the caption mentions, or makes a character shrink to half size between consecutive panels, the painter faithfully renders the mistake. The result is a swapped identity, a missing person, or a warped body, and nothing later in the pipeline can recover from it. Information extraction has seen this failure for years: an upstream tagger misses an entity and every downstream reasoner is cut off from it.
We propose to treat the plan as a symbolic object that can be checked, and to close the loop in both directions. Before painting, a small constraint solver checks the whole storyboard jointly and makes the smallest edit that restores consistency. After painting, a character re-identification model reports which character actually appears in each region. A second, abductive step then asks which explanation is cheapest: did the plan cause the error, or did the painter? Abduction here means inferring the most plausible cause from what was observed. Only the faulty component is then repaired, either by editing the plan or by re-rendering the affected panel. The core contributions are two. The first is a controlled measurement of how layout errors cascade into identity errors. The second is fault attribution across the planner-to-renderer boundary, which no current story pipeline attempts.
Core Claim
Identity failures in layout-conditioned story generation come from two sources. One is planning errors, which the painter cannot fix. The other is rendering errors, which a better plan cannot fix. A symbolic layer that reasons jointly over the plan and the re-identified output can tell these apart, and repairing only the blamed component beats both of the obvious alternatives: unconditional verification of the plan alone, and best-of-N re-rendering of the output alone. We expect the advantage to grow with the number of panels and characters, because the relevant constraints span the whole story. Such constraints include persistence of who is present, continuity of scale between panels, consistency of front-to-back order with box overlap, and uniqueness of each character's box. Local rejection-and-resample then becomes increasingly unlikely to find a valid plan.
Relation to Prior Work
The closest work is ObjectAlign. It scores adjacent edited video frames with image metrics, uses a solver for Satisfiability Modulo Theories (SMT), a logic engine that checks whether constraints over numbers can all hold, to keep object embeddings within tolerances, and repairs flagged frames by discarding them and interpolating with optical flow. It motivates our proposal by showing that symbolic checks catch real drift; the solver accounted for 16.6% of its inconsistency flags. Our design differs in three ways. ObjectAlign verifies pixels after generation, whereas we verify the intermediate plan. ObjectAlign discards and interpolates, which fails when drift is sustained, as MovieBench's 41.3% PrecisionID suggests it often is. We instead re-render with a corrected cause. Finally, ObjectAlign covers single-object edits and never asks whether an upstream plan caused the error.
The pipelines we build on are Storybooth and DreamingComics. Storybooth pairs a language-model layout planner with attention that is masked so each character attends only to its own boxes across frames. DreamingComics pairs a fine-tuned Qwen2.5-VL layout model with positional embeddings re-indexed to target boxes. These systems supply the painter we reuse, and they also reveal the gap: per the file, both depend on the planner with no check and no return channel. Storybooth further shows that unbounded cross-image sharing, as in Group Diffusion Transformers and Style Aligned, causes characters to leak into each other. Bounded attention is therefore worth keeping, which is exactly why its dependence on the plan has to be addressed.
The repair machinery comes from neuro-symbolic work in text and reinforcement learning. ASPER runs a declarative solver over noisy neural extractions to remove impossible ones before retraining, which raised relation F1 on CoNLL04 from 41.76% to 52.47% at 10% labels. Abductive State Grounding reconciles a neural recognizer's symbol probabilities with a knowledge base by abduction. OPERA ranks competing hypotheses over multimodal extractions, including face re-identification. We borrow abductive reconciliation from the second and confidence-weighted hypothesis ranking from the third. Our use is new in that the "observations" are re-identified regions of a generated image, and the hypotheses being ranked are blame assignments across a generation pipeline.
Two results constrain the design. First, ASPER's gains shrank on SciERC because rules were hard to write. We therefore keep the rule vocabulary small and generic to the domain, covering geometry, presence, uniqueness, ordering, and continuity, rather than encoding story semantics. Second, CoType and query-graph ranking show that joint or generate-and-rank formulations can beat repair, so a joint layout-and-render ranker is an alternative we test rather than dismiss.
Research Program
The plan is represented as facts of the form "character $c$ occupies box $b$ in panel $p$ at depth rank $d$", together with caption mentions. The constraints are hard rules: every mentioned character has exactly one box, boxes lie inside the canvas, and front-to-back order agrees with overlap. They are joined by soft rules: scale changes between consecutive panels stay within bounds tied to the shot type, and boxes keep plausible aspect ratios. Pre-render repair solves a weighted MaxSAT/MaxSMT problem, that is, it finds the plan that satisfies all hard rules while violating as few weighted soft rules as possible. It minimizes
$$\sum_{f \in \Delta} w_f + \lambda \sum_{r} \text{viol}_r,$$
where $\Delta$ is the set of plan facts changed relative to the planner's output, $w_f$ is the planner's confidence in fact $f$ (so confident facts are expensive to change), and $\text{viol}_r$ is the violation of soft rule $r$, weighted by $\lambda$.
After rendering, a detector plus a re-identification model matched to each character's reference crops assigns observed labels and confidences to regions. Mismatches with the plan become observations. Abduction then chooses the cheapest set of retracted assumptions under the same weighted objective. One kind of assumption is a plan fact, such as "Alice is in box 2". The other kind is a painter-faithfulness assumption, such as "box 2 was rendered as its assigned character". A retracted plan fact triggers a plan edit and a re-render of the affected panels. A retracted faithfulness assumption triggers a re-render of only that panel, with a new seed and a tighter attention bound.
The first deliverable is a cascade measurement study. We take natural plans, inject controlled errors of five types: swapped labels, omitted characters, scale jumps, colliding boxes, and inconsistent depth. We then measure how identity consistency and anatomy failure degrade with error type and magnitude. The second deliverable is the closed-loop system and its comparison against simpler alternatives at matched compute.
Baselines
The naive reference is the unmodified Storybooth pipeline: its own planner, its own bounded-attention painter, one render, and no checking. This is also the strongest published system on the benchmark we use. Storybooth reports a consistency score of 0.811 (DreamSim) and a VQAScore of 0.706 on its multi-subject storyboard benchmark, against 0.754 and 0.598 for StoryDiffusion. We will re-run it on identical prompts and seeds rather than rely on the reported number. Beating it means a statistically significant gain in identity-swap rate and DreamSim consistency with VQAScore no worse, at a stated time budget. Storybooth runs at about 8.7 s per sequence, so we report overhead against that figure.
Where DreamingComics' layout model can be run, it serves as a stronger-planner baseline. The file gives only relative gains for it (+29.2% character consistency over DreamO and UNO), with no absolute score on our benchmark. Its inclusion tests whether a better-trained planner removes the need for repair.
Best-of-N re-rendering generates N renders of the original plan and keeps the one with the highest re-identification agreement, with N chosen so wall-clock time matches our loop. Rule-filter-and-resample applies the identical constraint set as plain code checks and re-queries the planner until the plan passes or the budget runs out. This is the ablation that isolates minimal-edit joint repair. A plan-only ablation runs pre-render repair without the post-render abductive step, isolating fault attribution. A soft-mask ablation loosens bounded attention so the painter can disregard box boundaries, testing whether tolerance in the painter alone absorbs plan errors.
Why not just…?
Why not just ask a strong language model to think step by step and produce better boxes? DreamingComics reports that GPT-4 layouts were judged less plausible than those of a task-specialized layout model. Even a specialized planner gives no guarantee across the whole story, which is why we include the DreamingComics planner as a baseline rather than assume it fails. If its plans rarely violate our constraints, the pre-render repair adds little. The cascade study will show this directly by counting natural violations per planner.
Why not just check the rules in code and resample until a plan passes? This is the most serious threat. For short single-panel stories it may match a solver exactly. The case for minimal-edit solving is that cross-panel constraints couple panels, so the chance that an independent resample passes should fall roughly multiplicatively with story length. The resample also discards the planner's correct facts. We will plot pass rate and final consistency against the number of panels for both methods. If resampling keeps up at 8 or more panels, we will report that the solver is unnecessary and keep only the attribution step.
Why not just render several times and pick the most consistent output? Best-of-N fixes rendering errors but cannot fix planning errors. If the plan swaps two labels, every seed reproduces the swap. The injected-error experiments separate the two error sources. We expect best-of-N to recover painter faults but not plan faults, and our loop to recover both at matched compute.
Why not just let the painter ignore bad boxes with softer masks? Storybooth shows that unbounded sharing causes characters to leak into each other, so softening the masks trades one failure for another. The soft-mask ablation measures that trade-off directly, with leakage and swap rate reported side by side.
Proposed Experiments
We use the Storybooth multi-subject storyboard benchmark for paired characters. We also use stories built from MovieBench character banks and scene structure to reach 4 to 16 panels with 2 to 4 characters. Character-consistency prompts from LoCoT2V-Bench, where reported identity consistency is 30 to 55%, provide a held-out stress set. Metrics are DreamSim consistency and VQAScore, as in Storybooth; identity-swap rate from Hungarian matching of re-identified crops to reference characters; omission rate; human-judged anatomy failures; and wall-clock time.
The decisive checks come in sequence. First, the cascade study must show that injected label swaps and omissions sharply raise swap and omission rates under bounded attention. If the painter is robust to them, the premise fails. Second, natural planner outputs must contain violations often enough to matter; we report the rate per planner. Third, fault attribution is scored on injected errors, where ground truth is known, against a vision-language judge asked to blame either the plan or the render. Fourth, end-to-end comparisons against all baselines are run at matched compute as story length grows. Here the gap between our system and rule-filter-and-resample determines whether the symbolic solver earns its place, and the gap against the plan-only ablation determines whether attribution does.
References
- ObjectAlign: Neuro-Symbolic Object Consistency Verification and Correction
- MovieBench: A Hierarchical Movie Level Dataset for Long Video Generation
- Storybooth: Training-Free Multi-Subject Consistency for Improved Visual Storytelling
- DreamingComics: A Story Visualization Pipeline via Subject and Layout Customized Generation using Video Models
- Group Diffusion Transformers are Unsupervised Multitask Learners
- Style Aligned Image Generation via Shared Attention
- ASPER: Answer Set Programming Enhanced Neural Network Models for Joint Entity-Relation Extraction
- Abductive State Grounding For Neuro-Symbolic Reinforcement Learning
- OPERA: Operations-oriented Probabilistic Extraction, Reasoning, and Analysis
- CoType: Joint Extraction of Typed Entities and Relations with Knowledge Bases
- Learning to Rank Query Graphs for Complex Question Answering over Knowledge Graphs