DeepLearning.AI Just Dropped a Course on Building AI Agents for Video. Here’s What’s Inside.

The hottest skill in AI right now is not writing prompts. It is building agents that generate video, check their own output, and fix it without you lifting a finger. DeepLearning.AI just released a course on exactly that.

It is called AI Agents for Image and Video Generation. It runs about 90 minutes, it was built in partnership with Google, and it is already featured as the flagship release on a platform that serves over 7 million learners globally. The timing is not accidental. Video AI has moved from novelty to production tool faster than most people expected, and the builders who understand how to wire evaluation loops into these pipelines are a step ahead of everyone still treating generation as a one-shot activity.

Here is what is inside, who it is actually built for, and whether you should bother.

Why This Course Exists Right Now

Generating an image or a clip from a prompt is the easy part. You type something, the model produces something. Fine. The harder problem is consistency at scale. When you need 50 product images that all match a brand guide, or a multi-scene explainer video where the lighting does not shift between cuts, a one-shot generation workflow collapses. There is no single correct answer to check against, so quality becomes a judgment call, and judgment calls do not scale.

The answer is evaluation pipelines baked directly into the agent loop. That is what this course teaches. Google’s Veo and Imagen models power the generation side; the course builds the scaffolding that makes them actually useful at scale.

Google’s Veo 3.1 (the current state-of-the-art video model accessible through the Gemini API) can generate up to 4K video with natively synchronized audio and frame-specific direction. Imagen handles the image generation side. The course uses these models as the engine, then teaches you to build the intelligent wrapper around them.

The Course at a Glance

Duration: 1 hour 24 minutes
Lessons: 9 video lessons, 6 code examples
Level: Intermediate
Instructors: Katie Nguyen (Developer Relations Engineer, Google Cloud AI) and Wafae Bakkali (Staff Generative AI Specialist, Google)
Built in partnership with: Google
Cost: Free to watch. Graded assignments and certificate require a DeepLearning.AI Pro membership ($25/month billed annually, $30/month billed monthly, with a 7-day free trial available)
Prerequisite: Basic Python familiarity and some experience working with LLM APIs

What You Actually Learn, Lesson by Lesson

Lesson 1: Introduction (3 min)

Sets up the problem clearly: generating a single output from a prompt is easy; generating consistent, high-quality output at scale requires evaluation in the loop. This frames everything that follows.

Lesson 2: Overview of Generative Media (9 min)

A mental model of the current landscape: how image, video, and audio generation models are architected, what they are good at, and where they still fall short. This is not a history lecture. It is the conceptual foundation you need to make smart architectural decisions later.

Lesson 3: Prompt Engineering for Image Generation (5 min + code)

Covers techniques that most people miss: LLM-enhanced prompting (using a language model to improve your image prompt before it hits the generation model), reference images, and structural constraints. The code example walks through this in practice.

Lesson 4: Prompt Engineering for Video Generation (7 min + code)

Video prompt engineering has its own quirks. Starting frames, camera motion descriptions, temporal consistency instructions, and how to specify what happens at a particular moment in the clip. This lesson covers all of it with hands-on code.

Lesson 5: Evaluation Techniques (12 min + code)

This is the core intellectual contribution of the course, and worth the enrollment on its own. Three complementary methods:

SigLIP image-text similarity scoring: Checks whether the generated output actually matches the prompt. Gives you a numerical score you can act on programmatically.
LLM-based judges: An LLM evaluates the output against custom criteria you define, like brand consistency or visual tone. More flexible than a similarity score, and better at catching qualitative mismatches.
Structured rubrics: Break a prompt into specific, verifiable yes/no questions. “Is the subject in the frame?” “Does the camera motion match the specified direction?” “Is the product logo visible?” Each becomes a checkable condition. Structured rubrics are especially valuable when you need to audit outputs systematically rather than eyeball them.

Combining all three is how you get an evaluation pipeline that catches different failure modes. A similarity score might not flag a technically matching image that breaks your brand guide. A rubric catches what the score misses.

Lesson 6: Image Generation Agent (10 min + code)

Here the evaluation techniques from Lesson 5 get wired into an actual agent. The project: an agent that takes brand guidelines as input, generates UI mockups, evaluates them against the guidelines automatically, and loops back to regenerate when results miss the bar. This is the full feedback loop, end to end.

Lesson 7: Video Generation Agent (10 min + code)

A more complex version of the same pattern, applied to multi-scene video. The agent plans the scenes, generates and animates reference frames with synchronized audio, then evaluates temporal consistency across the whole sequence. The evaluation step checks that lighting, character appearance, and camera motion hold together between clips.

Lesson 8: Building a Media Agent with AI (12 min)

The final build lesson uses Gemini CLI to construct a generative media agent in natural language. You describe what you want the agent to do, and the CLI builds the scaffolding. The lesson packages everything you have learned into reusable agent skills.

Lesson 9: Conclusion (2 min)

Wraps up the mental model and points toward what to build next.

Who This Is Actually Built For

The course page says “AI builders who want to extend agentic workflows beyond text into visual media.” That is honest. Here is a more specific read:

This course fits you if:

You have already built text-based AI agents or pipelines and want to add visual generation to them
You work in marketing, content, product, or design and want to understand how to systematize AI-generated visual assets (not just one at a time)
You are a developer building on top of Google’s Gemini API or Vertex AI and want to add image/video generation with evaluation built in
You want a practical, hands-on course from instructors who work at Google and use these tools daily

This course is not for you if:

You have never written Python. The prerequisite is real. The code examples are not copy-paste tutorials.
You want a course on how to prompt image or video tools as a user. This is about building autonomous agents, not one-shot generation.
You are looking for a no-code or non-technical overview. The Gemini CLI lesson is as close as it gets, and it still involves structured commands.

The Free vs. Pro Question

All 9 video lessons are free to watch on DeepLearning.AI’s platform, no account required. You can go through every lesson, see every code walkthrough, and absorb the full curriculum at zero cost.

The graded assignment and the certificate require a DeepLearning.AI Pro membership. Pro is $25/month billed annually or $30/month billed monthly, and there is a 7-day free trial. With Pro, you also get access to the full course catalog (150+ programs), hands-on coding labs, and new content released weekly.

Here is the practical read: if you are evaluating whether this course is worth your time, go through the free lessons first. If the evaluation techniques lesson (Lesson 5) clicks for you and you want the graded project, the Pro trial gives you room to finish the course without committing to a long subscription.

Check the current Pro membership pricing page for the latest rates before enrolling, as these can be updated.

How to Enroll and Get Started

Go directly to the course page. Head to deeplearning.ai/courses/ai-agents-for-image-and-video-generation. No login required to browse.
Watch the intro video. It is 3 minutes. If the problem framing makes sense to you, you are in the right place.
Create a free account. Click “Start Learning.” Sign up with your email. The video lessons become immediately accessible.
Work through Lessons 1 to 5 in one sitting. The first five lessons total about 36 minutes. They give you the full mental model and the evaluation techniques. Lesson 5 especially is worth pausing and re-watching once.
Set up your Python environment before Lesson 3. You will need Python installed and a Google Cloud or Gemini API key to run the code examples locally. The course provides Jupyter notebooks; you can also run them in Google Colab without installing anything.
Start the Gemini API trial if you do not already have access. The course uses Google’s Imagen and Veo models via the Gemini API. There is a free tier with usage limits, which is enough to run the course examples.
Complete Lessons 6 and 7 with the code open alongside the video. These are the agent-building lessons. Pause, run the code, modify a parameter, and see what breaks. That trial-and-error moment is where the concepts actually land.
Finish with Lesson 8 (Gemini CLI). This is where you package your agent into reusable skills. If you are planning to build something with this immediately after, this lesson gives you the workflow template.
Decide on Pro if you want the certificate. The 7-day trial gives you time to complete the graded quiz and earn the certificate. If you want the credential for your portfolio or LinkedIn profile, activate the trial after completing the free lessons.

Why the Timing Actually Matters

Video generation moved from research demo to production API faster than almost anyone predicted. Google’s Veo 3.1 is accessible through the Gemini API right now, generating up to 4K video with natively synchronized audio. Imagen 4 is publicly available on Vertex AI. The tools exist. What most builders are missing is the evaluation layer that makes them usable at scale.

That gap is exactly what this course addresses. Building a pipeline that generates, evaluates, and iterates is not a niche skill for research engineers. It is quickly becoming a baseline for anyone building visual AI workflows in production. A designer automating brand asset creation needs it. A developer building a marketing tool needs it. A startup founder trying to ship a video generation feature without a QA team needs it.

DeepLearning.AI releasing this course now, in partnership with the team at Google that built the underlying models, is the clearest possible signal that this skill set is moving from “advanced” to “expected.”

The course is 84 minutes. The evaluation techniques lesson is 12 minutes. If you take nothing else from it, Lesson 5 alone will change how you think about what a generative AI pipeline should actually do.

Enroll in AI Agents for Image and Video Generation on DeepLearning.AI

The agents that generate, evaluate, and fix their own visual output are already being built. The question is whether you are building them or waiting for someone else to ship the tools.