Course · Agentic AI
Systems that act, and the loops that keep them honest.
An 8-week agentic AI course on tool use, reasoning loops, memory, multi-agent coordination, MCP, and the evaluation that keeps autonomous systems trustworthy.
- 8 weeks
- Advanced
- LangGraph
- MCP
- Multi-agent
- Duration
- 8 weeksDuration
- Effort
- 8 hours per weekEffort
- Level
- Intermediate to AdvancedLevel
- Modules
- 8Modules
The premise
Agent demos are easy and agent systems are not. The gap is entirely in the parts demos skip: termination, retries, memory that does not poison the next run, coordination costs, and evaluation of a system whose output changes every time. This course is about that gap.
Who it is for
- Engineers who have shipped an LLM feature and hit its ceiling
- Teams evaluating agent frameworks before committing
- Platform engineers building internal agent infrastructure
- Researchers working on multi-agent systems
Prerequisites
- Have called an LLM API from your own code
- Understand RAG at a working level
- Comfortable with async Python and debugging
Outcomes
What you can do at the end.
Write an agent loop from scratch and know exactly why each line is there
Design tools with schemas and error surfaces an agent can recover from
Choose between a workflow, a single agent, and a multi-agent system on evidence
Give agents memory that helps rather than accumulates
Build and consume MCP servers
Evaluate and trace agent runs well enough to debug them in production
Syllabus
8 modules, in this order.
The agent loop from scratch
6 hours
- Perception, decision, action, termination
- Why most agent failures are loop failures
- Building one in 100 lines with no framework
Tools and function calling
6 hours
- Schema design and description writing
- Error surfaces the model can act on
- Idempotency, side effects, and dry runs
Orchestration with LangGraph
8 hours
- Explicit state and graph structure
- Checkpointing, interrupts, and human in the loop
- When a graph beats a loop, and when it is overhead
Model Context Protocol
6 hours
- Building an MCP server
- Resources, tools, and prompts as a boundary
- Reusing capability across clients
Memory
8 hours
- Working, episodic, and semantic memory
- What to persist, summarise, and discard
- Memory poisoning and how to detect it
Multi-agent systems
8 hours
- Supervisor, hierarchical, and blackboard patterns
- Communication protocols and the cost of coordination
- CrewAI, and where role-based framing helps
Context engineering for agents
6 hours
- Retrieval, ranking, compression, position
- Budgeting context across a long run
- Context rot and recovery strategies
Evaluation, tracing, and safety
8 hours
- Trajectory evaluation, not just final answers
- Tracing, cost attribution, and replay
- Guardrails, permissions, and blast radius
Capstone
Build a multi-step research and action agent with real tools, persistent memory, a trajectory evaluation suite, full tracing, and a written analysis of its failure modes under adversarial input.
Tools and stack
- Python
- LangGraph
- CrewAI
- MCP SDK
- Mem0
- Redis
- OpenTelemetry
- AgentOps
Delivery
How it can run.
Live cohort
Corporate batch
Self-paced
Corporate batches run against your own stack and swap the capstone for an internal use case. Campus delivery includes syllabus mapping, rubrics, and question banks — and faculty training if you want to own it afterwards.
FAQ
Agentic AI — questions
What is agentic AI?
Software that decides its own next step. Instead of a fixed pipeline, a model chooses which tool to call, reads the result, and decides whether to continue — inside a loop you design, with the termination conditions, permissions, and recovery paths you set.
Which agent framework does the course teach?
The loop is built from scratch first, without any framework, because that is the only way to see what frameworks are hiding. LangGraph and CrewAI come after, alongside MCP for capability boundaries. The point is judgement about which to use, not loyalty to one.
Is this suitable if I have only used ChatGPT?
No. You should have called an LLM API from your own code and built something with retrieval. Take the Generative AI course first; this one starts where that one ends.
Do you cover multi-agent systems?
Yes, a full module — supervisor, hierarchical, and blackboard patterns, communication protocols, and honest accounting of coordination overhead. A recurring finding in the labs is that a single well-designed agent often beats three coordinating badly.
How do you evaluate something non-deterministic?
By evaluating trajectories rather than only final answers: did it pick the right tool, recover from the error, terminate correctly. The course builds a harness that runs a fixed scenario set and reports success rate, cost, and step count per change.
Can we run this internally for our team?
Yes. Corporate batches use your own tools and internal APIs in the labs, so the capstone is an agent that operates against your systems rather than a sample one.
Other courses
12 weeks
Full Stack AI Engineering
A 12-week full stack AI course: build, deploy, and operate an AI application end to end — API, retrieval, agents, frontend, infrastructure, and monitoring.
8 weeks
Generative AI
An 8-week generative AI course covering LLMs, embeddings, RAG, fine-tuning, multimodal models, and safety — with working code at every stage.
6 weeks
Forward Deployed AI Engineer
A 6-week course for forward deployed AI engineers: scoping in the field, prototyping against messy customer data, integration, demos that convince, and handover that lasts.
Run this
for your people.
Tell us the cohort size, the hours available, and whether this is a corporate batch or a campus program. Scope and price come back in writing within two working days.
Request a proposal