The difference between AI output and a deliverable
A chat window hands you a first draft and stops. A producer cannot budget from a first draft, and a 1st AD cannot run a shoot day from something that merely reads like a call sheet. The gap between “an AI wrote this” and “I can hand this to my department head” is validation, and that gap is where this platform lives.
Between the model and the deliverable sit seven distinct passes. Each is a separately configured stage rather than an instruction buried in a prompt. Five of them depend on which quality tier you run. The other two are not tier-gated, but they work on a finished deliverable, so streamed output does not get them either. This page is specific about which is which, because a quality claim you cannot check is worth nothing.
What actually runs
| Stage | Runs on | What it does |
|---|---|---|
| Review | Premium | Checks the draft against the originating feature's own guidelines and structural requirements. |
| Continuity | Premium | Inspects the output for continuity defects in timeline and stated facts. |
| Contradiction | Premium | Looks for logical contradictions against your project's canon — your script, not a generic rulebook. |
| Refinement (text) | Standard and Premium | Rewrites text deliverables incorporating the QA feedback above. |
| Refinement (structured) | Standard and Premium | Rewrites structured deliverables incorporating the same feedback. |
| Schema repair | Assembled deliverables | Repairs structured output that failed its schema contract. Not gated by tier — but it needs the finished deliverable in hand, so it does not apply to text streamed to you live as it is written. |
| Format repair | Assembled deliverables | Repairs improperly formatted text — a broken Fountain screenplay, for example. Same condition: it runs on output assembled before delivery, not on a live stream. |
Mandatory versus budgeted — and why it matters
The two repair stages always run. Without them there is no valid deliverable to return at all: a stripboard that fails its schema is not a stripboard, and a screenplay with broken Fountain formatting is not a screenplay. Those are contracts, not enhancements.
The review, continuity, contradiction and refinement passes are different. Credits are charged before QA begins, so once the system holds a valid draft the safest possible failure mode is to return it rather than risk the request being killed mid-flight and losing the work entirely. Each optional stage therefore estimates whether it can finish before the platform deadline. If it cannot, it is skipped — and written into the generation’s metadata, so a shed check is auditable rather than invisible.
The continuity and contradiction passes are part of the Premium tier. On Fast and Standard they do not run. We would rather state that plainly than let you infer otherwise from a page like this one.
Streaming output is the second limit, and it is easy to miss
Tier is not the only thing that decides what runs. Some generations stream to you token by token as they are written, so you can read along instead of watching a spinner. That is a deliberate choice and most people prefer it — but a stage that repairs a finished deliverable has nothing to work on while the text is still arriving. Those generations currently reach you without the schema and format repair passes.
This applies to Fast tier by default, and to several longer narrative features on Standard. Premium never streams; its multi-pass loop is the thing you are paying for, and it needs the whole draft in hand before it can check anything. That makes Premium the only tier where every generation goes through the full pipeline.
We are working on validating streamed output after the stream closes, so the version saved to your project gets the same treatment as everything else. Until that ships, this paragraph is the accurate description, and we would rather publish it than round it up.
What we will not claim
Not that output is error-free. No generative system can promise correctness, and a platform that tells you otherwise is either confused or selling something. Not that all seven stages run on every generation, because four of them are sheddable. Not that the two ungated stages reach every generation either — see the note on streaming above. And not that validation replaces your own judgement — it is a floor under the output, not a substitute for reading it.
What is checkable: deliverables assembled before they reach you are validated against their contract, malformed formatting is repaired rather than passed along, and on Premium the result is additionally checked against your project’s own canon rather than a generic rulebook. When a check is shed for time, the system records it.
Why a chat window cannot do this
Not because the model is weaker — general assistants are extremely capable writers. The constraint is structural. A schema contract requires knowing the shape the output is supposed to take. A continuity check requires a canonical set of project facts to check against. A format repair requires knowing that this particular text was meant to be Fountain with correct margins. A conversation has none of those: it has your prompt and its own reply.
That is also why the checks here are scoped to your script rather than to general filmmaking knowledge — the project canon exists, so there is something specific to be consistent with. The full ChatGPT comparison covers this properly, including where ChatGPT is genuinely the better tool.
Common questions
Does every generation pass all seven stages?
No, and there are two separate reasons. Five of the seven are gated by tier: refinement runs on Standard and Premium, and the review, continuity and contradiction passes are Premium. The other two — schema repair and format repair — are not tier-gated, but they need the finished deliverable in hand, so they do not apply to output streamed to you live as it is written. Premium never streams, which makes it the one tier where the full pipeline runs on every generation.
Why can't I just use ChatGPT for this?
You can, for a draft. The differences are structural rather than about model quality: a chat window starts every conversation empty, so you re-establish your scenes, cast, locations and schedule for each document; there is no schema contract, so structured output is free text that happens to look tabular; and what comes back needs reformatting before a department head can use it. We wrote this out properly on the ChatGPT comparison page, including where ChatGPT is genuinely the better tool.
What happens if a check can't finish in time?
It is skipped and recorded rather than silently dropped. Credits are charged before QA runs, so the only safe behaviour past that point is to return the valid draft already in hand rather than risk the request being killed mid-flight. When that happens the shed stage is written to the generation's metadata, so it is auditable rather than invisible.
Is the output guaranteed to be correct?
No, and we won't claim it. No generative system can guarantee correctness, and a page promising error-free output would be lying to you. What we do claim is narrower and checkable: deliverables assembled before they reach you — breakdowns, schedules, budgets — are validated against their contract and repaired if malformed, and on Premium the result is additionally checked against your project's own facts.
What is the difference between this and script coverage?
Coverage is a creative judgement about whether the script works — structure, character, pacing — and it is something you request and read. The validation pipeline is infrastructure you never interact with directly: it checks that what the system produced is well-formed, internally consistent and in the shape it promised. One is an opinion about the writing; the other is a contract about the output.
Does this slow down generation?
The optional stages add time, which is exactly why they are budgeted against the request deadline and shed when they will not fit. That is also part of why the quality tiers exist: Fast is a single pass when you are testing structure and want an answer quickly, Premium runs the additional passes when you are producing something that has to hold up.