Ai Video Producer

AI Video Producer (MCP Edition)

Create professional AI-generated videos through a structured, iterative workflow using Google Flow via MCP Playwright.

Architecture Overview

This skill uses a main agent + sub-agents architecture for efficient context management:

┌─────────────────────────────────────────────────────────────────┐
│                         MAIN AGENT (this skill)                 │
│  - Handles all user interaction and approvals                  │
│  - Creates philosophy.md, style.json, scene-breakdown.md       │
│  - Generates pipeline.json                                      │
│  - Orchestrates sub-agents via Task tool                       │
│  - Updates pipeline.json status after each sub-agent returns   │
│  - Runs FFmpeg concatenation                                    │
└───────────────────────────┬─────────────────────────────────────┘
                            │ Task tool spawns general-purpose agents
                            │ with embedded instructions from .claude/agents/
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│ asset-generator│   │keyframe-generator│ │segment-generator│
│ (general-purpose)│ │ (general-purpose)│ │ (general-purpose)│
├───────────────┤   ├───────────────┤   ├───────────────┤
│ Fresh context │   │ Fresh context │   │ Fresh context │
│ MCP browser   │   │ MCP browser   │   │ MCP browser   │
│ Returns path  │   │ Returns path  │   │ Returns paths │
│ + status only │   │ + status only │   │ + status only │
└───────────────┘   └───────────────┘   └───────────────┘

Benefits:

• Each generation has isolated memory (no context pollution)
• Browser automation details don't clutter main conversation
• Parallel execution possible for independent tasks
• Easy retry of individual failed generations
• Main agent stays focused on orchestration

Implementation Note: Sub-agents are spawned using subagent_type="general-purpose" with the full instructions from .claude/agents/*.md files embedded in the prompt. This achieves the same isolation benefits while using Claude Code's built-in agent system.

Prerequisites & Setup

Required:

• Google account with Flow access (Google AI Pro or Ultra subscription)
• Internet connection

MCP Playwright: If not installed, run automatically:

claude mcp add playwright -- npx @playwright/mcp@latest

No Python scripts required! Claude directly controls the browser via MCP.

Auto-Setup Check

At workflow start, verify MCP Playwright is available:

1. Try calling mcp__playwright__browser_snapshot()
2. If tools unavailable, offer to install: claude mcp add playwright -- npx @playwright/mcp@latest
3. After install, user must restart Claude Code for MCP to load

Google Flow Overview

URL: https://labs.google/fx/flow

Flow is a project-based AI filmmaking tool with these generation modes:

| Mode | German Label | Model | Purpose | |------|--------------|-------|---------| | Text to Image | "Bild erstellen" | Nano Banana Pro | Generate assets and keyframes | | Video from Frames | "Video aus Frames" | Veo 3.1 - Quality | Generate video segments from start frame | | Text to Video | "Video aus Text" | Veo 3.1 - Quality | Generate video from text only | | Video from Elements | "Video aus Elementen" | Veo 3.1 - Quality | Generate video with reference elements |

Key Interface Elements:

• Mode selector dropdown (combobox) to switch between generation types
• Text input field for prompts
• "add" buttons for uploading reference images/frames
• "Erstellen" (Create) button to start generation
• Generated content appears in the gallery (Videos/Images tabs)
• Settings button ("tune" / "Einstellungen") to configure model and output count

REQUIRED Video Settings (configure via Settings button):

• Model: Veo 3.1 - Quality (NOT Veo 3.1 - Fast)
• Outputs per prompt: 1 (NOT 2)
• Aspect ratio: Querformat 16:9 (Landscape)

MANDATORY WORKFLOW REQUIREMENTS

YOU MUST FOLLOW THESE RULES:

1. ALWAYS use TodoWrite at the start to create a task list for the entire workflow
2. NEVER skip phases - complete each phase in order before proceeding
3. ALWAYS create required files - philosophy.md, style.json, scene-breakdown.md, and pipeline.json are REQUIRED
4. ALWAYS break videos into multiple scenes - minimum 2 scenes for any video over 5 seconds
5. ALWAYS ask user for approval before proceeding to the next phase
6. NEVER generate without a complete pipeline.json - plan ALL prompts first, execute second
7. ALWAYS use sub-agents for generation - use Task tool to spawn asset-generator, keyframe-generator, segment-generator
8. ALWAYS update pipeline.json after each sub-agent returns with status
9. ALWAYS move downloads to correct locations - files download to .playwright-mcp/, sub-agents handle this

Sub-Agent Definitions

Three sub-agents are defined in .claude/agents/:

asset-generator

• Purpose: Generate ONE asset image (character, background, object) via Flow
• Input: assetid, prompt, outputpath, project_dir
• Output: JSON with status, assetid, outputpath, message
• Uses: Flow "Bild erstellen" mode (Nano Banana Pro)

keyframe-generator

• Purpose: Generate ONE scene starting keyframe via Flow
• Input: sceneid, prompt, outputpath, projectdir, stylecontext
• Output: JSON with status, sceneid, outputpath, message
• Uses: Flow "Bild erstellen" mode (Nano Banana Pro)

segment-generator

• Purpose: Generate ONE video segment (8 seconds max) via Flow
• Input: segmentid, sceneid, motionprompt, startframepath, outputvideopath, projectdir, extractendframe, endframepath
• Output: JSON with status, segmentid, sceneid, outputvideopath, endframepath, message
• Uses: Flow "Video aus Frames" mode (Veo 3.1 Fast)

How to Invoke Sub-Agents

Use the Task tool with subagent_type="general-purpose" and embed the agent instructions from .claude/agents/ in the prompt:

Task(
  subagent_type="general-purpose",
  prompt='''
  You are an asset-generator sub-agent. Follow these instructions:

  [Read and embed full contents of .claude/agents/asset-generator.md here]

  ---
  NOW EXECUTE THIS TASK:
  {
    "asset_id": "hero_character",
    "prompt": "A heroic knight in silver armor, standing tall, dramatic lighting",
    "output_path": "output/project/assets/characters/hero.png",
    "project_dir": "D:/Project/gemini-video-producer-skill/output/project"
  }
  ''',
  description="Generate hero character asset"
)

IMPORTANT: Before spawning sub-agents, use the Read tool to load the agent instructions:

• Read(".claude/agents/asset-generator.md") for asset generation
• Read(".claude/agents/keyframe-generator.md") for keyframe generation
• Read(".claude/agents/segment-generator.md") for segment generation

Then embed those instructions in the Task prompt.

Parallel Execution: For independent tasks, spawn multiple sub-agents in a single message:

# Assets can be generated in parallel (all use general-purpose with embedded instructions)
Task(subagent_type="general-purpose", prompt="[asset-generator instructions] + asset 1 task", description="Generate asset 1")
Task(subagent_type="general-purpose", prompt="[asset-generator instructions] + asset 2 task", description="Generate asset 2")
Task(subagent_type="general-purpose", prompt="[asset-generator instructions] + asset 3 task", description="Generate asset 3")

Sequential Execution: Segments within a scene must be sequential (frame chaining):

# Segment A first (uses keyframe)
result_A = Task(subagent_type="general-purpose", prompt="[segment-generator instructions] + seg A task...")

# Segment B uses extracted frame from A
result_B = Task(subagent_type="general-purpose", prompt="[segment-generator instructions] + seg B task...")

Pipeline Architecture

Scene and Segment Model

Videos are structured hierarchically:

• Scenes contain one or more segments
• Each scene has a generated starting keyframe (new visual context)
• Segments within a scene chain via extracted frames (seamless continuity)
• Transitions between scenes are applied programmatically (cut, fade, dissolve)

Scene 1 (20 sec target → 3 segments)
├── Keyframe: scene-01-start.png (GENERATED via keyframe-generator)
├── Segment A (8 sec) → extract frame (via segment-generator)
├── Segment B (8 sec) → extract frame (via segment-generator)
└── Segment C (4 sec) (via segment-generator, no extraction)

[TRANSITION: fade/cut/dissolve]

Scene 2 (8 sec target → 1 segment)
├── Keyframe: scene-02-start.png (GENERATED via keyframe-generator)
└── Segment A (8 sec) (via segment-generator)

Why this model:

• Scenes = narrative units (different camera, location, or perspective)
• Segments = technical chunks needed due to 8-second generation limit
• Keyframes generated per scene (not per segment) - establishes visual context
• Transitions between scenes are real cinematic choices (not just frame chaining)

Workflow Phases

Phase 0: Setup Check

1. Navigate to https://labs.google/fx/flow (use MCP directly for initial check)
2. Handle cookie consent if needed
3. Verify login status (look for project list or user avatar)
4. If not logged in, guide user through login
5. Create a new project or use existing one

Note: This phase is done by the main agent directly to verify MCP is working.

Phase 1: Production Philosophy (REQUIRED)

Create both files before proceeding:

• {output_dir}/philosophy.md
• {output_dir}/style.json

philosophy.md template:

# Production Philosophy: [Project Name]

## Visual Identity
- **Art Style**: [e.g., cinematic realistic, anime, painterly]
- **Color Palette**: [primary colors, mood, temperature]
- **Lighting**: [natural, dramatic, soft, high-contrast]
- **Composition**: [rule of thirds, centered, dynamic angles]

## Motion Language
- **Movement Quality**: [smooth/fluid, dynamic/energetic, subtle/minimal]
- **Pacing**: [fast cuts, slow contemplative, rhythmic]
- **Camera Style**: [static, tracking, handheld, cinematic sweeps]

## Subject Consistency
- **Characters/Products**: [detailed descriptions]
- **Environment**: [setting details]
- **Props/Elements**: [recurring visual elements]

## Constraints
- **Avoid**: [unwanted elements]
- **Maintain**: [elements that must stay consistent]

style.json template:

{
  "project_name": "Project Name",
  "visual_style": {
    "art_style": "description",
    "color_palette": "description",
    "lighting": "description",
    "composition": "description"
  },
  "motion_language": {
    "movement_quality": "description",
    "pacing": "description",
    "camera_style": "description"
  },
  "subject_consistency": {
    "main_subject": "detailed description",
    "environment": "detailed description"
  },
  "constraints": {
    "avoid": ["list", "of", "things"],
    "maintain": ["list", "of", "things"]
  }
}

CHECKPOINT: Get user approval before proceeding.

Phase 2: Scene Breakdown (REQUIRED)

Create {output_dir}/scene-breakdown.md:

# Scene Breakdown: [Project Name]

## Overview
- **Total Duration**: [X seconds]
- **Number of Scenes**: [N]
- **Segment Duration**: 8 seconds (Flow Veo limit)
- **Video Type**: [promotional/narrative/educational/etc.]

---

## Scene 1: [Title]
**Duration**: [X seconds] → [ceil(X/8)] segments
**Purpose**: [What this scene communicates]
**Transition to Next**: [cut/fade/dissolve/wipe]

**Starting Keyframe**:
[Detailed visual description for the generated keyframe that starts this scene]

**Segments**:
1. **Seg A** (0-8s): [Motion description for first 8 seconds]
2. **Seg B** (8-16s): [Motion description for next 8 seconds]
3. **Seg C** (16-Xs): [Motion description for remaining seconds]

**Camera**: [static/tracking/pan/zoom/POV]

---

## Scene 2: [Title]
**Duration**: [X seconds] → [ceil(X/8)] segments
**Purpose**: [What this scene communicates]
**Transition to Next**: [null - last scene]

**Starting Keyframe**:
[Detailed visual description - this is a NEW scene so needs its own keyframe]

**Segments**:
1. **Seg A** (0-8s): [Motion description]

**Camera**: [camera style]

---

Planning Guidelines:

| When to Create a New Scene | |----------------------------| | Camera angle/perspective changes significantly | | Location or setting changes | | Time jump occurs | | Subject/focus changes | | You want a cinematic transition (fade, dissolve) |

| When to Add Segments (Same Scene) | |-----------------------------------| | Continuous action exceeds 8 seconds | | Same camera perspective continues | | No narrative break needed |

Segment Calculation: segments_needed = ceil(scene_duration / 8)

| Scene Duration | Segments Needed | |----------------|-----------------| | 1-8 seconds | 1 | | 9-16 seconds | 2 | | 17-24 seconds | 3 | | 25-32 seconds | 4 |

CHECKPOINT: Get user approval before proceeding.

Phase 3: Pipeline Generation (REQUIRED)

Create {output_dir}/pipeline.json:

Pipeline Schema v3.0:

{
  "version": "3.0",
  "project_name": "project-name",
  "config": {
    "segment_duration": 8
  },
  "metadata": {
    "created_at": "ISO timestamp",
    "philosophy_file": "philosophy.md",
    "style_file": "style.json",
    "scene_breakdown_file": "scene-breakdown.md"
  },
  "assets": {
    "backgrounds": {
      "": {
        "prompt": "Detailed description...",
        "output": "assets/backgrounds/.png",
        "status": "pending"
      }
    },
    "characters": {
      "": {
        "prompt": "Detailed description...",
        "output": "assets/characters/.png",
        "status": "pending"
      }
    }
  },
  "scenes": [
    {
      "id": "scene-01",
      "title": "Scene Title",
      "duration_target": 20,
      "transition_to_next": "cut",
      "first_keyframe": {
        "prompt": "Detailed visual description for scene start...",
        "output": "keyframes/scene-01-start.png",
        "status": "pending"
      },
      "segments": [
        {
          "id": "seg-01-A",
          "motion_prompt": "Motion description for first 8 seconds...",
          "output_video": "scene-01/seg-A.mp4",
          "status": "pending"
        },
        {
          "id": "seg-01-B",
          "motion_prompt": "Continuing motion for next 8 seconds...",
          "output_video": "scene-01/seg-B.mp4",
          "status": "pending"
        },
        {
          "id": "seg-01-C",
          "motion_prompt": "Final motion segment...",
          "output_video": "scene-01/seg-C.mp4",
          "status": "pending"
        }
      ]
    },
    {
      "id": "scene-02",
      "title": "Different Scene",
      "duration_target": 8,
      "transition_to_next": null,
      "first_keyframe": {
        "prompt": "New visual context description...",
        "output": "keyframes/scene-02-start.png",
        "status": "pending"
      },
      "segments": [
        {
          "id": "seg-02-A",
          "motion_prompt": "Motion description...",
          "output_video": "scene-02/seg-A.mp4",
          "status": "pending"
        }
      ]
    }
  ]
}

Schema Notes:

• config.segment_duration: Flow Veo's max video length (8 seconds)
• scenes[].duration_target: Desired scene length → determines segment count: ceil(duration / 8)
• scenes[].transition_to_next: Transition to apply before next scene (cut, fade, dissolve, wipe, or null for last scene)
• scenes[].first_keyframe: Generated image to establish scene's visual context
• scenes[].segments[]: Technical video chunks that chain seamlessly within the scene

Veo Motion Prompt Guidelines (CRITICAL)

Motion prompts for video segments MUST follow this official Veo structure:

Structure: `[Cinematography] + [Subject] + [Action] + [Cont

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: zysilm
• Source: zysilm/video-producer-skill
• License: MIT

Install and usage instructions live in the source repository linked above.