A free "1-hour agentic engineering course" is tearing across X this week, shared with the same breathless caption every time: "Google just dropped a full course on building agents from scratch." Before you retweet it: the video is a third-party YouTube upload, and the Google attribution is the kind of claim that travels faster than anyone checks it. Ignore the branding. What's worth your attention is the syllabus, because whoever assembled it drew an accurate map of the entire modern agent stack — and that map is more useful than the hour of video.

Here's the whole thing, up front. The course is five modules, in this order, and the order is the point:

  1. Build your first AI agent
  2. Give it memory — short, persistent, long
  3. Agentic loops that run for hours on their own
  4. Build your own MCP — and when to instead of a plain API
  5. Multi-agent systems

Each layer depends on the one below it. That's why the sequence, not any single lesson, is the real curriculum. Below is the primary source and the hands-on build guide for each module — so you can spend the hour building one small thing per layer instead of watching.

Module 1 — Build your first agent (don't skip the loop)#

An agent is not a framework. It's a loop: call a model, let the model choose a tool, run the tool, feed the result back into the context, repeat until the model says it's done. Build that loop by hand once — twenty lines — before you reach for LangGraph or the Agents SDK, so you know exactly what the framework is doing for you later. Anthropic's Building Effective Agents is the single best primer on when you even need a loop versus a fixed workflow; our end-to-end build guide walks the minimal version with a real tool call.

Module 2 — Memory across three horizons#

The moment your agent needs to remember anything past one context window, you're in memory territory — and "memory" is really three different jobs. Short-term is the working context of the current turn. Persistent is state that survives across turns in a session. Long-term is durable recall that outlives the session entirely. Conflating them is the most common early mistake; each wants a different store and a different eviction rule. Start with the three kinds of agent memory, then wire the simplest working version with this how-to.

Memory is what lets the loop survive longer than a context window. Everything else in the stack is downstream of getting these three horizons straight.

Module 3 — Loops that run for hours#

A demo agent finishes in one breath. A useful one runs for hours — a research task, a migration, an overnight batch — and that changes the engineering problem entirely. Now you need durable state you can crash and resume from, context management so the run doesn't drown in its own history, and a checkpoint you can inspect when it stalls. The real decision here is checkpointing versus context management — do you persist the whole run and resume, or aggressively compact the context so the loop stays lean? We mapped that tradeoff in agentic loops that run for hours.

Module 4 — Build your own MCP (and the MCP-vs-API call)#

This is the module the viral posts phrase most honestly: MCP vs API. The Model Context Protocol is how a tool becomes portable — usable across many agents and clients instead of hard-wired into one loop. That portability is real value, and it's also not always worth the ceremony. If it's one agent calling your own functions, a plain API or direct calls are often the simpler right answer. MCP earns its place when the same tools must serve multiple agents, or agents you don't control. The spec is the primary source; when you decide it's worth it, build the server — or wrap the REST API you already have.

Module 5 — Multi-agent systems (reach for this last)#

The finale is the module everyone wants to start with and should end with. Splitting work across a team of agents buys you parallelism and specialization — and costs you coordination overhead, harder debugging, and a new class of failure where agents talk past each other. Most problems that feel like they need multiple agents need one better single agent with real memory and a clean tool interface. Before you split, be sure a single agent has genuinely hit its ceiling. When it has, the first real fork is deterministic versus LLM orchestration — who decides which agent runs next, your code or a model.

The takeaway the video buries#

The curriculum is right; the "Google dropped it" framing is noise. Learn the five layers in order, build one small thing at each, and treat module five as a destination you earn — not a starting line. The founders shipping real agents this year aren't the ones who watched the fastest course. They're the ones who built the loop, got the three memory horizons straight, made the run survive a crash, and only then reached for a second agent.