Agentic
Training
Ship agents from first principles.
A 6-week leveling course: LLM components, hand-built loops, then production systems in Python and TypeScript.
The bar
From “I’ve used ChatGPT” to a portfolio of working agents.
Students leave with engineering habits agents demand—evals, tracing, guardrails. Experienced engineers apply habits they already have to a new kind of component. Same finish line, whatever your start.
Method
Primitives before frameworks.
Build the agent loop by hand once. Measure behaviour from week one. Ship something every phase. Climb complexity only when the problem demands it.
01
Understand the component
Tokens, sampling, tools, cost, and failure modes—before you glue libraries together.
02
Build the loop yourself
Observe → plan → act → reflect, written line by line so frameworks never feel like magic.
03
Ship and operate
Evals, tracing, MCP, multi-agent tradeoffs, and a production-grade final project.
Six weeks
Lessons, labs, and projects that compound.
Interactive demos, bilingual code, quizzes, and an AI tutor on every unit—intensive at ~15 hours a week, or stretch to a semester pace.
Week 1
LLMs, tools, and retrieval
Treat the model as a component with an API, a price and predictable failure modes. Then give it tools and search over your own documents.
9 lessons · 1 lab · 1 project
You cover
- Tokens, context windows and cost
- Sampling and model tiers
- Prompting and structured output
- The tool-calling cycle
- Embeddings, hybrid search and reranking
- Your first eval
You build
- Lab 1
Raw API calls and a structured extractor. Call a model over plain HTTP with no SDK, then turn messy text into validated, typed data and measure how often it gets it right.
- Project 1
Docs assistant. Question answering over documents you know well, with retrieval exposed to the model as a tool.
Week 2
Agents by hand
Build every workflow pattern and the agent loop from raw API calls. No frameworks this week, so nothing is a mystery later.
9 lessons · 1 lab · 1 project
You cover
- Chaining, routing and parallelization
- Orchestrator-workers and evaluator-optimizer
- The agent loop and ReAct
- Stop conditions and budgets
- Tool design as API design
- Sandboxing tools
You build
- Lab 2
Workflow patterns side by side. Solve one task five ways, measure each, and see when each pattern pays off.
- Project 2
Mini coding agent. A coding agent with no framework that takes a small repository and a failing test, and makes the test pass.
Week 3
Planning and memory
Make agents plan, check their own work and remember, while keeping what enters the context window relevant.
8 lessons · 1 lab · 1 project
You cover
- Plan-and-execute and re-planning
- Reflection and self-critique
- When to pay for reasoning
- Compaction and long-term memory
- Context engineering
- Sub-agents for context isolation
You build
- Lab 3
Planner and reviewer. Add planning and review to your coding agent and measure whether they help.
- Project 3
Research agent. Researches a question across web sources, writes a cited report and remembers what it learned between sessions.
Week 4
Frameworks and MCP basics
Port your hand-built agent to two frameworks with different philosophies, then learn how MCP connects agents to tools and data.
9 lessons · 1 lab
You cover
- Why frameworks, and when not
- Graph-based: LangGraph
- Loop-based: OpenAI and Claude agent SDKs
- TypeScript-first: Vercel AI SDK and Mastra
- Durable state and human-in-the-loop
- MCP: tools, resources and prompts
You build
- Lab 4
Port Project 2 to two frameworks. Re-implement your coding agent in two frameworks and compare all three versions on the same benchmark.
Week 5
Protocols and multi-agent
Take MCP remote, connect agents to each other over A2A, and find out when a multi-agent design is worth what it costs.
6 lessons · 2 projects
You cover
- Transports and remote servers
- MCP authorization
- A2A: agent cards and tasks
- Multi-agent patterns
- The cost of multi-agent
- When multi-agent wins
You build
- Project 4
MCP server for a real system. A production-quality MCP server for a system you know: tested, documented and used from two hosts.
- Project 5
Multi-agent system. A supervisor-led system for a breadth-first task, with numbers showing whether it beats a single agent.
Week 6
Production and wrap-up
The work that separates a demo from a product: evals, tracing, security and cost, applied to an agent you already built.
10 lessons · 1 lab · 1 project
You cover
- Eval layers, graders and datasets
- Evals in CI
- Tracing and reliability
- Prompt injection and least privilege
- Human approval gates
- Cost, latency and deployment
You build
- Lab 6
Red-team your agent. Attack your own agent with 20 prompt-injection attempts, add defences and measure again.
- Project 6
Production hardening. Take an earlier project to production grade: eval scores, threat model, cost per task and a runbook.
Agentic Training
Sign in with a magic link and pick up at your week—progress stays with your account.






