For CEOs · CTOs · COOs

Storyboard is the agent.
Livepeer is the network.

Storyboard owns the agentic intelligence — planning, intent, brand awareness, human-in-the-loop approval. Livepeer owns the media network — model orchestration, payment, capability discovery. They meet at a single open protocol. Anyone can plug in. Nothing gets locked in.

📘 Engineer's deep dive → The full architecture reference — 5 agent plugins, 31 browser tools, 83 MCP tools, payment-channel flow, MCP envelope, BYOC orch internals.
Your question

"How much of this is Storyboard-specific IP versus a common media-aware orchestration layer that runs inside Livepeer?"

Short answer: the agentic pipeline planning — intent classification, multi-step skill execution, project state, HITL gates, brand context — runs in Storyboard (browser + a thin Vercel server). The actual media execution — image, video, audio, finishing tools, third-party services — runs on the Livepeer open network through a single payment-tied protocol. Storyboard sends jobs to Livepeer. The agent does not run on Livepeer.

§1The four layers

Read top to bottom. Pink layers are Storyboard's IP. Cyan layers are Livepeer's open network. Grey layers are external providers any network participant can plug in.

👤 Human — the marketer, PM, or COO
Asks for a launch in natural language. Approves or refines at each gate.
↓
🧠 Agent layer Storyboard IP
Where the intelligence lives. Runs in the browser (canvas + agent loop) or as MCP tools other AI tools call. create_media, moodboard_spread, generate_project, brand-kit memory, project entity registry, intent classifier, skills (markdown rules), playbooks, HITL approval gates.
↓    JSON envelope · Bearer auth · over HTTPS
🌐 Media bus — Livepeer open network Livepeer common infra
One protocol, many providers. SDK Service (FastAPI) accepts agent jobs, queries the live capability registry, routes through BYOC orchestrators on go-livepeer (BYOC = "bring your own compute" — any provider can join the network). Payment tickets signed on Arbitrum. Same wire format for AI inference, deterministic tools (ffmpeg, OpenCV), and bridged third-party MCP services. Public network: any orchestrator can publish capabilities.
↓    /inference · capability name · per-call payment
⚙️ Providers — model runners, tool containers, MCP servers External / open
Pluggable. fal.ai (image, video, TTS), Google (Imagen, Veo, Gemini), OpenAI (gpt-image), xAI (Grok), Bytedance (Seedance), Mistral (Voxtral), NVIDIA (Nemotron), plus deterministic Docker tools for finishing, plus external MCP servers (Slack, Drive, Linear, Publora). Each speaks the same envelope; any participant can add a new one.
Storyboard IP — agent & orchestration logic Livepeer — open media network External providers — pluggable

§2What lives where

The decision matrix for who owns what — useful when assessing portability, lock-in, and the surface area you'd need to fork.

CapabilityLives inWhat it does
Chat UI, canvas, drag-resize cardsStoryboardVisual surface; renders agent output as cards on an infinite canvas.
Agent loop (Claude / Gemini / OpenAI plugins)StoryboardDrives the LLM, calls tools, handles tool-use replies. Runs client-side in the browser.
Skills (markdown rules)StoryboardDomain knowledge for marketers, filmmakers, etc. Loaded into the system prompt.
Playbooks (paste-into-chat recipes)StoryboardSelf-contained workflows with HITL gates. Saved as plain YAML.
Brand kits, moodboards, project stateStoryboardPersisted in Vercel Blob, scoped per Daydream API key.
MCP server (60+ tool surface)StoryboardExposes the agent capabilities to any MCP-speaking client (Claude, Cursor, Codex, Antigravity). Vercel-hosted.
Intent planner, entity registry, HITL gatesStoryboardDecides "is this one image or a multi-scene story?", tracks recurring characters, pauses for approval.
Inference protocol (/inference envelope)LivepeerThe wire format every job rides. Same shape whether it's an image, a video, or an ffmpeg crop.
Capability registryLivepeerLive list of every model + tool + MCP service available. Discoverable, not hard-coded.
BYOC orchestrators (go-livepeer)LivepeerRoute inference to the right provider, handle queueing, capacity, payment validation.
Payment tickets (Arbitrum signer)LivepeerOn-chain payment per call. No subscriptions. Trustless billing.
Scope LV2V live-streaming runtimeLivepeerReal-time video-to-video on fal Scope runners, signed and metered through the same network.
AI models (flux, gpt-image, veo, seedance, …)ExternalRun on fal / Google / OpenAI / xAI / etc. Any provider can plug in.
Deterministic tools (ffmpeg, OpenCV, hyperframes)ExternalDocker containers anyone can publish to the network.
Third-party MCP bridges (Slack, Drive, Linear, Publora)ExternalExisting MCP servers proxied through the Livepeer mcp-bridge. Bring your own publishing destination.

§3An end-to-end flow

One representative request — a marketer pastes a launch brief, the agent plans it, Livepeer executes it, the marketer approves, Publora schedules it. Each step is labelled with where it runs.

  1. Paste the brief into chat
    "Launch our trail running shoe. Earth tones, cinematic outdoor. Brand: Aurora Run." Could be Claude, Cursor, Codex, the Storyboard canvas — any MCP-speaking surface.
    Human
  2. Intent classifier & preprocessor decide the shape of the job
    "This is a multi-scene launch, not a single image." Skills (marketer rules) inject brand-kit conventions. Project state is created. No LLM token spent on routing.
    Storyboard
  3. Agent calls Storyboard MCP tools
    brand_kit_create → moodboard_create → moodboard_spread(slots=12). Each call lands at Storyboard's MCP server.
    Storyboard
  4. Storyboard fans the work out to Livepeer
    Each slot becomes an /inference call against the SDK service with a capability name (e.g. gpt-image, flux-pro) and a bearer-tied payment ticket. No model name picks: Storyboard asks for a result; Livepeer routes.
    Livepeer
  5. Livepeer routes to live providers, signs & meters
    go-livepeer BYOC orchestrators dispatch to the cheapest healthy provider that supports the capability. Per-call payment settled on Arbitrum through the signer service.
    Livepeer
  6. Provider runs the model, returns the asset URL
    fal.ai / Google / OpenAI / etc. produce the image. The URL flows back through the orchestrator to Storyboard, lands as a card on the canvas.
    Provider
  7. HITL gate — the marketer approves, refines, or swaps
    "Slot 3 warmer." "Re-spread slots 1 + 5 in a different aesthetic." Each turn is one targeted call, not a full re-run.
    Human
  8. Finishing pass — deterministic tools, same protocol
    Concat, crop for platforms, watermark, export. ffmpeg-concat, opencv-smart-crop ride the same /inference envelope as AI models.
    Livepeer
  9. Publish — third-party MCP bridge
    publora_publish_post schedules to IG / TikTok / X / LinkedIn through the Livepeer mcp-bridge. Same payment rail.
    Livepeer

Notice what the agent doesn't do: it never picks a specific model, never holds payment, never bridges to a third-party API directly. Storyboard plans; Livepeer executes.

§4One protocol, three kinds of capability

Livepeer's capability registry doesn't distinguish "AI" from "non-AI" — it just exposes things the agent can call. Three flavors today; all speak the same envelope and the same payment rail.

Kind 1 — AI

Model inference

Image, video, audio, 3D, voice — text-to-X and X-to-X. 50+ models live today across image generation, video generation, image edit, TTS, speech-to-text, depth, etc.

flux-dev, gpt-image, veo-t2v, seedance-i2v, chatterbox-tts, voxtral-stt
Kind 2 — Tool

Deterministic containers

Docker containers running ffmpeg, OpenCV, Pillow, headless browsers. The finishing layer that turns AI output into platform-ready deliverables.

ffmpeg-concat, opencv-smart-crop, obscura-extract-text, ffmpeg-overlay
Kind 3 — MCP

Third-party services

Existing MCP servers (Slack, Drive, Linear, GitHub, Notion, Publora) proxied through the Livepeer mcp-bridge. Publishing, ticketing, comms — same protocol.

slack-send-file, drive-upload, linear-create-issue, publora-publish-post
Why this matters for the executive: the agent never needs to know which kind it's calling. A marketer says "publish to Slack with a watermark." The agent picks the capability by name, Livepeer routes the payment ticket, the tool runs, the result comes back. Adding a new internal tool — say, a corporate brand-guideline checker — is one capability registration. No agent retraining, no integration build.

§5Why open infrastructure matters

The closed pattern in this space is: pick one vendor's AI suite, sign their contract, build your workflow on their proprietary endpoints, hope they don't deprecate the model you depend on. Closed infrastructure means your workflow has the lifespan of one vendor's roadmap.

The open pattern Livepeer offers:

🔌 Any media, one rail

Image, video, voice, deterministic tools, third-party services — all flow through the same protocol with the same payment ticket. The internet of media-centric tooling is the headline; the network doesn't care whether a job is "AI" or "ffmpeg" or "Slack send" under the hood.

🌍 Any provider, anywhere

The capability registry is live and public. Independent orchestrators publish models. Today's set spans fal, Google, OpenAI, xAI, Bytedance, NVIDIA, Mistral, plus deterministic Docker tools. Tomorrow's set includes whoever publishes a competitive runner.

💸 Trustless per-call billing

Arbitrum-signed payment tickets at job submission. No subscriptions, no minimum commit, no platform monthly. You pay for the call that ran; the orchestrator who ran it gets paid.

🧱 Zero lock-in for the agent

The agentic IP is markdown skills + a small MCP server. Any LLM can drive it — Claude, Gemini, OpenAI, Grok, an open-source model behind a self-hosted endpoint. The agent moves; the network stays.

🛡️ Human-in-the-loop by design

Checkpoint gates are first-class in the protocol. Long jobs pause and wait for "approve / refine / swap / abort." A marketer never wakes up to a surprise spend or a render they can't audit.

🌱 Competitive economics

Providers compete on a public network. The orchestrator quoting the cheapest valid path for a capability wins the job. That price discovery happens per call, not per quarter — and it bends in the customer's favor as the provider set grows.

§6What would a fork look like?

A common executive concern: "If we adopt this, what's reversible? What's portable? What would I have to rebuild to leave?"

📦 Replace Storyboard

Storyboard is open source (livepeer/storyboard on GitHub). The MCP server is a small TypeScript surface; one file per LLM plugin drives the agent loop; skills are plain markdown. Fork-able by a small team in days, swap the brand, keep the Livepeer rail.

🔄 Replace Livepeer

Harder, but the protocol is documented. The /inference envelope is bearer-auth JSON. You could swap to OpenRouter or Replicate for AI-only workflows — you'd lose deterministic tools, third-party MCP, payment tickets, and the public capability network, but the agent contract is portable.

🧩 Stay on Storyboard, swap one provider

The capability registry is live. If fal goes down, Storyboard fails over to the next provider serving the same capability. No code change; the agent doesn't know.

🔐 Portable, no proprietary format

Brand kits and moodboards are JSON. Projects are JSON. Skills are markdown. Playbooks are YAML. Generated assets are standard image/video/audio files. Export at any time — none of it requires Storyboard to remain useful.

§7If you only remember three things

  1. Storyboard is the agent, Livepeer is the network. Planning and intelligence live in Storyboard. Media execution lives on Livepeer. They meet at a single open protocol.
  2. One envelope for AI, tools, and third-party services. The agent doesn't distinguish "AI inference" from "ffmpeg crop" from "Slack publish." The network does the routing; the agent does the work.
  3. Open by design. Any provider can publish capabilities. Any LLM can drive the agent. Any team can fork the agent layer in a weekend. The lock-in surface is approximately zero.
Where to dig deeper: Playbooks show the agent layer in production. Showcase shows what teams have shipped through the rail. GitHub is the agent source. The Livepeer network repo is at livepeer/go-livepeer.

§8Glossary

Plain-English definitions for terms used above.

TermMeaning
AgentThe combination of an LLM (Claude, Gemini, OpenAI, Grok…) plus the tools, skills, and loop that drive it to act on the user's behalf. In Storyboard's case, the agent layer is the skills + MCP tools + chat loop — not the LLM itself.
MCPModel Context Protocol. An open standard for connecting LLMs to outside tools. Think of it as USB-C for AI: every MCP-speaking agent (Claude Code, Claude Desktop, Cursor, Codex, Antigravity) can plug into any MCP server.
SkillA small markdown file teaching the LLM how a domain expert thinks (marketer, filmmaker, etc.). Loaded into the system prompt. No code, no retraining.
PlaybookA self-contained workflow (paste-into-chat YAML) with checkpoints. Walks the agent through a full deliverable with human approval at each step.
HITLHuman-in-the-loop. A pause point where the agent stops, shows what it made, and waits for the human to approve, refine, swap, or abort. Prevents surprise spend and surprise output.
BYOCBring Your Own Compute. The Livepeer pattern where independent providers join the network and offer capabilities for hire. Any orchestrator can publish; the network picks the best healthy one per call.
CapabilityLivepeer's unit of "thing the agent can call." An image model, an ffmpeg crop, a Slack publish — all capabilities. Each has a name, a price, and a runtime contract.
Payment ticketAn Arbitrum-signed micropayment for one capability call. The orchestrator who runs the job receives the ticket. Per-call, trustless, no subscription.
OrchestratorA Livepeer network participant that accepts jobs, runs them on the right provider, and gets paid via tickets. Decentralized — anyone can run one.
Brand kitStored palette + reference imagery + style words + "don't include" terms. Once saved, every subsequent generation in the session inherits it. Reusable across campaigns.
MoodboardA set of brand-locked reference images, typically rendered in parallel across multiple AI providers for diversity within a single brand identity. Shareable to stakeholders via a public viewer URL.