Draft-Then-Upscale: A Generative AI Cost Pattern

Gemini Omni 1.1 Flash added a 360p draft mode at about one-third the cost, then upscales only the clip you approve, and that draft-then-upscale pattern is a general cost lever for any expensive generative pipeline, not just video. On August 28, 2026, Google shipped Gemini Omni 1.1 Flash with cheap drafts and 4K upscaling. The video features grabbed the headlines, but the cost pattern underneath is the part worth stealing. At Van Data Team, we help teams turn patterns like this into a lower generative-AI bill.

Key Takeaways

• On August 28, 2026, Google shipped Gemini Omni 1.1 Flash with a 360p draft mode at roughly one-third the cost of 720p, plus 1080p and 4K upscaling.
• The reusable idea isn't the video; it's draft-then-upscale: generate cheap drafts, pick the winner, and spend expensive compute only on that one.
• It saves money because most generative work throws away several candidates, so paying premium rates for the discards is pure waste.
• The pattern generalizes: cheap-model drafts finalized by a strong model for text, low-res options upscaled for images, cheap exploration then expensive commitment for agents.
• Van Data Team's recommendation: find your priciest generate-and-select step, split it into a cheap draft pass and an expensive finalize pass, and measure cost per accepted output.

What Did Google Actually Ship?

Google shipped an update to its generative video model, and buried in the video features is a clean, reusable cost pattern.

Reported fact: On August 28, 2026, Google released Gemini Omni 1.1 Flash. It adds scene extension up to 40 seconds in 10-second steps, first-and-last-frame keyframe control, a 360p draft mode that renders up to 60% faster at about one-third the cost of 720p output, and upscaling to 1080p or 4K. Notably, 4K is upscaled output, not native generation.

For a video team, the extension and keyframe controls are the story. For everyone else, the interesting part is the workflow the draft mode implies: render cheap 360p options, pick the one that works, and upscale only that clip to full resolution.

Van Data Team analysis: This piece isn't a video review, because generative video isn't our lane. It's about the cost pattern Google just productized. Draft cheap, select, then finalize the winner is an old idea in a new, concrete form, and it applies far beyond video, to any generative step where you make many outputs and keep one.

What Is the Draft-Then-Upscale Pattern?

Draft-then-upscale is a two-phase workflow: a cheap pass to decide what's worth keeping, then an expensive pass to finalize only the keeper. The costly step runs once, on the winner.

The logic is simple. Most generative work is generate-and-select: you produce several candidates and ship one. If every candidate is rendered at full quality, you pay premium rates for the ones you throw away. Draft-then-upscale flips that: the many candidates are cheap and low-fidelity, just good enough to choose between, and the single expensive render happens after the choice is made.

Gemini Omni's numbers make it concrete. A 360p draft costs roughly a third of a 720p render, so exploring ten ideas as drafts costs about what three full renders would, and you only pay the full, upscaled price once, for the clip you keep. The savings scale with how many candidates you would otherwise have rendered at full price.

Van Data Team analysis: The pattern works because selection and quality are separable. You don't need 4K to decide whether a shot is right; you need it only for the final deliverable. Any time those two things, choosing and finishing, can be split, you can make choosing cheap and pay for finishing once. That's the whole trick, and it's hiding in a lot of expensive pipelines.

Why Does Draft-Then-Upscale Cut Costs?

It cuts costs because it stops you paying full price for rejected work. In a generate-and-select workflow, the waste isn't the winner; it's all the candidates that never ship.

Picture a step where you generate 5 candidates and keep 1. At full price, you pay for 5 premium outputs to get 1. With draft-then-upscale, you pay 5 cheap draft prices plus 1 premium finalize. If a draft is a third of full cost, that's roughly 2.7 units versus 5 units the old way, a real cut on the identical deliverable, and the more candidates you explore, the wider that gap grows.

There's a second, quieter saving: speed. Omni's drafts render up to 60% faster, so exploration is quicker as well as cheaper, which means more iteration for the same time budget. Faster feedback usually means a better final choice, so you're not just saving money, you're improving the odds you pick the right winner.

Van Data Team analysis: This is the same economics behind token efficiency: the cheapest work is the work you don't do at full price. Draft-then-upscale doesn't make any single render cheaper; it makes sure the expensive render happens once instead of five times. That's a workflow change, not a discount, which is why it stacks on top of every other cost lever you already use.

Where Does the Pattern Apply Beyond Video?

It applies anywhere you generate many outputs and keep few, which describes most generative AI in production. Video just made it visible; the shape is everywhere.

• Text and LLMs: draft with a small, cheap model, then finalize the chosen output with a larger one, instead of running the expensive model on every attempt.
• Images: generate low-resolution options, pick the composition, and upscale only the winner to full print or web resolution.
• Code and agents: explore several approaches cheaply, then spend expensive reasoning or a stronger model only on the branch that looks right.
• Data pipelines: validate a transformation on a cheap sample before running the full, costly job over the entire dataset.

Van Data Team analysis: Notice the common shape: make selection cheap, and spend premium compute only on the winner. For LLM work this is especially powerful, because a small model can often draft or filter well enough to hand the large model just the finalists. The pattern is the same one Google shipped for video, and it maps directly onto the text and agent pipelines we build most.

How Do You Design the Draft Pass So It Picks the Right Winner?

The whole pattern depends on one thing: the cheap draft has to be a good enough proxy that the winner it picks is still the winner at full quality. If the draft misleads you, you save money and ship the wrong output.

A draft is a good proxy when it preserves the qualities you actually select on, even if it drops the ones you don't. For video, a 360p draft keeps composition, motion, and timing while dropping fine detail, and you choose shots on the first three, so it works. For text, a smaller model can preserve structure and argument while a larger one sharpens phrasing, so drafting the outline cheaply is safe.

• Preserve the decision signal: make sure the draft keeps whatever you judge on, resolution, structure, or logic, even at lower fidelity.
• Drop only the finish: let the draft shed the expensive detail that doesn't change your choice, which is where the savings live.
• Sanity-check the proxy: occasionally finalize a rejected draft too, and confirm it really was worse, so you trust the selection.
• Watch for proxy gaps: if the cheap draft and the full render disagree often, tighten the draft or raise its fidelity until they agree.

Van Data Team analysis: This is the one place the pattern can quietly fail, so it's worth an explicit check. A draft that's too cheap stops predicting the winner, and you trade a small saving for a worse output, which is a bad deal. The fix isn't to abandon drafting; it's to tune the draft until it reliably agrees with the full render on which candidate wins. Get that right, and the rest of the savings are free.

Draft-Then-Upscale Versus Full-Fidelity Everywhere

The contrast is easiest to see side by side. The table shows why splitting selection from finishing changes the bill.

Van Data Team analysis: Read the cost-driver row. Full-fidelity ties your bill to how much you explore, which punishes iteration exactly when you want more of it. Draft-then-upscale ties your bill to how much you ship, so exploring more costs almost nothing. That inversion is the point: it makes trying more ideas cheap, not expensive.

What Is the Honest Catch With Upscaling?

The catch is that upscaling approximates detail rather than creating it, so an upscaled result isn't always identical to one generated at full resolution natively. Be clear-eyed about where that matters.

For video and images, a 4K upscale infers detail from a lower-resolution source; it's excellent for most uses but not the same as native 4K for the most demanding work. Google itself describes Omni's 4K as upscaled, not native, which is the honest framing. For text and code, the analog is stronger: re-running the chosen draft on a better model is closer to true full quality, because the model regenerates rather than interpolates.

Van Data Team analysis: The lesson is to match the finalize step to your quality bar. If upscaled output clears it, you capture the full saving. If you need native fidelity, use the draft only for selection and generate the winner natively at full price, which still beats generating every candidate natively. Either way, the draft pass pays for itself by making selection cheap.

How Should a Team Start With Draft-Then-Upscale?

Start with your single most expensive generate-and-select step, split it into a draft pass and a finalize pass, and measure the cost per accepted output. You prove it on one step before you spread it.

• Find the step where you generate several candidates, keep one, and pay premium rates for all of them.
• Add a cheap draft mode for selection: a smaller model, a lower resolution, or a sampled dataset.
• Finalize only the chosen candidate at full quality, whether that's an upscale or a native re-run.
• Measure cost per accepted output before and after, and confirm the final quality still clears your bar.
• Roll the split into your next costly generate-and-select step, so the savings compound across the pipeline.

This is a workflow change, not a re-platforming. The first step you convert usually reveals how much you were spending to render work you never shipped, which is the number that makes the case. From there, each generate-and-select step you split lowers your bill without touching quality, much like the guardrail discipline in our cloud cost optimization work.

How Van Data Team Helps

Van Data Team treats generative AI cost as an engineering problem, not a fixed price you accept. We start by finding the generate-and-select steps in your pipelines where you pay full rates for work you discard, because that's where draft-then-upscale pays off fastest.

From there, we help you split those steps into cheap selection and expensive finalize, instrument cost per accepted output, and keep quality on the final where it matters. If you want help, our AI agent development and data pipeline development work covers the pipelines this sits inside, and it complements the model-side savings in our AI agent development cost work. The goal is simple: explore as much as you want, and pay full price only for what you actually ship, so more ideas cost you almost nothing and only finished work shows up on the bill.