AI curriculum
Course outline for Agentic AI Foundations
Build a small agent with LangChain and see how it selects a next step from a goal, tools, and observed results. Compare this with a fixed workflow. Add simple planning and memory, inspect actual tool calls, and check proposed corrections. Keep the agent bounded through human oversight and enforced execution limits without assuming that reflection guarantees success.
Agentic AI Foundations Course Objectives
- Explain the goal, observations, choices, actions, and environment of an agent.
- Compare agent-selected steps with a fixed workflow for the same task.
- Build and run a small LangChain agent with typed tools.
- Use planning and explicit memory to guide work across steps.
- Check a proposed correction against independently observed results.
- Apply human oversight, resource limits, and stop or escalation conditions.
Pre-requisites
- Artificial Intelligence Foundations and Applied Generative AI or equivalent AI-limitations and prompting competence.
- Programming Language Concepts for AI Engineers or equivalent basic Python functions, collections, files, and program execution.
- Basic model/API familiarity helps; a prepared connection adapter supports the lab.
- No prior LangChain, LangGraph, or particular coding-agent product experience is required.
Before this course
Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.
Required preparation
- Programming Language Concepts for AI Engineers
- Artificial Intelligence Foundations
- Applied Generative AI
Recommended preparation
Readiness checks
- Artificial Intelligence Foundations and Applied Generative AI or equivalent AI-limitations and prompting competence.
- Programming Language Concepts for AI Engineers or equivalent basic Python functions, collections, files, and program execution.
- Basic model/API familiarity helps; a prepared connection adapter supports the lab.
- No prior LangChain, LangGraph, or particular coding-agent product experience is required.
Can write and run small Python programs and use model prompts. LangChain and agent loops are taught from the first working example; coding is required.
Find your place in the learning mapLab Setup
Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
A prepared Python environment with a verified stable LangChain release and compatible provider integration, authorized model access, synthetic policies, harmless tools, a small persistence adapter, and tests. Teach the smallest complete agent before extending it. Provide local event/result inspection; a paid tracing platform is not required. Verify versions, limit/approval support, credentials, quotas, costs, and exact execution behavior before delivery. No production message-sending permission or personal data is used.
Detailed Course Outline
Module 1: Build the first tool-using agent (2 hours)
- Agent components: Agent basics: goals, observations, actions, and environment.
- Fixed and selected steps: Fixed workflows versus model-selected steps and harness execution.
- First LangChain agent: LangChain setup, model connection, instructions, and create_agent.
- Typed Python tool: A small typed Python tool and its actual returned result.
- Tool feedback and results: Tool-call feedback, final response, and independent result inspection.
- Simpler alternatives: When rules, scripts, or human judgment are the better choice.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Build and run a minimal agent and compare it with a fixed workflow.
Module 2: Planning, memory, and reflection (2 hours)
- Planning and replanning: Small plans, dependencies, new observations, and justified replanning.
- Thread state and memory: Messages, thread state, checkpoints, and an explicit memory record.
- Memory relevance: Useful memory selection, stale facts, and authoritative records.
- Observable execution: Tool execution events and inspected results, not inferred private reasoning.
- Reflection and repair: Reflection as critique and proposed correction, not proof of repair.
- Changed input and handoff: Changed inputs, reruns, and task handoffs with necessary context.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Add a plan and memory record, then check their effect on actual runs.
Module 3: Keep the loop useful and bounded (2 hours)
- Progress and budgets: Goal checks, observable progress, call limits, and time/cost budgets.
- Failure patterns: Wrong tools, missing context, repetition, and unavailable dependencies.
- Middleware and controls: Framework middleware and application-owned validation or execution restrictions.
- Approval and interruption: Human approval, interruption, escalation, and uncertain external-effect status.
- Independent repair checks: Repeatable failure tests and independently checked repairs.
- Fixed-workflow comparison: Agent versus fixed-workflow outcomes and review effort.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Extend the agent with a bounded stop or handoff and verify its behavior.
Practical exercise
- Build a small LangChain support-desk agent over synthetic policies. Its job is to find relevant information and draft a response, not send it. Start from a minimal model-connection scaffold. Learners define or extend typed search/read and local draft tools, create the agent, run it, and inspect the actual tool arguments, results, and final artifact. Compare with a prepared fixed workflow.
- Add a small plan and explicit task-memory record using a provided persistence adapter. Change one stored fact and check it against the policy before reuse. Test an unavailable tool, an ineffective self-critique, and a forbidden operation. Add a call/step limit and human handoff. Verify the result outside the model's narration. Deterministic fixtures make adverse cases reproducible; actual model-backed agent runs and learner-authored code remain required.
Delivery and timing
- Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.
What you will produce
Build and run a small LangChain agent with tools, explicit memory, independent checks, and stop conditions.
How the work is checked
- Runnable learner code creates a LangChain agent with a typed tool.
- Actual model-backed execution uses tools and produces an independently checked draft.
- The explanation separates model selection, framework execution, and application authority.
- A changed observation, plan, or memory record influences the next-step decision.
- Independent evidence exposes an ineffective correction or incorrect success claim.
- A real control enforces the configured limit or forbidden-operation boundary.
- The comparison explains when agent selection adds value over the fixed workflow.
6 guided hours. A practical Python and LangChain foundation, not a noncoding agent survey. Learners run an actual bounded model/tool loop, explicit memory, and independent checks. Prepared model/storage adapters avoid an application-stack build. Multi-agent architecture and production recovery belong in later courses.
When another approach is better
- Use a fixed workflow when steps and inputs are known and agent selection adds uncertainty without value.
- Do not use autonomous execution when consequences cannot be checked or delegated authority is undefined.
How we train
Contact us for full course details, including duration, delivery options and lab requirements.
Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.
Discuss your learning goalsRelated Courses
These courses list this course as preparation.
Courses that require this course
- Agent Architecture and Orchestration
- Agent Interoperability and Protocols
- Agent Execution Environments
- Agent Platforms and Frameworks
- Event-Driven Workflow Design
- Dynamic and Agentic Workflows
- Context Engineering and Context Graphs
- LLM and Agent Evaluation
- Agent Security
- The Agent-Accessible Web