learning tracks
Learn agentic AI, in order
Three tracks, 32 lessons, one curriculum. Each step builds on the one before it and ends by handing you the next. Your progress saves in this browser — no account needed.
Beginner
New to agents, or used ChatGPT but never built one.
You can explain agents in plain words and have shipped your first MCP server.
0 of 8 done IntermediateYou’ve built a demo agent and want it to be reliable.
You can design, test, and debug an agent someone else depends on.
0 of 12 done AdvancedYou run agents for a team or company — or will soon.
You can put agents in production and defend the design to security, finance, and audit.
0 of 12 doneBeginner track
Understand what an agent really is, then build one that works — a tool server, an agent loop, and an agentic coding workflow.
- How an AI agent actually works: build the loop behind every framework Every agent framework wraps the same ~40-line loop: model decides, tool runs, result feeds back. Build it in plain Python and the whole ecosystem stops being magic. Tutorial
40 min - The agentic AI tech stack, layer by layer: what you actually need to build agents Seven layers make up every serious agentic system — models, serving, harness, protocols, knowledge, evals, and controls. What each layer does, the main options in each, and where the choices actually matter. Decision guide
- MCP vs. A2A vs. AG-UI: the agent protocol stack, explained with one diagram The three agent protocols solve three different problems — agent-to-tools, agent-to-agent, and agent-to-user. Learn which layer each owns and when you need more than one. Tutorial
25 min read - How to build your first MCP server, step by step (Python and TypeScript) Build a working Model Context Protocol server with tools and resources, connect it to a real client, and understand what actually happens on the wire. Tutorial
45–60 min - Claude Code from zero: an agentic coding workflow, step by step Install Claude Code, learn the core loop, and build up to a disciplined agentic workflow: CLAUDE.md, plan mode, custom skills, hooks, and MCP servers. Tutorial
50 min - How to write Agent Skills (SKILL.md) that work across coding agents A skill is a folder with a SKILL.md file that a coding agent loads only when it needs it. Build a working release-notes skill with a bundled script, put it where Claude Code, Codex, Copilot, Cursor and Gemini CLI can all find it, and fix it when it does not trigger. Tutorial
30 min - How to choose an LLM for your agent: Claude, GPT, Gemini, or open-weights General benchmarks predict agent performance poorly. The seven criteria that matter for agentic workloads, a tiering strategy that beats single-model loyalty, and the eval-driven way to decide. Decision guide
- How to build a personal AI agent for daily productivity (note and task triage) Build an agent that triages your notes into tasks, references, and archives — runnable today with zero API keys, upgradeable to any LLM, and scalable from personal to team use. Tutorial
40 min
Intermediate track
Structured outputs, real integrations, memory, multi-agent orchestration, and evals — the engineering that turns a demo into a system.
- Structured outputs for agents: make models emit JSON you can actually trust Agents break where prose meets code. Build the validate-and-retry loop that turns flaky model JSON into a reliable contract — in plain Python, runnable without an API key. Tutorial
35 min - How to wrap a REST API in an MCP server (without handing the agent the whole API) Turn any REST API into agent-safe MCP tools: a narrow allowlist instead of a proxy, PII redaction before the model sees data, and a fake API so you can test the whole thing offline. Tutorial
45 min - How to migrate an MCP server to the stateless 2026 spec (mcp v2 and TypeScript SDK v2) `pip install mcp` now gives you mcp 2.x and your FastMCP import breaks. Move a working MCP server to the stateless 2026-07-28 spec in Python and TypeScript, without locking out the clients that still use the old protocol. Tutorial
45 min - MCP servers vs. direct CLI calls: when each wins (with measured token costs) Agents can reach tools through an MCP server or by running CLI commands directly. A decision framework, real token counts for four MCP servers and their CLI equivalents, and what tool search changes. Decision guide
- Skills vs. tools vs. hooks vs. subagents vs. prompts: when to use what Agentic coding assistants offer half a dozen extension mechanisms, and picking wrong wastes context or bites silently. One decision table for instructions files, skills (which now include slash commands), MCP tools, hooks, and subagents. Decision guide
- Agent memory patterns: vector stores, knowledge graphs, and context engineering Why agents forget, the four memory patterns that fix it, and a working retrieval loop you can run in plain Python before you buy a vector database. Tutorial
40 min - RAG vs. agent memory vs. fine-tuning: which knowledge problem do you actually have? Three ways to make a model "know" things, routinely confused with each other. A diagnostic for picking the right one — and the order to try them in. Decision guide
- Multi-agent orchestration explained: build an orchestrator and sub-agents from scratch Build the agent harness pattern in ~80 lines of plain Python — an orchestrator that plans, delegates to specialist sub-agents, and synthesizes — with a mock model so you can run it instantly. Tutorial
50 min - Single agent vs. multi-agent: when splitting actually helps Multi-agent architectures are fashionable and usually premature. The three forces that genuinely justify a split, the costs nobody mentions, and a staged migration path. Decision guide
- Agent frameworks vs. rolling your own harness: build or buy the loop? LangGraph, CrewAI, Microsoft Agent Framework, Pydantic AI, the OpenAI, Google and Claude agent SDKs — or 200 lines of your own code? A decision framework based on what agent frameworks actually provide, plus a dated map of the options. Decision guide
- How to evaluate an AI agent: build a golden-task eval harness from scratch Agents without evals break silently on every prompt tweak. Build a small golden-task harness in plain Python — tasks, checks, scoring, and a regression gate you can run in CI. Tutorial
60 min - How to secure your agent supply chain: pinning, provenance, and MCP server vetting A hands-on guide to locking down the packages and MCP servers your agents run on: hash-pinned lockfiles, release cooldowns, provenance checks, .pth audits, SBOMs, and tool-definition pinning against MCP rug pulls. Every command tested. Playbook
Advanced track
Security, human oversight, observability, cost control, and governance for agents doing real work in production.
- Workflow vs. agent: when BPMN-style orchestration beats dynamic reasoning The most expensive architecture mistake in enterprise AI is putting an agent where a workflow belongs — or vice versa. A decision framework with a bright-line design principle. Decision guide
- Prompt injection for agentic systems: a working threat model When agents read email, web pages, and documents, every input is a potential instruction. The lethal trifecta, the controls that actually work, and the ones that only feel like they do. Playbook
- Human-in-the-loop patterns that scale: approval design for agent actions Naive HITL either rubber-stamps everything or drowns reviewers. Five approval patterns, a materiality matrix for choosing, and the metrics that tell you when to loosen the loop. Playbook
- Agent observability: what to log, what to alert on, and what to keep You cannot debug, defend, or bill what you did not record. The trajectory-log specification, the four signals worth alerting on, and retention that satisfies both engineers and auditors. Playbook
- How to trace AI agents with OpenTelemetry (agent, LLM, and tool spans) Instrument a small Python agent loop with the OpenTelemetry GenAI semantic conventions: one invoke_agent span per run, a chat span per model call, an execute_tool span per tool call, plus token usage and errors. Then use the trace to explain what a run cost and where its time went. Tutorial
45 min - Run agents locally: LLM serving plus MCP on your own hardware Serve an open-weights model with llama.cpp on your own machine (ARM64 included), expose an OpenAI-compatible endpoint, and wire a local agent loop to MCP tools — no cloud required. Tutorial
60–90 min - Long-running agent tasks: MCP Tasks vs. A2A tasks vs. durable execution When agent work takes minutes, hours, or a human approval, three different things called "tasks" compete for the job. What each one guarantees, what it does not, and how they fit together. Decision guide
- FinOps for AI agents: metering token spend before it meters you An architecture for agent cost governance: OpenTelemetry GenAI conventions for instrumentation, a gateway for enforcement, and the reporting dimensions finance will actually ask for. Playbook
- The agent adoption ladder: personal → team → enterprise, without the faceplant What actually changes when an agent graduates from one laptop to a team to a company — identity, secrets, review, cost — and the checklist for each rung. Playbook
- AI agent governance for regulated industries: a practical framework A working control framework for agentic AI in banks, insurers and other regulated organizations: five control layers, a worked example of a refund agent, and a mapping table to SR 26-2 concepts and EU AI Act articles. Playbook
- SR 26-2 explained: governing agentic AI when model-risk guidance excludes it SR 26-2 replaced SR 11-7 in April 2026 and explicitly puts generative and agentic AI out of scope. What the guidance actually says, what that exclusion does and does not mean, and a practical control framework for the agents that fall into the gap. Playbook
- EU AI Act timeline for AI agents after the Digital Omnibus (2026–2028) Which EU AI Act obligations already apply to AI agents, which moved under the Digital Omnibus (Regulation (EU) 2026/1744), and a checklist of what an agent team should do this quarter. Playbook
Progress is stored only in this browser.
newsletter
One practical agentic-AI guide in your inbox. No news, no hype.
Tutorials and decision frameworks as they ship. Unsubscribe anytime.