{
  "mcpServers": {
    "storyboard": {
      "url": "https://storyboard.daydream.monster/api/mcp/sse",
      "transport": "sse",
      "headers": {
        "Authorization": "Bearer sk_<your-daydream-key>"
      }
    }
  }
}

Use the storyboard MCP to give me a 12-scene illustrated short story about
a Scottish ferryman's last crossing — watercolor pencil, John Bauer x Ghibli,
3:2, character-locked across scenes.

curl -fsSL https://storyboard.daydream.monster/cli/install.sh | bash
livepeer setup --non-interactive --api-key sk_<your-daydream-key>

# One-shot
livepeer agent run "make me a watercolor fox in Studio Ghibli style"

# Interactive REPL
livepeer
livepeer> /story 8-scene story about a fox in autumn
livepeer> /film 4-shot sci-fi opener about a derelict station
livepeer> /talk "Welcome to Aurora" --face img-1

livepeer config llm gemini --model gemini-2.5-pro    # Gemini direct
livepeer config llm anthropic --model claude-sonnet-4-6  # Claude direct
livepeer config llm ollama --model llama3.1          # local
livepeer config llm livepeer                         # back to hosted

1. Open  https://storyboard.daydream.monster
2. Sign in with your Daydream account
3. Type in chat:
     /story 6 scenes of a fox catching salmon in autumn
4. Watch the scenes render on the canvas in parallel
5. Right-click any card for context-menu actions:
     • Animate (i2v)         • Variations (×4)
     • Restyle / Edit        • Talking Video
     • Convert to 3D         • Virtual Try-On
     • Analyze Media         • Cinematic Video
6. /render to stitch the canvas into a final video

npm install @livepeer/agent

import {
  AgentRunner,
  ToolRegistry,
  WorkingMemoryStore,
  LivepeerProvider,
} from "@livepeer/agent";

// 1. Provider (uses YOUR users' Daydream key for billing)
const provider = new LivepeerProvider({
  apiKey: process.env.DAYDREAM_API_KEY!,
});

// 2. Tool registry — built-in tools work out of the box
const tools = new ToolRegistry();
// Or add your own:
tools.register({
  name: "send_to_slack",
  description: "Post an asset URL to a Slack channel",
  parameters: {
    type: "object",
    properties: {
      channel: { type: "string" },
      url: { type: "string" },
    },
    required: ["channel", "url"],
  },
  execute: async (args) => {
    await myAppSlackPost(args.channel as string, args.url as string);
    return JSON.stringify({ ok: true });
  },
});

// 3. Memory and runner
const memory = new WorkingMemoryStore();
const runner = new AgentRunner(provider, tools, memory);

// 4. Stream events
for await (const event of runner.runStream({
  user: "Generate a hero image for the spring launch and post it to #marketing",
})) {
  if (event.kind === "text") process.stdout.write(event.text);
  if (event.kind === "tool_call") console.log("→", event.name, event.args);
  if (event.kind === "tool_result") console.log("←", event.content);
}

curl -X POST https://sdk.daydream.monster/inference \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_<your-daydream-key>" \
  -d '{
    "capability": "flux-dev",
    "input": { "prompt": "a watercolor fox", "image_size": "landscape_16_9" }
  }'

Consumer surfaces (pick one or all three)
─────────────────────────────────────────
  • Direct CLI / SDK  (`@livepeer/agent`)
  • As MCP server     (Claude Code, Cursor, ChatGPT)
  • Embedded runtime  (import the SDK into your app)

                        │
                        │  Bearer: sk_<user-daydream-key>
                        │  Wire:  POST /inference { capability, input } → { output }
                        ▼

  Livepeer agent layer
  ┌───────────────────────────────────────────────┐
  │  • SDK service        sdk.daydream.monster     │
  │  • Storyboard MCP +   /api/mcp/sse + /api/llm  │
  │  • Hermes (long-task) agent.daydream.monster   │
  └───────────────────────────┬───────────────────┘
                              │
                              ▼
  Orchestrator network (go-livepeer, decentralized)
  ┌───────────────────────────────────────────────┐
  │  • BYOC orchs   AI / Tool / MCP capability    │
  │  • Scope orchs  live video-to-video           │
  │  • Signer       Arbitrum payment tickets      │
  └───────────────────────────┬───────────────────┘
                              │
                              ▼
  Adapters — all speak the same /inference envelope
  ┌───────────────────────────────────────────────┐
  │  AI   : Flux, Seedance, GPT-Image, Veo,       │
  │         Chatterbox, Music, Tripo, Gemini-text │
  │  TOOL : ffmpeg-concat / -mux / -export,       │
  │         opencv-smart-crop, yolo-segment/-detect│
  │  MCP  : Slack, Drive, Linear, GitHub          │
  └───────────────────────────────────────────────┘

User turn
   │
   ▼
findSkills(userMessage, context)  ─── ranks all skills by frontmatter
                                       relevance (task, domain, persona,
                                       scope) — top 3-5 win
   │
   ▼
Skills concatenated into system prompt:
   "You are a creative agent. CRITICAL CONSTRAINTS:
    [base.md content]
    [director-mcp.md content]
    [finishing-quality.md content]
    [storyteller.md content]
    ..."
   │
   ▼
LLM call (with tools + system prompt)
   │
   ▼
Agent fires tools according to skill guidance:
   - "movie quality" → seedance-i2v (from director-mcp)
   - "watercolor pencil" → gpt-image (from director-mcp model table)
   - finishing pass mandatory (from finishing-quality)
   - cut transitions for 3+ clips (from director-mcp)
   │
   ▼
Skill outcomes scored after turn ends — feeds future
ranking (skills that produced good outcomes get bumped)

---
name: director-mcp
description: "Director-language → multi-step MCP recipes; pick defaults, don't name models"
agent_rule: "User describes a deliverable — pick model/params, don't make them name caps."
task: [render, compose, animate, narrate]
domain: [video, image, audio, film]
persona: [agent-only]
scope: epic
---

# Director — natural language → MCP recipes

When the user says "30-second cinematic clip," you pick flux-schnell
for keyframes + seedance-i2v-fast for animation + ffmpeg-concat for
stitching. They don't name models; you do.

[... full markdown body teaches the agent ...]

# Day 1 — author and pin on your laptop CLI
$ livepeer skills new --name aurora-brand-voice
$ livepeer skills load aurora-brand-voice
$ livepeer agent run "make me a launch hero image"
  # Hero respects the brand voice immediately.

# Day 2 — fire up the Storyboard webapp
  # The chat header pill bar shows: [aurora-brand-voice ●]
  # Every generation already brand-locked.

# Day 3 — switch to Claude Code (MCP) for an iterative session
  > "Use the storyboard MCP to draft 4 social cuts."
  # Claude calls list_skills, sees aurora-brand-voice active
  # and uses it without you asking.

# Roll back anywhere:
$ livepeer skills unload aurora-brand-voice
# OR in the webapp:
/skills/unload aurora-brand-voice
# OR ask Claude Code:
  > "Drop the aurora-brand-voice skill — I want generic output."

User action on any surface
   │
   ▼
1. Active-set update:
     local:   ~/.livepeer/skills/active.json
     remote:  storyboard-mcp/user-mirror/<user-hash>.json  (Vercel Blob,
                                                              mirrored across
                                                              devices)
   │
   ▼
2. Next agent turn fires:
     findSkills(userMsg, { tools, persona })
     → ranks ALL skills by relevance
     → top-N + every pinned skill from active-set
       always wins (pinned override ranking)
   │
   ▼
3. System prompt assembled:
     [base.md content]
     [pinned skill 1]                ← from your active-set
     [pinned skill 2]
     [ranked-in skill 3]             ← matched the current intent
     [ranked-in skill 4]
   │
   ▼
4. LLM call (with system prompt + tools)
   │
   ▼
5. Outcome scored at turn end:
     - did the agent reach for a tool the skill recommends?
     - was the result rated thumbs-up?
     - update skill's effectiveness score in the per-user ledger
   │
   ▼
6. Future rankings boost or demote based on outcomes
   (your skills get smarter with use)

---
name: my-brand-voice
description: "Brand voice for Aurora Audio — premium, understated, hopeful"
agent_rule: "All copy targets Aurora Audio brand voice. Premium without superlatives."
task: [render, narrate]
domain: [image, video, audio]
persona: [agent-only]
scope: epic
---

# Aurora Audio brand voice

Tone: confident, understated, premium. Avoid superlatives ("uncompromising",
"the best", "world's first"). Prefer warmth ("the headphones that come home
with you", "made for the quiet hour").

Visual cues:
  - Always cool blue / charcoal / brushed silver palette
  - Studio lighting, never sunlight
  - Product on minimalist surfaces — concrete, walnut, marble

Caption patterns:
  - TikTok: short, sensory, second-person ("you'll hear...")
  - Instagram: longer, story-led, soft pull-quote
  - LinkedIn: hopeful, work-life balance angle

When generating campaign creative, always reference this skill alongside
director-mcp.md and finishing-quality.md.

{
  "id": "my-brand-voice",
  "category": "vertical",
  "description": "Aurora Audio brand voice — premium understated hopeful",
  "tags": ["brand", "voice", "aurora"]
}

User chat:                       Or CLI:                   Or MCP:
  /agent aurora-marketer           livepeer agent run \        mcp__storyboard__
    "launch the X1 next Tuesday"     --agent aurora-marketer \    create_agent_task
                                     "launch the X1 next Tuesday"  agent_id: aurora-marketer
   │                                 │                              prompt: "launch ..."
   │                                 │                              │
   └──────────────┬─────────────────┘                              │
                  │                                                │
                  ▼                                                ▼
       ┌──────────────────────────────────────────────────────────────┐
       │ Agent registry resolves "aurora-marketer" to:                 │
       │   • system_prompt: "You are Aurora's brand director ..."     │
       │   • skill_refs:    [director-mcp, marketing, my-brand-voice] │
       │   • lora_refs:     [bkit_aurora_lora_v3]                     │
       │   • tool_allowlist: [create_media, project_create, …]        │
       │   • brand_kit_id:  bkit_aurora_a1b2c3                        │
       │   • author + signature + reputation score                    │
       └──────────────┬───────────────────────────────────────────────┘
                      │
                      ▼
              Agent loop runs with this bundle pre-loaded.
              First turn is already brand-aware, model-aware,
              and finishing-pass-aware.

{
  "id": "aurora-marketer",
  "version": "1.4.2",
  "title": "Aurora Audio brand director",
  "author": "@aurora-creative",
  "signature": "0xabcdef...",       // signed with author's wallet
  "reputation": 4.8,                 // 0-5 from rated runs

  "system_prompt": "You are Aurora's brand director. Premium, understated...",

  "skill_refs": [
    "director-mcp",
    "marketing",
    "finishing-quality",
    "my-brand-voice"
  ],

  "lora_refs": [
    "bkit_aurora_lora_v3"            // private LoRA, accessible to owners
  ],

  "brand_kit_id": "bkit_aurora_a1b2c3",

  "tool_allowlist": [                // what this agent is allowed to call
    "livepeer.create_media",
    "livepeer.project_create",
    "livepeer.project_generate",
    "livepeer.canvas_organize",
    "ffmpeg-*",
    "publora-schedule"
  ],

  "pricing": {
    "model": "free" | "per-run" | "subscription",
    "fee_eth_per_run": "0.001",       // marketplace fee on top of compute
    "creator_split": 0.7              // 70% to author, 30% to network
  }
}

# 1. Build the manifest locally (CLI helper)
livepeer agent build \
  --id my-fashion-director \
  --title "Fashion campaign director" \
  --skills marketing,director-mcp,finishing-quality \
  --brand-kit bkit_aurora \
  --lora lora_aurora_v3 \
  --tool-allow create_media,project_create,publora-schedule \
  --pricing per-run --fee 0.0005 --output ./my-agent.json

# 2. Sign it with your wallet
livepeer agent sign ./my-agent.json --key ~/.daydream/wallet.key

# 3. Register on the marketplace
livepeer agent publish ./my-agent.json
# → Published as agent_a1b2c3d4 — your share of fees lands in
# → 0x1234... on Arbitrum within 24h of each invocation.

livepeer agent fork aurora-marketer --new-id studio-x-marketer
# Opens the manifest in your editor. Tweak the system prompt,
# swap skill_refs, change pricing. Sign + publish.
livepeer agent publish ./studio-x-marketer.json

User: /story a dragon adventure
→ 6-scene story card (editable)

User: add more scenes about finding treasure
→ System detects continuation → generates 3 matching scenes → appends
→ Updated card with NEW badges → user deletes unwanted → Apply

User: /story a space adventure
→ resetForNewWork() clears old context → fresh story, no bleed

import { ScopePlayer } from "@livepeer/scope-player";

// In your React component:
<ScopePlayer
  sdkUrl="https://sdk.daydream.monster"
  apiKey="sk_your_key"
  externalStreamId={streamId}
  onStateChange={(state) => console.log(state.status, state.fps)}
  onSourceReady={(setSource) => {
    // Drag an image onto the player to transform it live
    setSource({ type: "image", url: imageUrl });
  }}
/>

import { PerformanceEngine } from "./performance";

const engine = new PerformanceEngine();
engine.setScenes([
  { index: 0, title: "Dawn", prompt: "golden sunrise over mountains", preset: "cinematic", duration: 30 },
  { index: 1, title: "Storm", prompt: "dark storm clouds, lightning", preset: "abstract", duration: 15 },
  { index: 2, title: "Night", prompt: "starry sky, aurora borealis", preset: "dreamy", duration: 25 },
]);

// Transitions use noise_scale + kv_cache ramp for smooth morphing
engine.play(controlFn, onStateUpdate);
engine.pause();   // freeze at current point
engine.resume();  // continue from where paused

import {
  createArtifactStore,   // Canvas cards (images, videos, audio)
  createChatStore,       // Chat messages
  createProjectStore,    // Multi-scene projects
  createGroupManager,    // Episode/collection grouping
  createConversationContext, // Active work tracking
} from "@livepeer/creative-kit";

const artifacts = createArtifactStore({ maxArtifacts: 200 });
artifacts.getState().add({ type: "image", title: "Dragon", url: "...", refId: "img-1" });

import { routeModel, recordModelLatency, getModelStats } from "@livepeer/creative-kit";

// Scores: speed (60%) + style match (30%) + capacity (10%)
const result = routeModel({
  action: "generate",
  prompt: "a logo with text",
  availableModels: new Set(["flux-dev", "gpt-image", "recraft-v4"]),
});
// After each inference, feed back actual speed → router learns
recordModelLatency(result.model, elapsedMs);

// Check learned stats
const stats = getModelStats();
// → Map { "flux-dev" → { avgMs: 3200, count: 47, currentSpeed: 8.9 } }

import { createPipelineRegistry } from "@livepeer/creative-kit";

const registry = createPipelineRegistry();

// Resolve user intent to the best recipe
const recipe = registry.resolve("smooth 24fps stream");
// → { id: "ltx-responsive", pipeline: "ltx2", graph: {...}, defaults: { kv_cache: 0.3 } }

// List all recipes by quality tier
const quality = registry.listRecipes("quality");
// → [depth-lock, ltx-smooth, krea-hq, memflow-consistent, ...]

# Step 1: Generate key frame
IMG=$(curl -s -X POST https://sdk.daydream.monster/inference \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_your_key" \
  -d '{"capability":"flux-dev","prompt":"a majestic eagle soaring"}' \
  | jq -r '.image_url // .data.images[0].url')

echo "Image: $IMG"

# Step 2: Animate to video (10 seconds with audio)
curl -X POST https://sdk.daydream.monster/inference \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_your_key" \
  -d "{
    \"capability\": \"seedance-i2v\",
    \"prompt\": \"eagle gliding through mountain valley, cinematic camera follow\",
    \"params\": { \"image_url\": \"$IMG\", \"duration\": \"10\", \"generate_audio\": true }
  }"

# → { "data": { "video": { "url": "https://..." } } }