Consistency in long-form AI video: A literature review (2026)

One of the most active research problems in video generation is consistency: keeping a character or a setting the same each time it appears. Current models render a single clip of a few seconds convincingly. A long-form video, however, is assembled from dozens of such clips, each generated separately, and small differences between them accumulate into visible errors. This review examines how researchers have approached the problem, drawing on published research papers and benchmarks up to September 2026.

This review uses a number of technical terms. If any of them are new to you, the glossary below explains each one in plain words.

▸Please click here for a Glossary of technical terms

Adapter: A small add-on attached to a model so that it can accept an extra input, such as a reference image, without the model itself being retrained.

Anchor frame: An image fixed in advance, such as a keyframe or a view of a character, that later shots are generated against so they stay consistent with it.

Attention: The part of a model that decides which other parts of its input to draw on, for example which earlier frames matter for the frame being generated.

Autoregressive generation: Generating each new part of a video from the parts already made, one after another.

Benchmark: A standard set of prompts with an agreed way of scoring the results, so that different methods can be compared fairly.

Context: The amount of earlier video and text a model can look at while it generates. It is limited mainly by memory.

Diffusion model: A model that generates an image or video by starting from random noise and removing it step by step.

Diffusion transformer: A diffusion model built on the transformer, the same building block behind ChatGPT. Most recent video models use this design.

Drift: The gradual change in a character or setting over a long video, as small errors build up from one part to the next.

Elo rating: A rating scale borrowed from chess. A higher score means viewers preferred the result more often in head-to-head comparisons.

Fine-tuning: Training an existing model a little further on new examples, such as a few photos of a character, so it learns them.

Frozen model: A model whose weights are locked, so they do not change while something else, such as an adapter, is trained.

Identity embedding: A list of numbers that captures who a person is, such as face shape and features, which the model reads instead of the photo itself.

Keyframe: A frame generated first at an important moment, with the frames in between filled in afterwards.

KV cache: The store of earlier frames that a model keeps in working memory so it does not have to recompute them.

Latent space: A compressed version of an image or video that a model works on internally, rather than full-size pixels.

LoRA (Low-Rank Adaptation): A cheap way to fine-tune a model by adding a small set of extra weights and training only those.

Markov chain: A sequence in which each step depends only on the step just before it and on nothing earlier.

Memory bank: A store of frames from earlier shots that a model draws on when generating later ones.

Motion module: An add-on, trained on real video, that gives an image model the ability to move things smoothly between frames.

Recurrent network: A network that passes a hidden summary from one step to the next. The LSTM is a long-established type.

Reference image: A picture of a character or setting given to the model at generation time so that it can match it.

State-space model: A network that keeps a compact running summary and updates it at a cost that grows only in step with the length of the video.

Test-time training: Letting part of a model keep learning while it generates, so its memory adapts to the video being made.

Training-free method: A method that uses a model exactly as it was trained and changes only the way it generates.

Weights: The millions or billions of numbers a model learned during training. Changing them changes what the model knows.

World model: A video model that responds to actions, such as moving a camera, and generates what would be seen next.

Why is consistency the central problem in long-form AI video?

Video generation has advanced quickly at the level of the single clip. Diffusion models now produce several seconds of footage in which faces hold steady and motion looks plausible. However, that quality becomes harder to maintain as a video gets longer. A 2025 survey that compared 32 research papers on video generation found that the most advanced systems of the time produced clips of only 5 to 16 seconds, and that beyond 16 seconds they struggled to keep character appearance and scene layout consistent (Elmoghany et al., 2025).

This limitation stems from the way long videos are assembled. A ten-minute explainer contains dozens of shots, and in most pipelines each shot is generated independently, conditioned only on its own prompt. Nothing in that process ensures that the protagonist of the twelfth shot is the person introduced in the third. Whatever variation the model introduces, whether in a face or in the arrangement of a room, carries into the finished video.

Researchers have tried four main ways to help a model remember what a character or setting looks like from one shot to the next (Figure 1):

• Model weights: The model is trained on a specific character before any video is generated.
• Reference image: An image of the character or setting is supplied to the model at generation time.
• Written plan: A plan defines the characters and settings before any shot is rendered.
• Memory of earlier frames: The model carries what it has already generated forward as it continues.

In this review, we take each approach and then examine how consistency is measured and which problems remain open. We focus on how characters and settings stay consistent across the shots of a story. We cover interactive world models, which maintain the spatial layout of an environment a user explores, as a short section, whereas audio, lip synchronization and single-shot visual quality are outside the scope of this review.

What does consistency mean in AI video?

Researchers working on long video use the word consistency for several different properties, and a model that performs well on one can fail on another. A video can be free of flicker and still change its main character between shots, or keep the character intact and lose track of the story. Comparing methods fairly therefore requires separating the types of consistency they target. We distinguish five types, ordered from the shortest time span to the longest. Click or tap each card to see its definition and an example.

Within a single clip, current models handle temporal consistency well. The other four types span multiple shots, and they are what the approaches in the following sections try to preserve.

A curated repository of research on memory in video world models offers a useful way to group them (Qian, 2026). It asks whether a model needs to remember what is in the video or where things are:

• What: Identity, appearance and narrative consistency depend on remembering the characters in the video and the events of the story. Story video relies mostly on this kind of memory.
• Where: Scene consistency depends on remembering how a space is laid out. Interactive world models, covered in a later section, rely mostly on this kind of memory.

How do video diffusion models generate a clip?

The video diffusion model underlies nearly every method in this review. Understanding how that system works explains both what current models do well and why they lose consistency over longer videos. Readers new to the subject will find a fuller introduction in our article on what AI animation is and how it works.

A diffusion model is built on two processes that run in opposite directions. The forward process takes a real image and adds a small amount of random noise at each of many steps, until nothing of the image remains. The reverse process removes that noise step by step, and learning it is the model’s task (Ho et al., 2020). Both processes are Markov chains, a term for a sequence in which each step depends only on the step just before it and on nothing earlier (Figure 2). To generate an image, the model starts from pure noise and runs the reverse process, guided by a text prompt. Most current models run these processes in a compressed latent space instead of on raw pixels, which makes generation fast enough to be practical (Rombach et al., 2022).

Extending this process from images to video requires the model to keep frames coherent over time as well as within each frame. AnimateDiff (Guo et al., 2023) showed that a separate add-on, which the authors call a motion module, can be trained once on real video and then plugged into many existing image models. The image model decides how each frame looks, and the motion module decides how things move between frames. Stable Video Diffusion (Blattmann et al., 2023) found that video models train best in stages, moving from text-to-image pretraining to video pretraining and then to fine-tuning on high-quality video, and that a well-curated pretraining dataset is necessary. For a full technical account of the field, see the survey by Xing et al. (2024).

Two properties of this design explain why consistency breaks down across clips. First, the model builds every clip from fresh noise, guided only by what it receives at that moment, such as the prompt and any images supplied as conditions. Anything it does not receive, including how a character looked in an earlier clip, it has to invent again. Second, the connections between frames that keep motion smooth operate only among the frames generated together, so they never reach a clip made earlier. So the fixes covered in the next sections take one of two routes: they give the model more to work from each time it generates a clip, such as a reference image of the character, or they let it carry forward what it has already made.

How do AI video models keep a character consistent?

Keeping a character looking the same is the most studied of the five types of consistency. Most of this work started with still images and later moved to video. Researchers have found three main ways to do it: training the character into the model, showing the model a reference image, and letting shots borrow from one another.

The earliest approach teaches the model the character before any video is made, either by adjusting the model itself or by adding something small to it. A model’s weights are the millions or billions of numbers it learned during training. Five methods shaped this approach:

The drawback of all five is that every new character needs a training run before any video can be made. The methods in the next subsection remove that step. PhotoMaker, one of them, kept faces closer to the original than fine-tuned models in its authors’ tests, and it worked much faster (Li et al., 2023).

The second approach skips the training step. Instead, the model is shown a picture of the character each time it generates, through a small add-on called an adapter. The original model stays frozen, meaning its weights are locked and never change, and the adapter teaches it to accept an image as part of its prompt. The research has moved through three stages:

The value of a reference is clearest when it is taken away. In a multistage pipeline for AI video stories, character consistency fell from 7.99 to 0.55 out of 10 when the reference image was removed (Jain et al., 2025).

A third group of methods needs neither training nor a separate reference image. The model generates several images or shots together and lets them share internal features, so that each acts as a reference for the others. ConsiStory needs no training at all. It lets a batch of images share attention, so each image can draw on the subject as it appears in the others, and it copies matching features between them. In its authors’ tests it kept the subject more consistent and followed the prompt more closely than earlier methods (Tewel et al., 2024). StoryDiffusion uses a similar form of shared attention and adds a module that predicts the motion between images. Its authors found this produced much steadier long videos than predicting the motion directly (Zhou et al., 2024).

Identity and motion pull against each other

Video Storyboarding brought shared features to multi-shot video and, in doing so, exposed a tension that runs through this whole area (Atzmon et al., 2024). The method shares one set of internal features, called queries, between shots, and the authors found that these features shape not just the layout of a scene but also, to a large degree, who the character is. The same features that make a character recognizable therefore also shape how the character is posed and how it moves. Sharing them more strongly keeps identity stable but pushes the shots toward the same motion, whereas sharing them less frees the motion at the cost of identity.

The next section turns to systems that work at a higher level, planning what each shot should contain before any of it is rendered.

How do AI systems plan a story across many shots?

The methods in the previous section hold a character steady, but they leave open the larger question of what each shot should contain. A story has to decide which characters appear in which scene, where they stand and what has changed since the last time the viewer saw them. A second group of researchers treats this as a planning problem: decide what each shot shows first, then render it. They have found three main ways to do it: writing a plan with a language model, fixing the key moments as images first, and keeping a memory of earlier shots.

The first planning systems hand the structure of a video to a large language model. VideoDirectorGPT (Lin et al., 2024) asks GPT-4 to expand a single prompt into a video plan that lists the scenes, the layout of the entities in each scene, the backgrounds and which entities must look the same from scene to scene. A separate model called Layout2Vid then renders the plan, and the authors report better control of layout and movement along with consistent multi-scene video. VideoStudio (Long et al., 2024) follows the same order of work. A language model turns the prompt into a multi-scene script, each recurring entity receives a reference image, and the video model generates every scene conditioned on those shared references.

Later systems split the planning across several roles. Vlogger (Zhuang et al., 2024) uses a language model as a director that coordinates a script writer, an actor designer, a video generator and a voice, and it produces vlogs longer than five minutes. StoryAgent (Hu et al., 2024) divides the work among agents for story design, storyboarding, video generation and evaluation. MovieDreamer (Zhao et al., 2024) takes a different route, using an autoregressive model to predict a compact set of visual tokens for every scene from a multimodal script, after which a diffusion model renders the frames.

A plan written in words still leaves the model to invent what each character looks like. A second group of methods therefore fixes images before it fixes motion. NUWA-XL (Yin et al., 2023) generates keyframes across the full length of a video with a global diffusion model, then fills the gaps between them with local models that run in parallel. Because the model was trained on videos of 3,376 frames, it avoids the usual gap between training on short clips and generating long ones, and the authors report a 94.26 percent cut in inference time for 1,024 frames.

Gloria (Yang et al., 2026), presented at CVPR 2026, extends anchoring to characters seen from many angles. The method prepares anchor frames for scenes, character views and expressions, and it places each anchor in its own positional range so that the model can tell several references apart. The authors report character videos longer than ten minutes with consistent appearance across views. EchoShot (Wang et al., 2025b) builds the notion of a shot into the model itself, with position embeddings that mark which shot each frame belongs to, and trains on a dataset of multi-shot portrait video. ShotDirector (Wu et al., 2025a) adds control over the camera, combining camera parameters with shot-aware masks so that the transition from one shot to the next can be planned like a film edit.

Anchors decided in advance cannot cover everything that happens during a story, so the most recent work keeps a memory of what has already been generated. StoryMem (Zhang et al., 2025a) stores a compact bank of keyframes from earlier shots and attaches them to the input of each new shot, which requires only a lightweight fine-tune of an existing video model. The authors also introduce ST-Bench, a benchmark of multi-shot story scripts. VideoMemory (Zhou et al., 2026) organizes its memory around entities, with separate banks for characters, props and backgrounds that a language model updates and retrieves from as the story moves on, and evaluates the approach on a benchmark of 54 multi-shot cases.

OneStory (An et al., 2025) generates a story one shot at a time, selecting the most relevant earlier frames as a global memory and compressing them according to their importance before they condition the next shot. LogiShot (Guo et al., 2026) encodes the earlier context video together with a visual memory, with the aim of keeping the logic of a story intact from shot to shot, and contributes a dataset of 110,000 samples for that purpose. The same idea also appears outside story generation, where Memory-V2V (Lee et al., 2026) keeps a memory of earlier edits so that several rounds of video editing stay consistent with one another and MemFlow (Ji et al., 2025) retrieves memory for each new chunk of a streaming video at a cost of 7.9 percent in speed compared with the same model without memory.

The planning pipeline in four steps

Taken together, these systems describe a common pipeline, even though no single paper implements every part of it.

The common thread across this research is the separation of what a video shows from how each shot is rendered. Planning leaves the limits of the underlying video model in place, since every shot is still a short generation, while giving each of those generations the information it needs about the story so far. The next section turns to the opposite strategy, research that tries to make a single generation long enough to need less planning in the first place.

How do AI models generate longer continuous video?

The systems in the previous section keep every shot short and connect the shots with a plan. A different line of research tries to make a single continuous generation run for longer. Its central difficulty is error accumulation. Each new stretch of video is built from the stretch before it, so small mistakes add up, and over time a face, a color or the layout of a room slowly drifts away from where it started. Researchers have tried four main ways to push past this limit: stretching an existing model without retraining it, generating the video piece by piece, compressing the past so that more of it fits in memory, and keeping a running summary of what has happened.

A training-free method uses a video model exactly as it was trained and changes only the way it generates, so no new training is needed.

• FreeNoise (Qiu et al., 2023): Rearranges the random noise a video starts from, so that distant parts of a long video share a common pattern. It adds about 17% to generation time, against 255% for the best earlier method.
• Gen-L-Video (Wang et al., 2023): Generates overlapping short clips together, each guided by its own text prompt, and blends them into videos hundreds of frames long.
• FIFO-Diffusion (Kim et al., 2024): Keeps a queue of frames at increasing levels of noise. At each step a finished frame leaves the front of the queue and fresh noise joins the back, so the video can in principle continue indefinitely while memory use stays constant.
• Ouroboros-Diffusion (Chen et al., 2025a): Builds on FIFO-Diffusion by adding attention that follows the subject from frame to frame and by letting the clearer frames at the front of the queue guide the noisier ones at the back. In its authors’ tests it kept subjects more consistent and motion smoother than earlier training-free methods.

Because these methods teach the model nothing new, they inherit its view of the world, which only ever covered a few seconds. They make a video longer, but the model still has no lasting record of what a character looked like a minute earlier.

An autoregressive model generates each new part of a video from the parts it has already made, much as a writer adds one sentence after another. This is the setting where drift is most visible.

• StreamingT2V (Henschel et al., 2024): Extends a video chunk by chunk, with one memory module that links each chunk to the one before it and another that keeps the scene from forgetting how it began.
• FramePack (Zhang and Agrawala, 2025): Compresses older frames more heavily than recent ones, so the model always reads a fixed amount of context however long the video becomes. It also uses a sampling order designed to stop drift. The authors report that models with 13 billion weights can generate thousands of frames on consumer hardware.
• Pack and Force Your Memory (Wu et al., 2025b): Pairs a memory guided by text and images with a training technique called Direct Forcing, which narrows the gap between how the model is trained and how it is used. In its authors’ tests it improved consistency over long videos and reduced the spread of errors.

Some researchers doubt that drift can be removed entirely. The authors of VRAG argue that compounding error is a built-in property of autoregressive video, so the realistic goal is to reduce it rather than eliminate it (Chen et al., 2025b).

A model can only look back at a limited amount of earlier video while it generates. This limit is its context, and it is set mainly by memory. Compression methods shrink earlier frames so that more of the past fits inside it.

• LoViC (Jiang et al., 2025): Compresses earlier video and text into a smaller summary at ratios that adapt to the content, which lowers memory use and running time when a long video is generated segment by segment.
• TinyHistory (Zhang et al., 2025b): Trains a compressor that keeps the fine detail of individual frames wherever they sit in the history. Its authors report consistency comparable to heavier approaches, with lower training cost and a longer history.
• FAST-AR (Samuel et al., 2026): A training-free method that shrinks the KV cache, the store of earlier frames a model keeps in working memory, by matching content that stays the same from frame to frame, and that skips attention calculations that add little. The authors report speedups of five to ten times with nearly identical quality and peak memory that stays close to constant.

Instead of rereading earlier frames, some models keep a running summary that they update as the video grows, in the way a reader remembers the plot of a novel without rereading earlier chapters.

• VideoSSM (Yu et al., 2025): Combines a window of recent frames with a state-space model, a type of network that holds a compact summary and updates it at a cost that grows only in step with the length of the video. Its authors report the best temporal consistency among autoregressive generators at the scale of minutes.
• RAD (Chen et al., 2025c): Adds recurrent networks, which pass a hidden summary from one step to the next, into a diffusion transformer. The authors compared several kinds and found that the LSTM, a long-established recurrent design, worked best in tests set in maze and Minecraft environments.
• One-Minute Video Generation with Test-Time Training (Dalal et al., 2025): Adds layers whose memory is itself a small network that keeps learning while the video is generated. Built on an existing model, it produced one-minute Tom and Jerry cartoons from multi-scene storyboards. In human ratings of 100 videos per method, it led the alternatives by 34 Elo points, a rating scale borrowed from chess in which a higher score means viewers preferred the result more often.

All four routes address the same problem from different directions. Their results are measured in seconds or minutes, and consistency is judged over those short spans. That is part of why the planning approach in the previous section remains the more practical choice for story video.

How do world models remember a space?

A world model is a video model that responds to actions, such as moving a camera or steering a character in a game, and generates what would be seen next. Such a model must remember where things are, so that a room looks the same when the viewer walks back into it. This research sits slightly outside the scope of this review, because story video mostly needs to remember who is on screen and what has happened, while world models need to remember the layout of a space. The two problems overlap whenever a story returns to a location it has shown before.

World models store spatial memory in three main ways. Some keep earlier frames and retrieve the ones whose view overlaps the current camera position. Others build a 3D representation of the scene and render from it. A third group compresses the history into a fixed budget so that memory does not grow with the length of the exploration.

How is consistency in AI video measured?

A benchmark is a standard set of prompts with an agreed way of scoring the results, so that different methods can be compared fairly. Consistency benchmarks fall into three layers (Qian, 2026): perceptual benchmarks check whether a clip looks smooth and stable, entity benchmarks check whether the same character or object stays the same across shots, and narrative and state benchmarks check whether the video keeps track of what has happened in the story. A fourth, smaller group tests physical plausibility and the spatial memory of world models.

Generation is random, so the same prompt can produce a good result one time and a poor one the next. A fair comparison therefore samples each prompt more than once. Video-Bench, for example, generates every prompt three times to reduce the effect of chance (Han et al., 2025).

These benchmarks produce the most telling results. After comparing 20 multi-shot methods, the authors of MSVBench concluded that current models mostly blend smoothly between what they are shown rather than understanding the world of the story (Shi et al., 2026). Their automated scoring ranked methods in close agreement with human judges, with a rank correlation of 94.4%. TC-Bench found that generators achieved fewer than 20% of the changes over time that its prompts asked for (Feng et al., 2024).

On physics, average compliance stayed below 0.60 in every category of law that T2VPhysBench tests (Guo et al., 2025).

What are the open problems in long-form AI video consistency?

The research reviewed here leaves six problems open.

• No benchmark covers videos of ten minutes or more: Story benchmarks such as ST-Bench test prompts of 8 to 12 shots. A ten-minute explainer can run to dozens of shots, and none of the benchmarks in this review measures consistency at that length.
• Identity and motion still pull against each other: The features that keep a character recognizable also shape how it moves, so stronger identity tends to produce stiffer, more similar motion (Atzmon et al., 2024). No method in this review removes the trade-off.
• Story state lags behind identity: Methods hold a face steady far better than they hold a story together. The MSVBench and TC-Bench results show models losing track of what has changed and failing to show the changes a prompt describes.
• Training data for long video is scarce: Few large datasets are built for long, multi-shot video. Two exceptions are LongTake-HD, with 261,000 videos captioned section by section (Yan et al., 2024), and OpenS2V-5M, with five million subject, text and video examples (Yuan et al., 2025).
• Drift in step by step generation may never fully disappear: Autoregressive models accumulate small errors as they extend a video, and at least one research group argues that the error can be reduced but not eliminated (Chen et al., 2025b).
• Evaluation leans on automated scores: Most benchmarks score videos automatically, and only some of them report how closely those scores agree with human viewers.

What does the research mean for making long-form AI video today?

The research points to a practical pattern for anyone making a long video with AI today. Plan the story before generating anything. Define each character and setting once, with a reference image, and reuse that reference in every shot. Generate the video shot by shot, and check each shot for drift before moving on, regenerating any shot that breaks consistency. This is the planning pipeline from the section on story planning, and it works because it keeps every generation short while giving each one the information it needs about the story.

Some production tools now follow this pattern. Scenema, which publishes this review, writes a treatment and a shot plan from a prompt or script, stores characters, objects and locations as entities with reference images that every shot can draw on, and lets the maker regenerate any single shot without redoing the video. Our guide on how to keep character consistency in AI video explains the practical side in more detail.

References

Papers are listed under the section where they are first cited, with their current titles on arXiv.

Introduction and key takeaways

• Elmoghany, Rossi, Yoon et al. (2025). A Survey on Long-Video Storytelling Generation: Architectures, Consistency, and Cinematic Quality. arXiv:2507.07202
• Jain, Sharma, Garg et al. (2025). Lights, Camera, Consistency: A Multistage Pipeline for Character-Stable AI Video Stories. arXiv:2512.16954
• Atzmon, Gal, Tewel et al. (2024). Motion by Queries: Identity-Motion Trade-offs in Text-to-Video Generation. arXiv:2412.07750
• Lin, Zala, Cho et al. (2024). VideoDirectorGPT: Consistent Multi-scene Video Generation via LLM-Guided Planning. arXiv:2309.15091
• Yang, Zhang, Pi et al. (2026). Gloria: Consistent Character Video Generation via Content Anchors. arXiv:2603.29931
• Zhang, Jiang, Wang et al. (2025a). StoryMem: Multi-shot Long Video Storytelling with Memory. arXiv:2512.19539
• Shi, Li, Deng et al. (2026). MSVBench: Towards Human-Level Evaluation of Multi-Shot Video Generation. arXiv:2602.23969

What does consistency mean in AI video

• Huang, He, Yu et al. (2023). VBench: Comprehensive Benchmark Suite for Video Generative Models. arXiv:2311.17982

How do video diffusion models generate a clip

• Ho, Jain and Abbeel (2020). Denoising Diffusion Probabilistic Models. arXiv:2006.11239
• Rombach, Blattmann, Lorenz et al. (2022). High-Resolution Image Synthesis with Latent Diffusion Models. arXiv:2112.10752
• Guo, Yang, Rao et al. (2023). AnimateDiff: Animate Your Personalized Text-to-Image Diffusion Models without Specific Tuning. arXiv:2307.04725
• Blattmann, Dockhorn, Kulal et al. (2023). Stable Video Diffusion: Scaling Latent Video Diffusion Models to Large Datasets. arXiv:2311.15127
• Xing, Feng, Chen et al. (2023). A Survey on Video Diffusion Models. arXiv:2310.10647

How do AI video models keep a character consistent

• Ruiz, Li, Jampani et al. (2022). DreamBooth: Fine Tuning Text-to-Image Diffusion Models for Subject-Driven Generation. arXiv:2208.12242
• Gal, Alaluf, Atzmon et al. (2022). An Image is Worth One Word: Personalizing Text-to-Image Generation using Textual Inversion. arXiv:2208.01618
• Hu, Shen, Wallis et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685
• Avrahami, Hertz, Vinker et al. (2023). The Chosen One: Consistent Characters in Text-to-Image Diffusion Models. arXiv:2311.10093
• Ma, Zhou, Yeh et al. (2024). Magic-Me: Identity-Specific Video Customized Diffusion. arXiv:2402.09368
• Li, Cao, Wang et al. (2023). PhotoMaker: Customizing Realistic Human Photos via Stacked ID Embedding. arXiv:2312.04461
• Ye, Zhang, Liu et al. (2023). IP-Adapter: Text Compatible Image Prompt Adapter for Text-to-Image Diffusion Models. arXiv:2308.06721
• Wang, Bai, Wang et al. (2024). InstantID: Zero-shot Identity-Preserving Generation in Seconds. arXiv:2401.07519
• Jiang, Wu, Yang et al. (2023). VideoBooth: Diffusion-based Video Generation with Image Prompts. arXiv:2312.00777
• He, Liu, Qian et al. (2024). ID-Animator: Zero-Shot Identity-Preserving Human Video Generation. arXiv:2404.15275
• Hu, Gao, Zhang et al. (2023). Animate Anyone: Consistent and Controllable Image-to-Video Synthesis for Character Animation. arXiv:2311.17117
• Yuan, Huang, He et al. (2024). Identity-Preserving Text-to-Video Generation by Frequency Decomposition. arXiv:2411.17440
• Zhong, Yang, Teng et al. (2025). Concat-ID: Towards Universal Identity-Preserving Video Synthesis. arXiv:2503.14151
• Wang, Li, Hu et al. (2025a). Collaborative Face Experts Fusion in Video Generation: Boosting Identity Consistency Across Large Face Poses. arXiv:2508.09476
• Wu, Mishra, Dey et al. (2026). ConsID-Gen: View-Consistent and Identity-Preserving Image-to-Video Generation. arXiv:2602.10113
• Tewel, Kaduri, Gal et al. (2024). Training-Free Consistent Text-to-Image Generation. arXiv:2402.03286
• Zhou, Zhou, Cheng et al. (2024). StoryDiffusion: Consistent Self-Attention for Long-Range Image and Video Generation. arXiv:2405.01434

How do AI systems plan a story across many shots

• Long, Qiu, Yao et al. (2024). VideoStudio: Generating Consistent-Content and Multi-Scene Videos. arXiv:2401.01256
• Zhuang, Li, Chen et al. (2024). Vlogger: Make Your Dream A Vlog. arXiv:2401.09414
• Hu, Jiang, Chen et al. (2024). StoryAgent: Customized Storytelling Video Generation via Multi-Agent Collaboration. arXiv:2411.04925
• Zhao, Liu, Wang et al. (2024). MovieDreamer: Hierarchical Generation for Coherent Long Visual Sequence. arXiv:2407.16655
• Yin, Wu, Yang et al. (2023). NUWA-XL: Diffusion over Diffusion for eXtremely Long Video Generation. arXiv:2303.12346
• Wang, Sheng, Cai et al. (2025b). EchoShot: Multi-Shot Portrait Video Generation. arXiv:2506.15838
• Wu, Chen, Wang et al. (2025a). ShotDirector: Directorially Controllable Multi-Shot Video Generation with Cinematographic Transitions. arXiv:2512.10286
• Zhou, Du, Xu et al. (2026). VideoMemory: Toward Consistent Video Generation via Memory Integration. arXiv:2601.03655
• An, Jia, Qiu et al. (2025). OneStory: Coherent Multi-Shot Video Generation with Adaptive Memory. arXiv:2512.07802
• Guo, Yang, Zhang et al. (2026). LogiShot: Logically Coherent Cross-Shot Video Generation. arXiv:2608.08820
• Lee, Huang, Chen et al. (2026). Memory-V2V: Memory-Augmented Video-to-Video Diffusion for Consistent Multi-Turn Editing. arXiv:2601.16296
• Ji, Chen, Yang et al. (2025). MemFlow: Flowing Adaptive Memory for Consistent and Efficient Long Video Narratives. arXiv:2512.14699

How do AI models generate longer continuous video

• Qiu, Xia, Zhang et al. (2023). FreeNoise: Tuning-Free Longer Video Diffusion via Noise Rescheduling. arXiv:2310.15169
• Wang, Chen, Song et al. (2023). Gen-L-Video: Multi-Text to Long Video Generation via Temporal Co-Denoising. arXiv:2305.18264
• Kim, Kang, Choi et al. (2024). FIFO-Diffusion: Generating Infinite Videos from Text without Training. arXiv:2405.11473
• Chen, Long, An et al. (2025a). Ouroboros-Diffusion: Exploring Consistent Content Generation in Tuning-free Long Video Diffusion. arXiv:2501.09019
• Henschel, Khachatryan, Poghosyan et al. (2024). StreamingT2V: Consistent, Dynamic, and Extendable Long Video Generation from Text. arXiv:2403.14773
• Zhang, Cai, Li et al. (2025). Frame Context Packing and Drift Prevention in Next-Frame-Prediction Video Diffusion Models. arXiv:2504.12626
• Wu, Zhang, Xu et al. (2025b). Pack and Force Your Memory: Long-form and Consistent Video Generation. arXiv:2510.01784
• Chen, Hu, Ding et al. (2025b). VRAG: Learning World Models for Interactive Video Generation. arXiv:2505.21996
• Jiang, Li, Ren et al. (2025). LoViC: Efficient Long Video Generation with Context Compression. arXiv:2507.12952
• Zhang, Cai, Li et al. (2025b). TinyHistory: Lightweight Video History Embeddings via Two-Stage Context Learning. arXiv:2512.23851
• Samuel, Tzachor, Levy et al. (2026). Fast Autoregressive Video Diffusion and World Models with Temporal Cache Compression and Sparse Attention. arXiv:2602.01801
• Yu, Wu, Hu et al. (2025). VideoSSM: Autoregressive Long Video Generation with Hybrid State-Space Memory. arXiv:2512.04519
• Chen, Ding, Li et al. (2025c). Recurrent Autoregressive Diffusion: Global Memory Meets Local Attention. arXiv:2511.12940
• Dalal, Koceja, Hussein et al. (2025). One-Minute Video Generation with Test-Time Training. arXiv:2504.05298

How do world models remember a space

• Xiao, Lan, Zhou et al. (2025). WorldMem: Long-term Consistent World Simulation with Memory. arXiv:2504.12369
• Yu, Bai, Qin et al. (2025). Context as Memory: Scene-Consistent Interactive Long Video Generation with Memory Retrieval. arXiv:2506.03141
• Li, Torr, Vedaldi et al. (2025). VMem: Consistent Interactive Video Scene Generation with Surfel-Indexed View Memory. arXiv:2506.18903
• Zhao, Wei, Liu et al. (2025). Spatia: Video Generation with Updatable Spatial Memory. arXiv:2512.15716
• Huang, Zheng, Wang et al. (2025). Voyager: Long-Range and World-Consistent Video Diffusion for Explorable 3D Scene Generation. arXiv:2506.04225
• Wang, Lin, Yoon et al. (2026). AnchorWeave: World-Consistent Video Generation with Retrieved Local Spatial Memories. arXiv:2602.14941
• Wu, He, Cheng et al. (2026). Infinite-World: Scaling Interactive World Models to 1000-Frame Horizons via Pose-Free Hierarchical Memory. arXiv:2602.02393
• Oshima, Iwasawa, Suzuki et al. (2025). WorldPack: Dynamic Frame Compression for Long-context Video World Modeling. arXiv:2512.02473
• Hong, Mei, Ge et al. (2025). RELIC: Interactive Video World Model with Long-Horizon Memory. arXiv:2512.04040
• Sun, Zhang, Wang et al. (2025). WorldPlay: Towards Long-Term Geometric Consistency for Real-Time Interactive World Modeling. arXiv:2512.14614
• Po, Nitzan, Zhang et al. (2025). Long-Context State-Space Video World Models. arXiv:2505.20171

How is consistency in AI video measured

• Zheng, Huang, Liu et al. (2025). VBench-2.0: Advancing Video Generation Benchmark Suite for Intrinsic Faithfulness. arXiv:2503.21755
• Liu, Cun, Liu et al. (2023). EvalCrafter: Benchmarking and Evaluating Large Video Generation Models. arXiv:2310.11440
• Han, Li, Chen et al. (2025). Video-Bench: Human-Aligned Video Generation Benchmark. arXiv:2504.04907
• Yuan, He, Deng et al. (2025). OpenS2V-Nexus: A Detailed Benchmark and Million-Scale Dataset for Subject-to-Video Generation. arXiv:2505.20292
• Zhuang, Huang, Hu et al. (2025). ViStoryBench: Comprehensive Benchmark Suite for Story Visualization. arXiv:2505.24862
• Tang, Wang, Wang et al. (2025). SeqBench: Benchmarking Sequential Narrative Generation in Text-to-Video Models. arXiv:2510.13042
• Feng, Li, Saxon et al. (2024). TC-Bench: Benchmarking Temporal Compositionality in Text-to-Video and Image-to-Video Generation. arXiv:2406.08656
• Bugliarello, Moraldo, Villegas et al. (2023). StoryBench: A Multifaceted Benchmark for Continuous Story Visualization. arXiv:2308.11606
• Guo, Huo, Shi et al. (2025). T2VPhysBench: A First-Principles Benchmark for Physical Consistency in Text-to-Video Generation. arXiv:2505.00337
• Ye, Lu, Jiang et al. (2026). MIND: Benchmarking Memory Consistency and Action Control in World Models. arXiv:2602.08025
• Lian, Cai, Liang et al. (2025). LoopNav: Benchmarking Spatial Consistency in World Models. arXiv:2505.22976
• Qian, S. (2026). Awesome World Models with Memory. GitHub repository. github.com/SiriYep/Awesome-World-Models-with-Memory

What are the open problems in long-form AI video consistency

• Yan, Cai, Wang et al. (2024). Long Video Diffusion Generation with Segmented Cross-Attention and Content-Rich Video Data Curation. arXiv:2412.01316