DALANG — Storyboard-to-Animatic Studio

DALANG turns one line of brief into a finished, narrated vertical animatic video — the

entire storyboard-to-video pipeline collapsed into a single agent call. Give it an idea and

it writes the shot list, generates style-consistent frames that hold one recurring character

or product across every shot, voices each line, burns in captions, and assembles a

share-ready 1080x1920 MP4. Two engines: a fast Ken Burns tier, and a cinematic tier that

animates each shot into real motion via image-to-video.

It is built agent-native for OKX.AI, not adapted to it. One tool call = one billable unit,

priced and settled as x402 on X Layer: $0.49 in USDT0 through OKX's own facilitator, with a

free storyboard-preview and quote tier so a caller — human or agent — can approve direction

and price before paying. It is composable: an upstream "director" agent can hand DALANG a

ready-made shot_list and use it purely as a render primitive, which is what an agent economy

actually needs.

Every output is Web3-native. Each render returns a content fingerprint (SHA-256 + IPFS

CIDv1) and a tamper-evident proof-of-creation you can anchor on X Layer, plus mint-ready

ERC-721 metadata carrying co-creator royalty splits — so every agent that contributed to a

video co-owns it — and on-chain remix lineage linking a derivative back to its parent. The

landing page ships an in-browser verifier: drop the MP4, the fingerprint is recomputed

locally and matched. Authenticity you check rather than trust.

Also in the box: multilingual title and voiceover (including Bahasa Indonesia), vertical

templates (product ad, book trailer, recipe reel, real estate, explainer), style presets,

editable SRT subtitles, and a token-gating option on X Layer.

One sentence in → a paid, provably-authored, co-owned film out, with no human in the loop.

Agent #7234 on OKX.AI · MCP endpoint https://dalang-engine.vercel.app/mcp

Built from zero during the hackathon window.

Engine: a single Venice API key drives the LLM shot-breakdown, frame generation with

character consistency, and Kokoro TTS; ffmpeg assembles Ken Burns motion, burned-in

captions, an optional score-and-sting bookend, and the final H.264/AAC cut. Later in the

window the cinematic tier landed — real image-to-video motion per shot, with automatic

fallback to Ken Burns when a clip fails.

Agent-economy layer: an x402 payment gate written to the open spec, then reconciled field

by field against OKX's own @okxweb3/x402-* SDKs (facilitator, network eip155:196, USDT0,

EIP-712 domain). Payment is verified BEFORE any compute and settled only AFTER a successful

render, so a failed render is never charged; a settlement failure withholds the artifact

instead of shipping free work. Registered as an A2MCP ASP on OKX.AI (Agent #7234) and

deployed serverless on Vercel Fluid Compute with a pip-bundled ffmpeg.

Web3 depth: provenance.py (SHA-256 + CIDv1 + ERC-721 metadata + royalty splits + remix

lineage), tokengate.py (X Layer balanceOf gating, fail-closed, documented honestly as a soft

gate), a render-credit ERC-20, and a browser-side verifier cross-checked byte-for-byte

against the Python implementation in Chromium, Firefox and WebKit.

Hardening was the bulk of the work: eight review passes (seven functional, one security)

plus adversarial agent reviews. Real bugs found and fixed, not cosmetics — an ffmpeg hang on

a corrupt frame that could burn an entire paid render; an x402 success sentinel a caller

could forge to dodge settlement; a Docker build broken by an inline comment that had made

every container deploy dead on arrival; an API key attached to third-party CDN download URLs;

a Vercel response-cap overflow that made callers pay and receive a 500. On the final day,

live probing caught the biggest one: the deployed MCP endpoint was returning HTTP 200 with an

every container deploy dead on arrival; an API key attached to third-party CDN download URLs;

a Vercel response-cap overflow that made callers pay and receive a 500. On the final day,

live probing caught the biggest one: the deployed MCP endpoint was returning HTTP 200 with an

EMPTY body on every call, because Vercel's ASGI bridge cancels an SSE stream before it

flushes — invisible to smoke tests that only assert status codes. Fixed by replying as plain

JSON, verified live, and the free preview tool was shrunk from a 5.2 MB response to 97 KB.

Everything is covered by self-checks and an offline integration test that runs the real

render chain against stubbed generators, in CI on every push, including a Docker build job.