We Published the Number Nobody Publishes

In July we wrote that no AI video pricing page publishes cost per usable clip. That was easy to write, and it left out the uncomfortable part: we weren't publishing ours either. This is what we built so we could — a public record of every attempt behind a film, including the ones we threw away.

Every finished AI video is the survivor of a process nobody shows you. Somewhere behind the thirty seconds you watched are the eleven attempts that didn't make it: the one where the camera pushed in after you asked for a locked-off frame, the one where the character's face drifted halfway through, the one the provider refused outright and charged you for anyway.

That process is where the money goes. In Cost Per Usable Clip we argued that the number deciding your bill isn't the credit price on the pricing page — it's what you actually spend to get one clip worth keeping, which on most platforms runs two to four times the advertised figure. We ended that post with a sentence that has been quietly bothering us since: no pricing page publishes it.

Ours didn't either. So we built the thing that would let us.

Why the Number Isn't Published

It's tempting to read the silence as marketing discipline — nobody volunteers an unflattering multiplier. That's part of it. But the larger reason is architectural, and it's more interesting.

On most tools, a regeneration overwrites. You ask for the shot again, a new file lands where the old one was, and the previous attempt stops existing in any meaningful sense. It isn't archived, it isn't counted, it isn't linked to the thing that replaced it. The failed generation is a line on a credit statement and nothing else.

Which means that even internally, the attempts multiplier often isn't measurable. You can't publish a number you never recorded. A tool that overwrites cannot tell you how many tries a shot took, because after the third try there is only ever one file.

What a Take Graph Is

A take graph is the record of how a film was actually made. One lane per shot. Inside each lane, every attempt at that shot in the order you made them, with the prompt as it was sent, the model that ran it, what came back, and — for the ones you rejected — the reason and the note you typed at the time.

One take in each lane is the keeper: the one that's in the cut. The rest are the interesting part. A lane with five attempts and four rejection notes tells you more about what it takes to make this kind of film than any showreel does, because it shows the distance between what was asked for and what arrived, four times.

Some lanes have one take. The shot worked first time, there's nothing to compare, and the graph says so rather than dressing it up. That's the honest shape of real production: a few shots fight you and most don't.

The Three Leaks, Answered

Our July post named three specific ways the advertised price and the real price come apart. Each one has a direct answer in how attempts get recorded, so it's worth taking them in order.

"Failed and partial renders still get charged"

They do — here too. We can't make a provider refund a refusal. What we can do is refuse to hide it.

A failed attempt gets a row exactly like a successful one. So does a cancelled one. Both appear in the take graph with their status, and — when the author has chosen to publish costs — both count toward the film's total. A charge for a take nobody kept is precisely the kind of spend a public record exists to surface. Dropping failures from the total would make the number prettier and useless.

"The meter starts too early"

The attempt row is written before the provider is called, not after it answers. Dispatch is conditional on the record existing first.

That ordering is the whole ballgame. If you write the record after the response, then every timeout, every crash, every provider that takes your money and returns nothing becomes an invisible charge — money spent with no row to explain it. Writing first means the worst case is a row that says the attempt failed, which is a far better worst case than a bill you can't reconcile.

"Two to four times the advertised number"

That multiplier has a name in the graph: attempts to keeper. It's the median number of tries a shot in this film took before one was kept, and it's computed from the rows rather than estimated. Published alongside it: the number of shots, the number of takes, how many models were involved, and — at the author's discretion — what the whole thing cost.

If the number is bad, the number is bad. It's derived from the same rows a reader can scroll through and count.

What "Published" Means, Exactly

Publishing a take graph is a deliberate act with a screen in front of it. Before anything becomes public you see the exact text that will be visible — every prompt as it was sent, every reference file name, every note you typed on a rejected take. Not a summary, not a count. The actual strings.

We're specific about this because prompts are not neutral. They routinely contain client names, unreleased product details, campaign strategy, and candid opinions about what went wrong. A tool that publishes "your project" without showing you the text is publishing things you didn't know you'd written.

A published graph carries:

• The prompt for each take, as sent to the model
• The model and provider that ran it
• Reference file names — so you can see that a character sheet was used, and which one
• The verdict on each take, and the rejection note if there is one
• The lineage: which take came from which

And it deliberately does not carry:

• Seeds and provider parameters
• The reference files themselves
• Output media inside the file

Default visibility is private. A film is not public because you made it; it's public because you decided it should be, on a screen that showed you what that meant.

The Part That Costs Us Something

Here is the rule we're most likely to be asked to change, and the one we'd defend hardest.

A published cost total is all-or-nothing. If a single attempt in the film has no recorded price — a legacy row from before we captured charges, a provider response that didn't include a figure — then the film's total is reported as unknown, and unknown is what gets published. We don't sum the attempts we do have prices for and present that as the total.

The temptation to do otherwise is real, because a partial total is always a smaller total. Sum nine priced attempts out of eleven and you publish a number that is confidently, quietly wrong in the flattering direction. The reader has no way to detect it. That's the exact failure the whole feature exists to prevent, so the rule is the opposite: one unpriced attempt makes the figure unknown for the entire film, and the page says so.

The costs that do get published are what was actually charged, tied to the receipt for that generation — not a rate-card estimate reconstructed afterwards. When a single charge covered several outputs, it's counted once.

It's a File, and the File Is Open

The take graph isn't only a web page. It's a document format — take/1.0 — and any published film can be downloaded as a .take file.

The file records the lineage: shots, takes, the tree of which attempt came from which, the inputs behind each one, the verdicts, and a hash of each take's inputs that a reader can recompute to verify nothing was edited after the fact. It is not an edit decision list and not a delivery format. It sits alongside an EDL; it doesn't replace one.

We gave it away. The specification, the JSON Schema and the example files are CC0 — public domain, no permission needed, no attribution required. The reference reader, the command-line tool and the viewer are MIT. If you implement it, you are not a licensee; you're an implementer.

• The specification — the format, the rules a JSON Schema can't express, and the reproducibility contract
• github.com/meet1919/take-format — reference reader, CLI, single-file viewer, four example documents
• The viewer — open it, drop a .take on it, read someone's lineage without uploading anything anywhere

One detail in the viewer is worth calling out, because it's the kind of thing that's easy to get wrong. The viewer will not fetch any URL named inside a file you give it. Its content security policy makes that structurally impossible rather than merely discouraged. A .take file that arrives from a pull request or a group chat is untrusted input, and a viewer that dereferences URIs out of untrusted input is a server-side request forgery and a tracking pixel wearing a document's clothes. So it renders the lineage and refuses the network.

Two Flavours of the Same Document

A file you export from your own project carries more than a file downloaded from a public page: output references, seeds where they were captured, provider versions. A published file is input-only. Both are valid take/1.0, and a reader has to expect either — which is why the published example shipped with the spec is generated by the same code that serves the endpoint, so it can't drift from what the service actually returns.

Forking

Because the document carries inputs rather than media, a published film can be forked. You start from someone else's recipe — their prompts, their structure, their settings, the notes explaining what they rejected — in your own project, with your own references, and generate your own footage. You don't get their video. You get their reasoning, which is the part that was actually hard to come by.

Sending It to a Client

The same machinery answers a problem that has nothing to do with transparency and everything to do with Thursday afternoon.

Review links are private, revocable links you hand to one client. No account, nothing to install, nothing to spend. They open the cut and — if you choose — every attempt behind it. Your client can approve the cut or request changes, and leave notes attached to a specific take rather than to "the video." You see whether they've opened it.

The reason to show a client the rejected takes isn't confession, it's speed. Half of every revision round is a client asking for something you already tried and discarded for a reason you can no longer remember. When the rejected take is sitting there with the note "asked for static; it pushed in" underneath it, that conversation takes one message instead of three. It pairs with what we wrote about doing revision rounds without regenerating the whole film.

These links are noindex, carry no referrer, and can be revoked the moment a relationship changes.

See For Yourself

[PLACEHOLDER — replace with the published film, its real numbers, and one real rejection note.]

What This Doesn't Do

Four honest limits, because a transparency feature that oversells itself is self-refuting.

Replay is best effort. Providers deprecate models and silently re-tune them, and some accept no seed at all. A recorded seed does not guarantee you'll reproduce a take. Where no seed exists, the file records null rather than inventing a plausible number, and a reader is told not to claim a take was reproduced unless both the seed and the provider version are present.

It is not a media archive. The format carries lineage and inputs. Video lives where video lives; the file tells you what was made and why, not where the bytes are.

Audio is recorded, but it isn't a lane. Voice and music attempts are captured and counted in the cost, because they're real spend. They don't appear as lanes in the graph, which is one shot per lane by design.

Publishing is a real disclosure. We've been careful about what's withheld and explicit about what isn't, but the prompts go public as written. Read them on the confirmation screen. That screen exists because we expect you to use it.

The Bottom Line

The industry's honest position on cost per usable clip is that it's unflattering and unmeasured, in that order. We think the measurement problem is the one worth solving first, because once attempts are durable records instead of overwritten files, publishing them is a decision rather than a project.

We've made that decision. The format is public domain, the tools are MIT, and any film we publish can be downloaded, parsed and checked by a stranger with no account and no permission. If our numbers are bad, they're bad in public and in a file you can verify.

That's the only version of transparency that means anything: the kind you can audit without asking us.

FAQ

Related Reading

• Cost Per Usable Clip: The AI Video Pricing Metric Nobody Publishes
• How to Do Revision Rounds in AI Video Without Regenerating the Whole Film
• Before You Sign Up: How RizzGen Shows You Everything
• Controllable AI Director: What Directorial Control Means in AI Video