A Client Review Loop Built on Previews and Share Links

A generation takes seconds and a client review round takes days, and that mismatch is where most of AI video's speed advantage quietly disappears. It doesn't disappear because generating is slow — it's because the default review loop still treats every round the same way a live-action revision round worked: re-render the whole thing, send a file, wait, repeat. Versely's own primitives point at a cheaper shape than that, built from three pieces that were designed separately but happen to fit together into exactly the loop an agency actually needs.

The three primitives a review loop is built from

edit_video bills previews and final exports differently by design: preview:true renders a free 480p pass with a short per-user cooldown, and only the final render — preview:false, the default — charges the normal single editor_export price. create_share_link mints a link for any hosted media URL with a rich preview card, viewable without an account, and doesn't spend generation credits to create. review_generation self-checks a generated image or video against its original prompt via vision and returns a structured verdict — matches_prompt, a list of issues, a severity of ok, minor or broken, and a suggested_fix.

None of these three were built specifically for agency-client review. Put together, they are one anyway: iterate for free, catch the broken take before anyone outside the team sees it, then hand over a link that opens on a client's phone with no login screen in the way.

What "free" actually buys in a review round

The mechanic worth understanding before anything else: Versely's editor charges by export count, not by edit count. Eight preview passes while cutting cost nothing at all; the credit charge only lands once, on the export you actually confirm. That inverts the assumption a lot of review processes are still built around — that every client round consumes billable output. A client asking for "a bit warmer," then "actually go back toward the original," then "warmer again, but keep the crop" is three free preview renders internally, and the only credit spend in that entire exchange is the one export that goes out once everyone's actually satisfied.

That's a different economic shape than a studio day, where every round of notes eats billable time whether or not the client ends up somewhere better than round one. Here, the iteration itself is free; only the confirmed answer costs anything, which means the honest incentive is to keep revising in preview until it's actually right rather than exporting early to "show progress" and eating a charge for a cut nobody signed off on yet.

Self-QC before the client ever sees it

The more expensive failure in a client review loop was never the credit cost of a re-render — it's sending something broken to a client in the first place and burning trust on a mistake that a five-second internal check would have caught. review_generation is built for exactly that gap: run it against the finished piece before the share link goes out, and a severity of "broken" or even "minor" with a suggested_fix attached is a problem fixed on your side of the table, not discovered on theirs. Its own guidance is not to run this reflexively on every single generation — it costs credits and a beat of latency — which makes the natural rule for a review loop specifically: run it once, right before something is about to leave the building for a client's eyes, not on every intermediate preview along the way.

The share link as the actual review surface

The friction that usually breaks a client review loop isn't the video — it's the account. Asking a client to sign up, log in, or install something before they can look at a cut is the single biggest reason review rounds stall on "did you get a chance to look at that yet." Asking the agent for a shareable link sidesteps the entire problem: the link opens with a rich preview card — the video or image itself, plus the original prompt as context — and needs nothing from the person opening it beyond a tap. Paste it into an email, a WhatsApp thread or a Slack message and it renders properly before anyone's even clicked through, which is most of what "easy to review" actually means in practice.

It's worth naming what this replaces, because the old version of "send the client a preview" usually meant a shared drive folder, a file naming convention nobody follows past the second round, and a client who's now three videos deep with no idea which one is current. A share link sidesteps all of that by being disposable and specific — one link, one asset, one round of notes attached to exactly the thing it's about. Nothing about the mechanism cares whether the client has ever touched Versely before, which is the whole point: the review surface has to work for the person with the least context on the tool, not the person who built the cut.

Where it all lives between rounds

A review loop that spans several rounds needs somewhere for "the version we liked from round one" to live that isn't a scroll through chat history. Saving the confirmed preview — or the final export, once there is one — into a named project keeps that organized without spending anything to do it: saving generations to a project doesn't use generation credits, and it automatically skips a URL that's already saved rather than duplicating it. When round three's note is "actually, go back to what we had before the last change," that's a project lookup instead of a regeneration nobody budgeted for.

What happens when the client comes back with notes

The loop only earns its keep on the second round, not the first — anyone can send one preview link. What matters is whether "make the intro a beat faster and swap the music" turns into another free preview pass or a fresh billable render. It's the former by construction here: the note gets applied with another edit_video call at preview:true, reviewed the same way, and re-shared the same way, with the export step held back until there's nothing left to change. A five-round revision cycle on a single deliverable costs exactly one export, whenever the client actually says yes — the number of rounds it took to get there is invisible to the credit total.

A Versely walkthrough

The full loop, in the order it actually runs:

"Cut these three clips together with the intro voiceover, preview it at 480p — I want to check the pacing before we spend anything on a real export."

That's edit_video with preview:true, free and repeatable through as many rounds of client notes as it takes. Once a cut looks ready to go out:

"Run a quality check on this before I send it to the client, then give me a shareable link."

review_generation grades the result against the original brief first — worth fixing anything it flags before the next step — then create_share_link mints the no-login preview link that actually goes to the client. Once they approve it:

"Save this to our 'Q3 Client Review' project, then export it for real."

save_to_project files the approved cut for reference, and the final edit_video call — preview:false this time — is the one and only charge the entire round produces. Check Versely's pre-publish review task for the deeper version of the QC step when a deliverable is about to carry real ad spend behind it, not just a client's sign-off.