How a Brief Becomes a Production: The Pipeline as a Feedback Loop

OpenMontage's pipeline is not a conveyor belt that runs every stage once. It is a controlled loop in which each stage narrows uncertainty, records a decision, and leaves enough context for a later stage to correct an earlier assumption. This chapter follows that loop from proposal to render so the reader can see where approval, revision, targeted send-back, and resume behavior protect the production.

The distinction is important because video facts arrive at different times. A proposal can estimate a voice cost before narration exists, but it cannot know the exact duration of the generated audio. A scene plan can assign a clip to a beat, but retrieval may reveal that the right footage is unavailable. A render can expose an audio or timing defect that no text artifact could show. OpenMontage's design treats those discoveries as inputs to the workflow rather than as reasons to pretend the original plan was complete.

Before production, the system spends understanding before it spends money

The pipeline begins with research and proposal rather than asset generation. Research creates a brief grounded in sources, audience questions, data points, and possible angles. Proposal turns that material into concepts, a production plan, a cost estimate, and a user-visible choice. In the animated-explainer manifest, research and proposal are explicitly separated from later stages that call generation tools, and proposal approval is required before the pipeline moves on.

This is the system's last inexpensive exit. A user can reject a concept, change its duration, choose a different visual approach, or question the cost before the agent generates a batch of assets. Once images, video clips, narration, or music have been produced, changing the direction can mean wasted calls and inconsistent material. The approval gate is therefore not a delay added after the creative work; it is a boundary that prevents the most expensive kind of misunderstanding from propagating.

The proposal also makes the production promise more concrete. It can identify the intended pipeline, playbook, tools, render path, music plan, budget, and alternatives. Those details are not an inventory for its own sake. They tell later stages what they are allowed to assume. A script should be written for the selected duration and tone. A scene plan should use asset types that the approved tools can actually produce. The asset stage should not quietly replace a missing capability with a lower-quality treatment if that change violates the promise.

After approval, the production moves through canonical artifacts. Research informs the proposal; the proposal informs the script; the script informs the scene plan; the scene plan and script inform the asset manifest; assets and scene timing inform edit decisions; edit decisions and assets inform composition; the render report and final review inform publication. Each artifact reduces a different uncertainty.

A script reduces uncertainty about what will be said and how long the narration should run. A scene plan reduces uncertainty about what the audience should see at each beat. An asset manifest reduces uncertainty about which files belong to which scene and where they came from. Edit decisions reduce uncertainty about order, timing, transitions, audio, and subtitles. A render report reduces uncertainty about what was actually produced. The chain is valuable because a later stage can use the earlier decision as structured context rather than reconstructing it from scattered files.

The artifact does not make the decision correct. It makes the decision inspectable and transferable. A clearly written scene plan can still choose weak visuals; a complete asset manifest can still contain a clip with the wrong emotional register. The contract narrows ambiguity so that review can address the creative problem directly instead of first trying to discover what the previous stage intended.

The order also explains why a later stage should not be asked to compensate for every earlier weakness. If the proposal never decided whether the piece needs real motion, the asset stage cannot resolve that ambiguity by picking a convenient provider. If the script has no usable timing, the scene plan cannot create a reliable rhythm from nothing. If the scene plan has no feasible asset treatment, the generator cannot be blamed for failing to produce an unspecified result. Each artifact is a boundary around the next decision, and a good feedback loop sends a defect back to the boundary where it belongs.

That principle keeps the pipeline from becoming a chain of local optimizations. A generator may optimize for a visually attractive frame, an editor may optimize for a smooth cut, and a renderer may optimize for a playable file. The production still fails if those local successes do not express the approved concept together. Canonical artifacts give the agent a shared reference for the whole piece while allowing each stage to do its narrower job.

The executive producer carries context across the stages

A blind serial workflow would call stage one, pass whatever it returned to stage two, and continue until a file appeared. OpenMontage's explainer executive-producer skill describes a different role. The executive producer maintains cumulative state: the approved concept, production plan, budget, narration durations, visual style anchors, revision counts, and an issues log. It reviews each stage against the manifest, the relevant playbook, and cross-stage conditions before deciding what happens next.

That state is what turns a list into a feedback loop. Suppose the selected concept expects a ten-second visual section, but the generated narration takes sixteen seconds at a natural speaking pace. The mismatch is discovered during the asset stage, after the script and scene plan already exist. A blind workflow might cut the narration, stretch a still, or let the audio collide with the next scene. The executive-producer loop has more disciplined options: send the section back to the script stage with a word constraint, adjust the scene timing if the change is within the approved tolerance, or revise the affected asset plan. The important point is that the downstream measurement is allowed to challenge the upstream assumption.

This is cross-stage judgment rather than ordinary error handling. The problem is not necessarily that the audio tool failed. The tool may have produced a valid file. The problem is that the file changes the relationship between narration and visual timing. Because the cumulative state retains the original target and the actual duration, the system can compare them and repair the right decision.

A similar loop applies to budget. If early paid operations consume most of the approved amount, later stages cannot be treated as if the original estimate still had unlimited headroom. The executive-producer state carries spend and remaining budget forward. The production can use a cheaper or local option, but a quality or capability change should remain visible. In this model, cost is not a note added after the render; it is part of the context that shapes later decisions.

The same logic carries style. If early visual assets establish a palette, motion language, or subject treatment, later assets should inherit those anchors. The executive producer's state gives the asset and review stages a place to preserve that continuity. This does not guarantee that all generated images look alike in a good way. It prevents the more basic failure in which each stage behaves as if it were starting a new video.

sequenceDiagram participant U as User participant A as Agent participant M as Manifest participant S as StageSkill participant T as Tool participant R as Review participant C as Checkpoint participant H as Human U->>A: Provide brief and constraints A->>M: Load stage contracts M-->>A: Return order, tools, gates, criteria loop Each stage A->>S: Load stage instructions and prior state S-->>A: Return execution guidance A->>T: Execute bounded operation T-->>A: Return artifact or measured result A->>R: Check schema, criteria, and cross-stage fit R-->>A: Pass, revise, or identify mismatch alt Stage passes A->>C: Persist artifact and state else Downstream mismatch A->>S: Send affected work back with constraint S-->>A: Return targeted revision end opt Creative gate applies A->>C: Mark awaiting human approval C-->>H: Present artifact and cost context H-->>A: Approve, revise, or abort end end

The sequence shows why a checkpoint is more than a save button. It records the state at a decision boundary and gives the next run a way to resume. A long asset or compose stage can write partial progress, allowing the system to know which scene units have completed rather than starting from zero after an interruption. A gated stage can remain paused until a person responds. A failed or revised stage can preserve the previous version in history instead of erasing it.

The saved state also makes decisions legible outside the immediate conversation. The project describes an append-only decision log for major choices such as providers, styles, music, voices, and render paths. Backlot reads checkpoint and event data to show what is waiting, what has completed, what has been spent, and which assets belong to the storyboard. The board does not make the decisions, but it gives a person a way to inspect the decisions without asking the agent to retell the entire run from memory.

That distinction matters after interruption. Resuming is not the same as replaying the user's prompt. A replay could choose a different provider, produce different media, or spend money twice. A checkpointed run can instead load the last valid stage and the partial progress that belongs to it. The preserved history also makes a revision visible: the current artifact may replace an earlier one for execution, but the earlier decision remains part of the run's record.

Why limits make the loop credible

Feedback can improve a production, but unlimited feedback can also create an agent that revises forever. OpenMontage places bounds on revision and send-back behavior. The explainer executive-producer contract allows a limited number of revisions per stage and limits how often work can be sent back between stage pairs. Once a limit is reached, the process proceeds with warnings rather than blocking indefinitely.

That trade-off is important. A quality system that cannot ship is not a production system, but a system that ships after silently ignoring a serious mismatch is not trustworthy either. Bounded iteration forces the agent to distinguish structural problems from polish. A narration section that is slightly longer may be accommodated by a small timing adjustment. A missing capability that invalidates the promised visual treatment requires a more serious decision. The limit does not solve that judgment; it makes the cost of continuing visible.

The checkpoint system also separates progress from approval. An in-progress checkpoint can say that work is underway or partially complete. An awaiting-human checkpoint says that the artifact is ready for a decision but the pipeline must stop. A completed checkpoint says that the stage has passed its required gate. These states prevent the agent from treating “I generated something” and “the user approved this direction” as the same event.

That separation matters most at proposal and asset stages. Proposal approval commits the user to a concept and production plan before the expensive work begins. Asset approval gives the user a chance to inspect the actual visual and audio material before composition locks it into a final timeline. The production can therefore preserve speed without treating the human as a last-minute reviewer who sees only a finished file.

A useful approval request must include more than a button. The person needs the artifact's important choices, the review findings, the cost already spent, and the cost or risk of continuing. Otherwise, the gate merely transfers responsibility without providing the information needed to exercise it. OpenMontage's checkpoint protocol makes that context part of the expected pause, which ties the creative decision back to the same state the agent will use when it resumes.

The resulting loop is neither fully automatic nor manually scripted. The agent supplies continuity and execution; the manifest and skills supply constraints; tools supply capabilities and measurements; checkpoints supply memory; and the human supplies approval where creative intent is at stake. A later chapter will need to judge how strong those guarantees really are, because a procedure can be explicit without being infallible. For now, the key conclusion is that OpenMontage's pipeline is designed to learn from production facts as they appear, rather than forcing every fact to fit the first plan.

References