Inside the PLAN-PRODUCE-CRITIQUE-ASSEMBLE Loop

Plan, produce, critique, assemble: those four stages are how CoreReflex's agentic Director turns a single sentence into a finished, graded cut. It is a loop, not a one-shot prompt: the Director boards the film, generates it, scores every shot against concrete checks, regenerates the misses, and only then stitches the result into a continuous sequence. Understanding the loop is the fastest way to understand why the output is something you can actually ship.

Most AI video tools collapse this into a single step: prompt in, clip out, your problem to fix. The loop exists because production has always been four distinct jobs, directing, shooting, reviewing dailies, and editing, and skipping any one of them is how you end up with a pile of clips instead of a cut. Here is what each stage does and why the order matters.

The four stages at a glance

The loop runs in sequence, and each stage feeds the next:

The economics shape the design. Planning, scoring, and editing are free, only the PRODUCE step, where real generation happens, costs credits. That means the Director can think hard and review hard without running up a bill, and your spend is concentrated on the one stage that creates pixels.

PLAN: boarding the film before a single frame

The loop starts by turning your sentence into a shot list. The Director decides how many shots the idea needs, and for each one it sets a role (establishing, detail, payoff), a camera move, and a specific prompt. This is the storyboard stage, and it is where structure is decided, pacing, coverage, the arc from open to close.

Planning for free is a deliberate choice. Because no credits are spent here, the Director can board, reconsider, and refine the plan as much as the idea requires before any generation happens, you're paying for a thought-through shot list, not a lucky single prompt. If the concept of a system that boards and directs on its own is new to you, what an agentic AI video director is lays out the foundation behind this step.

PRODUCE: generating each shot from the plan

With the board set, the Director shoots. Each planned shot is generated through the owned stack on Google Vertex AI, the right model for the job, with the prompt, camera move, and parameters the plan specified. This is the only stage that consumes credits, which is why the planning and review around it are built to make every generation count.

Two things make PRODUCE more than "call a model." Camera intent from the plan is carried into generation rather than left to chance, and continuity is preserved across shots: the last frame of one shot anchors the next so the cut doesn't jump. That continuity anchoring is what keeps a sequence feeling like one film instead of a collage of unrelated clips.

CRITIQUE: scoring the dailies before they earn a place

This is the stage that separates a production system from a generator. Before any shot is allowed into the cut, it is scored against concrete checks, prompt match, sharpness, motion coherence, on-screen text legibility, on-brand fit, and claims risk. A shot that clears the bar advances. A shot that fails is flagged with the reason and sent back.

Crucially, a failure triggers selective regeneration, not a restart. The Director re-produces just the failing shot, carrying forward its plan, camera move, and continuity anchor, and keeps every shot that already passed. That is how the loop converges on a finished cut instead of rolling the dice on the whole sequence again. The full set of checks is worth knowing in detail; the checks every shot is scored on and the specific claims-risk check for brand safety explain how the bar is defined.

Why critique comes before assemble

Reviewing before editing is not an arbitrary order. It is the whole reason the output is shippable. If you assemble first and review later, every fix means re-cutting, and a single bad shot contaminates the finished file. By scoring at the shot level and regenerating failures in place, the Director guarantees that only shots that cleared the bar ever reach the edit. The cut is correct by construction, not by a frantic review pass afterward.

ASSEMBLE: cutting a continuous, graded sequence

Once every shot has passed, the Director edits. The passing shots are sequenced into a continuous cut, continuity already preserved from PRODUCE, graded, and rendered through a deterministic render path: a real render-worker claims the job, renders it, uploads to your storage, and writes an asset row, with retries, a dead-letter queue, faststart, and encoder tiers behind it.

Determinism is the quiet superpower here. The same manifest produces the same cut every time, so a film is reproducible rather than a one-time accident, which is what makes reproducible AI video renders possible. And because the render path retries failures and dead-letters anything unrecoverable, you get reliable rendering with no lost renders instead of jobs that silently vanish.

Provenance: the loop you can replay

Wrapping all four stages is a portable trace. Every generation records the model, the prompt, the parameters, and the score it earned, so the entire loop is auditable end to end. You can see why a shot passed or failed, reproduce it exactly, and hand a client a deliverable you can stand behind. The loop isn't a black box that happens to produce a video, it's a transparent process you can inspect and replay, which is exactly what production work demands.

Frequently asked questions

What are the four stages of the director loop?

They are PLAN (board the film into a shot list with a role, camera move, and prompt per shot), PRODUCE (generate each shot through the owned stack on Google Vertex AI), CRITIQUE (score every shot against concrete checks and flag failures), and ASSEMBLE (cut the passing shots into a continuous, graded sequence and render it). The stages run in sequence, and failures route back for selective regeneration before assembly. Planning, scoring, and editing are free; only PRODUCE costs credits.

Why does the loop critique before assembling?

Because reviewing before editing is what makes the output shippable. If you assembled first, every fix would mean re-cutting and a single bad shot would contaminate the finished file. By scoring at the shot level and regenerating only the failures in place, the Director ensures that only shots that cleared the quality bar ever reach the edit, so the cut is correct by construction.

What happens when a shot fails the quality gate?

The Director regenerates just that shot, carrying forward its plan, camera move, and continuity anchor, while keeping every shot that already passed. The failure is flagged with the reason, and because each generation carries a portable trace of model, prompt, parameters, and score. Youcan see exactly why it failed and reproduce the result, this selective regeneration is how the loop converges on a finished cut instead of restarting.

Is the loop reproducible?

Yes. Every generation rides a portable trace, and the deterministic render path means the same manifest produces the same cut every time. You can replay any film, audit why each shot passed or failed, and trust the result with a client deliverable rather than treating it as a one-off accident.

See the loop run

The four stages are what turn one sentence into a cut you can actually ship: a thought-through plan, real generation, a hard review on every shot, and a deterministic edit, all auditable and replayable. Want to compare what each plan includes? See pricing, or read the docs for the full loop reference. Better yet, start free with no credit card, describe your first film, and watch the Director board, score, and assemble a graded cut for you.