Build an Automated YouTube Shorts Pipeline with AI Video Generation

The architecture

The pipeline has three layers. First, a JSON prompt library stores your video ideas with metadata about which model and aspect ratio to use. Second, a bash script reads the library and submits each prompt to agent-media CLI as an async job. Third, a monitoring step checks job status and downloads completed outputs into organized folders. Each layer is a simple, standalone script that you can modify, extend, or plug into a larger CI/CD workflow.

Step 1: Set up your prompt library

A prompt library is a JSON file that contains your video ideas. Each entry specifies a prompt, the target model, duration, and aspect ratio. Keeping prompts in a structured file makes it easy to iterate, add new ideas, and track what you have already generated.

[
  {
    "id": "cooking-01",
    "model": "seedance1",
    "prompt": "Chef plating a colorful dish, close-up hands, steam rising, restaurant kitchen",
    "duration": 5,
    "aspect_ratio": "9:16"
  },
  {
    "id": "nature-01",
    "model": "kling3",
    "prompt": "Bioluminescent jellyfish floating in deep ocean, ethereal blue glow, 4K cinematic",
    "duration": 5,
    "aspect_ratio": "9:16"
  },
  {
    "id": "urban-01",
    "model": "sora2",
    "prompt": "Time-lapse of city traffic at dusk, streaking headlights, skyscrapers in background",
    "duration": 8,
    "aspect_ratio": "9:16"
  },
  {
    "id": "fitness-01",
    "model": "seedance1",
    "prompt": "Athlete doing dynamic stretches in gym, energetic movement, motivational feel",
    "duration": 5,
    "aspect_ratio": "9:16"
  }
]

Notice that all entries use 9:16 aspect ratio — the native format for YouTube Shorts, TikTok, and Reels. The id field helps you track which prompt produced which output file.

Step 2: Write the batch generation script

This bash script reads your prompt library and submits each entry as an async job. It uses jq to parse the JSON and logs each job ID for later tracking. The key is not using --sync — by submitting all jobs asynchronously, they run in parallel on the server instead of sequentially.

#!/bin/bash
PROMPTS_FILE="prompts.json"
LOG_FILE="jobs-$(date +%Y%m%d).log"

echo "Starting batch generation at $(date)"
echo "---" >> "$LOG_FILE"

COUNT=$(jq length "$PROMPTS_FILE")
for i in $(seq 0 $((COUNT - 1))); do
  ID=$(jq -r ".[$i].id" "$PROMPTS_FILE")
  MODEL=$(jq -r ".[$i].model" "$PROMPTS_FILE")
  PROMPT=$(jq -r ".[$i].prompt" "$PROMPTS_FILE")
  DURATION=$(jq -r ".[$i].duration" "$PROMPTS_FILE")
  RATIO=$(jq -r ".[$i].aspect_ratio" "$PROMPTS_FILE")

  echo "Submitting [$ID] to $MODEL..."
  RESULT=$(agent-media generate "$MODEL" \
    -p "$PROMPT" \
    --duration "$DURATION" \
    --aspect-ratio "$RATIO")

  echo "$ID|$MODEL|$RESULT" >> "$LOG_FILE"
  echo "  -> $RESULT"

  sleep 2  # Brief pause between submissions
done

echo "All $COUNT jobs submitted. See $LOG_FILE"

Run the script with bash generate.sh and it will submit all four prompts in under 30 seconds. The log file maps each prompt ID to its job ID for easy tracking.

Step 3: Model selection strategy

Different content types work best with different models. Here is a decision framework for YouTube Shorts:

Step 4: Monitor job status

After submitting a batch, use the jobs command to track progress. The agent-media jobs list command shows all your recent jobs with their current status.

For automated pipelines, you can poll job status in a script. Check individual jobs with agent-media jobs status <job_id> and parse the output to trigger downloads when jobs complete.

Step 5: Download and organize outputs

Once jobs complete, you receive a direct URL to the output file. A download script reads your job log, checks completion status, and saves outputs into an organized folder structure.

#!/bin/bash
OUTPUT_DIR="outputs/$(date +%Y%m%d)"
mkdir -p "$OUTPUT_DIR"

while IFS='|' read -r ID MODEL JOB_ID; do
  STATUS=$(agent-media jobs status "$JOB_ID" --json \
    | jq -r '.status')

  if [ "$STATUS" = "completed" ]; then
    URL=$(agent-media jobs status "$JOB_ID" --json \
      | jq -r '.output_url')
    curl -sL "$URL" -o "$OUTPUT_DIR/$ID-$MODEL.mp4"
    echo "Downloaded: $ID-$MODEL.mp4"
  else
    echo "Skipping $ID ($STATUS)"
  fi
done < "jobs-$(date +%Y%m%d).log"

echo "Downloads complete -> $OUTPUT_DIR/"

Cost analysis: How many Shorts per plan

The cost of your pipeline depends on which models you use. Here is how many 5-second Shorts each plan tier supports at different model mixes:

*Mixed assumes 50% Seedance, 30% Sora, 20% Kling

Pro tips

Scaling up: GitHub Actions integration

For fully automated pipelines, trigger batch generation from GitHub Actions. Push new prompts to your repository and let CI handle the generation. Here is a minimal workflow that runs your batch script on every push to the prompts file:

name: Generate Shorts
on:
  push:
    paths: ['prompts.json']

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm install -g agent-media-cli
      - run: agent-media login --device-key ${{ secrets.AM_DEVICE_KEY }}
      - run: bash generate.sh

Store your device key as a GitHub Actions secret. Every time you add prompts to prompts.json and push, the workflow installs the CLI, authenticates, and runs your batch. The generated videos appear in your agent-media dashboard gallery, ready for download.