Claude does the strategy, story and scripting work a studio bills for, with boards and QA in build. This page shows where it sits in our system, which model and features each agent uses, and what is live versus still in build.
The Story Engine is a serverless function that chains two Opus calls and streams progress to the browser. The production lane, in build, will take the approved storyboard and drive real creative tools.
The left lane is built and deployed; the public demo currently replays a labelled sample until live generation is switched on. In the right lane, dashed boxes are agents still in development. Each handoff is structured data, and a person approves the story before production and the cut before delivery.
We need a model that can make creative calls, hand off clean data, operate real software and remember a brand. Here is how Claude covers each.
The Story Director decides how much to reason before it commits to an angle, instead of us tuning a fixed budget per brief. The Story Engine is built to stream the summarized thinking to the page, so you can watch the director's notes form once live generation opens. The preview replays a labelled sample.
Every storyboard is generated against a JSON schema: beats, timecodes, voiceover, on-screen text and sound. Production can read it directly, so nobody re-types a script between stages.
Production agents will call allowlisted operations in After Effects, Blender, Cavalry and DaVinci Resolve. The output will be editable project files that our founder can open and finish, not a flat clip.
Planned: a brand kit, past scripts and performance notes will sit in a stable cached prefix, so every new ad will start from what already worked, without paying to re-read it each time.
One model family, matched to each job by effort level and tooling. A dash means we have not committed to a model for that row yet.
| Agent | Model | Claude features | Status |
|---|---|---|---|
| Brand Analyst | Opus 5.5 | Web fetch, effort low | Built |
| Story Director | Opus 5.5 | Adaptive thinking, structured outputs, streaming | Built |
| Script Timer | None (code) | Deterministic 2.5 words/sec timing check | Built |
| Storyboard Artist | Opus 5.5 | Vision on product photos | In build |
| Production Agent | Opus 5.5 via Claude Agent SDK | MCP | In build |
| QA Reviewer | Opus 5.5 | Vision | In build |
| Brand Memory | — | Prompt caching | Next |
| Performance loop | — | — | Next |
A public endpoint that calls a model and fetches web pages needs limits. These are the ones we ship with, and the ones we are adding as production comes online.
The web fetch tool gets the exact page you give us, never one we or the model chose. Each brief is capped at two fetches.
The URL and the product description have hard limits in the form and on the server, so a brief cannot be used to push arbitrary volumes of text through the model.
The public Story Engine endpoint limits requests per IP address to protect it from abuse and runaway cost.
If the model declines or a call fails, the server falls back rather than breaking the page. Output that is a sample, not a live run, is labeled as one.
You approve the story, our founder finishes the cut and signs off as creative director. No ad is delivered on model output alone.
Briefs, URLs and assets are used only to produce your concepts and ad. We do not use them to train models.
The QA Reviewer will flag claims in a script or on-screen text that the brand page does not support, so unverifiable claims do not reach an ad.
We use Claude to build the product as well as to run it, and we can be plain about what that costs in API calls.
We build with Claude Code. This site and the pipeline were built with it, from the serverless Story Engine to the schemas and the front end. We review what it writes before it ships.
Today: the Story Engine backend is deployed, and each live run is two Claude Opus 5.5 calls, one to read the brand and one to direct the story. The public demo shows a labelled sample until live generation opens. Planned: once the production and QA agents ship, each paid ad will also run long-context production calls and vision QA passes over rendered frames. Usage will scale linearly with briefs and orders.
See a labelled sample of the two built agents' output in the Story Engine demo. Questions about how it is built? Email us.