Youtube Agent

AI agent that researches, analyzes, and automates YouTube content workflows.

Comment 1

Inspiration

Managing a YouTube channel is way more than just uploading. Creators have to research competitors, spot trends, track posting cadence, optimize thumbnails, test titles, and keep audiences engaged—work that’s time-consuming and usually spread across pricey or fragmented tools.

This project started with a simple goal:

Help YouTube creators focus on creativity while an AI agent handles research, content strategy, and production support.

It’s built around agentic AI workflows and the Model Context Protocol (MCP) so the assistant can use real tools—not just generate text.

What it does

The Autonomous YouTube AI Agent bundles MCP-enabled tools and an agent to support the whole workflow:

  • Channel & competitor search/analysis (e.g., YouTube/LinkUp integrations): query channels by topic, language, and size; surface upload frequency, topic clusters, performance patterns, and thumbnail/title styles.
  • Video-level insights: pull metadata/transcripts, segment by scenes/topics, and extract hooks, formats, and retention risks.
  • Content ideation & drafting: generate video ideas, titles, descriptions, and script drafts using LLM reasoning (model choice is configurable).
  • Visuals: create thumbnails and cover/hero images with a Freepik-powered pipeline (text-to-image and reference-image enhancement).
  • Upload (in progress): YouTube uploader (OAuth) to push video, thumbnail, and metadata; returns the video ID.
  • Runs locally or remotely: connect from OpenAI Desktop or MCP Inspector; the React/Vite UI streams reasoning and tool output live over SSE.

How it was built

  1. Implemented an MCP server with FrontMCP (TypeScript) and Zod schemas; exposed tools for search, analysis, generation, and (in-progress) upload.
  2. Added a Google ADK agent (youtube_agent) that orchestrates tool calls and streams reasoning/output to the UI.
  3. Built a React + Vite frontend to render live traces/markdown via Server-Sent Events (SSE).
  4. Wired dynamic auth to FrontMCP through environment-provided headers and kept all credentials in local .env files (no secrets committed).
  5. Supported local dev with separate processes: MCP tools server, ADK API server, and the frontend—with CORS configured for local hosts.

Challenges

We ran into a lot of practical issues while shipping under time pressure:

  • API rate limits across multiple providers.
  • Google Agent ADK intermittently failing to serve the API and connect to the JavaScript frontend.
  • FrontMCP library issues—especially the auth system—causing the agent to fail to connect to MCP.
  • Freepik API and nano-banana not consistently generating the images we needed.
  • YouTube API quota and rate-limit constraints.
  • Gemini API rate limits.
  • Complex system design causing modules not to collaborate well with each other.
  • Over-scoped plan: the project was too big for the time window, so we couldn’t complete every idea or fully debug issues.
  • Deployment challenges for the agent system and MCP servers across environments.

What I learned

  • MCP as a clean toolchain layer: typed, schema-validated tools are far more reliable than ad-hoc prompting.
  • Agentic vs. prompt-only workflows: planning/execution loops, retries, and result consolidation are key to dependable autonomy.
  • YouTube analytics patterns: upload cadence, topic clusters, and creative packaging (titles/thumbnails/hooks) strongly affect performance.
  • Credential hygiene in practice: env management, per-tool keys, and short-lived auth headers for MCP; never commit secrets.
  • Shipping locally & remotely: a typed ADK backend + streaming UI makes it easier to demo, debug, and plug into OpenAI Desktop / MCP Inspector.

Built With

Share this project:

Updates