Building Agentic AI Systems
Go from a single LLM call to autonomous, production-shaped agents. A practical, build-along course where you ship one real assistant and level it up module by module.
One assistant, refactored as you learn
You build a Sales Ops Assistant early on, then keep refactoring the same project module after module — so every concept lands against working code.
From LLM Calls to an Agent SDK
Start at the metal: what a model call really does, how prompting shapes it, and how tool use works at the API level. You'll wire all of it together into a bare-bones Sales Ops Assistant that becomes the spine of the whole course.
Giving It Real Data — MCP & RAG
So far the assistant fakes its world: deal and analytics data is hardcoded JSON, and the sales playbook is one long document. You'll fix both — connecting live systems through MCP, and grounding answers in the playbook with RAG — by refactoring the assistant you already built.
Autonomy & Design Patterns
With tools, MCPs and RAG in place, the assistant can finally make decisions. We go deep on the patterns that make agents reliable rather than lucky — ReAct, CodeAct, Plan-and-Execute, Reflection and recursive language models — and when to reach for each. Along the way we cover the things autonomy forces you to handle: memory & state across steps and sessions, human-in-the-loop approval gates, and the security concerns that come with a connected, acting agent (prompt injection, sandboxing tools, least-privilege access).
Evaluation — Knowing It Actually Works
Agents are non-deterministic and multi-step, so they fail in ways unit tests never catch. Before optimising anything, you learn to judge quality properly: building eval sets from real failures, scoring whole trajectories rather than just final answers, using LLM-as-judge (and avoiding its traps), and setting up regression tests so improvements don't quietly break something else.
Prompt & Pipeline Optimisation
Now that you can measure quality, you can improve it systematically. Stop tweaking prompts by hand: optimise prompts and whole pipelines programmatically against the metrics you built in the previous module, so the agent gets measurably better while the underlying model stays the same.
LoRA Fine-Tuning with Tinker
Take it the last mile with lightweight LoRA fine-tuning, using the Tinker API end to end — so the model speaks your domain's language rather than relying on prompting alone.
Best Practices & Bringing It All Together
We close by stitching every piece into one coherent system and covering what production actually demands: cost, latency and token budgets; observability and tracing for multi-step runs; reliability patterns like retries, fallbacks and timeouts; and how multiple specialised agents coordinate. You leave with a checklist and a finished assistant you understand end to end.
Prerequisites
Basic knowledge of software design and architecture, and comfort with JavaScript. No prior ML experience required.
Pick the schedule that fits your week
Two ways to take the same 30-hour course — spread across weekday evenings, or condensed into focused weekends.
Evening Cohort
Weekend Cohort
Ship your first real agent this July
Both cohorts cover the same syllabus and the same hands-on build. Pick a date and reserve your seat.
Join a cohort