VOOZH about

URL: https://www.coursera.org/learn/ai-agents-python

⇱ AI Agents and Agentic AI with Python & Generative AI | Coursera

AI Agents and Agentic AI with Python & Generative AI

Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

AI Agents and Agentic AI with Python & Generative AI

This course is part of multiple programs.

Instructor: Dr. Jules White

Top Instructor

82,104 already enrolled

Included with

Ask Coursera

Gain insight into a topic and learn the fundamentals.
4.6

440 reviews

Beginner level

Recommended experience

Flexible schedule
1 week at 10 hours a week
Learn at your own pace
87%
Most learners liked this course
Gain insight into a topic and learn the fundamentals.
4.6

440 reviews

Beginner level

Recommended experience

Flexible schedule
1 week at 10 hours a week
Learn at your own pace
87%
Most learners liked this course

What you'll learn

  • Build a complete AI agent framework in Python, creating each component yourself to gain deep understanding of how agents work

  • Design tool discovery systems and function calling mechanisms that allow your agents to interact with external systems and perform meaningful actions

  • Create practical, production-ready agents for tasks like intelligent file exploration, documentation generation, and coding

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

3 assignments

Taught in English

Build your subject-matter expertise

This course is available as part of
When you enroll in this course, you'll also be asked to select a specific program.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 5 modules in this course

AI Agents Are the Next Leap in Software. Learn to Build Them in Python.

AI agents aren't passive tools. They think, act, and solve problems—without waiting for instructions. That's the future of software. And in this course, you'll learn how to build it. Frameworks come and go. Principles last. This course cuts through the noise to teach you how AI agents really work—using Python, the leading language for AI development. Forget tutorials on trendy APIs that'll be dead by next quarter. You'll learn to build AI agents from the ground up. No fluff. No shortcuts. Just the core architecture that powers intelligent systems—knowledge that stays useful no matter how fast the landscape shifts. In this course, you will: - Master Python-based agent architectural fundamentals - Understand the core GAME components (Goals, Actions, Memory, Environment) that make AI agents tick and how they work together in a cohesive Python system - Leverage Python's strengths for efficient agent development - Use Python's dynamic typing, decorators, and metaprogramming to create flexible, maintainable agent frameworks with minimal boilerplate code - Rapidly prototype and implement Python agents - Learn techniques to quickly design Python agent capabilities with prompt engineering before writing a single line of code, then efficiently translate your designs into working Python implementations - Connect Python AI agents to real-world systems - Build Python agents that can interact with file systems, APIs, and other external services - Create Python-powered tool-using AI assistants - Develop Python agents that can analyze files, manage data, and automate complex workflows by combining LLM reasoning with Python's extensive libraries and ecosystem - Build Python developer productivity agents - Create specialized Python agents that help you write code, generate tests, and produce documentation to accelerate your software development process Why Principles Matter More Than Frameworks The AI landscape is changing weekly, but the core principles of agent design remain constant. By understanding how to build agents from scratch, you'll gain: - Transferable knowledge that works across any LLM or AI technology Deep debugging skills because you'll understand what's happening at every level - Framework independence that frees you from dependency on third-party libraries and allows you to succeed with any of them - Future-proof expertise that will still be relevant when today's popular tools are long forgotten By the end of this course, you won't just know how to use AI agents—you'll know how to build them in Python, customize them, and deploy them to solve real business problems. This course will teach you these concepts using OpenAI's APIs, which require paid access, but the principles and techniques can be adapted to other LLMs.

In this module, you’ll learn the core concepts behind agentic AI—systems that can plan, act, and adapt based on feedback. You’ll explore patterns like flipped interaction, agent loops, and programmatic prompting, and see how memory and structured outputs enable agents to operate autonomously. Tip: Focus on how agents decide what to do next. That decision-making loop is the foundation of everything you’ll build later.

What's included

4 videos4 readings2 assignments9 plugins

4 videos•Total 41 minutes
  • Introduction•10 minutes
  • Flipped Interaction Pattern•7 minutes
  • The Agent Loop•9 minutes
  • Adding Structure to AI Agent Outputs•15 minutes
4 readings•Total 40 minutes
  • Running the Code Samples in the Course•10 minutes
  • Try Out Programmatic Prompting•10 minutes
  • Try Out the Customer Service Agent•10 minutes
  • Learning More & Staying Connected•10 minutes
2 assignments•Total 45 minutes
  • Understanding Agentic AI Concepts•30 minutes
  • Knowledge Check: Agent Loop & Flipped Interaction•15 minutes
9 plugins•Total 135 minutes
  • Programmatic Prompting for Agents•15 minutes
  • Programmatic Prompting for Agents II•15 minutes
  • Programmatic Prompting for Agents III•15 minutes
  • Giving Agents Memory•15 minutes
  • Practicing Programmatic Prompting for Agents•15 minutes
  • Practicing Programmatic Prompting for Agents (Solution)•15 minutes
  • Building Your First Agent•15 minutes
  • AI Agent / Environment Interface•15 minutes
  • AI Agent Feedback and Memory•15 minutes

This module introduces the core components of AI agents, focusing on how they use structured prompts, tools, and actions to interact with real-world systems. You’ll learn how to design effective agent prompts using the GAIL framework, define tools clearly, and build agent loops that use feedback to make decisions. The module also covers function calling and best practices for creating reliable, structured agent behaviors.

What's included

4 videos4 readings1 assignment4 plugins

4 videos•Total 35 minutes
  • GAIL - Goals, Actions, Information, Language•7 minutes
  • Giving Agents Tools•8 minutes
  • Tool Descriptions and Naming•9 minutes
  • Tool Results and Agent Feedback•10 minutes
4 readings•Total 40 minutes
  • Try Out an Agent that Calls Python Functions•10 minutes
  • Try Out LLM Function Calling•10 minutes
  • Try Out an Agent Loop with Function Calling•10 minutes
  • Exercise: Extend the Function Calling Agent•10 minutes
1 assignment•Total 30 minutes
  • Understanding the AI Agent Loop•30 minutes
4 plugins•Total 60 minutes
  • Agent Tools in Python•15 minutes
  • Using Function Calling Capabilities with LLMs•15 minutes
  • An Agent Loop with Function Calling•15 minutes
  • Agent Tool Design Best Practices•15 minutes

This module introduces the GAME framework as a practical way to design AI agents before building them in code. You’ll explore how goals, actions, memory, and environment work together in an agent loop, how to simulate agent behavior in conversation, and how to translate the framework into modular, reusable Python code.

What's included

2 videos1 reading7 plugins

2 videos•Total 12 minutes
  • Overview of the GAME Framework•5 minutes
  • Simulating Agents in ChatGPT•7 minutes
1 reading•Total 10 minutes
  • Try Out the Agent Framework•10 minutes
7 plugins•Total 120 minutes
  • Designing AI Agents with GAME•15 minutes
  • Simulating GAME Agents in Conversation•30 minutes
  • Modular AI Agent Design•15 minutes
  • Agent Loop Customization•15 minutes
  • Implementing GAME in Code•15 minutes
  • How Your Agent Communicates with the LLM: The Agent Language•15 minutes
  • Putting It All Together: Document Your Code with a README Agent•15 minutes

In this module, you’ll learn how to design, organize, and maintain tools that AI agents use to take action. You’ll explore how Python decorators can keep tool definitions and documentation in sync, how to organize tools using tags and registries, and how to simplify agent development through reusable, well-structured tool systems.

What's included

1 reading3 plugins

1 reading•Total 10 minutes
  • Try Out the README Agent with the Decorator•10 minutes
3 plugins•Total 45 minutes
  • Keeping Agent Tools Up to Date with Python Decorators•15 minutes
  • Tool Organization for Agents•15 minutes
  • Refactoring Our README Agent•15 minutes

In this module, you’ll explore how AI agents are changing who can build software, how software is designed, and how information can be accessed and used. You’ll examine how simple tools plus agent intelligence can create powerful systems, and how capabilities like multimodal reasoning, flexible translation, and perspective generation open up new ways to solve problems. Tip: As you go through this module, focus less on “the right answer” and more on how AI agents expand what is possible in designing software and working with information.

What's included

4 videos1 plugin

4 videos•Total 16 minutes
  • Build the Impossible with AI Agents•1 minute
  • Rethinking How We Teach Innovation•4 minutes
  • Hallucination is a New Form of Computing•8 minutes
  • New Ways to Access and Extract Information•3 minutes
1 plugin•Total 15 minutes
  • The Inventory Management Agent•15 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Instructor ratings
4.8 (123 ratings)

Top Instructor

Vanderbilt University
52 Courses•1,199,972 learners

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Learner reviews

  • 5 stars

    76.62%

  • 4 stars

    14.38%

  • 3 stars

    3.82%

  • 2 stars

    2.69%

  • 1 star

    2.47%

Showing 3 of 440

JE
·

Reviewed on Sep 23, 2025

Excellent course, well-paced, a variety of non-boring delivery methods and practical examples in code.

CC
·

Reviewed on Jul 28, 2025

This was a great course and Dr. White is so very well-versed in the subject. His thinking "outside the box" in problem-solving is quite remarkable.

MM
·

Reviewed on Aug 7, 2025

Detail explanation from Basic AI features to advanced deep understanding very useful upgrading skill course.

Frequently asked questions

You'll learn how AI agents work and how to build them in Python in a way that's easier to understand and adapt later. It starts with what makes software agentic and how an agent loop works, then builds into tools, memory, feedback, and the GAME framework. You'll apply that through guided exercises such as creating agents that inspect files, call Python functions, and draft project documentation such as a README.

Some basic Python familiarity is helpful. The course moves quickly into functions, notebooks, decorators, and agent code rather than teaching Python syntax from scratch. If you can read and edit simple Python, you'll be in a much better position to follow the hands-on parts.

Yes, it's beginner-friendly if you're new to AI agents but not completely new to Python. The course starts with what agentic AI is and how an agent loop works, then uses guided exercises to build up from there. If you're looking for a no-code overview, or if basic Python still feels unfamiliar, it may still feel fairly fast-paced.

Plan on about 11 hours in total. At around 10 hours a week, that works out to roughly 1 to 2 weeks, depending on how much time you spend exploring the notebook exercises. The course includes lessons, readings, interactive exercises, and short written assignments.

Yes, there's real hands-on work, but it's mostly guided rather than a single open-ended project. You'll use interactive exercises and notebook-based practice to build agent loops, try function calling, and extend agents that can list files, read code, or generate documentation. That lets you apply each idea right after it's introduced instead of only reading about it. Some of the notebook exercises use OpenAI's APIs, so running those examples yourself requires paid API access.

The main topics are how agents are structured, how prompting shapes their behavior, and how they use tools, memory, and feedback. You'll also work through function calling, the GAME framework, and Python patterns for organizing and updating agent tools. By the end, you'll have a clear picture of how to design agents that can act on goals and interact with outside systems in a controlled way.

After finishing, you should be able to build a basic AI agent in Python that can follow a goal, choose from defined tools, and respond to results. You should also be able to prototype an agent's behavior with prompts and then turn that into working code for tasks like file exploration or documentation writing. A realistic outcome is a small assistant that reads project files and drafts a README based on what it finds.

It's more concept-first with guided hands-on work. The course spends time explaining how an agent is structured, then reinforces that through notebook exercises and small builds instead of a large independent project. It's a good fit if you want to understand why an agent works, not just follow a ready-made tutorial.

This course is a strong choice if you want to learn AI agents by building the core pieces in Python instead of leaning on a single framework. It focuses on transferable ideas like agent loops, tool use, and feedback, then reinforces them with interactive notebook practice and small agent builds. If you want a principles-first course that still includes real coding work, this is a better fit than a lighter overview or a tool-specific tutorial.

Financial aid available,