An agent-callable creative surface on an open GPU network

Storyboard MCP turns a single Daydream API key into a brand kit, moodboard, character-consistent storyboard, comic spread, or live-stream pipeline — driven by any agent framework, billed by the second, no SaaS lock-in.

The four companion case studies show the Storyboard MCP shipping real work for four distinct creative personas in under five minutes per brief, for under $0.55 per artifact set. Each one runs against the same MCP server, the same 52 Livepeer-routed AI capabilities, the same agent surface. The differentiator is not any one model — it's the network shape, the agent ergonomics, and the cost transparency that come from sitting on top of a public GPU mesh instead of a vendor's private cloud.

What the four case studies cover

Total spend across the four case studies: $3.58 for 35 stills, 7 video clips, two anchor sheets, 32 drift-grading calls, 11 auto-retries, and four public viewer URLs the personas can share with collaborators today. Total wall clock end-to-end across all four briefs: under 12 minutes.

• Product marketing — Pure North bottled water. A brand director, three MCP calls, twelve diverse on-brand slots in under 90 seconds plus one hero video animated from the strongest still.
• Movie storyboard — Grandpa Tom's Last Cast. An 8-scene cinematic short with auto-anchor, drift detection, selective retries — then four animated episodes (5-6s each) rendered from key keyframes. Final drift average 0.78.
• Graphic novel — The Lantern Apprentice. A 6-page kitsune anime spread with an honest 0.27 drift score, a documented LoRA upgrade path, and a 5s motion-comic clip animated from page 5.
• Social promotion — Lumen Wellness IG grid. A 9-slot palette-locked launch board for an indie founder, plus one vertical-friendly Instagram Reel animated from the hero slot.
• Meta — marketing the SDK with the SDK. A blog-style case study where Storyboard renders its own marketing materials: brand kit, 6-slot personas moodboard, 6-scene "Maya's launch day" storyboard, 3 animated episodes. Shows how to sell an abstract developer-facing product to non-technical creatives.

Why the network shape matters

The Storyboard MCP sits on top of a Livepeer / Daydream GPU mesh, with a BYOC (Bring Your Own Compute) orchestrator routing capability calls to fal.ai providers across the network. The implications of that shape, for an agent building creative work, are not cosmetic.

Dimension	Storyboard MCP / Livepeer	Vendor-owned creative cloud
GPU sourcing	Open mesh — multiple providers, dynamic price discovery	Single-tenant data centers, fixed cost
Capability mix	52 caps mixed from many vendors (fal, gemini, gpt-image, bytedance, runway, recraft)	One vendor family per surface
Pricing model	Per-second compute, transparent USD pre-flight	Per-month subscription or pre-paid credits
Agent surface	Native MCP with 50+ tools	REST APIs of varying ergonomics; almost none MCP-native yet
Identity-binding	Daydream API key signs orch payment tickets — no per-tool credentials	One vendor account per tool
Public sharing	Auto-published viewer URLs with TTL	Account-gated previews
Local fallback	CLI works offline against the same MCP surface	UI-only or thin SDK

The agent-experience pillars

Four months of focused agent-experience work (the Z and AX tracks) shipped between late April and mid-May. The pillars are visible in every one of the case studies above.

Cost transparency

get_pricing returns USD per unit before submit. max_cost_usd on create_media, moodboard_spread, generate_project, and submit_creative_job hard-caps spend pre-flight. Every job-status response includes cost_usd_estimated. The agent never has to guess what a call will cost or what it did cost.

Openness

The MCP server is a public artifact (storyboard.daydream.monster/api/mcp). The CLI is open-source. The Daydream API key is portable across surfaces — same key works for MCP, CLI, browser, and any agent framework that speaks the MCP protocol. No vendor lock-in. No proprietary chat sandbox. No "approved providers" list.

Agent-friendliness

50+ MCP tools, each with a single clear purpose, "USE WHEN / DO NOT USE WHEN" delimiters in their descriptions (AX-3 audit), typed error envelopes with code, retryable, retry_after_seconds, and hint fields (AX-1), idempotency keys with a 24-hour cache (AX-4), p50/p95 SLA metadata on every capability (AX-5), URL normalization on every output (AX-6), notifications/progress streaming on long-running work (Z7), and pausable creative jobs with checkpoint review and resume (Z6). The agent does not have to wrap a fragile vendor SDK — it picks the tool, calls it, branches on a structured response.

Capability breadth

52 live capabilities across image, video, audio, 3D, and live video-to-video. The agent doesn't switch surfaces to switch modalities — the same create_media call handles a flux-dev still, a chatterbox TTS clip, a tripo-i3d 3D mesh, or a seedance i2v animation. The capability router picks the right model when the agent doesn't specify one.

Same surface, still → moving

The four case studies all illustrate the same shape: the agent first generates the still board (the deliverable that historically would have been the end of the brief), then the same surface — same key, same MCP server, same idempotency / retry / cost-cap semantics — pivots to image-to-video. create_media action=animate model_override=seedance-i2v source_url=. The keyframe is the first frame; the result is 5–6 seconds of cinematic motion. Across the four scenarios this added 7 video clips for ~$2 — a ~2× cost lift on the $1.58 still spend, in exchange for video-ready deliverables. The episodic shape in scenario 2 is the cleanest demonstration: 4 narrative beats × 5-6s = ~22 seconds of polished short-form, ready to drop into Premiere or DaVinci. The agent did not have to learn a new surface to get this — the i2v path is one more action on the tool it was already calling for stills.

Consistency across multi-shot work — the Z track

The movie-storyboard and graphic-novel case studies stress-test the Z-track work shipped in mid-May: character anchor sheets, drift detection with weighted face/marks/wardrobe/palette sub-scores, auto-retry when scores fall below the 0.70 threshold, entity registry per project so subsequent calls route consistently, and a checkpoint primitive that lets long-running creative jobs pause for review and resume idempotently.

This is the substantive difference vs prompt-and-pray: the system grades its own work, surfaces drift, and the agent can decide whether to ship, retry, or escalate to a per-character LoRA. The graphic-novel case study is the honest report on what happens when the gate's score stays low — the system surfaced it instead of pretending.

Across four agent frameworks

The same MCP server has been exercised through Claude Cowork, Codex, Cursor, OpenHands, and Hermes — five distinct agent frameworks, one server. The portability matters: a creative team can pick the agent that best fits the rest of its workflow, and the storyboard surface stays constant.

Framework	Connection shape	Notes
Claude Cowork	mcp__storyboard__* via MCP	Default development surface for this project. 50+ tools.
Codex / Cursor	MCP through Cursor's MCP config	Same tool registry. Cost pre-flight prevents accidental spend in IDE flows.
OpenHands / autonomous agents	MCP over websocket	Idempotency keys + retry envelopes are designed for headless re-tries.
Hermes (long-task orchestrator)	submit_agent_task + Hermes-backed worker	For multi-step flows that don't fit one job. Cards stream into the browser as Hermes progresses.
CLI / direct	storyboard CLI	Same MCP surface, terminal-rendered. Same checkpoint review, same error envelope.

The competitive cite-only comparison

We did not run the same briefs on competing platforms for these case studies. The numbers below are vendor-published pricing and capability claims as of mid-2026, cited rather than benchmarked.

Dimension	Storyboard MCP / Livepeer	Runway	Flora	Midjourney
Native MCP surface	✓ 50+ tools	HTTP API only	Node-based UI, no MCP	Discord bot, unofficial APIs
Multi-model capability mix	52 caps from 6+ vendors	Runway-family only	Multiple per-node providers	Single Niji/v7 family
Character-anchor + drift grading	✓ Auto-anchor + per-shot 0–1 score	References (no drift score)	Manual per-node	--cref manual
Pausable / resumable creative jobs	✓ Checkpoint primitive (Z6)	No	UI-canvas based	No
Public auto-share viewer URL	✓ 14-day TTL default	In-app share	Canvas link (sub-gated)	Discord or download
Cost surfaces pre-submit	✓ max_cost_usd hard cap	Credits, no $ pre-check	Credits, no pre-check	GPU-minute after-the-fact
Idempotency key with 24h cache	✓ AX-4	No	No	No
Open GPU network	✓ Livepeer mesh	Single-tenant cloud	Vendor-cloud per node	Vendor-cloud

What an agent does, end to end

The shape of an agent's interaction with this surface, written out plainly:

1. list_capabilities at session start. Read the SLA p50/p95 metadata so the agent knows which capabilities are fast and which are premium-slow.
2. get_pricing when the user mentions cost or when the brief is large. The agent quotes the expected spend before submit.
3. brand_kit_create when the work is branded. Palette + keywords + forbidden terms registered once, applied to every later call.
4. The right action tool: moodboard_create + moodboard_spread for boards, generate_project for multi-scene character-consistent work, create_media for one-shot assets, place_subject for product-photo-in-scene, submit_creative_job for plan-from-brief.
5. subscribe_progress on long-running jobs. The server emits notifications/progress as scenes finish — the agent renders progress in real time instead of polling.
6. On error: read the typed envelope (code, retryable, hint). Branch — retry, fall back, escalate, or surface to user.
7. On checkpoint (Z6): the worker pauses, the agent calls review_checkpoint to surface options to the user, the user picks continue / edit / abort, the agent calls resume_from_checkpoint. Resume is idempotent — replays on flaky network return the same decision.
8. On done: read the viewer_url, the consistency_log if relevant, and the cost_usd. Share the URL with collaborators.

The platform metrics that came out of the Z+AX sprint

The cross-surface parity discipline (documented in the design matrix) is the unsung pillar. Every Z and AX item lands on all three surfaces or none. An agent picking the CLI for a CI flow gets the same error envelope, the same idempotency cache, the same checkpoint primitive, the same SLA metadata as the agent calling MCP through Claude Cowork. The browser users see the same checkpoint review card the CLI users see in format/checkpoint.ts.

Where the network is heading

The roadmap pillars that the case studies above set up, but don't yet exercise:

• Auto-LoRA from drift-stable scenes. The graphic-novel case captured a lora_training_ready bucket of stable scene URLs. Z4 ships when submit_lora_train accepts a URL list and the worker fans out a training pipeline. The graphic-novel re-run with the LoRA goes from 0.27 to 0.85+.
• Distributed payment metering at the BYOC orch. The pixel-counted metering and prod-canary work tracked in the byoc-payment-fleet-2026-05 effort — when those land, the per-second compute pricing is provable end-to-end on Arbitrum.
• Multi-stream Director. The Scope Domain Agent already drives single LV2V streams. The Director surface orchestrates many streams as a live multi-cam edit. The /stream skill is the entry point.
• Marketplace agents. Skilled agents (story-teller, film-director, fashion-stylist, ad-copywriter) published as MCP-callable subagents, each with its own pricing tier on the same network.

What you can try today