Agents didn't appear in 2024. They're the sixth wave in a long arc of AI evolution, each era adding a new capability without erasing what came before. Understanding this arc explains why agents are uniquely powerful now - and which pieces of the stack you already know.

Each era solved a limitation of the one before it. Rule-based systems were brittle. ML models generalized but couldn't reason. LLMs could reason but were passive. Agents are LLMs that can act - and loop until the task is done.

Concept 1 of 10

Analogy

The Six Waves

Everyday Analogy

Before: think of transportation technology. Before cars existed, horses were the only option. Then steam engines. Then internal combustion. Each replaced the previous - but also required the previous era's infrastructure (roads, fuel networks).

The pain: every wave initially looked like a replacement, but was actually an expansion. Developers who only knew SQL were confused by NoSQL - not because SQL was wrong, but because the new capability required a different mental model.

The mapping: AI waves work the same way. Rule-based systems gave us precision. ML gave us pattern recognition. LLMs gave us language. Agents give us autonomy. Each layer uses the previous - agents run on LLMs which use ML which uses statistics. You don't abandon the foundation; you add a new capability on top.

Concept 1 of 10

How It Works

Six Waves of AI

Rule-based (1950s-80s): If-then logic. Precise but brittle - breaks on anything not anticipated by the programmer.
Machine learning (1990s-2000s): Models learn patterns from data. Generalizes, but limited to predictions - can't explain reasoning.
Deep learning (2010s): Multi-layer neural networks. Image recognition, voice, translation. Superhuman at narrow tasks.
Foundation models (2020-2022): Large pre-trained models. One model works across many tasks. Reasoning emerges at scale.
Instruction-following LLMs (2022-2023): Models that follow instructions in natural language. The chatbot era.
Agentic AI (2024+): LLMs with tools, memory, and loops. Not just responding - acting, observing, and completing goals autonomously.

Concept 1 of 10

Decision Framework

Which Era Solves Which Problem?

-- Match the tool to the task -- IF task has fixed rules and no exceptions: Rule-based system -- fast, precise, fragile IF task needs to learn from data patterns: Machine learning model -- generalizes, predicts IF task needs image/audio/text understanding: Deep learning -- perception tasks IF task needs reasoning across open-ended text: Foundation model / LLM -- language tasks IF task needs to take actions, use tools, loop, and complete a multi-step goal: Agent -- autonomous completion -- Agents don't replace ML models. -- They ADD autonomy on top of LLMs.

Concept 1 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Agents replaced machine learning - ML is outdated

Agents build on top of every previous wave. The ML model that predicts churn still runs in production. Agents often call those models as tools. "Newer" doesn't mean "replaces."

Agentic AI is a fundamentally new technology requiring all-new skills

Agents use standard APIs, HTTP, JSON, Python, and databases. If you can build a web service, you can build an agent. The new part is the loop and the tool-calling pattern - not the underlying stack.

The six waves each added one capability. Agents add autonomy: the ability to loop, use tools, and complete a goal without step-by-step human instruction. Every previous capability still applies.

Concept 2 of 10

Big Idea

Prelude: From ML Model to AI Agent

If you've built ML models or prediction APIs, an agent adds one critical capability: reasoning about context before acting. The same business problem can be solved with a hardcoded script, an ML prediction API, or an agent - and the difference is who decides what happens next.

Consider a UCC delinquency prediction task. A script follows fixed rules. An ML model predicts a probability. An agent reasons: "the ML score is borderline - let me look up the full filing history before recommending." The data is the same; the intelligence in the loop is different.

Concept 2 of 10

Analogy

The Calculator vs. the Analyst

Everyday Analogy

Before: a financial calculator gives you a number when you punch in inputs. A financial analyst uses calculators as tools - but also reads context, asks follow-up questions, and recommends a course of action.

The pain: the calculator is always faster and more accurate for arithmetic. But the analyst can handle the ambiguous case: "This company's debt-to-equity looks fine, but I noticed their largest customer just filed for bankruptcy - that changes the recommendation."

The mapping: ML models are calculators - fast, accurate, and limited to their training distribution. Agents are analysts - they use models as tools but also reason about context, gather missing information, and produce recommendations that account for the unexpected. You don't replace the calculator; you give it a brain.

Concept 2 of 10

How It Works

Three Approaches to the Same Problem

Approach	Decides	Handles exceptions?
Script	Programmer (at write time)	Only if programmer anticipated them
ML API	Model (at train time)	Only within training distribution
Agent	Claude (at run time)	Yes - reasons about unexpected cases

The script is fastest and cheapest - use it for well-defined, stable tasks
The ML model is better for pattern recognition at scale
The agent adds value only when context changes what the right action is - when "it depends" is the honest answer

Concept 2 of 10

Decision Framework

When to Use Each Approach

-- Script vs. ML vs. Agent -- IF task is deterministic (same input = same action): USE script -- fastest, cheapest IF task needs to learn from examples and input is structured/predictable: USE ML model -- pattern recognition IF task requires: - understanding natural language context - making decisions that depend on edge cases - gathering additional info before deciding - explaining reasoning to the user THEN: USE agent -- contextual reasoning -- Most production systems use all three: -- script for ETL, ML for scoring, -- agent for exception handling.

Concept 2 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Agents should replace all ML models in production

ML models run faster, cheaper, and more predictably than agents. Agents should handle the cases where context changes the right answer - not replace models that do batch prediction at scale.

Adding an agent makes any pipeline "AI-powered" and therefore better

An agent adds value only when reasoning about context actually changes the outcome. If every input leads to the same action, a script is better. More AI is not always more correct.

Agents add contextual reasoning to existing pipelines. They're not replacements for scripts or ML - they're the exception-handling layer that activates when context matters and "it depends" is the honest answer.

Concept 3 of 10

Big Idea

Why Agents: The Business Case

The business case for agents rests on three properties no previous technology combined: they work with unstructured inputs (natural language, documents), they adapt their process to context (unlike fixed pipelines), and they can call external tools and APIs to gather information they weren't given upfront.

The seven canonical agent use cases are: document extraction and classification, research synthesis, code generation and review, customer support automation, data pipeline orchestration, multi-step form completion, and compliance monitoring. What unites them: all require reading context and deciding what action to take next.

Concept 3 of 10

Analogy

The Contractor vs. The Vending Machine

Everyday Analogy

Before: software historically worked like a vending machine. Put in a specific coin, get a specific item. Predictable, fast, and brittle. If you put in the wrong coin, nothing comes out.

The pain: real business tasks don't come with uniform coins. A customer might describe their problem in 10 different ways. An exception might require checking three different systems. A vending machine can't handle that.

The mapping: agents work like skilled contractors. You describe what you want in plain language. The contractor asks clarifying questions if needed, uses the right tools for each part of the job, handles surprises on the fly, and delivers the finished product. You don't need to specify every step - you describe the outcome.

Concept 3 of 10

How It Works

Seven Agent Use Cases

Document extraction: read PDFs, emails, contracts and pull structured data - even when format varies
Research synthesis: search multiple sources, reconcile conflicting information, produce a report
Code generation and review: write, test, and fix code in response to requirements
Customer support: understand the issue, look up account data, apply business rules, resolve or escalate
Data pipeline orchestration: decide what to transform, run queries, handle errors, notify on completion
Compliance monitoring: check filings, compare against rules, flag violations with explanation
Multi-step form completion: gather requirements, fill complex forms, validate output

Concept 3 of 10

Decision Framework

Is This Task Agent-Worthy?

-- Should you build an agent for this? -- SCORE = 0 IF input is natural language or unstructured: SCORE += 2 IF the right action varies by context: SCORE += 2 IF task requires calling external APIs or DBs: SCORE += 2 IF task takes multiple steps to complete: SCORE += 1 IF exceptions need explanation, not just flags: SCORE += 1 IF SCORE >= 5: BUILD an agent IF SCORE 3-4: Consider hybrid (script + agent) IF SCORE < 3: Stick with script or ML model -- Low scores mean agents add cost without value

Concept 3 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Any task that involves AI should be built as an agent

Agents cost more per task (multiple LLM calls) and are harder to test. Build an agent when contextual reasoning changes the outcome. If the same inputs always produce the same action, a script is better.

Agents eliminate the need for human oversight

Production agents in regulated domains (healthcare, finance, legal) always require human review checkpoints for high-stakes decisions. Agents accelerate the work; humans remain accountable for the outcomes.

The business case for agents: they handle tasks where the right action depends on context, the input is unstructured, and multiple information sources must be consulted. When those conditions hold, agents dramatically reduce human labor.

Concept 4 of 10

Big Idea

What Is an AI Agent? — The Three Levels

There are three distinct levels of LLM-powered programs. Only the third is an agent. The boundary between them comes down to one question: who decides what happens next - your code, or Claude?

Level 1 (LLM Call): your code decides everything; Claude just generates text. Level 2 (Chatbot): Claude responds to one message at a time; your code handles the turn-taking. Level 3 (Agent): Claude uses tools, decides what actions to take, and loops until the goal is achieved. The key capability that separates Level 3 is autonomous decision-making about what to do next.

Concept 4 of 10

Analogy

The Autocomplete Spectrum

Everyday Analogy

Before: phone autocomplete suggests the next word but doesn't write your message. Google Search finds pages but doesn't read them for you. A research assistant finds, reads, summarizes, and emails you a briefing - acting on your behalf across multiple steps.

The pain: every tool that falls short of your goal requires you to do the remaining steps manually. Autocomplete saves one word. Search saves one lookup. But you still have to synthesize, decide, and act.

The mapping: Level 1 (LLM call) is autocomplete - it completes text. Level 2 (chatbot) is a knowledgeable colleague you can converse with. Level 3 (agent) is that colleague who also has access to your systems, can run code, look things up, and come back with a finished deliverable rather than just an answer.

Concept 4 of 10

How It Works

The Three Levels

Level	Who decides?	Can use tools?	Loops?
1 - LLM Call	Your code	No	No
2 - Chatbot	Your code (turn by turn)	No (or limited)	No
3 - Agent	Claude (autonomously)	Yes	Yes

A text summarizer that calls Claude once is Level 1. Claude generates text; your code does everything else.
A support chatbot that responds to each message is Level 2. One turn per call, no tool use, your code orchestrates.
A research agent that searches, reads, cross-checks, and writes a report is Level 3. Claude decides what to search next.

Concept 4 of 10

Decision Framework

Which Level Are You Building?

-- Identify what you're building -- IF your code decides every step and Claude just generates text: Level 1 - LLM Call IF Claude responds to user messages but your code controls the turn-taking and Claude uses no tools: Level 2 - Chatbot IF Claude can: - call tools (search, database, API) - decide which tool to call next - loop until the task is complete - stop when it determines it's done: Level 3 - Agent -- The question: who decides what happens next? -- Your code = Level 1 or 2 -- Claude = Level 3 (agent)

Concept 4 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Any code that calls Claude is an "agent"

Most code that calls Claude is Level 1 (LLM call) or Level 2 (chatbot). A true agent requires Claude to have tools AND to autonomously decide which tools to use to complete a goal. The loop and the decision-making are what make it an agent.

Agents run completely independently without any code wrapper

Agents still run inside your code. Your code starts the loop, provides tools, executes tool calls, and stops the loop. Claude decides WHAT to do next; your code makes it actually happen.

An agent = LLM + Tools + Loop. Claude decides what tool to call next. Your code executes the call and passes the result back. The loop continues until Claude says it's done (stop_reason = "end_turn").

Concept 5 of 10

Big Idea

See an Agent in Action

Abstract definitions only go so far. Let's trace a real agent interaction from start to finish. The example: a bank analyst asks "What's the total lien exposure for Acme Corporation across all states?" The agent doesn't know the answer - it has to go find it.

This 9-step walkthrough shows every phase: the question arrives, the agent reasons about what it needs, calls tools to gather data, observes results, reasons again, calls more tools, and finally synthesizes a complete answer. Each step maps to a concept you'll build in the course.

Concept 5 of 10

Analogy

The Research Librarian

Everyday Analogy

Before: you ask a library search engine for "lien exposure Acme Corporation." It returns a list of documents. You have to open each one, read it, cross-reference with other documents, and do the math yourself.

The pain: five states, forty filings, three different filing systems, each with different formats. The tool found the data; you're still doing 90% of the actual work.

The mapping: an agent is the librarian who doesn't just return results - they read every filing, calculate the totals by state, cross-check for amendments, and hand you a finished analysis. The same data sources. The same complexity. Zero work on your end once the question is asked.

Concept 5 of 10

How It Works

The 9 Steps

Receive: user question arrives ("lien exposure for Acme Corp across all states")
Reason: Claude writes "Thought: I need to search UCC filings by debtor name across states"
Act: Claude calls search_filings(debtor="Acme Corporation", state="all")
Execute: your code runs the search, returns 47 matching filings
Observe: Claude reads results - sees filings in 5 states, 3 with large collateral values
Reason again: Claude writes "Thought: I need amendment status to avoid double-counting"
Act again: calls check_amendments(filing_ids=[...])
Synthesize: Claude calculates totals by state after removing superseded filings
Return: delivers a formatted report with totals, breakdown by state, and risk flag

Concept 5 of 10

Pseudocode

The 9-Step Flow

-- What happens behind the scenes -- USER asks: "Lien exposure for Acme Corp?" Claude THINKS: "I need to search UCC filings" Claude CALLS: search_filings("Acme Corporation") → Your code runs DB query, returns 47 rows Claude THINKS: "Need amendment status to avoid double-counting original + amendments" Claude CALLS: check_amendments(filing_ids) → Your code checks filing chain, flags 8 amended Claude THINKS: "Now I can calculate net exposure" Claude CALCULATES: sum(collateral) per state excluding superseded filings Claude RETURNS: Total exposure: $42.3M By state: NY $18.1M, CA $11.2M, TX $13M Risk: HIGH (3 filings near maturity) [stop_reason = "end_turn"]

Concept 5 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Agents know the answers - they're just reciting training data

Agents don't know your database, your filings, or your real-time data. They know how to reason about information. The actual data comes from tool calls that execute against your systems. The intelligence is the reasoning; the data is external.

Agents are slow because they make many API calls

Modern agents typically complete in 5-30 seconds for moderate tasks. Well-designed agents use parallel tool calls (M06), prompt caching (M22), and model routing to minimize latency. The trade-off is richness of answer vs. speed - usually worth it for complex tasks.

An agent walkthrough shows that intelligence = reasoning + external data. The LLM provides reasoning; your tools provide data. Together they produce an answer no one had to write code to calculate.

Concept 6 of 10

Big Idea

The Agent Architecture — 7 Building Blocks

Every production agent, no matter how simple or complex, is made of the same 7 components. You don't need all 7 to get started - a minimal agent needs only the first two. The others are added as the agent takes on harder tasks.

These 7 components map directly to the 9 course tracks. When you finish this course, you'll have built each component and understand how they connect. M00 shows you the map; the rest of the course builds the territory.

Concept 6 of 10

Analogy

The Human Body Analogy

Everyday Analogy

Before: a human body has specialized organs. The brain processes information. The hands take action. The eyes observe the environment. Memory stores what happened before. The immune system protects against threats.

The pain: you can't have a functional human body without all the organs working together. A brain with no hands can't act. Hands with no brain can't decide. Each part is useless without the others.

The mapping: an agent has the same structure. The Brain (LLM) reasons. Tools (hands) take action. Memory stores context. Planning (cerebral cortex) decomposes complex goals. Guardrails (immune system) protect against harm. Observability (nervous system) provides feedback. Deployment (skeleton) provides the structure to stand upright in production.

Concept 6 of 10

How It Works

The 7 Components

Brain (LLM): Claude. Reasons, plans, decides what tool to call next. Covered in M01-M04.
Tools: functions the agent can call - search, database, code execution, APIs. Covered in M05-M07.
Memory: conversation history, vector databases, episodic memory. Covered in M08-M11.
Planning: task decomposition, DAG execution, multi-agent coordination. Covered in M12-M15.
Guardrails: input/output validation, safety checks, human-in-the-loop. Covered in M16-M18.
Observability: traces, logs, dashboards for monitoring agent behavior. Covered in M19-M20.
Deployment: APIs, containers, cloud hosting, cost management. Covered in M21-M22.

Concept 6 of 10

Decision Framework

Which Components Do You Need?

-- Start minimal, add components as needed -- ALWAYS needed: Brain (LLM) + Tools -- minimum viable agent ADD Memory if: agent needs to remember across sessions or handle long conversations ADD Planning if: task requires multiple sub-tasks or coordination across agents ADD Guardrails if: agent touches sensitive data or takes irreversible actions or operates in a regulated domain ADD Observability if: agent runs in production (always - you need to debug it) ADD Deployment if: other systems need to call your agent (always - otherwise it's just a script) -- Most production agents use all 7. -- Most learning projects use 2-3.

Concept 6 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

You need to implement all 7 components before your agent is useful

A working agent needs only Brain + Tools. Add Memory when sessions need persistence. Add Guardrails when stakes are high. Add Observability when it goes to production. Build incrementally.

The 7 components are specific to Claude - other AI platforms use different architectures

These 7 components appear in every production agent framework - LangChain, AutoGen, CrewAI, OpenAI Agents. The names vary but the roles are universal. Learning them with Claude means you understand any agent stack.

Every production agent has 7 components: Brain, Tools, Memory, Planning, Guardrails, Observability, Deployment. This course teaches each one. Start with Brain + Tools; add the rest as your agent grows.

Concept 7 of 10

Big Idea

The Agent Lifecycle — 5 Stages

Building a production agent is not just writing code and deploying it. Production agents go through 5 stages, each adding a layer of capability and reliability. Skipping stages leads to agents that work in demos but fail in production.

The 5 stages are: Design (define the problem and architecture), Build (implement tools and the agent loop), Protect (add guardrails and safety), Observe (add tracing and monitoring), and Deploy (containerize, host, and scale). The course tracks map to these stages.

Concept 7 of 10

Analogy

Building a House

Everyday Analogy

Before: imagine building a house by skipping the foundation and framing and going straight to interior design. The walls look beautiful. Then it rains.

The pain: projects that skip stages - foundation (design), framing (build), waterproofing (protect), electrical inspection (observe), building permit (deploy) - fail at the stage they skipped. The failure always looks like a surprise; it was actually a skipped step.

The mapping: agent development follows the same pattern. Design without building = great architecture, no agent. Build without protect = works until a malicious input. Protect without observe = no idea when it breaks in production. Observe without deploy = it only runs on your laptop. All 5 stages are load-bearing.

Concept 7 of 10

How It Works

The 5 Stages

Design (Tracks 1-2): define the problem, pick the right LLM, design tool schemas, write the system prompt. Bad design = an agent that solves the wrong problem elegantly.
Build (Tracks 2-4): implement tool functions, write the agent loop, add memory and planning. This is where most tutorials stop - it's not where production agents stop.
Protect (Track 5): add input validation, output guardrails, PII redaction, human review checkpoints. Agents without protection are liability generators.
Observe (Track 6): instrument with traces, set up dashboards, define alert thresholds. If you can't see what the agent is doing, you can't fix what breaks.
Deploy (Track 7): containerize, add API authentication, set up auto-scaling, implement cost controls. A demo running on localhost is not a product.

Concept 7 of 10

Decision Framework

Which Stage Are You In?

-- Lifecycle stage checklist -- DESIGN stage done when: - Problem is clearly defined - Tools are designed (not implemented) - System prompt v1 exists BUILD stage done when: - Agent loop runs end-to-end - All tools implemented and tested - Happy path works reliably PROTECT stage done when: - Input validation rejects bad inputs - Output guardrails catch hallucinations - Human review gates are in place OBSERVE stage done when: - Every agent run produces a trace - Dashboard shows key metrics - Alerts fire on anomalies DEPLOY stage done when: - Runs in a container (not localhost) - Has authentication + rate limiting - Cost controls prevent runaway spend

Concept 7 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Protect and Observe are optional polish - the core is Build

In production, an unprotected agent is a security risk and an unobserved agent is a maintenance nightmare. Protect and Observe are where 80% of real production problems originate. They're not polish - they're the difference between a demo and a product.

Agents are "done" after Build - deployment is just packaging

Deployment adds authentication, rate limiting, cost controls, and auto-scaling. Skipping these means the first real user either breaks the agent, runs up a $1000 API bill, or both.

The 5-stage lifecycle: Design → Build → Protect → Observe → Deploy. Tutorials cover stages 1-2. Production requires all 5. This course teaches all 5 - that's what distinguishes it from a "hello world" tutorial.

Concept 8 of 10

Big Idea

How Agents Actually Work — The API Reality

A common misconception: many people think an AI agent is a separate running process making decisions independently. The reality is simpler - and more empowering. An agent is your code calling Claude's API in a loop, with you always in control of what happens.

Claude has no persistent state between API calls. There's no background process, no autonomous "agent runtime" running somewhere. Between calls, Claude doesn't exist. Your code maintains all state, manages history, executes tools, and decides when the loop continues or stops.

Concept 8 of 10

Analogy

The Stateless Consultant

Everyday Analogy

Before: imagine a brilliant consultant who has total amnesia between meetings. Every meeting, they start fresh - brilliant intelligence, zero memory of last time.

The pain: the consultant gives extraordinary answers when given context. Without context, they give generic answers. The "intelligence" only activates when you bring the right information to each meeting.

The mapping: Claude is that consultant. Each API call starts fresh - no memory, no persistent state. Your code is the meeting facilitator: it brings the conversation history, the tool results, and the current question to every call. The "agent memory" is in your messages array, not in Claude. You are always in control of what Claude sees.

Concept 8 of 10

How It Works

The Technical Reality

API call: your code sends an HTTP POST to api.anthropic.com with the full conversation history, tool definitions, and the current user message
Processing: Claude processes the entire context - history + tools + question - and returns either a text response or tool call requests
Stateless: the server processes the request and returns the response - nothing persists between calls
Your code executes tools: Claude returned tool call requests - your code runs the actual functions against your databases, APIs, and systems
History management: your code appends each exchange to the messages array - this IS the agent's memory

Concept 8 of 10

Pseudocode

The Full API Flow

-- What your code actually sends -- POST api.anthropic.com/messages { model: "claude-opus-4-7", system: "You are a UCC research agent...", tools: [search_filings, check_amendments], messages: [ {role: "user", content: "Acme Corp exposure?"}, {role: "assistant", content: [ thought: "I need to search UCC filings", tool_use: search_filings("Acme Corp") ]}, {role: "user", content: [ tool_result: "47 filings found: ..." ]}, -- history continues... -- ] } -- Claude processes everything above and returns: -- either more tool_use requests (loop continues) -- or stop_reason = "end_turn" (loop stops)

Concept 8 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

Claude runs autonomously in the background once started

Between API calls, Claude doesn't exist. It processes a request and returns. Your code starts the next call. There's no background process - just HTTP requests your code makes in a loop.

Agents are hard to control because Claude makes independent decisions

You control what tools Claude can call (by what you put in the tools array), what context Claude sees (by what you put in messages), and when the loop stops (by checking stop_reason). You are always in full control of the agent's environment.

Agents are your code calling an API in a loop. You control the tools, the history, and the stop condition. Claude provides the intelligence; you provide the infrastructure. This is empowering - it means you can debug, audit, and modify every part of the system.

Concept 9 of 10

Big Idea

Three Agents You'll Build

Theory only goes so far. This course has 5 capstone projects across 3 industry domains. Here are three representative capstones showing the progression from simple to production-grade, so you know what you're working toward from day one.

The three domains are Healthcare Pre-Authorization, B2B Ecommerce Order Tracking, and Public Records / UCC Data Engineering. Every domain appears in multiple capstones at increasing complexity - the same real-world problem solved with progressively more powerful tools.

Concept 9 of 10

Analogy

The Difficulty Progression

Everyday Analogy

Before: learning to drive by starting with Formula 1. You have the theory - throttle, steering, braking - but the stakes and complexity overwhelm the skill.

The pain: most tutorials jump straight to the complex case. "Here's a production-grade multi-agent system with RAG, guardrails, and observability." Helpful reference; terrible learning path.

The mapping: this course sequences capstones like a driving curriculum. Capstone 1 is an empty parking lot: one tool, one loop, immediate success. Capstone 3 adds a multi-agent team. Capstone 5 is the full production system. Each adds exactly one new concept to the working base you've already built.

Concept 9 of 10

How It Works

The Three Capstone Levels

Capstone 1 - Filing Lookup Agent: one tool, one loop, answers questions about UCC filings. Difficulty: 1 star. You'll build this after M05-M06. Time: 2-3 hours.
Capstone 3 - Research Synthesis Agent: multi-tool, multi-source research with RAG memory and citations. Difficulty: 3 stars. Built after M09-M13. Time: 4-6 hours.
Capstone 5 - Production Pre-Auth System: multi-agent team with guardrails, human review, tracing, and deployment. Difficulty: 5 stars. Built after M22. Time: 8-12 hours.

Three domains: Healthcare Pre-Auth (CPT/ICD codes, payer rules) · B2B Ecommerce (PO lifecycle, carrier APIs) · UCC Data Engineering (lien risk, entity resolution)

Concept 9 of 10

Decision Framework

Pick Your Domain

-- All three domains teach the same skills -- -- Pick based on your background -- IF you work in healthcare or insurtech: Domain A - Healthcare Pre-Authorization (CPT codes, ICD-10, HIPAA, payer criteria) IF you work in ecommerce or logistics: Domain B - B2B Ecommerce Order Tracking (PO lifecycle, carrier APIs, SLA management) IF you work in fintech, legal, or data: Domain C - UCC Data Engineering (lien risk, entity resolution, Medallion arch) -- Each domain appears in 5 capstones -- -- You can complete all 5 in one domain -- -- or mix domains across capstones --

Concept 9 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

I need to finish all 30 modules before attempting a capstone

Each capstone has a prerequisite module listed. Capstone 1 only needs M05-M06. You can start building real agents after about 6 hours of learning. The course is designed for incremental delivery, not linear completion.

The three domains are teaching examples - the skills don't transfer to my real work

The skills are domain-agnostic. Document extraction in healthcare uses the same RAG and tool patterns as in legal or finance. The domains provide realistic complexity; the patterns apply to any vertical.

Five capstones. Three domains. Progressive difficulty from 1-tool to full production. You pick the domain closest to your work. The skills transfer to any industry - the domain is just the concrete context that makes the learning stick.

Concept 10 of 10

Big Idea

Course Roadmap — 9 Tracks, 30 Modules

The course is organized into 9 tracks, each building on the previous. Tracks 1-2 give you the foundation. Tracks 3-4 add memory and agent architectures. Tracks 5-7 make agents production-ready. Track 8 applies everything to real projects. Track 9 prepares you for certification.

The progression is deliberate: you can't secure something you haven't built, can't observe something you haven't deployed, and can't certify knowledge you haven't applied. Each track's position in the sequence is load-bearing.

Concept 10 of 10

Analogy

The Building Construction Sequence

Everyday Analogy

Before: construction has a strict sequence: foundation before walls, walls before roof, roof before plumbing, plumbing before drywall. Deviating from the sequence creates structural problems downstream.

The pain: developers who jump to Track 4 (agent architectures) without Track 1 (LLM mental model) write agents that work by accident. They can't debug them because they don't understand the underlying token-by-token inference model.

The mapping: the course tracks follow construction logic. Foundation (Tracks 1-2) supports the walls (Tracks 3-4). Walls support the roof (Tracks 5-6). Roof enables habitation (Tracks 7-8). Inspection and certification (Track 9) confirms it's fit for purpose. Every track serves the ones above it.

Concept 10 of 10

How It Works

The 9 Tracks

Track 0 M00 — Course Overview (this module)
Track 1 M01-M04 — Foundations (LLM, Tokens, Prompts, Structured Output)
Track 2 M05-M07 — Tool Use (Function Calling, Orchestration, MCP)
Track 3 M08-M11 — Memory & Context (Conversation, RAG, Advanced RAG, Memory)
Track 4 M12-M15 — Agent Architectures (ReAct, Planning, Multi-Agent, Code)
Track 5 M16-M18 — Guardrails & Safety (Input, Output, Evaluation)
Track 6 M19-M20 — Observability (Tracing, Monitoring)
Track 7 M21-M22 — Production (API Design, Cost Optimization)
Track 8 M23-M24 — Capstones & What's Next
Track 9 M25-M27 — Cert Prep (Claude Code, Hooks/SDK, Exam)

Concept 10 of 10

Decision Framework

Where to Start?

-- Recommended paths based on experience -- IF new to AI / LLMs: Start at M01. Work sequentially. Don't skip Tracks 1-2. They're the foundation. IF experienced with LLMs but new to agents: Skim M01-M04. Start building at M05. Read M12 carefully (ReAct loop is the core). IF experienced developer wanting cert prep: Work through M12-M22 for the main patterns. Jump to M25-M27 for exam-specific content. IF domain expert wanting to apply AI: Pick your domain (A, B, or C). Read M00-M06, then jump to your Capstone 1. Return to fill gaps as needed. -- All paths eventually need all 9 tracks -- for production-grade agent work.

Concept 10 of 10

Misconceptions + Takeaway

Common Wrong Beliefs

I can skip to Track 4 because I already know how to call APIs

Track 4 (agent architectures) assumes you understand token limits (M02), prompt construction (M03), structured output (M04), and tool calling (M05-M06). Skipping those means debugging Track 4 failures with no vocabulary to understand what went wrong.

Track 9 (cert prep) is only useful if I'm taking the exam

Track 9 teaches Claude Code, hooks, the Agent SDK, and production anti-patterns. These are high-value production skills regardless of certification. The exam just provides a structured way to verify you learned them.

Nine tracks, thirty modules, five capstones. The sequence is deliberate: each track serves the ones above it. Start where your experience level dictates, but plan to cover all 9 tracks before claiming production-grade agent expertise.

Quick Quiz

Test Your Understanding

Tap each question to reveal the answer.

1. What is the single property that makes something a Level 3 agent rather than a chatbot?

Tap to reveal

Claude autonomously decides what tool to call next and loops until the task is complete. A chatbot responds to one message at a time; an agent decides the sequence of actions needed to reach a goal. The key: who decides what happens next - your code (chatbot) or Claude (agent).

2. You need to build an agent. Which two of the 7 building blocks do you need minimum?

Tap to reveal

Brain (LLM) + Tools. A minimal agent needs Claude to reason and at least one tool it can call. Everything else (Memory, Planning, Guardrails, Observability, Deployment) adds capability and reliability but isn't required to get a working first version.

3. Between API calls, where does Claude store the agent's memory?

Tap to reveal

Nowhere - Claude has no persistent state between calls. Your code maintains the messages array (conversation history). This array, passed with every API call, is what the agent uses as memory. Claude processes it fresh each time - you manage the state.

4. Name the 5 stages of the agent lifecycle in order.

Tap to reveal

Design - Build - Protect - Observe - Deploy. Tutorials typically cover only Design and Build. Production agents require all 5. Protect (guardrails) and Observe (tracing) are where most production failures originate when skipped.

5. What changed between each of the 6 AI waves?

Tap to reveal

Each wave added one new capability without replacing the previous: Rule-based added precision. ML added pattern learning. Deep learning added perception. Foundation models added general reasoning. Instruction-following added natural language control. Agents added autonomous action and looping. No wave was a replacement - each was an expansion.

What's Next

Ready to Build?

You've seen the complete picture - all 10 concepts, all 7 building blocks, all 5 lifecycle stages. The desktop module has the full live demo walkthrough, interactive animations, and reflection exercises.

Open the Full Module

Live agent demo - Interactive animations - Cert tips - Full knowledge check

Open M00 on Desktop

Start Building

M01: LLM Mental Model

How Claude actually generates responses

Back to Mobile Course Index