💻 computer science

LogiStory: A Logic-Aware Framework for Multi-Image Story Visualization

This paper introduces LogiStory, a multi-agent framework that explicitly models visual logic to generate coherent multi-image stories, accompanied by the LogicTale benchmark and evaluation protocols to address the persistent challenges of narrative disconnection in current multimodal systems.

Original authors: Chutian Meng, Fan Ma, Chi Zhang, Jiaxu Miao, Yi Yang, Yueting Zhuang

Published 2026-03-31

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Chutian Meng, Fan Ma, Chi Zhang, Jiaxu Miao, Yi Yang, Yueting Zhuang

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

Imagine you are trying to tell a story to a friend using only a series of drawings, like a comic book. You want the story to make sense: if a character drops a glass in the first picture, it should be broken in the second. If a character is wearing a red hat, they shouldn't suddenly be wearing a blue one in the next frame without explanation.

For a long time, computers have been great at drawing individual pictures that look beautiful. But when you ask them to draw a whole sequence of pictures to tell a story, they often get confused. The characters might change faces, objects might disappear, or the plot might jump around illogically. It's like watching a movie where the actors swap costumes between scenes, or the plot skips from "making coffee" to "fighting a dragon" with no explanation.

This paper introduces a new system called LogiStory to fix this problem. Here is how it works, explained simply:

The Problem: The "Amnesiac Artist"

Current AI artists are like incredibly talented painters who have short-term memory loss. They can paint a beautiful scene of a crow drinking water from a bottle. But if you ask them to paint the next scene where the crow drops a pebble in, the AI might forget the bottle exists, or make the crow look like a different bird entirely. They focus on making one picture look good, but they don't understand the story connecting the pictures.

The Solution: LogiStory (The "Director's Team")

The authors realized that to tell a good story, you don't just need a painter; you need a whole film crew. They built a system that acts like a multi-agent production team, where different "AI workers" have specific jobs before a single pixel is drawn.

Think of it like this:

The Scriptwriter (SceneCrafter & LogicMiner):
Before drawing anything, this agent reads the story and breaks it down. It creates a "character bible" (so everyone knows the crow has black feathers and a yellow beak) and a "causal map."
- Analogy: Imagine a director saying, "Okay, in Scene 1, the crow is thirsty. In Scene 2, it finds pebbles. In Scene 3, the water rises because of the pebbles." It writes down exactly how one thing leads to the next.
The Storyboard Artist (ShotPlanner):
This agent takes the script and plans out exactly what each picture should look like. It decides the camera angle, the lighting, and where the characters stand.
- Analogy: This is like the storyboard artist in a movie studio who draws rough sketches to make sure the action flows smoothly from one frame to the next.
The Fact-Checkers (The "Logic Police"):
This is the most important new part. As the AI draws each picture, two "inspectors" check the work immediately.
- The Local Monitor: This is like a reader turning the page of a comic book. It looks at the current picture and asks, "Does this make sense compared to the picture I just saw?" If the crow was flying in the last picture, it shouldn't be sleeping in the water in this one unless something happened.
- The Global Verifier: This is like the showrunner looking at the whole season. It checks the "Causal Map" created by the scriptwriter. It asks, "Did the water actually rise because of the pebbles? Did we forget a step?"

If the picture fails the check, the system doesn't just move on. It sends the picture back to the "editor" to fix the mistake (like changing the water level or fixing the character's hat) before moving to the next scene.

The New Test: LogicTale

To prove their system works, the authors couldn't just use old tests, because those tests only checked if the pictures looked pretty. They built a new test called LogicTale.

Analogy: Imagine a driving test. Old tests only checked if the car looked shiny and the engine sounded good. The new test (LogicTale) checks if the driver actually knows how to stop at a red light, yield to pedestrians, and follow the map.
They created 60 stories (like "The Three Little Pigs" or "The Crow and the Pitcher") and annotated them with specific logic rules (e.g., "If the wolf blows the house, the house must fall"). This allows them to grade the AI on how well it followed the plot, not just how pretty the images were.

The Results

When they tested LogiStory against other top AI models:

Other AIs often produced beautiful images that told a confusing story (e.g., the pigs were wearing the wolf's clothes, or the brick house was made of straw).
LogiStory produced sequences where the story actually made sense. The characters stayed consistent, the cause-and-effect relationships were clear, and the viewer could easily follow the narrative without getting lost.

Why This Matters

This paper is a big step forward because it teaches AI to care about logic, not just beauty. It's the difference between a random collection of pretty photos and a coherent movie. By giving AI a "brain" that understands cause-and-effect, we can eventually get computers to help us write better books, make better movies, and even simulate complex real-world scenarios where things need to happen in the right order.

In short: LogiStory is the first AI that doesn't just draw pictures; it actually understands the story it's telling.

1. Problem Definition

The paper addresses the critical challenge in multi-image story visualization: generating a sequence of images that not only possesses high visual fidelity but also maintains logical coherence and narrative causality.

Current Limitations: Existing multimodal models (including diffusion models and LLM-driven agents) often produce disjointed sequences where characters change appearance, actions lack causal links, or the storyline becomes fragmented. They treat image generation as isolated events rather than a continuous, causally connected narrative.
The Gap: While visual quality and entity consistency have improved, there is a lack of attention to Visual Logic, defined as the perceptual and causal coherence among characters, actions, and scenes over time. Current benchmarks and evaluation metrics focus on single-image quality or surface-level consistency, failing to assess whether the sequence tells a logically sound story.

2. Methodology: The LogiStory Framework

The authors propose LogiStory, a framework that explicitly models visual logic through a structured, multi-stage pipeline. The system transforms narrative text into a logically consistent image sequence using two core components:

A. Logic-Aware Multi-Agent System

This system decomposes the input story into structured intermediate representations before generation begins. It consists of three collaborative agents:

SceneCrafter: An entity and context definition agent. It extracts and defines semantic entities (characters, objects, scenes) with detailed visual attributes (appearance, clothing, texture) to ensure a consistent "visual grounding vocabulary" across all panels.
LogicMiner: A key event extraction agent. It identifies causally relevant or state-changing moments in the story, representing them as tuples: (actor, action, target, result). This captures both explicit narrative cues and implicit state transitions (e.g., inferring that water rises when pebbles are dropped).
ShotPlanner: A shot-level planning agent. It organizes events into a sequence of panel specifications, incorporating visual storytelling conventions (pacing, framing, camera angles) to ensure the sequence is visually engaging and narratively rhythmic.

B. Visual Logic Enhancement Module

This module bridges the gap between semantic planning and visual realization by verifying and refining generated images in real-time. It employs a dual-level verification strategy:

Local Causal Monitor: Simulates a human reader's linear comprehension. It maintains a memory buffer of previous states and actions ( $M_{t-1}$ ) and evaluates the current image ( $I_t$ ) for narrative plausibility. It assigns a causal plausibility score ( $\psi_t$ ). If the score is low, the image is flagged for regeneration; if moderate, it triggers refinement.
Global Causal Verifier: Constructs a directed Causal Graph ( $G_{causal}$ ) based on the extracted key events. It tracks the state of all instances (characters, objects) throughout the story. For each generated image, it verifies if the visualized state transitions match the expected causal links in the graph. Inconsistencies are flagged and sent to image editing tools (e.g., inpainting models) for targeted correction.

Refinement Logic: The system uses thresholds ( $\tau_1, \tau_2$ ) on the logic confidence score to decide actions:

$\psi < \tau_1$ : Regenerate the image.
$\tau_1 \le \psi < \tau_2$ : Invoke the Global Verifier and edit the image.
$\psi \ge \tau_2$ : Accept the image.

3. Key Contributions

Definition of Visual Logic: The paper formally introduces "Visual Logic" as a critical dimension of generative modeling, distinguishing it from mere visual consistency. It emphasizes the need for causal soundness and semantic plausibility in visual sequences.
LogiStory Framework: A novel architecture that reframes story visualization as a logic-aware reasoning problem. It integrates structured multi-agent planning with a dual-level (local/global) causal verification system to enforce narrative coherence.
LogicTale Benchmark: The authors constructed a new benchmark dataset containing 60 meticulously annotated stories (mix of classics and originals).
- Annotations: Includes causal chains, action-state flows, and difficulty levels.
- Evaluation: Introduces new metrics specifically for Instance Consistency, Narrative Causality, and Story Readability, moving beyond standard image quality metrics like FID or CLIPScore.

4. Experimental Results

The authors evaluated LogiStory against state-of-the-art baselines, including closed-source models (GPT-4o, Gemini 2.0, Nano Banana) and open-source methods (StoryDiffusion, MM-StoryAgent, Flux).

Automatic Evaluation: LogiStory achieved the highest scores in Narrative Causality (4.45), Story Readability (0.8267), and Character Expressiveness (4.32). It significantly outperformed baselines in maintaining logical flow, though it slightly trailed GPT-4o in Instance Consistency (due to GPT-4o's strong image editing capabilities).
Human Evaluation: A user study with 30 participants confirmed the automatic results. LogiStory was preferred for its logical clarity and narrative coherence. There was a strong Pearson correlation (0.959–0.978) between human ratings and the automatic logic metrics.
Ablation Studies:
- Replacing the multi-agent planner with a direct LLM prompt resulted in lower logic scores, proving the value of structured decomposition.
- Removing the Global Causal Verifier significantly dropped Narrative Causality scores, highlighting its role in enforcing long-range consistency.
- Removing the Local Causal Monitor reduced Story Readability, confirming its importance in step-by-step coherence.
Complex Cases: The framework demonstrated robustness in handling complex narratives involving flashbacks and subtle emotional shifts, where baselines often failed to maintain character identity or plot continuity.

5. Significance and Impact

Foundational Step: This work provides a foundational approach to modeling and enforcing visual logic in general image sequence and video generation tasks, moving the field from "generating pretty pictures" to "generating coherent stories."
Bridging Planning and Generation: By explicitly separating structured planning (logic) from visual synthesis, LogiStory offers a blueprint for integrating symbolic reasoning with neural generation.
New Evaluation Standard: The introduction of LogicTale and its associated metrics sets a new standard for evaluating story visualization, shifting the focus from pixel-level fidelity to narrative interpretability and causal reasoning.
Broader Applicability: The principles of visual logic modeling are applicable to video generation, interactive narrative systems, and robotics, where logical consistency across time is paramount.

In summary, LogiStory demonstrates that explicitly modeling visual logic through multi-agent planning and causal verification significantly enhances the quality and interpretability of AI-generated visual stories, addressing a major bottleneck in current multimodal generation systems.