DEV Community: Nidheeshdas Thavorath

Observability for Generative Video Pipelines: Wallets, Audits, and Replays

Nidheeshdas Thavorath — Tue, 29 Sep 2026 04:33:41 +0000

Traditional video render farms taught us to watch queues, workers, and encode errors. Generative video adds a second economy on top: model calls with fuzzy latency, variable cost, and non-identical outputs.

If you treat that economy like "just another HTTP client," you will not be able to answer the only questions that matter to a team:

What did we spend?
On which scene revision?
Which function call produced this clip?
Can we replay the composition without paying for a new surprise?

At SceneRok we talk publicly about a token wallet that covers traditional render and generative calls, with an audit trail. This essay stays at the pattern layer: how to think about observability when video is programmable.

Three planes, not one dashboard

Collapse everything into a single "GPU busy" graph and you will misdiagnose forever. Split the problem:

Authoring / compile plane — script validity, generative resolves, pin decisions.
Execution plane — preview vs final jobs, browser/worker health, encode progress.
Commercial plane — wallet debits, per-call attribution, project/team rollups.

Signals cross planes, but alerts should name which plane broke. A model timeout is not a browser crash. A preview queue backup is not a wallet mischarge. Operators and agents need that vocabulary.

Wallets as productized metering

A wallet is not a spreadsheet. It is a user-visible budget with an append-only story.

Patterns that keep trust:

Debit at well-defined moments. Prefer "compile resolved this generative call" and "final job accepted" over ambient polling charges nobody can map to intent.
Attribute to a scene revision. Cost without revision id is trivia. Cost with revision id is engineering.
Separate exploratory spend from delivery spend in the UI even if one balance backs both — preview/generative exploration should feel labeled.
Show rough category breakdowns (generative vs compose/encode) without pretending sub-cent precision you cannot defend.

What not to do: silent retries that double-charge; "estimate" that never reconciles; mixing seat fees into the same line items as model calls without labels.

Audit trails agents can read

Humans skim. Agents parse.

An audit event worth emitting (conceptually) includes:

timestamp
project / scene / revision
actor (user, agent, CI)
action class (validate, resolve, pin, preview, final, refund/adjust)
resource class (model call, compose, encode)
high-level result (ok, user-error, transient, quarantine)
correlation id tying compile to later render

You do not need to publish your schema for the idea to be useful. You need the discipline: every billable or state-changing act leaves a breadcrumb.

Then agent skills can answer "why did this preview cost more than yesterday?" by reading structured history instead of hallucinating.

Replay vs regenerate

Observability without replay is just guilt with timestamps.

Define two verbs clearly in the product:

Replay composition — re-run preview/final on pinned artifacts and the same source revision. Should not invent new generative pixels.
Regenerate — intentionally re-invoke stochastic functions. Costs more. Changes art.

If your logs cannot tell you which verb a job used, your support channel will become archaeology. If your wallet cannot tell you which verb a debit paid for, your users will assume the worst.

This pairs with the deterministic-structure essay: composition is reproducible; assets re-roll only on purpose.

SLOs that fit generative reality

Classic render SLO: time-to-first-frame, time-to-complete, failure rate.

Add generative-aware SLOs:

Resolve success rate by provider class (qualitative monitoring — not a public league table).
Pin rate — fraction of accepted compiles that reuse pins vs fresh rolls (health of the iteration culture).
Mismatch reports — preview/final semantic disagreements filed by users.
Orphan spend — debits not tied to a surviving revision (should trend toward zero).

Page on execution-plane crashes. Ticket on commercial-plane anomalies. Teach agents to fix authoring-plane errors themselves before they burn finals.

Privacy and secrecy still apply

Observability loves payloads. Marketing blogs and shared dashboards should not.

Keep prompts and brand assets in access-controlled audit detail views. Export support bundles that strip secrets. Never paste real customer ledger lines into DEV.to. The shape of the trail is enough to teach; the contents are production data.

Same secrecy bar as the browser-pool essay: principles, not topology. You can say "quarantine sick workers" without naming hosts. You can say "correlate compile id to job id" without publishing your bus topics.

Practical starter checklist

If you are building a programmable video pipeline — or evaluating one — ask:

Can a user see generative vs render spend separately?
Can they name the revision that incurred a charge?
Can they replay without regenerating?
Can an agent parse why validate failed vs why a provider failed?
Do retries declare whether they are free continuations or new billable work?

If any answer is no, observability is still a slide deck.

Correlation ids beat folklore

When something goes wrong, teams invent stories: "the GPU was sad," "the model was weird," "preview lied." Correlation ids kill folklore.

Propagate one id from compile → preview lease → final job → wallet debit. When support asks "why is this invoice line here?", you jump the chain instead of grepping vibes. When an agent asks the same question via tooling, it gets a structured answer.

You do not need to expose the id scheme publicly. You need the habit: no billable side effect without a correlator.

User-facing vs operator-facing views

Ship two lenses:

Creator lens — plain language: what ran, what it cost in categories, whether pins were reused, what failed in authoring terms.
Operator lens — quarantine rates, acquire timeouts, provider transient classes, queue depth.

Creators should not see hostnames. Operators should not debug brand copy. Mixing the lenses produces either panic or silence. SceneRok-style products should bias the creator lens toward revision-centric narratives ("this compile resolved 2 generative calls; preview reused pins; final encoded revision abc").

Refunds, retries, and moral clarity

Money systems need ethics encoded as state machines.

Transient infra failure after debit authorization → continuation or credit, labeled.
User cancelled before work started → no charge.
User disliked art → that is regenerate territory, not a silent refund automaton.
Double-submit of the same final envelope → idempotent no-op, not two charges.

Write those rules down before the first angry email. Observability is how you prove you followed them.

What "good" looks like after a month

Qualitative targets, not fake percentages:

Creators can explain last week's spend in one paragraph using the audit UI.
Agents can avoid repeating failed resolves by reading error classes.
Finance stops asking engineering for CSV archaeology.
Preview/final mismatch tickets trend down because replay uses pins.

If none of that is true, more dashboards will not help — fix the verbs first.

Closing

Generative video without a wallet story becomes surprise invoicing. With a wallet but no audit, it becomes argument. With audit but no replay, it becomes expensive archaeology.

Wire the three together: meter deliberately, attribute to revisions, replay pins, regenerate on intent. That is how programmable video feels like shipping software — including the part where finance and engineering stop yelling past each other.

See the product framing on scenerok.com. Build your own pipelines with the same verbs even if your stack differs. The verbs travel.

Agents Writing Video: `@scenerok/sdk` vs VidScript

Nidheeshdas Thavorath — Sun, 27 Sep 2026 04:34:58 +0000

People ask a practical question once the demo lands: should my agent write VidScript or TypeScript?

The honest answer is the one on the public @scenerok/sdk README, expanded into engineering judgment:

Use	Language
Short promos, human edits, templates	VidScript (`.vid`)
Loops, branches, computed timing, agents	TypeScript + `@scenerok/sdk`

Both emit the same intermediate timeline for preview and render. That sameness is the feature. This essay is how to choose without cargo-culting either side.

VidScript: readable intent

VidScript is for when the video wants to look like a script.

Imports pull generative providers. Inputs declare footage you already have. Time ranges place layers on a clock. Compile-time slots resolve model calls before composition. Output sets container and destination.

Why humans like it:

You can review a diff in PR like copy, not like a graph of objects.
Brand and motion designers can learn the shape without adopting a full TS toolchain.
Templates stay legible: slots and parameters are obvious.

Why agents like it sometimes:

For linear launch reels, a DSL is less rope to hang yourself.
Fewer syntactic degrees of freedom means fewer invalid programs.
Diagnostics map cleanly onto lines of intent.

If the job is "15s reel, hero clip, VO, end card," start in VidScript. Do not open with a framework.

SDK: when the timeline is a program

@scenerok/sdk exists because some videos are data.

Examples that outgrow a tidy .vid:

40 SKUs → 40 end cards with computed durations from probed media
Branching explainer paths assembled from a CMS JSON
Grid layouts with areas filled by loop
Agent refactors that rearrange dozens of markers arithmetically

In TypeScript you get real control flow, real tests, real module imports, and the same toIR() exit. Public surface includes timeline construction, loadVideo / loadAudio probing helpers, text/audio factories, grid areas, transitions — see the npm README for the current API. Stay on that surface in articles; do not invent private methods for blog flair.

Agents already live in TypeScript. Giving them a first-class authoring SDK is how "write the launch video too" stops being a metaphor.

The meeting point: one IR, two authoring DX

If VidScript and the SDK drifted into different semantics, you would fork the product: preview lies depending on path; templates refuse to migrate; agents and humans cannot hand off.

So the rule is strict: authoring is plural; timeline meaning is singular.

Operational consequences:

Features land in IR semantics first, then in both frontends when relevant.
Validate before render — scenerok validate style checks apply to both (public CLI behavior).
Showcase examples can ship as .vid or .ts folders; forks should not surprise you at render.

This is the same lesson compilers learned decades ago: multiple languages, one machine model — here the "machine" is the timeline + render contract.

Decision guide for agent builders

Use VidScript when:

Duration is small and mostly linear.
A human must regularly edit the source.
You are parameterizing a template with a handful of slots.
You want the fewest ways to be wrong.

Use @scenerok/sdk when:

You are generating many related scenes from data.
Timing depends on probed media durations or arithmetic.
You need loops, conditionals, shared libraries.
The agent must unit-test pieces of assembly.

Use both in one shop when:

Humans tune a VidScript template for taste.
Agents expand parameterized campaigns in TS.
CI validates IR equivalence on golden fixtures (qualitative goal: same structure for same intent).

Pitfalls we see (and how to avoid them)

Pitfall: SDK for everything.

You get enterprise-shaped code for a six-second bumper. Prefer the DSL until it hurts.

Pitfall: VidScript with pretend-loops.

Copy-pasting twenty near-identical blocks is a smell. Migrate that scene to TS.

Pitfall: Generative calls without pins.

Either language will burn money if every agent pass re-resolves assets. Make pinning part of the workflow, not an afterthought.

Pitfall: Teaching agents only prompts, not validate/render.

The loop is edit → validate → preview → (maybe) final. Wire MCP/CLI skills to that loop; do not stop at "emit text."

Public example shape

From the SDK README, the flavor is intentional: build a timeline, assign clips to ranges, return toIR(). From the site, VidScript shows timed ranges and compile-time generative functions side by side with brand inputs. Cloneable showcase material lives in the public GitHub showcase — fork, change a string, re-render. That loop is the pedagogy.

How agents should navigate the choice

A good agent skill does not always emit TypeScript because TypeScript is familiar. It classifies the job:

Parse the brief for cardinality (one video vs N variants).
Detect computed timing needs (probe durations, arithmetic, branches).
Choose VidScript for linear single-shots; SDK for data-shaped campaigns.
Run validate; fix type/timeline errors before preview.
Pin generative results before proposing a final.

If your skill always scaffolds the SDK, you will get correct-but-heavy programs. If it always scaffolds VidScript, you will get unmaintainable copy-paste. The classifier is the product.

Hand-off between humans and agents

The sweet spot we see:

Human designs a VidScript template with clear parameters and brand constraints.
Agent fills parameters, generates variants, opens PRs with diffs.
Human reviews prompts and pins, not raw frames only.
Final renders happen on accepted revisions.

When the template outgrows declarative form, a human (or agent with a migration brief) ports the skeleton to @scenerok/sdk once — then the campaign scales in TS. Migration is a deliberate event, not a surprise rewrite mid-flight.

Testing video programs

You cannot unit-test taste. You can test structure:

Duration bounds and required layers present.
Brand lockup occupies the right window.
Forbidden models absent from compile plan.
Golden IR snapshots for template fixtures (high-level idea: same authoring intent → stable structure).

Keep tests on the IR/validate layer so VidScript and SDK share them. That reinforces the peace treaty: two frontends, one meaning.

What "public surface" means for this post

Everything above stays within what you can learn from scenerok.com, the npm README for @scenerok/sdk, and the public showcase. If an API is not documented there, do not teach it in GTM essays. Longevity beats insider flex.

Closing

Agents should not "prompt a video." They should author a program that compiles into one.

Pick VidScript when clarity wins. Pick @scenerok/sdk when computation wins. Refuse a world where those choices fork your renderer.

Install the SDK from npm, open the editor or CLI path on scenerok.com, and let the IR be the peace treaty between humans and agents.

Same Source, Two Cost Curves: Local Preview vs GPU Final

Nidheeshdas Thavorath — Wed, 23 Sep 2026 04:47:06 +0000

Every video tool eventually grows two buttons that mean different economic things: Preview and Export.

In timeline editors those buttons often hide divergent engines. Preview cheats. Export reinterprets. Someone notices during brand review when the fade is denser, the font thicker, the color a half-step off.

Programmable video only works if that divergence is a controlled contract, not an accident. At SceneRok, VidScript and @scenerok/sdk compile to one intermediate timeline. Local-style preview and GPU final are two executions of that same source — with different cost curves.

This post is about designing that split on purpose.

Cost curves, not vibes

Think in curves, not in absolutes.

Preview curve: optimize for iteration count. Agents and humans will hit this path dozens of times while chasing timing. Marginal cost per attempt should feel closer to "save file" than "order a render farm."

Final curve: optimize for delivery honesty. You pay more per run because pixels, codecs, and generative pins matter. You should run it when intent is stable — or when you need a client-facing proof.

If both paths cost like final, people stop exploring. If both paths cheap out like preview, people ship sketches. Hybrid execution is the name for keeping one source while admitting two budgets.

What must stay identical

Samness is not "bit-identical frames in preview." Sameness is semantic agreement:

Timing: a cut at 3.0s is at 3.0s in both paths.
Layering: z-order and occupancy match.
Generative pins: the asset you resolved at compile is the asset both paths use unless you explicitly re-roll.
Brand rules: safe zones and lockups cannot "approximately" apply.

Where paths may diverge — and should say so — is fidelity class: resolution proxies, shader precision, color management edge cases, encode ladder. Preview can be representative. Final is authoritative. Say that in the product UI, not only in an engineering wiki.

Where money actually goes (qualitative)

Without publishing a fake invoice:

Authoring — cheap. Text edits. Agent rewrites.
Compile / generative resolves — variable. Model calls dominate when you invent new footage, VO, or music. Pin aggressively once you like a take.
Preview composition — should be the bargain bin relative to final: enough fidelity to trust timing.
Final composition + encode — the bill you accept when shipping.

A common failure mode in AI video stacks: every scrub silently re-rolls a model. That couples the preview curve to the generative curve and bankrupts curiosity. Keep generative resolution explicit and mostly compile-time, then let preview/final reuse artifacts.

Local preview as a product promise

"Local" here means close to the creator loop — editor-adjacent, low ceremony — not a claim about which chassis runs which binary.

The promise:

Fast enough to keep flow state.
Faithful enough that timing decisions survive final.
Failure modes that explain scene problems vs machine problems.

The anti-promise:

Silent fallback from accelerated paths to software paths without labeling the delivery class.
Preview that invents different assets than final.
A preview that can only run on a heroic laptop configuration.

If you also offer browser-class frame capture for some workloads (see the pool essay), apply the same contract language: lease intent is preview or final; SLOs differ; source does not.

GPU final as a delivery class

Final is where you spend for honesty: stable drivers, predictable color, encode settings you would show a client, headroom for heavy shaders and long timelines.

Patterns:

Queue finals; interactive-ize previews. Do not block the editor thread on a master encode.
Idempotent finals. Same pinned inputs + same source revision → safe to retry after infra blips without creative drift.
Artifact permanence. Keep the compile outputs you paid for. Re-encode should not imply re-imagine.
Clear progress. Users forgive duration; they do not forgive opaque spinners.

You do not need to name your GPU vendor in a blog post to teach this. You need to teach teams to stop treating export as a surprise boss fight.

Agents change the shape of the curves

Coding agents do not get bored. They will preview in a loop. That is wonderful for product velocity and dangerous for an uncached generative bill.

Design for agents explicitly:

Validate and preview against pinned assets by default.
Require an intentional action to re-resolve stochastic functions.
Prefer patching parameters in source over regenerating the universe.
Emit compile diagnostics agents can read — duration conflicts, missing inputs — so they fix structure before they burn finals.

Humans need the same defaults. Agents just hit the foot-gun faster.

A practical decision table

Situation	Prefer
Nailing VO against B-roll timing	Preview, pinned assets
Trying three alternate model prompts	Re-resolve only those slots, then preview
Client review / ad upload / launch	Final
Suspected preview/final mismatch	Pixel-compare offline; fix engine agreement; do not "nudge" the timeline by eye forever
CI / PR checks on templates	Validate + cheap preview class, not full final

Caching without self-delusion

Hybrid stacks live or die on caches. The wrong cache key couples unrelated work; the right one makes preview feel free.

Useful keying ideas (conceptual — not our internal schema):

Source revision of the timeline program.
Resolved asset set (pins), not the prompt text alone.
Delivery class (preview vs final) so a cheap proxy never masquerades as a master.
Capability class (accelerated vs software) so you do not "hit cache" across incompatible paint paths.

Invalidate on purpose when the user re-rolls a slot. Do not invalidate the universe because one text overlay moved. Composition caches and generative caches should be layered: moving a title should not re-invoice an imagine call.

Measuring the curves without fake dashboards

You do not need vanity charts in a blog. You do need internal honesty:

How many preview iterations per final?
What fraction of finals re-used compile artifacts vs re-resolved models?
How often do users complain about preview/final mismatch?

If iterations-per-final is ~1, your preview path is too expensive or too untrustworthy. If mismatch complaints are non-zero, fix agreement before you buy more GPUs. Hardware cannot patch a semantic fork.

Team workflow that respects the curves

A pattern that works for small teams and agencies:

Author in VidScript/SDK from a brief.
Resolve generative slots deliberately; pin keepers.
Preview until timing and copy land.
One final for stakeholder review.
Parameterize variants (aspect ratio, CTA, locale) from the same source — prefer re-compose over re-imagine.

Agents fit between steps 1–3 if you give them validate/preview tools. Humans still own taste at the pin boundary. That division of labor is the point of programmable video.

Closing

Same source, two cost curves is how programmable video stays both playable and shippable.

Fork the engine accidentally and you recreate the old NLE tax. Fuse the costs accidentally and you recreate the AI-bill tax. Hold the line: one VidScript/SDK truth, explicit generative pins, preview for learning, final for delivery.

Feel it in the product at scenerok.com. Spend curiosity on structure. Spend credits on purpose.

Stochastic Assets, Deterministic Structure: Why Video Must Be Code

Nidheeshdas Thavorath — Sun, 20 Sep 2026 04:41:12 +0000

Frontier video models are astonishing. They are also stochastic.

Same prompt, different day, different seed policy, different upstream weights — you get a cousin of the clip you loved, not a byte-identical twin. That is fine when you are exploring. It is hostile when you are shipping a product launch on Thursday and legal wants the logo lockup where it was on Tuesday.

SceneRok's bet is simple enough to say in one line: let models invent assets; let a compiler own structure.

This essay is about why that split is not marketing language. It is an engineering boundary.

Two different jobs got smashed into one UI

Most "AI video" products optimize for a single box: describe what you want, receive a surprise. Surprise is a feature when the job is moodboards.

Shipping video has a different job description:

Beat timing that matches a VO script
Brand elements that never drift
A CTA that appears at 0:12.0, not "somewhere near the end"
A template you can re-run when the price changes
A history you can diff instead of final_v7_reallyfinal.mp4

Those requirements are closer to compiling a program than to chatting with a model. If you force one mega-prompt to invent both the pixels and the edit grammar, you are asking probability to do bookkeeping. Probability is bad at bookkeeping.

What "deterministic structure" actually means

Deterministic does not mean "the generative clip never changes." It means:

Given the same resolved inputs and the same timeline source, the composition is reproducible.

Inputs include: placed media files, already-generated assets you chose to pin, fonts, timing expressions, shader choices, audio mix parameters. The compiler's job is to honor them without creative improvisation.

Stochastic steps still happen — but they happen in a named, bounded place: a function call at compile time. imagine(...), tts(...), music(...). The return value becomes an asset reference. After that, the timeline treats it like any other clip.

That is the same mental model as: fetch a dependency, then build. You do not want npm install to randomly rewrite your package.json graph every night. You especially do not want your video editor to.

Why the source of truth must be code

Chat transcripts are terrible source control.

They are linear, ambiguous, full of "make it punchier," and nearly impossible to merge across teammates. Proprietary project files are better for humans with mice — until an agent needs to change twenty parameterized end cards and open a PR.

Code gives you:

Diffs — see that only the VO string and the CTA URL changed.
Review — brand can reject a prompt change without scrubbing a timeline.
Reuse — templates with slots, not duplicated projects.
Automation — agents already speak TypeScript and DSLs; they do not speak CapCut.

In SceneRok, short declarative work lives in VidScript. Heavier branching and data-driven timing lean on @scenerok/sdk. Both emit the same intermediate timeline for preview and render. The public docs are enough to understand the shape; you do not need our private compiler guts to use the idea.

Compile-time generation vs render-time surprise

A useful pattern in programmable video: resolve generative work at compile, then render.

Why compile-time?

You can log what was called, with what parameters, against a wallet.
You can fail before you spend a long encode discovering the model timed out.
You can reuse a resolved asset across preview and final without re-rolling.
You can pin: "this clip is good — stop resampling it."

Render-time generation (invent frames while encoding) blurs cost, attribution, and reproducibility. Sometimes you want live generative effects. For launch reels and brand templates, you usually want the opposite: known assets in, deterministic mux out.

Agents need constraints more than vibes

When we say "agents author video," we do not mean "paste a novel into a prompt box." We mean: an agent edits a script under rules — duration caps, safe zones, allowed models, required end card — then asks the compiler to accept or reject.

That workflow only exists if structure is explicit. A stochastic all-in-one clip cannot tell you which rule failed. A compiler can: timing overlap, missing input, brand lockup not placed, generative call not allowed in this template.

Failure messages are product surface. Treat them like type errors, not like "the muse said no."

What we refuse to pretend

We will not claim generative video is "solved" by better prompting alone. Models will keep improving. Structure will still matter.

We will not publish fake reproducibility percentages. The qualitative claim is enough: composition is deterministic; assets are pinned or re-rolled on purpose.

We will not dump IR schemas here. You can ship the idea with a readable .vid file and a public SDK.

A concrete mental model (public surface)

Think in layers:

Intent — brief, brand pack, offer parameters.
Authoring — VidScript or SDK, possibly agent-written.
Compile — generative functions resolve; timeline IR solidifies.
Preview / final — same source, different cost curves (next essay).

If you change a model prompt, you expect new pixels in that slot — not a reshuffled edit. If you change a time range, you expect the edit to move — not a new personality from the model. That separation is the whole point.

Pinning, seeds, and intentional re-rolls

Teams new to programmable video often ask for "full determinism including the model." That is the wrong ask. Model providers change. Safety filters change. Even with a seed parameter, cross-provider identicality is a fantasy.

What you can operationalize:

Pin by content address or asset id once a human (or eval) accepts a take.
Re-roll on purpose with a new compile when exploring.
Never silently re-roll during preview scrub or final retry.
Record the function arguments you care about for audit — prompt text, model id, duration request — alongside the chosen asset.

Seeds are a hint, not a contract. Pins are a contract. Teach your agents the difference or they will "helpfully" regenerate your hero shot every PR.

Diffs as a creative review surface

Once structure is code, review rituals change.

Instead of scrubbing a 40-track timeline looking for what moved, you read a diff:

VO string changed → expect audio slot to change; picture timing should not.
model: id changed → expect that generative slot to change; brand lockup layer untouched.
End-card URL parameter changed → expect a localized variant, not a new edit grammar.

This is how agencies hand off to clients without exporting a museum of MP4s. This is how founders accept an agent's PR at 1 a.m. without opening an NLE. The compiler is what makes the diff trustworthy: if the timeline source did not change, composition should not invent new structure.

Template libraries beat prompt libraries

Prompt libraries age like milk. Model ids churn. Phrasing that worked in March fails in September.

Template libraries age like software. You version a .vid or .ts module with parameterized slots: offer, price, voice, footage inputs. Generative calls sit in named holes. When a provider improves, you change one function call site — not forty chat bookmarks.

SceneRok's public showcase pattern (brief + metadata + source per folder) is intentional pedagogy: the unit of reuse is a program, not a prompt scrapbook.

Closing

Stochastic assets are how we get beautiful raw material in 2026. Deterministic structure is how we ship.

If your stack cannot say which parts are allowed to surprise you, every re-render is a negotiation with entropy. Put surprise inside functions. Put the edit in code. Diff it. Fork it. Reproduce it.

That is programmable video. Try the editor and agent path at scenerok.com — and keep your lottery tickets in the asset slots, not in the timeline grammar.

CapCut nights vs code-shaped video

Nidheeshdas Thavorath — Fri, 18 Sep 2026 18:37:06 +0000

CapCut is honest about what it is: a fast human editor. The tax shows up when the same launch needs a second offer, a third aspect ratio, and a fourth “final” because the CTA moved. You are not bad at editing. The tool never stored the campaign as something an agent can patch.

Remotion-class tools (and peers like Clipkit) store the edit as code or schema. That is the right leap for scale and CI. Pure compose still leaves generative assets and brand lock as someone else’s problem — or another prompt box bolted on the side.

SceneRok sits in the third lane: agents author VidScript or @scenerok/sdk, generative models run as compile-time functions, brand templates and timing stay in the shell. You get novelty where models help and a structure CapCut cannot version.

Three jobs, three tools

CapCut — one-off polish. Best when a human is finishing a single cut. Worst as a system of record for multi-variant campaigns. Revision tax is the product.

Remotion / Clipkit-class — compose at scale. Best when the timeline is deterministic assembly and you want code or JSON as source. Weakest when the ask is “generate the hero, keep brand, ship ten variants” without a generative-compile story.

SceneRok — agent + gens + brand shell. Best when coding agents already ship the product and should ship the launch narrative too. Soft edges: you still need taste and a brief; structure does not invent strategy.

Use CapCut to polish a hero when you must. Use compose infra when video is pure layout math. Use SceneRok when the failure mode is brand drift and CapCut nights after every agent-speed release.

Soft CTA

Free preview and BYO assets on scenerok.com; pay hosted finals only. Rank 1 covered campaign consistency; Rank 2 covered the agent path. This one is the positioning map — pick the lane that matches the tax you are actually paying.

Your agent shipped the feature. Why is the launch reel still in CapCut?

Nidheeshdas Thavorath — Fri, 18 Sep 2026 18:31:47 +0000

Your coding agent just landed the PR, updated the changelog, and maybe even opened the docs page. Then someone — usually you — opened CapCut to cut the launch reel by hand.

That mismatch is the whole problem. The product moved at agent speed. The video still moves at timeline speed.

SceneRok is built for the case where the same agents that write code should also write the launch video as source: VidScript or @scenerok/sdk, generative models as compile-time functions, a deterministic compiler for structure. This is a walkthrough of that path for people who already live in Claude, Cursor, Aider, OpenCode, or Codex — and why it beats both “one black-box generate_video MCP call” and another night of CapCut.

The gap after the merge

Shipping software with agents is getting boring in a good way. Shipping the announcement is not. You still need a fifteen-second cut that hits brand, timing, and a CTA on the right beat. CapCut can polish one take. It does not give you a versionable source the agent can patch when the offer changes at 11pm.

Black-box video MCPs feel closer to the agent loop until the first failure. Wrong aspect ratio. Logo too small. Brand colors off by a hair. The model gave you a clip; it did not give you a program you can fix. You regenerate and hope. That is the same lottery as one-shot campaign tools, just invoked from the terminal.

Four steps that look like software

1. Brief. Same as a ticket: audience, length, offer, must-show product shot, brand constraints. Keep it in the repo next to the feature if you can.

2. Agent authors source. For a short linear reel, VidScript stays readable — time ranges, text, VO, compile-time slots. For loops, SKU grids, or timing derived from probed media, the agent writes TypeScript with @scenerok/sdk. Both compile to the same intermediate timeline. Humans can still edit a .vid template without learning a framework; agents that need control flow stay in TS.

3. Compile. Generative plugins resolve as functions inside the script — image/video/TTS calls at compile time, not a side chat. Structure (duration, overlays, CTA placement, brand rules) stays with the compiler. Same source and same inputs should reproduce.

4. Preview, then hosted final. Preview is free; bring your own assets if you do not want model generation. You pay when you burn a hosted final render. That matches how builders already think about compute: iterate cheap, pay for the artifact that ships.

One real failure mode

An agent once emitted a clean-looking reel that was 16:9 for a Stories placement and skipped the brand lockup because the brief only said “make it punchy.” In a CapCut world you notice in export and re-edit. In a black-box MCP world you re-prompt. In a source world you fail validation or a template rule: wrong aspect for the target, missing lockup slot — then the agent patches the script and recompiles. The failure becomes a diff, not a vibe.

That is the contrast that matters. generate_video({ prompt }) returns media. VidScript / SDK returns a program. Programs get reviews, fixtures, and retries that do not erase everything that was already correct.

CapCut vs black-box MCP vs source

CapCut wins when you need one human polish pass. It loses when the same reel must come back next sprint with a new offer and the same brand shell.

A generate_video MCP wins on speed to first pixels. It loses when the failure is structural — aspect, lockup, CTA beat — because there is nothing to open except a new prompt.

Source wins when the agent is already your coworker. The brief lives in git. The script is reviewable. A bad compile is a failed check or a small patch, not a full creative restart. SceneRok’s generative-compile path is that middle: novelty in the model calls, brand and timing in the shell.

Soft next step

If your agents already ship code and you are still hand-cutting launch cuts, try the structure-first path: free account and preview on scenerok.com, BYO assets optional, pay only for hosted finals. Point Claude, Cursor, Aider, OpenCode, or Codex at the public skills/CLI and a brief in-repo. The goal is not a prettier one-shot — it is a launch reel you can fork when the feature ships again next week.

Why one-shot AI video breaks campaigns

Nidheeshdas Thavorath — Thu, 17 Sep 2026 15:49:47 +0000

You ship the first clip and it looks sharp. Product sits right, light is flattering, the CTA lands. Then you need seven more for the same campaign — different aspect ratios, a second offer, a new hook — and by clip eight the brand looks like it hired a different agency every night.

That is not bad luck. It is what one-shot generation does when you treat every render as a fresh lottery ticket.

One-shot means no shared structure

One-shot tools are good at a single impressive artifact. A campaign is not a single artifact. It is a family of variants that have to feel like siblings: same product silhouette, same grade, same spokesperson energy, same CTA timing even when the copy changes.

When each variant starts from a new prompt with no durable structure underneath, drift shows up in the places marketers notice first — light temperature, product shape, face identity, type hierarchy, when the offer appears. You can paper over one miss in CapCut. You cannot paper over a whole matrix without paying a revision tax that eats the week.

What teams try (and why it still hurts)

The usual mitigations are reasonable and still incomplete. Lock seeds. Shrink the batch. Anchor with image-to-video. Generate stills, then polish in CapCut. Each of those reduces variance for a moment. None of them give you a reusable shell that says: this is the brand frame, this is where the product lives, this is when the CTA hits — and the generative model only fills the slots that are allowed to move.

Seed control helps when the model path actually respects it, which is uneven across providers and modes. Smaller batches just slow the discovery of drift; they do not define what must stay constant. Image-to-video anchors the first frame and still lets motion, grade, and product silhouette wander by beat four. CapCut can rescue a hero cut. It cannot be the source of truth for twenty localized variants without turning someone into a full-time continuity editor.

So you end up with a timeline museum: final_v3, final_v3_safe, final_v7_reallyfinal. CapCut is excellent at human revision. It is a terrible system of record for campaign structure.

A better split: novelty in assets, determinism in the shell

Campaign-ready AI video needs two different jobs done well.

Generative models should own novelty — the product hero in a new setting, a fresh B-roll beat, a voice line you did not record in a booth. Structure should own everything you cannot afford to reroll: brand rules, safe areas, duration, offer timing, aspect variants, CTA placement.

If you invert that split, you feel it immediately. Ask a timeline tool to invent fresh product photography and you wait on humans or a side channel. Ask a one-shot model to keep CTA timing and pack hierarchy identical across ten exports and you will babysit every render. Campaigns want both jobs, explicitly assigned.

That hybrid is the point. Pure one-shot hopes the model remembers your brand. Pure timeline tools remember your brand only as long as a human re-edits it. The useful middle is: generative calls as functions inside a scripted structure the compiler can reproduce.

How SceneRok maps to that

SceneRok treats the edit as source. Agents (or you) write VidScript or build the same timeline through @scenerok/sdk. At compile time, generative plugins can resolve assets — image and video models through providers like xAI or Cloudflare Gateway, TTS and music where you wire them — while templates and brand rules keep the shell honest. Same source in, same composition out, even when a slot’s media is newly generated.

The practical win for campaigns is boring and valuable: one structured source can fan into two aspects or two offers without hand-rebuilding the timeline. You change parameters and allowed generative inputs; you do not reinvent light, layout, and CTA timing from a blank prompt.

Compose-infra tools (Remotion for React-as-video, Clipkit for schema-to-GPU composition) are strong when the job is deterministic assembly. SceneRok’s wedge is generative-compile plus brand templates: novelty inside a locked shell, not another prompt box and not “re-open CapCut for every SKU.”

Proof sketch (no fake metrics)

Take a launch template with locked brand chrome and a CTA beat at a fixed time. Variant A and variant B swap offer copy and regenerate only the hero slot. Export 9:16 and 1:1 from the same source. The point is not a leaderboard number — it is that the family still looks like one campaign after the tenth change, because structure was never left to chance.

Soft next step

If you are stuck in reroll loops for multi-variant ads, try structure-first: free account and browser preview on scenerok.com, bring your own assets if you do not want model generation, and pay only when you burn a hosted final render. Agents can author VidScript in Cursor or Claude; humans can stay in the editor. The goal is campaign-ready consistency — not one lucky clip.

Warm Browsers, Cold Frames: Engineering a Reliable Preview/Render Browser Pool

Nidheeshdas Thavorath — Wed, 16 Sep 2026 14:07:44 +0000

If you are building programmable video, at some point you stop arguing about timelines in the abstract and confront a duller problem: something has to paint the frames. Not a marketing-site screenshot, but a composition surface that respects timed layers, fonts, shaders, and motion that is supposed to match what the editor showed — and then hand those frames to an encoder. Chrome-class browsers are good at that work. They are also good at failing in ways that look healthy from a distance: out-of-memory kills, GPU process flaps, hung tabs, contexts that still answer a ping while painting black.

At SceneRok we treat video as source code. Agents and humans author VidScript or build timelines through @scenerok/sdk; generative calls can resolve at compile time; a compiler owns structure so the same inputs produce the same edit. None of that removes the need to draw. This piece is about the pool patterns that sit under preview and final render when the drawer is a real browser. I am sticking to patterns on purpose. You will not get an inventory of our pipes, pool sizes, or host topology — those go stale, and they are not the interesting part anyway.

Why keep browsers warm

The clean mental model is one browser per job: launch, load the scene, capture, kill. It is clean until every request pays cold start — process bring-up, profile init, GPU or software raster path, fonts, first paint — before anyone can answer "does this cut look right?" For agent-authored video that question is the product loop. People and agents iterate; if each scrub feels like waiting for a machine to boot, they stop iterating.

So you keep browsers warm. Warmth buys launch cost and introduces a harder problem: a warm browser is shared, privileged, and sticky with state. The design question is how to reuse it without yesterday's job leaking into today's.

Isolation before clever reuse

Slowness is annoying. Cross-job leakage is worse. Cookies, cached media, service workers, localStorage from another tenant, a WebGL context that never quite recovered — any of that quietly destroys the reproducibility story you sold when you said the edit was deterministic.

In practice that means one job gets one logical browser context, preferably a fresh profile or a hard reset rather than another tab on a shared profile, because tabs share more than people remember. It also means you should not trust the page's ready events alone; they fire early. Paint something you control, check a pixel or DOM invariant you understand, and only then start the capture clock. Teardown is the same story in reverse: graceful close is nice when the renderer is healthy, and useless when it is wedged, so hard kill with a timeout is part of the design, not an embarrassment. Media caches deserve the same suspicion. Prefetch helps performance and also smuggles assets across scenes unless you scope or wipe them between leases.

People hear "isolation" and think security review. For programmable video it is also correctness. If the pool leaks state, you are debugging ghosts while claiming the compiler is deterministic.

Leases, not immortal workers

A warm pool is not a promise that a browser lives forever. Treat reuse as a lease: take a browser that passed the last health check, bind it to a job id and a wall-clock deadline, run capture inside that deadline, and release it only after reset succeeds — otherwise quarantine it.

Quarantine is the part operators skip when they are optimistic. A browser that crashed mid-encode, blew GPU memory, or spent too long in "almost done" should not return to the hot set because someone hopes the next job will be fine. Mark it sick, bring up a cold replacement, and watch how often that happens. Quarantine rate tells you more about pool health than average frame time.

Even when preview and final share code paths, their policies should differ. Preview exists for latency and representative fidelity; final exists for pixel honesty and encode quality. If you shove both intents through one undifferentiated queue, you get slow iteration for people who are exploring and flaky masters for people who are shipping.

Budgets instead of hope

In browser capture, timeouts are not a config afterthought. They are how you keep a hung GPU path from owning the machine. You want stacked budgets: how long you wait to acquire a healthy browser, how long load may take, how long until first meaningful frame, how long the stream may stall once it has started, and a hard ceiling so nothing runs forever because a 4K job is "almost finished."

When a budget trips, recovery should be boring. Abort, record a high-level reason code (not a memory dump in a blog post), recycle the browser, and retry automatically only when the failure class looks like a transient worker problem. A bad scene input and a poisoned warm worker are not the same event. Retrying everything without classification is a good way to amplify an outage.

Crashes you can see vs crashes you ship

Browsers crash. GPU subprocesses disappear while the parent still looks fine. If supervision only asks whether the top process is alive, you will eventually ship black frames with a green health check.

What holds up in practice is a heartbeat on meaningful progress — frames actually produced — and a watchdog that does not live inside the stuck capture loop. After a crash, quarantine and replace cold rather than hot-patching a mystery. Jobs should be restartable under the same id from a known checkpoint when you have one, so a mid-flight failure does not force you to pretend the whole creative pipeline never ran.

That last point matters more for SceneRok than for a pure compositor. Generative assets can already be resolved and stored at compile time; composition happens after. A browser dying during frame capture should not automatically re-roll every model call if the compile artifacts are durable. Keeping those stages separate is reliability and cost control at once.

Hardware paint vs software paint

Headless Chrome will paint without a real GPU, usually through software rasterization. That path is useful in constrained environments and expensive for motion-heavy scenes. Preview can bias toward speed if timeline timing stays honest. Final should bias toward the path that matches creative intent, and if you silently fall back from hardware acceleration, say so — capability detection beats wishing. Preview and final are not identical pipelines; say which one is representative and which one is authoritative, and treat silent disagreement on opacity, font hinting, or blend modes as a product bug waiting for a brand review.

Same source, different job

Programmable video only works if one source drives both experiences. For us that is VidScript or the SDK compiling to the same intermediate timeline; the browser pool is machinery behind that contract. Preview's job is fast feedback and clear failure. Final's job is delivery quality, transient retries where they help, and a clear stop when they do not. If every request is treated like a master, agents cannot explore. If every request is treated like a disposable sketch, clients cannot ship. The lease has to carry intent.

What we actually watch, without dressing it up as a benchmark post, is acquire latency people feel in the editor, crashes users never see because quarantine worked, and whether preview timing still agrees with final timing. Pool sizes and frame-time charts do not belong here; they rot.

Closing

A reliable browser pool is not "Chrome on a server." It is careful reuse of crashy, GPU-adjacent work: isolate per job, warm without lying to yourself about state, put real budgets on every stage, quarantine sickness, and keep preview and final as different contracts over the same creative source.

That is how programmable video starts to feel like software — people and agents iterating on code — instead of a cold boot every time someone scrubs the timeline.

If you want the product side of this (editor, CLI, agents writing VidScript), start at scenerok.com. The pool should stay boring. The videos should not.

Stop Paying CapCut Nights for Structure You Could Compile Once

Nidheeshdas Thavorath — Mon, 14 Sep 2026 05:20:31 +0000

Your coding agent shipped the feature before lunch.

By dinner you were still in CapCut, nudging a caption three frames left so it wouldn't collide with the logo.

That is not a creativity problem. It is a cost structure problem. You are paying human time — and generative credits, when you use them — for structure that should be reusable, while burning both on every tiny revision.

This post is an honest look at what hand-editing launch and social video actually costs for indie SaaS founders, novice creators, and small agencies — and how programmable video (VidScript + a deterministic compiler) changes the equation. No fake case-study invoices. Where I use numbers, they are labeled examples so you can swap in your own rates.

I'm building SceneRok (scenerok.com) for people who already live in Cursor or Claude and are tired of video being the one asset that refuses to behave like software.

What you are actually paying for in CapCut

Break a "simple" launch reel into cost buckets. Ignore vanity metrics. Look at repeat work.

1. First-cut labor

Someone — you, a VA, a freelancer — imports screen recordings, picks B-roll, lays VO or captions, matches a beat, exports. For a 15–30s vertical, that is often hours, not minutes, the first time. Agencies bill this as project time. Founders pay in calendar nights.

2. Revision tax

"Change the CTA." "Swap the product shot." "Make a LinkedIn cut." In a timeline editor, each revision reopens the project. Timing drifts. Someone re-checks the brand lockup. You re-export. The revision tax is why final_v7_reallyfinal.mp4 exists.

3. Variant multiplication

One hero idea becomes: 9:16 for Reels/TikTok/Shorts, 1:1 for feed, 16:9 for YouTube/landing, maybe a 6s bumper. In CapCut that is either multiple projects or a fragile nested edit. Cost scales roughly with variants × revision rounds, not with "how clever the idea was."

4. Credit burn without reuse

If you also use prompt-to-video tools for B-roll or hero shots, you pay per generation. When the edit is not reusable, a failed timing pass often means regenerating assets you already liked — or worse, regenerating because you cannot pin the old clip into a stable structure. You burn credits on surprise, then burn hours trying to force that surprise into a brand system.

5. Opportunity cost

While you scrub, your agent is idle on the video path. The same brief that produced a PR could have produced a script — if video were code.

None of this means CapCut is "bad." It is excellent at exploratory cutting. The cost problem shows up when you need the fifteenth on-brand variant, not the first pretty clip.

Example math (illustrative — replace with your numbers)

Assume you are a founder who values your time at $75/hour (pick your number). An agency might use billable rates of $100–150/hr for junior edit; the shape of the math is the same.

Work item	CapCut-style path (example)	Compile-once path (example)
First 20s launch reel	3 hrs edit = $225 labor	Agent authors VidScript from template + brief; you review 20–40 min = ~$25–50 labor + generative credits for assets you actually generate
CTA / offer change	30–60 min reopen + re-export = $37–75	Edit a string / param; recompile = minutes
Three aspect ratios	+1–2 hrs or separate projects = $75–150	Same source, different output specs = near-zero extra edit labor
Five SKU variants	Often ~5× first-cut pain if templates are weak	One template; five param sets; agent loop fills slots

Labeled caveat: generative model calls still cost money. SceneRok uses a unified token wallet for traditional render and plugin calls (Grok Imagine, Cloudflare AI Gateway models, ElevenLabs, etc.). The ROI claim is not "video becomes free." It is: stop paying senior-human rates for structure that a compiler can enforce, and stop re-burning credits because the edit has no source of truth.

If your CapCut night is "fun creative exploration," keep it. If it is the blocker after every ship, the table above is your real P&L.

Where prompt-to-video quietly increases cost

One-shot prompt tools optimize for a single beautiful output. Product and agency work optimize for control across a family of outputs.

When structure lives only in a chat transcript or a proprietary project file:

You cannot diff last week's reel against this week's.
An agent cannot safely "change the offer" without re-deriving timing.
Brand lockups are tribal knowledge, not enforced constraints.
Credit spend has no audit trail tied to a reproducible build.

So teams do the rational thing: they regenerate. Credits go up. Trust in the pipeline goes down. Someone opens CapCut again "just to fix the end card."

Programmable video flips the dependency: models fill slots; the script owns structure. Stochastic generation, deterministic composition. You pay for new assets when the creative changes — not every time the CTA string changes.

The compile-once cost model (qualitative)

SceneRok's loop, in cost language:

Invest once in a template — timing, type system, logo safe zones, VO windows. This is front-loaded cost (human taste + brand rules).
Parameterize — {{hero}}, {{offer}}, {{cta_voice}}. Humans or agents fill slots.
Generate only what you need — xai.imagine(), cf.imagine(), xai.tts(), eleven.music() at compile time, logged against the wallet.
Recompile for variants — aspect ratio, duration trim, SKU copy. Structure does not get reinvented.
Agent loops cheaply — Cursor/Claude edits the .vid or SDK source the way it edits TypeScript. Review is a diff, not a scrub.

Labor shifts from timeline craft per variant to template craft + review. Credit spend shifts from regenerate to fix structure to generate to fill intentional slots.

That is the ROI story. It is boring on purpose. Boring is what scales.

Agency and creator workflow (same economics, more volume)

If you run a small agency or creator shop, CapCut cost shows up as margin death on revisions and brand inconsistency across juniors.

A workable programmable workflow:

Senior locks the brand template (the expensive taste).
Briefs become parameter tables (offer, hero asset URL, VO script, CTA).
Agent or junior fills params; compiler produces cutdowns.
Client feedback maps to field changes, not "start over."
Audit trail shows which generative calls ran for which client — useful for billing and for "why does this look different."

Batch launch cutdowns stop being a hero weekend. They become a job that finishes while you review a PR. Brand consistency is a property of the template, not a hope that everyone remembered the margin rules.

For novice creators: you are not learning After Effects on day one. You start from system templates in the web editor, then drop into VidScript when you need precision — the same progression as "use a component library before you write your own design system."

When CapCut (or a prompt app) is still the right spend

Be honest about non-fits:

One-off surreal clip for fun → consumer prompt tool.
Documentary-style story edit with heavy human performance timing → traditional NLE.
First exploration of a brand's motion language → timeline play is still valuable.

SceneRok is for the wedge where shipping volume + brand constraints + agent-native teams collide. If that is not your week, do not force it.

A practical way to measure your own ROI this month

Before switching tools, measure one week:

Hours spent in CapCut (or equivalent) on launch/social variants.
Number of revision rounds after "first export."
Generative credits spent that were thrown away because timing or brand failed.
Variants you wanted but skipped because edit cost was too high.

Then run one campaign with a template + agent-authored script: same brief, count hours and credits again. Compare cost per accepted variant, not cost per pretty first draft.

If the second number is not clearly better for your rates, keep your current stack. If it is, the asymmetry you feel after every code ship has a name: you were paying structure prices for every copy change.

Soft CTA

SceneRok is programmable video: agents write VidScript; generative models run as functions; a deterministic compiler ships the edit.

Product: https://scenerok.com
Agent path: CLI + MCP + skills for Claude, Cursor, Aider, OpenCode, Codex
Examples: github.com/nidheeshdas/scenerok-showcase

Fork a showcase source, change a parameter, recompile a variant. Or open a Product Launch template and treat the first CapCut night you skip as the start of the ROI spreadsheet.

— Nidheeshdas Thavorath (@nidheeshdas_)

SceneRok · scenerok.com

Why Your Coding Agent Should Write the Launch Video Too

Nidheeshdas Thavorath — Wed, 09 Sep 2026 17:16:28 +0000

Your agent just shipped a feature, opened the PR, and drafted the changelog.

Then you opened CapCut.

That gap — software that moves at agent speed, marketing video that still moves at timeline speed — is the wedge SceneRok is built around. We treat video the way modern teams already treat apps: as source code. Agents author it. Generative models run as functions. A deterministic compiler produces something you can diff, fork, and reproduce.

This post is for builders who live in Claude, Cursor, Aider, OpenCode, or Codex — and for creators and agencies tired of one-shot prompt boxes that can't enforce brand timing.

The problem isn't "AI video." It's structure.

The last two years of generative video models are impressive. Grok Imagine, Veo, PixVerse, Runway, FLUX stills, ElevenLabs voice and music — you can get beautiful clips from a sentence.

What you still can't get reliably from a single prompt is shipping video:

Exact beat timing for a 15-second reel
Brand lockups that never drift
A founder VO that lands on the product shot, not three frames early
A template you can reuse next week when the offer changes
A file history that isn't final_v7_reallyfinal.mp4

Prompt-first tools optimize for surprise. Product launches optimize for control. Those are different jobs.

If your coding agent can refactor a codebase from a brief, it should be able to author a launch reel from a brief too — without you scrubbing a timeline at midnight.

Video should be programmable

"Programmable video" means the source of truth is code, not a proprietary project file and not a chat transcript.

In SceneRok that language is VidScript. Intent becomes a readable script. At compile time, imported packages call frontier models as functions — assets resolve before the timeline is rendered. The compiler then enforces timing, shaders, overlays, and audio mix. Same source, same inputs → reproducible output.

The loop looks like software, because it is:

Intent — describe the video or hand your agent a brief. No blank timeline.
Agent authors VidScript — templates, brand rules, parameterized slots.
Generative plugins at compile — xai.imagine(), cf.imagine(), cf.image(), xai.tts(), eleven.music(), and any Cloudflare AI Gateway model via model:.
Deterministic composition — the compiler owns structure. You own taste and constraints.

You can work three ways: web editor (creators and motion designers), CLI + MCP + skills (agent-first builders), or templates + version control (teams). Hybrid execution means local preview and GPU render from the same source. One token wallet covers traditional render and generative calls, with an audit trail.

The slogan we keep coming back to: Agents don't prompt. They program.

VidScript mental model

Think of VidScript as a declarative timeline with real function calls.

Imports pull in generative providers (@scenerok/xai, @scenerok/cloudflare, ElevenLabs music, motion helpers).
Inputs declare assets you already have (brand hero clip, logo, screen recording).
Time ranges like [0s .. 6.5s] place video, text, and audio on a clock.
[-] means "generate / resolve this asset at compile time" — duration comes from the model call or context.
Output sets container, resolution, destination.

Generative calls are not a side chat. They are first-class expressions inside the script. That matters: the agent can change a prompt string, a model: id, or a voice name the same way it changes a constant in TypeScript — and you still get a reviewable diff.

For longer, data-driven, or heavily branched scenes, the TypeScript authoring SDK (@scenerok/sdk) builds the same intermediate timeline IR. Short promos and human edits stay in .vid. Agents that need loops and computed timing lean on the SDK. Both paths compile to the same place.

Cloneable sources for videos on the public showcase live in nidheeshdas/scenerok-showcase — each folder is a brief, metadata, and source.vid or source.ts you can fork and re-render with the CLI.

Example: a tiny launch reel (from product docs)

The following is adapted from the VidScript examples published on scenerok.com — not a one-off invention. It shows the shape: brand footage + compile-time generative video + TTS, composed deterministically.

import cf from "@scenerok/cloudflare"
import xai from "@scenerok/xai"

input brand = "https://cdn.scenerok.com/samples/brand-hero.mp4"

# Generative assets created at compile time — pick any Cloudflare Gateway model
[-] = video cf.imagine(
  "minimal product shot, floating in void, soft rim light",
  model: "pixverse/v6",
  aspect_ratio: "9:16",
  duration: 6
)

[0s .. 6.5s]  = video brand
[0.8s .. 5.8s] = audio xai.tts(
  "This is not generated. This is compiled.",
  voice: "jessica"
)

output to "launch-reel.mp4", resolution: "1080x1920"

A second pattern — text-to-video plus timed type — looks like this (also from the site's mental model):

import xai from "@scenerok/xai"
import motion from "@scenerok/basic-animations"

[-] = video xai.imagine(
  "cyberpunk city at dusk, cinematic",
  aspect_ratio: "9:16",
  duration: 4.2
)

[2.8s .. 7s] = text "The future is compiled",
  style: title,
  animate: motion.fadeIn(0.6s)

Notice what is not happening: you are not pasting a mega-prompt and hoping the model invents your brand system. The model fills slots. The script owns structure.

Cloudflare's plugin is the "one plugin, many providers" path — PixVerse, Veo, Seedance, Runway, FLUX, Grok Imagine via gateway billing, and more — selectable with model: or inspectable at compile time with cf.listModels().

Templates with teeth

One-shot generators fade when you need campaign volume. SceneRok leans on parameterized templates: Product Launch, Founder Testimonial, UGC Remix, Motion Campaign. Slots like {{hero}}, {{offer}}, {{cta_voice}} can be filled by humans, data, or generative calls — while brand rules, timing, and type systems stay enforced.

That is the agency and growth-team unlock. Fork last week's reel, swap the offer string and hero asset, recompile. Version control becomes the edit history. Review happens on a PR, not a Loom of someone scrubbing a timeline.

Who this is for

Indie founders and coding-agent users

You already ship with agents. You still under-ship video because CapCut doesn't live in your IDE. Install the SceneRok CLI and skills once; stay in Claude, Cursor, Aider, or Codex. Tell the agent what to build; it writes and renders.

Novice creators

You want production-grade starting points without learning After Effects. Web editor first, system templates, real-time preview — drop into VidScript only when you need precision.

Agencies and small motion teams

You need reuse, brand guardrails, and client variants without rebuilding from zero. Templates + unified billing + audit trail beat a folder of untitled projects.

Not the first wedge

If you only need a single surreal clip for fun, a consumer prompt app is fine. SceneRok is for people who need the fifteenth variant to still match the brand.

Why "deterministic" matters when models are stochastic

Generative calls are stochastic by nature. Composition should not be.

SceneRok's bet is hybrid: resolve generative assets at compile time (logged against your wallet), then compose with a compiler that respects explicit timing and effects. You can change a model prompt without rewriting your entire edit. You can re-render with the same script after swapping one input. You can preview locally and push final frames to GPU targets without forking the creative.

That is closer to how CI treats builds than how chat treats images. Builders already trust that mental model.

Getting started (soft CTA)

If the asymmetry bothers you — agents shipping code while humans hand-cut launch videos — try SceneRok:

Site and web editor: https://scenerok.com
Agent path: CLI + MCP + skills (Claude, Cursor, Aider, OpenCode, Codex)
Public examples: github.com/nidheeshdas/scenerok-showcase
Showcase templates: scenerok.com/showcase

Fork a showcase folder, change a line, render a variant. Or open the editor and start from a Product Launch template.

I'm building this in the open for the people who already treat software as code and are ready to treat video the same way.

— Nidheeshdas Thavorath (@nidheeshdas_)

SceneRok · scenerok.com