Brand as Compile-Time Rules: Template Parameterization That Survives Agents

Brand guidelines PDFs are not runtime.

Agents do not reliably obey a paragraph that says "keep the logo clear of the lower third" when a model suggests a prettier crop. Humans do not reliably obey it at 1 a.m. either.

If video is source code, brand has to become something a compiler can reject — not vibes in a prompt prologue.

This final essay in the series is about template parameterization and compile-time rules: how SceneRok-shaped systems keep agents fast without letting them invent a new identity system every render.

Parameters are the API; rules are the type system

A useful template exposes a small API:

• Offer / headline / CTA strings
• Input footage references
• Voice choice
• Aspect ratio / length class
• Optional generative slots with allowed model sets

That API is what agents fill. Around it sits a type system of constraints:

• Duration must stay within [t_min, t_max]
• Logo lockup occupies a fixed window and safe zone
• End card required
• Certain generative providers disallowed for this brand pack
• Text must remain inside titled regions / grid areas

Parameters without rules produce infinite variety — including infinite off-brand variety. Rules without parameters produce museum pieces nobody can campaign with. You want both.

Why compile-time beats chat-time

Chat-time constraints ("please follow the brand guide") fail open. The model smiles and drifts.

Compile-time constraints fail closed:

• Missing lockup → compile error.
• VO longer than the picture window → compile error.
• Disallowed model id → compile error.
• Safe-zone collision → compile error.

Agents already understand fail-closed tools. tsc taught a generation of developers that rejection is kindness. Video should feel the same. Soft warnings are fine for taste ("contrast may be low"); hard errors are mandatory for identity and legal-adjacent placement.

Designing slots agents cannot smuggle past

Good slots are narrow.

• Prefer cta_url and price_text over freeform_endcard_html.
• Prefer an enum of approved voices over arbitrary voice strings when brand requires it.
• Prefer generative prompts that are wrapped — agent supplies product noun and mood tags; template owns camera language and negative constraints.
• Prefer grid areas (title, stage, lower-third, caption) so layout is structural, not absolute pixel hope.

Narrow slots reduce the search space. That makes agents stronger, not weaker: they optimize within a feasible set.

Human taste stays at the pin boundary

Rules catch structure. Humans (or brand reviewers) still catch soul.

Workflow that respects both:

1. Agent authors within the template API.
2. Compiler enforces rules.
3. Preview for timing.
4. Human pins generative keepers.
5. Variants fan out by changing parameters — not by forking the brand skeleton.

If every variant requires a new freehand timeline, you do not have a template. You have a graveyard of almost-sames.

Rules as code review surface

Because constraints live with the template source, PRs become brand governance:

• Diff shows a widened duration cap — brand lead comments.
• Diff shows a newly allowed model — production comments on cost/risk.
• Diff shows lockup timing change — design comments.

That is impossible when the "template" is a CapCut project plus a Slack thread. It is natural when the template is VidScript or @scenerok/sdk checked into git beside the product.

Multi-brand shops and agencies

Agencies need packs, not one global rule blob.

Conceptual layering:

• Studio defaults — technical limits (max duration class, required validate).
• Brand pack — lockups, fonts, color tokens, allowed models, safe zones.
• Campaign template — offer slots and narrative structure.
• Run parameters — this week's SKU list.

Agents should bind to a brand pack explicitly. Silent fallback to "studio default identity" is how you ship the wrong logo to the wrong client. Fail closed if the pack is missing.

We will not describe customer packs here. The layering idea is enough to steal.

Testing constraints

Treat rules like tests:

• Fixture scenes that must compile.
• Fixture scenes that must fail — missing lockup, overlong VO, illegal model.
• Golden structure snapshots for the happy path.

Run them in CI on template PRs. Agents that edit templates should run the same suite before opening a PR. This is boring. Boring is how brands survive automation.

Connecting the series

This post sits on top of the others:

• Browser pools keep preview/final reliable enough to trust the loop.
• Deterministic structure keeps rules meaningful.
• Two cost curves keep exploration affordable.
• SDK vs VidScript tells you which authoring surface holds the template.
• Wallets/audits tell you what each compliant render cost.

Without compile-time brand rules, agents accelerate off-brand entropy. With them, agents accelerate shipping.

Soft rules vs hard rules

Not every guideline deserves a hard error.

Hard (fail closed): missing mandatory lockup, duration outside legal/ad-length class, disallowed model, unsafe overlay on required disclaimer region, missing end card when template requires it.

Soft (warn): low-contrast text guesses, busy background behind caption, generative prompt missing a recommended keyword.

If everything is hard, agents thrash and humans disable the checker. If everything is soft, brand drifts. Label the severity in diagnostics so agents know what to fix first. Put severities in the template pack, not in an undocumented global.

Localization without forking identity

Parameterization shines when locale changes.

Keep constant: lockup timing, grid areas, motion grammar, allowed models.

Parameterize: strings, voice, maybe footage input per market.

Rule: translated VO must still fit the window — compile measures or bounds duration, fails if overflow.

Agents are excellent at filling locale tables. They are dangerous if localization is allowed to rewrite structure. Bind locale packs to the same rules as the base brand pack.

Escape hatches (rare, explicit)

Sometimes a campaign needs a one-off that violates a template rule. Do not teach agents to comment out checks.

Prefer an explicit override record: who approved, which rule, which revision, expiry. The override itself becomes auditable. If your system cannot express overrides, people will fork the template and never merge back — entropy wins.

Public essays should not invent a proprietary override DSL. The product lesson is enough: escapes must be louder than compliance.

Onboarding a brand pack

A practical sequence for a new brand:

1. Encode lockup media + safe zones.
2. Encode duration classes you actually ship.
3. Encode allowed generative providers / models.
4. Build one golden template with narrow slots.
5. Add must-fail fixtures.
6. Only then hand agents the keys.

Skipping to step 6 produces demos, not systems. SceneRok's editor + code path is meant to make step 4 pleasant; the discipline of steps 1–3 and 5 is on the team.

Closing

Prompt prologues are not governance. PDFs are not runtime. If you want programmable video that agencies and product teams can trust, put brand into parameters + compile-time rules, keep humans at the pin boundary, and let agents fill the API at speed.

That is the SceneRok shape: VidScript and SDK for authoring, generative models as functions, a compiler that can say no.

Start from templates and the editor at scenerok.com. Teach your agents the rules once. Make the compiler the enforcer every time after.