Where knowledge becomes capability.Enrol now
All courses
ARTIFICIAL INTELLIGENCE

Agentic AI

From machine learning foundations to a working, tested AI agent

View curriculum in LMS
COURSE SNAPSHOT
StatusCurriculum availableLesson videos being prepared
LevelIntermediate to advanced
Curriculum12 core modules · 70 teaching topics · 30 hands-on
Practice12 practice briefs · capstone project
01

About this course

A build-through course in agentic AI. It starts from what machine learning actually is, works up through transformers, large language models, prompting and retrieval, and then spends the second half building one real agent — AgentBot, an order-and-support agent — end to end: tools, agent loop, API, tests and an evaluation harness.

Eleven chapters take you from foundations to a production-ready agent, with a practice brief and a short self-check in every module and a capstone in which you build an agent for a domain you know well.

  • Agentic AI
  • LLM applications
  • RAG
  • pgvector
  • tool calling
  • FastAPI
  • Python
  • agent evaluation
02

What you’ll be able to do

  • Explain, in plain language, how an LLM produces text and what its parameters and context window actually control
  • Write prompts that hold up: system prompts, few-shot, chain-of-thought, and schema-bound JSON output
  • Build a retrieval pipeline over your own documents with embeddings and pgvector, and judge when retrieval is the wrong answer
  • Implement the perceive-reason-act-observe agent loop with real tool calling, rather than describing it
  • Choose between router, ReAct, planner-executor, multi-agent, self-reflection and human-in-the-loop patterns on evidence
  • Manage agent state, and instrument an agent so a failure can be traced rather than guessed at
  • Unit-test tools and evaluate whole-agent quality against a fixed question set
03

Before you start

What this course assumes you can already do.

  • Comfortable writing Python: functions, classes, virtual environments, reading a traceback.
  • Basic SQL and the ability to run a local PostgreSQL database (the environment set-up uses Docker).
  • Have called some HTTP API from code before; JSON is familiar.
  • No machine learning background needed.
04

The curriculum

Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.

Recaps and reference material are included in the LMS.

PART 1Foundations

01What AI actually means6 topics · practice brief · checkpoint

Place generative AI and agents inside the wider AI landscape, and be able to say which of the three learning paradigms a given problem needs — so later modules are not learned as folklore.

  • The Big Picture: What Does "AI" Actually Mean?Concept
  • The Three Tiers of AIConcept
  • The AI Hierarchy: A Map of the LandscapeConcept
  • How AI Systems Learn: The Three ParadigmsConcept
  • Why Now? The Convergence of Three ForcesConcept
  • Real-World AI Applications TodayConcept
PRACTICE

Classify three problems by learning paradigm

Take three problems from your own work or product: one where you have labelled outcomes, one where you only have raw records, and one where something acts and gets feedback. For each, place it in the AI hierarchy and name the paradigm that fits.

Knowledge checkpoint with explained answers

02Machine learning foundations6 topics · practice brief · checkpoint

Work through the ML pipeline end to end — features, splits, overfitting, metrics — and finish able to argue why classical ML alone cannot deliver the AgentBot use case.

  • The Core Idea: Learning From ExamplesConcept
  • The Machine Learning PipelineConcept
  • Key Concepts You Must KnowConcept
  • Common ML Algorithms: A Practical ReferenceConcept
  • Evaluation Metrics: How Do We Know If The Model Is Good?Concept
  • Why ML Alone Is Not Enough for AgentBotConcept
PRACTICE

Break a model on purpose, then measure it honestly

Train a small classifier on any tabular dataset you can get. First make it overfit deliberately, then fix it, and hold a test set back throughout as section 2.3.2 requires.

Knowledge checkpoint with explained answers

PART 2Language models, prompting and retrieval

03Neural networks, transformers and large language models8 topics · 1 hands-on · practice brief · checkpoint

Get from a single neuron to self-attention to a deployed LLM, then make a first API call from Python and understand every parameter you passed.

  • Neural Networks: The FoundationConcept
  • The Transformer Architecture: The LLM EngineConcept
  • What Is a Large Language Model (LLM)?Concept
  • How LLMs Generate Text: Token by TokenConcept
  • Key LLM Parameters You Need to KnowConcept
  • The Context Window: The Model's Working MemoryConcept
  • From Pretraining to Production: The Three StagesConcept
  • Calling an LLM from Python: Your First API CallHands-on
PRACTICE

Instrument your own first API call

Extend the API call into a small script you can learn from: the same prompt sent several times at different temperature settings, with tokens and latency recorded each time.

Knowledge checkpoint with explained answers

04Prompt engineering7 topics · practice brief · checkpoint

Treat the prompt as an engineered interface: system prompt, technique selection, guaranteed-shape output, and a context-window budget you control.

  • What Is Prompt Engineering?Concept
  • The Anatomy of a PromptConcept
  • The System Prompt: Your Most Important ToolConcept
  • Core Prompting TechniquesConcept
  • Structured Output: Getting JSON from LLMsConcept
  • Context Window ManagementConcept
  • Common Prompting Mistakes to AvoidConcept
PRACTICE

Make one prompt produce parseable output every time

Pick a task with a structured answer — extracting order details from a customer message, say. Write a prompt that returns JSON matching a schema you define, then try hard to break it.

Knowledge checkpoint with explained answers

05Retrieval-augmented generation9 topics · 4 hands-on · practice brief · checkpoint

Build a working RAG pipeline over your own documents with pgvector, and be able to explain why each stage exists and what breaks when it is skipped.

  • The Problem: LLMs Do Not Know Your DataConcept
  • What Is RAG?Concept
  • The RAG Pipeline: Step by StepConcept
  • Vector Embeddings: The Mathematics of MeaningDemonstration
  • Vector Databases: Storing and Searching Embeddings at ScaleConcept
  • Setting Up pgvector for AgentBotHands-on
  • The Document Processing PipelineHands-on
  • The Retrieval QueryHands-on
  • Putting It Together: Full RAG Query in AgentBotHands-on
PRACTICE

Build retrieval over documents you actually know

Index a document set whose answers you already know — your own team wiki, a product manual, past tickets. Run the full pipeline and 5.8 over it with pgvector.

Knowledge checkpoint with explained answers

PART 3Agent design

06From chatbot to agent6 topics · 2 hands-on · practice brief · checkpoint

Understand what actually changes when a model is allowed to act: the agent loop, tool calling, memory types, and the agent taxonomy you will be choosing from.

  • The Fundamental Shift: From Chatbot to AgentConcept
  • The Agent Loop: Perceive → Reason → Act → ObserveHands-on
  • Tool Calling: How Agents Take ActionHands-on
  • Types of Memory in AI AgentsConcept
  • Types of AI AgentsConcept
  • Agent Frameworks: Your ToolkitConcept
PRACTICE

Turn a chatbot into something that acts

Start from a plain question-answering script and add one real tool. Then make the loop explicit in the code — perceive, reason, act, observe — with each step logged.

Knowledge checkpoint with explained answers

07Production agent patterns4 topics · 4 hands-on · practice brief · checkpoint

Pick agent patterns deliberately rather than by default, and design the state management and observability that decide whether an agent survives contact with production.

  • Principles of a Production-Ready AgentHands-on
  • The Core Agent PatternsHands-on
  • Agent State ManagementHands-on
  • Observability: If You Cannot See It, You Cannot Fix ItHands-on
PRACTICE

Choose a pattern, then defend it against two others

Take one real workflow you would like to automate. Design it three times — as a router, as a ReAct tool-calling agent, and as planner-executor — then decide, and add the human-in-the-loop checkpoint from pattern 6 where it belongs.

Knowledge checkpoint with explained answers

PART 4Building AgentBot

08AgentBot: project foundations6 topics · 5 hands-on · practice brief · checkpoint

Stand up the real project: layout, dependencies, configuration, database schema and connection pooling — the parts that are boring until they are the reason nothing works.

  • Project Architecture OverviewConcept
  • Project Directory StructureHands-on
  • Requirements and DependenciesHands-on
  • Configuration ManagementHands-on
  • Database SchemaHands-on
  • Database Connection PoolHands-on
PRACTICE

Stand the project up and prove the foundations hold

Build out the AgentBot skeleton to 8.6 on your own machine, then deliberately test the parts people skip: configuration, migrations and the connection pool.

Knowledge checkpoint with explained answers

09AgentBot: building the tools5 topics · 5 hands-on · practice brief · checkpoint

Implement every tool the agent can call against a single contract, including the RAG search tool, and register them in the API schema format the model expects.

  • The Tool Implementation ContractHands-on
  • Order ToolsHands-on
  • Action ToolsHands-on
  • RAG Tool: Searching the Knowledge BaseHands-on
  • Tool Registry: Anthropic API Schema FormatHands-on
PRACTICE

Write a tool a model cannot misuse

Implement one order tool, one action tool and the RAG search tool against the single contract, then register all three in the schema format.

Knowledge checkpoint with explained answers

10AgentBot: the agent loop and API5 topics · 4 hands-on · practice brief · checkpoint

Assemble the working agent — system prompt, state, loop, FastAPI surface — and read a complete end-to-end trace of one real conversation.

  • The Complete System PromptHands-on
  • The Agent StateHands-on
  • The Agent Loop: Complete ImplementationHands-on
  • The FastAPI InterfaceHands-on
  • End-to-End Trace: A Complete ConversationDemonstration
PRACTICE

Assemble the agent and read your own trace

Wire the system prompt, state and loop to 10.3 behind the FastAPI interface. Then produce your own version of the end-to-end trace.

Knowledge checkpoint with explained answers

PART 5Testing and shipping

11Testing, evaluation and production readiness4 topics · 2 hands-on · practice brief · checkpoint

Test an agentic system for real: unit tests on tools, an evaluation harness for whole-agent quality, and a production checklist you would actually sign.

  • Testing an Agentic SystemConcept
  • Unit Testing the ToolsHands-on
  • Evaluating Agent QualityHands-on
  • Production ChecklistConcept
PRACTICE

Build the evaluation set before you trust the agent

Write unit tests for your tools as, then build a fixed evaluation set and score whole-agent behaviour against it as. Finally walk your own build against the production checklist.

Knowledge checkpoint with explained answers

PART 6Orientation and reference

12Orientation, references and appendices4 topics · 3 hands-on · practice brief · checkpoint

Know how to work through the course, where its ideas come from, how to get the AgentBot environment running, and where to look terms up.

  • Course introductionConcept
  • AgentBot environment setupHands-on
  • PrerequisitesHands-on
  • Quick start with DockerHands-on
PRACTICE

Get the environment running and check the sources

Follow appendix A to a working environment, then spot-check the reference list: pick three cited papers or resources and read enough of each to say what the course took from it.

Knowledge checkpoint with explained answers

05 · CAPSTONE

A working agent for a domain you know

Build one agent end to end, in a domain you understand well enough to judge its answers. AgentBot is the worked example; the capstone is the same shape applied to your own problem, so the evaluation set can be honest.

MILESTONES

Scope and tool surface — Define what the agent is for, and design its tool surface as an API before writing any of it.

Project foundations — Stand up the project so the rest of the build is not fighting the environment.

Agent build — Implement the tools, the loop and the interface, with the pattern choice argued.

Retrieval (where justified) — If retrieval is in scope, build it properly and measure it separately from the agent.

Evaluation and observability — Prove the agent works, and make it debuggable when it does not.

Honest handover — Write the document you would want if you inherited this agent on call.

KEEP EXPLORING

Next course

AI-Augmented Python and Azure for Manufacturing
Interested in Agentic AI?

Tell us about yourself or your team and we’ll let you know how and when you can take this course.