AI Video Production Pipeline: From Idea to NLE Export

You know this tedious workflow. Generate the still in one tool. Download it. Switch tabs. Upload to a video tool. Prompt for motion. Download the take. Switch tabs again. Upload to a voice tool. Generate the audio. Download. Open a lip-sync tool. Upload everything. Render. Open the editor. Import. Cut. Color. Export. Each transition costs time. Each download loses fidelity. Each tool has its own version history that does not talk to the others. Each step is a place where a small inconsistency creeps in and you do not notice until the cut is done and the brand color is half a step off across three shots.

The Martini canvas replaces this with one workspace. Image generation, video generation, voice synthesis, lip-sync, multi-shot assembly, and NLE export all live as nodes in the same graph. The output of one node becomes the input of the next. References stay shared across the graph. The version tray remembers every take across every node. There is no download-then-upload step because there is no separation between tools to download across.

This is the production pipeline shape that AI video work has been heading toward since the first generation of standalone AI tools shipped. The leverage is in the continuity, not in the individual tools. Every model in the canvas exists in other places. The structural advantage is the canvas pattern — that they all live in one workspace and feed into each other directly.

The pipeline starts at script. A text node holds the script for the piece — the structure, the beats, the dialogue. Downstream of script, the production splits into the visual and audio tracks. The visual track runs through image and video nodes. The audio track runs through voice and music nodes. Both tracks converge at the NLE export node, which is the closing edge of the pipeline.

The visual track typically holds: image generation nodes for stills (Nano Banana 2 for character, GPT Image 2 for text-bearing assets, Imagen 4 for photoreal environments, Flux for illustration), video generation nodes per shot type (Seedance 2 for cinematic image-to-video, Google Veo for environmental wides, Runway Gen4 for editor-grade kinetic shots, Kling Avatar for talking-head), and any edit nodes between them (Flux Kontext for surgical image edits, Runway Aleph for clip continuation).

The audio track typically holds: voice nodes for spoken content (ElevenLabs or Fish Audio S2 for cloned or library voices), music nodes for sonic identity, and sound effect nodes for atmospheric layers. The voice nodes feed into Kling Avatar for lip-synced shots. The music and sound effects flow into the NLE export node directly.

Asset continuity is the load-bearing property. The output of one node feeds directly into the next without a download-and-re-upload step. A still generated by Nano Banana 2 is wired into the Seedance 2 video node — Seedance reads the image directly. The voice generated by ElevenLabs is wired into the Kling Avatar node — Avatar reads the audio directly. The chosen video takes are wired into the NLE export node — the NLE reads them directly.

Shared references are the second property. The canonical character library lives once on the canvas and is wired into every image, video, and lip-sync node that needs it. The brand color reference, the product still, the style anchor — same pattern. A change to a reference propagates downstream automatically. A change to the script propagates downstream automatically. The pipeline is reactive to its inputs.

The version tray is the third property. Every take across every node lives in the tray. Pinning the strongest take from each node sets the canvas state. Re-pinning later updates the cut downstream. The pipeline holds together because the canvas remembers everything, and the cost of trying alternative takes is bounded by the version tray rather than by re-generation.

The structural advantage of the canvas is that the model choice happens per shot, not per project. Outside the canvas, you commit to a video tool and use it for everything in the project. On the canvas, every shot in the sequence gets the right model for what it is doing — and changing your mind on a shot is one node-swap away.

The default model loadout on most production canvases is: Seedance 2 for cinematic image-to-video shots (the workhorse, runs as Pro for hero takes and Lite for iteration), Google Veo for environmental establishing shots and long-range wides, Runway Gen4 for editor-grade kinetic shots that will color-grade well in the downstream NLE, Kling Avatar for any shot dominated by a character speaking, Vidu when high-volume iteration on character motion is the priority. Different projects emphasize different parts of this loadout, but the structural pattern of using all of them is consistent.

For each shot, the workflow is: drop the model node, wire shared references in, write a one-shot motion prompt, render two or three takes, pin the strongest. The version tray keeps the alternates so re-cuts are cheap. The cost difference between models is small relative to the quality difference per shot, which is why the per-shot choice matters.

The NLE export node is where the pipeline produces its deliverable. The node sits at the right edge of the canvas and reads from every upstream chain. Wire each chosen video take into the NLE node in the order they should appear in the cut. The NLE node assembles the takes, applies basic cuts and transitions, and produces an export-ready video file.

For finishing — color grading, audio mixing, advanced effects — the NLE export node produces output that is ready to import into a traditional editor (Premiere, Resolve, Final Cut, Capcut). The Martini canvas is not trying to replace your editor; it is producing the source assets and the rough cut so the finishing pass in your editor of choice is the last step rather than the only step. The handoff is clean because the canvas exports standard video formats that any NLE imports directly.

When you need to revise the cut after finishing has started, the canvas is reactive — change a video take upstream, the NLE export node re-renders the assembled cut with the new take, you re-export and re-import to the editor. This is dramatically cheaper than the traditional pattern of re-generating the take in a separate tool, downloading, re-uploading to the editor, and replacing in the timeline.

The shape of AI video work is changing from "AI video tool" to "AI video pipeline." The first generation of products treated AI video as a discrete capability — a tool you switched into when you wanted to use AI. The second generation treats AI video as a layer of the production pipeline — a set of nodes in the editing graph alongside everything else. The Martini canvas is the second-generation product shape.

Two years from now, the question "which AI video tool do you use" will sound the way "which Photoshop do you use" sounds today — like a category error. There will not be a discrete AI video tool to commit to. There will be AI video models exposed as nodes in the editing pipeline, and the choice will be per-shot rather than per-project. The orchestrator pattern is what the production-grade workflows of 2027 look like.

Where the canvas pattern is heading next is deeper integration with traditional editing surfaces. The NLE export node is the first step — it produces output ready for traditional editors. The next step is bidirectional integration: the canvas pulls source video back from the editor for AI processing, applies effects nodes, and pushes results back into the timeline. The boundary between "AI step" and "editing step" disappears entirely. The canvas is the editing pipeline.