If you build with AI, you've seen the post: "Google just dropped a 1-hour course on agentic engineering from scratch," followed by a tidy timestamped syllabus — first agent at 00:00, agent memory at 08:24, agentic loops at 28:34, MCP at 40:04, graph engineering at the end. It has tens of thousands of likes. It's probably in your bookmarks.

We went looking for the actual video. Here's the honest result, up front: we could not verify a single official Google-published 1-hour course that matches that syllabus. What we found instead is a viral template — and, separately, a genuinely good free Google course that almost nobody in those threads is linking.

Why the "1-hour course" doesn't hold up#

The claim has three tells, and you can check them yourself:

None of this means agentic engineering isn't worth learning. It means that post is engagement bait wearing a syllabus. The good news: the five topics it lists are the right ones. So let's use them — pointed at sources you can actually trust.

Treat the viral post as a table of contents someone screenshotted. The course it promises doesn't exist; the curriculum it gestures at absolutely does.

The real Google course (free, and actually Google)#

If you want structure and ground truth, start here:

That's the difference between a screenshot and a syllabus you can cite.

The five things "agentic engineering" actually means — with a real guide for each#

Here's the useful part. The viral post's five headings are the shape of the field. Learn each one from something concrete — including, where we've built it, our own hands-on coverage:

  1. Build your first agent. An agent is a model plus tools plus a loop. Don't start with a framework; start from scratch so you understand the moving parts. Walk through building a minimal coding agent from scratch — it's the shortest path from "what is an agent" to a thing that runs.
  2. Agent memory (short, persistent, long). The single most-misunderstood topic. There are three kinds of memory, and each is wired differently — conflating them is why so many agents "forget" mid-task.
  3. Agentic loops / long-running agents. The loop is where planning, tool calls, and error handling live. The hard part isn't the loop — it's keeping the context usable as it grows, which is the whole context-editing vs. compaction tradeoff.
  4. MCP (the tool protocol). How agents talk to tools without you hand-wiring every integration. Start with tools vs. resources vs. prompts, then read code execution vs. direct tool calls for how the calls actually get made.
  5. Graph / multi-agent orchestration. Once one agent isn't enough, you're orchestrating several — and every serious agent framework has quietly become a graph. Understand why before you pick one.

The actual takeaway#

The fastest way to learn agentic engineering isn't watching an hour of anything. It's picking one small real task and building an agent that does it end to end — a model, two or three tools, a loop, and a place to keep state — then adding memory and error handling until it survives contact with reality.

Bookmark the Kaggle intensive for structure. Use the five links above to go deep where you're weakest. And the next time a "Google just dropped a course" post lands in your feed, spend ten seconds checking the channel before you spend an hour on it — the reposters didn't.