Skip to content
Resources / Video generation

Plan the shot.Build the world.Then generate.

A scene-first method for making AI video with an agent. The agent plans the work, builds a controllable reference scene, checks it, and only then asks a generation model for pixels.

Reviewed November 7, 2026. Tools, prices, model quality, and licensing change. Check the linked source before a client job.

Use fewer tools, with clear jobs.

The current recommendation is Claude Opus 5.5 as the primary builder for this workflow, subject to change. The model is the worker. The source files, scene system, review gates, and saved evidence are what make the work repeatable.

Scene systemDefault

Blender

Block the set, camera, people, props, light, and motion before an AI model paints over anything. Use real scale and saved source files so a fix changes the scene, not just one frame.

Motion layerChoose one

HyperFrames or Remotion

Use one deterministic compositor for typography, captions, timing, and assembly. HyperFrames is a good HTML/CSS path. Remotion is the React path. Choose one for a project.

Generation layerProvider

Sunra

Use a provider workspace for short AI shots, tests, and alternate takes after the scene and reference frames pass. Check current access, pricing, export limits, and commercial rights before a client job.

Conditional engineWhen needed

Unity or Unreal

Use one when the project already depends on its assets, real-time output, or engine-specific sequencing. They are useful options, not defaults to install for every video.

Voice and languageAudio

ElevenLabs

Use it for voice, overdub, and dubbing after the picture timing is stable. Keep the approved script and speaker permissions beside the audio output.

Proof layerRequired

FFmpeg and ffprobe

Inspect the file that actually came out: duration, frame rate, dimensions, audio streams, frame count, and decode errors. A successful render command is not a finished-video check.

Give the agent a small set of files it can keep true.

These names are a useful convention, not a new bureaucracy. For a small project, combine them into one project brief. Keep the fields. The point is that the plan, scene, and review speak the same language.

SPEC.md

The promise, audience, length, format, audio needs, and pass bar.

STORYBOARD.md

Stable shot IDs, framing, action, camera move, timing, and narration.

DESIGN.md

The visual bible: people, props, palette, light, type, and continuity rules.

ROADMAP.md

The short path from board to animatic, approved shots, assembly, and export.

NOW.md

The current shot, selected take, next action, and open defects for a resumable run.

shots.json

Machine-readable timing, assets, versions, take IDs, and review findings.

ledger.jsonl

Every external asset and generation: source revision, model, job ID, hashes, terms, and outcome.

Smallest useful project shape

video-project/
├── SPEC.md
├── STORYBOARD.md
├── DESIGN.md
├── ROADMAP.md
├── NOW.md
├── shots.json
├── ledger.jsonl      # generations, assets, hashes, terms, and outcomes
├── scenes/          # editable Blender / Unity / Unreal source
├── assets/          # references with source and license notes
├── renders/         # guides, takes, and final exports
└── reviews/         # timestamped findings and pass records

The agent earns the right to generate.

Do not ask the model to solve story, staging, physics, camera, continuity, and final polish in one prompt. Separate the jobs so each pass has something concrete to check.

  1. Write the brief and the pass bar

    State who the video is for, what it must make clear, how long it is, where it will play, what must be on screen, and what would make it fail. The agent cannot check a goal that was never written down.

    SPEC.md is complete and every must-have has a check.
  2. Board the shots before building

    Give every shot a stable ID. Record the camera, action, timing, narration, transition, reference image, and the thing the viewer must notice. Make a rough animatic when timing matters.

    STORYBOARD.md and shots.json agree on shot IDs and timing.
  3. Build one controllable scene

    Start with one representative shot in Blender, Unity, or Unreal. Keep the source editable. Check scale, contact, camera, light, materials, and the path of every hand, foot, prop, and cable that the camera can see.

    The scene can be rebuilt from source and the guide render is reproducible.
  4. Review the guide and loop

    Render a fast guide, contact sheet, and close-ups. A reviewer checks the guide against the storyboard and returns timestamped findings. The builder edits the source, saves a new version, and renders again until the shot passes or reaches its bounded review limit.

    Every finding is pass, fixed, or clearly marked not checked.
  5. Generate the AI overlay or take

    Only now send reference frames, motion, style, and shot instructions to the generation provider. Keep the prompt, model, settings, seed or job ID, selected take, and rejected takes in the ledger.

    The generated take can be traced back to one approved shot and source version.
  6. Assemble, sound, and review the final file

    Composite the selected takes, narration, music, effects, captions, and end card. Then review the exported file frame by frame and at normal speed. The final file is the evidence, not the editor timeline.

    The file passes visual, motion, continuity, audio, caption, and technical checks.

Render a guide. Find the break. Fix the source.

Use a different review pass from the builder when you can. Give the reviewer the video, the storyboard, the spec, and a review pack. Findings should name the shot, time, rule, evidence, and fix. Keep the old render so the change can be seen.

Build sourcescene or comp
Render guidesheet + close-ups
Reviewtimestamped findings
Pass?revise or continue

Story

  • The shot shows the promised action.
  • The order and timing match the board.
  • Nothing appears before the story brings it in.

Motion and physics

  • Feet and hands contact what they touch.
  • Held things stay held; hung things hang.
  • No body, prop, rope, door, or shadow passes through another object.

Camera and continuity

  • The camera move has a reason and a clean landing.
  • The same people, set, light, clothes, and props match between shots.
  • The viewer can read the action at the intended size.

Sound and text

  • Every line is heard and appears when it should.
  • Music and effects support the action instead of covering it.
  • Captions, labels, and end cards are inside safe areas and spell correctly.

Stop condition: every must-pass check is green, or the unresolved item is explicitly marked NOT CHECKED and sent to a person for a decision. “The render command exited 0” is not a stop condition.

Installed skills and the gaps to close.

This is a live local catalog check from Studio0. It is not a claim that every machine, account, or provider is ready. Read the skill source before using it and verify the target machine.

Found in the local skill catalog

  • blender-agent-scenesBuild, inspect, animate, check, and render Blender shots headlessly.
  • human-body-motionCheck joints, balance, floor contact, and human movement.
  • hand-motionInspect hands, grips, and close-up motion where a wide shot hides defects.
  • finished-video-reviewCreate frame, hand, foot, continuity, sound, and guide-to-finished review packs.
  • HyperFrames and RemotionRender deterministic motion graphics and programmatic compositions.
  • video-storytelling and make-a-videoPlan the story, beats, and visual language before the render.
  • SunraUse the connected provider layer for media generation when production work calls for it.

Astra recommendation: add or verify

  • A small storyboard contractNot currently found as one installed skill. Add a reusable template that validates shot IDs, timing, reference assets, narration, and the must-pass line for every shot.
  • A scene physics and contact gateNot currently found as one general skill. Start with Blender contact checks and add a heavier simulator only for work that truly needs cloth, fluids, rigid bodies, or robotics-level interaction.
  • Unity Timeline and Unreal Sequencer skillsNot currently found in the local skill catalog. Add them only when a project already depends on that engine, its assets, or its real-time output.
  • One saved job ledger and controllerNot currently found as a video-specific harness. Track stage, source revision, artifact hash, tool version, provider job ID, selected take, findings, and pass/fail/not-checked state in one place.

One controller. Saved evidence. Bounded retries.

Start with a proven project when it fits. Build a small Utlyze harness around the parts that are missing. It is scaffolding, not a reliability promise. Keep the source beside every result. Use a stateful framework such as LangGraph only when pause and resume are worth the added machinery; a small controller is enough for a short production.

Controller contractKeep it boring

Every stage writes a record.

planbrief + shot manifest
buildeditable scene source
previewguide render + sheets
reviewfindings.json
revisenew source revision
generateprovider job + take
qapass / fail / not checked
LedgerTraceable

Save the facts that make a rerun possible.

  • Source revision and artifact hashes
  • Tool, model, provider, and version
  • Prompt, settings, seed, and job ID
  • Selected take and rejected takes
  • Review findings and the final decision
Safety valveHuman review

Do not hide uncertainty.

Name one approver in the brief. Set a retry limit, keep failed outputs, and stop to re-plan if the same defect survives two bounded passes. Ask for a decision with the evidence attached.

Start from the strongest pieces we found.

Star counts and release dates move. The links are the source of truth. Review licenses and provider terms before using code or assets for paid work.

Reference harness

OpenMontage

The strongest ready-made reference found in this review: an agentic production system with pipelines, tools, skills, schemas, review guidance, and a Remotion composer. Read its AGPL license before copying code into a commercial project.

Generation backend

ComfyUI and Wan2.2

A repeatable node and workflow layer for generated footage. Use it as a generation backend after the scene plan and review loop exist. It does not supply the whole production process by itself.

Optional harness

LangGraph

An optional stateful controller for pause, resume, conditional routing, and saved checkpoints. Use it when the workflow needs persistence; keep a small script for a short project.

Motion reference

Remotion agent skills

Official agent guidance for projects that use Remotion. The repository is a useful source for project rules and reusable motion patterns, with licensing checked separately for the Remotion runtime.

Alternate

Motion Canvas

A good alternate coded-scene option when a TypeScript animation project needs interactive preview and FFmpeg export. It still needs the planning, review, and acceptance layer described here.

Do not generate what you could have checked first.

Build the scene. Check the scene. Then use AI where it adds speed, texture, voice, or reach. Keep the plan and the evidence so the next video starts from a better system.

Back to the preflight checklist