Workflow

AI Storyboard Generator

You have a script or a brief and you need a visual board — fast, accurate, and ready to animate. Astorie lets you generate storyboard frames in image nodes, lay them out as the cut on one canvas, then chain each frame straight into a video node when you are ready to test motion. Or open a native Sora 2 Pro Storyboard node and build the sequence scene by scene. Concept to animatic, in one surface.

What this feature solves

Every filmmaker knows the two-tool dance. You board in a traditional storyboard tool — clean static frames the client can sign off on. Approval comes in. Then you pivot to a completely different AI video tool and start from scratch, recreating every framing, character, lens, and lighting cue you already locked. That is the trap of separating boarding from production: every storyboard decision gets decided again in the generator, and every revision means doing it twice.

The industry offers two half-solutions. Traditional storyboard tools are great for static boards but have no production path — you re-create everything in a video tool. AI video tools produce great single shots but have no boarding structure — you "storyboard in your head" and hope the result holds together across cuts. What teams actually need is a board that connects to production: the establishing-shot frame should be the literal reference for the animated establishing shot, sharing characters, style, and composition.

The third gap is iteration. Clients will ask for frame three to be tighter, frame five to be a different angle, frame eight to swap the location. Tab-based image generators force you to re-prompt from scratch and lose the look you established. A real storyboard tool needs character locking, style references, and shot-by-shot revision without rebuilding the whole board.

Why Astorie is different

Astorie ships an actual storyboard model, not a "prompt longer" workaround. Open a video node, pick Sora 2 Pro Storyboard, and you get a real storyboard editor: up to 10 scenes per generation, a total-duration budget of 10, 15, or 25 seconds, per-scene prompts and durations edited live in a timeline strip, and duration math that shows what you have left to spend. You decide the cuts; the model produces the scenes as one stitched multi-scene video. Kick off the job, close the tab, come back — the canvas reconnects to the running generation and updates the node when frames land.

The same canvas hosts the rest of the production, so the board is never throwaway work. Generate frames in image nodes — one per shot, laid out left to right like a board — and feed each frame into a video node when you are ready to animate. Reference and character anchors keep the board coherent: pin a character image and a style reference, wire them into every frame node, and the board reads as one project — same person, same lighting language, same world. Image models like Nano Banana 2 and Flux give you frame-level fidelity; chaining them into Seedance 2 or Kling 3 turns the board into an animatic.

Iteration is surgical. Client wants frame three tighter? Re-run only that node — the rest of the board, and the downstream video chain, stay intact. Swap the location reference, and every frame and clip downstream re-renders against the new world without re-prompting. The canvas treats the storyboard as a graph you edit, not a deck you redo.

Common use cases

Pre-vis for ad campaigns and commercials

Generate the full shot list as frames before the shoot day so the client signs off on visuals, not just words.

Concept boards for pitch decks and treatments

Build a polished visual treatment for new business pitches in hours instead of waiting on a freelance illustrator.

Short-film storyboards with character and style locked

Plan a narrative short shot by shot with consistent characters and locations across every frame.

Storyboard-to-animatic pipeline

Generate frames, then animate the strongest as motion tests so the team sees the cut before any expensive production.

Director and DP shot planning

Visualize camera angles, blocking, and lighting for each shot before scouting locations or booking talent.

Music video and editorial visual planning

Map the visual journey of a music video or editorial piece as a board the artist and label can react to.

Recommended model stack

How the workflow works in Astorie

  1. 1

    1. Drop the script or brief onto the canvas

    Use a text node to hold the source material. Break it into a shot list with a text-model pass if you like — the script becomes the prompt source for each frame and keeps the board grounded in the brief.

  2. 2

    2. Pin character and style references

    Add anchor image nodes for the main character and the visual style — color, lighting, world. Wire them into every storyboard frame node so the board reads as one project.

  3. 3

    3. Generate frames shot by shot

    Add an image node per shot, prompt it with the shot intent (establishing, hero, reaction), and pick GPT Image 2, Midjourney, Flux, or Nano Banana 2 based on the look you need. Lay nodes out left to right.

  4. 4

    4. Iterate per frame, not per board

    When the client requests changes, re-run only the affected frame nodes. Reference and style anchors keep the rest of the board untouched.

  5. 5

    5. Animate — per frame, or as a native multi-scene storyboard

    Wire storyboard frames into Seedance 2 or Kling 3 video nodes to test motion shot by shot. Or open a Sora 2 Pro Storyboard node: build the sequence scene by scene with per-scene prompts and durations, pick the 10, 15, or 25-second budget, and generate one stitched multi-scene video that respects your beat structure.

  6. 6

    6. Export the board or the animatic

    Export the board as a stills sequence for client review or push the animatic into Premiere, DaVinci, or Final Cut via NLE export for editorial review.

Example workflow

A production company is pitching a 60-second narrative ad and needs a 12-frame storyboard plus a 3-frame animated sample for the treatment deck. They drop the script into a text node and pin a character reference for the protagonist plus a style reference for the soft-light, warm-tone visual world. Twelve image nodes line up left to right, each prompted with a shot intent — establishing wide, hero close-up, reaction, etc. GPT Image 2 handles the structured shot frames, Midjourney handles the look-development hero frames, Nano Banana 2 keeps the character consistent across all twelve. The three strongest frames chain into Seedance 2 video nodes to produce a motion sample. Board exports as a stills sequence; the animatic exports to Premiere for the deck. Client signs off in two days instead of two weeks.

Tips and common mistakes

Tips

  • Generate the board left to right in shot order. The visual layout becomes the cut — keep it readable.
  • Use one consistent character and style anchor for the entire board. Mixing references mid-board breaks coherence.
  • Pick the right image model per shot: GPT Image 2 for structure, Midjourney for cinematic look, Flux for photoreal.
  • Animate only the 2-3 hero frames for pitch decks — full animatic comes after greenlight, not before.
  • Save the storyboard canvas as a template (a Recipe) once it works for one project. The next pitch inherits the whole chain.

Common mistakes

  • Generating frames in random order and trying to arrange them after. The canvas is the board — lay it out as you generate.
  • Skipping character and style references. Without anchors, the twelve frames will look like twelve unrelated images.
  • Using one image model for every frame. Different models suit different shot intents — mix per frame.
  • Animating every frame in the board for a pitch. Greenlight first, animate later — frame work is cheap, motion work is not.
  • Treating the board as throwaway work. The canvas links board to production — don't rebuild from scratch when motion starts.

Related how-to guides

Related models and tools

Related features

Related docs

Related reading

Comparisons

Frequently asked questions

What is the Sora 2 Pro Storyboard mode and what are the actual limits?

Sora 2 Pro Storyboard is a native model on Astorie. You get up to 10 scenes per generation, with three total-duration tiers — 10, 15, or 25 seconds. Each scene has its own prompt and duration; the editor lives in the video node with a click-to-select scene timeline and hover-to-insert. Edit, reorder, and re-run as many times as you need.

Which image model is best for storyboard frames?

GPT Image 2 leads for shot-intent fidelity — it understands prompts like "low angle hero close-up, warm key light from camera right." Midjourney is unmatched for cinematic look development; Nano Banana 2 is the choice when character continuity matters. Style is per-shot, not per-project: lean stylized models for animated looks and photoreal models for live-action realism inside the same board.

Can I import a script and auto-generate a storyboard?

Yes. Drop the script in a text node, use a text model to break it into a shot list, then either feed those shots into a Sora 2 Pro Storyboard scene timeline or generate per-shot keyframes with your image models. Script-to-board in minutes, board-to-animatic in an afternoon.

How do I keep characters consistent across all the frames?

Pin one strong character reference image as an anchor node and wire it into every storyboard frame — most major image-to-video models on Astorie accept reference inputs. Update the character node once and every connected shot regenerates with the new look. Nano Banana 2 has the strongest reference adherence for identity-critical frames.

Can I export the storyboard for client review?

Yes — export the frames as an ordered stills sequence, or export the animatic as MP4 with timing and voiceover for stakeholders who would rather watch than read. Share the canvas project link for live review with your director, DP, or client. A dedicated PDF storyboard export is on the roadmap; stills, MP4 animatic, and the shareable canvas view are the supported formats today.

Does each storyboard frame become a real shot?

Two answers, both yes. A Sora 2 Pro Storyboard node generates all its scenes as one stitched, production-resolution video — that IS the shot. And any keyframe node can be wired into a video model node — Seedance 2, Kling 3, Veo, Runway Gen4 — so the frame becomes the input for a final-resolution shot.

How is this different from Boords, FrameForge, or Toon Boom Storyboard Pro?

Traditional storyboard tools produce static boards you re-create in a video tool when production starts; Astorie's cells are live nodes that generate and extend into production-resolution shots — the boards ARE the production. Toon Boom remains the right tool for hand-drawn and rigged 2D animation pipelines; Astorie does not replace frame-level drawing craft. For AI-driven boarding-to-production in one place, the canvas is the difference.

How long does a 12-frame storyboard take?

A small team can produce a clean 12-frame board in 2-4 hours including iteration on a couple of frames — compared to days or a week with a freelance artist. For pitches and pre-vis, AI boards are now competitive with hand-drawn work; for projects that need a specific drawing style, they complement rather than replace it.

Build it on the canvas

Open Astorie and wire this workflow up in minutes. Free to start — no card required.