Agentic AI

Lesson 1: Introduction to Prompting for Effective LLM Reasoning and Planning 

Introduces the core concepts of Agentic AI, the course structure, prerequisites, and learning environment. 

Lesson 2: The Role of Prompting in Agentic AI with Python and OpenAI 

Learn what AI agents are and how prompting guides them to reason, plan, and act toward goals. 

Lesson 3: Role-Based Prompting 

Explore how roles and personas shape tone, expertise, and behaviour in agent outputs. 

Lesson 4: Implementing Role-Based Prompting with Python 

Practise building role-based prompts to create a believable historical persona. 

Lesson 5: Chain-of-Thought and ReAct Prompting 

Understand frameworks for guided reasoning and action-oriented planning. 

Lesson 6: Applying CoT and ReAct Prompting with Python 

Implement reasoning and action prompts to solve a retail analytics problem. 

Lesson 7: Prompt Instruction Refinement 

Learn systematic approaches to refining prompts across role, task, context, and output. 

Lesson 8: Applying Prompt Instruction Refinement with Python 

Iteratively refine a prompt to transform a generic tool into a structured dietary consultant. 

Lesson 9: Chaining Prompts for Agentic Reasoning 

Design multi-step workflows by chaining prompts with validation checkpoints. 

Lesson 10: Chaining Prompts with Python 

Build a three-stage prompt chain with gate checks to automate insurance claim triage. 

Lesson 11: LLM Feedback Loops 

Design systems where agents improve outputs through iterative feedback. 

Lesson 12: Implementing LLM Feedback Loops with Python 

Create a self-debugging agent that generates and tests Python code. 

Lesson 1: Introduction to Agentic Workflows 

Explore the foundational concepts of agentic workflows and system setup. 

Lesson 2: Understanding Agentic Workflows 

Learn the core components of modern AI agents and workflow types. 

Lesson 3: Agentic Workflow Modeling 

Design and visualise agentic workflows using common agent patterns. 

Lesson 4: Agentic Workflow Implementation 

Translate workflow models into Python code and orchestrate agent interactions. 

Lesson 5: Prompt Chaining Workflow Pattern 

Break down complex tasks into sequential agent workflows. 

Lesson 6: Implementing Prompt Chaining with Python 

Build a multi-agent chain that passes information step by step. 

Lesson 7: Routing Workflow Pattern 

Design routing systems that dispatch tasks to specialised agents. 

Lesson 8: Implementing Routing with Python 

Create a routing agent that classifies requests and orchestrates responses. 

Lesson 9: Parallelisation Workflow Pattern 

Run multiple agent tasks concurrently and aggregate results. 

Lesson 10: Implementing Parallelisation with Python 

Use Python threading to build concurrent agent workflows. 

Lesson 11: Evaluator–Optimiser Workflow Pattern 

Iteratively improve outputs through critique and refinement loops. 

Lesson 12: Implementing Evaluator–Optimiser with Python 

Build a creator–critic system that refines outputs until constraints are met. 

Lesson 13: Orchestrator–Workers Workflow Pattern 

Design systems where a central agent plans and delegates work dynamically. 

Lesson 14: Implementing Orchestrator–Workers with Python 

Build an agentic market analysis system with specialised workers. 

Lesson 1: Introduction to Building Agents 

Set up tools and environments for agent development. 

Lesson 2: Extending Agents with Tools 

Integrate tools to enable real-time actions and data access. 

Lesson 3: Building Agents with Tools in Python 

Develop and test tool-enabled agents using the OpenAI SDK. 

Lesson 4: Structured Outputs 

Transform agent responses into validated, machine-readable outputs. 

Lesson 5: Implementing Structured Outputs with Pydantic 

Create validated JSON outputs for reliable automation. 

Lesson 6: Agent State Management 

Design state machines that track context and decisions across workflows. 

Lesson 7: Implementing Agent State with Python 

Build dynamic workflows using Python state machines. 

Lesson 8: Short-Term Agent Memory 

Implement memory strategies to maintain coherence in active sessions. 

Lesson 9: Adding Agent Memory with Python 

Build persona-based agents with session continuity. 

Lesson 10: External Tools and APIs 

Integrate external APIs for real-time data and actions. 

Lesson 11: Integrating External Tools with Python 

Build agents that authenticate and interact with live systems. 

Lesson 12: Web Search Agents 

Enable agents to retrieve and ground responses in real-time information. 

Lesson 13: Creating Web Search Agents with Python 

Build a web-enabled agent using external search APIs. 

Lesson 14: Interacting with Databases 

Connect agents to SQL and vector databases. 

Lesson 15: Building Database Agents with Python 

Translate natural language into database queries. 

Lesson 16: Agentic Retrieval Augmented Generation 

Enhance RAG systems with reflection and retry loops. 

Lesson 17: Agentic RAG with Python 

Build adaptive document retrieval systems. 

Lesson 18: Long-Term Agent Memory 

Design persistent memory strategies for agents. 

Lesson 19: Maintaining Long-Term Memory with Python 

Implement long-term memory using vector databases. 

Lesson 20: Agent Evaluation 

Assess agent performance, quality, and reliability. 

Lesson 21: Evaluating Agents with Python 

Design evaluation frameworks and test cases. 

Lesson 1: Introduction to Multi-Agent Systems 

Learn the fundamentals of multi-agent architectures. 

Lesson 2: Designing Multi-Agent Architecture 

Design high-level system architectures for agent teams. 

Lesson 3: Implementing Multi-Agent Architecture with Python 

Code multi-agent systems with well-defined interfaces. 

Lesson 4: Orchestrating Agent Activities 

Coordinate agent actions across complex workflows. 

Lesson 5: Implementing Agent Orchestration 

Apply orchestration patterns for multi-step execution. 

Lesson 6: Routing and Data Flow in Agentic Systems 

Manage information flow between agents. 

Lesson 7: Implementing Routing and Data Flow 

Build intelligent routing agents. 

Lesson 8: State Management in Multi-Agent Systems 

Track and update state across agent interactions. 

Lesson 9: Implementing State Management 

Synchronise state across multiple agents. 

Lesson 10: Multi-Agent Orchestration and Coordination 

Resolve conflicts and manage shared resources. 

Lesson 11: Implementing Orchestration and Coordination 

Build concurrent multi-agent systems. 

Lesson 12: Multi-Agent Retrieval Augmented Generation 

Extend RAG systems across agent teams. 

Lesson 13: Implementing Multi-Agent RAG 

Build cooperative retrieval and synthesis agents.