If your founder timeline looks like ours, one thing has crowded out everything else this week: a free, roughly one-hour walkthrough of "agentic engineering from scratch," reposted with some version of Google just killed ten paid AI-agent courses in one hour. The hype is doing its job. The syllabus underneath it is worth more than the hype, because it happens to be the exact stack every agent product ships on.

Here's the whole thing in one line: an agent is a loop with memory, and everything else — long-running behavior, MCP, multiple agents — is a decision you make when the loop or the memory hits a wall. Watch the hour for the shape. Then make these five calls.

1. The agent loop — write it raw once#

Strip away every framework and an "agent" is a while loop: send the model a prompt, let it ask for a tool, run the tool, feed the result back, repeat until it says it's done. That's it. LangGraph, the OpenAI Agents SDK, ADK — all of them are ergonomics wrapped around this loop. The single highest-leverage hour you can spend is writing it once with no framework, so you know what the framework is doing for you. We walked through exactly that in build an AI agent from scratch: the loop, no framework.

2. Memory — three tiers, and only one is a real decision#

The course's memory segment is the part most founders underrate. There are three tiers, and conflating them is the most common early bug:

Tiers one and two are free; the framework hands them to you. Tier three is the decision. Google's ADK models it cleanly — a Session, a State dict, and a MemoryService you can back with a throwaway in-memory store for prototyping or with Vertex AI Memory Bank for persistent, semantically-searchable memory across sessions. The question isn't whether to add long-term memory; it's where it lives — a managed service, a library like Mem0, or your own vector DB. We break that specific fork down in three kinds of agent memory.

3. Long-running loops — the wall is the context window, not the model#

The segment on "agentic loops that run for hours" names the real inflection point of the last year: the moment a task outlives a single context window. Founders reach for a bigger prompt. That's the wrong lever. A loop that runs for hours needs checkpointing (so a crash doesn't lose the run) and context management (so stale tool output doesn't crowd out what matters) — not more tokens.

The first time your agent has to run longer than one window, you stop building a prompt and start building a process.

This is where context editing, compaction, and a memory tool stop being nice-to-haves and become the difference between an agent that finishes and one that forgets its own goal halfway through. Our context editing vs compaction piece is the field guide for that wall.

4. MCP vs a plain API — a category, not a fork#

The course spends a segment on "MCP vs API," which sounds like a either/or and isn't. A plain API call is how your code talks to a service. MCP is a distribution standard that packages tools so any agent can discover and call them at runtime — turning an N-apps-by-M-tools wiring problem into N+M, and keeping your API keys behind the server where the model never sees them.

The decision is about reuse, not capability. One app calling a few tools you own? Hardcode the functions — less code, no network hop, a smaller token bill and attack surface. The same tools traveling across apps, or third-party tools you want discovered dynamically? That's what MCP is for. We drew the full line in MCP vs function calling: when you actually need a server.

5. Multi-agent — the pattern to reach for last#

The finale, "agent-as-a-tool," is genuinely elegant: wrap a specialist agent so an orchestrator can call it like any other tool, and you get a team of narrow experts instead of one overloaded generalist. It's also the layer founders adopt too early. Most tasks that look like they need a team are one agent that needs better tools, tighter instructions, or memory. Exhaust the single-agent path first — then, when a single context genuinely can't hold the job, split it. The handoff patterns across LangGraph, OpenAI, and ADK are where to start when you do.

The through-line#

The viral video's real gift isn't the hour of footage — it's the ordering. Loop, then memory, then the three decisions you make when the loop or the memory hits a wall. Founders who ship durable agents don't skip to layer five because it's the exciting one. They build the loop, get memory right, and add each higher layer only when the one below it stops scaling. That's not the ten-paid-courses-killed version. It's the version that survives contact with production.