Script Writer Agent

Explore how the Script Writer Agent creates engaging, structured video scripts optimized for viewer retention

Overview

The Script Writer Agent transforms content strategies into complete, production-ready video scripts. It uses proven scriptwriting templates, pacing algorithms, and engagement techniques to create scripts optimized for maximum viewer retention.

What It Does

The Script Writer Agent generates fully structured video scripts with hooks, introductions, main content, conclusions, and calls-to-action. Each script is tailored to the content type and optimized for the target audience.

Key Features

Template Library

5 scriptwriting templates for different content types

Dynamic Pacing

Adjusts pacing and timing based on content type

Engagement Hooks

Creates compelling opening hooks to capture attention

Duration Estimation

Calculates estimated video duration with precise timing

Script Templates

The agent includes 5 specialized templates:

Tutorial

Structure: Hook → Introduction → Problem → Solution Steps → Demonstration → Recap → CTA

Best For: How-to guides, educational content

Pacing: Moderate (10-15 minutes optimal)

script-writer-agent.js

tutorial: {
  structure: ['hook', 'introduction', 'problem', 'solution_steps', 
              'demonstration', 'recap', 'cta'],
  tone: 'educational',
  pacing: 'moderate'
}

Explainer

Structure: Hook → Question → Background → Explanation → Examples → Implications → Summary → CTA

Best For: Concept explanations, “What is” videos

Pacing: Steady (5-10 minutes optimal)

script-writer-agent.js

explainer: {
  structure: ['hook', 'question', 'background', 'explanation', 
              'examples', 'implications', 'summary', 'cta'],
  tone: 'informative',
  pacing: 'steady'
}

List

Structure: Hook → Introduction → List Items → Bonus Item → Summary → CTA

Best For: Top 10 lists, countdowns, rankings

Pacing: Quick (8-15 minutes optimal)

script-writer-agent.js

list: {
  structure: ['hook', 'introduction', 'list_items', 
              'bonus_item', 'summary', 'cta'],
  tone: 'engaging',
  pacing: 'quick'
}

Review

Structure: Hook → Introduction → Overview → Pros → Cons → Comparison → Verdict → CTA

Best For: Product reviews, comparisons

Pacing: Detailed (8-12 minutes optimal)

script-writer-agent.js

review: {
  structure: ['hook', 'introduction', 'overview', 'pros', 
              'cons', 'comparison', 'verdict', 'cta'],
  tone: 'analytical',
  pacing: 'detailed'
}

Story

Structure: Hook → Setup → Conflict → Journey → Climax → Resolution → Lesson → CTA

Best For: Personal stories, case studies

Pacing: Dynamic (10-20 minutes optimal)

script-writer-agent.js

story: {
  structure: ['hook', 'setup', 'conflict', 'journey', 
              'climax', 'resolution', 'lesson', 'cta'],
  tone: 'narrative',
  pacing: 'dynamic'
}

Core Methods

generateScript()

Main method that orchestrates the entire script generation process.

script-writer-agent.js

async generateScript(strategy) {
  this.logger.info(`Generating script for: ${strategy.topic}`);
  
  const template = this.templates[strategy.contentType.toLowerCase()] 
    || this.templates.explainer;
  
  // Generate script components
  const hook = await this.generateHook(strategy);
  const introduction = await this.generateIntroduction(strategy);
  const mainContent = await this.generateMainContent(strategy, template);
  const conclusion = await this.generateConclusion(strategy);
  const cta = await this.generateCTA(strategy);

  const script = {
    title: await this.generateTitle(strategy),
    hook,
    introduction,
    mainContent,
    conclusion,
    callToAction: cta,
    duration: this.estimateDuration(mainContent),
    tone: template.tone,
    pacing: template.pacing,
    keywords: strategy.keywords,
    metadata: {
      strategy: strategy,
      generatedAt: new Date().toISOString(),
      version: '1.0'
    }
  };

  script.fullScript = this.formatFullScript(script);
  await this.db.saveScript(script);
  
  return script;
}

generateHook()

Creates attention-grabbing opening hooks using proven patterns.

script-writer-agent.js

async generateHook(strategy) {
  const hooks = [
    {
      type: 'question',
      text: `Have you ever wondered ${this.generateQuestionAbout(strategy.topic)}?`
    },
    {
      type: 'statistic',
      text: `Did you know that ${this.generateStatistic(strategy.topic)}?`
    },
    {
      type: 'statement',
      text: `${strategy.topic} is about to change everything, and here's why...`
    },
    {
      type: 'challenge',
      text: `Most people think they understand ${strategy.topic}, but they're completely wrong.`
    },
    {
      type: 'promise',
      text: `In the next few minutes, you'll learn exactly how to master ${strategy.topic}.`
    }
  ];

  const selected = hooks[Math.floor(Math.random() * hooks.length)];
  
  return {
    type: selected.type,
    text: selected.text,
    duration: '0:00-0:05'
  };
}

The first 5 seconds are critical for retention. The agent uses proven hook patterns that have been shown to maximize viewer engagement.

generateSolutionSteps()

Creates detailed step-by-step content for tutorial videos.

script-writer-agent.js

async generateSolutionSteps(strategy) {
  const steps = [];
  const numSteps = 3 + Math.floor(Math.random() * 3); // 3-5 steps
  
  for (let i = 1; i <= numSteps; i++) {
    steps.push({
      number: i,
      title: `Step ${i}: ${this.generateStepTitle(strategy.topic, i)}`,
      description: this.generateStepDescription(strategy.topic, i),
      tip: this.generateProTip(strategy.topic)
    });
  }
  
  return {
    type: 'solution_steps',
    title: 'The Solution',
    steps,
    duration: steps.length * 45 // 45 seconds per step
  };
}

generateListItems()

Creates countdown-style list content optimized for engagement.

script-writer-agent.js

async generateListItems(strategy) {
  const items = [];
  const numItems = 5 + Math.floor(Math.random() * 6); // 5-10 items
  
  for (let i = 1; i <= numItems; i++) {
    items.push({
      number: numItems - i + 1, // Countdown for engagement
      title: this.generateListItemTitle(strategy.topic, i),
      description: this.generateListItemDescription(strategy.topic),
      impact: this.generateImpactStatement()
    });
  }
  
  return {
    type: 'list_items',
    title: `Top ${numItems} Things About ${strategy.topic}`,
    items,
    duration: items.length * 30 // 30 seconds per item
  };
}

Script Structure

Every generated script follows this structure:

1. Hook (5 seconds)

   Attention-grabbing opening using one of 5 proven hook patterns

2. Introduction (15 seconds)

   Greeting, topic introduction, value proposition, and credibility statement

3. Main Content (5-15 minutes)

   Template-specific content structured for maximum engagement

4. Conclusion (30 seconds)

   Recap of key points and final thought

5. Call-to-Action (15 seconds)

   Subscribe, like, comment prompts and next video suggestion

Duration Estimation

The agent calculates precise video duration:

script-writer-agent.js

estimateDuration(mainContent) {
  const totalSeconds = mainContent.sections.reduce((total, section) => {
    return total + (section.duration || 60);
  }, 0);
  
  // Add hook, intro, conclusion, CTA
  const fullDuration = totalSeconds + 5 + 15 + 30 + 15;
  
  return this.formatDuration(fullDuration); // Returns "8:45" format
}

Hook

5 seconds

Intro

15 seconds

Content

Variable

CTA

45 seconds

Script Formatting

Scripts are formatted for easy reading and production:

script-writer-agent.js

formatFullScript(script) {
  let fullScript = '';
  
  // Title
  fullScript += `TITLE: ${script.title}\n\n`;
  fullScript += '═'.repeat(50) + '\n\n';
  
  // Hook
  fullScript += `[${script.hook.duration}] HOOK\n`;
  fullScript += `${script.hook.text}\n\n`;
  
  // Introduction
  fullScript += `[${script.introduction.duration}] INTRODUCTION\n`;
  fullScript += `${script.introduction.greeting}\n`;
  fullScript += `${script.introduction.topicIntro}\n`;
  fullScript += `${script.introduction.valueProposition}\n\n`;
  
  // Main Content with timing markers...
  
  return fullScript;
}

Example Output

TITLE: Ultimate Guide to AI Technology Trends (2026)

══════════════════════════════════════════════════

[0:00-0:05] HOOK
Have you ever wondered why AI technology is becoming so important?

[0:05-0:20] INTRODUCTION
Hey everyone, welcome back to the channel!
Today, we're diving deep into AI Technology Trends.
By the end of this video, you'll understand exactly what AI technology is and why it matters.
I've spent months researching this topic

[0:20-5:00] MAIN CONTENT
──────────────────────────────

[0:45] THE CHALLENGE
Many people struggle with AI Technology Trends.
The main issues are:
1. Lack of clear information
2. Complexity and confusion
3. Not knowing where to start

...

Engagement Techniques

Pattern Interrupts

Strategic placement of questions, statistics, and surprises every 60-90 seconds to maintain attention

Value Stacking

Each section provides new value, keeping viewers engaged to learn more

Social Proof

Includes credibility statements and references to research/data

Storytelling Elements

Uses narrative techniques even in educational content

Configuration Options

Customize script generation through environment variables:

.env

# Default video duration target (minutes)
DEFAULT_DURATION=10

# Script tone (educational|casual|professional)
DEFAULT_TONE=educational

# Include pro tips in tutorial steps
INCLUDE_PRO_TIPS=true

# Content density (low|medium|high)
CONTENT_DENSITY=medium

Script Output Example

{
  "title": "Ultimate Guide to AI Technology Trends (2026)",
  "hook": {
    "type": "question",
    "text": "Have you ever wondered why AI technology is becoming so important?",
    "duration": "0:00-0:05"
  },
  "introduction": {
    "greeting": "Hey everyone, welcome back to the channel!",
    "topicIntro": "Today, we're diving deep into AI Technology Trends.",
    "valueProposition": "By the end of this video, you'll understand exactly what AI technology is and why it matters.",
    "credibility": "I've spent months researching this topic",
    "duration": "0:05-0:20"
  },
  "mainContent": {
    "sections": [
      {
        "type": "explanation",
        "title": "Deep Dive",
        "content": [...],
        "duration": 90
      }
    ],
    "totalDuration": 540
  },
  "duration": "8:45",
  "tone": "educational",
  "pacing": "steady"
}

Best Practices

Match Template to Content

Let the agent select the template automatically based on content type for optimal results

Review Generated Scripts

While scripts are production-ready, reviewing them allows you to add personal touches and brand voice

Monitor Retention Metrics

Use analytics data to identify which script patterns work best for your audience

Adjust Duration Targets

Different niches have different optimal durations. Experiment to find what works for your channel

Performance Metrics

Generation Time

2-5 seconds

Average Duration

8-12 minutes

Templates

5 specialized

Next Steps

Thumbnail Designer

See how thumbnails complement your scripts

SEO Optimizer

Learn how scripts are optimized for search

Production Agent

Discover how scripts become videos

API Reference

View complete API documentation