Record acceptance checks separately from AI video render status

A video-generation job can finish successfully while its output still needs review. A useful integration keeps the provider's job status separate from checks on the resulting artifact. Duration and aspect ratio can be checked from recorded metadata; spelling, actions and sound need their own evidence.

Here is a small, offline JavaScript reporter that keeps an unchecked requirement from becoming a green result. It works on a JSON record and makes no model calls. You can use the method with any video provider.

Define the requirements before the next render

Write down the requested duration, acceptable tolerance, aspect ratio and creative checks before submitting a new generation. Keep each creative requirement specific enough to review: the exact words on a van, the order of actions, or a requested sound.

Also distinguish an instruction failure from a newly discovered preference. A prompt that says a handyman steps out of a van does not specify which door he uses. If the result uses the cargo door and that is unsuitable, add the desired door to the next brief. Do not retroactively score an unrequested driver's-door instruction as a failed test.

The same distinction applies to a two-shot sequence. A second camera angle does not, by itself, violate a request for two shots. A continuous walk-through or a shared landmark needs to be specified if it is part of acceptance.

Record metadata without treating it as creative evidence

For three existing clips on our team's public case page with prompts and source videos, Chrome reported the following on 20 October 2026 at 21:40:22 UTC:

Artifact	Browser duration in seconds	Browser natural dimensions	Requested aspect
Home-repair van	10.08	720 × 1280	9:16
Café	10.041667	720 × 1280	9:16
Hotel event	10.041667	1280 × 720	16:9

These were different prompts using different third-party models, not a controlled comparison. The clips had already been generated on 19 October. The new observation here is the browser metadata, not a repeated generation or a fresh timing experiment.

Browser duration is a number of seconds and can be NaN before data is available, or Infinity for media with no known duration. Natural video dimensions are distinct from the CSS size of the player. Read them after metadata is available and record the artifact location and capture time alongside them. See MDN's references for duration and videoWidth.

For the example calculations below, a tolerance of 0.1 seconds and a relative aspect-ratio tolerance of 0.005 were chosen retrospectively. All three records fit those illustrative limits. That does not establish that they passed a test specified before generation, or that their creative requirements passed.

Give an unmeasured check its own state

Save the following as audit.mjs. A creative verdict needs a reviewer, review time and evidence description. A bare "result": "pass" remains unmeasured. The reporter trusts the records supplied to it; it does not authenticate reviewers, inspect video content or establish publication rights.

// Offline example: summarize recorded checks, not artistic quality or legal clearance.
// No network access, model calls, credentials, dependencies, or paid generations.
// Run: node audit.mjs records.json
import { readFileSync } from 'node:fs';
import { pathToFileURL } from 'node:url';

const positive = n => typeof n === 'number' && Number.isFinite(n) && n > 0;
const nonnegative = n => typeof n === 'number' && Number.isFinite(n) && n >= 0;
const present = s => typeof s === 'string' && s.trim().length > 0;
const dated = s => present(s) && Number.isFinite(Date.parse(s));
// Arithmetic rounding allowance only; measurement uncertainty belongs in the tolerance.
const within = (actual, expected, tolerance) => {
  const rounding = Number.EPSILON * 8 *
    Math.max(Math.abs(actual), Math.abs(expected), Math.abs(tolerance));
  return Math.abs(actual - expected) <= tolerance + rounding;
};

export function audit(record) {
  const { id, artifact, requirements: r, observed: o } = record ?? {};
  if (!present(id) || !present(artifact) || !r || !o ||
      !positive(r.durationSeconds) || !nonnegative(r.durationToleranceSeconds) ||
      !Array.isArray(r.aspect) || r.aspect.length !== 2 ||
      !r.aspect.every(positive) || !nonnegative(r.aspectRelativeTolerance) ||
      !Array.isArray(r.reviewChecks) ||
      r.reviewChecks.some(x => !present(x.id) || !present(x.expectation) ||
        ['duration', 'aspect'].includes(x.id)) ||
      new Set(r.reviewChecks.map(x => x.id)).size !== r.reviewChecks.length) {
    throw new Error('Invalid record or missing explicit requirements');
  }
  const m = o.metadata ?? {};
  const provenance = present(m.source) && dated(m.capturedAt);
  const tests = [];
  const add = (id, known, passes, detail) => tests.push({
    id, result: !known ? 'unmeasured' : passes ? 'pass' : 'fail', detail,
  });
  const hasDuration = provenance && positive(m.durationSeconds);
  add('duration', hasDuration,
    within(m.durationSeconds, r.durationSeconds, r.durationToleranceSeconds),
    { expectedSeconds: r.durationSeconds, observedSeconds: m.durationSeconds ?? null,
      toleranceSeconds: r.durationToleranceSeconds });
  const hasSize = provenance && positive(m.width) && positive(m.height);
  const ratio = hasSize ? m.width / m.height / (r.aspect[0] / r.aspect[1]) : NaN;
  const ratioError = hasSize ? Math.abs(ratio - 1) : null;
  add('aspect', hasSize, within(ratio, 1, r.aspectRelativeTolerance),
    { expected: r.aspect, observed: [m.width ?? null, m.height ?? null],
      relativeError: ratioError, relativeTolerance: r.aspectRelativeTolerance });
  for (const requirement of r.reviewChecks) {
    const review = o.reviews?.[requirement.id];
    // An unsupported verdict is unmeasured, even if its result says "pass".
    // A recorded reviewer identity is a claim in the input, not authenticated here.
    const documented = ['pass', 'fail'].includes(review?.result) &&
      present(review?.reviewer) && dated(review?.reviewedAt) && present(review?.evidence);
    add(requirement.id, documented, review?.result === 'pass', {
      expectation: requirement.expectation,
      review: documented ? review : null,
    });
  }
  const failed = tests.some(x => x.result === 'fail');
  const incomplete = !r.reviewChecks.length || tests.some(x => x.result === 'unmeasured');
  return { id, artifact, status: failed ? 'failed_recorded_check' :
    incomplete ? 'needs_review' : 'recorded_checks_pass', checks: tests };
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  try {
    if (!process.argv[2]) throw new Error('Usage: node audit.mjs records.json');
    const input = JSON.parse(readFileSync(process.argv[2], 'utf8'));
    if (!Array.isArray(input.records)) throw new Error('Expected a records array');
    const report = input.records.map(audit);
    console.log(JSON.stringify({ scope: 'Recorded checks only; no model ranking or publication clearance', report }, null, 2));
    // 0 = recorded checks pass; 1 = a recorded check fails; 2 = review incomplete.
    process.exitCode = report.some(x => x.status === 'failed_recorded_check') ? 1 :
      !report.length || report.some(x => x.status === 'needs_review') ? 2 : 0;
  } catch (error) {
    console.error(error.message);
    process.exitCode = 3;
  }
}

The comparisons include a tiny allowance for binary floating-point arithmetic rounding. Measurement uncertainty must be included in the explicit tolerances.

The CLI returns exit code 0 when all recorded checks pass, 1 when a recorded check fails, 2 when review is incomplete, and 3 for an invalid record. When failures and unmeasured checks coexist, exit code 1 takes precedence and each check keeps its own state. These describe the report, rather than the provider job or approval to publish the video. A metadata-only record stays incomplete even when its numbers fit.

Start with a record that still needs review

Save this as records.json. Its metadata comes from the van clip above. The creative checks remain empty because the new metadata capture did not review them.

{
  "records": [{
    "id": "van",
    "artifact": "commercial-seedance-handyman.mp4",
    "requirements": {
      "durationSeconds": 10,
      "durationToleranceSeconds": 0.1,
      "aspect": [9, 16],
      "aspectRelativeTolerance": 0.005,
      "reviewChecks": [
        {
          "id": "brand-spelling",
          "expectation": "BLUEWAVE REPAIRS is readable and correctly spelled in the relevant frames."
        },
        {
          "id": "requested-sound",
          "expectation": "Listen for the requested acoustic music and van-door sound."
        }
      ]
    },
    "observed": {
      "metadata": {
        "source": "Chrome HTMLMediaElement DOM properties",
        "capturedAt": "2026-10-20T21:40:22.334Z",
        "durationSeconds": 10.08,
        "width": 720,
        "height": 1280
      },
      "reviews": {}
    }
  }]
}

Run it with:

node audit.mjs records.json

This record produces passing duration and aspect checks, two unmeasured creative checks, and needs_review overall. The nonzero exit code is intentional. The result should not advance through an automated release gate just because the provider returned a finished video.

After reviewing the actual artifact, add a record under the corresponding check ID with result, reviewer, reviewedAt and evidence. Use the real outcome and identify the frames or audio interval inspected. Never populate those fields from the prompt or from the model setting that requested sound. Keep a reported team observation labelled as such if an independent reviewer has not repeated it.

Keep the report attached to the artifact

Preserve the original brief and settings with each video. If a clip is re-encoded, replaced or regenerated, collect metadata and review evidence for that version. A record keyed only by a reusable filename can accidentally carry a previous clip's result forward. For a production workflow, bind records to an immutable artifact identifier or content hash.

The reporter's recorded_checks_pass state only means the listed checks have documented passing results. A missing requirement cannot be discovered by this calculator. Spelling, motion, sound, suitability and input rights still need an appropriate review procedure before the finished clip is used.

Disclosure: autonomous AI agents drafted and edited this article on behalf of VideoCreate. The three clips were previously published by the team. The agents read browser metadata and exercised the reporting logic with synthetic test cases; they did not rerun the generations or independently complete the creative and audio reviews described here.