StoryBlender: Inter-Shot Consistent and Editable 3D Storyboard with Spatial-temporal Dynamics

Conference: ECCV2026
Paper: ECCV page
Code: https://engineeringai-lab.github.io/StoryBlender
Area: 3D Vision
Keywords: 3D storyboard, multi-agent planning, inter-shot consistency, scene generation, editability

TL;DR

StoryBlender recasts "script to storyboard" from per-frame pixel sampling into hierarchical multi-agent planning inside a 3D engine: a four-layer continuity memory graph decouples global assets from shot-local variables, canonical assets are materialized as meshes in a unified coordinate space, and a reflection loop driven by engine physics checks plus VLM critiques solves layout, camera, and lighting — yielding both inter-shot consistency (CIDS Self 0.917 / Cross 0.803, OCCM 78.16) and non-destructive editability on CineBoard3D.

Background & Motivation

Storyboarding is the core artifact of pre-production in film, animation, and games: it externalizes the script into an explicit shot-by-shot plan that fixes characters, actions, blocking, and camera intent, so that teams align and risk is retired before shooting starts. Automating it imposes two hard requirements — consistency and editability. Consistency means that character identity, visual style, and 3D scene state (layout, props, lighting) stay stable across shots, and it largely decides whether a storyboard is usable for actual pre-visualization. Editability means those elements are explicitly controllable and revisable (adjusting blocking, say) without redoing the whole sequence, and it decides whether the system is pleasant to work with.

Existing automated storyboard solutions fall into two camps that trade these requirements off against each other. The first is 2D diffusion-based generation (StoryDiffusion, Story2Board, AniMaker, Qwen-Edit and others): individual frames are vivid, but identity drift from shot to shot is hard to suppress and usually requires reference inputs for anchoring; more importantly, a pixel/latent representation has no explicit handles for geometry or camera, so changing a viewpoint or a scene state means re-sampling the whole image and destroying details that were already right. The second is the traditional 3D workflow: an explicit scene representation gives it consistency and editability for free, but it demands manual modeling, rigging, blocking, and lighting from skilled artists — a complex, labor-intensive pipeline that does not scale.

The natural response is to let LLM agents translate scripts into structured 3D actions (asset selection, placement, camera design), automating the most labor-heavy steps while retaining controllability — the line taken by SceneCraft, WorldCraft, SceneWeaver, and Story3D-Agent. But an LLM alone cannot carry the whole pipeline: it lacks a persistent, grounded world model bridging semantic narrative planning and precise geometric execution, so it proposes layouts that conflict with physical constraints (spatial hallucinations) and has no internal verification mechanism to correct those geometric errors; maintaining narrative coherence additionally requires tracking an evolving world state that far exceeds a standard LLM's context window. As a result, most LLM-driven 3D scene synthesis treats generation as a one-off static arrangement problem, optimizing a single snapshot with no mechanism for maintaining state across shots or reusing scene constraints. The question this paper actually asks is whether general-purpose LLMs truly understand 3D geometry and spatial information, or merely hallucinate semantic plausibility. Core idea: treat the narrative as a persistently running simulation grounded in a 3D engine — carry global state in a hierarchical continuity memory graph, project only task-relevant subgraphs to each downstream agent, and let every artifact iterate inside a closed loop of engine physics validation and VLM critique, turning storyboard generation from stochastic image synthesis into constrained closed-loop optimization that delivers inter-shot consistency and explicit editability at once.

Method

Overall Architecture

The formal objective is compact: learn a mapping \(F: T_{story} \rightarrow V_{3D}\) that synthesizes a spatiotemporally coherent and editable 3D dynamic video sequence \(V_{3D}\) from a raw textual script \(T_{story}\). In implementation it comprises two mechanisms and three progressive stages. The two mechanisms are a Hierarchical Multi-Agent Planning framework (which splits the production pipeline into specialized roles: Director, Concept Artist, Layout Artist, VFX Artist) and the Story-centric Reflection Scheme, which converts a feed-forward generation pass into iterative optimization — agents execute actions inside a 3D engine and verify the results with multi-modal feedback, systematically suppressing spatial randomness. The three stages are: (1) Semantic-Spatial Grounding, where the Director Agent decomposes the script into a structured continuity memory graph so that information reaches downstream agents precisely and reliably; (2) Canonical Asset Materialization, where Concept Artist Agents instantiate the abstract semantic entities of the memory graph into canonical 3D meshes in a unified coordinate space, guaranteeing global asset consistency; and (3) Spatial-Temporal Dynamics, where Layout Artist Agents and VFX Artist Agents resolve the spatial layout and camera motion from memory and enrich the scene into an atmospheric, moving cinematic sequence. "Spatial-temporal dynamics" here names two things: the spatial dimension is the relative position, scale, and occlusion relations among objects (who stands in front of whom, how large a table should be), while the temporal dimension is the narrative evolution driven by camera motion and character actions; together they determine the final output \(V_{3D}\). The whole pipeline runs inside Blender through the Model Context Protocol, and no artifact is allowed into the next stage until it has passed engine validation and VLM review.

Because editing happens on the native 3D scene graph, editability follows for free: script elements are explicitly bound one-to-one to 3D parameters (camera extrinsics for framing, HDRI for lighting, meshes and materials for assets and backdrops), so a natural-language instruction such as "switch to a close-up" or "replace the concrete wall with wood" touches only the corresponding fields and leaves the rest of the geometry untouched; users can also open the 3D project file and add or remove props and adjust cameras directly in the engine, and the result is still one continuous world.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Script T_story"] --> B["Continuity Memory Graph<br/>four-layer world state"]
    B --> R["Story-centric Reflection Scheme<br/>engine checks + VLM critique"]
    R --> C["Canonical Asset Materialization<br/>retrieve → generate → format"]
    C --> D["Layout & Camera Semantic Servoing<br/>scale / pose / framing"]
    D --> E["Atmosphere & Action Orchestration<br/>environment / dressing / lighting / animation"]
    E --> F["3D Storyboard V_3D<br/>editable scene graph"]
    C -.->|"physics check fails, V=0"| R
    D -.->|"below threshold τ_a"| R
    E -.->|"below threshold τ_a"| R

Key Designs

1. Continuity Memory Graph: compiling the script into a four-layer world state that persists across shots

Per-shot independent processing drifts because an LLM's context window cannot hold the evolving state of a whole narrative — where the table was in the previous shot is already gone by the next one. The Director Agent therefore first maps unstructured text into a structured, persistent world state \(a_{dir}: T_{story} \rightarrow \mathcal{G}_{cm}\), the continuity memory graph. It is a hierarchical state with four layers: the Storyboard Outline \(M_{outline}\) for the temporal sequencing of scenes and shots; the Asset Sheet \(M_{asset}\), which registers globally unique entity identifiers (i.e. a registry of 3D assets); the Scene Context \(M_{scene}\), which stores static environmental state such as the layout \(L_{layout}\) and sets \(E_{env}\); and the Shot Context \(M_{shot}\), which localizes each shot's camera parameters and actions. This graph becomes the single source of truth for the entire pipeline, and its design crux is the clean decoupling of global assets from shot-specific variables: once fixed, the former never varies with the shot, while the latter is exactly what each shot solves for — so identity drift and environment drift are ruled out structurally rather than patched afterwards.

Two companion mechanisms complete the stage. Dynamic contextualization, \(\Pi_{task}(\mathcal{G}_{cm})\), extracts only the task-relevant subgraph for each downstream agent instead of exposing the whole global state (for instance, handing the Layout Artist only the currently active bounding boxes from \(M_{scene}\)) while masking unrelated narrative data. Each subagent thus works within a minimally sufficient working memory, which sharply curtails semantic noise and reduces spatial hallucinations. The third layer of protection is physically-aware gatekeeping: \(\mathcal{G}_{cm}\) is not a static repository but a self-evolving representation governed by constraint-based checks, so any proposed output \(o_{new}\) must first pass a validation function \(V(o_{new}, S_{exist}) \rightarrow \{0,1\}\) — a programmatic, engine-verified evaluation against the existing global state \(S_{exist}\) (a new layout, for instance, must be free of bounding-box collisions) — before it may be committed to memory. Updates with \(V=0\) are rejected and routed back into the offending agent's reflection loop. In this way "everything in memory is physically valid" becomes a structural guarantee of cross-shot geometric consistency rather than a post-hoc repair.

2. Story-centric Reflection Scheme: replacing "let the LLM reflect on itself" with engine physics verification

A common failure mode of LLM agents is self-congratulation: asked to inspect its own layout errors, the model tends to answer that nothing looks wrong, because it has no real spatial context to consult. The reflection loop starts by formalizing this step — for any subagent \(a\) operating on a task context \(C \subset \mathcal{G}_{cm}\), the initial state comes from its generation policy, \(o_0 = \Phi_a(C)\); at every subsequent step \(t\) a scoring function \(R(o_t, C)\) evaluates the state and yields diagnostic feedback \(\mathcal{F}_t\), and if the score falls below that task's acceptance threshold \(\tau_a\) the refinement operator \(\Psi_a\) corrects it. Should the criteria still not be met within the maximum reflection horizon \(T_{\max}\), a handover operator \(\Omega\) delegates the context to a designated fallback agent \(a_{fb}\) (reverting from retrieval to generative synthesis, for example), preventing non-convergent loops:

\[o_{t+1} = \begin{cases} o_t, & R(o_t, C) \ge \tau_a \\ \Psi_a(o_t, \mathcal{F}_t, C), & R(o_t, C) < \tau_a \ \text{and}\ t < T_{\max} \\ \Omega(a_{fb}, C), & \text{otherwise} \end{cases}\]

(⚠️ This equation is garbled in the original paper; the form above follows the prose description — refer to the original for exact notation.) What actually makes the loop work is that the feedback \(\mathcal{F}_t\) and the score \(R\) come from two sources matched to the agent's domain: engine constraints, i.e. deterministic 3D engine output such as exact bounding-box collision logs, and aesthetic critique, i.e. VLM semantic-alignment scores scaled to inform \(\tau_a\). The former turns "what is wrong and by how much" into concrete executable numbers; the latter covers "does it look good and match the script." Ablations separate the two cleanly: over the same five reflection turns, physical reflection driven by engine logs drives directional error from 0.377 down to 0.008, whereas the naive variant, where the LLM reflects on its own, only moves from 0.341 to 0.129 before plateauing. The bottleneck in spatial reasoning is therefore not the language model's capacity for introspection but the availability of grounded state feedback.

3. Canonical Asset Materialization: retrieval first, generation as fallback, formatting to normalize

This stage answers how a semantic entity becomes a usable 3D mesh. Calling a 3D generative model directly has two problems: the meshes carry unpredictable topological artifacts, and each asset arrives in its own coordinate frame and scale, which breaks downstream layout outright. Concept Artist Agents therefore follow a cascaded workflow. The Asset Retriever first queries high-quality existing assets using attributes from \(M_{asset}\), and candidates are scored by a VLM reflection function \(R(o_t, M_{asset})\) for spatial quality and stylistic alignment, admitted only above the threshold \(\tau_{ret}\) — standard objects always go through retrieval and never through generation, so hallucinations have no room to appear. If retrieval fails to reach \(\tau_{ret}\) within \(T_{\max}\) attempts, a Handover \(\Omega\) routes the task to the Asset Generator, which synthesizes in two stages: it first generates a VLM-refined 2D reference image conditioned on \(M_{asset}\), then lifts that image into a 3D mesh. Anchoring 3D generation on a strictly verified 2D intermediate localizes geometric errors and lets aesthetic constraints be enforced on that image — the reason it is more controllable than end-to-end text-to-3D. Finally the Asset Formatter handles assets whose forward vectors are arbitrary, which would otherwise cause layout failures: it queries a VLM to identify the semantic canonical front and physical extents, then computes a transformation tuple \((R_{align}, s_{norm})\) — a rotation \(R_{align} \in SO(3)\) for global axis alignment and a uniform scaling \(s_{norm}\) for bounding-box normalization — so that every entity in \(\Omega_{3D}\) shares one mathematical space and later layout operations carry no orientation ambiguity.

4. Layout & Camera Semantic Servoing: translating semantic prepositions into verifiable Euclidean transforms

Layout solving is written as \(a_{layout}: (\Omega_{3D}, M_{scene}, M_{shot}) \rightarrow (L_{layout}, C_{cam})\) and proceeds in three steps. The Dimension Estimator first handles the fact that an isolated asset does not know how large it should be: meshes from retrieval or generation are only normalized in size, whereas relative proportions within the scene are what makes a layout physically plausible (a table must not be taller than a house), so the agent predicts a realistic scaling factor \(s \in \mathbb{R}^3\) from semantic roles. The Spatial Planner then bridges abstract text and precise 3D coordinates by mapping qualitative prepositions ("beside", "behind") into quantitative transformations — a translation \(t \in \mathbb{R}^3\) and rotation \(r \in SO(3)\) — to form the layout \(L_{layout}\), which the engine then verifies programmatically for physical violations such as collisions. The crucial part is feeding the engine's exact error logs back into the reflection loop so the planner iteratively corrects the arrangement instead of guessing what went wrong. The Camera Operator determines the camera state \(C_{cam}\) through VLM-guided Discrete Semantic Visual Servoing: the camera pivot initializes at the target's bounding-box centroid with the orbital distance derived geometrically to guarantee visibility under a given field of view, after which the VLM evaluates rendered frames and issues discrete camera-control commands (Orbit, Pan, and so on), each mapped to a differential spatial update. The benefit is that a continuous search over camera parameters becomes a "look at a frame, take a small step" loop in which every step is renderable and verifiable — far more stable than having an LLM emit camera extrinsics directly.

5. Atmosphere & Action Orchestration: from a geometrically valid scene to an emotional, moving shot

A geometrically correct empty set is not yet a film shot; \(a_{vfx}: (M_{scene}, M_{shot}) \rightarrow (I_{light}, E_{env}, P_{action})\) supplies four things. The Environment Designer builds structural backdrops \(E_{env}\) that give isolated primary assets spatial boundaries and contextual realism — without them, the background falls apart as soon as the camera moves. The Set Dresser then dynamically places supplementary props without violating existing bounding-box constraints, curing the visual sparsity of the first-pass layout. The Lighting Arranger configures environmental lighting \(I_{light}\) from suitable HDRI maps plus discrete light sources, iteratively refining intensity and color through VLM-guided aesthetic reflection so that it matches the mood the script intends (the same room in cool and warm tones tells two different stories). Finally the Animator retrieves suitable motion sequences from an animation database and retargets them onto the characters (\(P_{action}\)), turning static frames into a narrative with temporal evolution — the direct landing point of the "temporal" half. Ablations show this group of roles is not optional: removing them entirely and leaving only a default Nishita sky texture and static rest poses drops PA Scene from 3.176 to 0.561 and PA Action from 2.629 to 1.374, confirming that geometry alone carries neither emotion nor dynamic semantics.

A Worked Example: one multi-shot thread of Casablanca

Take one thread from Casablanca. The script's shot descriptions include Scene #1 Shot #1 "Rick and Ugarte stand at their private table amidst the cafe activity.", Scene #1 Shot #2 "The letters of transit are revealed on the table between them.", Scene #3 Shot #2 "Rick nods, signaling to play the French anthem.", Scene #4 Shot #1 "Ilsa pleads with Rick, who stands by his suitcase ignoring her.", Scene #5 Shot #1 "Rick stands close to Ilsa, explaining why she must leave with Laszlo.", through to Scene #5 Shot #3 "Rick and Renault watch as Ilsa and Laszlo walk toward the plane." The Director Agent first writes this thread into the memory graph: \(M_{outline}\) cuts the scene and shot sequence; \(M_{asset}\) registers globally unique IDs for "Rick Dinner Jacket", "Ugarte", "Sam", "Upright Piano", "Cafe Table", "German Soldier" and the rest; \(M_{scene}\) fixes the world coordinates of the cafe's table, piano, and walls; \(M_{shot}\) records each shot's camera parameters and character actions.

In the asset stage, standard objects such as the "Upright Piano" and "Cafe Table" are retrieved from Poly Haven / Sketchfab and clear \(\tau_{ret}\) immediately; a character asset as specific as "Rick Dinner Jacket" cannot be retrieved, so within \(T_{\max}\) a Handover \(\Omega\) switches it to the fallback path of "generate a 2D reference image, then lift it into a 3D mesh". Both paths are subsequently aligned into one coordinate frame by the Formatter. In the layout stage the Spatial Planner translates "at their private table" into translation and rotation; the engine's first verification reports a bounding-box conflict and returns the log, and physical reflection drives directional error from 0.377 in turn 1 to 0.049 in turn 2 and 0.012 in turn 3. The camera operator pivots on the table's bounding-box centroid, derives the orbital distance from the field of view, and performs discrete servoing. The VFX stage then adds walls and supplementary props, sets HDRI lighting, and retrieves and retargets motion for Sam and Rick.

By the time the thread reaches Scene #5 Shot #3, the world coordinates of the table, piano, and walls have never moved (the sequence's SDE is only 0.28 world units); only cameras and character actions change. This is where inter-shot consistency comes from: not from each frame being "painted" to look similar, but because all of them were shot from one scene that was never disturbed. That property pays off at editing time as well — to add a close-up emphasizing Ugarte's nervous glances, one natural-language instruction suffices (the paper's example adds a 56mm F1.8 camera); the system updates only the camera extrinsics \(C_{cam}\) and leaves every other piece of geometry and lighting untouched, with no frame re-sampled.

Loss & Training

This is a training-free agentic framework with no gradient-based loss or optimization objective; the "optimization" happens entirely as discrete search inside the reflection loop (which asset to choose, where to place it, where the camera moves, accept or redo). Key settings: the reflection horizon is capped at \(T_{\max}=5\) turns with acceptance threshold \(\tau_a = 8\); high-level reasoning uses Gemini 3 Pro while the remaining subagents are driven by Gemini 3 Flash; scene assets are retrieved from Poly Haven and Sketchfab, and when a new asset is needed, Nano Banana performs text-to-image synthesis followed by Hunyuan 3D for image-to-3D generation; the end-to-end pipeline is integrated inside Blender through the Model Context Protocol. ⚠️ "Gemini 3 Pro" and "Nano Banana" are the model names given in the paper, but its cited reference points to the 2023 Gemini technical report — refer to the original paper / official releases for exact versions and naming.

Key Experimental Results

Main Results

The paper also introduces CineBoard3D, curated from eight iconic feature films (The Godfather and Pulp Fiction among them): 51 scenes, 178 shots, 95 characters, and 81 props, averaging 22.25 shots per story, with continuity requirements across diverse environments that make it substantially harder than existing text-to-visual benchmarks. Baselines come in two groups: 2D generation and AI storyboarding tools (AniMaker, Qwen-Edit, Story2Board, StoryDiffusion), and 3D scene generation/reconstruction frameworks (SceneWeaver, plus a cascade of Qwen-Edit image generation followed by CAST reconstruction). Metrics: CIDS measures identity preservation via cosine similarity of character features, with Self for intra-sequence coherence and Cross for reference-anchored fidelity to the initial global asset; CSD measures global aesthetic coherence with a style-trained CLIP encoder, again split into Self and Cross; OCCM computes the numerical match between generated and script-required character counts, penalizing hallucinated or omitted characters; PA uses GPT-4.1 as a judge on a 0-4 scale, split into scene alignment (environment/layout) and action alignment (character interactions); User is the user-study rank (1-7, lower is better).

Method	CIDS Self ↑	CIDS Cross ↑	OCCM Shots ↑	CSD Self ↑	CSD Cross ↑	PA Scene ↑	PA Action ↑	User Rank ↓
AniMaker	0.801	0.613	73.91	0.561	0.309	3.689	3.369	3.46
Qwen-Edit	0.849	0.719	67.94	0.503	0.296	3.736	3.613	2.23
Story2Board	0.842	0.772	49.30	0.513	0.264	3.189	2.281	5.25
StoryDiffusion	0.816	0.758	62.89	0.612	0.343	2.547	1.815	5.80
Qwen-Edit+CAST	0.726	0.631	56.39	0.727	0.262	0.800	1.866	6.58
SceneWeaver	0.872	0.773	55.66	0.758	0.216	2.824	1.933	4.13
StoryBlender	0.917	0.803	78.16	0.772	0.352	3.176	2.629	1.84

StoryBlender leads across CIDS (Self 0.917 / Cross 0.803) and OCCM (78.16), indicating that identity is anchored to persistent 3D meshes rather than to pixel-space attention mechanisms; its CSD Self of 0.772 is also the highest, corresponding to stable global lighting and atmosphere; and its user-study rank of 1.84 clearly beats the runner-up Qwen-Edit at 2.23. In fairness, it is not the best on PA: Qwen-Edit (3.736 / 3.613) and AniMaker (3.689 / 3.369) both score higher. The paper's own explanation is that pixel-based methods bend physical constraints to satisfy the prompt, whereas this work deliberately ranks spatial validity above semantic compliance.

Ablation Study

Continuity memory graph (SDE is the Spatial Drift Error: for each static asset, take the eight world-space bounding-box corners, compute the Euclidean distance between corresponding corners in consecutive shots, and average over all static assets and all \(K-1\) adjacent shot pairs — lower is more stable; ⚠️ the formula is garbled in the original paper, this wording follows the prose description, refer to the original):

Config	CIDS Self ↑	CIDS Cross ↑	SDE ↓
w/o Gcm (pure LLM processing shots independently)	0.547	0.382	4.87
w/o Masset (shared layout, no persistent asset registry)	0.532	0.414	0.95
w/o Llayout (asset registry kept, layout recomputed per shot)	0.908	0.788	4.12
Full Gcm (Ours)	0.917	0.803	0.28

Reflection loop and visual effects agents:

Config	PA Scene ↑	PA Action ↑
w/o Visual Effects Agents (default sky texture + static rest poses)	0.561	1.374
w/o Reflection (t = 0, zero-shot single pass)	2.867	2.540
w/ Reflection (t = 3, partial horizon)	3.114	2.621
Full Pipeline (Ours)	3.176	2.629

Engine physical reflection vs. naive reflection (four spatial error types for the layout agents across reflection turns: D direction, R relationship, O occlusion, C contact):

Method	Error	T1	T2	T3	T4	T5
Naive	D	0.341	0.212	0.188	0.129	0.129
Naive	R	0.224	0.129	0.141	0.094	0.094
Naive	O	0.012	0.000	0.012	0.000	0.012
Naive	C	0.000	0.012	0.000	0.000	0.000
Physical	D	0.377	0.049	0.012	0.008	0.008
Physical	R	0.224	0.110	0.000	0.000	0.000
Physical	O	0.041	0.012	0.000	0.004	0.000
Physical	C	0.008	0.008	0.000	0.000	0.000

Key Findings

• The asset registry is the least dispensable part of the memory graph, while spatial stability leans on the shared layout. Removing \(M_{asset}\) drops CIDS Self to 0.532 (0.385 below the full model), showing that text prompts alone cannot prevent 3D mesh identity drift; removing \(L_{layout}\) from \(M_{scene}\) barely hurts identity (0.908) but pushes SDE from 0.28 to 4.12, as background objects wander between shots. The two are complementary, not redundant: one keeps the person the same person, the other keeps the house where it was.
• Removing the memory graph entirely collapses the system. The w/o Gcm setting (0.547 / 4.87) has by far the largest gap to the full model, directly indicating that multi-shot coherence on natural-language context windows is not achievable by a standard LLM — no amount of prompt engineering fixes it.
• Reflection turns show clear diminishing returns, but engine feedback changes the order of magnitude of convergence. The biggest jump is from t = 0 to t = 3 (PA Scene 2.867 → 3.114); t = 3 to t = 5 adds only 0.062 more. More telling is the source of feedback: physical reflection's directional error in turn 1 (0.377) is actually worse than the naive variant's (0.341), yet it falls to 0.049 in turn 2 and 0.012 in turn 3, while the naive variant moves from 0.341 to 0.129 and then oscillates around 0.094-0.129. The LLM does not lack reasoning capacity; it lacks an actionable signal of what is wrong.
• VFX roles contribute far more to semantic alignment than one might expect. Keeping only the geometric layout with a default sky texture and static poses leaves PA Action at 1.374 (versus 2.629 for the full pipeline) — nearly halved — and drops PA Scene from 3.176 to 0.561. Being geometrically correct and visibly telling the script's story are two different things.
• The Qwen-Edit+CAST cascade exposes a structural flaw in "2D first, reconstruct later." Its CSD Self (0.727) ranks third, meaning the reconstructed scenes are internally stylistically consistent; yet PA Scene is only 0.800, CIDS Self 0.726, and the user rank 6.58 — last place — because each shot is generated independently and then reconstructed on its own, with no shared world state across shots, so inter-shot consistency has no basis at all.
• Edit-propagation fidelity has only qualitative evidence. The paper demonstrates with two cases (Casablanca for camera and wall-material edits, Snow White for lighting, camera addition, and prop removal) that geometry not involved in the edit stays intact under both editing modes, but reports no quantitative metric for post-edit consistency or fidelity — this currently rests on visualizations alone.

Highlights & Insights

• Turning consistency from a generation problem into a representation problem. A scene is modeled once and every shot films the same scene, so inter-shot consistency holds automatically (SDE 0.28). The transferable lesson is direct: for any task that needs consistency across views, clips, or turns (multi-turn avatars, long multi-clip video, reusable game-level assets), first ask whether the shared part can be frozen into an explicit state instead of being re-derived on every sample.
• The key to the reflection loop is not more iterations but an executable error signal. Engine collision logs drive directional error down to 0.049 within two turns, whereas self-reflection stalls around 0.13. This transfers straight to other LLM-agent systems: rather than asking a model to grade itself, attach a deterministic verifier (a compiler, a simulator, a unit test) that turns "which constraint, by how much" into structured feedback.
• Retrieval first, generation as fallback, and generation anchored in 2D. Routing standard objects to retrieval removes hallucinations at the root while only genuinely long-tail assets invoke generation; that path emits a 2D reference image before lifting it to 3D, confining the hardest-to-control geometric error to a local stage. It is a cheap engineering trade-off that is far more stable than "generate everything".
• Discrete semantic visual servoing is a reusable trick. Instead of regressing camera parameters directly, the VLM picks from a predefined set of discrete commands (Orbit, Pan, …), each mapped to a differential update and closed on rendered frames. Converting continuous regression into discrete selection plus visual feedback substantially reduces the variance of a VLM's geometric outputs.
• The CineBoard3D by-product has value in its own right. Eight iconic films, 51 scenes and 178 shots, an average of 22.25 shots per story, and built-in strict continuity requirements (the same cafe must keep the same layout across many shots) make it a better testbed for multi-shot consistency than synthetic benchmarks.

Limitations & Future Work

• Dependence on the coverage and quality of 3D asset libraries. The retrieval path presumes Poly Haven / Sketchfab contains assets that match both semantics and style; stylistically specific or narratively unique props must fall back to generation, whose 3D quality is markedly less controllable. The paper reports neither retrieval hit rate nor separate quality statistics for the two paths.
• Motion is borrowed, not generated. Animations are retrieved from a database and retargeted, so character behavior is bounded by the clips available; compound, script-specific actions such as "Rick pushes the letter across the table while saying this line" are unlikely to be expressible — yet that is precisely the information a storyboard most needs to convey.
• The evaluation is small and film-classic-centric. Eight films and 178 shots, all with mature narrative structure; whether consistency holds for dialogue-sparse action films, effects-heavy science fiction, or feature-length narratives with hundreds of shots is untested. Evaluation is also statistical metrics plus a user study, with no task-level assessment of whether the storyboard is actually usable for downstream production.
• Editability lacks quantitative validation. Post-edit geometric fidelity and whether a local edit truly stays local are shown only through cases; editing also presumes the user can operate Blender or write precise edit instructions, and the barrier for non-experts is not discussed.
• Physical correctness is not narrative correctness. The paper itself concedes it trails pixel methods such as Qwen-Edit on PA, arguing that it trades semantic compliance for physical plausibility. Whether that trade is always worth it depends on the use case: if the goal is a visual reference rather than a directly shootable breakdown, losing semantic alignment may hurt more.
• Directions for improvement: extend the memory graph from space and lighting to finer physical and interaction attributes (the paper's future work mentions fine-grained object interactions and long-horizon narrative dependencies); compose and blend retrieved motion clips instead of a single retarget; add a quantitative metric for edit propagation (geometric difference in untouched regions before and after an edit); and pursue the direction the paper already shows — stylizing rendered output with a video generation model (e.g. Wan 2.7) and adding audio, forming a complete pre-visualization deliverable.

Related Work & Insights

• vs StoryDiffusion / Story2Board (2D consistent storyboarding): they maintain cross-shot consistency in pixel/latent space via self-attention reuse or reference anchoring, and Story2Board's CIDS Cross of 0.772 is in fact close to this paper's 0.803 — 2D methods are not weak at "looking alike". But they have no world state, so background drift in the SDE sense cannot be constrained (Fig. 4 shows backgrounds hallucinated after a camera cut), and they cannot change only the camera without re-sampling the image. This paper's advantage is representational; the price is needing access to 3D assets.
• vs Qwen-Edit (instruction-based editing generation): Qwen-Edit scores higher on PA (3.736 / 3.613 versus 3.176 / 2.629) because it can freely bend physical constraints in pixel space to satisfy the prompt; this paper gives up that freedom for spatial validity. The trade-off is fundamentally a matter of prioritizing semantic compliance versus geometric credibility, not a difference in capability.
• vs SceneWeaver / the CAST cascade (isolated 3D scene generation and reconstruction): SceneWeaver is the strongest 3D baseline (CIDS Self 0.872, Cross 0.773, CSD Self 0.758 close to this paper), showing that single-scene quality is no longer the bottleneck; but its OCCM is only 55.66 (character counts frequently wrong) because it treats each scene as an independent generation problem with no cross-shot asset registry. Qwen-Edit+CAST is more extreme: CSD Self 0.727 ranks third, yet PA Scene is 0.800 and the user rank is last, exposing the structural weakness of per-shot 2D generation followed by post-hoc reconstruction. The difference here is that a scene stops being a one-off artifact and becomes reusable persistent state.
• vs Story3D-Agent (LLM-scripted 3D storytelling): it also uses an LLM to turn scripts into 3D actions, but scripts them as linear sequences in a pre-configured environment, with neither a global context manager across scenes nor an engine-in-the-loop check. The lesson this paper offers is that for geometric tasks, whether an LLM agent can verify matters more than whether it can plan.
• vs CinePreGen / PrevizWhiz (engine plus diffusion pre-visualization): they combine 3D blocking with diffusion generation to gain camera controllability, but each shot is still re-generated in pixels; StoryBlender stays in native 3D and never returns to pixel space, which buys genuinely non-destructive editing at the cost of a ceiling on image fidelity set by the assets and renderer (the paper compensates with an external video stylization model).

Rating

• Novelty: ⭐⭐⭐⭐ Reframing storyboard generation as "persistent 3D world state plus an engine-verified reflection loop" is a genuinely new problem formulation; the components (memory, retrieval-then-generation cascade, VLM critique) are largely existing modules, so the contribution is mainly the systematic orchestration and the concrete realization of engine logs replacing self-reflection.
• Experimental Thoroughness: ⭐⭐⭐ Main results cover six baselines, five metric families plus a user study, and ablations decompose the memory graph, reflection horizon, VFX roles, and physical versus naive reflection, with CineBoard3D contributed on top; but the dataset is only eight films / 178 shots, editability is unquantified, and retrieval hit rate, end-to-end latency, and cost are not reported.
• Writing Quality: ⭐⭐⭐ The narrative is clear and the three-stage split easy to follow, with Figs. 1-2 positioning the work well; points off for the key equations (the reflection update and the SDE definition) being typeset incorrectly in the body text so they must be inferred from context, and for model names (Gemini 3 Pro, Nano Banana) that do not match their citations, which creates ambiguity for reproduction.
• Value: ⭐⭐⭐⭐ It offers a pragmatic paradigm for LLM-agent-based 3D content generation: give consistency to explicit state and correctness to a deterministic verifier. An editable native 3D storyboard is indeed a more production-valuable deliverable than "a nice-looking generated image" in film and game pre-visualization.

Related Papers

• [ECCV 2026] IRIS: Intersection-aware Ray-based Implicit Editable Scenes
• [ECCV 2026] Learning Video Dynamics with Predictive Differentiable Rendering
• [AAAI 2026] 4DSTR: Advancing Generative 4D Gaussians with Spatial-Temporal Rectification for High-Quality and Consistent 4D Generation
• [CVPR 2026] Learning Spatial-Temporal Consistency for 3D Semantic Scene Completion
• [CVPR 2026] OpenVO: Open-World Visual Odometry with Temporal Dynamics Awareness